chainlesschain 0.166.10 → 0.166.13

package/src/commands/memory.js

@@ -69,6 +69,31 @@ export function openMemoryEditor(editor, filePath, deps = _deps) {
   });
 }
 
+async function resolveCanonicalMemory(ctx) {
+  const { createCliCanonicalMemoryService } =
+    await import("../lib/context-memory-kernel/index.js");
+  const legacyDb = ctx?.db?.getDatabase?.() || null;
+  const service = createCliCanonicalMemoryService({ legacyDb });
+  if (service.decision.canonical && ctx?.db) {
+    await service.migrateLegacyEntries(exportMemory(ctx.db.getDatabase()));
+  }
+  return service;
+}
+
+async function resolveScopedMemory() {
+  const [{ createCliCanonicalMemoryService }, { getMemoryStore }] =
+    await Promise.all([
+      import("../lib/context-memory-kernel/index.js"),
+      import("../lib/session-core-singletons.js"),
+    ]);
+  const service = createCliCanonicalMemoryService();
+  const legacyStore = getMemoryStore();
+  if (service.decision.canonical) {
+    await service.migrateLegacyScopedEntries(legacyStore.list());
+  }
+  return { service, legacyStore };
+}
+
 export function registerMemoryCommand(program) {
   const memory = program
     .command("memory")
@@ -145,15 +170,20 @@ export function registerMemoryCommand(program) {
     .action(async (options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
+        const service = await resolveCanonicalMemory(ctx);
+        if (!ctx.db && !service.decision.canonical) {
           logger.error("Database not available");
           process.exit(1);
         }
-        const db = ctx.db.getDatabase();
-        const entries = listMemory(db, {
-          limit: Math.max(1, parseInt(options.limit) || 20),
-          category: options.category,
-        });
+        const entries = service.decision.canonical
+          ? await service.list({
+              limit: Math.max(1, parseInt(options.limit) || 20),
+              category: options.category,
+            })
+          : listMemory(ctx.db.getDatabase(), {
+              limit: Math.max(1, parseInt(options.limit) || 20),
+              category: options.category,
+            });
 
         if (options.json) {
           console.log(JSON.stringify(entries, null, 2));
@@ -193,11 +223,14 @@ export function registerMemoryCommand(program) {
     .action(async (options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
+        const service = await resolveCanonicalMemory(ctx);
+        if (!ctx.db && !service.decision.canonical) {
           logger.error("Database not available");
           process.exit(1);
         }
-        const entries = exportMemory(ctx.db.getDatabase());
+        const entries = service.decision.canonical
+          ? await service.export()
+          : exportMemory(ctx.db.getDatabase());
         if (options.output) {
           const fs = await import("fs");
           fs.writeFileSync(options.output, JSON.stringify(entries), "utf-8");
@@ -240,11 +273,14 @@ export function registerMemoryCommand(program) {
           throw new Error("import: expected a JSON array of memory entries");
         }
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
+        const service = await resolveCanonicalMemory(ctx);
+        if (!ctx.db && !service.decision.canonical) {
           logger.error("Database not available");
           process.exit(1);
         }
-        const result = importMemory(ctx.db.getDatabase(), entries);
+        const result = service.decision.canonical
+          ? await service.import(entries)
+          : importMemory(ctx.db.getDatabase(), entries);
         if (options.json) {
           console.log(JSON.stringify(result));
         } else {
@@ -269,18 +305,27 @@ export function registerMemoryCommand(program) {
     .action(async (text, options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
+        const service = await resolveCanonicalMemory(ctx);
+        if (!ctx.db && !service.decision.canonical) {
           logger.error("Database not available");
           process.exit(1);
         }
-        const db = ctx.db.getDatabase();
-        const entry = addMemory(db, text, {
+        const normalizedOptions = {
           category: options.category,
           importance: Math.max(
             1,
             Math.min(5, parseInt(options.importance) || 3),
           ),
-        });
+        };
+        let entry;
+        if (service.decision.canonical) {
+          entry = await service.add(text, normalizedOptions);
+        } else {
+          if (service.decision.shadow) {
+            service.validateLegacyProposal(text, normalizedOptions);
+          }
+          entry = addMemory(ctx.db.getDatabase(), text, normalizedOptions);
+        }
 
         if (options.json) {
           console.log(JSON.stringify(entry, null, 2));
@@ -307,14 +352,18 @@ export function registerMemoryCommand(program) {
     .action(async (query, options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
+        const service = await resolveCanonicalMemory(ctx);
+        if (!ctx.db && !service.decision.canonical) {
           logger.error("Database not available");
           process.exit(1);
         }
-        const db = ctx.db.getDatabase();
-        const results = searchMemory(db, query, {
-          limit: Math.max(1, parseInt(options.limit) || 20),
-        });
+        const limit = Math.max(1, parseInt(options.limit) || 20);
+        const recalled = service.decision.canonical
+          ? await service.search(query, { limit })
+          : null;
+        const results = service.decision.canonical
+          ? recalled.entries
+          : searchMemory(ctx.db.getDatabase(), query, { limit });
 
         if (options.json) {
           console.log(JSON.stringify(results, null, 2));
@@ -351,14 +400,28 @@ export function registerMemoryCommand(program) {
     .action(async (id) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
+        const service = await resolveCanonicalMemory(ctx);
+        if (!ctx.db && !service.decision.canonical) {
           logger.error("Database not available");
           process.exit(1);
         }
-        const db = ctx.db.getDatabase();
-        const ok = deleteMemory(db, id);
+        const deletion = service.decision.canonical
+          ? await service.delete(id)
+          : null;
+        const ok = service.decision.canonical
+          ? deletion?.status === "purged"
+          : deleteMemory(ctx.db.getDatabase(), id);
         if (ok) {
-          logger.success("Memory entry deleted");
+          logger.success(
+            service.decision.canonical
+              ? `Memory entry deleted (${deletion.digest})`
+              : "Memory entry deleted",
+          );
+        } else if (deletion) {
+          logger.warn(
+            `Memory deletion is ${deletion.status}; reconcile request ${deletion.requestId} before treating it as globally purged`,
+          );
+          process.exitCode = 2;
         } else {
           logger.error(`Memory entry not found: ${id}`);
         }
@@ -370,6 +433,35 @@ export function registerMemoryCommand(program) {
       }
     });
 
+  memory
+    .command("reconcile")
+    .description("Resume a pending canonical memory deletion")
+    .argument("<operation-id>", "Deletion request ID")
+    .option("--json", "Output the reconciliation receipt as JSON")
+    .action(async (operationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const service = await resolveCanonicalMemory(ctx);
+        if (!service.decision.canonical) {
+          throw new Error("memory reconcile requires canonical Context/Memory");
+        }
+        const result = await service.reconcile(operationId);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else if (result.status === "purged") {
+          logger.success(`Memory deletion reconciled: ${result.digest}`);
+        } else {
+          logger.warn(
+            `Memory deletion remains ${result.status}: ${result.reason || operationId}`,
+          );
+          process.exitCode = 2;
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // memory daily
   memory
     .command("daily")
@@ -382,6 +474,7 @@ export function registerMemoryCommand(program) {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
         const memoryDir = getMemoryDir(ctx.env.dataDir);
+        const service = await resolveCanonicalMemory(ctx);
 
         if (options.list) {
           const notes = listDailyNotes(memoryDir);
@@ -402,8 +495,21 @@ export function registerMemoryCommand(program) {
         }
 
         if (options.append) {
-          const result = appendDailyNote(memoryDir, options.append);
-          logger.success(`Added to daily note: ${chalk.cyan(result.date)}`);
+          const today = new Date().toISOString().slice(0, 10);
+          if (service.decision.canonical) {
+            await service.addScoped(options.append, {
+              scope: "user",
+              scopeId: "local-user",
+              category: "daily-note",
+              tags: ["daily-note", `date:${today}`],
+              source: "cli-memory-daily",
+              evidenceStore: "cli-command",
+              evidenceId: `daily-${today}`,
+            });
+          } else {
+            appendDailyNote(memoryDir, options.append);
+          }
+          logger.success(`Added to daily note: ${chalk.cyan(today)}`);
           await shutdown();
           return;
         }
@@ -443,23 +549,23 @@ export function registerMemoryCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (query, options) => {
       try {
-        const { getMemoryStore } =
-          await import("../lib/session-core-singletons.js");
-        const store = getMemoryStore();
+        const { service, legacyStore } = await resolveScopedMemory();
         const tags = options.tags
           ? options.tags
               .split(",")
               .map((t) => t.trim())
               .filter(Boolean)
           : null;
-        const results = store.recall({
-          query: query || "",
+        const recallOptions = {
           scope: options.scope,
           scopeId: options.scopeId,
           category: options.category,
           tags,
           limit: Math.max(1, parseInt(options.limit) || 10),
-        });
+        };
+        const results = service.decision.canonical
+          ? (await service.recallScoped(query || "", recallOptions)).results
+          : legacyStore.recall({ query: query || "", ...recallOptions });
 
         if (options.json) {
           console.log(JSON.stringify(results, null, 2));
@@ -494,22 +600,28 @@ export function registerMemoryCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (content, options) => {
       try {
-        const { getMemoryStore } =
-          await import("../lib/session-core-singletons.js");
-        const store = getMemoryStore();
+        const { service, legacyStore } = await resolveScopedMemory();
         const tags = options.tags
           ? options.tags
               .split(",")
               .map((t) => t.trim())
               .filter(Boolean)
           : [];
-        const m = store.add({
+        const proposal = {
           scope: options.scope,
           scopeId: options.scopeId || null,
           category: options.category,
-          content,
           tags,
-        });
+        };
+        let m;
+        if (service.decision.canonical) {
+          m = await service.addScoped(content, proposal);
+        } else {
+          if (service.decision.shadow) {
+            service.validateLegacyScopedProposal(content, proposal);
+          }
+          m = legacyStore.add({ content, ...proposal });
+        }
         if (options.json) console.log(JSON.stringify(m, null, 2));
         else
           logger.success(
@@ -576,11 +688,58 @@ export function registerMemoryCommand(program) {
           return;
         }
 
-        const result = await consolidateJsonlSession(options.session, {
-          scope: options.scope,
-          scopeId: options.scopeId || null,
-          agentId: options.agentId || null,
-        });
+        const { service } = await resolveScopedMemory();
+        let result;
+        if (service.decision.canonical) {
+          const { readEvents } =
+            await import("../harness/jsonl-session-store.js");
+          const { defaultMemoryExtractor } =
+            await import("@chainlesschain/session-core");
+          const events = readEvents(options.session);
+          const trace = buildTraceStoreFromJsonl(options.session, events);
+          const traceEvents = trace.query(options.session, {
+            limit: Number.MAX_SAFE_INTEGER,
+          });
+          const facts = defaultMemoryExtractor(traceEvents);
+          const scope = options.scope || "agent";
+          const scopeId =
+            scope === "global"
+              ? null
+              : options.scopeId ||
+                (scope === "session"
+                  ? options.session
+                  : options.agentId || options.session);
+          const written = [];
+          for (const [index, fact] of facts.entries()) {
+            written.push(
+              await service.addScoped(String(fact.content || ""), {
+                scope,
+                scopeId,
+                category: fact.category || "general",
+                tags: fact.tags || [],
+                score: fact.score,
+                source: "cli-session-consolidator",
+                evidenceStore: "cli-jsonl-session",
+                evidenceId: `${options.session}-${index}`,
+              }),
+            );
+          }
+          result = {
+            sessionId: options.session,
+            scope,
+            scopeId,
+            eventCount: traceEvents.length,
+            factCount: facts.length,
+            writtenCount: written.length,
+            written,
+          };
+        } else {
+          result = await consolidateJsonlSession(options.session, {
+            scope: options.scope,
+            scopeId: options.scopeId || null,
+            agentId: options.agentId || null,
+          });
+        }
         await new Promise((r) => setImmediate(r)); // let adapter flush
 
         if (options.json) {
@@ -613,8 +772,16 @@ export function registerMemoryCommand(program) {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
         const memoryDir = getMemoryDir(ctx.env.dataDir);
         const content = getMemoryFile(memoryDir);
+        const service = await resolveCanonicalMemory(ctx);
 
         if (options.edit) {
+          if (service.decision.canonical) {
+            const error = new Error(
+              "MEMORY.md is a read-only legacy projection after canonical cutover; use 'cc memory add' instead",
+            );
+            error.code = "legacy_writer_fenced";
+            throw error;
+          }
           const editor =
             process.env.EDITOR ||
             process.env.VISUAL ||

package/src/commands/promcomp.js

@@ -31,12 +31,29 @@ import {
   autoFailStuckPcompRunsV2,
   getPromptCompressorGovStatsV2,
 } from "../lib/prompt-compressor.js";
+import {
+  assertLegacyMutationAllowed,
+  resolveCliContextMemoryCutover,
+} from "../lib/context-memory-kernel/authority.js";
 
 export function registerPromcompCommand(program) {
   const pc = program
     .command("promcomp")
     .description("Prompt Compressor V2 governance (in-memory, CLI v0.143.0)");
 
+  pc.hook("preAction", (_thisCommand, actionCommand) => {
+    const decision = resolveCliContextMemoryCutover({
+      scopeKey: `cli:promcomp:${actionCommand.name()}`,
+    });
+    try {
+      assertLegacyMutationAllowed(decision);
+    } catch (error) {
+      error.message += "; use `cc context` or `cc compact`";
+      error.replacement = "cc compact";
+      throw error;
+    }
+  });
+
   pc.command("enums-v2")
     .description("Show V2 enums")
     .action(() =>

package/src/commands/serve.js

@@ -8,7 +8,7 @@ import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 import path from "node:path";
 
 export function registerServeCommand(program) {
-  program
+  const serve = program
     .command("serve")
     .description("Start WebSocket server for remote CLI access")
     .option(
@@ -21,7 +21,15 @@ export function registerServeCommand(program) {
     )
     .option(
       "--app-server-state-dir <path>",
-      "Owner-controlled rollout directory for --app-server",
+      "Owner-controlled rollout directory (JSONL directory or SQLite parent)",
+    )
+    .option(
+      "--app-server-state-path <path>",
+      "Exact JSONL directory or SQLite database path for --app-server",
+    )
+    .option(
+      "--app-server-store <backend>",
+      "Physical rollout adapter: jsonl or sqlite (default: jsonl)",
     )
     .option(
       "--app-server-queue-cap <n>",
@@ -74,20 +82,32 @@ export function registerServeCommand(program) {
         if (opts.appServerWebsocket && !opts.appServer) {
           throw new Error("--app-server-websocket requires --app-server");
         }
+        if (opts.appServerStateDir && opts.appServerStatePath) {
+          throw new Error(
+            "--app-server-state-dir and --app-server-state-path are mutually exclusive",
+          );
+        }
         if (opts.appServer) {
           const [
             { runStdioAppServer },
-            { JsonlRolloutStore },
+            { closeRolloutStore, createRolloutStore },
             { CliAgentKernelAdapter },
           ] = await Promise.all([
             import("../lib/app-server/stdio-transport.js"),
-            import("../lib/app-server/rollout-store.js"),
+            import("../lib/app-server/rollout-store-factory.js"),
             import("../lib/app-server/cli-agent-kernel-adapter.js"),
           ]);
           const stateDirectory = opts.appServerStateDir
             ? path.resolve(opts.appServerStateDir)
             : undefined;
-          const store = new JsonlRolloutStore({ directory: stateDirectory });
+          const statePath = opts.appServerStatePath
+            ? path.resolve(opts.appServerStatePath)
+            : undefined;
+          const store = createRolloutStore({
+            backend: opts.appServerStore,
+            directory: stateDirectory,
+            location: statePath,
+          });
           const cwd = opts.project ? path.resolve(opts.project) : process.cwd();
           const maxQueuedRequests = Math.max(
             1,
@@ -127,14 +147,19 @@ export function registerServeCommand(program) {
               process.off("SIGTERM", shutdown);
               host.off("error", fail);
               await host.close();
+              closeRolloutStore(store);
             }
             return;
           }
-          await runStdioAppServer({
-            store,
-            kernel: new CliAgentKernelAdapter({ cwd }),
-            maxQueuedRequests,
-          });
+          try {
+            await runStdioAppServer({
+              store,
+              kernel: new CliAgentKernelAdapter({ cwd }),
+              maxQueuedRequests,
+            });
+          } finally {
+            closeRolloutStore(store);
+          }
           return;
         }
         const runtime = createAgentRuntimeFactory().createServerRuntime({
@@ -156,4 +181,63 @@ export function registerServeCommand(program) {
         process.exit(1);
       }
     });
+
+  serve
+    .command("migrate-rollouts")
+    .description(
+      "Verify or copy canonical rollouts between physical storage adapters",
+    )
+    .requiredOption("--from <backend>", "Source adapter: jsonl or sqlite")
+    .requiredOption(
+      "--from-path <path>",
+      "Source JSONL directory or SQLite database file",
+    )
+    .requiredOption("--to <backend>", "Target adapter: jsonl or sqlite")
+    .requiredOption(
+      "--to-path <path>",
+      "Target JSONL directory or SQLite database file",
+    )
+    .option(
+      "--thread <id...>",
+      "Migrate only the named thread ids (otherwise enumerate the source)",
+    )
+    .option(
+      "--apply",
+      "Copy verified records; without this flag the command is a dry run",
+    )
+    .action(async (opts) => {
+      const { closeRolloutStore, createRolloutStore } =
+        await import("../lib/app-server/rollout-store-factory.js");
+      let source;
+      let target;
+      try {
+        source = createRolloutStore({
+          backend: opts.from,
+          location: path.resolve(opts.fromPath),
+        });
+        target = createRolloutStore({
+          backend: opts.to,
+          location: path.resolve(opts.toPath),
+        });
+        const result = source.migrate({
+          targetStore: target,
+          threadIds: opts.thread || null,
+          dryRun: opts.apply !== true,
+        });
+        process.stdout.write(
+          `${JSON.stringify(
+            {
+              ...result,
+              source: { backend: source.backend, location: source.location },
+              target: { backend: target.backend, location: target.location },
+            },
+            null,
+            2,
+          )}\n`,
+        );
+      } finally {
+        closeRolloutStore(target);
+        closeRolloutStore(source);
+      }
+    });
 }

package/src/commands/session.js

@@ -1463,9 +1463,8 @@ export function registerSessionCommand(program) {
           await import("../lib/session-core-singletons.js");
         const gate = await getApprovalGate();
         if (options.set) {
-          gate.setSessionPolicy(id, options.set);
-          // give persistence a tick before the CLI process exits
-          await new Promise((r) => setImmediate(r));
+          await gate.setSessionPolicy(id, options.set);
+          await gate.awaitPersistence?.();
           logger.success(
             `Session ${chalk.gray(id.slice(0, 12))} policy → ${chalk.cyan(options.set)}`,
           );

package/src/commands/team.js

@@ -3283,6 +3283,13 @@ export function registerTeamCommand(program, { logger } = {}) {
             tasksByGovernanceKey.get(governanceKey)?.push(task);
           }
           for (const [key, tasks] of tasksByGovernanceKey) {
+            // A unit settled by afterTask is immutable. Graph cancellation can
+            // subsequently project the registry task as cancelled; do not mask
+            // the original terminal outcome with a forbidden second settlement.
+            const currentStatus = collaborationUnits.get(key)?.status;
+            if (["completed", "failed", "cancelled"].includes(currentStatus)) {
+              continue;
+            }
             const states = tasks.map((task) =>
               String(task.status || "").toLowerCase(),
             );
@@ -3295,7 +3302,6 @@ export function registerTeamCommand(program, { logger } = {}) {
                     )
                   ? "cancelled"
                   : "failed";
-            if (collaborationUnits.get(key)?.status === status) continue;
             settleGovernance(key, status, {
               endedAt: Date.now(),
             });