chainlesschain 0.162.176 → 0.162.178

package/src/lib/cli-anything-bridge.js

@@ -8,13 +8,27 @@
  * that the existing 4-layer skill-loader picks up automatically.
  */
 
-import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import { getElectronUserDataDir } from "./paths.js";
+import executionBroker from "./process-execution-broker/index.js";
 
 /* ---------- _deps injection (Vitest CJS mock pattern) ---------- */
-export const _deps = { execSync, fs, path };
+export const _deps = {
+  execFileSync: executionBroker.execFileSync.bind(executionBroker),
+  fs,
+  path,
+};
+
+function execCliAnything(file, args, options, origin) {
+  return _deps.execFileSync(file, args, {
+    ...options,
+    origin,
+    policy: "allow",
+    scope: "cli-anything",
+    shell: false,
+  });
+}
 
 /* ----------------------------------------------------------------
  * Database helpers
@@ -55,13 +69,16 @@ export function detectPython() {
 
   for (const cmd of candidates) {
     try {
-      const ver = _deps
-        .execSync(`${cmd} --version`, {
+      const ver = execCliAnything(
+        cmd,
+        ["--version"],
+        {
           encoding: "utf-8",
           timeout: 10000,
           stdio: ["pipe", "pipe", "pipe"],
-        })
-        .trim();
+        },
+        "cli-anything:detect-python",
+      ).trim();
       const match = ver.match(/Python\s+([\d.]+)/i);
       if (match) {
         return { found: true, command: cmd, version: match[1] };
@@ -82,11 +99,16 @@ export function detectCliAnything() {
   if (!py.found) return { installed: false };
 
   try {
-    const out = _deps.execSync(`${py.command} -m pip show cli-anything`, {
-      encoding: "utf-8",
-      timeout: 15000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
+    const out = execCliAnything(
+      py.command,
+      ["-m", "pip", "show", "cli-anything"],
+      {
+        encoding: "utf-8",
+        timeout: 15000,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+      "cli-anything:detect-package",
+    );
     const verMatch = out.match(/Version:\s*([\d.]+)/i);
     return {
       installed: true,
@@ -102,11 +124,16 @@ export function detectCliAnything() {
  * Install CLI-Anything via pip.
  */
 export function installCliAnything(pythonCmd) {
-  _deps.execSync(`${pythonCmd} -m pip install cli-anything`, {
-    encoding: "utf-8",
-    timeout: 120000,
-    stdio: "inherit",
-  });
+  execCliAnything(
+    pythonCmd,
+    ["-m", "pip", "install", "cli-anything"],
+    {
+      encoding: "utf-8",
+      timeout: 120000,
+      stdio: "inherit",
+    },
+    "cli-anything:install",
+  );
 }
 
 /* ----------------------------------------------------------------
@@ -152,11 +179,16 @@ export function scanPathForTools() {
 export function parseToolHelp(command) {
   let helpText;
   try {
-    helpText = _deps.execSync(`${command} --help`, {
-      encoding: "utf-8",
-      timeout: 15000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
+    helpText = execCliAnything(
+      command,
+      ["--help"],
+      {
+        encoding: "utf-8",
+        timeout: 15000,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+      "cli-anything:tool-help",
+    );
   } catch (err) {
     const raw = err.stdout || err.stderr || "";
     helpText = typeof raw === "string" ? raw : raw.toString("utf-8");
@@ -252,19 +284,44 @@ Pass the subcommand and arguments as plain text input:
  */
 export function _generateHandlerJs(name, command) {
   return `"use strict";
-const { execSync } = require("child_process");
+const CLI_COMMAND = ${JSON.stringify(command)};
+
+function parseArgs(input) {
+  const args = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (const ch of input.trim()) {
+    if (ch === "'" && !inDouble) { inSingle = !inSingle; continue; }
+    if (ch === '"' && !inSingle) { inDouble = !inDouble; continue; }
+    if (/\\s/.test(ch) && !inSingle && !inDouble) {
+      if (current) { args.push(current); current = ""; }
+      continue;
+    }
+    current += ch;
+  }
+  if (inSingle || inDouble) return null;
+  if (current) args.push(current);
+  return args;
+}
 
 module.exports = {
   async execute(task, context) {
     const input = (task?.params?.input || task?.action || "").trim();
     if (!input) return { success: false, error: "No input provided" };
-    // Security: input is interpolated into a shell command, so reject shell
-    // metacharacters to prevent command injection from untrusted skill input.
+    // Keep the historical shell-character guard for generated-handler
+    // compatibility even though the Broker now receives literal argv.
     if (/[;&|\`$<>()\\n\\r]/.test(input)) {
       return { success: false, error: "Input contains unsafe shell characters; refused." };
     }
+    const args = parseArgs(input);
+    if (!args) return { success: false, error: "Input contains an unmatched quote; refused." };
+    const processBroker = context?.processBroker;
+    if (!processBroker || typeof processBroker.runFileSync !== "function") {
+      return { success: false, error: "Process Broker unavailable for skill execution." };
+    }
     try {
-      const output = execSync(\`${command} \${input}\`, {
+      const output = processBroker.runFileSync(CLI_COMMAND, args, {
         encoding: "utf-8",
         timeout: 60000,
         cwd: context?.projectRoot || process.cwd(),

package/src/lib/context-breakdown.js

@@ -84,14 +84,93 @@ export function breakdownSkillSources(skills, estimateTokens) {
     .map((skill) => ({
       source: skill?.source || "skill",
       skill: String(skill?.id || skill?.displayName || "skill"),
-      tokens: est(
-        `## Persona: ${skill?.displayName || skill?.id || "skill"}\n${skill?.body || ""}`,
-      ),
+      tokens: Number.isFinite(skill?.tokens)
+        ? Math.max(0, 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) };
 }
 
