chainlesschain 0.162.174 → 0.162.176

package/src/lib/channels/telegram-channel.js

@@ -13,6 +13,7 @@
 
 const POLL_TIMEOUT_S = 25;
 const ERROR_BACKOFF_MS = 5000;
+import { EventRuntimeProducer } from "../event-runtime-producer.js";
 
 export async function startTelegramChannel(options = {}) {
   const {
@@ -27,7 +28,11 @@ export async function startTelegramChannel(options = {}) {
     // failures) can never turn the loop into a microtask chain that starves
     // the event loop (timers, stop()) entirely.
     pollPauseMs = 50,
+    eventRuntimeStore = null,
   } = options;
+  const runtimeProducer = eventRuntimeStore
+    ? new EventRuntimeProducer({ store: eventRuntimeStore })
+    : null;
 
   if (!botToken) {
     throw new Error(
@@ -65,12 +70,17 @@ export async function startTelegramChannel(options = {}) {
           if (!chatId || !text) continue;
           if (!allowed.has(String(chatId))) continue; // fail closed
           try {
-            onEvent?.({
+            const event = {
               channel: "telegram",
               sender: String(chatId),
               text,
               meta: { updateId: update.update_id },
+            };
+            runtimeProducer?.publish(event, {
+              origin: "telegram",
+              id: `telegram:${update.update_id}`,
             });
+            onEvent?.(event);
           } catch {
             /* downstream owns its failures */
           }

package/src/lib/channels/webhook-channel.js

@@ -17,6 +17,7 @@
 
 import { createServer } from "node:http";
 import { randomBytes, timingSafeEqual } from "node:crypto";
+import { EventRuntimeProducer } from "../event-runtime-producer.js";
 
 const MAX_BODY_BYTES = 64 * 1024;
 
@@ -34,7 +35,11 @@ export async function startWebhookChannel(options = {}) {
     allowlist,
     onEvent,
     log = () => {},
+    eventRuntimeStore = null,
   } = options;
+  const runtimeProducer = eventRuntimeStore
+    ? new EventRuntimeProducer({ store: eventRuntimeStore })
+    : null;
 
   const isLoopback =
     host === "127.0.0.1" || host === "::1" || host === "localhost";
@@ -92,8 +97,7 @@ export async function startWebhookChannel(options = {}) {
           return respond(403, { error: "sender not in allowlist" });
         }
       }
-      try {
-        onEvent?.({
+      const event = {
           channel: "webhook",
           sender,
           text,
@@ -101,9 +105,17 @@ export async function startWebhookChannel(options = {}) {
             payload.meta && typeof payload.meta === "object"
               ? payload.meta
               : undefined,
+        };
+      try {
+        runtimeProducer?.publish(event, {
+          origin: "webhook",
+          id: payload.event_id || payload.eventId || null,
         });
+        onEvent?.(event);
       } catch {
-        /* the session queue owns downstream failures */
+        // A configured durable runtime is the recovery boundary. Refuse the
+        // request rather than acknowledging an event that was not persisted.
+        if (runtimeProducer) return respond(503, { error: "event persistence unavailable" });
       }
       respond(202, { ok: true });
     });

package/src/lib/checkpoint-store.js

@@ -18,9 +18,13 @@
  * is. When it is not, callers should fall back / report unavailable.
  */
 
-import { spawnSync } from "node:child_process";
 import { rmSync } from "node:fs";
 import path from "node:path";
+import executionBroker from "./process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 const REF_NS = "refs/cc-checkpoints";
 // Deterministic identity for shadow commits so `git commit-tree` never trips on
@@ -41,7 +45,11 @@ const CHECKPOINT_IDENTITY = Object.freeze({
  * @throws {Error} with git's stderr when the command fails
  */
 function git(args, { cwd, env, input } = {}) {
-  const res = spawnSync("git", args, {
+  const res = _deps.spawnSync("git", args, {
+    origin: "checkpoint:git",
+    scope: "checkpoint",
+    policy: "allow",
+    shell: false,
     cwd,
     input,
     encoding: "utf-8",

package/src/lib/cloud/bundle.js

@@ -7,13 +7,23 @@
  * a repo.
  */
 
-import { execFileSync } from "node:child_process";
 import { writeFileSync, mkdtempSync } from "node:fs";
 import { readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { executionBroker } from "../process-execution-broker/index.js";
 
-export const _deps = { execFileSync };
+function brokerExecFileSync(file, args, options) {
+  return executionBroker.execFileSync(file, args, {
+    ...options,
+    origin: "cloud:git",
+    policy: "allow",
+    scope: "cloud",
+    shell: false,
+  });
+}
+
+export const _deps = { execFileSync: brokerExecFileSync };
 
 function git(args, cwd, deps = _deps) {
   return deps

package/src/lib/code-review.js

@@ -4,8 +4,37 @@
  * @module lib/code-review
  */
 
-import { execSync } from "child_process";
 import { logger } from "./logger.js";
+import { executionBroker } from "./process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
+
+export function buildGitDiffArgs(
+  target = "--staged",
+  { nameOnly = false } = {},
+) {
+  const args = ["diff"];
+  if (nameOnly) args.push("--name-only");
+  if (target === "--staged" || target === "--cached") {
+    args.push(target);
+  } else {
+    args.push("--end-of-options", String(target), "--");
+  }
+  return args;
+}
+
+function gitDiff(target, options = {}) {
+  return _deps.execFileSync("git", buildGitDiffArgs(target, options), {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+    origin: "review:git-diff",
+    policy: "allow",
+    scope: "review",
+    shell: false,
+  });
+}
 
 /**
  * Get git diff for review
@@ -14,10 +43,7 @@ import { logger } from "./logger.js";
  */
 export function getGitDiff(target = "--staged") {
   try {
-    return execSync(`git diff ${target}`, {
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024,
-    });
+    return gitDiff(target);
   } catch (err) {
     logger.error(`Failed to get git diff: ${err.message}`);
     return "";
@@ -31,9 +57,7 @@ export function getGitDiff(target = "--staged") {
  */
 export function getChangedFiles(target = "--staged") {
   try {
-    const output = execSync(`git diff ${target} --name-only`, {
-      encoding: "utf8",
-    });
+    const output = gitDiff(target, { nameOnly: true });
     return output.trim().split("\n").filter(Boolean);
   } catch (err) {
     logger.error(`Failed to get changed files: ${err.message}`);

package/src/lib/computer-use/control-backend.js

@@ -7,16 +7,27 @@
  * project's U-Key/hardware posture.
  */
 
-import { spawnSync } from "node:child_process";
+import executionBroker from "../process-execution-broker/index.js";
 
-export const _deps = { spawnSync, platform: () => process.platform };
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+  platform: () => process.platform,
+};
 
 /** Run a PowerShell script, returning { ok, stdout, stderr }. */
 function runPowerShell(script, deps = _deps) {
   const res = deps.spawnSync(
     "powershell.exe",
     ["-NoProfile", "-NonInteractive", "-Command", script],
-    { encoding: "utf-8", windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
+    {
+      encoding: "utf-8",
+      windowsHide: true,
+      maxBuffer: 16 * 1024 * 1024,
+      origin: "computer-use:powershell",
+      scope: "computer-use",
+      policy: "allow",
+      shell: false,
+    },
   );
   if (res.error) return { ok: false, stdout: "", stderr: res.error.message };
   return {
@@ -140,6 +151,10 @@ export function createWindowsBackend(deps = _deps) {
           windowsHide: false,
           detached: true,
           stdio: "ignore",
+          origin: "computer-use:app-launch",
+          scope: "computer-use",
+          policy: "allow",
+          shell: false,
         });
         return res.error
           ? { ok: false, error: res.error.message }

package/src/lib/context-breakdown.js

@@ -57,6 +57,41 @@ export function breakdownInstructionSources(files, estimateTokens, cwd) {
   return { sources, total };
 }
 
+/** Attribute the exact MCP tool schemas admitted to a persisted run. */
+export function breakdownMcpSchemas(definitions, estimateTokens) {
+  const est = typeof estimateTokens === "function" ? estimateTokens : () => 0;
+  const list = Array.isArray(definitions) ? definitions : [];
+  const sources = list
+    .map((definition) => {
+      const fn = definition?.function || definition || {};
+      const name = String(fn.name || definition?.name || "mcp");
+      const schema = fn.parameters || definition?.inputSchema || {};
+      return {
+        source: name.split("__")[1] || name,
+        tool: name,
+        tokens: est(JSON.stringify({ description: fn.description || "", parameters: schema })),
+      };
+    })
+    .filter((row) => row.tokens > 0);
+  return { sources, total: sources.reduce((sum, row) => sum + row.tokens, 0) };
+}
+
+/** Attribute Skill bodies that were actually injected into the system prompt. */
+export function breakdownSkillSources(skills, estimateTokens) {
+  const est = typeof estimateTokens === "function" ? estimateTokens : () => 0;
+  const list = Array.isArray(skills) ? skills : [];
+  const sources = list
+    .map((skill) => ({
+      source: skill?.source || "skill",
+      skill: String(skill?.id || skill?.displayName || "skill"),
+      tokens: est(
+        `## Persona: ${skill?.displayName || skill?.id || "skill"}\n${skill?.body || ""}`,
+      ),
+    }))
+    .filter((row) => row.tokens > 0);
+  return { sources, total: sources.reduce((sum, row) => sum + row.tokens, 0) };
+}
+
 // role bucket key → { label, kind } for the ranked source list.
 const MESSAGE_SOURCE_ROWS = [
   ["system", "system messages", "message"],
@@ -84,6 +119,7 @@ export function rankContextSources({
   instructionTotal = 0,
   buckets = {},
   counts = {},
+  extraSources = [],
 } = {}) {
   const rows = [];
   if (instructionTotal > 0) {
@@ -105,6 +141,16 @@ export function rankContextSources({
       });
     }
   }
+  for (const row of Array.isArray(extraSources) ? extraSources : []) {
+    if (!row || !(row.tokens > 0)) continue;
+    rows.push({
+      kind: row.kind || "runtime",
+      source: row.source || "runtime",
+      tokens: row.tokens,
+      count: row.count ?? null,
+      tool: row.tool || null,
+    });
+  }
   const total = rows.reduce((s, x) => s + x.tokens, 0);
   // Stable sort: tokens desc, then source name for deterministic ties.
   rows.sort((a, b) => b.tokens - a.tokens || a.source.localeCompare(b.source));

package/src/lib/context-source-ledger.js

@@ -43,6 +43,7 @@ class ContextSourceLedger {
     const entryId = entry.entryId || crypto.randomUUID();
     const full = {
       entryId,
+      traceId: entry.traceId || null,
       sessionId: entry.sessionId || "unknown",
       turnId: entry.turnId || "unknown",
       sourceType: entry.sourceType || "unknown",
@@ -69,6 +70,48 @@ class ContextSourceLedger {
     return entryId;
   }
 
+  /** Compatibility adapter for runtime provenance producers. */
+  recordRead(entry = {}) {
+    return this.record({
+      sessionId: entry.sessionId,
+      turnId: entry.turnId,
+      sourceType: entry.sourceType || entry.source || "unknown",
+      sourceId: entry.sourceId || entry.span || "unknown",
+      permissionMode: entry.permissionMode || "agent",
+      confidence: entry.confidence,
+      summary: entry.summary || entry.content,
+      metadata: entry.metadata,
+      tokenCount: entry.tokenCount ?? entry.tokens ?? 0,
+      traceId: entry.traceId,
+    });
+  }
+
+  /** Return a flat, read-only provenance snapshot for diagnostics/export. */
+  getProvenance({ sessionId, turnId } = {}) {
+    let entries = Array.from(this._entries.values());
+    if (sessionId) entries = entries.filter((e) => e.sessionId === sessionId);
+    if (turnId) entries = entries.filter((e) => e.turnId === turnId);
+    return entries.map((entry) => ({ ...entry, tags: [...entry.tags] }));
+  }
+
+  /** Aggregate token usage by source type. */
+  getTokenBreakdown() {
+    const bySource = {};
+    let total = 0;
+    for (const entry of this._entries.values()) {
+      total += entry.tokenCount;
+      bySource[entry.sourceType] = (bySource[entry.sourceType] || 0) + entry.tokenCount;
+    }
+    return { total, bySource };
+  }
+
+  /** Clear the in-memory ledger (test/runtime lifecycle boundary). */
+  clear() {
+    this._entries.clear();
+    this._byTurn.clear();
+    this._bySession.clear();
+  }
+
   /**
    * Get all context entries for a given turn
    * @param {string} turnId

package/src/lib/crash-reporter.js

@@ -0,0 +1,6 @@
+/**
+ * Crash reporter stub
+ */
+export function installCrashReporter() {
+  // No-op stub for tests
+}

package/src/lib/diff-review-follow-up.js

@@ -0,0 +1,154 @@
+/**
+ * Correlate an IDE Diff "Request changes" decision with the next review of the
+ * same file. The tracker writes only bounded review metadata into the existing
+ * side-effect ledger; model text and file content are never copied.
+ */
+
+const MAX_ID = 256;
+const MAX_PATH = 2048;
+const MAX_REASON = 256;
+const VALID_OUTCOMES = new Set(["accepted", "rejected", "changes-requested"]);
+
+function bounded(value, max) {
+  if (value == null) return null;
+  const text = String(value).slice(0, max);
+  return text || null;
+}
+
+function reviewKey(audit) {
+  const path = bounded(audit?.path, MAX_PATH);
+  if (!path) return null;
+  return `${bounded(audit?.sessionId, MAX_ID) || ""}\0${path}`;
+}
+
+function pendingFollowUp(audit) {
+  return {
+    status: "pending",
+    requestedAt: bounded(audit?.createdAt, 64),
+  };
+}
+
+function reviewedFollowUp(audit) {
+  const outcome = VALID_OUTCOMES.has(audit?.outcome)
+    ? audit.outcome
+    : "rejected";
+  return {
+    status: outcome,
+    reviewId: bounded(audit?.reviewId, 64),
+    turnId: bounded(audit?.turnId, MAX_ID),
+    toolUseId: bounded(audit?.toolUseId, MAX_ID),
+    operation: bounded(audit?.operation, 16) || "modify",
+    targetPath:
+      audit?.operation === "rename"
+        ? bounded(audit?.targetPath, MAX_PATH)
+        : null,
+    written: audit?.written === true,
+    completedAt: bounded(audit?.createdAt, 64),
+  };
+}
+
+function terminalFollowUp(status, { turnId = null, reason = null } = {}) {
+  return {
+    status,
+    turnId: bounded(turnId, MAX_ID),
+    reason: bounded(reason, MAX_REASON),
+  };
+}
+
+/**
+ * Ledger-facing tracker. `ledger` only needs `list()` and `annotate()` methods,
+ * which keeps the correlation logic independently testable.
+ */
+export class DiffReviewFollowUpTracker {
+  constructor(ledger = null) {
+    this._pending = new Map();
+    if (ledger) this.hydrate(ledger);
+  }
+
+  /** Restore only explicitly-pending v1 records after a process/session resume. */
+  hydrate(ledger) {
+    this._pending.clear();
+    for (const op of ledger?.list?.() || []) {
+      const audit = op?.meta?.diffReview;
+      if (
+        audit?.schema !== "cc-diff-review/v1" ||
+        audit?.outcome !== "changes-requested" ||
+        audit?.followUp?.status !== "pending"
+      ) {
+        continue;
+      }
+      const key = reviewKey(audit);
+      if (key) this._pending.set(key, { opId: op.opId, audit });
+    }
+    return this;
+  }
+
+  /**
+   * Attach the current audit and, when applicable, resolve the preceding
+   * Request Changes record for the same trusted session/path.
+   */
+  observe(ledger, opId, audit) {
+    if (!ledger?.annotate || !opId || audit?.schema !== "cc-diff-review/v1") {
+      return [];
+    }
+    const updates = [];
+    const key = reviewKey(audit);
+    const prior = key ? this._pending.get(key) : null;
+    let currentAudit = audit;
+    if (prior && prior.opId !== opId) {
+      const followUp = reviewedFollowUp(audit);
+      ledger.annotate(prior.opId, {
+        diffReview: { ...prior.audit, followUp },
+      });
+      this._pending.delete(key);
+      currentAudit = {
+        ...audit,
+        followUpOfReviewId: bounded(prior.audit.reviewId, 64),
+      };
+      updates.push({
+        reviewId: prior.audit.reviewId || null,
+        followUp,
+      });
+    }
+
+    if (audit.outcome === "changes-requested" && key) {
+      currentAudit = { ...currentAudit, followUp: pendingFollowUp(audit) };
+      this._pending.set(key, { opId, audit: currentAudit });
+    }
+    ledger.annotate(opId, { diffReview: currentAudit });
+    return updates;
+  }
+
+  /**
+   * Settle every still-pending request when the agent run ends without another
+   * Diff proposal. Returns updates so callers can decide whether persistence is
+   * necessary.
+   */
+  complete(
+    ledger,
+    {
+      status = "completed-without-reproposal",
+      turnId = null,
+      reason = null,
+    } = {},
+  ) {
+    if (!ledger?.annotate || this._pending.size === 0) return [];
+    const updates = [];
+    for (const pending of this._pending.values()) {
+      const followUp = terminalFollowUp(status, { turnId, reason });
+      ledger.annotate(pending.opId, {
+        diffReview: { ...pending.audit, followUp },
+      });
+      updates.push({
+        reviewId: pending.audit.reviewId || null,
+        followUp,
+      });
+    }
+    this._pending.clear();
+    return updates;
+  }
+
+  get pendingCount() {
+    return this._pending.size;
+  }
+}

package/src/lib/downloader.js

@@ -7,12 +7,16 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { pipeline } from "node:stream/promises";
-import { execFileSync } from "node:child_process";
 import ora from "ora";
 import { GITHUB_RELEASES_URL } from "../constants.js";
 import { getBinDir, ensureDir } from "./paths.js";
 import { getPlatform, getArch } from "./platform.js";
 import logger from "./logger.js";
+import { executionBroker } from "./process-execution-broker/index.js";
+
+function brokerExecFileSync(file, args, options) {
+  return executionBroker.execFileSync(file, args, options);
+}
 
 // Platform-specific asset matching patterns
 const ASSET_PATTERNS = {
@@ -211,7 +215,7 @@ async function fetchRelease(url) {
 export function extractZip(
   zipPath,
   destDir,
-  { execFileImpl = execFileSync, platform = getPlatform() } = {},
+  { execFileImpl = brokerExecFileSync, platform = getPlatform() } = {},
 ) {
   // Never interpolate the paths into a shell string — `zipPath`/`destDir` derive
   // from the (remote) release asset name, so a `"`/`$()`/`'` in a path would be a
@@ -229,10 +233,20 @@ export function extractZip(
       {
         stdio: "ignore",
         env: { ...process.env, CC_ZIP_SRC: zipPath, CC_ZIP_DEST: destDir },
+        origin: "update:archive-extract",
+        policy: "allow",
+        scope: "update",
+        shell: false,
       },
     );
   } else {
-    execFileImpl("unzip", ["-o", zipPath, "-d", destDir], { stdio: "ignore" });
+    execFileImpl("unzip", ["-o", zipPath, "-d", destDir], {
+      stdio: "ignore",
+      origin: "update:archive-extract",
+      policy: "allow",
+      scope: "update",
+      shell: false,
+    });
   }
 }
 

package/src/lib/ensure-utf8.js

@@ -7,11 +7,13 @@
  * Node.js streams to use UTF-8 encoding.
  */
 
-import { execSync } from "child_process";
+import { executionBroker } from "./process-execution-broker/index.js";
 
 // Injectable so tests can assert whether the (expensive) chcp spawn happened
 // without actually spawning cmd.exe. See cli-dev.md `_deps` pattern.
-export const _deps = { execSync };
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
 
 /**
  * Call this as early as possible in the process entry point.
@@ -34,7 +36,13 @@ export function ensureUtf8() {
     Boolean(process.stderr && process.stderr.isTTY);
   if (consoleAttached || process.env.CC_FORCE_CHCP === "1") {
     try {
-      _deps.execSync("chcp 65001", { stdio: "ignore" });
+      _deps.execFileSync("cmd.exe", ["/d", "/s", "/c", "chcp 65001"], {
+        stdio: "ignore",
+        origin: "runtime:utf8-console",
+        policy: "allow",
+        scope: "runtime",
+        shell: false,
+      });
     } catch (_err) {
       // Ignore - may fail in non-interactive environments
     }

package/src/lib/event-runtime-producer.js

@@ -0,0 +1,58 @@
+/** Canonical producer boundary for durable Event Runtime events. */
+
+import { EventEmitter } from "node:events";
+import { eventId } from "./event-runtime-store.js";
+
+const ALLOWED_ORIGINS = new Set([
+  "agenda",
+  "monitor",
+  "webhook",
+  "telegram",
+  "mcp",
+  "hook",
+  "agent-ipc",
+  "system",
+]);
+
+function normalizeOrigin(origin) {
+  const value = String(origin || "system").trim().toLowerCase();
+  if (!ALLOWED_ORIGINS.has(value)) throw new Error(`unsupported event origin: ${value}`);
+  return value;
+}
+
+/**
+ * Publish an event with an immutable producer envelope. The store remains the
+ * source of truth; the optional emitter is only a low-latency notification.
+ */
+export class EventRuntimeProducer extends EventEmitter {
+  constructor({ store, emitter = null, now = () => Date.now() } = {}) {
+    super();
+    if (!store || typeof store.enqueue !== "function") {
+      throw new Error("EventRuntimeProducer requires a durable EventRuntimeStore");
+    }
+    this.store = store;
+    this.emitter = emitter;
+    this._now = now;
+  }
+
+  publish(event, { origin = "system", queue = "inbox", id = null, metadata = null } = {}) {
+    if (queue !== "inbox" && queue !== "outbox") throw new Error(`unsupported event queue: ${queue}`);
+    const producer = normalizeOrigin(origin);
+    const base = {
+      ...(event && typeof event === "object" ? event : { value: event }),
+      origin: producer,
+    };
+    const payload = { ...base, producedAt: this._now(), authority: "system" };
+    const record = this.store.enqueue(queue, payload, {
+      id: id || eventId(base),
+      metadata: { ...(metadata || {}), producer: producer },
+    });
+    if (!record.duplicate) {
+      this.emit("published", record);
+      this.emitter?.emit?.("event-runtime:published", record);
+    }
+    return record;
+  }
+}
+
+export { ALLOWED_ORIGINS };