chainlesschain 0.166.9 → 0.166.13

package/src/lib/llm-pricing.js

@@ -65,11 +65,21 @@ export const PRICE_TABLE = Object.freeze({
     { match: "o1", in: 15, out: 60 },
   ],
   deepseek: [
+    // DeepSeek V4 launch-list rates for the versioned 2026-04 model ids.
+    // Keep these ahead of the legacy aliases so formal budget gates never
+    // treat the current V4 models as unpriced remote usage.
+    { match: "deepseek-v4-pro", in: 0.435, out: 0.87 },
+    { match: "deepseek-v4-flash", in: 0.14, out: 0.28 },
     { match: "reasoner", in: 0.55, out: 2.19 },
     { match: "chat", in: 0.27, out: 1.1 },
   ],
   // Volcengine Doubao — rough USD conversion of public RMB list pricing.
   volcengine: [
+    // Third-party DeepSeek V4 ids exposed by Ark use the same token-accounting
+    // shape. Pricing them explicitly is required by USD-capped Agent/Team runs;
+    // falling through to the Doubao patterns would fail closed as unpriced.
+    { match: "deepseek-v4-pro", in: 0.435, out: 0.87 },
+    { match: "deepseek-v4-flash", in: 0.14, out: 0.28 },
     // Doubao Seed 2.0 family (2026, e.g. doubao-seed-2-0-lite-260215) is
     // natively multimodal. Rates ≈ official CNY ÷ ~7.2 (lite ≤32k is 0.6/3.6
     // CNY → $0.08/$0.50); the generic "seed" rate below underprices 2.0 output.

package/src/lib/memory-manager.js

@@ -8,6 +8,18 @@
 import fs from "fs";
 import path from "path";
 import { likePrefix, escapeLike } from "./sql-like.js";
+import {
+  assertLegacyMutationAllowed,
+  resolveCliContextMemoryCutover,
+} from "./context-memory-kernel/authority.js";
+
+function assertLegacyMemoryManagerMutationAllowed(operation) {
+  assertLegacyMutationAllowed(
+    resolveCliContextMemoryCutover({
+      scopeKey: `cli:legacy-memory-manager:${operation}`,
+    }),
+  );
+}
 
 /**
  * Atomically write a UTF-8 file: a crash mid-write must not truncate MEMORY.md
@@ -57,6 +69,15 @@ function ensureMemoryTable(db) {
   `);
 }
 
+function memoryTableExists(db) {
+  const row = db
+    .prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_entries'",
+    )
+    .get();
+  return Boolean(row);
+}
+
 /**
  * Get the memory directory path
  */
@@ -68,6 +89,7 @@ export function getMemoryDir(dataDir) {
  * Add an entry to memory (stored in DB)
  */
 export function addMemory(db, content, options = {}) {
+  assertLegacyMemoryManagerMutationAllowed("add");
   ensureMemoryTable(db);
 
   if (!content || !content.trim()) {
@@ -142,7 +164,9 @@ export function listMemory(db, options = {}) {
  * ordered deterministically so the same DB exports identically.
  */
 export function exportMemory(db) {
-  ensureMemoryTable(db);
+  // Canonical cutover calls this as a one-time read-only importer. Do not
+  // create a legacy table merely because no legacy data exists.
+  if (!memoryTableExists(db)) return [];
   return db
     .prepare(
       `SELECT id, content, category, importance, source, created_at, updated_at
@@ -162,6 +186,7 @@ function _nowSqlite() {
  * updated_at. Never aborts mid-batch; returns {ok, imported, failed, errors}.
  */
 export function importMemory(db, entries) {
+  assertLegacyMemoryManagerMutationAllowed("import");
   ensureMemoryTable(db);
   if (!Array.isArray(entries)) {
     throw new Error("importMemory: entries must be a JSON array");
@@ -208,6 +233,7 @@ export function importMemory(db, entries) {
  * Delete a memory entry
  */
 export function deleteMemory(db, id) {
+  assertLegacyMemoryManagerMutationAllowed("delete");
   ensureMemoryTable(db);
 
   // Try exact match first, then prefix match
@@ -228,6 +254,7 @@ export function deleteMemory(db, id) {
  * Append to today's daily note
  */
 export function appendDailyNote(memoryDir, content) {
+  assertLegacyMemoryManagerMutationAllowed("append-daily-note");
   ensureMemoryDirs(memoryDir);
 
   const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
@@ -260,8 +287,6 @@ export function getDailyNote(memoryDir, date) {
  * List available daily notes
  */
 export function listDailyNotes(memoryDir, options = {}) {
-  ensureMemoryDirs(memoryDir);
-
   const dailyDir = path.join(memoryDir, "daily");
   const limit = Math.max(1, parseInt(options.limit) || 30);
 
@@ -291,13 +316,13 @@ export function listDailyNotes(memoryDir, options = {}) {
  * Read or update the MEMORY.md file (long-term knowledge)
  */
 export function getMemoryFile(memoryDir) {
-  ensureMemoryDirs(memoryDir);
   const filePath = path.join(memoryDir, "MEMORY.md");
   if (!fs.existsSync(filePath)) return "";
   return fs.readFileSync(filePath, "utf8");
 }
 
 export function updateMemoryFile(memoryDir, content) {
+  assertLegacyMemoryManagerMutationAllowed("update-memory-file");
   ensureMemoryDirs(memoryDir);
   const filePath = path.join(memoryDir, "MEMORY.md");
   atomicWriteFileSync(filePath, content);

package/src/lib/model-context-window.js

@@ -0,0 +1,52 @@
+export const CONTEXT_WINDOWS = Object.freeze({
+  "qwen2.5:7b": 32768,
+  "qwen2.5:14b": 32768,
+  "qwen2.5-coder:14b": 32768,
+  "qwen2:7b": 32768,
+  "llama3:8b": 8192,
+  "mistral:7b": 32768,
+  "codellama:7b": 16384,
+  "gpt-4o": 128000,
+  "gpt-4o-mini": 128000,
+  "gpt-4-turbo": 128000,
+  "gpt-3.5-turbo": 16385,
+  o1: 200000,
+  "claude-opus-4-6": 200000,
+  "claude-sonnet-4-6": 200000,
+  "claude-haiku-4-5-20251001": 200000,
+  "deepseek-chat": 64000,
+  "deepseek-coder": 64000,
+  "deepseek-reasoner": 64000,
+  "qwen-turbo": 131072,
+  "qwen-plus": 131072,
+  "qwen-max": 32768,
+  "gemini-2.0-flash": 1048576,
+  "gemini-2.0-pro": 1048576,
+  "gemini-1.5-flash": 1048576,
+  "moonshot-v1-auto": 131072,
+  "moonshot-v1-8k": 8192,
+  "moonshot-v1-32k": 32768,
+  "moonshot-v1-128k": 131072,
+  "doubao-seed-1-6-251015": 32768,
+  "doubao-seed-2-1-pro-260628": 32768,
+  _provider_defaults: Object.freeze({
+    ollama: 32768,
+    openai: 128000,
+    anthropic: 200000,
+    deepseek: 64000,
+    dashscope: 131072,
+    gemini: 1048576,
+    kimi: 131072,
+    volcengine: 32768,
+    minimax: 32768,
+    mistral: 32768,
+  }),
+});
+
+export function getContextWindow(model, provider) {
+  if (model && CONTEXT_WINDOWS[model]) return CONTEXT_WINDOWS[model];
+  if (provider && CONTEXT_WINDOWS._provider_defaults[provider]) {
+    return CONTEXT_WINDOWS._provider_defaults[provider];
+  }
+  return 32768;
+}

package/src/lib/permanent-memory.js

@@ -9,6 +9,18 @@
 import fs from "fs";
 import path from "path";
 import { BM25Search } from "./bm25-search.js";
+import {
+  assertLegacyMutationAllowed,
+  resolveCliContextMemoryCutover,
+} from "./context-memory-kernel/authority.js";
+
+function assertLegacyPermanentMemoryMutationAllowed(operation) {
+  assertLegacyMutationAllowed(
+    resolveCliContextMemoryCutover({
+      scopeKey: `cli:legacy-permanent-memory:${operation}`,
+    }),
+  );
+}
 
 // Exported for test injection
 export const _deps = {
@@ -66,6 +78,7 @@ export class CLIPermanentMemory {
    */
   initialize() {
     if (this._initialized) return;
+    assertLegacyPermanentMemoryMutationAllowed("initialize");
     this._initialized = true;
 
     // Ensure directories
@@ -120,6 +133,7 @@ export class CLIPermanentMemory {
    */
   appendDailyNote(content) {
     if (!this.memoryDir || !content) return null;
+    assertLegacyPermanentMemoryMutationAllowed("append-daily-note");
 
     try {
       const today = new Date().toISOString().slice(0, 10);
@@ -154,6 +168,7 @@ export class CLIPermanentMemory {
    */
   updateMemoryFile(section, content) {
     if (!this.memoryDir) return null;
+    assertLegacyPermanentMemoryMutationAllowed("update-memory-file");
 
     try {
       const filePath = _deps.path.join(this.memoryDir, "MEMORY.md");
@@ -228,6 +243,7 @@ export class CLIPermanentMemory {
    */
   autoSummarize(sessionMessages) {
     if (!sessionMessages || sessionMessages.length < 4) return [];
+    assertLegacyPermanentMemoryMutationAllowed("auto-summarize");
 
     const facts = [];
 
@@ -281,6 +297,7 @@ export class CLIPermanentMemory {
    */
   _storeEntry(content, source = "auto", importance = 0.5) {
     if (!this.db) return null;
+    assertLegacyPermanentMemoryMutationAllowed("store-entry");
     try {
       const id = `pm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
       this.db

package/src/lib/plan-mode.js

@@ -1530,10 +1530,14 @@ export class PlanModeManager extends EventEmitter {
    */
   _fireHook(eventName, context) {
     if (!this._hookDb) return;
-    // Dynamic import to avoid circular deps
-    import("./hook-manager.js")
-      .then(({ executeHooks }) => {
-        executeHooks(this._hookDb, eventName, context).catch(() => {});
+    // Dynamic import avoids a constructor-time dependency while keeping the
+    // legacy SQLite registry behind the canonical Hooks v2 adapter.
+    import("./hooks-v2-producers.js")
+      .then(({ executeHooksV2Event }) => {
+        executeHooksV2Event(eventName, context, {
+          hookDb: this._hookDb,
+          matchTarget: context?.target || eventName,
+        }).catch(() => {});
       })
       .catch(() => {});
   }

package/src/lib/process-execution-broker/index.js

@@ -964,12 +964,19 @@ class ProcessExecutionBroker extends EventEmitter {
       sandboxed: 0,
       credFiltered: 0,
     };
-    this._logPath = path.join(
-      os.homedir(),
-      ".chainlesschain",
-      "logs",
-      "process-audit.log",
-    );
+    this._logPath =
+      process.env.NODE_ENV === "test"
+        ? path.join(
+            os.tmpdir(),
+            "chainlesschain-process-audit-tests",
+            `${process.pid}.log`,
+          )
+        : path.join(
+            os.homedir(),
+            ".chainlesschain",
+            "logs",
+            "process-audit.log",
+          );
 
     // P0-1: Platform sandbox functions (applySandbox/postSpawnSandbox imported above)
     // No instance needed — stateless functional API per platform
@@ -998,7 +1005,8 @@ class ProcessExecutionBroker extends EventEmitter {
     try {
       fs.mkdirSync(path.dirname(this._logPath), { recursive: true });
     } catch {
-      // Audit persistence is best-effort; in-memory audit remains available.
+      // Legacy callers may retain in-memory audit. Required-audit executions
+      // independently prove appendability before native spawn and fail closed.
     }
   }
 
@@ -1033,6 +1041,14 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   _recordAudit(entry) {
+    try {
+      fs.appendFileSync(this._logPath, JSON.stringify(entry) + "\n");
+    } catch (cause) {
+      if (entry.persistentAuditRequired === true) {
+        throw this._persistentAuditError(cause, entry);
+      }
+      // Non-sensitive legacy callers retain best-effort persistence.
+    }
     this._auditLog.push(entry);
     if (this._auditLog.length > 10000) this._auditLog.shift();
     this._stats.totalSpawned++;
@@ -1046,12 +1062,54 @@ class ProcessExecutionBroker extends EventEmitter {
     }
     this._stats.byOrigin[entry.origin] =
       (this._stats.byOrigin[entry.origin] || 0) + 1;
+    this.emit("spawn", entry);
+  }
+
+  _persistentAuditError(cause, entry) {
+    const error = new Error(
+      `Persistent process audit is unavailable: ${cause.message}`,
+    );
+    error.code = "ERR_PROCESS_AUDIT_UNAVAILABLE";
+    error.auditFailClosed = true;
+    error.cause = cause;
+    error.auditEntry = entry;
+    return error;
+  }
+
+  _requirePersistentAuditAdmission(entry) {
+    const admission = {
+      ...entry,
+      auditPhase: "admission",
+      persistentAuditRequired: true,
+      admittedAt: Date.now(),
+    };
     try {
-      fs.appendFileSync(this._logPath, JSON.stringify(entry) + "\n");
-    } catch {
-      // Audit persistence is best-effort; the in-memory entry is retained.
+      fs.appendFileSync(this._logPath, JSON.stringify(admission) + "\n");
+    } catch (cause) {
+      throw this._persistentAuditError(cause, entry);
+    }
+    entry.persistentAuditRequired = true;
+    entry.persistentAuditAdmitted = true;
+  }
+
+  _recordRequiredAuditOutcome(entry, auditPhase) {
+    if (entry.persistentAuditRequired !== true) return;
+    try {
+      fs.appendFileSync(
+        this._logPath,
+        JSON.stringify({ ...entry, auditPhase }) + "\n",
+      );
+    } catch (cause) {
+      const error = this._persistentAuditError(cause, entry);
+      entry.persistentAuditFailure = error.message;
+      if (this.listenerCount("audit-error") > 0) {
+        this.emit("audit-error", { auditEntry: entry, error });
+      }
+      process.emitWarning(error.message, {
+        code: error.code,
+        detail: `executionId=${entry.executionId}`,
+      });
     }
-    this.emit("spawn", entry);
   }
 
   _sanitizeOptions(options) {
@@ -3965,8 +4023,68 @@ class ProcessExecutionBroker extends EventEmitter {
     return sanitized;
   }
 
+  _auditCommand(command, redact = false) {
+    if (!redact) return command;
+    const digest = crypto
+      .createHash("sha256")
+      .update(String(command ?? ""), "utf8")
+      .digest("hex");
+    return `[REDACTED sha256:${digest}]`;
+  }
+
+  _normalizeAuditContext(value, origin) {
+    if (value === undefined || value === null) {
+      return {
+        actor: origin,
+        sessionId: null,
+        authorization: null,
+        policyDigest: null,
+      };
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+      throw new TypeError("auditContext must be an object");
+    }
+    const snapshot = ownDataObjectSnapshot(value);
+    if (!snapshot)
+      throw new TypeError("auditContext must contain data properties");
+    const authorization = snapshot.authorization;
+    if (
+      authorization !== undefined &&
+      authorization !== null &&
+      (typeof authorization !== "object" || Array.isArray(authorization))
+    ) {
+      throw new TypeError("auditContext.authorization must be an object");
+    }
+    const authorizationSnapshot = authorization
+      ? ownDataObjectSnapshot(authorization)
+      : null;
+    if (authorization && !authorizationSnapshot) {
+      throw new TypeError(
+        "auditContext.authorization must contain data properties",
+      );
+    }
+    const text = (input, fallback = null) =>
+      typeof input === "string" && input ? input.slice(0, 512) : fallback;
+    return {
+      actor: text(snapshot.actor, origin),
+      sessionId: text(snapshot.sessionId),
+      authorization: authorizationSnapshot
+        ? {
+            decision: text(authorizationSnapshot.decision, "unknown"),
+            via: text(authorizationSnapshot.via, "unknown"),
+            riskLevel: text(authorizationSnapshot.riskLevel),
+            policy: text(authorizationSnapshot.policy),
+          }
+        : null,
+      policyDigest: text(snapshot.policyDigest),
+    };
+  }
+
   _stripAuditControlOptions(options) {
     delete options.auditRedactArgIndexes;
+    delete options.auditRedactCommand;
+    delete options.auditContext;
+    delete options.requirePersistentAudit;
   }
 
   _applyCredentialBoundary(command, args, spawnOptions, origin) {
@@ -4380,12 +4498,20 @@ class ProcessExecutionBroker extends EventEmitter {
     );
 
     const traceCtx = this._getTraceContext();
+    const auditContext = this._normalizeAuditContext(
+      options.auditContext,
+      origin,
+    );
     const auditEntry = {
       executionId,
       traceId: traceCtx?.traceId || null,
       origin,
       scope,
-      command,
+      actor: auditContext.actor,
+      sessionId: auditContext.sessionId,
+      authorization: auditContext.authorization,
+      approvalPolicyDigest: auditContext.policyDigest,
+      command: this._auditCommand(command, options.auditRedactCommand === true),
       args: this._auditArgs(args, auditRedactArgIndexes),
       cwd,
       startTime,
@@ -4533,6 +4659,16 @@ class ProcessExecutionBroker extends EventEmitter {
       throw transactionError;
     }
 
+    if (options.requirePersistentAudit === true) {
+      try {
+        this._requirePersistentAuditAdmission(auditEntry);
+      } catch (auditError) {
+        sandboxPlan.cleanup?.();
+        auditError.auditEntry = auditEntry;
+        throw auditError;
+      }
+    }
+
     // Use native spawn from _native (set by patch-child-process.js)
     const nativeSpawnFn = this._native?.spawn || nativeSpawn;
     let proc;
@@ -4680,6 +4816,7 @@ class ProcessExecutionBroker extends EventEmitter {
         auditEntry.signal = signal;
         auditEntry.endTime = endTime;
         auditEntry.durationMs = endTime - startTime;
+        this._recordRequiredAuditOutcome(auditEntry, "completed");
         this._writeRplEntry(auditEntry, "completed");
         this._emitHooksEvent("tool:end", {
           executionId,
@@ -4695,6 +4832,7 @@ class ProcessExecutionBroker extends EventEmitter {
         auditEntry.error = err.message;
         auditEntry.endTime = Date.now();
         auditEntry.durationMs = auditEntry.endTime - startTime;
+        this._recordRequiredAuditOutcome(auditEntry, "error");
         this._writeRplEntry(auditEntry, "error", err);
         this._emitHooksEvent("tool:end", {
           executionId,
@@ -4743,12 +4881,20 @@ class ProcessExecutionBroker extends EventEmitter {
     );
 
     const traceCtx = this._getTraceContext();
+    const auditContext = this._normalizeAuditContext(
+      options.auditContext,
+      origin,
+    );
     const auditEntry = {
       executionId,
       traceId: traceCtx?.traceId || null,
       origin,
       scope,
-      command,
+      actor: auditContext.actor,
+      sessionId: auditContext.sessionId,
+      authorization: auditContext.authorization,
+      approvalPolicyDigest: auditContext.policyDigest,
+      command: this._auditCommand(command, options.auditRedactCommand === true),
       args: this._auditArgs(args, auditRedactArgIndexes),
       cwd,
       startTime,
@@ -4880,6 +5026,16 @@ class ProcessExecutionBroker extends EventEmitter {
       throw transactionError;
     }
 
+    if (options.requirePersistentAudit === true) {
+      try {
+        this._requirePersistentAuditAdmission(auditEntry);
+      } catch (auditError) {
+        sandboxPlan.cleanup?.();
+        auditError.auditEntry = auditEntry;
+        throw auditError;
+      }
+    }
+
     const nativeSpawnSyncFn = this._native?.spawnSync || nativeSpawnSync;
     try {
       const macPlanBindingDeclared =
@@ -4957,12 +5113,20 @@ class ProcessExecutionBroker extends EventEmitter {
       options.auditRedactArgIndexes,
       Array.isArray(args) ? args.length : 0,
     );
+    const auditContext = this._normalizeAuditContext(
+      options.auditContext,
+      origin,
+    );
     const auditEntry = {
       executionId,
       traceId: this._getTraceContext()?.traceId || null,
       origin,
       scope,
-      command,
+      actor: auditContext.actor,
+      sessionId: auditContext.sessionId,
+      authorization: auditContext.authorization,
+      approvalPolicyDigest: auditContext.policyDigest,
+      command: this._auditCommand(command, options.auditRedactCommand === true),
       args: this._auditArgs(args, auditRedactArgIndexes),
       cwd: options.cwd || process.cwd(),
       startTime,
@@ -5051,6 +5215,9 @@ class ProcessExecutionBroker extends EventEmitter {
       const filteredArgs = spawnOptions.args || [];
       delete spawnOptions.args;
       this._prepareWorkspaceTransactionAudit(auditEntry);
+      if (options.requirePersistentAudit === true) {
+        this._requirePersistentAuditAdmission(auditEntry);
+      }
 
       if (sandboxPolicy.requiredBoundaries.length === 0) {
         delete spawnOptions.origin;
@@ -5070,7 +5237,18 @@ class ProcessExecutionBroker extends EventEmitter {
         auditEntry.pid = proc?.pid ?? null;
         auditEntry.endTime = Date.now();
         auditEntry.durationMs = auditEntry.endTime - startTime;
-        this._recordAudit(auditEntry);
+        try {
+          this._recordAudit(auditEntry);
+        } catch (auditError) {
+          try {
+            proc.kill?.();
+          } catch {
+            // Preserve the required-audit failure after requesting teardown.
+          }
+          auditError.spawnedProcess = proc;
+          auditError.processTerminationRequested = true;
+          throw auditError;
+        }
         this._writeRplEntry(auditEntry, "started");
         return proc;
       }
@@ -5216,6 +5394,7 @@ class ProcessExecutionBroker extends EventEmitter {
         auditEntry.signal = signal;
         auditEntry.endTime = Date.now();
         auditEntry.durationMs = auditEntry.endTime - startTime;
+        this._recordRequiredAuditOutcome(auditEntry, "completed");
         this._writeRplEntry(auditEntry, "completed");
         this.emit("exit", auditEntry);
       });
@@ -5224,13 +5403,26 @@ class ProcessExecutionBroker extends EventEmitter {
         auditEntry.error = error.message;
         auditEntry.endTime = Date.now();
         auditEntry.durationMs = auditEntry.endTime - startTime;
+        this._recordRequiredAuditOutcome(auditEntry, "error");
         this._writeRplEntry(auditEntry, "error", error);
         if (this.listenerCount("error") > 0) this.emit("error", auditEntry);
       });
       auditEntry.pid = proc?.pid ?? null;
       auditEntry.endTime = Date.now();
       auditEntry.durationMs = auditEntry.endTime - startTime;
-      this._recordAudit(auditEntry);
+      try {
+        this._recordAudit(auditEntry);
+      } catch (auditError) {
+        try {
+          child.kill?.();
+        } catch {
+          // Preserve the required-audit failure after requesting teardown.
+        }
+        releaseTerminal();
+        auditError.spawnedProcess = proc;
+        auditError.processTerminationRequested = true;
+        throw auditError;
+      }
       this._writeRplEntry(auditEntry, "started");
       return proc;
     } catch (error) {

package/src/lib/runtime-usage-ledger.js

@@ -1,5 +1,6 @@
 const MAX_LABEL_LENGTH = 160;
 const MAX_CALL_ID_LENGTH = 128;
+const MAX_OPERATION_ID_LENGTH = 160;
 const MAX_ATTRIBUTION_ID_LENGTH = 256;
 let fallbackToolSequence = 0;
 const USAGE_FIELDS = Object.freeze([
@@ -65,6 +66,21 @@ function callId(value, { required = false } = {}) {
   return value.trim();
 }
 
+function operationId(value) {
+  if (value === undefined) return null;
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value.length > MAX_OPERATION_ID_LENGTH ||
+    /\p{Cc}/u.test(value)
+  ) {
+    throw new TypeError(
+      "runtime usage boundary requires a bounded operation id",
+    );
+  }
+  return value.trim();
+}
+
 function projectAttribution(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const projected = {};
@@ -120,12 +136,14 @@ export function projectRuntimeTokenUsage(event = {}) {
     }
   }
   const projectedCallId = callId(event.callId);
+  const projectedOperationId = operationId(event.operationId);
   const attribution = projectAttribution(event.attribution);
   return {
     provider: cleanLabel(event.provider),
     model: cleanLabel(event.model),
     usage,
     ...(projectedCallId ? { callId: projectedCallId } : {}),
+    ...(projectedOperationId ? { operationId: projectedOperationId } : {}),
     ...(event.source ? { source: source(event.source) } : {}),
     ...(attribution ? { attribution } : {}),
   };
@@ -138,11 +156,13 @@ export function projectRuntimeUsageBoundary(event = {}, outcome) {
       "runtime usage boundary outcome must be started or unknown",
     );
   }
+  const projectedOperationId = operationId(event.operationId);
   const projected = {
     callId: callId(event.callId, { required: true }),
     provider: cleanLabel(event.provider),
     model: cleanLabel(event.model),
     source: source(event.source),
+    ...(projectedOperationId ? { operationId: projectedOperationId } : {}),
   };
   const attribution = projectAttribution(event.attribution);
   if (attribution) projected.attribution = attribution;