@keb-org/consol 0.1.1 → 0.3.0

package/dist/native.d.ts

@@ -0,0 +1,96 @@
+import { type CallOptions, type Context, type Transport } from "./transport";
+import type { Reply } from "./types";
+/** A contextualized-embeddings endpoint (`POST {url}/contextualizedembeddings`); without it recall stays lexical-only. */
+export interface EmbeddingOptions {
+    url: string;
+    /** Omit for endpoints that take no key. */
+    apiKey?: string;
+    model: string;
+    dims?: number;
+    timeoutMs?: number;
+}
+/** Jev advice (experimental). */
+export interface JevOptions {
+    url?: string;
+    apiKey?: string;
+    model?: string;
+    /** `false` turns automatic triage off. */
+    auto?: boolean;
+}
+/**
+ * What starts the in-process engine. Options become its settings (the CONSOL_* map); this process's
+ * own CONSOL_* variables are never read, except CONSOL_DB_URL as the default database.
+ */
+export interface EngineOptions {
+    /** Database URL: PostgreSQL with pgvector, or CockroachDB. Without it this process's `CONSOL_DB_URL` applies; the engine needs one. */
+    db?: string;
+    embedding?: EmbeddingOptions;
+    jev?: JevOptions;
+    /** Explicit `consol.node`; otherwise CONSOL_ADDON, then the platform package. */
+    addonPath?: string;
+    /** Any other engine setting (a CONSOL_* name), applied last. */
+    env?: Record<string, string>;
+    /** Default per-call deadline in ms (300000); 0 disables it. */
+    timeoutMs?: number;
+    /** Receives each engine log line. One sink is shared by every engine in the process. */
+    onLog?: (line: string) => void;
+    /** Which engine lines reach `onLog`: an EnvFilter directive such as `info` or `consol_engine=debug` (default `warn`). Process-wide like the sink: the latest one set wins. */
+    logLevel?: string;
+}
+export declare function engineSettings(o: EngineOptions): Record<string, string>;
+/** One opened engine of `consol.node`. A frame is the JSON of `{op, ...}`; the answer is the Reply JSON. */
+export interface NativeEngine {
+    request(frame: string): Promise<string>;
+    close(): Promise<void>;
+}
+/** What the SDK uses of `consol.node`. Failures reject with an Error whose message is JSON `{code, message, field?}`. */
+export interface Addon {
+    version(): string;
+    /** `location` is the JSON `{"vaultRoot"}` or `{"vault"}`. */
+    openEngine(location: string, settings: Record<string, string>): Promise<NativeEngine>;
+    setLogSink(sink: ((line: string) => void) | null, level?: string): void;
+    /** JSON `{instructions, tools: [{name, description, inputSchema}]}` of the MCP server. Needs no engine. */
+    mcpSurface(): string;
+    /** The MCP `CallToolResult` (JSON) of a wire reply (JSON) of `tool`. Needs no engine. */
+    mcpResult(tool: string, reply: string): string;
+}
+/**
+ * Explicit path authoritative (a missing file fails here), then CONSOL_ADDON authoritative, then the
+ * platform package resolved relative to this SDK file. CONSOL_ADDON is read only here. Loaded on
+ * first use, so importing the SDK never fails.
+ */
+export declare function loadAddon(explicit?: string): Addon;
+export interface NativeOptions extends EngineOptions {
+    location: {
+        vaultRoot: string;
+    } | {
+        vault: string;
+    };
+    /** After opening the engine: create or open this vault. */
+    boot?: {
+        vault: string;
+        create: boolean;
+    };
+    /** The SDK version the addon's major.minor must match. */
+    sdkVersion: string;
+}
+/** The engine of `consol.node` in this process: one frame per call, answered by a Reply JSON, in any order. */
+export declare class NativeTransport implements Transport {
+    private readonly engine;
+    readonly version: string;
+    private readonly timeoutMs;
+    private readonly unsubscribe;
+    private readonly closed;
+    private closing;
+    private constructor();
+    /** Loads the addon, checks its version, opens the engine and runs the boot step; a failure leaves nothing open. */
+    static start(opts: NativeOptions): Promise<NativeTransport>;
+    /** Final and idempotent: in-flight and later calls fail with `closed`. Every close() returns the same promise. */
+    close(): Promise<void>;
+    private shutdown;
+    private send;
+    /** Runs one envelope under `ctx`. The reply is returned untouched, tool errors included. */
+    handle(body: unknown, ctx: Context, options?: CallOptions): Promise<Reply>;
+    /** Create or open a vault by name; a refusal arrives as the reply's `vault_exists` / `vault_not_found`. */
+    vaultOp(op: "create_vault" | "open_vault", vault: string, options?: CallOptions): Promise<Reply>;
+}

