chainlesschain 0.166.10 → 0.166.13

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

@@ -0,0 +1,192 @@
+import {
+  canonicalDigest,
+  canonicalJson,
+  normalizeContextItem,
+} from "@chainlesschain/context-memory-kernel";
+import { getContextWindow } from "../model-context-window.js";
+import { createCliContextMemoryRuntime } from "./runtime.js";
+import {
+  contextItemsToMessages,
+  memoryRecordsToContextItems,
+  messagesToContextItems,
+} from "./message-adapter.js";
+
+function defaultAdmissions(sessionId, options) {
+  const candidates = [
+    { scope: "session", scopeId: sessionId },
+    { scope: "agent", scopeId: options.agentId || sessionId },
+    { scope: "user", scopeId: options.userId || "local-user" },
+  ];
+  const configured = options.contextMemoryScopeAdmissions;
+  const admissions = Array.isArray(configured) && configured.length > 0
+    ? configured
+    : candidates;
+  const seen = new Set();
+  return admissions.filter((entry) => {
+    const key = `${entry.scope}\0${entry.scopeId || ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function toolDefinitionsToContextItems(definitionsInput, { sessionId, sink }) {
+  const definitions = Array.isArray(definitionsInput) ? definitionsInput : [];
+  return definitions.map((definition, index) => {
+    const content = canonicalJson(definition);
+    const name = String(
+      definition?.function?.name || definition?.name || `tool-${index}`,
+    );
+    const sourceDigest = canonicalDigest(
+      definition,
+      "chainlesschain.cli-tool-schema/v1",
+    );
+    return normalizeContextItem({
+      schemaVersion: 1,
+      itemId: `cli-tool-${sourceDigest.slice(7, 39)}`,
+      kind: "tool-schema",
+      scope: "session",
+      scopeId: sessionId,
+      sourceRef: {
+        store: "cli-tool-registry",
+        id: name,
+        digest: sourceDigest,
+      },
+      provenance: {
+        source: "cli-tool-registry",
+        observedAt: "1970-01-01T00:00:00.000Z",
+      },
+      trust: "host",
+      sensitivity: "internal",
+      allowedSinks: [sink],
+      tokenEstimate: Math.max(
+        1,
+        Math.ceil(Buffer.byteLength(content, "utf8") / 4),
+      ),
+      priority: Math.max(500_000, 600_000 - index),
+      pinned: false,
+      createdAt: "1970-01-01T00:00:00.000Z",
+      content,
+    });
+  });
+}
+
+/**
+ * Bind every paid provider request to one canonical plan and memory revision.
+ * The returned messages are ephemeral; the authoritative transcript remains
+ * the JSONL/session port and recalled memories remain independently deletable.
+ */
+export async function prepareCanonicalProviderContext(
+  messagesInput,
+  options = {},
+) {
+  const messages = Array.isArray(messagesInput) ? messagesInput : [];
+  const sessionId = String(options.sessionId || "ephemeral-cli-session");
+  const runtime = createCliContextMemoryRuntime({
+    env: options.contextMemoryEnv || process.env,
+    sessionId,
+    scopeKey: `cli:provider:${sessionId}`,
+    ...(options.contextMemoryFilePath
+      ? { memoryFilePath: options.contextMemoryFilePath }
+      : {}),
+  });
+  if (!runtime.decision.canonical || options.contextMemorySkipPlanning === true) {
+    return { messages, plan: null, recall: null, decision: runtime.decision };
+  }
+
+  const provider = String(options.provider || "local");
+  const sink = String(options.contextMemorySink || `provider.${provider}`);
+  const scopeAdmissions = defaultAdmissions(sessionId, options);
+  const lastUser = [...messages]
+    .reverse()
+    .find((message) => message?.role === "user");
+  const query =
+    typeof lastUser?.content === "string" && lastUser.content.trim()
+      ? lastUser.content.trim().slice(0, 32 * 1024)
+      : "*";
+  const recall = await runtime.kernel.recallMemory({
+    query,
+    sink,
+    scopeAdmissions,
+    limit: Math.max(1, Math.min(32, Number(options.contextMemoryRecallLimit) || 12)),
+    tokenBudget: Math.max(
+      1,
+      Math.min(32_768, Number(options.contextMemoryRecallTokens) || 4096),
+    ),
+  });
+  const messageItems = messagesToContextItems(messages, {
+    sessionId,
+    allowedSinks: [sink],
+    trustCurrentSystemPolicy: true,
+    trustedSystemIndexes: options.contextMemoryTrustedSystemIndexes,
+  });
+  const memoryItems = memoryRecordsToContextItems(
+    recall.results.map((entry) => entry.record),
+    { insertionSequence: Math.max(0, messages.length - 1) },
+  );
+  const toolItems = toolDefinitionsToContextItems(
+    options.contextMemoryToolDefinitions,
+    { sessionId, sink },
+  );
+  const items = [...messageItems, ...memoryItems, ...toolItems];
+  const modelWindowTokens = Math.max(
+    1024,
+    Number(options.contextMemoryModelWindowTokens) ||
+      getContextWindow(options.model, provider) ||
+      128 * 1024,
+  );
+  const reservedOutputTokens = Math.min(
+    modelWindowTokens - 1,
+    Math.max(256, Number(options.maxOutputTokens) || 4096),
+  );
+  const safetyMarginTokens = Math.min(
+    modelWindowTokens - reservedOutputTokens - 1,
+    Math.max(64, Math.floor(modelWindowTokens * 0.05)),
+  );
+  const inputBudget =
+    modelWindowTokens - reservedOutputTokens - safetyMarginTokens;
+  const recoveryReserveTokens = Math.min(
+    Math.max(32, Math.floor(inputBudget * 0.05)),
+    Math.max(0, inputBudget - 1),
+  );
+  const sessionHead =
+    options.contextMemorySessionHead ||
+    canonicalDigest(
+      messageItems.map((item) => item.digest),
+      "chainlesschain.cli-provider-context-head/v1",
+    );
+  const plan = await runtime.kernel.planContext({
+    modelWindowTokens,
+    reservedOutputTokens,
+    safetyMarginTokens,
+    recoveryReserveTokens,
+    items,
+    sink,
+    scopeAdmissions,
+    partitionCeilings: {
+      "trusted-system": inputBudget,
+      "working-state": inputBudget,
+      "tools-and-skills": inputBudget,
+      conversation: inputBudget,
+      "tool-evidence": inputBudget,
+      "memory-and-rules": Math.max(1, Math.floor(inputBudget * 0.12)),
+    },
+    policyVersion: String(options.contextMemoryPolicyVersion || "cli-provider-v1"),
+    modelProfile: `${provider}:${String(options.model || "default")}`.slice(0, 256),
+    sessionHead,
+    memoryRevision: recall.memoryRevision,
+  });
+  return {
+    messages: contextItemsToMessages(
+      plan.selected.filter((item) => item.kind !== "tool-schema"),
+    ),
+    selectedToolNames: toolItems
+      .filter((item) => plan.selectedItemIds.includes(item.itemId))
+      .map((item) => item.sourceRef.id),
+    plan,
+    recall,
+    decision: runtime.decision,
+  };
+}
+
+export { defaultAdmissions, toolDefinitionsToContextItems };

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

@@ -0,0 +1,61 @@
+import { ContextMemoryKernel } from "@chainlesschain/context-memory-kernel";
+import { DurableJsonMemoryPort } from "./durable-memory-port.js";
+import { JsonlSessionContextPort } from "./jsonl-session-context-port.js";
+import { CliLegacyMemoryPrivacyPurgePort } from "./privacy-purge-port.js";
+import {
+  createCliAuthority,
+  resolveCliContextMemoryCutover,
+} from "./authority.js";
+
+export function createCliContextMemoryRuntime(options = {}) {
+  const scopeKey = options.scopeKey ||
+    (options.sessionId ? `cli:session:${options.sessionId}` : "cli:memory");
+  const decision = resolveCliContextMemoryCutover({
+    env: options.env,
+    scopeKey,
+  });
+  const authority = createCliAuthority({
+    decision,
+    now: options.clock || Date.now,
+  });
+  const memoryPort =
+    options.memoryPort ||
+    new DurableJsonMemoryPort({
+      ...(options.memoryFilePath ? { filePath: options.memoryFilePath } : {}),
+    });
+  const sessionPort =
+    options.sessionPort ||
+    (options.sessionId
+      ? new JsonlSessionContextPort({
+          sessionId: options.sessionId,
+          allowedSinks: options.allowedSinks || ["*"],
+        })
+      : null);
+  const purgePorts = options.purgePorts || [
+    new CliLegacyMemoryPrivacyPurgePort({
+      ...(options.legacyMemoryStorePath
+        ? { memoryStorePath: options.legacyMemoryStorePath }
+        : {}),
+      ...(options.legacyDb ? { legacyDb: options.legacyDb } : {}),
+    }),
+  ];
+  const kernel = new ContextMemoryKernel({
+    sessionPort,
+    memoryPort,
+    reconciliationPort: memoryPort,
+    authorityRegistry: authority.registry,
+    writer: authority.writer,
+    mode: decision.canonical ? "canonical" : "shadow",
+    clock: options.clock || Date.now,
+    ...(options.randomUUID ? { randomUUID: options.randomUUID } : {}),
+    purgePorts,
+  });
+  return Object.freeze({
+    decision,
+    kernel,
+    memoryPort,
+    sessionPort,
+    authorityRegistry: authority.registry,
+    writer: authority.writer,
+  });
+}

package/src/lib/direct-model-usage.js

@@ -36,9 +36,16 @@ async function persistUsageEvent(persist, type, event) {
   }
 }
 
-function unknownUsageEvent({ callId, provider, model, source, code }) {
+function unknownUsageEvent({
+  callId,
+  provider,
+  model,
+  source,
+  operationId,
+  code,
+}) {
   return projectRuntimeUsageBoundary(
-    { callId, provider, model, source, code },
+    { callId, provider, model, source, operationId, code },
     "unknown",
   );
 }
@@ -54,6 +61,7 @@ export async function runMeteredDirectModelCall({
   provider,
   model,
   source = "model",
+  operationId = undefined,
   sessionBudget = null,
   call,
 }) {
@@ -77,11 +85,14 @@ export async function runMeteredDirectModelCall({
   await persistUsageEvent(
     persist,
     runtimeUsageEventType("started"),
-    projectRuntimeUsageBoundary({ callId, provider, model, source }, "started"),
+    projectRuntimeUsageBoundary(
+      { callId, provider, model, source, operationId },
+      "started",
+    ),
   );
   beginSessionBudgetUsage(
     sessionBudget,
-    { callId, provider, model, source },
+    { callId, provider, model, source, operationId },
     `direct model call ${source}`,
   );
   let result;
@@ -93,13 +104,10 @@ export async function runMeteredDirectModelCall({
       provider,
       model,
       source,
+      operationId,
       code: "provider_call_failed",
     });
-    await persistUsageEvent(
-      persist,
-      runtimeUsageEventType("unknown"),
-      unknown,
-    );
+    await persistUsageEvent(persist, runtimeUsageEventType("unknown"), unknown);
     markSessionBudgetUsageUnknown(sessionBudget, unknown);
     throw error;
   }
@@ -111,6 +119,7 @@ export async function runMeteredDirectModelCall({
         provider,
         model,
         source,
+        operationId,
         usage: result.usage,
       });
     } catch {
@@ -119,6 +128,7 @@ export async function runMeteredDirectModelCall({
         provider,
         model,
         source,
+        operationId,
         code: "provider_usage_missing",
       });
       await persistUsageEvent(
@@ -127,10 +137,7 @@ export async function runMeteredDirectModelCall({
         unknown,
       );
       if (markSessionBudgetUsageUnknown(sessionBudget, unknown)) {
-        rejectSessionBudgetUsageUnknown(
-          unknown,
-          `direct model call ${source}`,
-        );
+        rejectSessionBudgetUsageUnknown(unknown, `direct model call ${source}`);
       }
       return result;
     }
@@ -146,13 +153,10 @@ export async function runMeteredDirectModelCall({
       provider,
       model,
       source,
+      operationId,
       code: "provider_usage_missing",
     });
-    await persistUsageEvent(
-      persist,
-      runtimeUsageEventType("unknown"),
-      unknown,
-    );
+    await persistUsageEvent(persist, runtimeUsageEventType("unknown"), unknown);
     if (markSessionBudgetUsageUnknown(sessionBudget, unknown)) {
       rejectSessionBudgetUsageUnknown(unknown, `direct model call ${source}`);
     }

package/src/lib/graph-kernel/cutover-authority-resolver.js

@@ -1,8 +1,6 @@
 import path from "node:path";
-import {
-  defaultRolloutStoreDirectory,
-  JsonlRolloutStore,
-} from "../app-server/rollout-store.js";
+import { defaultRolloutStoreDirectory } from "../app-server/rollout-store.js";
+import { createRolloutStore } from "../app-server/rollout-store-factory.js";
 import { GraphCutoverLedger } from "./cutover-ledger.js";
 import {
   graphRuntimeEntryManifestDigest,
@@ -230,7 +228,8 @@ export function createRuntimeGraphCutoverAuthorityResolver({
   const resolvedLedger =
     ledger ||
     new GraphCutoverLedger({
-      store: new JsonlRolloutStore({
+      store: createRolloutStore({
+        backend: env.CHAINLESSCHAIN_ROLLOUT_STORE,
         directory: path.resolve(
           stateDirectory ||
             env.CHAINLESSCHAIN_GRAPH_CUTOVER_STATE_DIR ||

package/src/lib/graph-kernel/cutover-ledger.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { JsonlRolloutStore } from "../app-server/rollout-store.js";
+import { createRolloutStore } from "../app-server/rollout-store-factory.js";
 import { assertGraphCutoverTransition } from "./authority.js";
 import { graphDigest } from "./compiler.js";
 import {
@@ -478,7 +478,7 @@ function projection(state, events) {
 }
 
 export class GraphCutoverLedger {
-  constructor({ store = new JsonlRolloutStore(), now = Date.now } = {}) {
+  constructor({ store = createRolloutStore(), now = Date.now } = {}) {
     this.store = store;
     this.now = now;
   }

package/src/lib/graph-kernel/event-store.js

@@ -1,8 +1,6 @@
 import path from "node:path";
-import {
-  JsonlRolloutStore,
-  defaultRolloutStoreDirectory,
-} from "../app-server/rollout-store.js";
+import { defaultRolloutStoreDirectory } from "../app-server/rollout-store.js";
+import { createRolloutStore } from "../app-server/rollout-store-factory.js";
 
 export const GRAPH_EVENT_SCHEMA = "chainlesschain.graph-event/v1";
 
@@ -16,7 +14,7 @@ function clone(value) {
 
 export class GraphEventStore {
   constructor({
-    rolloutStore = new JsonlRolloutStore({
+    rolloutStore = createRolloutStore({
       directory: defaultGraphEventStoreDirectory(),
     }),
   } = {}) {

package/src/lib/graph-kernel/migration-saga.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { JsonlRolloutStore } from "../app-server/rollout-store.js";
+import { createRolloutStore } from "../app-server/rollout-store-factory.js";
 import { createGraphAuthorityBinding } from "./authority.js";
 
 export const GRAPH_MIGRATION_SCHEMA =
@@ -84,7 +84,7 @@ function stateFromEvents(events, migrationId) {
  * this API intentionally has no "fall back to legacy" operation.
  */
 export class GraphAuthorityMigrationSaga {
-  constructor({ store = new JsonlRolloutStore(), now = Date.now } = {}) {
+  constructor({ store = createRolloutStore(), now = Date.now } = {}) {
     this.store = store;
     this.now = now;
   }

package/src/lib/graph-kernel/production-cutover-evidence.js

@@ -797,6 +797,7 @@ export function normalizeGraphProductionCutoverEvidence(
     expectedRepository = undefined,
     expectedEnvironment = undefined,
     expectedWorkflowRunId = undefined,
+    expectedWorkflowRunAttempt = undefined,
   } = {},
 ) {
   if (input?.schema !== GRAPH_PRODUCTION_CUTOVER_EVIDENCE_SCHEMA) {
@@ -832,7 +833,9 @@ export function normalizeGraphProductionCutoverEvidence(
     (expectedRepository && provenance.repository !== expectedRepository) ||
     (expectedEnvironment && provenance.environment !== expectedEnvironment) ||
     (expectedWorkflowRunId !== undefined &&
-      provenance.workflowRunId !== Number(expectedWorkflowRunId))
+      provenance.workflowRunId !== Number(expectedWorkflowRunId)) ||
+    (expectedWorkflowRunAttempt !== undefined &&
+      provenance.workflowRunAttempt !== Number(expectedWorkflowRunAttempt))
   ) {
     throw evidenceError(
       "CC_GRAPH_PRODUCTION_PROVENANCE_MISMATCH",
@@ -844,6 +847,10 @@ export function normalizeGraphProductionCutoverEvidence(
           expectedWorkflowRunId === undefined
             ? undefined
             : Number(expectedWorkflowRunId),
+        expectedWorkflowRunAttempt:
+          expectedWorkflowRunAttempt === undefined
+            ? undefined
+            : Number(expectedWorkflowRunAttempt),
         actual: provenance,
       },
     );

package/src/lib/hierarchical-memory.js

@@ -6,6 +6,18 @@
  */
 
 import { escapeLike } from "./sql-like.js";
+import {
+  assertLegacyMutationAllowed,
+  resolveCliContextMemoryCutover,
+} from "./context-memory-kernel/authority.js";
+
+function assertLegacyHierarchicalMemoryMutationAllowed(operation) {
+  assertLegacyMutationAllowed(
+    resolveCliContextMemoryCutover({
+      scopeKey: `cli:legacy-hierarchical-memory:${operation}`,
+    }),
+  );
+}
 
 // ─── Configuration ───────────────────────────────────────────────
 export const MEMORY_CONFIG = {
@@ -123,6 +135,7 @@ function calcRetention(
  * Create persistent memory tables for long-term / core / sharing
  */
 export function ensureMemoryTables(db) {
+  assertLegacyHierarchicalMemoryMutationAllowed("ensure-tables");
   db.exec(`
     CREATE TABLE IF NOT EXISTS memory_long_term (
       id TEXT PRIMARY KEY,
@@ -179,6 +192,7 @@ export function ensureMemoryTables(db) {
  * @param {string} [options.namespace] - Namespace for in-memory isolation (default: "global")
  */
 export function storeMemory(db, content, options = {}) {
+  assertLegacyHierarchicalMemoryMutationAllowed("store");
   if (!content || !content.trim()) {
     throw new Error("Memory content cannot be empty");
   }
@@ -258,6 +272,7 @@ export function storeMemory(db, content, options = {}) {
  * the default "global" namespace (backward compatible).
  */
 export function recallMemory(db, query, options = {}) {
+  assertLegacyHierarchicalMemoryMutationAllowed("recall");
   if (!query || !query.trim()) return [];
 
   const limit = Math.max(1, parseInt(options.limit) || 20);
@@ -653,6 +668,7 @@ export function applyForgettingCurve(
  * persisted to the DB — lives alongside the in-memory layer.
  */
 export function attachMetadata(memoryId, metadata, namespace = DEFAULT_NS) {
+  assertLegacyHierarchicalMemoryMutationAllowed("attach-metadata");
   if (!memoryId) throw new Error("memoryId is required");
   if (!metadata || typeof metadata !== "object")
     throw new Error("metadata must be an object");
@@ -682,6 +698,7 @@ function _locateInMemory(memoryId) {
  * Promote a memory one layer up: working → short-term → long-term.
  */
 export function promoteMemoryV2(db, memoryId) {
+  assertLegacyHierarchicalMemoryMutationAllowed("promote");
   if (!memoryId) throw new Error("memoryId is required");
   const loc = _locateInMemory(memoryId);
   if (loc && loc.layer === MEMORY_LAYER.WORKING) {
@@ -728,6 +745,7 @@ export function promoteMemoryV2(db, memoryId) {
  * (long-term/core demotion requires DB round-trip; not exposed here.)
  */
 export function demoteMemoryV2(memoryId) {
+  assertLegacyHierarchicalMemoryMutationAllowed("demote");
   if (!memoryId) throw new Error("memoryId is required");
   for (const [ns, nsMap] of _shortTermNS) {
     if (nsMap.has(memoryId)) {
@@ -790,6 +808,7 @@ export function shareMemoryV2(
 }
 
 export function revokeShare(shareId) {
+  assertLegacyHierarchicalMemoryMutationAllowed("revoke-share");
   const record = _v2Shares.find((s) => s.id === shareId);
   if (!record) throw new Error(`Share not found: ${shareId}`);
   if (record.revokedAt) throw new Error(`Share already revoked`);
@@ -896,6 +915,7 @@ export function searchSemanticV2(db, options = {}) {
  * Delegates to existing consolidateMemory() for promotion logic.
  */
 export function consolidateV2(db, options = {}) {
+  assertLegacyHierarchicalMemoryMutationAllowed("consolidate-v2");
   const id = `consol-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const record = {
     id,
@@ -949,6 +969,7 @@ export function listConsolidations(options = {}) {
  * Prune with per-layer scope + custom threshold.
  */
 export function pruneV2(db, options = {}) {
+  assertLegacyHierarchicalMemoryMutationAllowed("prune-v2");
   const { layer, maxAge = 720, threshold } = options;
   if (layer && !_LAYER_VALUES.has(layer))
     throw new Error(`Invalid layer: ${layer}`);
@@ -1000,6 +1021,7 @@ export function startConsolidationTimer({
   db,
   onTick,
 } = {}) {
+  assertLegacyHierarchicalMemoryMutationAllowed("start-consolidation-timer");
   if (_consolidationTimer) return _consolidationTimer;
   if (!db) throw new Error("db is required for consolidation timer");
   _consolidationTimer = setInterval(() => {