@agenticros/core 0.5.0

package/dist/memory/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Cross-adapter semantic memory primitives.
+ *
+ * Memory is an optional, off-by-default subsystem that gives every adapter
+ * (OpenClaw, Claude Code MCP, Gemini CLI) a shared way to remember facts
+ * across sessions. Records are namespaced (default: robot namespace), so
+ * the three adapters talking to the same robot share the same store.
+ */
+export interface MemoryRecord {
+    /** Provider-assigned id. Used for `forget({ id })`. */
+    id: string;
+    /** Raw text content the agent stored. */
+    content: string;
+    /** Namespace this record belongs to (defaults to robot namespace at call time). */
+    namespace: string;
+    /** Optional tags the agent supplied at write time. */
+    tags?: string[];
+    /** Optional hierarchical path hint (e.g. "profile.preferences.speed"). */
+    path?: string;
+    /** ms since epoch when the record was created. */
+    createdAt: number;
+    /** Similarity / relevance score, populated only by `recall`. Higher = more relevant. */
+    score?: number;
+}
+export interface MemoryStatus {
+    /** True when a non-null provider was created from config. */
+    enabled: boolean;
+    /** Active backend identifier. */
+    backend: "local" | "mem0";
+    /** Effective namespace the adapter is using. */
+    namespace: string;
+    /** Number of records stored under this namespace (may be approximate for mem0). */
+    recordCount: number;
+    /** ms since epoch of the most recent write under this namespace, or null. */
+    lastWriteAt: number | null;
+    /** Embedder description for the mem0 backend, when configured. */
+    embedder?: {
+        provider: string;
+        model?: string;
+    };
+}
+export interface RememberInput {
+    content: string;
+    namespace?: string;
+    tags?: string[];
+    path?: string;
+}
+export interface RecallInput {
+    query: string;
+    namespace?: string;
+    limit?: number;
+}
+export interface ForgetInput {
+    id?: string;
+    query?: string;
+    namespace?: string;
+}
+/**
+ * Backend-agnostic memory provider.
+ *
+ * Implementations are obtained via `createMemory(config)`. The provider is
+ * null when `config.memory.enabled === false`, so adapters skip registering
+ * memory tools entirely.
+ */
+export interface MemoryProvider {
+    /** Backend identifier (matches `config.memory.backend`). */
+    readonly backend: "local" | "mem0";
+    /** Store a new memory. Returns the persisted record (with provider-assigned id). */
+    remember(input: RememberInput): Promise<MemoryRecord>;
+    /** Recall up to `limit` memories ranked by relevance to `query`. */
+    recall(input: RecallInput): Promise<MemoryRecord[]>;
+    /**
+     * Delete memories. Either:
+     *  - `{ id }` — delete one record by id.
+     *  - `{ query }` — delete all records in `namespace` matching the query.
+     *  - `{ namespace }` only (no id, no query) — delete every record in the namespace.
+     */
+    forget(input: ForgetInput): Promise<{
+        removed: number;
+    }>;
+    /** Health check: counts records, reports last-write time and embedder info if any. */
+    status(namespace: string): Promise<MemoryStatus>;
+    /**
+     * Return up to `limit` most recently written records in the namespace.
+     * Used by adapters that want to surface "recently remembered" snippets in
+     * the system prompt so the LLM doesn't need a tool call for common
+     * personal-context questions. Order: newest first.
+     */
+    recent(namespace: string, limit?: number): Promise<MemoryRecord[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/memory/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,EAAE,EAAE,MAAM,CAAC;IACX,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,wFAAwF;IACxF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,OAAO,EAAE,OAAO,CAAC;IACjB,iCAAiC;IACjC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,kEAAkE;IAClE,QAAQ,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACjD;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;IAEnC,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAEtD,oEAAoE;IACpE,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAEpD;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAEzD,sFAAsF;IACtF,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAEjD;;;;;OAKG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;CACpE"}

package/dist/memory/types.js

@@ -0,0 +1,10 @@
+/**
+ * Cross-adapter semantic memory primitives.
+ *
+ * Memory is an optional, off-by-default subsystem that gives every adapter
+ * (OpenClaw, Claude Code MCP, Gemini CLI) a shared way to remember facts
+ * across sessions. Records are namespaced (default: robot namespace), so
+ * the three adapters talking to the same robot share the same store.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/memory/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/mission-registry.d.ts

@@ -0,0 +1,94 @@
+/**
+ * MissionRegistry — Phase 1.f in-process tracker for active missions.
+ *
+ * Each adapter (Claude Code MCP server, OpenClaw plugin, Gemini CLI)
+ * keeps a module-level registry. When `run_mission` starts, the adapter
+ * registers a fresh cancellation token under a unique `mission_id` and
+ * returns the id in the tool response. A sibling `mission_cancel` tool
+ * call then looks up the token by id and flips `cancelled = true` — the
+ * mission runner picks that up at the next step boundary and stops
+ * gracefully.
+ *
+ * Lifetime semantics:
+ *  - `register()` returns the cancellation token AND a `dispose()`
+ *    callback the caller is expected to invoke in a `finally` block
+ *    once the mission ends (regardless of outcome). Disposal removes
+ *    the entry so a subsequent cancel doesn't silently target a
+ *    completed mission and the in-memory map stays small.
+ *  - `cancel()` is idempotent — calling it on a missing id returns
+ *    `{ found: false }`; calling it twice on the same id is a no-op
+ *    after the first.
+ *
+ * Why in-process (not cross-process)? Cancellation is fundamentally
+ * "stop the dispatcher I'm running"; that dispatcher is local to the
+ * adapter process. Cross-agent coordination is Phase 4. The transcript
+ * subsystem (memory) handles the "different agent reads what I did"
+ * story orthogonally.
+ */
+import type { MissionCancellationToken } from "./mission.js";
+/** One registered mission. */
+export interface MissionRegistryEntry {
+    mission_id: string;
+    /** Adapter-supplied label for diagnostics (e.g. mission.name). */
+    name?: string;
+    /** ms since epoch when the mission was registered. */
+    started_at: number;
+    /** The token the mission runner reads each step. */
+    cancellation: MissionCancellationToken;
+}
+/**
+ * Generate a stable, URL-safe mission identifier.
+ *
+ * Uses `crypto.randomUUID()` when available (Node 14.17+, Bun, modern
+ * browsers); falls back to a Math.random hex string with a `mns_` prefix.
+ * Either way the id is opaque to downstream consumers — they just echo
+ * it back to `mission_cancel` / `memory_recall`.
+ */
+export declare function generateMissionId(): string;
+/**
+ * Compute the canonical memory namespace for a mission's transcripts.
+ *
+ * The convention is `mission:<id>` so a downstream agent can recall
+ * every step the first agent ran via
+ * `memory_recall({ namespace: "mission:<id>", query: "" })`. This lives
+ * here (not in the memory module) because the adapter's transcript
+ * sink uses it and we want exactly one source of truth.
+ */
+export declare function missionTranscriptNamespace(missionId: string): string;
+export declare class MissionRegistry {
+    private readonly entries;
+    /**
+     * Register a fresh mission, returning the entry (with the
+     * cancellation token to hand to `runMission`) and a `dispose` hook
+     * to invoke when the mission ends. The id is caller-supplied so
+     * adapters can echo it in the tool response before this point.
+     */
+    register(missionId: string, opts?: {
+        name?: string;
+    }): {
+        entry: MissionRegistryEntry;
+        dispose: () => void;
+    };
+    /**
+     * Flip the cancellation token for the named mission.
+     *
+     * Returns `{ found: true }` when the mission existed (whether it was
+     * already cancelled or not), `{ found: false }` when the id is
+     * unknown (e.g. mission already finished + disposed).
+     */
+    cancel(missionId: string, reason?: string): {
+        found: boolean;
+        alreadyCancelled: boolean;
+    };
+    /** True when the named mission is currently registered. */
+    has(missionId: string): boolean;
+    /**
+     * Snapshot of the active mission set (for diagnostics / mission_list
+     * tools down the road). Returns a shallow copy so callers can't
+     * mutate internal state.
+     */
+    list(): MissionRegistryEntry[];
+    /** Test-only: drop every registered mission. */
+    _clear(): void;
+}
+//# sourceMappingURL=mission-registry.d.ts.map

package/dist/mission-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mission-registry.d.ts","sourceRoot":"","sources":["../src/mission-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D,8BAA8B;AAC9B,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,YAAY,EAAE,wBAAwB,CAAC;CACxC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAO1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IAEnE;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG;QACrD,KAAK,EAAE,oBAAoB,CAAC;QAC5B,OAAO,EAAE,MAAM,IAAI,CAAC;KACrB;IAmBD;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,gBAAgB,EAAE,OAAO,CAAA;KAAE;IASzF,2DAA2D;IAC3D,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B;;;;OAIG;IACH,IAAI,IAAI,oBAAoB,EAAE;IAS9B,gDAAgD;IAChD,MAAM,IAAI,IAAI;CAGf"}

package/dist/mission-registry.js

@@ -0,0 +1,123 @@
+/**
+ * MissionRegistry — Phase 1.f in-process tracker for active missions.
+ *
+ * Each adapter (Claude Code MCP server, OpenClaw plugin, Gemini CLI)
+ * keeps a module-level registry. When `run_mission` starts, the adapter
+ * registers a fresh cancellation token under a unique `mission_id` and
+ * returns the id in the tool response. A sibling `mission_cancel` tool
+ * call then looks up the token by id and flips `cancelled = true` — the
+ * mission runner picks that up at the next step boundary and stops
+ * gracefully.
+ *
+ * Lifetime semantics:
+ *  - `register()` returns the cancellation token AND a `dispose()`
+ *    callback the caller is expected to invoke in a `finally` block
+ *    once the mission ends (regardless of outcome). Disposal removes
+ *    the entry so a subsequent cancel doesn't silently target a
+ *    completed mission and the in-memory map stays small.
+ *  - `cancel()` is idempotent — calling it on a missing id returns
+ *    `{ found: false }`; calling it twice on the same id is a no-op
+ *    after the first.
+ *
+ * Why in-process (not cross-process)? Cancellation is fundamentally
+ * "stop the dispatcher I'm running"; that dispatcher is local to the
+ * adapter process. Cross-agent coordination is Phase 4. The transcript
+ * subsystem (memory) handles the "different agent reads what I did"
+ * story orthogonally.
+ */
+/**
+ * Generate a stable, URL-safe mission identifier.
+ *
+ * Uses `crypto.randomUUID()` when available (Node 14.17+, Bun, modern
+ * browsers); falls back to a Math.random hex string with a `mns_` prefix.
+ * Either way the id is opaque to downstream consumers — they just echo
+ * it back to `mission_cancel` / `memory_recall`.
+ */
+export function generateMissionId() {
+    const g = globalThis;
+    if (g.crypto?.randomUUID)
+        return `mn_${g.crypto.randomUUID()}`;
+    const a = Math.floor(Math.random() * 0xffffffff).toString(16).padStart(8, "0");
+    const b = Math.floor(Math.random() * 0xffffffff).toString(16).padStart(8, "0");
+    const c = Date.now().toString(16);
+    return `mn_${a}${b}${c}`;
+}
+/**
+ * Compute the canonical memory namespace for a mission's transcripts.
+ *
+ * The convention is `mission:<id>` so a downstream agent can recall
+ * every step the first agent ran via
+ * `memory_recall({ namespace: "mission:<id>", query: "" })`. This lives
+ * here (not in the memory module) because the adapter's transcript
+ * sink uses it and we want exactly one source of truth.
+ */
+export function missionTranscriptNamespace(missionId) {
+    return `mission:${missionId}`;
+}
+export class MissionRegistry {
+    entries = new Map();
+    /**
+     * Register a fresh mission, returning the entry (with the
+     * cancellation token to hand to `runMission`) and a `dispose` hook
+     * to invoke when the mission ends. The id is caller-supplied so
+     * adapters can echo it in the tool response before this point.
+     */
+    register(missionId, opts) {
+        const entry = {
+            mission_id: missionId,
+            name: opts?.name,
+            started_at: Date.now(),
+            cancellation: { cancelled: false },
+        };
+        this.entries.set(missionId, entry);
+        return {
+            entry,
+            dispose: () => {
+                // Only remove if we're disposing the same entry — guards against
+                // a race where the same id is re-registered between dispose calls
+                // (unlikely but cheap to defend against).
+                if (this.entries.get(missionId) === entry)
+                    this.entries.delete(missionId);
+            },
+        };
+    }
+    /**
+     * Flip the cancellation token for the named mission.
+     *
+     * Returns `{ found: true }` when the mission existed (whether it was
+     * already cancelled or not), `{ found: false }` when the id is
+     * unknown (e.g. mission already finished + disposed).
+     */
+    cancel(missionId, reason) {
+        const entry = this.entries.get(missionId);
+        if (!entry)
+            return { found: false, alreadyCancelled: false };
+        const alreadyCancelled = entry.cancellation.cancelled === true;
+        entry.cancellation.cancelled = true;
+        if (reason !== undefined)
+            entry.cancellation.reason = reason;
+        return { found: true, alreadyCancelled };
+    }
+    /** True when the named mission is currently registered. */
+    has(missionId) {
+        return this.entries.has(missionId);
+    }
+    /**
+     * Snapshot of the active mission set (for diagnostics / mission_list
+     * tools down the road). Returns a shallow copy so callers can't
+     * mutate internal state.
+     */
+    list() {
+        return [...this.entries.values()].map((e) => ({
+            mission_id: e.mission_id,
+            name: e.name,
+            started_at: e.started_at,
+            cancellation: { ...e.cancellation },
+        }));
+    }
+    /** Test-only: drop every registered mission. */
+    _clear() {
+        this.entries.clear();
+    }
+}
+//# sourceMappingURL=mission-registry.js.map

package/dist/mission-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mission-registry.js","sourceRoot":"","sources":["../src/mission-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAeH;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB;IAC/B,MAAM,CAAC,GAAG,UAAwD,CAAC;IACnE,IAAI,CAAC,CAAC,MAAM,EAAE,UAAU;QAAE,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;IAC/D,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC/E,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC/E,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAClC,OAAO,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,0BAA0B,CAAC,SAAiB;IAC1D,OAAO,WAAW,SAAS,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,OAAO,eAAe;IACT,OAAO,GAAG,IAAI,GAAG,EAAgC,CAAC;IAEnE;;;;;OAKG;IACH,QAAQ,CAAC,SAAiB,EAAE,IAAwB;QAIlD,MAAM,KAAK,GAAyB;YAClC,UAAU,EAAE,SAAS;YACrB,IAAI,EAAE,IAAI,EAAE,IAAI;YAChB,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE;YACtB,YAAY,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE;SACnC,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QACnC,OAAO;YACL,KAAK;YACL,OAAO,EAAE,GAAG,EAAE;gBACZ,iEAAiE;gBACjE,kEAAkE;gBAClE,0CAA0C;gBAC1C,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,KAAK;oBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAC5E,CAAC;SACF,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,SAAiB,EAAE,MAAe;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK;YAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC;QAC7D,MAAM,gBAAgB,GAAG,KAAK,CAAC,YAAY,CAAC,SAAS,KAAK,IAAI,CAAC;QAC/D,KAAK,CAAC,YAAY,CAAC,SAAS,GAAG,IAAI,CAAC;QACpC,IAAI,MAAM,KAAK,SAAS;YAAE,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC;QAC7D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;IAC3C,CAAC;IAED,2DAA2D;IAC3D,GAAG,CAAC,SAAiB;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC5C,UAAU,EAAE,CAAC,CAAC,UAAU;YACxB,IAAI,EAAE,CAAC,CAAC,IAAI;YACZ,UAAU,EAAE,CAAC,CAAC,UAAU;YACxB,YAAY,EAAE,EAAE,GAAG,CAAC,CAAC,YAAY,EAAE;SACpC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,gDAAgD;IAChD,MAAM;QACJ,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;CACF"}

package/dist/mission-transcript-sink.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Memory-backed mission transcript sink — Phase 1.f wiring.
+ *
+ * `createMemoryTranscriptSink(memory, missionId)` returns a
+ * `MissionTranscriptSink` the adapter hands to `runMission`. Each
+ * step's `MissionTranscriptEntry` is serialised to JSON and persisted
+ * via the shared `MemoryProvider` under the canonical
+ * `mission:<id>` namespace.
+ *
+ * Why JSON content (and not the structured `MemoryRecord` fields):
+ * `MemoryProvider.remember` only takes `content: string` (plus
+ * optional tags/path). We pack the full step snapshot into `content`
+ * so a downstream agent can `JSON.parse(record.content)` after
+ * `memory_recall(namespace="mission:<id>")`. Tags are used as
+ * coarse-grained filters (e.g. "step:ok" vs "step:error") for
+ * future status queries.
+ *
+ * The returned sink is best-effort by contract — `runMission` already
+ * swallows thrown errors, but we also defensively catch the await so a
+ * mem0 outage never propagates back into the run loop.
+ */
+import type { MemoryProvider } from "./memory/index.js";
+import type { MissionTranscriptSink } from "./mission.js";
+/**
+ * Build a transcript sink that writes each step's entry to memory.
+ *
+ * @param memory      Active memory provider (caller has already
+ *                    confirmed `config.memory.enabled === true`).
+ * @param missionId   Mission identifier. Surfaced as the namespace
+ *                    and also embedded in the content for grep-ability.
+ */
+export declare function createMemoryTranscriptSink(memory: MemoryProvider, missionId: string): MissionTranscriptSink;
+//# sourceMappingURL=mission-transcript-sink.d.ts.map

package/dist/mission-transcript-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mission-transcript-sink.d.ts","sourceRoot":"","sources":["../src/mission-transcript-sink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAA0B,MAAM,cAAc,CAAC;AAGlF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,GAChB,qBAAqB,CA2CvB"}

package/dist/mission-transcript-sink.js

@@ -0,0 +1,76 @@
+/**
+ * Memory-backed mission transcript sink — Phase 1.f wiring.
+ *
+ * `createMemoryTranscriptSink(memory, missionId)` returns a
+ * `MissionTranscriptSink` the adapter hands to `runMission`. Each
+ * step's `MissionTranscriptEntry` is serialised to JSON and persisted
+ * via the shared `MemoryProvider` under the canonical
+ * `mission:<id>` namespace.
+ *
+ * Why JSON content (and not the structured `MemoryRecord` fields):
+ * `MemoryProvider.remember` only takes `content: string` (plus
+ * optional tags/path). We pack the full step snapshot into `content`
+ * so a downstream agent can `JSON.parse(record.content)` after
+ * `memory_recall(namespace="mission:<id>")`. Tags are used as
+ * coarse-grained filters (e.g. "step:ok" vs "step:error") for
+ * future status queries.
+ *
+ * The returned sink is best-effort by contract — `runMission` already
+ * swallows thrown errors, but we also defensively catch the await so a
+ * mem0 outage never propagates back into the run loop.
+ */
+import { missionTranscriptNamespace } from "./mission-registry.js";
+/**
+ * Build a transcript sink that writes each step's entry to memory.
+ *
+ * @param memory      Active memory provider (caller has already
+ *                    confirmed `config.memory.enabled === true`).
+ * @param missionId   Mission identifier. Surfaced as the namespace
+ *                    and also embedded in the content for grep-ability.
+ */
+export function createMemoryTranscriptSink(memory, missionId) {
+    const namespace = missionTranscriptNamespace(missionId);
+    return async (entry) => {
+        try {
+            const content = JSON.stringify({
+                // Echo mission_id in the payload too — recall() returns the
+                // content blob; mission_id in the namespace might be lost if
+                // the caller scopes their recall differently.
+                mission_id: entry.mission_id || missionId,
+                mission_name: entry.mission_name,
+                adapter: entry.adapter,
+                robot_id: entry.robot_id,
+                started_at: entry.started_at,
+                step_index: entry.step_index,
+                step_total: entry.step_total,
+                step: {
+                    id: entry.result.id,
+                    capability: entry.result.capability,
+                    status: entry.result.status,
+                    inputs: entry.result.inputs,
+                    outputs: entry.result.outputs,
+                    message: entry.result.message,
+                    error: entry.result.error,
+                    duration_ms: entry.result.duration_ms,
+                },
+            });
+            // Tags are deliberately stable + greppable so a future
+            // `memory_recall(tags=…)` can filter to "every cancelled step"
+            // or "every step that touched capability=drive_base".
+            await memory.remember({
+                namespace,
+                content,
+                tags: [
+                    "mission_transcript",
+                    `step:${entry.result.status}`,
+                    `capability:${entry.result.capability}`,
+                ],
+                path: `${missionId}/${String(entry.step_index).padStart(3, "0")}-${entry.result.id}`,
+            });
+        }
+        catch {
+            // Best-effort: transcript loss must NEVER abort the mission.
+        }
+    };
+}
+//# sourceMappingURL=mission-transcript-sink.js.map

package/dist/mission-transcript-sink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mission-transcript-sink.js","sourceRoot":"","sources":["../src/mission-transcript-sink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACxC,MAAsB,EACtB,SAAiB;IAEjB,MAAM,SAAS,GAAG,0BAA0B,CAAC,SAAS,CAAC,CAAC;IACxD,OAAO,KAAK,EAAE,KAA6B,EAAiB,EAAE;QAC5D,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC7B,4DAA4D;gBAC5D,6DAA6D;gBAC7D,8CAA8C;gBAC9C,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,SAAS;gBACzC,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,IAAI,EAAE;oBACJ,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE;oBACnB,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,UAAU;oBACnC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;oBAC3B,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM;oBAC3B,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO;oBAC7B,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO;oBAC7B,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK;oBACzB,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,WAAW;iBACtC;aACF,CAAC,CAAC;YACH,uDAAuD;YACvD,+DAA+D;YAC/D,sDAAsD;YACtD,MAAM,MAAM,CAAC,QAAQ,CAAC;gBACpB,SAAS;gBACT,OAAO;gBACP,IAAI,EAAE;oBACJ,oBAAoB;oBACpB,QAAQ,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE;oBAC7B,cAAc,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE;iBACxC;gBACD,IAAI,EAAE,GAAG,SAAS,IAAI,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE;aACrF,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,6DAA6D;QAC/D,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}