chainlesschain 0.162.175 → 0.162.177

package/src/commands/agenda.js

@@ -18,7 +18,6 @@
  *               stop; else re-arm for the next interval
  */
 
-import { spawn, execSync } from "node:child_process";
 import { readFileSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import chalk from "chalk";
@@ -27,6 +26,12 @@ import { sendAgentNotification } from "../lib/agent-notify.js";
 import { nextWakeupAt, partitionSchedule } from "../lib/schedule-planner.js";
 import { monitorEventEnvelope, capEventPayload } from "../lib/monitor-event.js";
 import { unattendedDisallowedTools } from "../lib/unattended-action-policy.js";
+import executionBroker from "../lib/process-execution-broker/index.js";
+
+export const _processDeps = {
+  spawn: (...args) => executionBroker.spawn(...args),
+  execSync: (...args) => executionBroker.execSync(...args),
+};
 
 const BIN_PATH = fileURLToPath(
   new URL("../../bin/chainlesschain.js", import.meta.url),
@@ -53,8 +58,14 @@ export function registerAgendaCommand(program) {
     .description("Fire every entry that is due now")
     .option("--dry-run", "Show what would fire without running anything")
     .option("--json", "Machine-readable JSON output")
+    .option(
+      "--watch <seconds>",
+      "Keep running as a resident scheduler and poll at this interval",
+    )
     .action(async (options) => {
-      process.exitCode = await runAgendaRun(options);
+      process.exitCode = options.watch
+        ? await runAgendaDaemon(options)
+        : await runAgendaRun(options);
     });
 
   cmd
@@ -219,7 +230,11 @@ export async function runAgendaRun(options = {}, _deps = {}) {
   const retired = options.dryRun
     ? partitionSchedule(store.list(), { now }).expired
     : store.retireExpired(now);
-  const due = store.due(null, now);
+  const due = options.dryRun
+    ? store.due(null, now)
+    : typeof store.claimDue === "function"
+      ? store.claimDue(now, options.leaseMs)
+      : store.due(null, now);
   const actions = [];
 
   for (const entry of due) {
@@ -337,6 +352,7 @@ export async function runAgendaRun(options = {}, _deps = {}) {
         }
       }
     } catch (err) {
+      store.releaseClaim?.(entry.id);
       actions.push({
         id: entry.id,
         kind: entry.kind,
@@ -373,6 +389,52 @@ export async function runAgendaRun(options = {}, _deps = {}) {
   return actions.some((a) => a.action === "error") ? 1 : 0;
 }
 
+/**
+ * Resident scheduler loop for `cc agenda run --watch <seconds>`.
+ *
+ * The store remains the source of truth: every tick re-reads durable entries,
+ * retires expired work, and claims due entries through the same lease path as
+ * one-shot execution. A signal or injected AbortSignal stops after the current
+ * tick; `maxTicks` is intentionally supported for deterministic tests.
+ */
+export async function runAgendaDaemon(options = {}, _deps = {}) {
+  const intervalSeconds = Number(options.watch);
+  const intervalMs = Math.max(
+    250,
+    Number.isFinite(intervalSeconds) && intervalSeconds > 0
+      ? intervalSeconds * 1000
+      : 60000,
+  );
+  const signal = options.signal || _deps.signal || null;
+  const runOnce = _deps.runOnce || ((next) => runAgendaRun(next, _deps));
+  const sleep =
+    _deps.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let stopped = Boolean(signal?.aborted);
+  let lastCode = 0;
+  let ticks = 0;
+  const stop = () => {
+    stopped = true;
+  };
+  const onAbort = () => stop();
+  signal?.addEventListener?.("abort", onAbort, { once: true });
+  const onSignal = () => stop();
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  try {
+    while (!stopped) {
+      lastCode = Math.max(lastCode, await runOnce({ ...options, watch: null }));
+      ticks += 1;
+      if (Number.isFinite(_deps.maxTicks) && ticks >= _deps.maxTicks) break;
+      await sleep(intervalMs);
+    }
+  } finally {
+    signal?.removeEventListener?.("abort", onAbort);
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+  }
+  return lastCode;
+}
+
 // ─── default effectful deps (overridable in tests) ─────────────────────────
 
 /**
@@ -397,6 +459,14 @@ export function buildAgentArgs(prompt, policy = null) {
   if (disallow.length > 0) {
     args.push("--disallowed-tools", disallow.join(","));
   }
+  args.push("--unattended");
+  if (
+    policy &&
+    Array.isArray(policy.unattendedAllowlist) &&
+    policy.unattendedAllowlist.length > 0
+  ) {
+    args.push("--unattended-allow", policy.unattendedAllowlist.join(","));
+  }
   if (policy && typeof policy === "object") {
     if (
       typeof policy.permissionMode === "string" &&
@@ -432,13 +502,17 @@ export function buildAgentArgs(prompt, policy = null) {
 
 function defaultSpawnAgent(prompt, policy = null) {
   return new Promise((resolve, reject) => {
-    const child = spawn(
+    const child = _processDeps.spawn(
       process.execPath,
       [BIN_PATH, ...buildAgentArgs(prompt, policy)],
       {
         stdio: "ignore",
         detached: false,
         env: process.env,
+        origin: "agenda:agent-run",
+        policy: "allow",
+        scope: "agenda",
+        shell: false,
       },
     );
     child.on("error", reject);
@@ -452,10 +526,14 @@ function defaultSpawnAgent(prompt, policy = null) {
 
 function defaultRunCommand(command) {
   try {
-    return execSync(command, {
+    return _processDeps.execSync(command, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 60000,
+      origin: "agenda:monitor-command",
+      policy: "allow",
+      scope: "agenda",
+      shell: true,
     });
   } catch (err) {
     // A non-zero exit still yields output we want to match against.

package/src/commands/agent.js

@@ -195,6 +195,14 @@ export function registerAgentCommand(program) {
       "--worktree",
       "Run this session in a fresh git worktree (isolated branch; auto-removed when the session changes nothing)",
     )
+    .option(
+      "--unattended",
+      "Enable fail-closed shell action policy for scheduled/event-driven runs",
+    )
+    .option(
+      "--unattended-allow <classes>",
+      "Comma-separated action classes explicitly allowed for unattended shell runs",
+    )
     .option(
       "--sandbox [image]",
       "Run shell commands in an ephemeral Docker sandbox (network disabled by default)",
@@ -422,6 +430,21 @@ export function registerAgentCommand(program) {
         console.log(JSON.stringify(buildAgentCapabilities(), null, 2));
         return;
       }
+      let toolAdmission = null;
+      if (process.env.CC_TOOL_ADMISSION) {
+        try {
+          const { parseToolAdmissionConfig } =
+            await import("../lib/agent-tool-admission.js");
+          toolAdmission = parseToolAdmissionConfig(
+            process.env.CC_TOOL_ADMISSION,
+          );
+        } catch (error) {
+          process.stderr.write(
+            `CC_TOOL_ADMISSION: ${error.message}; refusing an ungoverned session.\n`,
+          );
+          process.exit(6);
+        }
+      }
       // CC_API_KEY env fallback for --api-key: lets callers (IDE plugins,
       // scripts) pass the key via the environment instead of argv, where it
       // is visible to every local process (/proc/<pid>/cmdline, Win32_Process).
@@ -536,7 +559,7 @@ export function registerAgentCommand(program) {
             _worktreeSettingsHooks =
               loadHooks({ cwd: _worktree.repoRoot }).hooks || null;
             const { runWorktreeCreateHooks, dispatchAsyncHooks } =
-              await import("../lib/settings-hook-events.cjs");
+              await import("../lib/settings-hook-events.js");
             runWorktreeCreateHooks(_worktreeSettingsHooks, {
               worktreePath: _worktree.path,
               branch: _worktree.branch,
@@ -545,7 +568,7 @@ export function registerAgentCommand(program) {
             });
             if (!_worktreeAsyncSupervisor) {
               const { AsyncHookSupervisor } =
-                await import("../lib/async-hook-supervisor.cjs");
+                await import("../lib/async-hook-supervisor.js");
               _worktreeAsyncSupervisor = new AsyncHookSupervisor({
                 persistStats: true,
               });
@@ -606,7 +629,7 @@ export function registerAgentCommand(program) {
           if (_worktreeSettingsHooks) {
             try {
               const { runWorktreeRemoveHooks, dispatchAsyncHooks } =
-                await import("../lib/settings-hook-events.cjs");
+                await import("../lib/settings-hook-events.js");
               runWorktreeRemoveHooks(_worktreeSettingsHooks, {
                 worktreePath: _worktree.path,
                 branch: _worktree.branch,
@@ -754,6 +777,16 @@ export function registerAgentCommand(program) {
           await import("../lib/settings-loader.cjs");
         const sc = loadSettingsConfig({
           cwd: process.cwd(),
+          unattendedActionPolicy: options.unattended
+            ? {
+                unattended: true,
+                allowlist: String(options.unattendedAllow || "")
+                  .split(",")
+                  .map((value) => value.trim())
+                  .filter(Boolean),
+                trigger: { trusted: true },
+              }
+            : null,
           settingsFile: options.settings || null,
         });
         for (const [k, v] of Object.entries(sc.env || {})) {
@@ -997,7 +1030,11 @@ export function registerAgentCommand(program) {
             jsonSchema: options.jsonSchema || null,
           });
         } catch (err) {
-          process.stderr.write(`Error: ${err.message}\n`);
+          process.stderr.write(
+            process.env.CC_DEBUG && err?.stack
+              ? `${err.stack}\n`
+              : `Error: ${err.message}\n`,
+          );
           await _finishWorktree();
           process.exit(1);
         }
@@ -1168,6 +1205,7 @@ export function registerAgentCommand(program) {
           baseUrl: visionLlm.baseUrl || options.baseUrl,
           apiKey: visionLlm.apiKey || options.apiKey,
           sessionId: options.session,
+          toolAdmission,
           // A resolved --session/--continue/--resume id means "replay this
           // conversation and persist the new turns"; the runner loads prior
           // history when the id already exists and creates it otherwise.

package/src/commands/background-session.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { readPrLinkLedger } from "../lib/pr-link-ledger.js";
+import executionBroker from "../lib/process-execution-broker/index.js";
 
 function formatAge(ms) {
   const n = Math.max(0, Math.round(Number(ms || 0) / 1000));
@@ -460,7 +461,6 @@ async function runDashboardView(options = {}) {
 
   const { runBgDashboard } = await import("../repl/bg-dashboard.js");
   const { fileURLToPath } = await import("node:url");
-  const { spawn } = await import("node:child_process");
   const BIN_PATH = fileURLToPath(
     new URL("../../bin/chainlesschain.js", import.meta.url),
   );
@@ -524,10 +524,18 @@ async function runDashboardView(options = {}) {
       await followBackgroundAgent(session.id, { lines: 40 });
     },
     dispatchAgent: async (text) => {
-      const child = spawn(
+      const child = executionBroker.spawn(
         process.execPath,
         [BIN_PATH, "agent", "--bg", "-p", text],
-        { detached: true, stdio: "ignore", windowsHide: true },
+        {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: true,
+          origin: "background-session:dispatch",
+          policy: "allow",
+          scope: "background-session",
+          shell: false,
+        },
       );
       child.unref();
       return null; // id is minted by the launcher; the next refresh shows it
@@ -794,4 +802,3 @@ export function registerBackgroundSessionCommands(program) {
       }
     });
 }
-

package/src/commands/batch.js

@@ -19,8 +19,6 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { spawn } from "child_process";
-import { execFileSync } from "child_process";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { runBatch } from "../lib/agent-batch.js";
@@ -31,6 +29,12 @@ import {
   mergeWorktree,
 } from "../harness/worktree-isolator.js";
 import { findProjectRoot } from "../lib/project-detector.js";
+import executionBroker from "../lib/process-execution-broker/index.js";
+
+export const _processDeps = {
+  spawn: executionBroker.spawn.bind(executionBroker),
+  execFileSync: executionBroker.execFileSync.bind(executionBroker),
+};
 
 const BIN = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
@@ -183,6 +187,26 @@ function sanitize(key) {
   return String(key).replace(/[^a-zA-Z0-9._-]/g, "-");
 }
 
+function spawnBatchProcess(command, args, options, origin) {
+  return _processDeps.spawn(command, args, {
+    ...options,
+    origin,
+    policy: "allow",
+    scope: "batch",
+  });
+}
+
+function runBatchGit(args, cwd, options, origin) {
+  return _processDeps.execFileSync("git", args, {
+    ...options,
+    cwd,
+    origin,
+    policy: "allow",
+    scope: "batch",
+    shell: false,
+  });
+}
+
 function spawnAgent(prompt, cwd, opts = {}) {
   return new Promise((resolve, reject) => {
     const args = [
@@ -196,11 +220,17 @@ function spawnAgent(prompt, cwd, opts = {}) {
       "text",
     ];
     if (opts.model) args.push("--model", opts.model);
-    const child = spawn(process.execPath, args, {
-      cwd,
-      env: { ...process.env, CLAUDECODE: "1" },
-      windowsHide: true,
-    });
+    const child = spawnBatchProcess(
+      process.execPath,
+      args,
+      {
+        cwd,
+        env: { ...process.env, CLAUDECODE: "1" },
+        windowsHide: true,
+        shell: false,
+      },
+      "batch:agent-run",
+    );
     let err = "";
     child.stderr?.on("data", (d) => (err += d.toString("utf8")));
     child.on("error", (e) => reject(new Error(e.message)));
@@ -214,12 +244,17 @@ function spawnAgent(prompt, cwd, opts = {}) {
 
 function runTestCommand(command, cwd) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, {
-      cwd,
-      shell: true,
-      env: process.env,
-      windowsHide: true,
-    });
+    const child = spawnBatchProcess(
+      command,
+      [],
+      {
+        cwd,
+        shell: true,
+        env: process.env,
+        windowsHide: true,
+      },
+      "batch:test-command",
+    );
     let err = "";
     child.stderr?.on("data", (d) => (err += d.toString("utf8")));
     child.on("error", (e) => reject(new Error(e.message)));
@@ -234,11 +269,13 @@ function runTestCommand(command, cwd) {
 /** `git add -A` staged numstat totals for a worktree. */
 function gitDiffStat(cwd) {
   try {
-    execFileSync("git", ["add", "-A"], { cwd, stdio: "ignore" });
-    const out = execFileSync("git", ["diff", "--cached", "--numstat"], {
+    runBatchGit(["add", "-A"], cwd, { stdio: "ignore" }, "batch:git-diff");
+    const out = runBatchGit(
+      ["diff", "--cached", "--numstat"],
       cwd,
-      encoding: "utf8",
-    });
+      { encoding: "utf8" },
+      "batch:git-diff",
+    );
     let insertions = 0;
     let deletions = 0;
     let filesChanged = 0;
@@ -258,11 +295,13 @@ function gitDiffStat(cwd) {
 
 function gitCommitAll(cwd, message) {
   try {
-    execFileSync("git", ["add", "-A"], { cwd, stdio: "ignore" });
-    execFileSync("git", ["commit", "-m", message, "--no-verify"], {
+    runBatchGit(["add", "-A"], cwd, { stdio: "ignore" }, "batch:git-commit");
+    runBatchGit(
+      ["commit", "-m", message, "--no-verify"],
       cwd,
-      stdio: "ignore",
-    });
+      { stdio: "ignore" },
+      "batch:git-commit",
+    );
     return true;
   } catch {
     return false; // nothing to commit / commit failed
@@ -289,11 +328,17 @@ async function decomposeGoal(goal, parts, opts = {}) {
       "plan",
     ];
     if (opts.model) args.push("--model", opts.model);
-    const child = spawn(process.execPath, args, {
-      cwd: opts.repoDir || process.cwd(),
-      env: { ...process.env, CLAUDECODE: "1" },
-      windowsHide: true,
-    });
+    const child = spawnBatchProcess(
+      process.execPath,
+      args,
+      {
+        cwd: opts.repoDir || process.cwd(),
+        env: { ...process.env, CLAUDECODE: "1" },
+        windowsHide: true,
+        shell: false,
+      },
+      "batch:decompose",
+    );
     let out = "";
     let err = "";
     child.stdout?.on("data", (d) => (out += d.toString("utf8")));
@@ -342,4 +387,11 @@ function formatEvent(ev) {
   }
 }
 
-export const _internal = { decomposeGoal, gitDiffStat, DECOMPOSE_SCHEMA };
+export const _internal = {
+  decomposeGoal,
+  gitDiffStat,
+  gitCommitAll,
+  runTestCommand,
+  spawnAgent,
+  DECOMPOSE_SCHEMA,
+};

package/src/commands/changelog.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { VERSION } from "../constants.js";
-import { loadChangelog } from "../lib/changelog.js";
+import { latestCliVersion, loadChangelog } from "../lib/changelog.js";
 import logger from "../lib/logger.js";
 
 /**
@@ -82,10 +82,21 @@ export function registerChangelogCommand(program) {
     .action((version, options) => {
       const data = loadChangelog();
       const releases = data.releases || [];
+      const jsonPayload = (selected) =>
+        JSON.stringify(
+          {
+            ...data,
+            installedVersion: VERSION,
+            latestDocumentedVersion: latestCliVersion(releases),
+            releases: selected,
+          },
+          null,
+          2,
+        );
 
       if (releases.length === 0) {
         if (options.json) {
-          logger.log(JSON.stringify({ releases: [] }, null, 2));
+          logger.log(jsonPayload([]));
         } else {
           logger.warn("No changelog data is bundled with this build.");
         }
@@ -97,7 +108,7 @@ export function registerChangelogCommand(program) {
         selected = matchVersion(releases, version);
         if (selected.length === 0) {
           if (options.json) {
-            logger.log(JSON.stringify({ releases: [] }, null, 2));
+            logger.log(jsonPayload([]));
           } else {
             logger.warn(`No CLI release notes found for "${version}".`);
             logger.info(
@@ -114,7 +125,7 @@ export function registerChangelogCommand(program) {
       }
 
       if (options.json) {
-        logger.log(JSON.stringify({ ...data, releases: selected }, null, 2));
+        logger.log(jsonPayload(selected));
         return;
       }
 

package/src/commands/config.js

@@ -9,6 +9,75 @@ import {
 import { getConfigPath } from "../lib/paths.js";
 import logger from "../lib/logger.js";
 import { listFeatures, setFeature, getFlagInfo } from "../lib/feature-flags.js";
+import { executionBroker } from "../lib/process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
+
+/** Parse the conventional $EDITOR string without invoking a shell. */
+export function parseEditorCommand(value) {
+  const input = String(value || "").trim();
+  if (!input) return [];
+  const tokens = [];
+  let token = "";
+  let quote = null;
+  let started = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+        started = true;
+      } else if (char === "\\" && input[index + 1] === quote) {
+        token += quote;
+        index += 1;
+      } else {
+        token += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (started || token) {
+        tokens.push(token);
+        token = "";
+        started = false;
+      }
+      continue;
+    }
+    if (
+      char === "\\" &&
+      (input[index + 1] === '"' || input[index + 1] === "'")
+    ) {
+      token += input[index + 1];
+      index += 1;
+      started = true;
+      continue;
+    }
+    token += char;
+    started = true;
+  }
+  if (quote) throw new Error("EDITOR contains an unterminated quote");
+  if (started || token) tokens.push(token);
+  return tokens;
+}
+
+export function openConfigEditor(editor, configPath, deps = _deps) {
+  const [file, ...editorArgs] = parseEditorCommand(editor);
+  if (!file) throw new Error("EDITOR command is empty");
+  return deps.spawnSync(file, [...editorArgs, configPath], {
+    stdio: "inherit",
+    origin: "config:editor",
+    policy: "allow",
+    scope: "config",
+    shell: false,
+  });
+}
 
 export function registerConfigCommand(program) {
   const cmd = program
@@ -109,12 +178,8 @@ export function registerConfigCommand(program) {
         process.env.EDITOR ||
         process.env.VISUAL ||
         (process.platform === "win32" ? "notepad" : "vi");
-      const { execSync } = await import("node:child_process");
       try {
-        // Escape any `"` in the path so it can't break out of the quoted arg
-        // (editor stays unquoted so `$EDITOR` values with args still work).
-        const safePath = configPath.replace(/"/g, '\\"');
-        execSync(`${editor} "${safePath}"`, { stdio: "inherit" });
+        openConfigEditor(editor, configPath);
       } catch (err) {
         logger.error(`Failed to open editor: ${err.message}`);
         logger.info(`Config file is at: ${configPath}`);

package/src/commands/context.js

@@ -100,12 +100,17 @@ export function registerContextCommand(program) {
       // different window.
       let recordedModel = "";
       let recordedProvider = "";
+      let recordedContextSources = null;
       try {
-        const start = (readEvents(sessionId) || []).find(
+        const sessionEvents = readEvents(sessionId) || [];
+        const start = sessionEvents.find(
           (e) => e.type === "session_start",
         );
         recordedModel = start?.data?.model || "";
         recordedProvider = start?.data?.provider || "";
+        recordedContextSources = [...sessionEvents]
+          .reverse()
+          .find((e) => e.type === "context_sources")?.data || null;
       } catch {
         // header optional — fall through to flags/defaults
       }
@@ -129,7 +134,12 @@ export function registerContextCommand(program) {
         try {
           const { loadProjectInstructions } =
             await import("../lib/project-instructions.js");
-          const { breakdownInstructionSources, rankContextSources } =
+          const {
+            breakdownInstructionSources,
+            breakdownMcpSchemas,
+            breakdownSkillSources,
+            rankContextSources,
+          } =
             await import("../lib/context-breakdown.js");
           const cwd = process.cwd();
           let instructionExcludes;
@@ -151,15 +161,37 @@ export function registerContextCommand(program) {
             estimateTokens,
             cwd,
           );
+          const mcp = breakdownMcpSchemas(
+            recordedContextSources?.mcp || [],
+            estimateTokens,
+          );
+          const skills = breakdownSkillSources(
+            recordedContextSources?.skills || [],
+            estimateTokens,
+          );
           const ranked = rankContextSources({
             instructionTotal: instr.total,
             buckets,
             counts,
+            extraSources: [
+              ...mcp.sources.map((source) => ({
+                ...source,
+                kind: "mcp_schema",
+              })),
+              ...skills.sources.map((source) => ({
+                ...source,
+                kind: "skill",
+              })),
+            ],
           });
           sourceReport = {
             cwd,
             instructions: instr.sources,
             instructionTokens: instr.total,
+            mcpSchemas: mcp.sources,
+            mcpSchemaTokens: mcp.total,
+            skills: skills.sources,
+            skillTokens: skills.total,
             ranked: ranked.sources,
             combinedTotal: ranked.total,
           };
@@ -189,6 +221,8 @@ export function registerContextCommand(program) {
                     sources: sourceReport.ranked,
                     instructions: sourceReport.instructions,
                     instructionTokens: sourceReport.instructionTokens,
+                    mcpSchemas: sourceReport.mcpSchemas,
+                    mcpSchemaTokens: sourceReport.mcpSchemaTokens,
                     combinedTotal: sourceReport.combinedTotal,
                     cwd: sourceReport.cwd,
                   }