Pattern is a Subject matcher using NATS-style wildcards: - matches exactly one segment > matches one or more trailing segments (must be the last seg

Subject is a dot-delimited routing key, e.g.: graph.run.r1.start graph.run.r1.node.n1.complete kanban.board.b1.update Segments are separated by '

RetrieveMode is one source for MultiRetrieve / Retrieve. The string value of each mode MUST match the corresponding [retrieval.LaneKey] constant — th

RetrieveMode is one source for MultiRetrieve / Retrieve. The string value of each mode MUST match the corresponding [retrieval.LaneKey] constant — th

helper: deciderFunc adapts a closure into agent.Decider.

stubProvider is a tiny adapter used to inject canned responses into a Multi without writing a full type for each test.

Category classifies a long-term memory entry.

BoardSeederFunc is the function-typed adapter for BoardSeeder. Useful when the seed logic is a single closure over a transcript loader or retriever:

EventType is a publish Claw stream event discriminator.

LLM is the unified interface for language model interactions.

MetricsSinkFunc adapts a function to MetricsSink.

RevisionKind classifies how a write relates to prior facts. - RevisionSupersede: default merge_key conflict path (close prior). - RevisionFork: paral

State is the per-task mutable "world". Concretely it's a JSON-like nested map (orders, products, customers, …) that tools read from and mutate. We use

VideoID represents a YouTube video ID.

BackpressurePolicy controls what happens when a subscription's buffer is already full at Publish time.

CardStatus represents the lifecycle state of a Card on the kanban board.

CollapseStrategy names the chunks→docID aggregation function used by runLane. See Options.CollapseStrategy for the full rationale.

DropReason explains why an envelope was discarded for a particular subscription.

EngineBuilder is the resolved engine factory closure, already bound to its ref string + config map. The fleet calls it from inside its EngineFactory c

EngineFactory builds an [engine.Engine] for the given Agent entry, receiving the resolved dependencies the Captain has hydrated. The factory is called

ErrorKind enumerates the errdefs categories scripts may set on signal.error({ kind, message }). Only categories that can plausibly originate from scri

----------------------------------------------------------------------------- Public types -----------------------------------------------------------

MemoryFactKind is a public semantic memory fact kind accepted by AppendMemoryFact.

MergeStrategy defines how parallel branch results are merged.

ResolveOp is the action an [UpdateResolver] requests for one existing memory in response to a new fact.

Strategy enumerates the three loading modes the bench compares.

SubscriptionID identifies a subscription within a single Bus instance. It is opaque to consumers; bus implementations choose the format.

WriteMode controls SaveRequest semantics. Zero value = synchronous (preserves current behaviour). WriteModeAsyncSemantic stores raw episodes synchrono

AckSubscription is the optional capability a Subscription may expose when its parent Bus implements at-least-once delivery (typically cross-process bu

AcousticEchoCanceller optionally preprocesses microphone capture using a playback reference frame before speech detection. Production implementations

ActivatedLens is one row in PlanDetail.ActivatedLenses. Lives in shared.go (cross-detail vocabulary, per restructure §4).

ActorFn extracts an actor label from ctx (optional).

ActorFn extracts an actor label from ctx (optional).

AdditiveExtractor is the default single-pass extractor. When LLM is nil, Extract returns an empty slice; callers should treat Add as the only ingesti

Agent describes one agent inside a vessel. The Captain assembles the corresponding sdk/agent.Agent value at New time using these fields plus the depen

Agent is the wire form of a single vessel agent. Only the fields the daemon needs to differentiate at startup live here; rich engine config (system pr

Agent is the application-layer description of one logical agent. It is a plain data struct, NOT a "live object" that knows how to run itself: executio

AgentCapabilities declares which optional A2A features the agent supports. JSON keys exactly match the A2A spec — note the plural PushNotifications an

AgentCard mirrors the agent.AgentCard wire fields the resolver can populate. We do NOT reuse the SDK type directly so wire changes here are independen

AgentCard describes an agent's capabilities for discovery. Field names and JSON tags are a *proper subset* of the A2A AgentCard specification: every f

AgentConfig configures the single agent owned by a Claw.

AgentEngine is the engine ref + opaque config map. The factory registered under Ref decides what the Config keys mean. We use map[string]any rather th

AgentExecutor is the interface for executing tasks on target agents. WorkflowRunner implements this by creating/reusing AgentActors.

AgentSpec carries the per-agent configuration.

AgentValidator checks whether a target agent ID is valid before submission. Return nil if valid; return an error (ideally listing available IDs) if no

AliasResolver canonicalises a single surface mention within a scope. Implementations stay pure (no I/O); they are consulted once per mention per Inges

AnswerContext is an answer-ready prompt body produced by a backend from its native recall results. Backends with structured memory should prefer this

AnswerContextItem is one rendered memory item passed to an answer stage.

AnswerContextRecaller lets a backend keep its native recall result shape for answer rendering. The returned artifacts are for diagnostics and report d

AnswerContextStageAuditor combines structured answer rendering with recall stage diagnostics.

AnswerQuestion is the small part of a benchmark question a backend needs to render its own answer context. It deliberately avoids depending on the eva

AnswerReplayRecord is the diagnostic JSONL shape emitted by --dump-answer-replay. It captures the exact answer input and scored output so verifier/aud

Append writes the resolved facts to the canonical store. The compensator deletes whatever was appended on any downstream failure. When the downstream

AppendDetail —— write/append stage.

AppendEpisode writes the raw KindEpisode facts produced by build_episode to the canonical store. It is separate from Append so the runner / trace clea

AppendMemoryFactResult reports the canonical memory facts written by AppendMemoryFact.

Appender is an optional interface. If the underlying store supports native append (e.g. Alibaba OSS AppendObject), it should implement this. The works

ApplyFeedback is the single stage of the feedback pipeline. Run order: 1. Validate FactID + at least one positive delta. 2. store.UpdateFeedback app

ArchiveConfig controls message archiving behavior.

ArchiveConfig controls message archiving behavior.

ArchiveManifest tracks archived message segments.

ArchiveManifest tracks archived message segments.

ArchiveResult holds the result of an archive operation.

ArchiveResult holds the result of an archive operation.

ArchiveSegment describes a single archived file.

ArchiveSegment describes a single archived file.

Artifact is a named bundle of typed parts produced during a run (e.g. "summary", "tool_output_image"). Engines that write artifacts store them in a bo

Assembly is the resource graph produced by Build.

AsyncSemanticClaimOptions controls Claim batching and tenancy filters. Zero Max defaults to no jobs; callers should set Max explicitly. ProcessAsyncSe

AsyncSemanticFailure is the worker's failure report. ErrClass drives retry vs dead-letter routing in the queue backend.

AsyncSemanticJob is one durable semantic extraction work item.

AsyncSemanticProcessDetail —— async semantic worker completion. Emitted once per processed job so operators can join sync SaveTrace stages via AsyncRe

AsyncSemanticProcessOptions controls one ProcessAsyncSemantic batch.

AsyncSemanticProcessResult summarizes one drain pass.

AsyncSemanticProcessor is the caller-driven drain entry for queued semantic extraction. It is intentionally separate from Memory so the main facade do

AsyncSemanticQueue is a durable outbox for semantic extraction work items produced by Memory.Save(WriteModeAsyncSemantic). Implementations MUST: - Ma

AsyncSemanticQueueFactory returns a fresh, empty AsyncSemanticQueue for one subtest.

AsyncSemanticQueueHealth is the operator-facing queue snapshot used by health dashboards.

AsyncSemanticQueueObserver exposes queue health when Memory is wired with WithAsyncSemanticQueue and the backend implements Stats.

AsyncSemanticReceipt is the return value of Enqueue and the wire contract observable to Memory.Save callers via SaveResult.

AsyncSemanticReconcileOptions controls canonical async semantic recovery.