chainlesschain 0.162.174 → 0.162.176

package/src/lib/agent-coordinator.js

@@ -281,6 +281,8 @@ export const ROLE_TOOL_WHITELIST = {
     "read_file",
     "write_file",
     "edit_file",
+    "delete_file",
+    "move_file",
     "run_shell",
     "search_files",
     "list_dir",
@@ -297,6 +299,8 @@ export const ROLE_TOOL_WHITELIST = {
     "read_file",
     "write_file",
     "edit_file",
+    "delete_file",
+    "move_file",
     "run_shell",
     "search_files",
     "list_dir",

package/src/lib/agent-ipc-bus.js

@@ -11,6 +11,8 @@
 
 import { EventEmitter } from "node:events";
 import crypto from "node:crypto";
+import { EventRuntimeProducer } from "./event-runtime-producer.js";
+import { EventRuntimeStore } from "./event-runtime-store.js";
 
 /**
  * @typedef {Object} InteractionRequest
@@ -27,8 +29,11 @@ import crypto from "node:crypto";
  */
 
 class AgentIPCBus extends EventEmitter {
-  constructor() {
+  constructor({ runtimeStore = null } = {}) {
     super();
+    this._runtimeProducer = runtimeStore
+      ? new EventRuntimeProducer({ store: runtimeStore, emitter: this })
+      : null;
     /** @type {Map<string, {req: InteractionRequest, resolve: Function, reject: Function, timer?: NodeJS.Timeout}>} */
     this._pendingRequests = new Map();
     /** @type {Map<string, Function>} resolvers by agentId */
@@ -58,6 +63,10 @@ class AgentIPCBus extends EventEmitter {
     this.emit("agent:unregistered", { agentId });
   }
 
+  isAgentRegistered(agentId) {
+    return this._agentResolvers.has(agentId);
+  }
+
   /**
    * Child agent calls this to request human interaction
    * @param {string} agentId
@@ -91,6 +100,19 @@ class AgentIPCBus extends EventEmitter {
       }, fullReq.timeoutMs);
 
       this._pendingRequests.set(requestId, { req: fullReq, resolve, reject, timer });
+      try {
+        this._runtimeProducer?.publish(
+          { type: "interaction_request", request: fullReq },
+          { origin: "agent-ipc", id: `interaction:${requestId}` },
+        );
+      } catch (error) {
+        // Durable publication is fail-closed for configured runtime mode: do
+        // not leave a request that cannot be recovered after a crash.
+        this._pendingRequests.delete(requestId);
+        clearTimeout(timer);
+        reject(error);
+        return;
+      }
       this.emit("request", fullReq);
     });
   }
@@ -106,6 +128,10 @@ class AgentIPCBus extends EventEmitter {
     if (entry.timer) clearTimeout(entry.timer);
     this._pendingRequests.delete(requestId);
     entry.resolve(response);
+    try {
+      const id = `interaction:${requestId}`;
+      this._runtimeProducer?.store.acknowledgeInbox(id, { response });
+    } catch {}
     this.emit("request:resolved", { requestId, response });
     return true;
   }
@@ -326,6 +352,10 @@ class AgentIPCBus extends EventEmitter {
 }
 
 // Singleton
-const ipcBus = new AgentIPCBus();
+const ipcBus = new AgentIPCBus(
+  process.env.CC_EVENT_RUNTIME_DURABLE === "1"
+    ? { runtimeStore: new EventRuntimeStore() }
+    : {},
+);
 export default ipcBus;
 export { AgentIPCBus };

package/src/lib/agent-sandbox.js

@@ -1,10 +1,12 @@
 /** OS-isolated shell execution for the coding agent. */
-import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { proxyEnv } from "./sandbox-egress-proxy.js";
+import executionBroker from "./process-execution-broker/index.js";
 
 export const DEFAULT_SANDBOX_IMAGE = "node:22-bookworm-slim";
-export const _deps = { spawnSync };
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 function stringList(value) {
   if (!Array.isArray(value)) return [];
@@ -126,6 +128,10 @@ export function executeSandboxedShell(command, sandbox, options = {}) {
   }
   args.push(sandbox.image, "sh", "-lc", String(command || ""));
   const result = _deps.spawnSync("docker", args, {
+    origin: "agent-sandbox:docker",
+    scope: "sandbox",
+    policy: "allow",
+    shell: false,
     encoding: "utf8",
     timeout: options.timeout,
     maxBuffer: options.maxBuffer,
@@ -189,6 +195,10 @@ function executeBubblewrapShell(command, sandbox, options, hostCwd, policy) {
       ? { ...(options.env || {}), ...proxyEnv(egress.port, "127.0.0.1") }
       : options.env;
   const result = _deps.spawnSync("bwrap", args, {
+    origin: "agent-sandbox:bubblewrap",
+    scope: "sandbox",
+    policy: "allow",
+    shell: false,
     cwd: hostCwd,
     env: bwrapEnv,
     encoding: "utf8",
@@ -244,6 +254,10 @@ export function probeSandboxAvailability(sandbox, deps = _deps) {
       ? ["bwrap", ["--version"]]
       : ["docker", ["version", "--format", "{{.Server.Version}}"]];
   const result = deps.spawnSync(probeArgs[0], probeArgs[1], {
+    origin: "agent-sandbox:probe",
+    scope: "sandbox",
+    policy: "allow",
+    shell: false,
     encoding: "utf8",
     timeout: 10000,
     windowsHide: true,

package/src/lib/agent-schedule-store.js

@@ -27,6 +27,7 @@ import { isEntryExpired, effectiveFireAt } from "./schedule-planner.js";
 import { SUBAGENT_PERMISSION_MODES } from "./subagent-contract.js";
 import { parseGoalCondition } from "./goal-condition-engine.js";
 import { normalizeActionClass } from "./unattended-action-policy.js";
+import { withFileLock } from "./with-file-lock.js";
 
 export const SCHEDULE_KINDS = Object.freeze(["wakeup", "cron", "monitor"]);
 
@@ -155,6 +156,10 @@ function isSchedulableStatus(entry) {
     : entry.status === "active";
 }
 
+function hasLiveExecutionLease(entry, now) {
+  return Number(entry.executionLease?.expiresAt) > Number(now);
+}
+
 /** Statuses an entry can never leave — safe to prune. */
 export const TERMINAL_STATUSES = Object.freeze([
   "fired",
@@ -487,6 +492,7 @@ export class AgentScheduleStore {
       // (defense-in-depth: retireExpired need not have run first).
       if (isEntryExpired(entry, now)) return false;
       if (!isSchedulableStatus(entry)) return false;
+      if (hasLiveExecutionLease(entry, now)) return false;
       // The effective fire time applies the entry's OWN deterministic jitter
       // (`entry.jitterMs`, default 0 → base fire time, byte-identical to the
       // prior `dueAt`/`nextAt` comparison). A jittered entry fires slightly
@@ -496,6 +502,52 @@ export class AgentScheduleStore {
     });
   }
 
+  /**
+   * Atomically claim due entries for one agenda runner. The lease is retained
+   * on the durable entry, so a second process cannot fire the same item while
+   * the first is working; an abandoned process becomes reclaimable after the
+   * lease expires. This is deliberately separate from `due()` for backwards
+   * compatibility with read-only callers and injected test stores.
+   */
+  claimDue(atMs = null, leaseMs = 120000) {
+    const now = atMs != null ? Number(atMs) : this._now();
+    const ttl = Math.max(1000, Number(leaseMs) || 120000);
+    this._ensureDir();
+    return withFileLock(path.join(this.dir, ".agenda-claims"), () => {
+      const claimed = [];
+      for (const kind of SCHEDULE_KINDS) {
+        const entries = this._readAll(kind);
+        let changed = false;
+        for (const entry of entries) {
+          if (!isSchedulableStatus(entry) || isEntryExpired(entry, now)) continue;
+          if (hasLiveExecutionLease(entry, now)) continue;
+          const fireAt = effectiveFireAt(entry);
+          if (fireAt == null || fireAt > now) continue;
+          entry.executionLease = {
+            owner: `${process.pid}:${randomUUID()}`,
+            claimedAt: now,
+            expiresAt: now + ttl,
+          };
+          claimed.push({ ...entry, executionLease: { ...entry.executionLease } });
+          changed = true;
+        }
+        if (changed) this._writeAll(kind, entries);
+      }
+      return claimed;
+    }, { failIfUnavailable: true });
+  }
+
+  /** Release a failed/aborted claim so a later runner can retry it. */
+  releaseClaim(id) {
+    for (const kind of SCHEDULE_KINDS) {
+      const updated = this._mutate(kind, id, (entry) => {
+        delete entry.executionLease;
+      });
+      if (updated) return updated;
+    }
+    return null;
+  }
+
   /**
    * Retire every schedulable entry whose `expiresAt` has passed (status →
    * "expired", stamping `expiredAt`), across all kinds, so it never fires again.
@@ -632,6 +684,9 @@ export class AgentScheduleStore {
     const entry = entries.find((e) => e.id === id);
     if (!entry) return null;
     fn(entry);
+    // Every lifecycle mutation settles the claim before the write becomes
+    // visible, including a recurring cron/monitor entry that remains active.
+    delete entry.executionLease;
     this._writeAll(kind, entries);
     return entry;
   }

package/src/lib/agent-tool-admission.js

@@ -30,6 +30,110 @@ export const TOOL_TIER = Object.freeze({
   EXTENSION: "extension",
 });
 
+const ADMISSION_BOOLEAN_FIELDS = Object.freeze([
+  "enforce",
+  "capabilityGranted",
+  "policyAllowed",
+  "permissionGranted",
+  "budgetOk",
+  "uiSupported",
+]);
+const ADMISSION_TEXT_FIELDS = Object.freeze([
+  "source",
+  "version",
+  "scope",
+  "tier",
+]);
+const ADMISSION_TEXT_PATTERN = /^[A-Za-z0-9@][A-Za-z0-9_.:/@+-]{0,127}$/;
+const RESERVED_TOOL_NAMES = new Set(["__proto__", "prototype", "constructor"]);
+
+/**
+ * Parse the IDE-to-CLI CC_TOOL_ADMISSION envelope. Only decision/provenance
+ * fields are accepted; arguments, prompts and credentials have no place in
+ * this contract. Invalid input throws so a host that opted into enforcement
+ * cannot silently fall back to an ungoverned session.
+ */
+export function parseToolAdmissionConfig(input) {
+  if (input == null || input === "") return null;
+  let raw;
+  try {
+    raw = typeof input === "string" ? input : JSON.stringify(input);
+  } catch {
+    throw new Error("tool admission config is not valid JSON");
+  }
+  if (typeof raw !== "string") {
+    throw new Error("tool admission config must be an object");
+  }
+  if (Buffer.byteLength(raw, "utf8") > 32768) {
+    throw new Error("tool admission config exceeds 32 KiB");
+  }
+  let value;
+  try {
+    value = typeof input === "string" ? JSON.parse(input) : input;
+  } catch {
+    throw new Error("tool admission config is not valid JSON");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("tool admission config must be an object");
+  }
+  if (value.enforce !== true) {
+    throw new Error("tool admission config must set enforce=true");
+  }
+
+  const sanitize = (entry, label) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`${label} must be an object`);
+    }
+    const out = {};
+    for (const field of ADMISSION_BOOLEAN_FIELDS) {
+      if (entry[field] !== undefined) {
+        if (typeof entry[field] !== "boolean") {
+          throw new Error(`${label}.${field} must be boolean`);
+        }
+        out[field] = entry[field];
+      }
+    }
+    for (const field of ADMISSION_TEXT_FIELDS) {
+      if (entry[field] !== undefined) {
+        if (
+          typeof entry[field] !== "string" ||
+          !ADMISSION_TEXT_PATTERN.test(entry[field])
+        ) {
+          throw new Error(`${label}.${field} must be a safe identifier`);
+        }
+        out[field] = entry[field];
+      }
+    }
+    return out;
+  };
+
+  const config = sanitize(value, "toolAdmission");
+  config.enforce = true;
+  if (value.tools !== undefined) {
+    if (
+      !value.tools ||
+      typeof value.tools !== "object" ||
+      Array.isArray(value.tools)
+    ) {
+      throw new Error("toolAdmission.tools must be an object");
+    }
+    const entries = Object.entries(value.tools);
+    if (entries.length > 256)
+      throw new Error("toolAdmission.tools exceeds 256 entries");
+    config.tools = {};
+    for (const [name, entry] of entries) {
+      if (
+        !/^[A-Za-z0-9_.:-]{1,160}$/.test(name) ||
+        RESERVED_TOOL_NAMES.has(name)
+      ) {
+        throw new Error(`invalid tool admission name: ${name}`);
+      }
+      config.tools[name] = sanitize(entry, `toolAdmission.tools.${name}`);
+    }
+  }
+  return config;
+}
+
 /** Normalize a tier label; anything unrecognized → EXTENSION (fail-closed). */
 export function normalizeToolTier(value) {
   const s = String(value || "")

package/src/lib/api-key-helper.js

@@ -14,7 +14,7 @@
  * rule). Cached per process (5 min) so multi-call runs don't re-spawn it.
  */
 
-import { execSync } from "node:child_process";
+import { executionBroker } from "./process-execution-broker/index.js";
 
 const TTL_MS = 5 * 60 * 1000;
 const _cache = new Map(); // helper command → { key, at }
@@ -31,7 +31,15 @@ export function resolveApiKeyFromHelper(helperCmd, opts = {}) {
   const now = opts.now || Date.now;
   const hit = _cache.get(cmd);
   if (hit && now() - hit.at < TTL_MS) return hit.key;
-  const exec = opts.exec || execSync;
+  const exec =
+    opts.exec ||
+    ((command, options) =>
+      executionBroker.execSync(command, {
+        ...options,
+        origin: "credential:api-key-helper",
+        policy: "allow",
+        scope: "credential",
+      }));
   try {
     const out = exec(cmd, {
       encoding: "utf-8",

package/src/lib/async-hook-supervisor.cjs

@@ -128,11 +128,23 @@ class AsyncHookSupervisor {
       if (process.platform === "win32") {
         const r = this._deps.spawnSync(
           "taskkill",
-          ["/pid", String(pid), "/T", "/F"],
+          ["/PID", String(pid), "/T", "/F"],
           { windowsHide: true },
         );
+        // A shell can publish a just-created descendant between the first
+        // tree snapshot and termination. Repeat once so that race cannot
+        // leave a short-lived hook grandchild orphaned.
+        if (!r?.error && r?.status === 0) {
+          this._deps.spawnSync(
+            "taskkill",
+            ["/PID", String(pid), "/T", "/F"],
+            { windowsHide: true },
+          );
+        }
         // If taskkill couldn't launch, fall back to a direct kill.
-        if (r && r.error) child.kill(signal);
+        if (r && (r.error || (r.status != null && r.status !== 0))) {
+          child.kill(signal);
+        }
       } else {
         // Negative pid → the whole process group (requires the detached spawn).
         try {
@@ -239,7 +251,7 @@ class AsyncHookSupervisor {
 
     let child;
     try {
-      child = this._deps.spawn(hook.command, {
+      const spawnOptions = {
         cwd: opts.cwd || process.cwd(),
         shell: true,
         // POSIX: own process group so a timeout / stopAll can signal the whole
@@ -250,7 +262,17 @@ class AsyncHookSupervisor {
           ...process.env,
           CLAUDE_HOOK_EVENT: hook.event || payload.hook_event_name || "",
         },
-      });
+      };
+      child = opts.broker && hook.origin === "plugin:hook"
+        ? opts.broker.spawn(hook.command, [], {
+            ...spawnOptions,
+            origin: hook.origin,
+            policy: "allow",
+            pluginId: hook.pluginId || null,
+            pluginVersion: hook.pluginVersion || null,
+            pluginSource: hook.pluginSource || null,
+          })
+        : this._deps.spawn(hook.command, spawnOptions);
     } catch (err) {
       this._record(hook, {
         ok: false,

package/src/lib/background-interaction-resolver.js

@@ -0,0 +1,71 @@
+/**
+ * background-interaction-resolver — 监听 agent 子进程发来的交互请求，
+ * 转发给后台会话 transport 并通过 pendingInteractions 追踪回复。
+ *
+ * 当 agent 调用 onPrompt/onApprove 等需要用户交互的方法时，子进程通过 IPC
+ * 发送 { type: "interaction-request", intId, requestType, prompt, options } 消息。
+ * 本模块监听这些消息，加入本地 pending map，并广播给所有 attach 客户端。
+ */
+
+const INTERACTION_TIMEOUT_MS = 5 * 60 * 1000; // 5 分钟超时
+
+/**
+ * 挂载交互请求监听到 agent 子进程。
+ *
+ * @param {import('node:child_process').ChildProcess} child - agent 子进程实例
+ * @param {Map<string, { resolve: Function, reject: Function, timer: NodeJS.Timeout }>} pendingInteractions - 待处理交互映射
+ * @param {Function} broadcast - 广播消息给所有 attach 客户端的函数
+ * @returns {Function} 卸载函数，调用后停止监听
+ */
+export function attachInteractionRequestHandler(
+  child,
+  pendingInteractions,
+  broadcast,
+) {
+  if (!child) {
+    return () => {};
+  }
+
+  const handler = (message) => {
+    if (!message || typeof message !== "object") return;
+    if (message.type !== "interaction-request") return;
+
+    const { intId, requestType, prompt, options = {} } = message;
+    if (!intId) return;
+
+    // 加入 pending 映射，设置超时
+    const timer = setTimeout(() => {
+      const entry = pendingInteractions.get(intId);
+      if (!entry) return;
+      pendingInteractions.delete(intId);
+      // 超时返回默认值：confirm 返回 false，其他返回 null
+      const defaultAnswer = requestType === "confirm" ? false : null;
+      entry.resolve(defaultAnswer);
+      broadcast?.({
+        type: "interaction-timeout",
+        intId,
+      });
+    }, INTERACTION_TIMEOUT_MS);
+    // 不保持事件循环存活
+    timer.unref?.();
+
+    // 这里不存 resolve/reject — 调用方 (worker) 已经在 agentAskUser 中存了
+    // 我们只负责广播给 attach 客户端
+    // 但为了超时能触发 worker 的 resolve，需要把 entry 透传？不，worker 自己存 entry
+    // 只需要广播消息即可
+    broadcast?.({
+      type: "interaction_request",
+      intId,
+      requestType,
+      prompt,
+      options,
+    });
+  };
+
+  child.on("message", handler);
+
+  // 返回卸载函数
+  return () => {
+    child.off("message", handler);
+  };
+}

package/src/lib/background-session-transport.js

@@ -16,9 +16,11 @@
  * Protocol (one JSON object per line, both directions):
  *   client → worker: {type:"hello", token} · {type:"prompt", text}
  *                    · {type:"status"} · {type:"stop"} · {type:"detach"}
+ *                    · {type:"interaction_response", requestId, result, error?}
  *   worker → client: {type:"hello", ...status} · {type:"accepted", queued}
  *                    · {type:"status", ...status} · {type:"error", message}
  *                    · {type:"turn-started"|"turn-ended"|"idle", ...}
+ *                    · {type:"interaction_request", requestId, payload}
  */
 
 import net from "node:net";
@@ -85,13 +87,24 @@ function writeMessage(socket, message) {
  * @param {(text:string)=>{queued:number}} opts.onPrompt queue a follow-up
  *        prompt; throw to reject (message is relayed to the client)
  * @param {()=>void} [opts.onStop] kill the current agent turn
+ * @param {(requestId:string, result:any, error?:string)=>void} [opts.onInteractionResponse]
+ *        handle a user's response to a pending interaction request
  * @param {(count:number)=>void} [opts.onClientChange]
  * @param {()=>object} [opts.getStatus] session status payload for hello/status
  * @returns {Promise<{pipePath:string, clientCount:()=>number,
  *          broadcast:(msg:object)=>void, close:()=>Promise<void>}>}
  */
 export function startBackgroundSessionServer(opts) {
-  const { id, dir, token, onPrompt, onStop, onClientChange, getStatus } = opts;
+  const {
+    id,
+    dir,
+    token,
+    onPrompt,
+    onStop,
+    onInteractionResponse,
+    onClientChange,
+    getStatus,
+  } = opts;
   const pipePath = opts.pipePath || transportPipePath(id, dir);
   if (process.platform !== "win32") {
     try {
@@ -182,6 +195,36 @@ export function startBackgroundSessionServer(opts) {
               socket.end();
               return;
             }
+            case "interaction_response": {
+              try {
+                // Support both field names: requestId (client) and intId (wire legacy)
+                const { requestId, intId, answer, result, error } = message;
+                const resolvedId = requestId || intId;
+                if (!resolvedId) {
+                  writeMessage(socket, {
+                    type: "error",
+                    message: "interaction_response requires requestId or intId",
+                  });
+                  return;
+                }
+                // Single-object callback matching worker expectation: { requestId, answer, error }
+                onInteractionResponse?.({
+                  requestId: resolvedId,
+                  answer: answer ?? result,
+                  error,
+                });
+                writeMessage(socket, {
+                  type: "received",
+                  requestId: resolvedId,
+                });
+              } catch (err) {
+                writeMessage(socket, {
+                  type: "error",
+                  message: err?.message || String(err),
+                });
+              }
+              return;
+            }
             default:
               writeMessage(socket, {
                 type: "error",
@@ -218,6 +261,21 @@ export function startBackgroundSessionServer(opts) {
         broadcast: (message) => {
           for (const socket of clients) writeMessage(socket, message);
         },
+        broadcastInteractionRequest: (intId, payload) => {
+          for (const socket of clients)
+            writeMessage(socket, {
+              type: "interaction_request",
+              intId,
+              requestId: intId,
+              question:
+                payload.question || payload.prompt || "Agent needs your input",
+              prompt: payload.question || payload.prompt || "",
+              hint: payload.hint || "",
+              options: payload.options || null,
+              multiSelect: payload.multiSelect || false,
+              defaultValue: payload.defaultValue,
+            });
+        },
         close: () =>
           new Promise((done) => {
             for (const socket of clients) socket.destroy();

package/src/lib/changelog.js

@@ -225,24 +225,32 @@ function extractCliSections(bodyLines, header) {
  *
  * @returns {{ source: string, releases: Array }}
  */
-export function loadChangelog() {
+export function loadChangelog({
+  fsApi = fs,
+  pathApi = path,
+  dirname = __dirname,
+} = {}) {
   const changelogCandidates = [
-    path.join(__dirname, "..", "..", "CHANGELOG.md"), // packages/cli/CHANGELOG.md
-    path.join(__dirname, "..", "..", "..", "..", "CHANGELOG.md"), // repo root
+    pathApi.join(dirname, "..", "..", "CHANGELOG.md"), // packages/cli/CHANGELOG.md
+    pathApi.join(dirname, "..", "..", "..", "..", "CHANGELOG.md"), // repo root
   ];
   for (const p of changelogCandidates) {
-    if (fs.existsSync(p)) {
-      return {
-        source: "CHANGELOG.md",
-        releases: parseChangelog(fs.readFileSync(p, "utf-8")),
-      };
+    if (fsApi.existsSync(p)) {
+      const releases = parseChangelog(fsApi.readFileSync(p, "utf-8"));
+      // A parent-level CHANGELOG can exist in a global Node.js installation
+      // (for example C:\\nvm4w\\nodejs\\CHANGELOG.md).  Do not treat an
+      // unrelated, successfully-read file with zero CLI releases as the
+      // authoritative source; continue to the bundled artifact instead.
+      if (releases.length > 0) {
+        return { source: "CHANGELOG.md", releases };
+      }
     }
   }
   // Installed npm package: CHANGELOG.md isn't shipped, use the bundled artifact.
-  const jsonPath = path.join(__dirname, "..", "data", "changelog.json");
-  if (fs.existsSync(jsonPath)) {
+  const jsonPath = pathApi.join(dirname, "..", "data", "changelog.json");
+  if (fsApi.existsSync(jsonPath)) {
     try {
-      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      const data = JSON.parse(fsApi.readFileSync(jsonPath, "utf-8"));
       if (Array.isArray(data.releases)) return data;
     } catch {
       /* fall through to empty */

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

@@ -20,6 +20,7 @@ import {
   canApprove,
   describeAuthorityChain,
 } from "../agent-authority.js";
+import { EventRuntimeStore } from "../event-runtime-store.js";
 
 export const CHANNEL_KINDS = ["webhook", "telegram"];
 
@@ -120,6 +121,9 @@ export async function startChannels(specsInput, opts = {}) {
   const config = opts.config || {};
   const log = opts.log || ((msg) => logger.info(msg));
   const deps = opts.deps || {};
+  const eventRuntimeStore =
+    opts.eventRuntimeStore ||
+    (process.env.CC_EVENT_RUNTIME_DURABLE === "1" ? new EventRuntimeStore() : null);
   // Every inbound event is stamped with its channel authority (`steer`, never
   // `approve`) before the caller's handler sees it — so a channel message can
   // never be mistaken for a user approval no matter what it contains.
@@ -149,6 +153,7 @@ export async function startChannels(specsInput, opts = {}) {
           port: spec.arg ? Number(spec.arg) : cfg.port,
           onEvent,
           log,
+          eventRuntimeStore,
         });
         started.push({ kind: "webhook", describe: handle.describe, ...handle });
       } else if (spec.kind === "telegram") {
@@ -161,6 +166,7 @@ export async function startChannels(specsInput, opts = {}) {
           ...cfg,
           onEvent,
           log,
+          eventRuntimeStore,
         });
         started.push({
           kind: "telegram",