@joshuaswarren/openclaw-engram 9.0.45 → 9.0.47

package/README.md

@@ -46,6 +46,7 @@ AI agents forget everything between conversations. Engram fixes that.
 - **Creation-memory ledger** — Engram can now, when `creationMemoryEnabled` is enabled, persist a typed work-product ledger for explicit outputs agents create or update, inspect it with `openclaw engram work-product-status`, and write deterministic entries through `openclaw engram work-product-record`.
 - **Artifact recovery recall** — Engram can now, when both `creationMemoryEnabled` and `workProductRecallEnabled` are enabled, surface prompt-relevant work-product ledger entries back into recall as a dedicated `Work Products` section and inspect reuse candidates with `openclaw engram work-product-recall-search`.
 - **Commitment lifecycle foundation** — Engram can now, when `creationMemoryEnabled`, `commitmentLedgerEnabled`, and `commitmentLifecycleEnabled` are enabled, transition existing commitments to `fulfilled` / `cancelled` / `expired`, inspect overdue and stale obligations in `openclaw engram commitment-status`, and run deterministic lifecycle cleanup with `openclaw engram commitment-lifecycle-run`.
+- **Resume-bundle builder** — Engram can now, when `creationMemoryEnabled` and `resumeBundlesEnabled` are enabled, persist typed crash-recovery resume bundles, inspect them with `openclaw engram resume-bundle-status`, write explicit handoff shells through `openclaw engram resume-bundle-record`, and build bounded resume bundles from transcript recovery, recent objective-state snapshots, work products, and open commitments through `openclaw engram resume-bundle-build`.
 - **Zero-config start** — Install, add an API key, restart. Engram works out of the box with sensible defaults and progressively unlocks advanced features as you enable them.
 
 ## Quick Start
@@ -228,6 +229,8 @@ Key settings:
 | `commitmentLifecycleEnabled` | `false` | Enable commitment lifecycle transitions, stale tracking, and resolved-entry cleanup for the commitment ledger |
 | `commitmentStaleDays` | `14` | Days before an open commitment without a due date is considered stale in lifecycle status |
 | `commitmentLedgerDir` | `{memoryDir}/state/commitment-ledger` | Root directory for typed commitment ledger entries |
+| `resumeBundlesEnabled` | `false` | Enable typed resume-bundle storage plus the operator-facing `resume-bundle-status`, `resume-bundle-record`, and `resume-bundle-build` commands |
+| `resumeBundleDir` | `{memoryDir}/state/resume-bundles` | Root directory for typed resume bundles |
 | `workProductRecallEnabled` | `false` | Inject prompt-relevant work-product ledger entries into recall and expose `openclaw engram work-product-recall-search` |
 | `workProductLedgerDir` | `{memoryDir}/state/work-product-ledger` | Root directory for typed work-product ledger entries |
 

package/dist/index.js

