chainlesschain 0.162.176 → 0.162.178

package/src/lib/event-runtime-store.js

@@ -100,7 +100,17 @@ export class EventRuntimeStore {
     );
   }
 
-  enqueue(queue, event, { id = null, metadata = null } = {}) {
+  enqueue(
+    queue,
+    event,
+    {
+      id = null,
+      metadata = null,
+      claimOwner = null,
+      leaseMs = this.leaseMs,
+      availableAt = null,
+    } = {},
+  ) {
     const key = eventId(event, id);
     return this._mutate(queue, (records) => {
       const existing = records.find((record) => record.id === key);
@@ -118,15 +128,27 @@ export class EventRuntimeStore {
         error.code = "CC_EVENT_RUNTIME_BACKPRESSURE";
         throw error;
       }
+      const createdAt = this._now();
+      const claimed = claimOwner != null && String(claimOwner);
       const record = {
         id: key,
         event: clone(event || {}),
         metadata: clone(metadata),
-        status: "pending",
-        attempts: 0,
-        createdAt: this._now(),
-        nextAttemptAt: this._now(),
-        lease: null,
+        status: claimed ? "processing" : "pending",
+        attempts: claimed ? 1 : 0,
+        fence: claimed ? 1 : 0,
+        createdAt,
+        nextAttemptAt:
+          availableAt == null ? createdAt : Math.max(createdAt, Number(availableAt)),
+        lease: claimed
+          ? {
+              owner: String(claimOwner),
+              fence: 1,
+              claimedAt: createdAt,
+              expiresAt:
+                createdAt + Math.max(1, Number(leaseMs) || this.leaseMs),
+            }
+          : null,
       };
       records.push(record);
       return clone(record);
@@ -160,7 +182,13 @@ export class EventRuntimeStore {
         if (Number(record.nextAttemptAt || 0) > t) continue;
         record.status = "processing";
         record.attempts = Number(record.attempts || 0) + 1;
-        record.lease = { owner: this.owner, claimedAt: t, expiresAt: t + ttl };
+        record.fence = Number(record.fence || 0) + 1;
+        record.lease = {
+          owner: this.owner,
+          fence: record.fence,
+          claimedAt: t,
+          expiresAt: t + ttl,
+        };
         claimed.push(clone(record));
       }
       return claimed;
@@ -175,16 +203,68 @@ export class EventRuntimeStore {
     return this.claim("outbox", options);
   }
 
-  acknowledge(queue, id, result = null, { owner = null } = {}) {
+  _leaseMatches(record, { owner = null, fence = null, now = this._now() } = {}) {
+    const expectedOwner = owner == null ? null : String(owner);
+    const expectedFence =
+      fence == null || !Number.isFinite(Number(fence)) ? null : Number(fence);
+    if (expectedOwner == null && expectedFence == null) return true;
+    if (record.status !== "processing" || !record.lease) return false;
+    if (expectedOwner != null && record.lease.owner !== expectedOwner) {
+      return false;
+    }
+    if (
+      expectedFence != null &&
+      Number(record.lease.fence) !== expectedFence
+    ) {
+      return false;
+    }
+    // A holder that let its lease expire must renew before it is allowed to
+    // commit. This closes the gap where a slow worker could settle just before
+    // a recovery worker claims the same record.
+    return Number(record.lease.expiresAt) > Number(now);
+  }
+
+  renew(
+    queue,
+    id,
+    {
+      owner = this.owner,
+      fence = null,
+      now = this._now(),
+      leaseMs = this.leaseMs,
+    } = {},
+  ) {
+    const t = Number(now);
+    const ttl = Math.max(1, Number(leaseMs) || this.leaseMs);
+    return this._mutate(queue, (records) => {
+      const record = records.find((item) => item.id === String(id));
+      if (!record || !this._leaseMatches(record, { owner, fence, now: t })) {
+        return null;
+      }
+      record.lease.expiresAt = t + ttl;
+      record.lease.renewedAt = t;
+      return clone(record);
+    });
+  }
+
+  renewInbox(id, options) {
+    return this.renew("inbox", id, options);
+  }
+
+  renewOutbox(id, options) {
+    return this.renew("outbox", id, options);
+  }
+
+  acknowledge(
+    queue,
+    id,
+    result = null,
+    { owner = null, fence = null, now = this._now() } = {},
+  ) {
     return this._mutate(queue, (records) => {
       const record = records.find((item) => item.id === String(id));
       if (!record) return null;
-      const expectedOwner = owner ? String(owner) : null;
-      if (
-        expectedOwner &&
-        (record.status !== "processing" ||
-          record.lease?.owner !== expectedOwner)
-      ) {
+      if (!this._leaseMatches(record, { owner, fence, now })) {
         return null;
       }
       record.status = "done";
@@ -207,17 +287,18 @@ export class EventRuntimeStore {
     queue,
     id,
     error,
-    { retryDelayMs = 1000, maxAttempts = this.maxAttempts, owner = null } = {},
+    {
+      retryDelayMs = 1000,
+      maxAttempts = this.maxAttempts,
+      owner = null,
+      fence = null,
+      now = this._now(),
+    } = {},
   ) {
     return this._mutate(queue, (records) => {
       const record = records.find((item) => item.id === String(id));
       if (!record) return null;
-      const expectedOwner = owner ? String(owner) : null;
-      if (
-        expectedOwner &&
-        (record.status !== "processing" ||
-          record.lease?.owner !== expectedOwner)
-      ) {
+      if (!this._leaseMatches(record, { owner, fence, now })) {
         return null;
       }
       record.error = String(error || "event delivery failed").slice(0, 1000);

package/src/lib/event-runtime-worker.js

@@ -16,6 +16,9 @@ export class EventRuntimeWorker {
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     batchSize = 50,
     retryDelayMs = 1000,
+    leaseRenewIntervalMs = null,
+    setIntervalFn = setInterval,
+    clearIntervalFn = clearInterval,
   } = {}) {
     if (!store) throw new Error("EventRuntimeWorker requires a store");
     this.store = store;
@@ -25,6 +28,60 @@ export class EventRuntimeWorker {
     this.sleep = sleep;
     this.batchSize = Math.max(1, Number(batchSize) || 50);
     this.retryDelayMs = Math.max(0, Number(retryDelayMs) || 0);
+    const inferredRenewMs = Math.max(
+      1,
+      Math.floor(Number(store.leaseMs || 120000) / 3),
+    );
+    this.leaseRenewIntervalMs =
+      leaseRenewIntervalMs == null
+        ? inferredRenewMs
+        : Math.max(0, Number(leaseRenewIntervalMs) || 0);
+    this.setIntervalFn = setIntervalFn;
+    this.clearIntervalFn = clearIntervalFn;
+  }
+
+  _settlementOptions(record) {
+    if (!record?.lease?.owner) return {};
+    return {
+      owner: record.lease.owner,
+      ...(record.lease.fence == null ? {} : { fence: record.lease.fence }),
+    };
+  }
+
+  _startLeaseRenewal(queue, record) {
+    const renew =
+      queue === "inbox" ? this.store.renewInbox : this.store.renewOutbox;
+    if (
+      typeof renew !== "function" ||
+      !record?.lease?.owner ||
+      this.leaseRenewIntervalMs <= 0
+    ) {
+      return { lost: false, stop() {} };
+    }
+    const options = this._settlementOptions(record);
+    const state = { lost: false, timer: null };
+    const tick = () => {
+      if (state.lost) return;
+      try {
+        const renewed = renew.call(this.store, record.id, options);
+        if (renewed == null) state.lost = true;
+      } catch {
+        // Renewal is part of the correctness boundary. A lock/storage failure
+        // means this worker can no longer prove it owns the record.
+        state.lost = true;
+      }
+    };
+    state.timer = this.setIntervalFn(tick, this.leaseRenewIntervalMs);
+    state.timer?.unref?.();
+    return {
+      get lost() {
+        return state.lost;
+      },
+      stop: () => {
+        if (state.timer != null) this.clearIntervalFn(state.timer);
+        state.timer = null;
+      },
+    };
   }
 
   async _drain(queue, handler, stats) {
@@ -33,9 +90,15 @@ export class EventRuntimeWorker {
         ? this.store.claimInbox({ limit: this.batchSize, now: this.now() })
         : this.store.claimOutbox({ limit: this.batchSize, now: this.now() });
     for (const record of claimed) {
+      const renewal = this._startLeaseRenewal(queue, record);
       try {
         const result = await handler(record.event, record);
-        const options = { owner: record.lease?.owner };
+        renewal.stop();
+        if (renewal.lost) {
+          stats[`${queue}LeaseLost`] += 1;
+          continue;
+        }
+        const options = this._settlementOptions(record);
         const settled =
           queue === "inbox"
             ? this.store.acknowledgeInbox(record.id, result, options)
@@ -43,9 +106,14 @@ export class EventRuntimeWorker {
         if (settled === null && options.owner) stats[`${queue}LeaseLost`] += 1;
         else stats[`${queue}Acked`] += 1;
       } catch (error) {
+        renewal.stop();
+        if (renewal.lost) {
+          stats[`${queue}LeaseLost`] += 1;
+          continue;
+        }
         const options = {
           retryDelayMs: this.retryDelayMs,
-          owner: record.lease?.owner,
+          ...this._settlementOptions(record),
         };
         const settled = this.store.fail(
           queue,

package/src/lib/hook-runner.cjs

@@ -17,10 +17,9 @@
  *                               agent — only an explicit block decision blocks).
  *
  * Returns a normalized `{ decision, reason, exitCode, stdout, stderr, ... }`.
- * `_deps.spawnSync` is injected for unit tests (no real process needed).
+ * Process runners are injected for unit tests and by the ESM Broker facade.
  */
 
-const cpDefault = require("node:child_process");
 const {
   normalizeShellKind,
   buildPowershellArgv,
@@ -28,7 +27,27 @@ const {
 } = require("./shell-selector.cjs");
 const { mergeHookDecisions } = require("./hook-event-bus.cjs");
 
-const _deps = { spawnSync: cpDefault.spawnSync, spawn: cpDefault.spawn };
+const _deps = { runSync: null, run: null };
+Object.defineProperties(_deps, {
+  spawnSync: {
+    enumerable: true,
+    get() {
+      return this.runSync;
+    },
+    set(value) {
+      this.runSync = value;
+    },
+  },
+  spawn: {
+    enumerable: true,
+    get() {
+      return this.run;
+    },
+    set(value) {
+      this.run = value;
+    },
+  },
+});
 
 const HOOK_DECISIONS = Object.freeze({
   BLOCK: "block",
@@ -232,20 +251,29 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
         CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
       },
     };
-    const brokerOptions = {
+    const processOptions = {
       ...common,
       origin: opts.origin || "hook",
-      policy: opts.origin === "plugin:hook" ? "allow" : undefined,
+      policy: "allow",
+      scope: "hook",
       pluginId: opts.pluginId || null,
       pluginVersion: opts.pluginVersion || null,
       pluginSource: opts.pluginSource || null,
     };
-    if (opts.broker && opts.origin === "plugin:hook") {
-      res = opts.broker.spawnSync(
-        usePowershell ? buildPowershellArgv(command, shellKind, { executionPolicy: loadShellConfig({ cwd: common.cwd }).executionPolicy }).file : command,
-        usePowershell ? buildPowershellArgv(command, shellKind, { executionPolicy: loadShellConfig({ cwd: common.cwd }).executionPolicy }).argv : [],
-        brokerOptions,
-      );
+    const brokerRunSync =
+      opts.broker &&
+      opts.origin === "plugin:hook" &&
+      typeof opts.broker["spawnSync"] === "function"
+        ? opts.broker["spawnSync"].bind(opts.broker)
+        : null;
+    if (brokerRunSync) {
+      const invocation = usePowershell
+        ? buildPowershellArgv(command, shellKind, {
+            executionPolicy: loadShellConfig({ cwd: common.cwd })
+              .executionPolicy,
+          })
+        : { file: command, argv: [] };
+      res = brokerRunSync(invocation.file, invocation.argv, processOptions);
     } else if (usePowershell) {
       // Per-hook `shell: powershell|pwsh` (settings hook entry): explicit argv
       // instead of the default shell; the enterprise ExecutionPolicy override
@@ -254,9 +282,15 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
         cwd: common.cwd,
       });
       const inv = buildPowershellArgv(command, shellKind, { executionPolicy });
-      res = _deps.spawnSync(inv.file, inv.argv, common);
+      if (typeof _deps.runSync !== "function") {
+        throw new Error("hook process runner unavailable");
+      }
+      res = _deps.runSync(inv.file, inv.argv, processOptions);
     } else {
-      res = _deps.spawnSync(command, { ...common, shell: true });
+      if (typeof _deps.runSync !== "function") {
+        throw new Error("hook process runner unavailable");
+      }
+      res = _deps.runSync(command, { ...processOptions, shell: true });
     }
   } catch (err) {
     return {
@@ -360,36 +394,37 @@ async function _runCommandHookInnerAsync(command, input = {}, opts = {}) {
     ...process.env,
     CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
   };
+  const processOptions = {
+    cwd: wd,
+    env: spawnEnv,
+    origin: opts.origin || "hook",
+    policy: "allow",
+    scope: "hook",
+    pluginId: opts.pluginId || null,
+    pluginVersion: opts.pluginVersion || null,
+    pluginSource: opts.pluginSource || null,
+  };
 
   let child;
   try {
+    const brokerRun =
+      opts.broker &&
+      opts.origin === "plugin:hook" &&
+      typeof opts.broker["spawn"] === "function"
+        ? opts.broker["spawn"].bind(opts.broker)
+        : null;
+    const run = brokerRun || _deps.run;
+    if (typeof run !== "function") {
+      throw new Error("hook process runner unavailable");
+    }
     if (usePowershell) {
       const { executionPolicy } = loadShellConfig({ cwd: wd });
       const inv = buildPowershellArgv(command, shellKind, { executionPolicy });
-      child = opts.broker && opts.origin === "plugin:hook"
-        ? opts.broker.spawn(inv.file, inv.argv, {
-            cwd: wd,
-            env: spawnEnv,
-            origin: opts.origin,
-            policy: "allow",
-            pluginId: opts.pluginId || null,
-            pluginVersion: opts.pluginVersion || null,
-            pluginSource: opts.pluginSource || null,
-          })
-        : _deps.spawn(inv.file, inv.argv, { cwd: wd, env: spawnEnv });
+      child = run(inv.file, inv.argv, processOptions);
     } else {
-      child = opts.broker && opts.origin === "plugin:hook"
-        ? opts.broker.spawn(command, [], {
-            cwd: wd,
-            env: spawnEnv,
-            shell: true,
-            origin: opts.origin,
-            policy: "allow",
-            pluginId: opts.pluginId || null,
-            pluginVersion: opts.pluginVersion || null,
-            pluginSource: opts.pluginSource || null,
-          })
-        : _deps.spawn(command, { cwd: wd, env: spawnEnv, shell: true });
+      child = brokerRun
+        ? run(command, [], { ...processOptions, shell: true })
+        : run(command, { ...processOptions, shell: true });
     }
   } catch (err) {
     return {

package/src/lib/hook-runner.js

@@ -0,0 +1,55 @@
+import runner from "./hook-runner.cjs";
+import executionBroker from "./process-execution-broker/index.js";
+
+const brokerRunner = executionBroker.spawn.bind(executionBroker);
+const brokerSyncRunner = executionBroker.spawnSync.bind(executionBroker);
+
+export const _processDeps = {
+  run: brokerRunner,
+  runSync: brokerSyncRunner,
+};
+
+function normalizeInvocation(argsOrOptions, maybeOptions) {
+  return Array.isArray(argsOrOptions)
+    ? { args: argsOrOptions, options: maybeOptions || {} }
+    : { args: [], options: argsOrOptions || {} };
+}
+
+function runHookProcess(file, argsOrOptions, maybeOptions) {
+  const { args, options } = normalizeInvocation(argsOrOptions, maybeOptions);
+  return _processDeps.run(file, args, {
+    ...options,
+    origin: options.origin || "hook",
+    policy: "allow",
+    scope: "hook",
+  });
+}
+
+function runHookProcessSync(file, argsOrOptions, maybeOptions) {
+  const { args, options } = normalizeInvocation(argsOrOptions, maybeOptions);
+  return _processDeps.runSync(file, args, {
+    ...options,
+    origin: options.origin || "hook",
+    policy: "allow",
+    scope: "hook",
+  });
+}
+
+runner._deps.run = runHookProcess;
+runner._deps.runSync = runHookProcessSync;
+
+export const {
+  runCommandHook,
+  runCommandHookAsync,
+  runHooks,
+  runHooksParallel,
+  interpretHookOutcome,
+  tryParseDecision,
+  HOOK_DECISIONS,
+  HOOK_PAYLOAD_SCHEMA_VERSION,
+  hookBreakerConfig,
+  _resetHookBreaker,
+  _deps,
+} = runner;
+
+export default runner;

package/src/lib/hooks-v2-producers.js

@@ -3,13 +3,38 @@
  * Hook failures never change the surrounding agent or interaction result.
  */
 export function emitHooksV2Event(eventName, context = {}, options = {}) {
-  void import("./hooks-v2-runtime.js")
-    .then(({ default: runtime }) => {
-      if (!runtime || typeof runtime.executeHooks !== "function") return;
-      return runtime.executeHooks(eventName, context, options);
-    })
-    .catch(() => {
-      // Hooks are an optional extension; producer delivery is best-effort.
-    });
+  void executeHooksV2Event(eventName, context, options);
 }
 
+/**
+ * Decision-capable producer bridge. Callers at a real gate (PreToolUse,
+ * Setup, prompt expansion) await this result; observer producers can keep
+ * using emitHooksV2Event().
+ */
+export async function executeHooksV2Event(
+  eventName,
+  context = {},
+  options = {},
+) {
+  try {
+    const { default: runtime } = await import("./hooks-v2-runtime.js");
+    if (!runtime || typeof runtime.executeHooks !== "function") {
+      return {
+        success: options.failClosed !== true,
+        blocked: options.failClosed === true,
+        decision: options.failClosed === true ? "block" : "continue",
+        unavailable: true,
+        results: [],
+      };
+    }
+    return await runtime.executeHooks(eventName, context, options);
+  } catch (error) {
+    return {
+      success: options.failClosed !== true,
+      blocked: options.failClosed === true,
+      decision: options.failClosed === true ? "block" : "continue",
+      error: error?.message || String(error),
+      results: [],
+    };
+  }
+}