chainlesschain 0.162.175 → 0.162.177

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/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/doctor-checkup.js

@@ -23,9 +23,9 @@ import {
   statSync,
   rmSync,
 } from "node:fs";
-import { execSync, spawnSync } from "node:child_process";
 import { join, basename } from "node:path";
 import { getHomeDir, getConfigPath } from "./paths.js";
+import executionBroker from "./process-execution-broker/index.js";
 import {
   languageIdForFile,
   resolveServer,
@@ -59,8 +59,8 @@ export const _deps = {
   readFileSync,
   statSync,
   rmSync,
-  execSync,
-  spawnSync,
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
   now: () => Date.now(),
 };
 
@@ -549,10 +549,14 @@ async function worktreeSection(opts, deps) {
   try {
     const inRepo = (() => {
       try {
-        deps.execSync("git rev-parse --is-inside-work-tree", {
+        deps.execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
           cwd,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"],
+          origin: "doctor:git-worktree",
+          policy: "allow",
+          scope: "diagnostics",
+          shell: false,
         });
         return true;
       } catch {
@@ -570,10 +574,14 @@ async function worktreeSection(opts, deps) {
       );
     } else {
       const out =
-        deps.execSync("git worktree prune --dry-run -v", {
+        deps.execFileSync("git", ["worktree", "prune", "--dry-run", "-v"], {
           cwd,
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"],
+          origin: "doctor:git-worktree",
+          policy: "allow",
+          scope: "diagnostics",
+          shell: false,
         }) || "";
       const prunable = out.split("\n").filter((l) => l.trim()).length;
       if (prunable > 0) {
@@ -1138,10 +1146,14 @@ export async function runCheckupFixes(sections, opts = {}) {
           detail: `removed ${removed} file(s)`,
         });
       } else if (fix.id === "git-worktree-prune") {
-        deps.execSync("git worktree prune", {
+        deps.execFileSync("git", ["worktree", "prune"], {
           cwd: opts.cwd || process.cwd(),
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "ignore"],
+          origin: "doctor:git-worktree-fix",
+          policy: "allow",
+          scope: "diagnostics",
+          shell: false,
         });
         results.push({
           id: fix.id,

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/eval/tasks.js

@@ -11,7 +11,24 @@
 
 import fs from "fs";
 import path from "path";
-import { execFileSync } from "node:child_process";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
+
+function runTaskCheck(dir, script, options = {}) {
+  return _deps.execFileSync(process.execPath, [script], {
+    cwd: dir,
+    timeout: 10000,
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options,
+    origin: "eval:task-check",
+    policy: "allow",
+    scope: "eval",
+    shell: false,
+  });
+}
 
 function read(dir, rel) {
   try {
@@ -97,11 +114,8 @@ export const BUILTIN_TASKS = [
       // Objective check: it must parse AND print OK. Re-run in a child so we
       // score the actual behavior, not a heuristic on the source.
       try {
-        const out = execFileSync(process.execPath, ["bug.js"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "bug.js", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"], // capture stderr, don't inherit
         });
         return out.trim() === "OK"
           ? { pass: true, detail: "node bug.js prints OK" }
@@ -186,11 +200,8 @@ export const BUILTIN_TASKS = [
         };
       }
       try {
-        const out = execFileSync(process.execPath, ["run-checks.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "run-checks.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.includes("ALL OK")
           ? { pass: true, detail: "test suite passes" }
@@ -243,11 +254,8 @@ export const BUILTIN_TASKS = [
       }
       // Behavior must be preserved: run main.js and check the output.
       try {
-        const out = execFileSync(process.execPath, ["main.js"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "main.js", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.trim() === "6"
           ? { pass: true, detail: "renamed + behavior preserved" }
@@ -290,12 +298,7 @@ export const BUILTIN_TASKS = [
       if (read(dir, "verify.mjs") == null) {
         return { pass: false, detail: "verify.mjs not created" };
       }
-      const run = () =>
-        execFileSync(process.execPath, ["verify.mjs"], {
-          cwd: dir,
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
-        });
+      const run = () => runTaskCheck(dir, "verify.mjs");
       // 1) The verifier must PASS against the correct implementation.
       try {
         run();
@@ -383,11 +386,8 @@ export const BUILTIN_TASKS = [
         };
       }
       try {
-        const out = execFileSync(process.execPath, ["app.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "app.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         }).trim();
         return out === "Hello, Ada!\nHello, Bob!!!"
           ? { pass: true, detail: "signature migrated + callers updated" }
@@ -525,11 +525,8 @@ export const BUILTIN_TASKS = [
         };
       }
       try {
-        const out = execFileSync(process.execPath, ["build.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "build.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.includes("BUILD OK")
           ? { pass: true, detail: "build links + passes" }
@@ -620,11 +617,8 @@ export const BUILTIN_TASKS = [
         return { pass: false, detail: "app.mjs does not use the new toTitle" };
       }
       try {
-        const out = execFileSync(process.execPath, ["run.mjs"], {
-          cwd: dir,
+        const out = runTaskCheck(dir, "run.mjs", {
           encoding: "utf8",
-          timeout: 10000,
-          stdio: ["ignore", "pipe", "pipe"],
         });
         return out.trim() === "OK"
           ? { pass: true, detail: "adapted to new API + manifest bumped" }

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 };