package/dist/transport.d.ts

@@ -12,9 +12,9 @@ export interface Context {
     /** Pins the agent; the request cannot name another one. */
     agent?: string | null;
 }
-/** One way to move an envelope: a stdio child or HTTP. Internal: only Vault and Consol are public. */
+/** One way to move an envelope: the in-process engine or HTTP. Internal: only Vault and Consol are public. */
 export interface Transport {
-    /** Server version of the last reply; null before the first. */
+    /** Engine version (known at start) or, over HTTP, that of the last reply; null before the first. */
     readonly version: string | null;
     handle(body: unknown, ctx: Context, options?: CallOptions): Promise<Reply>;
     /** Final and idempotent. */
@@ -24,6 +24,7 @@ export interface Transport {
 export declare function deadline(ms: number | undefined, fallback: number): number;
 /** Server major.minor must equal the SDK's; returns the server version. */
 export declare function checkVersion(got: unknown, sdk: string): string;
+export declare const anySignal: (signals: AbortSignal[]) => AbortSignal;
 /** POSTs the envelope to `url`; the caller's headers are the backend's auth. Stateless. */
 export declare class HttpTransport implements Transport {
     private readonly url;

package/dist/types.d.ts

@@ -3,7 +3,7 @@ import type { ConsolErrorCode } from "./errors";
 type Open<T extends string> = T | (string & {});
 /**
  * The wire reply, the same on every transport. `text` is rendered for an LLM, `result` is the
- * contract payload (receipt fields next to `error` for a failed reflection-bound write). Tool
+ * contract payload (receipt fields next to `error` for a failed token-bound write). Tool
  * errors are replies with `error`, never exceptions.
  */
 export interface Reply {
@@ -19,7 +19,7 @@ export interface ToolError {
     code: ConsolErrorCode;
     retryable: boolean;
     message: string;
-    /** Input at fault as a path, e.g. `decisions[2].temporal.evidence[0]`; only when one input is to blame. */
+    /** Input at fault as a path, e.g. `decisions[2].refs[0]`; only when one input is to blame. */
     field?: string;
 }
 /** Part of a successful call that could not be done; an empty list means nothing was degraded. */
@@ -106,11 +106,11 @@ export interface RecallCard {
 }
 /** Every `jev`, `jev_triage` and `jev_advisory` field is experimental: present only with Jev configured. */
 export type Experimental = Record<string, unknown>;
-/** `recall` payload: at most `limit` cards, linked companions included. */
+/** `recall` payload: at most 30 cards (100 for a `*` query), linked companions included. */
 export interface RecallResult {
     /**
      * The progressive disclosure as a model reads it: full cards with excerpts, lead and id cards,
-     * the question's intent block and the hints. `candidates` are the same cards as data.
+     * the blocks its query symbols ask for and the hints. `candidates` are the same cards as data.
      */
     text: string;
     candidates: RecallCard[];
@@ -131,7 +131,7 @@ export interface EntityAffectedGroup {
     entity: string;
     docs: AffectedDoc[];
 }
-/** `remember` receipt; a reflection-bound write adds `reflection_write` to this same shape. */
+/** `remember` receipt; a token-bound write adds `reflection_write` to this same shape. */
 export interface RememberResult {
     changed: boolean;
     indexed: boolean;
@@ -145,8 +145,10 @@ export interface RememberResult {
     affected: AffectedDoc[];
     entity_affected: EntityAffectedGroup[];
     unavailable: Unavailable[];
-    /** Outcome of a reflection-bound write (and of the resume form). */
+    /** Outcome of a token-bound write (and of the write-token resume form). */
     reflection_write?: WriteOutcome;
+    /** `meta.<key>` for each `meta` key the server does not know; absent when there are none. */
+    ignored?: string[];
     jev?: Experimental;
 }
 /** `remove` receipt: the note is archived, its body stays readable and editable. */
@@ -163,7 +165,7 @@ export interface RemoveResult {
     reflection_write?: WriteOutcome;
     jev?: Experimental;
 }
-/** Durable state of a reflection-bound write (open); only `succeeded` published bytes. */
+/** Durable state of a token-bound write (open); only `succeeded` published bytes. */
 export type WriteState = Open<"pending" | "succeeded" | "conflicted" | "abandoned">;
 /** Why a reflection write has not succeeded yet (open); resume or abandon it explicitly. */
 export type WriteFailureCode = Open<"source_conflict" | "basis_changed" | "index_pending" | "publication_pending" | "receipt_pending">;
@@ -180,10 +182,13 @@ export interface WriteResolution {
     inspected: SourceRef | null;
     reason: string;
 }
-/** Outcome of one reflection-bound write; a write never completes the work by itself. */
+/** Outcome of one token-bound write; a write never completes the work by itself. */
 export interface WriteOutcome {
-    work_id: string;
-    action_key: string;
+    /** Write token: resume the write with it through `tool`, or abandon it through `reflect`. */
+    token: string;
+    tool: "remember" | "remove";
+    /** The note the write targets. */
+    id: string;
     state: WriteState;
     /** True for a replayed terminal outcome: it describes history, not the current source. */
     historical: boolean;
@@ -193,8 +198,16 @@ export interface WriteOutcome {
     resolution: WriteResolution | null;
     failure_code: WriteFailureCode | null;
 }
-/** Queue state of a work item; only an accepted decision completes it. */
-export type WorkStatus = "pending" | "completed" | "blocked" | "retryable" | "stale";
+/** An unresolved (pending or conflicted) write, as `reflect` lists every one of them on every call. */
+export interface UnresolvedWrite {
+    token: string;
+    tool: "remember" | "remove";
+    id: string;
+    state: WriteState;
+    failure_code: WriteFailureCode | null;
+}
+/** Queue state of a work item that is not open for a decision; only an accepted decision completes work. */
+export type ItemStatus = Open<"completed" | "stale">;
 /** Pair found through a link authored in `owner`. */
 export interface AuthoredLead {
     route: "authored";
@@ -208,11 +221,6 @@ export interface SharedFacetLead {
     route: "shared_facet";
     value: string;
 }
-/** Pair found through a shared numeric value. */
-export interface SharedNumericLead {
-    route: "shared_numeric";
-    value: string;
-}
 /** Pair found through embedding similarity (embeddings on only). */
 export interface SemanticLead {
     route: "semantic";
@@ -224,7 +232,7 @@ export interface SemanticLead {
     score: number;
 }
 /** Discovery witness of a pair; one witness, not an exhaustive list or a truth judgment. */
-export type PairLead = AuthoredLead | SharedFacetLead | SharedNumericLead | SemanticLead;
+export type PairLead = AuthoredLead | SharedFacetLead | SemanticLead;
 /** Hub witness; `target` is null when a new hub would be formed. Unstable: checked against Rust source only. */
 export interface HubLead {
     route: "hub";
@@ -241,43 +249,6 @@ export interface PromotionLead {
     scope: "skills" | "core";
     existing: string[];
 }
-/** Sources a work item was judged on; the basis hash binds decisions to exactly these versions. */
-export interface WorkBasis<L> {
-    subjects: SourceRef[];
-    sources: SourceRef[];
-    lead: L;
-}
-/** Shared by every work kind, so they stay readable before narrowing on `kind`. */
-export interface WorkBase {
-    work_id: string;
-    basis_hash: string;
-    status: WorkStatus;
-}
-/** Review one note; source work carries no lead. */
-export interface SourceWork extends WorkBase {
-    kind: "source";
-    basis: {
-        subjects: SourceRef[];
-        sources: SourceRef[];
-    };
-}
-/** Compare two notes. */
-export interface PairWork extends WorkBase {
-    kind: "pair";
-    basis: WorkBasis<PairLead>;
-}
-/** Form, attach to or bridge a hub. Unstable: checked against Rust source only. */
-export interface HubWork extends WorkBase {
-    kind: "hub_attachment" | "hub_formation" | "hub_bridge";
-    basis: WorkBasis<HubLead>;
-}
-/** Promote recurring knowledge to skills/core. Unstable: checked against Rust source only. */
-export interface PromotionWork extends WorkBase {
-    kind: "promotion";
-    basis: WorkBasis<PromotionLead>;
-}
-/** A delivered work item, discriminated on `kind`. */
-export type ReflectionWork = SourceWork | PairWork | HubWork | PromotionWork;
 /** Markdown block of a delivered source, as a suggested excerpt boundary. */
 export interface CandidateBlock {
     byte_range: ByteRange;
@@ -292,50 +263,62 @@ export interface DeliveredSource {
     /** Suggested body spans, not a replacement for inspection. */
     candidate_blocks: CandidateBlock[];
 }
-/** Work delivered with every source body; deliver, write and decide are separate steps. */
-export interface CompleteDelivery {
-    work: ReflectionWork;
+/** Shared by every work kind, so they stay readable before narrowing on `kind`. */
+export interface ItemBase {
+    /** Work token: pass it to `remember` / `remove` to bind a write, and in a decision. Opaque. */
+    token: string;
+    /** What the server offers for this item (open: it grows without a schema change); empty when `status` is set. */
+    verdicts: string[];
+    /** The evidence each verdict requires. */
+    needs: string[];
+    subjects: SourceRef[];
+    /** The complete Markdown of every source the item was judged on. */
     sources: DeliveredSource[];
-    complete: true;
+    /** Present only when the work is not open for a decision (`verdicts` is then empty). */
+    status?: ItemStatus;
     jev_advisory?: Experimental;
 }
-/** Work or a requested source that could not be delivered this call; the call itself succeeded. */
-export interface FailedDelivery {
-    /** Present when the work is known. */
-    work_id?: string;
-    /** Present for a requested source (`ids` mode). */
-    requested_id?: string;
-    complete: false;
-    error: ToolError;
+/** Review one note; source work carries no lead. */
+export interface SourceItem extends ItemBase {
+    kind: "source";
 }
-/** One entry of `reflect().deliveries`; narrow on `complete`. */
-export type ReflectDelivery = CompleteDelivery | FailedDelivery;
-/** Allowed `disposition` values of a source decision. */
-export type SourceDisposition = "synthesize" | "connect" | "archive" | "retained_raw" | "blocked" | "retryable_error" | "stale";
-/** Allowed `disposition` values of a pair decision. */
-export type PairDisposition = "linked" | "no_relation" | "unresolved" | "blocked" | "retryable_error" | "stale";
-/** Allowed `disposition` values of a hub or promotion decision. */
-export type ConsolidationDisposition = "applied" | "reused" | "rejected" | "retained_raw" | "blocked" | "retryable_error" | "stale";
-/** Accepted source/pair/hub/promotion decision; `status` echoes the disposition. */
-export interface AcceptedDecision {
-    work_id: string;
-    accepted: true;
-    status: SourceDisposition | PairDisposition | ConsolidationDisposition;
+/** Compare two notes. `validity` is computed from their bounds; where it is `unknown` a verdict may carry a second word. */
+export interface PairItem extends ItemBase {
+    kind: "pair";
+    lead: PairLead;
+    validity?: Open<"overlap" | "disjoint" | "empty" | "unknown">;
 }
-/** Accepted `abandon_write`; the resulting outcome is in `writes`. */
-export interface AcceptedAbandon {
-    work_id: string;
-    action_key: string;
+/** Form, attach to or bridge a hub. Unstable: checked against Rust source only. */
+export interface HubItem extends ItemBase {
+    kind: "hub_attachment" | "hub_formation" | "hub_bridge";
+    lead: HubLead;
+}
+/** Promote recurring knowledge to skills/core. Unstable: checked against Rust source only. */
+export interface PromotionItem extends ItemBase {
+    kind: "promotion";
+    lead: PromotionLead;
+}
+/** A delivered work item, discriminated on `kind`. */
+export type ReflectItem = SourceItem | PairItem | HubItem | PromotionItem;
+/** Accepted decision; `verdict` repeats the outcome (and a pair's validity word). */
+export interface AcceptedDecision {
+    token: string;
     accepted: true;
+    verdict: string;
 }
 /** Failed decision; the call still succeeds and later decisions still run. */
 export interface RejectedDecision {
-    work_id: string;
+    token: string;
     accepted: false;
     error: ToolError;
 }
 /** One entry of `reflect().decisions`, in submission order. */
-export type DecisionReceipt = AcceptedDecision | AcceptedAbandon | RejectedDecision;
+export type DecisionReceipt = AcceptedDecision | RejectedDecision;
+/** A `focus` target that could not be delivered, or a work that failed to deliver; the call itself succeeded. */
+export interface FocusError {
+    focus: string;
+    error: ToolError;
+}
 /** Discovery lanes in the order the server reports them. */
 export type ReflectionLane = "source" | "semantic_pairs" | "structural_pairs" | "hubs" | "promotions";
 /** Progress of one discovery page. */
@@ -364,7 +347,7 @@ export type DiscoveryLane = {
     error: ToolError;
     current_complete?: boolean;
 };
-/** Queue counters; `done` is true only when every lane is exhausted and nothing is open. */
+/** Queue counters; `done` is true only when every lane is current and nothing is open. */
 export interface ReflectCounters {
     pending: number;
     blocked: number;
@@ -372,17 +355,25 @@ export interface ReflectCounters {
     unresolved_writes: number;
     done: boolean;
 }
-/** `reflect` payload for every mode; unused sections are empty. Check `counters.done` before assuming nothing is left. */
+/** What to do next: `resume` unresolved writes, `decide` the delivered items, `continue` the scan, or `done`. */
+export type ReflectNext = Open<"resume" | "decide" | "continue" | "done">;
+/**
+ * `reflect` payload. One call applies its decisions, then delivers work, so a loop is: call with the
+ * decisions so far and follow `next`. `writes` lists every unresolved write on every call.
+ */
 export interface ReflectResult {
-    deliveries: ReflectDelivery[];
+    next: ReflectNext;
+    items: ReflectItem[];
+    writes: UnresolvedWrite[];
+    /** Work tokens of blocked work; pass one in `focus` to reopen it. */
+    blocked: string[];
     decisions: DecisionReceipt[];
-    writes: WriteOutcome[];
-    /** Lanes are filled by discovery (no targets) only. */
-    discovery: {
-        completion_checked: boolean;
-        lanes: DiscoveryLane[];
-    };
     counters: ReflectCounters;
+    /** Empty when `focus` named targets. */
+    lanes: DiscoveryLane[];
+    /** `focus` symbols this version does not know. */
+    ignored?: string[];
+    errors?: FocusError[];
     jev?: Experimental;
     jev_triage?: Experimental;
 }

package/dist/vault.d.ts

@@ -1,12 +1,12 @@
-import { type EngineOptions } from "./stdio";
+import { type EngineOptions } from "./native";
 import { type CallOptions } from "./transport";
-import type { ConsolidationDisposition, PairDisposition, ReadResult, RecallResult, Reply, ReflectResult, RememberResult, RemoveResult, Scope, SourceDisposition } from "./types";
+import type { ReadResult, RecallResult, Reply, ReflectResult, RememberResult, RemoveResult, Scope } from "./types";
 export { sliceUtf8 } from "./types";
 export declare const CLIENT_INFO: {
     name: string;
     version: string;
 };
-/** Local vault: the SDK spawns `consol stdio` for it. */
+/** Local vault: the engine runs in this process. */
 export interface VaultOptions extends EngineOptions {
     /** Local directory, or `s3://bucket[/prefix]/<name>` (needs `db`; AWS_* from the environment). */
     path: string;
@@ -24,85 +24,24 @@ export interface HostedOptions {
     /** Default per-call deadline in ms (300000); 0 disables it. */
     timeoutMs?: number;
 }
-/** Binds one recoverable write to inspected work; a write never completes the work. */
-export interface ReflectionContext {
-    work_id: string;
-    basis_hash: string;
-    action_key: string;
-}
-/** Decision input source reference; unlike results it never carries `review_version`. */
-export interface InspectedSource {
-    id: string;
-    owner: string;
-    content_version: string;
-}
-/** Body byte range (UTF-8, frontmatter excluded) that a decision cites as evidence. */
-export interface InspectedSpan {
-    source: InspectedSource;
-    byte_range: [number, number];
-}
-/** Required for completed pair decisions so validity periods are compared, not assumed. */
-export interface TemporalAssessment {
-    validity: "overlap" | "disjoint" | "empty" | "unknown";
-    reason: string;
-    evidence: InspectedSpan[];
-    correction_reason?: string;
-}
-/** Names the authored link a `linked` pair decision relies on. */
-export interface PairAssertion {
-    owner: InspectedSource;
-    src: string;
-    dst: string;
-    relation: "derives" | "causes" | "contradicts" | "questions";
-}
 /**
- * One explicit outcome for `reflect({ decisions })`; the tool schema defines each kind's required
- * evidence. `retry_after_ms` is an epoch-ms timestamp within the next day, only for `retryable_error`.
- * Hub and promotion decisions are experimental.
+ * One outcome for `reflect({ decisions })`. `token` is an item's work token, or a write token to
+ * abandon that write. `verdict` is one of the item's `verdicts` (`abandon` for a write token); a
+ * pair verdict may add `overlap`, `disjoint` or `empty` only where the item's `validity` is unknown.
+ * `refs` is what you inspected: `id@version` (a whole source) or `id@version#start-end` (a body
+ * span, UTF-8 byte offsets). `outputs` are the notes the work produced or relied on, `id@version`.
  */
-export type Decision = {
-    kind: "source";
-    work_id: string;
-    basis_hash: string;
-    disposition: SourceDisposition;
-    reason: string;
-    outputs?: InspectedSource[];
-    action_keys?: string[];
-    retry_after_ms?: number;
-} | {
-    kind: "pair";
-    work_id: string;
-    basis_hash: string;
-    disposition: PairDisposition;
-    reason: string;
-    temporal?: TemporalAssessment;
-    assertion?: PairAssertion;
-    action_keys?: string[];
-    retry_after_ms?: number;
-} | {
-    kind: "hub" | "promotion";
-    work_id: string;
-    basis_hash: string;
-    disposition: ConsolidationDisposition;
+export interface Decision {
+    token: string;
+    verdict: string;
     reason: string;
-    outputs?: InspectedSource[];
-    evidence?: InspectedSpan[];
-    action_keys?: string[];
-    retry_after_ms?: number;
-} | {
-    kind: "abandon_write";
-    work_id: string;
-    basis_hash: string;
-    action_key: string;
-    inspected: InspectedSource | null;
-    reason: string;
-};
+    refs?: string[];
+    outputs?: string[];
+}
 /** Flat wire args for recall. */
 export interface RecallArgs {
     query: string;
     agent?: string;
-    include_history?: boolean;
-    limit?: number;
 }
 /** Flat wire args for read. */
 export interface ReadArgs {
@@ -111,8 +50,8 @@ export interface ReadArgs {
     continuation?: string;
 }
 /**
- * Flat wire args for remember. Omitted or null metadata preserves the stored value; "" or [] clears
- * it. Without `expected_version` the write is create-only.
+ * Wire args for remember. Omitted or null `content` preserves the body. Without `expected_version`
+ * the write is create-only.
  */
 export interface RememberArgs {
     id: string;
@@ -120,44 +59,50 @@ export interface RememberArgs {
     /** Markdown body only, never frontmatter. */
     content?: string | null;
     expected_version?: string;
-    entities?: string[] | null;
-    facets?: string[] | null;
-    scope?: Scope | null;
-    summary?: string | null;
-    team?: string | null;
-    /** `YYYY-MM-DD` or RFC 3339 with `Z`/offset; "" clears the bound. */
-    valid_from?: string | null;
-    valid_to?: string | null;
-    reflection?: ReflectionContext;
+    /**
+     * A key left out keeps its value; null, "" or [] clears it (not `scope` or `team`: null keeps
+     * them). `valid_from`/`valid_to` are `YYYY-MM-DD` or RFC 3339 with `Z`/offset. A key the server
+     * does not know is ignored and listed in the receipt's `ignored`.
+     */
+    meta?: {
+        summary?: string | null;
+        entities?: string[] | null;
+        facets?: string[] | null;
+        scope?: Scope | null;
+        team?: string | null;
+        valid_from?: string | null;
+        valid_to?: string | null;
+        [key: string]: unknown;
+    };
+    /** An item's work token from `reflect` binds this write to that work; the server derives its action key. */
+    token?: string;
 }
 /** Flat wire args for remove (archives the note; its body stays readable). */
 export interface RemoveArgs {
     id: string;
     expected_version: string;
     agent?: string;
-    reflection?: ReflectionContext;
+    /** An item's work token from `reflect` records this archive as one write of that work. */
+    token?: string;
 }
-/** Resume a pending reflection-bound write with the same context and tool. */
+/** Resume (or replay) a write by its write token, with the tool that wrote it. */
 export interface ResumeArgs {
-    resume: true;
-    reflection: ReflectionContext;
+    token: string;
     agent?: string;
 }
-/** Flat wire args for reflect. */
+/** Flat wire args for reflect. `focus` is whitespace-separated work tokens and note ids. */
 export interface ReflectArgs {
     agent?: string;
-    ids?: string[];
-    work_ids?: string[];
-    limit?: number;
+    focus?: string;
     decisions?: Decision[];
 }
-/** One vault behind a transport (a local child or a hosted backend). Build it with createVault or openVault; close() is final. */
+/** One vault behind a transport (the in-process engine or a hosted backend). Build it with createVault or openVault; close() is final. */
 export declare class Vault {
     private readonly transport;
     private readonly vault;
     private readonly agent;
     private constructor();
-    /** Server version of the last reply; null before the first. */
+    /** Engine version (known once opened); a hosted vault's is that of the last reply, null before the first. */
     get serverVersion(): string | null;
     /** Final and idempotent; concurrent calls share one completion. Later calls fail with `closed`. */
     close(): Promise<void>;
@@ -171,10 +116,10 @@ export declare class Vault {
     remove(args: RemoveArgs | ResumeArgs, options?: CallOptions): Promise<RemoveResult>;
     reflect(args?: ReflectArgs, options?: CallOptions): Promise<ReflectResult>;
 }
-/** Creates the vault and starts its child; fails with `vault_exists` when a vault marker exists. */
+/** Creates the vault and opens its engine; fails with `vault_exists` when a vault marker exists. */
 export declare function createVault(options: VaultOptions): Promise<Vault>;
 /**
- * Local: starts the child of an existing vault (`vault_not_found` when no marker exists). Hosted
+ * Local: opens the engine of an existing vault (`vault_not_found` when no marker exists). Hosted
  * (`url`): no round trip here, a missing vault is `vault_not_found` on the first call.
  */
 export declare function openVault(options: VaultOptions | HostedOptions): Promise<Vault>;