chainlesschain 0.165.2 → 0.165.4

package/src/lib/background-agent-supervisor.js

@@ -79,6 +79,110 @@ export const PID_IDENTITY_TOLERANCE_MS = 60000;
 export const PROCESS_START_TIME_CACHE_TTL_MS = 10_000;
 export const PROCESS_START_TIME_CACHE_MAX_ENTRIES = 4_096;
 
+// Linux exposes these fields directly through procfs. `/proc/<pid>/stat`
+// reports starttime in USER_HZ units, which Linux defines as 100 ticks/second
+// for this userspace ABI independently of the kernel scheduler frequency.
+const LINUX_PROC_CLOCK_TICKS_PER_SECOND = 100;
+let linuxBootTimeMsCache;
+
+export function parseLinuxProcStat(text, bootTimeMs = null) {
+  const value = String(text || "").trim();
+  const open = value.indexOf("(");
+  const close = value.lastIndexOf(")");
+  if (open <= 0 || close <= open || value.charAt(close + 1) !== " ") {
+    return null;
+  }
+  const pid = Number(value.slice(0, open).trim());
+  const fields = value
+    .slice(close + 2)
+    .trim()
+    .split(/\s+/u);
+  const state = fields[0];
+  const processGroupId = Number(fields[2]);
+  const startTimeTicks = Number(fields[19]);
+  if (
+    !Number.isSafeInteger(pid) ||
+    pid <= 0 ||
+    !/^[A-Z]$/iu.test(state || "") ||
+    !Number.isSafeInteger(processGroupId) ||
+    processGroupId <= 0 ||
+    !Number.isFinite(startTimeTicks) ||
+    startTimeTicks < 0
+  ) {
+    return null;
+  }
+  const boot = Number(bootTimeMs);
+  return {
+    pid,
+    state: state.toUpperCase(),
+    processGroupId,
+    startTimeTicks,
+    startedAtMs:
+      Number.isFinite(boot) && boot > 0
+        ? boot + (startTimeTicks * 1000) / LINUX_PROC_CLOCK_TICKS_PER_SECOND
+        : null,
+  };
+}
+
+function linuxBootTimeMs() {
+  if (linuxBootTimeMsCache !== undefined) return linuxBootTimeMsCache;
+  try {
+    const match = /^btime\s+(\d+)\s*$/mu.exec(
+      readFileSync("/proc/stat", "utf8"),
+    );
+    const seconds = match ? Number(match[1]) : null;
+    linuxBootTimeMsCache =
+      Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : null;
+  } catch {
+    linuxBootTimeMsCache = null;
+  }
+  return linuxBootTimeMsCache;
+}
+
+function readLinuxProcProcess(pid) {
+  const target = Number(pid);
+  if (!Number.isSafeInteger(target) || target <= 0) {
+    return { status: "unknown", process: null };
+  }
+  try {
+    const parsed = parseLinuxProcStat(
+      readFileSync(`/proc/${target}/stat`, "utf8"),
+      linuxBootTimeMs(),
+    );
+    return parsed
+      ? { status: "present", process: parsed }
+      : { status: "unknown", process: null };
+  } catch (error) {
+    return ["ENOENT", "ESRCH"].includes(error?.code)
+      ? { status: "absent", process: null }
+      : { status: "unknown", process: null };
+  }
+}
+
+function readLinuxProcProcessGroupStates(pgid) {
+  const target = Number(pgid);
+  if (!Number.isSafeInteger(target) || target <= 0) return null;
+  let entries;
+  try {
+    entries = readdirSync("/proc");
+  } catch {
+    return null;
+  }
+  const states = [];
+  for (const entry of entries) {
+    if (!/^\d+$/u.test(entry)) continue;
+    const observed = readLinuxProcProcess(Number(entry));
+    if (observed.status === "unknown") return null;
+    if (
+      observed.status === "present" &&
+      observed.process.processGroupId === target
+    ) {
+      states.push(observed.process.state);
+    }
+  }
+  return states;
+}
+
 /**
  * A bounded FIFO/TTL cache for process creation-time probes.
  *
@@ -263,6 +367,13 @@ function defaultReadProcessStartTimeMs(pid) {
     }
     return null;
   }
+  if (process.platform === "linux") {
+    const observed = readLinuxProcProcess(target);
+    if (observed.status === "absent") return { status: "absent" };
+    if (Number.isFinite(observed.process?.startedAtMs)) {
+      return observed.process.startedAtMs;
+    }
+  }
   // POSIX: `ps -o lstart=` gives an absolute start timestamp on Linux + macOS
   // (procps and BSD ps both support it; busybox ps does not → null → open).
   try {
@@ -300,6 +411,12 @@ function defaultReadProcessState(pid) {
   ) {
     return null;
   }
+  if (process.platform === "linux") {
+    const observed = readLinuxProcProcess(target);
+    if (observed.status !== "unknown") {
+      return observed.process?.state || null;
+    }
+  }
   try {
     const result = runSupervisorCommand(
       "ps",
@@ -335,6 +452,10 @@ function defaultReadProcessGroupStates(pgid) {
   ) {
     return null;
   }
+  if (process.platform === "linux") {
+    const states = readLinuxProcProcessGroupStates(target);
+    if (Array.isArray(states)) return states;
+  }
   try {
     const result = runSupervisorCommand(
       "ps",
@@ -1128,7 +1249,7 @@ function mergeBackgroundAgentState(current, requested) {
   return next;
 }
 
-function persistBackgroundAgentState(target, next) {
+function persistBackgroundAgentState(target, next, options = {}) {
   // Multiple async state writers can run in one process; a pid-only temporary
   // name lets them overwrite each other's staging file. A unique suffix keeps
   // each atomic replacement independent. Windows scanners/readers can also
@@ -1136,6 +1257,21 @@ function persistBackgroundAgentState(target, next) {
   // transient class rather than surfacing a spurious EPERM background failure.
   const tmp = `${target}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
   writeFileSync(tmp, JSON.stringify(next, null, 2), { mode: 0o600 });
+  try {
+    if (
+      typeof options.publishReleaseAfterPathRemoved === "function" &&
+      options.publishReleaseAfterPathRemoved(tmp) !== true
+    ) {
+      const error = new Error(
+        `Could not publish state-lock release handoff: ${target}`,
+      );
+      error.code = "STATE_LOCK_RELEASE_HANDOFF_FAILED";
+      throw error;
+    }
+  } catch (error) {
+    rmSync(tmp, { force: true });
+    throw error;
+  }
   for (let attempt = 0; ; attempt++) {
     try {
       renameSync(tmp, target);
@@ -1179,7 +1315,7 @@ export function mutateBackgroundAgentState(id, updater, options = {}) {
   const target = statePath(safe);
   return withFileLock(
     target,
-    () => {
+    ({ publishReleaseAfterPathRemoved }) => {
       const read = readBackgroundAgentStateResult(safe);
       if (read.error) throw read.error;
       if (read.missing && options.createIfMissing !== true) {
@@ -1193,7 +1329,9 @@ export function mutateBackgroundAgentState(id, updater, options = {}) {
         ...requested,
         id: safe,
       });
-      persistBackgroundAgentState(target, next);
+      persistBackgroundAgentState(target, next, {
+        publishReleaseAfterPathRemoved,
+      });
       return { applied: true, state: next, previous: read.state };
     },
     {
@@ -2976,8 +3114,14 @@ function recordedBackgroundProcessesAlive(state) {
   );
 }
 
-export function isBackgroundProcessTreeExecutionAlive(pid, startedAt) {
-  const identity = inspectDestructiveProcessIdentity(pid, startedAt);
+export function isBackgroundProcessTreeExecutionAlive(
+  pid,
+  startedAt,
+  options = {},
+) {
+  const identity = inspectDestructiveProcessIdentity(pid, startedAt, {
+    processGroup: options.processGroup !== false,
+  });
   // `unverifiable` includes a vanished/zombie POSIX leader whose process group
   // is still executable or whose group snapshot failed. Both must block
   // worktree deletion just as a verified live leader does.

package/src/lib/background-turn-bootstrap-protocol.js

@@ -11,6 +11,10 @@ export const BACKGROUND_TURN_BOOTSTRAP_READY =
   "background-turn-bootstrap-ready";
 export const BACKGROUND_TURN_BOOTSTRAP_RELEASE =
   "background-turn-bootstrap-release";
+// The formal launch gate permits 120 seconds for a 20-worker hosted runner to
+// become ready. Keep the pre-main barrier alive for that same bounded window;
+// worker/IPC death still fails immediately through the disconnect listener.
+export const BACKGROUND_TURN_BOOTSTRAP_RELEASE_TIMEOUT_MS = 120_000;
 
 export const BACKGROUND_TURN_BOOTSTRAP_ENV = Object.freeze({
   nonce: "CC_BACKGROUND_TURN_BOOTSTRAP_NONCE",

package/src/lib/command-lifecycle-report.js

@@ -38,12 +38,16 @@ export const COMMAND_ALIAS_DECISION_POLICY = Object.freeze({
   requiredPlatforms: Object.freeze(["linux", "macos", "windows"]),
 });
 
-// This repository-owned anchor intentionally remains unconfigured until the
-// first public release containing the DELTA lifecycle exporter is published.
-// Updating it requires a reviewed code change with all three exact values.
+// Repository-owned anchor for the first public release containing the complete
+// DELTA lifecycle exporter and repository-probe hardening. Coverage must begin
+// at this exact npm publication boundary; report input cannot override it.
 export const COMMAND_LIFECYCLE_DELTA_RELEASE_POLICY = Object.freeze({
   schema: "chainlesschain.command-lifecycle-delta-release-policy.v1",
-  firstPublicRelease: null,
+  firstPublicRelease: Object.freeze({
+    version: "0.163.4",
+    commitSha: "27ed0ac2005e16ce5ddff53990e85b1d13ea0b1d",
+    npmPublishedAt: "2026-08-10T19:42:11.053Z",
+  }),
   incompatibleReleases: Object.freeze(["0.162.198", "0.163.3"]),
 });
 

package/src/lib/cowork-adapter.js

@@ -108,8 +108,9 @@ async function invokeChatCall(callWrapper, provider, model, call) {
  * @param {string} [options.apiKey] - API key override
  * @param {(request: {call: function, provider: string, model: string}) => Promise<object>} [options.callWrapper]
  *        Optional host boundary around each real provider call. The callback
- *        resolves to a private `{content, usage?}` envelope; callers still
- *        receive only the response string.
+ *        may invoke `call({ signal })` to bind cancellation and resolves to a
+ *        private `{content, usage?}` envelope; callers still receive only the
+ *        response string.
  * @returns {(messages: object[], opts?: object) => Promise<string>}
  */
 export function createChatFn(options = {}) {
@@ -145,9 +146,10 @@ export function createChatFn(options = {}) {
         callWrapper,
         provider,
         currentModel,
-        async () => {
+        async ({ signal = opts.signal || resolved.signal } = {}) => {
           const res = await fetch(`${baseUrl}/api/chat`, {
             method: "POST",
+            signal,
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
               model: currentModel,
@@ -185,9 +187,10 @@ export function createChatFn(options = {}) {
         callWrapper,
         provider,
         currentModel,
-        async () => {
+        async ({ signal = opts.signal || resolved.signal } = {}) => {
           const res = await fetch(`${baseUrl}/messages`, {
             method: "POST",
+            signal,
             headers: {
               "Content-Type": "application/json",
               "x-api-key": key,
@@ -214,9 +217,10 @@ export function createChatFn(options = {}) {
       callWrapper,
       provider,
       currentModel,
-      async () => {
+      async ({ signal = opts.signal || resolved.signal } = {}) => {
         const res = await fetch(`${baseUrl}/chat/completions`, {
           method: "POST",
+          signal,
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${key}`,

package/src/lib/cowork-task-runner.js

@@ -518,8 +518,12 @@ export function prepareCoworkMcpRuntime(mcp, options = {}) {
  * @param {string} [options.mcpSessionId] - Stable MCP ledger session for resume
  * @param {string} [options.workflowEffectId] - Canonical durable workflow effect
  * @param {boolean} [options.strictUsageTelemetry] - Require synchronous durable call observers
+ * @param {boolean} [options.managedCheckpoint] - Wrap mutating child tools in workspace transactions
+ * @param {string|null} [options.managedCheckpointStateDir] - Optional transaction state root
+ * @param {string[]} [options.managedCheckpointExclusions] - Explicit uncovered workspace paths
  * @param {function} [options.onUsageBoundary] - Provider-call durable start observer
  * @param {function} [options.onUsageSettlement] - Provider-call durable settlement observer
+ * @param {function} [options.onProviderReceipt] - Provider receipt durable prewrite observer
  * @param {function} [options.onToolCallBoundary] - Tool-call durable start observer
  * @param {function} [options.onToolCallSettlement] - Tool-call durable settlement observer
  * @param {(request: object) => boolean|Promise<boolean>} [options.approveMcpLocalCodeExecution]
@@ -540,8 +544,12 @@ export async function runCoworkTask(options = {}) {
     mcpSessionId = null,
     workflowEffectId = null,
     strictUsageTelemetry = false,
+    managedCheckpoint = false,
+    managedCheckpointStateDir = null,
+    managedCheckpointExclusions = [],
     onUsageBoundary = null,
     onUsageSettlement = null,
+    onProviderReceipt = null,
     onToolCallBoundary = null,
     onToolCallSettlement = null,
     approveMcpLocalCodeExecution = null,
@@ -640,6 +648,7 @@ export async function runCoworkTask(options = {}) {
             strictUsageTelemetry: true,
             onUsageBoundary,
             onUsageSettlement,
+            onProviderReceipt,
             onToolCallBoundary,
             onToolCallSettlement,
           }
@@ -678,6 +687,17 @@ export async function runCoworkTask(options = {}) {
       mcpRuntime.sessionId && mcpRuntime.bindingAllowed
         ? { sessionId: mcpRuntime.sessionId }
         : {};
+    if (managedCheckpoint === true) {
+      loopOptions.managedCheckpoint = true;
+      if (managedCheckpointStateDir) {
+        loopOptions.managedCheckpointStateDir = managedCheckpointStateDir;
+      }
+      if (Array.isArray(managedCheckpointExclusions)) {
+        loopOptions.managedCheckpointExclusions = [
+          ...managedCheckpointExclusions,
+        ];
+      }
+    }
     if (
       Array.isArray(template.shellPolicyOverrides) &&
       template.shellPolicyOverrides.length

package/src/lib/cowork-workflow.js

@@ -59,6 +59,9 @@ import { canonicalJson } from "./scheduler-kernel/contract.js";
 /** Maximum number of items a single forEach step can expand into. */
 export const MAX_FAN_OUT = 500;
 
+/** Maximum declarative choices accepted by one durable stage input gate. */
+export const MAX_STAGE_INPUT_OPTIONS = 32;
+
 /** Absolute ceiling on a single loop step's iterations (infinite-loop guard). */
 export const MAX_LOOP_ITERATIONS = 100;
 export const COWORK_WORKFLOW_RUN_RECORD_SCHEMA = "cc-cowork-workflow-run/v1";
@@ -832,6 +835,53 @@ export function validateWorkflow(wf) {
       if (s.when !== undefined && typeof s.when !== "string") {
         errors.push(`steps[${i}].when must be a string expression`);
       }
+      if (s.needsInput !== undefined) {
+        const input = s.needsInput;
+        const inputKeys =
+          input && typeof input === "object" && !Array.isArray(input)
+            ? Object.keys(input)
+            : [];
+        if (
+          !input ||
+          typeof input !== "object" ||
+          Array.isArray(input) ||
+          inputKeys.some(
+            (key) => !["prompt", "options", "multiSelect"].includes(key),
+          ) ||
+          typeof input.prompt !== "string" ||
+          input.prompt.trim() !== input.prompt ||
+          input.prompt.length === 0 ||
+          input.prompt.length > 4096
+        ) {
+          errors.push(`steps[${i}].needsInput has an invalid prompt schema`);
+        } else {
+          if (
+            input.options !== undefined &&
+            (!Array.isArray(input.options) ||
+              input.options.length === 0 ||
+              input.options.length > MAX_STAGE_INPUT_OPTIONS ||
+              input.options.some(
+                (option) =>
+                  typeof option !== "string" ||
+                  option.trim() !== option ||
+                  option.length === 0 ||
+                  option.length > 512,
+              ) ||
+              new Set(input.options).size !== input.options.length)
+          ) {
+            errors.push(`steps[${i}].needsInput.options is invalid`);
+          }
+          if (
+            input.multiSelect !== undefined &&
+            typeof input.multiSelect !== "boolean"
+          ) {
+            errors.push(`steps[${i}].needsInput.multiSelect must be boolean`);
+          }
+          if (input.multiSelect === true && !Array.isArray(input.options)) {
+            errors.push(`steps[${i}].needsInput.multiSelect requires options`);
+          }
+        }
+      }
       if (s.forEach !== undefined) {
         const f = s.forEach;
         const ok =
@@ -1076,6 +1126,69 @@ export function substitutePlaceholders(template, resultsById) {
   );
 }
 
+function normalizeResolvedStageInput(value, spec) {
+  const answer = snapshotAdmittedCanonicalValue(
+    value,
+    "workflow stage input answer",
+    { maxNodes: 256, maxBytes: 64 * 1024 },
+  );
+  const options = Array.isArray(spec.options) ? spec.options : null;
+  if (spec.multiSelect === true) {
+    if (
+      !Array.isArray(answer) ||
+      answer.length === 0 ||
+      answer.length > MAX_STAGE_INPUT_OPTIONS ||
+      answer.some((item) => typeof item !== "string") ||
+      new Set(answer).size !== answer.length ||
+      answer.some((item) => !options.includes(item))
+    ) {
+      throw runResultError("workflow stage input answer is invalid");
+    }
+    return answer;
+  }
+  if (
+    typeof answer !== "string" ||
+    answer.length === 0 ||
+    answer.length > 64 * 1024 ||
+    (options && !options.includes(answer))
+  ) {
+    throw runResultError("workflow stage input answer is invalid");
+  }
+  return answer;
+}
+
+async function resolveStageInputMessage(
+  step,
+  message,
+  resultsById,
+  resolveInput,
+) {
+  if (step.needsInput === undefined) return message;
+  if (typeof resolveInput !== "function") {
+    const error = new Error(
+      `workflow step '${step.id}' requires a durable input resolver`,
+    );
+    error.code = "COWORK_WORKFLOW_INPUT_RESOLVER_REQUIRED";
+    throw error;
+  }
+  const spec = step.needsInput;
+  const prompt = substitutePlaceholders(spec.prompt, resultsById);
+  const answer = normalizeResolvedStageInput(
+    await resolveInput(
+      Object.freeze({
+        stepId: step.id,
+        prompt,
+        options: Array.isArray(spec.options)
+          ? Object.freeze([...spec.options])
+          : null,
+        multiSelect: spec.multiSelect === true,
+      }),
+    ),
+    spec,
+  );
+  return `${message}\n\n## Bound user input for stage ${step.id}\n${canonicalJson(answer, "workflowStageInput")}`;
+}
+
 // ─── Persistence ─────────────────────────────────────────────────────────────
 
 function _storedWorkflowError(message) {
@@ -1600,6 +1713,7 @@ export async function runStepNode(step, ctx) {
     onStepComplete,
     taskSemaphore,
     runTask,
+    resolveInput,
     admitted = false,
   } = ctx;
   const recordId = step.id;
@@ -1620,9 +1734,20 @@ export async function runStepNode(step, ctx) {
   }
   if (!runThis) return single("skipped", "when-condition false");
 
-  if (isLoopStep(step)) {
+  const resolvedMessage = await resolveStageInputMessage(
+    step,
+    step.message,
+    resultsById,
+    resolveInput,
+  );
+  const activeStep =
+    resolvedMessage === step.message
+      ? step
+      : { ...step, message: resolvedMessage };
+
+  if (isLoopStep(activeStep)) {
     const o = await runLoopStep({
-      step,
+      step: activeStep,
       recordId,
       cwd,
       llmOptions,
@@ -1640,10 +1765,10 @@ export async function runStepNode(step, ctx) {
     };
   }
 
-  if (step.forEach !== undefined) {
+  if (activeStep.forEach !== undefined) {
     let items;
     try {
-      items = resolveForEachItems(step.forEach, resultsById);
+      items = resolveForEachItems(activeStep.forEach, resultsById);
     } catch (err) {
       return single("failed", err.message);
     }
@@ -1651,10 +1776,10 @@ export async function runStepNode(step, ctx) {
     const children = await Promise.all(
       items.map(async (item, k) => {
         const childId = `${recordId}[${k}]`;
-        const withItem = substituteItem(step.message, item);
+        const withItem = substituteItem(activeStep.message, item);
         const msg = substitutePlaceholders(withItem, resultsById);
         const r = await runStepWithRetry({
-          step,
+          step: activeStep,
           message: msg,
           cwd,
           llmOptions,
@@ -1687,9 +1812,9 @@ export async function runStepNode(step, ctx) {
     };
   }
 
-  const message = substitutePlaceholders(step.message, resultsById);
+  const message = substitutePlaceholders(activeStep.message, resultsById);
   const r = await runStepWithRetry({
-    step,
+    step: activeStep,
     message,
     cwd,
     llmOptions,
@@ -1724,6 +1849,7 @@ export async function runPipeline({
   onStepComplete,
   taskSemaphore,
   runTask = _deps.runTask,
+  resolveInput,
   admitted = false,
 }) {
   const limit = Math.max(1, Math.floor(maxParallel) || 1);
@@ -1787,6 +1913,7 @@ export async function runPipeline({
           onStepComplete,
           taskSemaphore,
           runTask,
+          resolveInput,
           admitted,
         });
       } catch (err) {
@@ -1950,6 +2077,7 @@ function normalizeAdmittedRunRecord(
  * @param {object} [options.llmOptions] - Forwarded to each task
  * @param {function} [options.onStepStart]
  * @param {function} [options.onStepComplete]
+ * @param {function} [options.resolveInput] - Durable stage input resolver
  * @param {object} [options.runAdmission] - Secret-free, digest-bound dynamic
  *   workflow admission. Production entry points require this even though the
  *   low-level executor keeps it optional for existing library callers.
@@ -1973,6 +2101,7 @@ export async function executeWorkflow(options = {}) {
     onStepComplete,
     pipeline,
     runAdmission,
+    resolveInput,
     runTask: requestedRunTask,
   } = options;
 
@@ -2019,6 +2148,16 @@ export async function executeWorkflow(options = {}) {
       "cowork-workflow: runTask is not available (wire runCoworkTask before executing)",
     );
   }
+  if (
+    runtimeWorkflow.steps.some((step) => step.needsInput !== undefined) &&
+    typeof resolveInput !== "function"
+  ) {
+    const error = new Error(
+      "workflow contains needsInput stages but no durable input resolver was provided",
+    );
+    error.code = "COWORK_WORKFLOW_INPUT_RESOLVER_REQUIRED";
+    throw error;
+  }
 
   const taskSemaphore = createWorkflowTaskSemaphore(concurrencyLimit);
   const resultsById = new Map();
@@ -2038,6 +2177,7 @@ export async function executeWorkflow(options = {}) {
       onStepComplete,
       taskSemaphore,
       runTask: runtimeRunTask,
+      resolveInput,
       admitted: verifiedRunAdmission != null,
     }));
   } else {
@@ -2094,23 +2234,33 @@ export async function executeWorkflow(options = {}) {
             preOutcomes.push(outcome);
             continue;
           }
+          const resolvedMessage = await resolveStageInputMessage(
+            step,
+            step.message,
+            resultsById,
+            resolveInput,
+          );
+          const activeStep =
+            resolvedMessage === step.message
+              ? step
+              : { ...step, message: resolvedMessage };
           // loop node — runs its body repeatedly; per-iteration substitution
           // happens inside runLoopStep, so push the raw template.
-          if (isLoopStep(step)) {
+          if (isLoopStep(activeStep)) {
             runnable.push({
-              step,
-              message: step.message,
-              recordId: step.id,
+              step: activeStep,
+              message: activeStep.message,
+              recordId: activeStep.id,
               parentId: null,
               isLoop: true,
             });
             continue;
           }
           // forEach-expansion
-          if (step.forEach !== undefined) {
+          if (activeStep.forEach !== undefined) {
             let items;
             try {
-              items = resolveForEachItems(step.forEach, resultsById);
+              items = resolveForEachItems(activeStep.forEach, resultsById);
             } catch (err) {
               anyFailure = true;
               const outcome = {
@@ -2135,20 +2285,28 @@ export async function executeWorkflow(options = {}) {
               continue;
             }
             for (let k = 0; k < items.length; k++) {
-              const childId = `${step.id}[${k}]`;
-              const withItem = substituteItem(step.message, items[k]);
+              const childId = `${activeStep.id}[${k}]`;
+              const withItem = substituteItem(activeStep.message, items[k]);
               const msg = substitutePlaceholders(withItem, resultsById);
               runnable.push({
-                step,
+                step: activeStep,
                 message: msg,
                 recordId: childId,
-                parentId: step.id,
+                parentId: activeStep.id,
               });
             }
             continue;
           }
-          const message = substitutePlaceholders(step.message, resultsById);
-          runnable.push({ step, message, recordId: step.id, parentId: null });
+          const message = substitutePlaceholders(
+            activeStep.message,
+            resultsById,
+          );
+          runnable.push({
+            step: activeStep,
+            message,
+            recordId: activeStep.id,
+            parentId: null,
+          });
         }
 
         const promises = runnable.map(