chainlesschain 0.166.9 → 0.166.13

package/src/lib/app-server/server.js

@@ -1,9 +1,20 @@
 import { createHash, randomUUID } from "node:crypto";
 import { BoundedAsyncQueue, QueueOverloadedError } from "./bounded-queue.js";
 import { CliAgentKernelAdapter } from "./cli-agent-kernel-adapter.js";
-import { JsonlRolloutStore } from "./rollout-store.js";
+import { assertRolloutStore } from "./rollout-store.js";
+import {
+  closeRolloutStore,
+  createRolloutStore,
+} from "./rollout-store-factory.js";
 import { AppServerGraphRuntime } from "./graph-runtime.js";
 import { compileGraphDefinition } from "../graph-kernel/compiler.js";
+import { createCliContextMemoryRuntime } from "../context-memory-kernel/runtime.js";
+import {
+  contextPlanCreatedNotification,
+  memoryDeletionNotification,
+  memoryMutationNotification,
+  memoryRecalledNotification,
+} from "./context-memory-notifications.js";
 import {
   APP_SERVER_MIN_PROTOCOL_VERSION,
   APP_SERVER_PROTOCOL_VERSION,
@@ -19,7 +30,6 @@ import {
 } from "./protocol.js";
 
 const TERMINAL_TURN_STATUSES = new Set(["completed", "failed", "interrupted"]);
-
 function stableValue(value) {
   if (Array.isArray(value)) return value.map(stableValue);
   if (!value || typeof value !== "object") return value;
@@ -96,13 +106,34 @@ function publicError(error) {
   ) {
     return new JsonRpcError(JSON_RPC_ERROR.CONFLICT, error.message);
   }
+  if (error?.code === "invalid_argument") {
+    return new JsonRpcError(
+      JSON_RPC_ERROR.INVALID_PARAMS,
+      error.message,
+      error.details || null,
+    );
+  }
+  if (
+    [
+      "revision_conflict",
+      "legacy_writer_fenced",
+      "scope_denied",
+      "replica_tombstone_fenced",
+    ].includes(error?.code)
+  ) {
+    return new JsonRpcError(
+      JSON_RPC_ERROR.CONFLICT,
+      error.message,
+      error.details || null,
+    );
+  }
   return error;
 }
 
 export class CcAppServer {
   constructor({
     send,
-    store = new JsonlRolloutStore(),
+    store = null,
     kernel = new CliAgentKernelAdapter(),
     now = Date.now,
     createId = randomUUID,
@@ -113,22 +144,31 @@ export class CcAppServer {
     interruptSettlementMs = 30_000,
     transport = "stdio",
     graphRuntime = null,
+    contextMemoryRuntimeFactory = createCliContextMemoryRuntime,
   } = {}) {
     if (typeof send !== "function") {
       throw new TypeError("CcAppServer requires a send(message) function");
     }
+    const resolvedStore = assertRolloutStore(store || createRolloutStore(), {
+      requireList: true,
+    });
     this.send = send;
-    this.store = store;
+    this.store = resolvedStore;
+    this._ownsStore = store == null;
     this.kernel = kernel;
     this.now = now;
     this.createId = createId;
     this.requestTimeoutMs = requestTimeoutMs;
     this.interruptSettlementMs = interruptSettlementMs;
     this.transport = transport === "websocket" ? "websocket" : "stdio";
+    if (typeof contextMemoryRuntimeFactory !== "function") {
+      throw new TypeError("contextMemoryRuntimeFactory must be a function");
+    }
+    this.contextMemoryRuntimeFactory = contextMemoryRuntimeFactory;
     this.graphRuntime =
       graphRuntime ||
       new AppServerGraphRuntime({
-        rolloutStore: store,
+        rolloutStore: resolvedStore,
         now,
         createId,
         executeNode: (context) => this._executeGraphNode(context),
@@ -299,6 +339,13 @@ export class CcAppServer {
       "graph/history": () => this._graphHistory(message.params),
       "graph/cancel": () => this._graphCancel(message.params),
       "graph/reconcile": () => this._graphReconcile(message.params),
+      "context/plan": () => this._contextPlan(message.params),
+      "context/compact": () => this._contextCompact(message.params),
+      "memory/recall": () => this._memoryRecall(message.params),
+      "memory/propose": () => this._memoryPropose(message.params),
+      "memory/decide": () => this._memoryDecide(message.params),
+      "memory/delete": () => this._memoryDelete(message.params),
+      "memory/reconcile": () => this._memoryReconcile(message.params),
     };
     const handler = handlers[method];
     if (!handler) {
@@ -353,6 +400,132 @@ export class CcAppServer {
     });
   }
 
+  _contextMemoryRuntime(options = {}) {
+    const runtime = this.contextMemoryRuntimeFactory(options);
+    if (!runtime?.kernel) {
+      throw new Error("Context/Memory runtime factory returned no kernel");
+    }
+    return runtime;
+  }
+
+  async _contextPlan(rawParams) {
+    const params = requireObject(rawParams);
+    const runtime = this._contextMemoryRuntime({
+      scopeKey: `app-server:context:${params.sessionHead || "plan"}`,
+    });
+    try {
+      const plan = await runtime.kernel.planContext(params);
+      const notification = contextPlanCreatedNotification(plan);
+      await this._notify(notification.method, notification.params);
+      return plan;
+    } catch (error) {
+      await this._notify("context/event", {
+        type: "context.plan.rejected",
+        reason_code: safeId(error?.code, "context_plan_failed"),
+      });
+      throw error;
+    }
+  }
+
+  async _contextCompact(rawParams) {
+    const params = requireObject(rawParams);
+    const sessionId = requiredString(params.sessionId, "sessionId");
+    const operationId = requiredString(params.operationId, "operationId");
+    const runtime = this._contextMemoryRuntime({ sessionId });
+    await this._notify("context/event", {
+      type: "context.compaction.started",
+      operation_id: operationId,
+      session_id: sessionId,
+    });
+    try {
+      const receipt = await runtime.kernel.compactContext(params);
+      const type =
+        receipt.status === "reconciliation_required"
+          ? "context.compaction.reconciliation_required"
+          : ["committed", "degraded"].includes(receipt.status)
+            ? "context.compaction.committed"
+            : "context.compaction.aborted";
+      await this._notify("context/event", {
+        type,
+        operation_id: operationId,
+        session_id: sessionId,
+        ...(type === "context.compaction.aborted"
+          ? { reason_code: safeId(receipt.status, "compaction_aborted") }
+          : { receipt }),
+      });
+      return receipt;
+    } catch (error) {
+      await this._notify("context/event", {
+        type: "context.compaction.aborted",
+        operation_id: operationId,
+        session_id: sessionId,
+        reason_code: safeId(error?.code, "compaction_failed"),
+      });
+      throw error;
+    }
+  }
+
+  async _memoryRecall(rawParams) {
+    const params = requireObject(rawParams);
+    const runtime = this._contextMemoryRuntime({
+      scopeKey: "app-server:memory",
+    });
+    const result = await runtime.kernel.recallMemory(params);
+    const notification = memoryRecalledNotification(result);
+    await this._notify(notification.method, notification.params);
+    return result;
+  }
+
+  async _memoryPropose(rawParams) {
+    const params = requireObject(rawParams);
+    const runtime = this._contextMemoryRuntime({
+      scopeKey: "app-server:memory",
+    });
+    const mutation = await runtime.kernel.proposeMemory(params);
+    await this._notifyMemoryMutation(mutation);
+    return mutation;
+  }
+
+  async _memoryDecide(rawParams) {
+    const params = requireObject(rawParams);
+    const runtime = this._contextMemoryRuntime({
+      scopeKey: "app-server:memory",
+    });
+    const mutation = await runtime.kernel.decideMemory(params);
+    await this._notifyMemoryMutation(mutation);
+    return mutation;
+  }
+
+  async _notifyMemoryMutation(mutation) {
+    const notification = memoryMutationNotification(mutation);
+    if (!notification) return;
+    await this._notify(notification.method, notification.params);
+  }
+
+  async _memoryDelete(rawParams) {
+    const params = requireObject(rawParams);
+    const runtime = this._contextMemoryRuntime({
+      scopeKey: "app-server:memory",
+    });
+    const receipt = await runtime.kernel.deleteMemory(params);
+    const notification = memoryDeletionNotification(receipt);
+    await this._notify(notification.method, notification.params);
+    return receipt;
+  }
+
+  async _memoryReconcile(rawParams) {
+    const params = requireObject(rawParams);
+    const operationId = requiredString(params.operationId, "operationId");
+    const runtime = this._contextMemoryRuntime({
+      scopeKey: "app-server:memory",
+    });
+    const result = await runtime.kernel.reconcile(operationId);
+    const notification = memoryDeletionNotification(result, operationId);
+    if (notification)
+      await this._notify(notification.method, notification.params);
+    return result;
+  }
+
   _graphCompile(rawParams) {
     const params = requireObject(rawParams);
     const compiled = compileGraphDefinition(
@@ -1115,7 +1288,11 @@ export class CcAppServer {
       );
     }
     this.pendingClientRequests.clear();
-    await this.kernel.close?.();
-    await Promise.all(this.workers);
+    try {
+      await this.kernel.close?.();
+      await Promise.all(this.workers);
+    } finally {
+      if (this._ownsStore) closeRolloutStore(this.store);
+    }
   }
 }

package/src/lib/app-server/sqlite-rollout-store.js

@@ -6,17 +6,32 @@ import { createRequire } from "node:module";
 import {
   ROLLOUT_STORE_SCHEMA,
   ROLLOUT_STORE_VERSION,
+  migrateRolloutStore,
   _rolloutStoreInternals,
 } from "./rollout-store.js";
 
-const { buildRecord, canonicalJson, projectThread, verifyRecords } =
-  _rolloutStoreInternals;
+const {
+  assertExpectedHead,
+  buildRecord,
+  canonicalJson,
+  projectThread,
+  startPayload,
+  verifyRecords,
+} = _rolloutStoreInternals;
 
 let DatabaseSync = null;
-try {
-  ({ DatabaseSync } = createRequire(import.meta.url)("node:sqlite"));
-} catch {
-  // node:sqlite is optional on the minimum supported Node 22.12 runtime.
+let sqliteProbed = false;
+
+function loadDatabaseSync() {
+  if (!sqliteProbed) {
+    sqliteProbed = true;
+    try {
+      ({ DatabaseSync } = createRequire(import.meta.url)("node:sqlite"));
+    } catch {
+      // node:sqlite is optional on the minimum supported Node 22.12 runtime.
+    }
+  }
+  return DatabaseSync;
 }
 
 function sqliteError(code, message, cause = null) {
@@ -40,7 +55,7 @@ function recordThreadId(input) {
 }
 
 export function sqliteRolloutStoreAvailable() {
-  return typeof DatabaseSync === "function";
+  return typeof loadDatabaseSync() === "function";
 }
 
 export class SqliteRolloutStore {
@@ -50,13 +65,14 @@ export class SqliteRolloutStore {
     if (this.filename !== ":memory:") {
       fs.mkdirSync(path.dirname(this.filename), { recursive: true });
     }
-    if (!database && !sqliteRolloutStoreAvailable()) {
+    const SqliteDatabase = database ? null : loadDatabaseSync();
+    if (!database && typeof SqliteDatabase !== "function") {
       throw sqliteError(
         "CC_ROLLOUT_SQLITE_UNAVAILABLE",
         "SQLite rollout storage requires a Node runtime with node:sqlite",
       );
     }
-    this.db = database || new DatabaseSync(this.filename);
+    this.db = database || new SqliteDatabase(this.filename);
     this.db.exec("PRAGMA journal_mode = WAL");
     this.db.exec("PRAGMA synchronous = FULL");
     this.db.exec("PRAGMA foreign_keys = ON");
@@ -148,6 +164,7 @@ export class SqliteRolloutStore {
     title = null,
     parentThreadId = null,
     metadata = {},
+    timestamp: startedAt = null,
   } = {}) {
     const id = recordThreadId(threadId);
     return this._transaction(() => {
@@ -158,7 +175,8 @@ export class SqliteRolloutStore {
           threadId: id,
           eventType: "thread.started",
           idempotencyKey: `thread:${id}`,
-          payload: { title, parentThreadId, metadata },
+          timestamp: startedAt || undefined,
+          payload: startPayload({ title, parentThreadId, metadata }),
         },
         null,
         this.now,
@@ -199,6 +217,7 @@ export class SqliteRolloutStore {
         }
         return clone(duplicate);
       }
+      assertExpectedHead(input, records);
       const record = buildRecord(input, records.at(-1), this.now);
       this.db
         .prepare(
@@ -237,7 +256,7 @@ export class SqliteRolloutStore {
       .map((threadId) => this.resume(threadId))
       .filter((thread) => includeArchived || thread.status !== "archived")
       .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
-      .slice(0, Math.max(1, Number(limit) || 100));
+      .slice(0, Math.max(1, Math.min(100_000, Number(limit) || 100)));
   }
 
   forkThread(sourceThreadId, { threadId = randomUUID(), title = null } = {}) {
@@ -261,6 +280,10 @@ export class SqliteRolloutStore {
     return this.resume(target.id);
   }
 
+  fork(sourceThreadId, options = {}) {
+    return this.forkThread(sourceThreadId, options);
+  }
+
   checkpoint(threadId, payload = {}) {
     return this.append({
       threadId,
@@ -271,13 +294,19 @@ export class SqliteRolloutStore {
   }
 
   compact(threadId, options = {}) {
+    if (typeof options.summary !== "string" || !options.summary.trim()) {
+      throw sqliteError(
+        "CC_ROLLOUT_INVALID_ARGUMENT",
+        "compaction summary is required",
+      );
+    }
     return this.append({
       threadId,
       eventType: "rollout.compacted",
       idempotencyKey: options.idempotencyKey || null,
       payload: {
-        summary: String(options.summary || ""),
-        retainedState: options.retainedState || {},
+        summary: options.summary,
+        retainedState: options.retainedState ?? {},
       },
     });
   }
@@ -292,11 +321,25 @@ export class SqliteRolloutStore {
     return this.resume(threadId);
   }
 
-  migrate({ fromVersion = 1, toVersion = 1, dryRun = true } = {}) {
+  migrate({
+    fromVersion = 1,
+    toVersion = 1,
+    dryRun = true,
+    targetStore = null,
+    threadIds = null,
+  } = {}) {
+    if (targetStore) {
+      return migrateRolloutStore({
+        sourceStore: this,
+        targetStore,
+        threadIds,
+        dryRun,
+      });
+    }
     if (Number(fromVersion) !== 1 || Number(toVersion) !== 1) {
       throw sqliteError(
-        "CC_ROLLOUT_VERSION_UNSUPPORTED",
-        "SQLite rollout adapter currently supports schema v1 only",
+        "CC_ROLLOUT_MIGRATION_UNSUPPORTED",
+        `rollout migration ${fromVersion} -> ${toVersion} is unsupported`,
       );
     }
     return Object.freeze({

package/src/lib/auto-mode-config.js

@@ -321,6 +321,12 @@ export function createAutoModeApprovalGate(inner, resolved, opts = {}) {
     clearSessionPolicy(sessionId) {
       return inner?.clearSessionPolicy?.(sessionId);
     },
+    awaitPersistence() {
+      return inner?.awaitPersistence?.();
+    },
+    hasPolicyStore() {
+      return inner?.hasPolicyStore?.() === true;
+    },
     setConfirmer(fn) {
       confirm = typeof fn === "function" ? fn : null;
       inner?.setConfirmer?.(fn);
@@ -360,6 +366,26 @@ export function createAutoModeApprovalGate(inner, resolved, opts = {}) {
       return inner?.createAuthorizationBinder?.() || null;
     },
     async decide(ctx = {}) {
+      const shouldCheckPersistence =
+        typeof inner?.awaitPersistence === "function" &&
+        (typeof inner?.hasPolicyStore !== "function" ||
+          inner.hasPolicyStore() === true);
+      if (shouldCheckPersistence) {
+        try {
+          await inner.awaitPersistence();
+        } catch (error) {
+          return {
+            decision: "deny",
+            via: "policy-store-error",
+            base: "deny",
+            policy: "auto-mode",
+            riskLevel: RISK_LEVELS.includes(ctx.riskLevel)
+              ? ctx.riskLevel
+              : "low",
+            error,
+          };
+        }
+      }
       if (!isActive()) return inner.decide(ctx);
       const riskLevel = RISK_LEVELS.includes(ctx.riskLevel)
         ? ctx.riskLevel

package/src/lib/causal-observability.js

@@ -532,6 +532,11 @@ function modelUsageBoundaryIdentity(data, field) {
     ),
     model: boundedLabel(data.model, `${field} model`, MAX_MODEL_LENGTH),
     source: normalizedUsageSource(data.source, `${field} source`),
+    operationId: boundedLabel(
+      data.operationId,
+      `${field} operationId`,
+      MAX_ID_LENGTH,
+    ),
   };
 }
 
@@ -539,7 +544,8 @@ function sameModelUsageIdentity(left, right) {
   return (
     left.provider === right.provider &&
     left.model === right.model &&
-    left.source === right.source
+    left.source === right.source &&
+    left.operationId === right.operationId
   );
 }
 
@@ -641,6 +647,11 @@ function strictUsage(event) {
   }
   return {
     callId,
+    operationId: boundedLabel(
+      data.operationId,
+      "session usage operationId",
+      MAX_ID_LENGTH,
+    ),
     provider: usageIdentity(
       data,
       raw,
@@ -1047,6 +1058,7 @@ export function createVerifiedSessionObservabilityProjection(
             provider: usage.provider,
             model: usage.model,
             source: usage.source,
+            operationId: usage.operationId,
           };
           if (previous && !sameModelUsageIdentity(previous, identity)) {
             throw new Error(

package/src/lib/context-memory-kernel/authority.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import {
+  ContextMemoryAuthorityRegistry,
+  CUTOVER_STAGES,
+} from "@chainlesschain/context-memory-kernel";
+
+const STAGE_ENV = "CHAINLESSCHAIN_CONTEXT_MEMORY_CLI_STAGE";
+const OPT_IN_ENV = "CHAINLESSCHAIN_CONTEXT_MEMORY_CLI_OPT_IN";
+const CANARY_PERCENT_ENV = "CHAINLESSCHAIN_CONTEXT_MEMORY_CLI_CANARY_PERCENT";
+
+function boundedPercent(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(0, Math.min(100, parsed));
+}
+
+function cohortBucket(scopeKey) {
+  const digest = createHash("sha256").update(scopeKey).digest();
+  return digest.readUInt32BE(0) % 10_000;
+}
+
+export function resolveCliContextMemoryCutover({
+  env = process.env,
+  scopeKey = "cli:global",
+} = {}) {
+  const stage = env[STAGE_ENV] || "shadow";
+  if (!CUTOVER_STAGES.includes(stage)) {
+    const error = new Error(`Unsupported CLI Context/Memory stage: ${stage}`);
+    error.code = "CONTEXT_MEMORY_STAGE_INVALID";
+    throw error;
+  }
+  let canonical = false;
+  let reason = stage;
+  if (stage === "internal_canary") {
+    const percent = boundedPercent(env[CANARY_PERCENT_ENV], 1);
+    canonical = cohortBucket(scopeKey) < percent * 100;
+    reason = canonical ? "internal_canary_selected" : "internal_canary_control";
+  } else if (stage === "opt_in_canary") {
+    canonical = env[OPT_IN_ENV] === "1";
+    reason = canonical ? "explicit_opt_in" : "not_opted_in";
+  } else if (
+    ["canonical_default", "legacy_read_only", "retired"].includes(stage)
+  ) {
+    canonical = true;
+  }
+  return Object.freeze({
+    stage,
+    scopeKey,
+    mode: canonical ? "canonical" : "legacy",
+    canonical,
+    shadow: stage === "shadow",
+    // A selected canonical cohort must never run a second legacy writer. This
+    // also covers canonical_default; legacy_read_only/retired only tighten the
+    // corresponding read capability.
+    legacyWritable: !canonical,
+    legacyReadable: stage !== "retired",
+    reason,
+    cohortBucket: cohortBucket(scopeKey),
+  });
+}
+
+export function createCliAuthority({ decision, now = Date.now } = {}) {
+  if (!decision?.canonical) return { registry: null, writer: null };
+  const registry = new ContextMemoryAuthorityRegistry({ clock: now });
+  const writer = Object.freeze({
+    scopeKey: decision.scopeKey,
+    surface: "cli",
+    mode: "canonical",
+    writerId: "cli-context-memory-kernel",
+    generation: 1,
+  });
+  registry.bind({
+    ...writer,
+    stage: decision.stage,
+    leaseExpiresAt: new Date(Number(now()) + 5 * 60_000).toISOString(),
+  });
+  registry.assertWriter(writer);
+  return { registry, writer };
+}
+
+export function assertLegacyMutationAllowed(decision) {
+  if (decision?.legacyWritable) return;
+  const error = new Error(
+    `Legacy CLI Context/Memory mutations are fenced at ${decision?.stage || "unknown"}`,
+  );
+  error.code = "legacy_writer_fenced";
+  throw error;
+}
+
+export {
+  CANARY_PERCENT_ENV,
+  OPT_IN_ENV,
+  STAGE_ENV,
+  cohortBucket,
+};