chainlesschain 0.162.176 → 0.162.178

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/context.js

@@ -138,6 +138,8 @@ export function registerContextCommand(program) {
             breakdownInstructionSources,
             breakdownMcpSchemas,
             breakdownSkillSources,
+            breakdownSkillCache,
+            buildContextOptimizations,
             rankContextSources,
           } =
             await import("../lib/context-breakdown.js");
@@ -169,6 +171,9 @@ export function registerContextCommand(program) {
             recordedContextSources?.skills || [],
             estimateTokens,
           );
+          const skillCache = breakdownSkillCache(
+            recordedContextSources?.skillCache,
+          );
           const ranked = rankContextSources({
             instructionTotal: instr.total,
             buckets,
@@ -192,6 +197,12 @@ export function registerContextCommand(program) {
             mcpSchemaTokens: mcp.total,
             skills: skills.sources,
             skillTokens: skills.total,
+            skillCache,
+            optimizations: buildContextOptimizations({
+              instructions: instr.sources,
+              mcpSchemas: mcp.sources,
+              skillCache,
+            }),
             ranked: ranked.sources,
             combinedTotal: ranked.total,
           };
@@ -223,6 +234,10 @@ export function registerContextCommand(program) {
                     instructionTokens: sourceReport.instructionTokens,
                     mcpSchemas: sourceReport.mcpSchemas,
                     mcpSchemaTokens: sourceReport.mcpSchemaTokens,
+                    skills: sourceReport.skills,
+                    skillTokens: sourceReport.skillTokens,
+                    skillCache: sourceReport.skillCache,
+                    optimizations: sourceReport.optimizations,
                     combinedTotal: sourceReport.combinedTotal,
                     cwd: sourceReport.cwd,
                   }
@@ -314,6 +329,23 @@ export function registerContextCommand(program) {
               `${chalk.cyan(bar(s.share))} ${String(Math.round(s.share * 100)).padStart(3)}%`,
           );
         }
+        if (sourceReport.skillCache.descriptors.resident > 0) {
+          logger.log("");
+          logger.log(
+            chalk.gray(
+              `  Skill cache: ${sourceReport.skillCache.descriptors.resident} descriptors, ` +
+                `${sourceReport.skillCache.bodies.resident} bodies resident, ` +
+                `${sourceReport.skillCache.savings.estimatedTokensAvoided} estimated tokens kept lazy`,
+            ),
+          );
+        }
+        if (sourceReport.optimizations.length > 0) {
+          logger.log("");
+          logger.log(chalk.bold("Optimization hints"));
+          for (const hint of sourceReport.optimizations) {
+            logger.log(chalk.gray("  路 ") + hint.message);
+          }
+        }
         logger.log(
           chalk.gray(
             "  note: instructions reflect the current cwd (what a new run here",
@@ -326,7 +358,7 @@ export function registerContextCommand(program) {
         );
         logger.log(
           chalk.gray(
-            "  tool schemas load at runtime and are not counted here.",
+            "  costs come from the newest persisted runtime source snapshot.",
           ),
         );
       }

package/src/commands/eval.js

@@ -11,15 +11,22 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { spawn, spawnSync } from "child_process";
 import { runEvalSuite } from "../lib/eval/runner.js";
 import { getSuite } from "../lib/eval/tasks.js";
+import executionBroker from "../lib/process-execution-broker/index.js";
 import {
   TelemetryRecorder,
   formatTelemetry,
 } from "../lib/telemetry/span-recorder.js";
 import { computeTrend, formatTrend } from "../lib/eval/trend.js";
 
+export const _deps = {
+  platform: process.platform,
+  kill: process.kill.bind(process),
+  spawn: executionBroker.spawn.bind(executionBroker),
+  spawnSync: executionBroker.spawnSync.bind(executionBroker),
+};
+
 /** Append a run summary as one JSONL line to the history file. */
 function appendHistory(file, record) {
   fs.appendFileSync(file, JSON.stringify(record) + "\n", "utf8");
@@ -55,18 +62,22 @@ const BIN = path.resolve(__dirname, "..", "..", "bin", "chainlesschain.js");
  */
 function killAgentTree(child) {
   if (!child || !child.pid) return;
-  if (process.platform === "win32") {
+  if (_deps.platform === "win32") {
     try {
-      spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+      _deps.spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
         windowsHide: true,
         timeout: 10000,
+        origin: "eval:agent-tree-kill",
+        policy: "allow",
+        scope: "eval",
+        shell: false,
       });
     } catch {
       /* fall through to the direct kill below */
     }
   } else {
     try {
-      process.kill(-child.pid, "SIGKILL"); // negative pid = process group
+      _deps.kill(-child.pid, "SIGKILL"); // negative pid = process group
       return;
     } catch {
       /* not a group leader / already gone — fall through */
@@ -105,12 +116,16 @@ function makeHeadlessRunAgent(opts = {}) {
         if (opts.model) args.push("--model", opts.model);
         if (opts.provider) args.push("--provider", opts.provider);
       }
-      const child = spawn(process.execPath, args, {
+      const child = _deps.spawn(process.execPath, args, {
         cwd,
         env: { ...process.env, CLAUDECODE: "1" },
         windowsHide: true,
         // Own process group on POSIX so a timeout can reap the whole tree.
-        detached: process.platform !== "win32",
+        detached: _deps.platform !== "win32",
+        origin: "eval:agent-run",
+        policy: "allow",
+        scope: "eval",
+        shell: false,
       });
       let out = "";
       let err = "";

package/src/commands/hook.js

@@ -173,7 +173,7 @@ export function registerHookCommand(program) {
           return;
         }
 
-        const { runHooks } = await import("../lib/hook-runner.cjs");
+        const { runHooks } = await import("../lib/hook-runner.js");
         const outcome = runHooks(matched, payload, {
           cwd: process.cwd(),
           event,
@@ -283,7 +283,7 @@ export function registerHookCommand(program) {
         // observe-only + --run: re-collect and execute the matching hooks.
         const { loadHooks, collectHooks } =
           await import("../lib/settings-hooks.cjs");
-        const { runHooks } = await import("../lib/hook-runner.cjs");
+        const { runHooks } = await import("../lib/hook-runner.js");
         const { hooks } = loadHooks({ cwd: process.cwd() });
         const matched = collectHooks(
           hooks,