+/** Normalize the content-free two-tier Skill cache snapshot. */
+export function breakdownSkillCache(cache) {
+  const descriptors = cache?.descriptors || {};
+  const bodies = cache?.bodies || {};
+  const savings = cache?.savings || {};
+  return {
+    descriptors: {
+      resident: Number(descriptors.resident) || 0,
+      scans: Number(descriptors.scans) || 0,
+      cacheHits: Number(descriptors.cacheHits) || 0,
+      estimatedTokens: Number(descriptors.estimatedTokens) || 0,
+    },
+    bodies: {
+      resident: Number(bodies.resident) || 0,
+      cacheHits: Number(bodies.cacheHits) || 0,
+      cacheMisses: Number(bodies.cacheMisses) || 0,
+      entries: Array.isArray(bodies.entries)
+        ? bodies.entries.map((entry) => ({
+            id: String(entry?.id || "skill"),
+            source: String(entry?.source || "skill"),
+            estimatedTokens: Number(entry?.estimatedTokens) || 0,
+            loads: Number(entry?.loads) || 0,
+            cacheHits: Number(entry?.cacheHits) || 0,
+            loadedBecause: Array.isArray(entry?.loadedBecause)
+              ? entry.loadedBecause.map(String)
+              : [],
+          }))
+        : [],
+    },
+    savings: {
+      lazyFileBytes: Number(savings.lazyFileBytes) || 0,
+      estimatedTokensAvoided: Number(savings.estimatedTokensAvoided) || 0,
+    },
+  };
+}
+
+/** Actionable, content-free suggestions derived from the measured sources. */
+export function buildContextOptimizations({
+  instructions = [],
+  mcpSchemas = [],
+  skillCache = null,
+} = {}) {
+  const suggestions = [];
+  if (skillCache?.savings?.estimatedTokensAvoided > 0) {
+    suggestions.push({
+      kind: "skill_lazy_loading",
+      estimatedTokens: skillCache.savings.estimatedTokensAvoided,
+      message:
+        `${skillCache.descriptors.resident} Skill descriptors stayed discoverable while ` +
+        `${skillCache.savings.estimatedTokensAvoided} estimated body tokens remained lazy.`,
+    });
+  }
+  const largestMcp = [...(mcpSchemas || [])].sort(
+    (a, b) => (b.tokens || 0) - (a.tokens || 0),
+  )[0];
+  if (largestMcp?.tokens > 0) {
+    suggestions.push({
+      kind: "mcp_tool_search",
+      estimatedTokens: largestMcp.tokens,
+      source: largestMcp.tool || largestMcp.source,
+      message: `Consider Tool Search or a narrower MCP allow-list for ${largestMcp.tool || largestMcp.source}.`,
+    });
+  }
+  const largestInstruction = [...(instructions || [])].sort(
+    (a, b) => (b.tokens || 0) - (a.tokens || 0),
+  )[0];
+  if (largestInstruction?.tokens > 0) {
+    suggestions.push({
+      kind: "instruction_scope",
+      estimatedTokens: largestInstruction.tokens,
+      source: largestInstruction.source,
+      message: `Scope or split ${largestInstruction.source} if it is not needed for every turn.`,
+    });
+  }
+  return suggestions.slice(0, 5);
+}
+
 // role bucket key → { label, kind } for the ranked source list.
 const MESSAGE_SOURCE_ROWS = [
   ["system", "system messages", "message"],

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

@@ -0,0 +1,225 @@
+/**
+ * Process-level lifecycle owner for the durable Event Runtime.
+ *
+ * Producers only append records. This host owns the single non-overlapping
+ * drain loop, dispatches records to registered handlers, and exposes a
+ * stoppable lifecycle shared by short CLI commands and resident daemons.
+ */
+
+import { EventEmitter } from "node:events";
+import { EventRuntimeStore } from "./event-runtime-store.js";
+import { EventRuntimeWorker } from "./event-runtime-worker.js";
+
+function routeType(event) {
+  return String(
+    event?.runtime_type ||
+      event?.runtimeType ||
+      event?.event ||
+      event?.type ||
+      "*",
+  );
+}
+
+function routeOrigin(event) {
+  return String(event?.origin || "*");
+}
+
+function routeKey(queue, type = "*", origin = "*") {
+  return `${queue}:${String(type || "*")}:${String(origin || "*")}`;
+}
+
+export class EventRuntimeHost extends EventEmitter {
+  constructor({
+    store = new EventRuntimeStore(),
+    intervalMs = 1000,
+    worker = null,
+    setTimeoutFn = setTimeout,
+    clearTimeoutFn = clearTimeout,
+  } = {}) {
+    super();
+    this.store = store;
+    this.intervalMs = Math.max(1, Number(intervalMs) || 1000);
+    this.setTimeoutFn = setTimeoutFn;
+    this.clearTimeoutFn = clearTimeoutFn;
+    this.handlers = new Map();
+    this.running = false;
+    this.timer = null;
+    this.inFlight = null;
+    this.lastStats = null;
+    this.lastError = null;
+    this.worker =
+      worker ||
+      new EventRuntimeWorker({
+        store,
+        onInbox: (event, record) =>
+          this._dispatch("inbox", event, record),
+        onOutbox: (event, record) =>
+          this._dispatch("outbox", event, record),
+      });
+  }
+
+  registerHandler(
+    handler,
+    { queue = "inbox", type = "*", origin = "*" } = {},
+  ) {
+    if (typeof handler !== "function") {
+      throw new TypeError("Event Runtime handler must be a function");
+    }
+    if (queue !== "inbox" && queue !== "outbox") {
+      throw new Error(`unsupported event queue: ${queue}`);
+    }
+    const key = routeKey(queue, type, origin);
+    const handlers = this.handlers.get(key) || new Set();
+    handlers.add(handler);
+    this.handlers.set(key, handlers);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) this.handlers.delete(key);
+    };
+  }
+
+  async _dispatch(queue, event, record) {
+    const type = routeType(event);
+    const origin = routeOrigin(event);
+    const candidates = [
+      routeKey(queue, type, origin),
+      routeKey(queue, type, "*"),
+      routeKey(queue, "*", origin),
+      routeKey(queue, "*", "*"),
+    ];
+    const handlers = [];
+    const seen = new Set();
+    for (const key of candidates) {
+      for (const handler of this.handlers.get(key) || []) {
+        if (seen.has(handler)) continue;
+        seen.add(handler);
+        handlers.push(handler);
+      }
+    }
+    if (handlers.length === 0 && event?.requiresHandler === true) {
+      const error = new Error(
+        `No Event Runtime handler for ${queue}:${type}:${origin}`,
+      );
+      error.code = "CC_EVENT_RUNTIME_HANDLER_UNAVAILABLE";
+      throw error;
+    }
+    const results = await Promise.all(
+      handlers.map((handler) => handler(event, record)),
+    );
+    const delivery = {
+      queue,
+      type,
+      origin,
+      handlerCount: handlers.length,
+      results,
+    };
+    this.emit("delivered", delivery, event, record);
+    this.emit(`${queue}:${type}`, event, record, delivery);
+    return delivery;
+  }
+
+  async runOnce() {
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = Promise.resolve()
+      .then(() => this.worker.runOnce())
+      .then((stats) => {
+        this.lastStats = stats;
+        this.lastError = null;
+        this.emit("tick", stats);
+        return stats;
+      })
+      .catch((error) => {
+        this.lastError = error;
+        this.emit("runtime-error", error);
+        throw error;
+      })
+      .finally(() => {
+        this.inFlight = null;
+      });
+    return this.inFlight;
+  }
+
+  _schedule() {
+    if (!this.running || this.timer != null) return;
+    this.timer = this.setTimeoutFn(async () => {
+      this.timer = null;
+      try {
+        await this.runOnce();
+      } catch {
+        // The durable records remain pending/retriable. The host keeps running
+        // so a transient lock or filesystem failure does not kill the daemon.
+      } finally {
+        this._schedule();
+      }
+    }, this.intervalMs);
+    this.timer?.unref?.();
+  }
+
+  start({ immediate = true } = {}) {
+    if (this.running) return false;
+    this.running = true;
+    if (immediate) {
+      void this.runOnce()
+        .catch(() => {})
+        .finally(() => this._schedule());
+    } else {
+      this._schedule();
+    }
+    this.emit("started");
+    return true;
+  }
+
+  async stop({ drain = true } = {}) {
+    const wasRunning = this.running;
+    this.running = false;
+    if (this.timer != null) {
+      this.clearTimeoutFn(this.timer);
+      this.timer = null;
+    }
+    if (drain && this.inFlight) {
+      try {
+        await this.inFlight;
+      } catch {
+        // Error already exposed through runtime-error/lastError.
+      }
+    }
+    if (wasRunning) this.emit("stopped");
+    return wasRunning;
+  }
+
+  status() {
+    return {
+      running: this.running,
+      inFlight: this.inFlight != null,
+      handlerRoutes: this.handlers.size,
+      lastStats: this.lastStats,
+      lastError: this.lastError?.message || null,
+      health: this.store.getHealthSnapshot(),
+    };
+  }
+}
+
+let defaultHost = null;
+
+export function getDefaultEventRuntimeHost(options = {}) {
+  if (!defaultHost) defaultHost = new EventRuntimeHost(options);
+  return defaultHost;
+}
+
+export function startDefaultEventRuntimeHost(options = {}) {
+  if (process.env.CC_EVENT_RUNTIME_DURABLE !== "1" && options.force !== true) {
+    return null;
+  }
+  const host = getDefaultEventRuntimeHost(options);
+  host.start({ immediate: options.immediate !== false });
+  return host;
+}
+
+export async function stopDefaultEventRuntimeHost(options) {
+  return defaultHost ? defaultHost.stop(options) : false;
+}
+
+export function _resetDefaultEventRuntimeHostForTests() {
+  defaultHost = null;
+}
+