@@ -312,6 +312,8 @@ function parseConfig(raw) {
     commitmentLifecycleEnabled: cfg.commitmentLifecycleEnabled === true,
     commitmentStaleDays: typeof cfg.commitmentStaleDays === "number" ? cfg.commitmentStaleDays : 14,
     commitmentLedgerDir: typeof cfg.commitmentLedgerDir === "string" && cfg.commitmentLedgerDir.trim().length > 0 ? cfg.commitmentLedgerDir.trim() : path.join(memoryDir, "state", "commitment-ledger"),
+    resumeBundlesEnabled: cfg.resumeBundlesEnabled === true,
+    resumeBundleDir: typeof cfg.resumeBundleDir === "string" && cfg.resumeBundleDir.trim().length > 0 ? cfg.resumeBundleDir.trim() : path.join(memoryDir, "state", "resume-bundles"),
     workProductRecallEnabled: cfg.workProductRecallEnabled === true,
     workProductLedgerDir: typeof cfg.workProductLedgerDir === "string" && cfg.workProductLedgerDir.trim().length > 0 ? cfg.workProductLedgerDir.trim() : path.join(memoryDir, "state", "work-product-ledger"),
     abstractionNodeStoreDir: typeof cfg.abstractionNodeStoreDir === "string" && cfg.abstractionNodeStoreDir.trim().length > 0 ? cfg.abstractionNodeStoreDir.trim() : path.join(memoryDir, "state", "abstraction-nodes"),
@@ -25307,7 +25309,7 @@ promotionCandidates: ${res.promotionCandidateCount}`
 }
 
 // src/cli.ts
-import path59 from "path";
+import path60 from "path";
 import { access as access3, readFile as readFile37, readdir as readdir24, unlink as unlink8 } from "fs/promises";
 import { createHash as createHash10 } from "crypto";
 
@@ -26188,8 +26190,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path61 = typeof record.path === "string" ? record.path : "";
-      if (!path61.startsWith("transcripts/") && !path61.includes("/transcripts/")) continue;
+      const path62 = typeof record.path === "string" ? record.path : "";
+      if (!path62.startsWith("transcripts/") && !path62.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -27823,6 +27825,237 @@ async function runCompatChecks(options) {
   };
 }
 
+// src/resume-bundles.ts
+import path59 from "path";
+import { mkdir as mkdir40, writeFile as writeFile37 } from "fs/promises";
+var DEFAULT_RESUME_BUNDLE_REF_LIMIT = 5;
+function resolveResumeBundleDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path59.join(memoryDir, "state", "resume-bundles");
+}
+function validateResumeBundle(raw) {
+  if (!isRecord2(raw)) throw new Error("resume bundle must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  const source = assertString2(raw.source, "source");
+  if (!["tool_result", "cli", "system", "manual"].includes(source)) {
+    throw new Error("source must be one of tool_result|cli|system|manual");
+  }
+  const recordedAt = assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt"));
+  if (!Number.isFinite(Date.parse(recordedAt))) {
+    throw new Error("recordedAt must be an ISO timestamp");
+  }
+  return {
+    schemaVersion: 1,
+    bundleId: assertSafePathSegment(assertString2(raw.bundleId, "bundleId"), "bundleId"),
+    recordedAt,
+    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
+    source,
+    scope: assertString2(raw.scope, "scope"),
+    summary: assertString2(raw.summary, "summary"),
+    objectiveStateSnapshotRefs: optionalStringArray2(raw.objectiveStateSnapshotRefs, "objectiveStateSnapshotRefs"),
+    workProductEntryRefs: optionalStringArray2(raw.workProductEntryRefs, "workProductEntryRefs"),
+    commitmentEntryRefs: optionalStringArray2(raw.commitmentEntryRefs, "commitmentEntryRefs"),
+    keyFacts: optionalStringArray2(raw.keyFacts, "keyFacts"),
+    nextActions: optionalStringArray2(raw.nextActions, "nextActions"),
+    riskFlags: optionalStringArray2(raw.riskFlags, "riskFlags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function readValidatedItems(options) {
+  const files = await listJsonFiles(options.rootDir);
+  const items = [];
+  for (const filePath of files) {
+    try {
+      items.push(options.validate(await readJsonFile(filePath)));
+    } catch {
+    }
+  }
+  return items;
+}
+async function readObjectiveStateSnapshotsForSession(options) {
+  const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);
+  const items = await readValidatedItems({
+    rootDir: path59.join(rootDir, "snapshots"),
+    validate: validateObjectiveStateSnapshot
+  });
+  return items.filter((item) => item.sessionKey === options.sessionKey).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
+}
+async function readWorkProductEntriesForSession(options) {
+  const rootDir = resolveWorkProductLedgerDir(options.memoryDir, options.workProductLedgerDir);
+  const items = await readValidatedItems({
+    rootDir: path59.join(rootDir, "entries"),
+    validate: validateWorkProductLedgerEntry
+  });
+  return items.filter((item) => item.sessionKey === options.sessionKey).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
+}
+async function readCommitmentEntriesForSession(options) {
+  const rootDir = resolveCommitmentLedgerDir(options.memoryDir, options.commitmentLedgerDir);
+  const items = await readValidatedItems({
+    rootDir: path59.join(rootDir, "entries"),
+    validate: validateCommitmentLedgerEntry
+  });
+  return items.filter((item) => item.sessionKey === options.sessionKey).filter((item) => options.state ? item.state === options.state : true).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
+}
+function buildRecoveryFact(recoverySummary) {
+  return recoverySummary.healthy ? `Transcript recovery healthy with ${recoverySummary.issueCount} issue(s), ${recoverySummary.incompleteTurns} incomplete turn(s), and ${recoverySummary.brokenChains} broken chain(s).` : `Transcript recovery flagged ${recoverySummary.issueCount} issue(s), ${recoverySummary.incompleteTurns} incomplete turn(s), and ${recoverySummary.brokenChains} broken chain(s); checkpoint healthy: ${recoverySummary.checkpointHealthy ? "yes" : "no"}.`;
+}
+function buildBundleSummary(options) {
+  const parts = [
+    `${options.openCommitmentCount} open commitment(s)`,
+    `${options.workProductCount} recent work product(s)`,
+    `${options.objectiveSnapshotCount} recent objective-state snapshot(s)`
+  ];
+  if (options.recoveryHealthy === false) {
+    parts.push("transcript recovery issues remain");
+  }
+  return `Resume ${options.sessionKey}: ${parts.join(", ")}.`;
+}
+async function buildResumeBundleFromState(options) {
+  const recordedAt = assertIsoRecordedAt(options.recordedAt, "recordedAt");
+  const maxRefsPerStore = Math.max(1, Math.floor(options.maxRefsPerStore ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT));
+  const objectiveSnapshots = options.objectiveStateMemoryEnabled ? await readObjectiveStateSnapshotsForSession({
+    memoryDir: options.memoryDir,
+    objectiveStateStoreDir: options.objectiveStateStoreDir,
+    sessionKey: options.sessionKey,
+    maxResults: maxRefsPerStore
+  }) : [];
+  const workProducts = options.creationMemoryEnabled ? await readWorkProductEntriesForSession({
+    memoryDir: options.memoryDir,
+    workProductLedgerDir: options.workProductLedgerDir,
+    sessionKey: options.sessionKey,
+    maxResults: maxRefsPerStore
+  }) : [];
+  const commitments = options.creationMemoryEnabled && options.commitmentLedgerEnabled ? await readCommitmentEntriesForSession({
+    memoryDir: options.memoryDir,
+    commitmentLedgerDir: options.commitmentLedgerDir,
+    sessionKey: options.sessionKey,
+    maxResults: maxRefsPerStore,
+    state: "open"
+  }) : [];
+  const openCommitments = commitments;
+  const recordedAtMs = Date.parse(recordedAt);
+  const overdueCommitments = openCommitments.filter((entry) => {
+    if (!entry.dueAt) return false;
+    const dueAtMs = Date.parse(entry.dueAt);
+    return Number.isFinite(dueAtMs) && dueAtMs < recordedAtMs;
+  });
+  let recoverySummary;
+  if (options.transcriptEnabled) {
+    const transcript = new TranscriptManager(parseConfig({
+      memoryDir: options.memoryDir,
+      transcriptEnabled: true
+    }));
+    await transcript.initialize();
+    recoverySummary = await transcript.getRecoverySummary(options.sessionKey);
+  }
+  const keyFacts = [
+    recoverySummary ? buildRecoveryFact(recoverySummary) : void 0,
+    workProducts[0]?.summary,
+    objectiveSnapshots[0]?.summary
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  const nextActions = openCommitments.map((entry) => entry.summary).filter((summary, index, values) => values.indexOf(summary) === index).slice(0, maxRefsPerStore);
+  const riskFlags = [
+    recoverySummary && !recoverySummary.healthy ? buildRecoveryFact(recoverySummary) : void 0,
+    ...objectiveSnapshots.filter((snapshot) => snapshot.outcome === "failure" || snapshot.outcome === "partial").map((snapshot) => snapshot.summary),
+    ...overdueCommitments.map((entry) => `Overdue commitment: ${entry.summary}`)
+  ].filter(
+    (value, index, values) => typeof value === "string" && value.length > 0 && values.indexOf(value) === index
+  );
+  return validateResumeBundle({
+    schemaVersion: 1,
+    bundleId: options.bundleId,
+    recordedAt,
+    sessionKey: options.sessionKey,
+    source: options.source ?? "system",
+    scope: options.scope,
+    summary: buildBundleSummary({
+      sessionKey: options.sessionKey,
+      openCommitmentCount: openCommitments.length,
+      workProductCount: workProducts.length,
+      objectiveSnapshotCount: objectiveSnapshots.length,
+      recoveryHealthy: recoverySummary?.healthy
+    }),
+    objectiveStateSnapshotRefs: objectiveSnapshots.map((snapshot) => snapshot.snapshotId),
+    workProductEntryRefs: workProducts.map((entry) => entry.entryId),
+    commitmentEntryRefs: openCommitments.map((entry) => entry.entryId),
+    keyFacts: keyFacts.length > 0 ? keyFacts : void 0,
+    nextActions: nextActions.length > 0 ? nextActions : void 0,
+    riskFlags: riskFlags.length > 0 ? riskFlags : void 0
+  });
+}
+async function recordResumeBundle(options) {
+  const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
+  const validated = validateResumeBundle(options.bundle);
+  const day = recordStoreDay(validated.recordedAt);
+  const bundlesDir = path59.join(rootDir, "bundles", day);
+  const filePath = path59.join(bundlesDir, `${validated.bundleId}.json`);
+  await mkdir40(bundlesDir, { recursive: true });
+  await writeFile37(filePath, JSON.stringify(validated, null, 2), "utf8");
+  return filePath;
+}
+async function readResumeBundles(options) {
+  const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
+  const files = await listJsonFiles(path59.join(rootDir, "bundles"));
+  const bundles = [];
+  const invalidBundles = [];
+  for (const filePath of files) {
+    try {
+      bundles.push(validateResumeBundle(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidBundles.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { files, bundles, invalidBundles };
+}
+async function getResumeBundleStatus(options) {
+  const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
+  const bundlesDir = path59.join(rootDir, "bundles");
+  if (!options.enabled) {
+    return {
+      enabled: false,
+      rootDir,
+      bundlesDir,
+      bundles: {
+        total: 0,
+        valid: 0,
+        invalid: 0,
+        bySource: {}
+      },
+      invalidBundles: []
+    };
+  }
+  const { files, bundles, invalidBundles } = await readResumeBundles(options);
+  let latestBundle;
+  const bySource = {};
+  for (const bundle of bundles) {
+    bySource[bundle.source] = (bySource[bundle.source] ?? 0) + 1;
+    if (!latestBundle || Date.parse(bundle.recordedAt) > Date.parse(latestBundle.recordedAt)) {
+      latestBundle = bundle;
+    }
+  }
+  return {
+    enabled: options.enabled,
+    rootDir,
+    bundlesDir,
+    bundles: {
+      total: files.length,
+      valid: bundles.length,
+      invalid: invalidBundles.length,
+      bySource,
+      latestBundleId: latestBundle?.bundleId,
+      latestRecordedAt: latestBundle?.recordedAt,
+      latestSessionKey: latestBundle?.sessionKey
+    },
+    latestBundle,
+    invalidBundles
+  };
+}
+
 // src/semantic-rule-promotion.ts
 function normalizeRuleWhitespace(value) {
   return value.replace(/\s+/g, " ").trim();
@@ -28229,6 +28462,46 @@ async function runWorkProductRecallSearchCliCommand(options) {
     sessionKey: options.sessionKey
   });
 }
+async function runResumeBundleStatusCliCommand(options) {
+  return getResumeBundleStatus({
+    memoryDir: options.memoryDir,
+    resumeBundleDir: options.resumeBundleDir,
+    enabled: options.creationMemoryEnabled && options.resumeBundlesEnabled
+  });
+}
+async function runResumeBundleRecordCliCommand(options) {
+  if (!options.creationMemoryEnabled || !options.resumeBundlesEnabled) return null;
+  return recordResumeBundle({
+    memoryDir: options.memoryDir,
+    resumeBundleDir: options.resumeBundleDir,
+    bundle: options.bundle
+  });
+}
+async function runResumeBundleBuildCliCommand(options) {
+  if (!options.creationMemoryEnabled || !options.resumeBundlesEnabled) {
+    return null;
+  }
+  const bundle = await buildResumeBundleFromState({
+    memoryDir: options.memoryDir,
+    sessionKey: options.sessionKey,
+    bundleId: options.bundleId,
+    recordedAt: options.recordedAt,
+    scope: options.scope,
+    transcriptEnabled: options.transcriptEnabled,
+    objectiveStateMemoryEnabled: options.objectiveStateMemoryEnabled,
+    objectiveStateStoreDir: options.objectiveStateStoreDir,
+    creationMemoryEnabled: options.creationMemoryEnabled,
+    workProductLedgerDir: options.workProductLedgerDir,
+    commitmentLedgerEnabled: options.commitmentLedgerEnabled,
+    commitmentLedgerDir: options.commitmentLedgerDir
+  });
+  const filePath = await recordResumeBundle({
+    memoryDir: options.memoryDir,
+    resumeBundleDir: options.resumeBundleDir,
+    bundle
+  });
+  return { bundle, filePath };
+}
 async function runCommitmentStatusCliCommand(options) {
   return getCommitmentLedgerStatus({
     memoryDir: options.memoryDir,
@@ -28518,7 +28791,7 @@ function policyVersionForValues(values, config) {
   return createHash10("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path59.join(config.memoryDir, "state", fileName);
+  const filePath = path60.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -29102,14 +29375,14 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace) {
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   if (!orchestrator.config.namespacesEnabled) return orchestrator.config.memoryDir;
-  const candidate = path59.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path60.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists2(candidate) ? candidate : orchestrator.config.memoryDir;
   }
   return candidate;
 }
 async function readAllMemoryFiles(memoryDir) {
-  const roots = [path59.join(memoryDir, "facts"), path59.join(memoryDir, "corrections")];
+  const roots = [path60.join(memoryDir, "facts"), path60.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -29120,7 +29393,7 @@ async function readAllMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path59.join(dir, entryName);
+      const fullPath = path60.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -29499,6 +29772,76 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(results, null, 2));
         console.log("OK");
       });
+      cmd.command("resume-bundle-status").description("Show resume bundle status, bundle counts, and the latest recorded handoff bundle").action(async () => {
+        const status = await runResumeBundleStatusCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          resumeBundleDir: orchestrator.config.resumeBundleDir,
+          creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
+          resumeBundlesEnabled: orchestrator.config.resumeBundlesEnabled
+        });
+        console.log(JSON.stringify(status, null, 2));
+        console.log("OK");
+      });
+      cmd.command("resume-bundle-record").description("Record an explicit resume bundle when creation-memory handoff bundles are enabled").requiredOption("--bundle-id <bundleId>", "Resume bundle id").requiredOption("--recorded-at <recordedAt>", "ISO timestamp for the bundle").requiredOption("--session-key <sessionKey>", "Session key that owns the bundle").requiredOption("--source <source>", "Bundle source (tool_result|cli|system|manual)").requiredOption("--scope <scope>", "Primary scope or recovery domain for the bundle").requiredOption("--summary <summary>", "Human-readable summary of what this bundle preserves").option("--key-fact <keyFact...>", "Short facts that a resumed agent should retain").option("--next-action <nextAction...>", "Explicit next actions for the resumed agent").option("--risk-flag <riskFlag...>", "Open risks or cautions attached to the bundle").option(
+        "--objective-state-snapshot-ref <objectiveStateSnapshotRef...>",
+        "Objective-state snapshot refs attached to the bundle"
+      ).option(
+        "--work-product-entry-ref <workProductEntryRef...>",
+        "Work-product ledger refs attached to the bundle"
+      ).option(
+        "--commitment-entry-ref <commitmentEntryRef...>",
+        "Commitment ledger refs attached to the bundle"
+      ).action(async (...args) => {
+        const options = args[0] ?? {};
+        const filePath = await runResumeBundleRecordCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          resumeBundleDir: orchestrator.config.resumeBundleDir,
+          creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
+          resumeBundlesEnabled: orchestrator.config.resumeBundlesEnabled,
+          bundle: {
+            schemaVersion: 1,
+            bundleId: String(options.bundleId ?? ""),
+            recordedAt: String(options.recordedAt ?? ""),
+            sessionKey: String(options.sessionKey ?? ""),
+            source: String(options.source ?? ""),
+            scope: String(options.scope ?? ""),
+            summary: String(options.summary ?? ""),
+            keyFacts: Array.isArray(options.keyFact) ? options.keyFact.map(String) : void 0,
+            nextActions: Array.isArray(options.nextAction) ? options.nextAction.map(String) : void 0,
+            riskFlags: Array.isArray(options.riskFlag) ? options.riskFlag.map(String) : void 0,
+            objectiveStateSnapshotRefs: Array.isArray(options.objectiveStateSnapshotRef) ? options.objectiveStateSnapshotRef.map(String) : void 0,
+            workProductEntryRefs: Array.isArray(options.workProductEntryRef) ? options.workProductEntryRef.map(String) : void 0,
+            commitmentEntryRefs: Array.isArray(options.commitmentEntryRef) ? options.commitmentEntryRef.map(String) : void 0
+          }
+        });
+        console.log(JSON.stringify({ wrote: filePath !== null, filePath }, null, 2));
+        console.log("OK");
+      });
+      cmd.command("resume-bundle-build").description("Build and persist a resume bundle from transcript recovery, objective state, work products, and open commitments").requiredOption("--bundle-id <bundleId>", "Resume bundle id").requiredOption("--recorded-at <recordedAt>", "ISO timestamp for the bundle").requiredOption("--session-key <sessionKey>", "Session key that owns the bundle").requiredOption("--scope <scope>", "Primary scope or recovery domain for the bundle").action(async (...args) => {
+        const options = args[0] ?? {};
+        const built = await runResumeBundleBuildCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          resumeBundleDir: orchestrator.config.resumeBundleDir,
+          objectiveStateStoreDir: orchestrator.config.objectiveStateStoreDir,
+          workProductLedgerDir: orchestrator.config.workProductLedgerDir,
+          commitmentLedgerDir: orchestrator.config.commitmentLedgerDir,
+          creationMemoryEnabled: orchestrator.config.creationMemoryEnabled,
+          resumeBundlesEnabled: orchestrator.config.resumeBundlesEnabled,
+          transcriptEnabled: orchestrator.config.transcriptEnabled,
+          objectiveStateMemoryEnabled: orchestrator.config.objectiveStateMemoryEnabled,
+          commitmentLedgerEnabled: orchestrator.config.commitmentLedgerEnabled,
+          bundleId: String(options.bundleId ?? ""),
+          recordedAt: String(options.recordedAt ?? ""),
+          sessionKey: String(options.sessionKey ?? ""),
+          scope: String(options.scope ?? "")
+        });
+        console.log(JSON.stringify({
+          wrote: built !== null,
+          filePath: built?.filePath ?? null,
+          bundle: built?.bundle ?? null
+        }, null, 2));
+        console.log("OK");
+      });
       cmd.command("commitment-status").description("Show commitment ledger status, entry counts, and the latest recorded commitment").action(async () => {
         const status = await runCommitmentStatusCliCommand({
           memoryDir: orchestrator.config.memoryDir,
@@ -30335,7 +30678,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path59.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path60.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -30558,8 +30901,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path59.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path59.join(memoryDir, "threads"));
+        const memoryDir = path60.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path60.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -31035,9 +31378,9 @@ async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
 }
 
 // src/index.ts
-import { readFile as readFile38, writeFile as writeFile37 } from "fs/promises";
+import { readFile as readFile38, writeFile as writeFile38 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path60 from "path";
+import path61 from "path";
 import os6 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 var ENGRAM_HOOK_APIS = "__openclawEngramHookApis";
@@ -31045,7 +31388,7 @@ function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os6.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path60.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path61.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -31295,11 +31638,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
                 `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
               );
               const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-              const signalPath = path60.join(
+              const signalPath = path61.join(
                 workspaceDir,
                 `.compaction-reset-signal-${safeSessionKey}`
               );
-              await writeFile37(
+              await writeFile38(
                 signalPath,
                 JSON.stringify({
                   sessionKey,
@@ -31326,7 +31669,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path60.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path61.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
@@ -31367,7 +31710,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile37(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile38(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
         log.info("auto-registered hourly summary cron job");
       } catch (err) {
         log.error("failed to auto-register hourly summary cron job:", err);