@automatalabs/workflows 0.55.0 → 0.57.0

package/dist/mcp-server.js

@@ -14,7 +14,7 @@ import { realpathSync as realpathSync4 } from "node:fs";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // ../mcp-server/src/daemon/commands.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 
 // ../../node_modules/.pnpm/@modelcontextprotocol+server@2.0.0/node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create = Object.create;
@@ -1419,8 +1419,8 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
           let i = 0;
           while (i < fullpath.length) {
             const el = fullpath[i];
-            const terminal = i === fullpath.length - 1;
-            if (!terminal) {
+            const terminal2 = i === fullpath.length - 1;
+            if (!terminal2) {
               curr[el] = curr[el] || { _errors: [] };
             } else {
               curr[el] = curr[el] || { _errors: [] };
@@ -1457,7 +1457,7 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
         let i = 0;
         while (i < fullpath.length) {
           const el = fullpath[i];
-          const terminal = i === fullpath.length - 1;
+          const terminal2 = i === fullpath.length - 1;
           if (typeof el === "string") {
             curr.properties ?? (curr.properties = {});
             (_a3 = curr.properties)[el] ?? (_a3[el] = { errors: [] });
@@ -1467,7 +1467,7 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
             (_b = curr.items)[el] ?? (_b[el] = { errors: [] });
             curr = curr.items[el];
           }
-          if (terminal) {
+          if (terminal2) {
             curr.errors.push(mapper(issue2));
           }
           i++;
@@ -11559,8 +11559,8 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   return _result.schema;
 }
 function extractDefs(ctx, schema) {
-  const root = ctx.seen.get(schema);
-  if (!root)
+  const root2 = ctx.seen.get(schema);
+  if (!root2)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
   for (const entry of ctx.seen.entries()) {
@@ -11585,7 +11585,7 @@ function extractDefs(ctx, schema) {
       entry[1].defId = id;
       return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
     }
-    if (entry[1] === root) {
+    if (entry[1] === root2) {
       return { ref: "#" };
     }
     const uriPrefix = `#`;
@@ -11649,8 +11649,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
 }
 function finalize(ctx, schema) {
-  const root = ctx.seen.get(schema);
-  if (!root)
+  const root2 = ctx.seen.get(schema);
+  if (!root2)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
     const seen = ctx.seen.get(zodSchema);
@@ -11733,7 +11733,7 @@ function finalize(ctx, schema) {
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id);
   }
-  Object.assign(result, root.def ?? root.schema);
+  Object.assign(result, root2.def ?? root2.schema);
   const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
@@ -18579,8 +18579,8 @@ function decodeMcpParamValue(value) {
     return;
   }
 }
-function valueAtPath(root, path) {
-  let node = root;
+function valueAtPath(root2, path) {
+  let node = root2;
   for (const key of path) {
     if (node === null || typeof node !== "object") return void 0;
     node = node[key];
@@ -23206,24 +23206,24 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
     }
   }
   exports.compileSchema = compileSchema;
-  function resolveRef2(root, baseId, ref) {
+  function resolveRef2(root2, baseId, ref) {
     var _a3;
     ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
-    const schOrFunc = root.refs[ref];
+    const schOrFunc = root2.refs[ref];
     if (schOrFunc) return schOrFunc;
-    let _sch = resolve.call(this, root, ref);
+    let _sch = resolve.call(this, root2, ref);
     if (_sch === void 0) {
-      const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
+      const schema = (_a3 = root2.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
       const { schemaId } = this.opts;
       if (schema) _sch = new SchemaEnv({
         schema,
         schemaId,
-        root,
+        root: root2,
         baseId
       });
     }
     if (_sch === void 0) return;
-    return root.refs[ref] = inlineOrCompile.call(this, _sch);
+    return root2.refs[ref] = inlineOrCompile.call(this, _sch);
   }
   exports.resolveRef = resolveRef2;
   function inlineOrCompile(sch) {
@@ -23237,20 +23237,20 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve(root, ref) {
+  function resolve(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string") ref = sch;
-    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
+    return sch || this.schemas[ref] || resolveSchema.call(this, root2, ref);
   }
-  function resolveSchema(root, ref) {
+  function resolveSchema(root2, ref) {
     const p = this.opts.uriResolver.parse(ref);
     const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
-    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
-    if (Object.keys(root.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root);
+    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root2.baseId, void 0);
+    if (Object.keys(root2.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root2);
     const id = (0, resolve_1.normalizeId)(refPath);
     const schOrRef = this.refs[id] || this.schemas[id];
     if (typeof schOrRef == "string") {
-      const sch = resolveSchema.call(this, root, schOrRef);
+      const sch = resolveSchema.call(this, root2, schOrRef);
       if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") return;
       return getJsonPointer.call(this, p, sch);
     }
@@ -23264,7 +23264,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
       return new SchemaEnv({
         schema,
         schemaId,
-        root,
+        root: root2,
         baseId
       });
     }
@@ -23278,7 +23278,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
     "dependencies",
     "definitions"
   ]);
-  function getJsonPointer(parsedRef, { baseId, schema, root }) {
+  function getJsonPointer(parsedRef, { baseId, schema, root: root2 }) {
     var _a3;
     if (((_a3 = parsedRef.fragment) === null || _a3 === void 0 ? void 0 : _a3[0]) !== "/") return;
     for (const part of parsedRef.fragment.slice(1).split("/")) {
@@ -23292,13 +23292,13 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
     let env;
     if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
       const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-      env = resolveSchema.call(this, root, $ref);
+      env = resolveSchema.call(this, root2, $ref);
     }
     const { schemaId } = this.opts;
     env = env || new SchemaEnv({
       schema,
       schemaId,
-      root,
+      root: root2,
       baseId
     });
     if (env.schema !== env.root.schema) return env;
@@ -24163,11 +24163,11 @@ var require_core$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
       while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") keyRef = sch;
       if (sch === void 0) {
         const { schemaId } = this.opts;
-        const root = new compile_1.SchemaEnv({
+        const root2 = new compile_1.SchemaEnv({
           schema: {},
           schemaId
         });
-        sch = compile_1.resolveSchema.call(this, root, keyRef);
+        sch = compile_1.resolveSchema.call(this, root2, keyRef);
         if (!sch) return;
         this.refs[keyRef] = sch;
       }
@@ -24472,16 +24472,16 @@ var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
     code(cxt) {
       const { gen, schema: $ref, it } = cxt;
       const { baseId, schemaEnv: env, validateName, opts, self } = it;
-      const { root } = env;
-      if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef();
-      const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
+      const { root: root2 } = env;
+      if (($ref === "#" || $ref === "#/") && baseId === root2.baseId) return callRootRef();
+      const schOrEnv = compile_1.resolveRef.call(self, root2, baseId, $ref);
       if (schOrEnv === void 0) throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
       if (schOrEnv instanceof compile_1.SchemaEnv) return callValidate(schOrEnv);
       return inlineRefSchema(schOrEnv);
       function callRootRef() {
-        if (env === root) return callRef(cxt, validateName, env, env.$async);
-        const rootName = gen.scopeValue("root", { ref: root });
-        return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
+        if (env === root2) return callRef(cxt, validateName, env, env.$async);
+        const rootName = gen.scopeValue("root", { ref: root2 });
+        return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root2, root2.$async);
       }
       function callValidate(sch) {
         callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
@@ -26196,12 +26196,12 @@ var require_dynamicAnchor = /* @__PURE__ */ __commonJSMin(((exports) => {
   exports.dynamicAnchor = dynamicAnchor;
   function _getValidate(cxt) {
     const { schemaEnv, schema, self } = cxt.it;
-    const { root, baseId, localRefs, meta: meta3 } = schemaEnv.root;
+    const { root: root2, baseId, localRefs, meta: meta3 } = schemaEnv.root;
     const { schemaId } = self.opts;
     const sch = new compile_1.SchemaEnv({
       schema,
       schemaId,
-      root,
+      root: root2,
       baseId,
       localRefs,
       meta: meta3
@@ -30640,7 +30640,7 @@ function createRequestStateCodec(options) {
 
 // ../mcp-server/src/server.ts
 import { createHash, randomBytes } from "node:crypto";
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { createRequire } from "node:module";
 import {
   buildModelFilter,
@@ -30696,7 +30696,8 @@ var workflowToolInputShape = {
   maxAgents: external_exports.number().int().positive().optional().describe("Max agents allowed in this run. Default 1000 (engine cap MAX_AGENTS_PER_RUN)."),
   concurrency: external_exports.number().int().positive().optional().describe("Max concurrent agents. CLAMPED to the runtime max (16) by the engine \u2014 not rejected."),
   agentRetries: external_exports.number().int().min(0).optional().describe("Retry attempts for recoverable agent failures. CLAMPED to the runtime max (3) by the engine."),
-  agentTimeoutMs: external_exports.number().int().positive().nullable().optional().describe("Per-agent timeout in ms. Omit/null for no hard timeout (the engine owns the timeout)."),
+  agentTimeoutMs: external_exports.number().int().positive().nullable().optional().describe("Per-agent total-wall timeout in ms. Omit/null for no hard timeout (the engine owns the timeout)."),
+  agentIdleTimeoutMs: external_exports.number().int().positive().nullable().optional().describe("Per-agent no-backend-activity timeout in ms. Omit/null to disable the idle watchdog."),
   resumeFromRunId: external_exports.string().min(1).optional().describe(
     "Start a new run from this persisted source run. Re-send the script via script or scriptPath and the desired args; the manager validates replay eligibility and runs live wherever reuse is uncertain. The source ID must exist in this project namespace."
   ),
@@ -30707,6 +30708,9 @@ var workflowToolInputShape = {
   callIndex: external_exports.number().int().nonnegative().safe().optional().describe(
     "With action=stop, cancel exactly this in-flight agent call without aborting the run. Forbidden for every other action."
   ),
+  forceOwner: external_exports.boolean().optional().describe(
+    "With whole-run action=stop, explicitly authorize terminating a superseded owner daemon when graceful cross-generation control cannot settle. Forbidden with callIndex and every other action."
+  ),
   lastN: external_exports.number().int().min(1).max(50).optional().describe("Latest matching calls. Default 20; range 1..50."),
   labelGlob: external_exports.string().refine((value) => [...value].length >= 1 && [...value].length <= 128, {
     message: "labelGlob must contain from 1 through 128 Unicode code points"
@@ -30718,14 +30722,14 @@ function hasConfigFields(raw) {
   return raw.harnesses !== void 0 || raw.modelSpecs !== void 0 || raw.modelFilter !== void 0 || raw.probeTimeoutMs !== void 0;
 }
 function hasExecutionFields(raw) {
-  return raw.script !== void 0 || raw.scriptPath !== void 0 || raw.projectDir !== void 0 || raw.args !== void 0 || raw.maxAgents !== void 0 || raw.concurrency !== void 0 || raw.agentRetries !== void 0 || raw.agentTimeoutMs !== void 0 || raw.resumeFromRunId !== void 0 || raw.resumePolicy !== void 0 || raw.checkpointReplies !== void 0 || raw.background !== void 0;
+  return raw.script !== void 0 || raw.scriptPath !== void 0 || raw.projectDir !== void 0 || raw.args !== void 0 || raw.maxAgents !== void 0 || raw.concurrency !== void 0 || raw.agentRetries !== void 0 || raw.agentTimeoutMs !== void 0 || raw.agentIdleTimeoutMs !== void 0 || raw.resumeFromRunId !== void 0 || raw.resumePolicy !== void 0 || raw.checkpointReplies !== void 0 || raw.background !== void 0;
 }
 function invalid(message) {
   throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid workflow tool input: ${message}`);
 }
 function parseWorkflowToolInput(raw, options = {}) {
   if (raw.action === "config") {
-    if (raw.script !== void 0 || raw.scriptPath !== void 0 || raw.args !== void 0 || raw.maxAgents !== void 0 || raw.concurrency !== void 0 || raw.agentRetries !== void 0 || raw.agentTimeoutMs !== void 0 || raw.resumeFromRunId !== void 0 || raw.resumePolicy !== void 0 || raw.checkpointReplies !== void 0 || raw.background !== void 0 || raw.runId !== void 0 || raw.callIndex !== void 0 || raw.waitMs !== void 0 || raw.lastN !== void 0 || raw.labelGlob !== void 0 || raw.logLines !== void 0) {
+    if (raw.script !== void 0 || raw.scriptPath !== void 0 || raw.args !== void 0 || raw.maxAgents !== void 0 || raw.concurrency !== void 0 || raw.agentRetries !== void 0 || raw.agentTimeoutMs !== void 0 || raw.agentIdleTimeoutMs !== void 0 || raw.resumeFromRunId !== void 0 || raw.resumePolicy !== void 0 || raw.checkpointReplies !== void 0 || raw.background !== void 0 || raw.runId !== void 0 || raw.callIndex !== void 0 || raw.forceOwner !== void 0 || raw.waitMs !== void 0 || raw.lastN !== void 0 || raw.labelGlob !== void 0 || raw.logLines !== void 0) {
       invalid('action="config" accepts only projectDir, harnesses, modelSpecs, modelFilter, and probeTimeoutMs');
     }
     if (options.requireProjectDir === true && raw.projectDir === void 0) {
@@ -30744,7 +30748,7 @@ function parseWorkflowToolInput(raw, options = {}) {
   }
   if (raw.action === "inspect") {
     if (!raw.runId) invalid('action="inspect" requires runId');
-    if (hasExecutionFields(raw) || hasConfigFields(raw) || raw.waitMs !== void 0 || raw.callIndex !== void 0) {
+    if (hasExecutionFields(raw) || hasConfigFields(raw) || raw.waitMs !== void 0 || raw.callIndex !== void 0 || raw.forceOwner !== void 0) {
       invalid('action="inspect" cannot include execution fields');
     }
     return {
@@ -30757,7 +30761,7 @@ function parseWorkflowToolInput(raw, options = {}) {
   }
   if (raw.action === "await") {
     if (!raw.runId) invalid('action="await" requires runId');
-    if (hasExecutionFields(raw) || hasConfigFields(raw) || raw.callIndex !== void 0) {
+    if (hasExecutionFields(raw) || hasConfigFields(raw) || raw.callIndex !== void 0 || raw.forceOwner !== void 0) {
       invalid('action="await" cannot include execution fields');
     }
     return {
@@ -30774,16 +30778,20 @@ function parseWorkflowToolInput(raw, options = {}) {
     if (hasExecutionFields(raw) || hasConfigFields(raw) || raw.waitMs !== void 0) {
       invalid('action="stop" cannot include execution fields or waitMs');
     }
+    if (raw.callIndex !== void 0 && raw.forceOwner !== void 0) {
+      invalid('action="stop" forceOwner is forbidden with callIndex');
+    }
     return {
       action: "stop",
       runId: raw.runId,
       callIndex: raw.callIndex,
+      ...raw.forceOwner === void 0 ? {} : { forceOwner: raw.forceOwner },
       lastN: raw.lastN,
       labelGlob: raw.labelGlob,
       logLines: raw.logLines
     };
   }
-  if (raw.runId !== void 0 || raw.callIndex !== void 0 || raw.waitMs !== void 0 || raw.lastN !== void 0 || raw.labelGlob !== void 0 || raw.logLines !== void 0 || hasConfigFields(raw)) {
+  if (raw.runId !== void 0 || raw.callIndex !== void 0 || raw.forceOwner !== void 0 || raw.waitMs !== void 0 || raw.lastN !== void 0 || raw.labelGlob !== void 0 || raw.logLines !== void 0 || hasConfigFields(raw)) {
     invalid("run inputs cannot include inspection fields");
   }
   const hasScript = raw.script !== void 0;
@@ -30808,6 +30816,7 @@ function parseWorkflowToolInput(raw, options = {}) {
     concurrency: raw.concurrency,
     agentRetries: raw.agentRetries,
     agentTimeoutMs: raw.agentTimeoutMs,
+    agentIdleTimeoutMs: raw.agentIdleTimeoutMs,
     resumeFromRunId: raw.resumeFromRunId,
     resumePolicy: raw.resumePolicy,
     checkpointReplies: raw.checkpointReplies === void 0 ? void 0 : Object.fromEntries(
@@ -30950,8 +30959,8 @@ async function discoverProjectDefaultBackend(context, probeRunner, timeoutMs = 6
 }
 
 // ../mcp-server/src/project-registry.ts
-import { existsSync as existsSync2, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { isAbsolute as isAbsolute2, join } from "node:path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join2 } from "node:path";
 import {
   WORKFLOW_PROJECTS_SUBDIR,
   WorkflowManager,
@@ -31240,6 +31249,152 @@ async function resetReplProjectState(state, boundMs = SHUTDOWN_DEADLINE_MS) {
   state.drainError = null;
 }
 
+// ../mcp-server/src/daemon/run-control-store.ts
+import { randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { join } from "node:path";
+var CONTROL_DIR = ".control";
+var RUN_ID = /^[a-z0-9]+-[a-z0-9]+$/;
+var OPERATION_ID = /^[0-9a-f-]{36}$/i;
+function root(manager) {
+  return join(manager.getPersistence().getRunsDir(), CONTROL_DIR);
+}
+function runDir(manager, runId) {
+  if (!RUN_ID.test(runId)) throw new Error(`Invalid run-control runId: ${runId}`);
+  return join(root(manager), runId);
+}
+function requestPath(manager, runId, operationId) {
+  if (!OPERATION_ID.test(operationId)) throw new Error(`Invalid run-control operationId: ${operationId}`);
+  return join(runDir(manager, runId), `${operationId}.request.json`);
+}
+function acknowledgementPath(manager, runId, operationId) {
+  if (!OPERATION_ID.test(operationId)) throw new Error(`Invalid run-control operationId: ${operationId}`);
+  return join(runDir(manager, runId), `${operationId}.ack.json`);
+}
+function ensureRunDir(manager, runId) {
+  const dir = runDir(manager, runId);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(root(manager), 448);
+  chmodSync(dir, 448);
+}
+function writeImmutableJson(path, value) {
+  const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { flag: "wx", mode: 384 });
+    linkSync(tmp, path);
+  } finally {
+    rmSync(tmp, { force: true });
+  }
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function validIntent(value, runId) {
+  return value?.version === 1 && value.action === "stop" && OPERATION_ID.test(value.operationId) && RUN_ID.test(value.runId) && (runId === void 0 || value.runId === runId) && typeof value.requestedAt === "string" && typeof value.requestedByInstanceId === "string";
+}
+function validAcknowledgement(value, runId, operationId) {
+  return value?.version === 1 && value.runId === runId && value.operationId === operationId && typeof value.acknowledgedAt === "string" && typeof value.acknowledgedByInstanceId === "string" && (value.outcome === "stopped" || value.outcome === "already-terminal");
+}
+function findPendingWholeStopIntent(manager, runId) {
+  let files;
+  try {
+    files = readdirSync(runDir(manager, runId)).filter((file2) => file2.endsWith(".request.json")).sort();
+  } catch {
+    return void 0;
+  }
+  for (const file2 of files) {
+    const operationId = file2.slice(0, -".request.json".length);
+    if (!OPERATION_ID.test(operationId)) continue;
+    const intent = readJson(requestPath(manager, runId, operationId));
+    if (!validIntent(intent, runId)) continue;
+    const acknowledgement = readWholeStopAcknowledgement(manager, runId, operationId);
+    if (acknowledgement === void 0) return intent;
+  }
+  return void 0;
+}
+function createOrReuseWholeStopIntent(manager, runId, requesterInstanceId) {
+  const pending = findPendingWholeStopIntent(manager, runId);
+  if (pending) return pending;
+  ensureRunDir(manager, runId);
+  for (; ; ) {
+    const intent = {
+      version: 1,
+      operationId: randomUUID(),
+      runId,
+      action: "stop",
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      requestedByInstanceId: requesterInstanceId
+    };
+    try {
+      writeImmutableJson(requestPath(manager, runId, intent.operationId), intent);
+      return intent;
+    } catch (error51) {
+      if (error51.code !== "EEXIST") throw error51;
+    }
+  }
+}
+function readWholeStopIntent(manager, runId, operationId) {
+  const value = readJson(requestPath(manager, runId, operationId));
+  return validIntent(value, runId) && value.operationId === operationId ? value : void 0;
+}
+function readWholeStopAcknowledgement(manager, runId, operationId) {
+  const value = readJson(acknowledgementPath(manager, runId, operationId));
+  return validAcknowledgement(value, runId, operationId) ? value : void 0;
+}
+function acknowledgeWholeStopIntent(manager, intent, ownerInstanceId, outcome) {
+  ensureRunDir(manager, intent.runId);
+  const acknowledgement = {
+    version: 1,
+    operationId: intent.operationId,
+    runId: intent.runId,
+    acknowledgedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    acknowledgedByInstanceId: ownerInstanceId,
+    outcome
+  };
+  const path = acknowledgementPath(manager, intent.runId, intent.operationId);
+  try {
+    writeImmutableJson(path, acknowledgement);
+    return acknowledgement;
+  } catch (error51) {
+    const existing = readWholeStopAcknowledgement(manager, intent.runId, intent.operationId);
+    if (existing) return existing;
+    throw error51;
+  }
+}
+function listPendingWholeStopIntents(manager) {
+  let runIds;
+  try {
+    runIds = readdirSync(root(manager)).filter((entry) => RUN_ID.test(entry));
+  } catch {
+    return [];
+  }
+  const intents = [];
+  for (const runId of runIds) {
+    const pending = findPendingWholeStopIntent(manager, runId);
+    if (pending) intents.push(pending);
+  }
+  return intents;
+}
+function deleteRunControlSidecars(manager, runId) {
+  try {
+    rmSync(runDir(manager, runId), { recursive: true, force: true });
+  } catch {
+  }
+}
+
 // ../mcp-server/src/project-registry.ts
 var MAX_BACKGROUND_RUNS = 4;
 var BackgroundRunRegistry = class {
@@ -31289,13 +31444,16 @@ function resolveProjectDir(raw) {
   }
 }
 var WorkflowProjectRegistry = class {
-  constructor(runner) {
+  constructor(runner, options = {}) {
     this.runner = runner;
+    this.options = options;
   }
   runner;
+  options;
   contexts = /* @__PURE__ */ new Map();
   deletionListeners = /* @__PURE__ */ new Set();
   persistedEventListeners = /* @__PURE__ */ new Set();
+  stoppedListeners = /* @__PURE__ */ new Set();
   /** Adopt an externally built manager as its project's context (composition back-compat). */
   adopt(manager, backgroundRuns) {
     const existing = this.contexts.get(manager.cwd);
@@ -31312,18 +31470,26 @@ var WorkflowProjectRegistry = class {
     if (existing !== void 0) return existing;
     return this.register({
       projectDir,
-      manager: new WorkflowManager({ agent: this.runner, cwd: projectDir }),
+      manager: new WorkflowManager({
+        agent: this.runner,
+        cwd: projectDir,
+        leaseOwnerId: this.options.leaseOwnerId
+      }),
       backgroundRuns: new BackgroundRunRegistry()
     });
   }
   register(context) {
     this.contexts.set(context.projectDir, context);
     context.manager.on("runDeleted", (event) => {
+      deleteRunControlSidecars(context.manager, event.runId);
       for (const listener of this.deletionListeners) listener(event);
     });
     context.manager.on("runEventPersisted", (record2) => {
       for (const listener of this.persistedEventListeners) listener(record2);
     });
+    context.manager.on("stopped", (event) => {
+      for (const listener of this.stoppedListeners) listener(event);
+    });
     return context;
   }
   storeFor(runId) {
@@ -31339,18 +31505,18 @@ var WorkflowProjectRegistry = class {
    * project's next engine construction).
    */
   locateOnDisk(runId) {
-    const projectsDir = join(workflowHomeDir(), WORKFLOW_PROJECTS_SUBDIR);
+    const projectsDir = join2(workflowHomeDir(), WORKFLOW_PROJECTS_SUBDIR);
     let keys;
     try {
-      keys = readdirSync(projectsDir);
+      keys = readdirSync2(projectsDir);
     } catch {
       return void 0;
     }
     for (const key of keys) {
-      const rootDir = join(projectsDir, key);
+      const rootDir = join2(projectsDir, key);
       try {
-        if (!existsSync2(join(rootDir, "runs", `${runId}.json`))) continue;
-        const manifest = JSON.parse(readFileSync(join(rootDir, "project.json"), "utf-8"));
+        if (!existsSync2(join2(rootDir, "runs", `${runId}.json`))) continue;
+        const manifest = JSON.parse(readFileSync2(join2(rootDir, "project.json"), "utf-8"));
         if (typeof manifest.projectDir !== "string" || !isAbsolute2(manifest.projectDir)) continue;
         return this.getOrCreate(manifest.projectDir);
       } catch {
@@ -31370,9 +31536,13 @@ var WorkflowProjectRegistry = class {
     this.persistedEventListeners.add(listener);
     return () => this.persistedEventListeners.delete(listener);
   }
+  onRunStopped(listener) {
+    this.stoppedListeners.add(listener);
+    return () => this.stoppedListeners.delete(listener);
+  }
   activeRunCount() {
     let total = 0;
-    for (const context of this.contexts.values()) total += context.backgroundRuns.activeCount();
+    for (const context of this.contexts.values()) total += context.manager.activeExecutionCount();
     return total;
   }
   /** Dispose every context's REPL workspace: each one DRAINS with the
@@ -31407,7 +31577,7 @@ var WorkflowProjectRegistry = class {
   snapshot() {
     return [...this.contexts.values()].map((context) => ({
       projectDir: context.projectDir,
-      activeRuns: context.backgroundRuns.activeCount()
+      activeRuns: context.manager.activeExecutionCount()
     }));
   }
 };
@@ -31424,6 +31594,10 @@ function singleStoreRouter(manager) {
     onRunEventPersisted: (listener) => {
       manager.on("runEventPersisted", listener);
       return () => manager.off("runEventPersisted", listener);
+    },
+    onRunStopped: (listener) => {
+      manager.on("stopped", listener);
+      return () => manager.off("stopped", listener);
     }
   };
 }
@@ -31484,7 +31658,8 @@ var workflowRunLimitsSchema = external_exports.object({
   tokenBudget: external_exports.number().nonnegative().nullable(),
   concurrency: external_exports.number().int().positive(),
   agentRetries: external_exports.number().int().nonnegative(),
-  agentTimeoutMs: external_exports.number().nonnegative().nullable()
+  agentTimeoutMs: external_exports.number().nonnegative().nullable(),
+  agentIdleTimeoutMs: external_exports.number().nonnegative().nullable()
 });
 var authContextSchema = external_exports.object({
   backendId: external_exports.string().optional(),
@@ -31607,7 +31782,7 @@ var resumeReportSchema = external_exports.discriminatedUnion("strategy", [
   })
 ]);
 var replayOperationalChangeSchema = external_exports.object({
-  option: external_exports.enum(["agentTimeoutMs", "agentRetries", "concurrency"]),
+  option: external_exports.enum(["agentTimeoutMs", "agentIdleTimeoutMs", "agentRetries", "concurrency"]),
   source: external_exports.number().nullable(),
   current: external_exports.number().nullable(),
   detail: external_exports.string()
@@ -31699,6 +31874,7 @@ var runStatusShape = {
       model: external_exports.string().optional(),
       backendId: external_exports.string().optional(),
       timeoutMs: external_exports.number().nonnegative().nullable().optional(),
+      idleTimeoutMs: external_exports.number().nonnegative().nullable().optional(),
       errorCode: external_exports.string().optional(),
       status: external_exports.enum(["queued", "running"]).optional(),
       resultPreview: external_exports.string(),
@@ -31851,6 +32027,19 @@ var discoveryOutputFields = [
   "omittedHarnesses",
   "models"
 ];
+var stopControlSchema = external_exports.object({
+  state: external_exports.literal("pending"),
+  operationId: external_exports.string(),
+  requestedAt: external_exports.string(),
+  owner: external_exports.object({
+    pid: external_exports.number().int().positive(),
+    instanceId: external_exports.string().optional(),
+    version: external_exports.string().optional(),
+    lameDuck: external_exports.boolean().optional(),
+    activeRuns: external_exports.number().int().nonnegative().optional(),
+    controlProtocol: external_exports.literal(1).optional()
+  }).optional()
+});
 var variantOutputFields = [
   ...executionDetailFields,
   "scriptSource",
@@ -31859,6 +32048,7 @@ var variantOutputFields = [
   "outcome",
   "stopped",
   "alreadyTerminal",
+  "control",
   ...discoveryOutputFields
 ];
 var forbidsRequired = (...fields) => ({
@@ -31900,23 +32090,26 @@ var workflowToolOutputShape = external_exports.object({
   wait: waitSchema.optional(),
   outcome: executionResultSchema.optional(),
   stopped: external_exports.boolean().optional(),
-  alreadyTerminal: external_exports.boolean().optional()
+  alreadyTerminal: external_exports.boolean().optional(),
+  control: stopControlSchema.optional()
 }).superRefine((value, context) => {
   const has = (field) => value[field] !== void 0;
   const inspectionComplete = inspectionRequired.every((field) => has(field));
   const runCommonComplete = has("runId") && has("status") && has("scriptUri");
-  const terminal = terminalStatuses.includes(value.status);
+  const terminal2 = terminalStatuses.includes(value.status);
   let valid;
   if (value.action === "config") {
     valid = has("ok") && has("harnessOptions") && has("omittedHarnesses") && has("models") && hasOnlyExactFields(value, ["action", "ok", "harnessOptions", "omittedHarnesses", "models"]);
   } else if (value.action === "run") {
     valid = value.status === "rejected" && has("validation") && hasOnlyExactFields(value, ["action", "status", "validation"]);
   } else if (has("scriptSource")) {
-    valid = runCommonComplete && has("limits") && (value.status === "running" ? hasOnlyFields(value, ["scriptSource"]) : terminal && hasOnlyFields(value, ["scriptSource", ...executionDetailFields]));
+    valid = runCommonComplete && has("limits") && (value.status === "running" ? hasOnlyFields(value, ["scriptSource"]) : terminal2 && hasOnlyFields(value, ["scriptSource", ...executionDetailFields]));
+  } else if (has("control")) {
+    valid = runCommonComplete && inspectionComplete && value.stopped === false && value.alreadyTerminal === false && (value.status === "pending" || value.status === "running") && hasOnlyFields(value, [...inspectionFields, "stopped", "alreadyTerminal", "control"]);
   } else if (has("stopped") || has("alreadyTerminal")) {
     valid = runCommonComplete && inspectionComplete && has("stopped") && has("alreadyTerminal") && (value.status === "completed" || value.status === "failed" || value.status === "aborted") && hasOnlyFields(value, [...inspectionFields, "stopped", "alreadyTerminal"]);
   } else if (has("wait")) {
-    valid = runCommonComplete && inspectionComplete && hasOnlyFields(value, [...inspectionFields, "wait", "tokenUsage", "outcome"]) && (terminal ? has("outcome") : !has("outcome"));
+    valid = runCommonComplete && inspectionComplete && hasOnlyFields(value, [...inspectionFields, "wait", "tokenUsage", "outcome"]) && (terminal2 ? has("outcome") : !has("outcome"));
   } else {
     valid = runCommonComplete && inspectionComplete && hasOnlyFields(value, inspectionFields);
   }
@@ -31940,7 +32133,8 @@ var workflowToolOutputShape = external_exports.object({
         "wait",
         "outcome",
         "stopped",
-        "alreadyTerminal"
+        "alreadyTerminal",
+        "control"
       )
     },
     {
@@ -31960,7 +32154,8 @@ var workflowToolOutputShape = external_exports.object({
         "wait",
         "outcome",
         "stopped",
-        "alreadyTerminal"
+        "alreadyTerminal",
+        "control"
       )
     },
     {
@@ -32000,6 +32195,16 @@ var workflowToolOutputShape = external_exports.object({
       required: [...runOutputRequired, ...inspectionRequired, "stopped", "alreadyTerminal"],
       properties: { status: { enum: ["completed", "failed", "aborted"] } },
       ...forbidsOutside([...inspectionFields, "stopped", "alreadyTerminal"])
+    },
+    {
+      title: "Workflow stop pending",
+      required: [...runOutputRequired, ...inspectionRequired, "stopped", "alreadyTerminal", "control"],
+      properties: {
+        status: { enum: nonterminalStatuses },
+        stopped: { const: false },
+        alreadyTerminal: { const: false }
+      },
+      ...forbidsOutside([...inspectionFields, "stopped", "alreadyTerminal", "control"])
     }
   ]
 });
@@ -32280,9 +32485,9 @@ var AUTHORING_DOC_TOPICS = [
       "workflow/determinism-and-resume",
       "workflow/models-and-config"
     ],
-    "bytes": 6835,
-    "sha256": "85a1d7894a0a36953511810bce9d073c29868bc0e1de89939d912c8f4356fa8f",
-    "text": '## Running workflows \u2014 the MCP `workflow` tool\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\nUse the connected `workflow` tool for deterministic batch orchestration. The shared server daemon owns execution, so admitted runs survive MCP client session churn and tool-request timeouts; only daemon exit can interrupt in-flight work. Any later session can await, inspect, or stop a run. Runs, journals, and logs persist per project namespace.\n\nEvery `config` and `run` call on the shared daemon names its project with the required `projectDir` argument \u2014 an absolute path, normally the workspace root. `inspect`/`await`/`stop` take only a `runId`; the run ID locates its project store automatically. In a single-project server, `projectDir` defaults to that server\'s project.\n\n### The `workflow` tool, by action\n\n- **Config** (`{ action: "config", projectDir, harnesses?, modelSpecs?, modelFilter? }`): discover live model, mode, effort, and `configOptions` values from no-prompt backend sessions. Use `harnesses` plus `modelFilter` to find ids, then `modelSpecs` to select exact models and read their model-specific option domains. Each successful entry reports `modes` explicitly: use only exact ids in `modes.availableModes`; `modes:null` means omit `mode`, never guess a default. It starts no workflow and spends zero tokens. Use it only when pinning those values; an omitted model or backend-only model uses configured defaults without discovery.\n- **Run** (default, no `action`): supply exactly one of `script` (the raw source string, no Markdown fences) or `scriptPath` (an absolute path on the server\'s filesystem), plus `projectDir`. The tool automatically performs static validation, a mocked dry run, and routed config checks before admission. Invalid scripts return bounded `status:"rejected"` diagnostics with no run ID, background slot, or token spend. A path is read once at admission and its content snapshotted; later edits affect only a new run. `args` arrives in the script as the `args` global; the run\'s base directory is the `cwd` global. Some hosts hand `args` through as a JSON **string** \u2014 tolerate both shapes (`typeof args === "string" ? JSON.parse(args) : args`). Foreground streams progress but is bound to the request and its timeout. Pass `background: true` for anything that may outlive one request; it acknowledges after durable admission with a `runId`.\n- **Await** (`{ action: "await", runId, waitMs }`): bounded collection for background runs. A timeout is progress, not failure \u2014 call again (`waitMs: 20000` is typical). At terminal status the response adds `outcome`: the authored result or pause context, plus `replayEligibility`, `resumeReport`, `fallbacks`, and `checkpointsTaken`.\n- **Inspect** (`{ action: "inspect", runId, lastN, labelGlob, logLines }`): a bounded snapshot \u2014 the latest matching calls with compact result previews plus the newest log lines. Use a narrow `labelGlob` to diagnose before deciding whether to resume, edit, or stop. Inspection never executes or resumes a script.\n- **Stop**: `{ action: "stop", runId }` durably aborts the whole run and returns its final snapshot; stopping a terminal run is a successful no-op. `{ action: "stop", runId, callIndex }` cancels exactly that in-flight agent: its slot settles to `null` with `AGENT_CANCELLED` and the run stays live. `labelGlob` only filters the returned snapshot; it never selects what to cancel.\n- **Resume**: a NEW run with `resumeFromRunId` plus the script content re-sent (the same `script` or `scriptPath`) and the desired `args` (+ `checkpointReplies` when answering a durable checkpoint). Read the returned `replayEligibility` for the predicted and observed replay prefix; never assume a prefix hit. Full semantics: **Determinism and resume**.\n\n### Operating rules\n\n- **Always retain the returned `runId`.** A paused, failed, or aborted response carries a redacted final-20 `logTail`. Read it before you change anything. Every admitted script is also an immutable resource at `workflow://runs/{runId}/script`, so a later session can recover a lost inline script.\n- **Two fingerprints control replay.** The identity hash covers the prompt, the resolved model, `mode` when set, non-empty sorted `configOptions`, `tier`, `phase`, `agentType`, the resolved agent definition, and the schema. The input fingerprint covers the resolved label, per-call `cwd` and isolation, `keepSession`, images, MCP servers, session/prompt metadata, and the approved script-backend digest.\n- **Operational bounds are not replay inputs.** Host `concurrency`, `agentRetries`, and `agentTimeoutMs`, plus per-call `timeoutMs` and `retries`, enter neither fingerprint. A resume does not inherit them from its source run; pass the values you want on every run. `agentTimeoutMs` caps the wall-clock time of each attempt; it is not an idle timer. A per-call `timeoutMs` can tighten that ceiling but cannot escape it. Each retry gets a fresh clock, so the envelope is `(resolved retries + 1) \xD7 resolved timeout`, with retries clamped to 3.\n- **Old journals stay usable.** Input formats below 2 replay positionally with `fallbackReason: "inputs-format-legacy"`. A current-format crash snapshot uses identity matching even without terminal-environment capture. Ancestor-scoped rows carried from \u22640.23 resume chains replay only while that ancestor run is still persisted. Journals resume across filesystem, environment, engine, Node, and V8 changes; `replayEligibility` reports those differences as diagnostics, never as gates.\n- **A background start returns immediately.** It sends no progress after it returns; collect progress with later bounded awaits. Background runs have no live checkpoint channel, so authored `headless` checkpoint modes apply. When a run\'s owner process dies, cold preflights reconcile stale `pending`/`running` state to `paused` with `pauseReason: "interrupted"`; a live owner is left alone.\n- A run paused with `reason: "auth_required"` resumes as a new run after that backend\'s credentials are configured.\n\n### Execution logs \u2014 the events resource\n\nEvery journaling run publishes an MCP resource at `workflow://runs/{runId}/events`. Subscribe to the canonical URI for advisory `resources/updated` hints, then read and paginate with `after`, `limit`, and `streamId`. Progress is coarse and redacted: `agentTranscript` rows are assistant/tool upserts partitioned by `(scope, callIndex, executionStartSeq)` and reduced by greatest revision per entry index. The durable cursor is authoritative when hints coalesce or a subscriber falls behind.\n\nEmbedding hosts can drive the same contract with `runDynamicWorkflow` / `WorkflowManager` from `@automatalabs/workflows`; the script contract is identical either way.\n'
+    "bytes": 7983,
+    "sha256": "55bae1f2f722adc7e9fd856f2d673f21ef90805e72473162750ee48dfab83744",
+    "text": '## Running workflows \u2014 the MCP `workflow` tool\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\nUse the connected `workflow` tool for deterministic batch orchestration. The shared server daemon owns execution, so admitted runs survive MCP client session churn and tool-request timeouts. During a version upgrade, the successor becomes the front door while a predecessor may remain the execution owner; signed run-control forwarding keeps later-session stop/cancel operations location-independent. Owner-process exit can still interrupt in-flight work. Any later session can await, inspect, or stop a run. Runs, journals, logs, and outstanding whole-stop intents persist per project namespace.\n\nEvery `config` and `run` call on the shared daemon names its project with the required `projectDir` argument \u2014 an absolute path, normally the workspace root. `inspect`/`await`/`stop` take only a `runId`; the run ID locates its project store automatically. In a single-project server, `projectDir` defaults to that server\'s project.\n\n### The `workflow` tool, by action\n\n- **Config** (`{ action: "config", projectDir, harnesses?, modelSpecs?, modelFilter? }`): discover live model, mode, effort, and `configOptions` values from no-prompt backend sessions. Use `harnesses` plus `modelFilter` to find ids, then `modelSpecs` to select exact models and read their model-specific option domains. Each successful entry reports `modes` explicitly: use only exact ids in `modes.availableModes`; `modes:null` means omit `mode`, never guess a default. It starts no workflow and spends zero tokens. Use it only when pinning those values; an omitted model or backend-only model uses configured defaults without discovery.\n- **Run** (default, no `action`): supply exactly one of `script` (the raw source string, no Markdown fences) or `scriptPath` (an absolute path on the server\'s filesystem), plus `projectDir`. The tool automatically performs static validation, a mocked dry run, and routed config checks before admission. Invalid scripts return bounded `status:"rejected"` diagnostics with no run ID, background slot, or token spend. A path is read once at admission and its content snapshotted; later edits affect only a new run. `args` arrives in the script as the `args` global; the run\'s base directory is the `cwd` global. Some hosts hand `args` through as a JSON **string** \u2014 tolerate both shapes (`typeof args === "string" ? JSON.parse(args) : args`). Foreground streams progress but is bound to the request and its timeout. Pass `background: true` for anything that may outlive one request; it acknowledges after durable admission with a `runId`.\n- **Await** (`{ action: "await", runId, waitMs }`): bounded collection for background runs. A timeout is progress, not failure \u2014 call again (`waitMs: 20000` is typical). At terminal status the response adds `outcome`: the authored result or pause context, plus `replayEligibility`, `resumeReport`, `fallbacks`, and `checkpointsTaken`.\n- **Inspect** (`{ action: "inspect", runId, lastN, labelGlob, logLines }`): a bounded snapshot \u2014 the latest matching calls with compact result previews plus the newest log lines. Use a narrow `labelGlob` to diagnose before deciding whether to resume, edit, or stop. Inspection never executes or resumes a script.\n- **Stop**: `{ action: "stop", runId }` durably aborts the whole run and normally returns its final snapshot; stopping a terminal run is a successful no-op. Across a daemon upgrade, the successor persists an idempotent stop intent and forwards to the predecessor that owns execution. If that owner does not settle within the bounded control wait, the successful response remains nonterminal with `control:{ state:"pending", operationId, requestedAt, owner? }`; retry stop, inspect, or await to observe settlement. `{ action: "stop", runId, callIndex }` synchronously routes to the live owner and cancels exactly that in-flight agent: its slot settles to `null` with `AGENT_CANCELLED` and the run stays live; call cancellation is never reconstructed after owner loss. Whole-run `{ action:"stop", runId, forceOwner:true }` explicitly authorizes terminating a superseded owner daemon when graceful control cannot settle and may interrupt sibling runs in that process; it is forbidden with `callIndex`. `labelGlob` only filters the returned snapshot; it never selects what to cancel.\n- **Resume**: a NEW run with `resumeFromRunId` plus the script content re-sent (the same `script` or `scriptPath`) and the desired `args` (+ `checkpointReplies` when answering a durable checkpoint). Read the returned `replayEligibility` for the predicted and observed replay prefix; never assume a prefix hit. Full semantics: **Determinism and resume**.\n\n### Operating rules\n\n- **Always retain the returned `runId`.** A paused, failed, or aborted response carries a redacted final-20 `logTail`. Read it before you change anything. Every admitted script is also an immutable resource at `workflow://runs/{runId}/script`, so a later session can recover a lost inline script.\n- **Two fingerprints control replay.** The identity hash covers the prompt, the resolved model, `mode` when set, non-empty sorted `configOptions`, `tier`, `phase`, `agentType`, the resolved agent definition, and the schema. The input fingerprint covers the resolved label, per-call `cwd` and isolation, `keepSession`, images, MCP servers, session/prompt metadata, and the approved script-backend digest.\n- **Operational bounds are not replay inputs.** Host `concurrency`, `agentRetries`, `agentTimeoutMs`, and `agentIdleTimeoutMs`, plus per-call `timeoutMs`, `idleTimeoutMs`, and `retries`, enter neither fingerprint. A resume does not inherit them from its source run; pass the values you want on every run. `agentTimeoutMs` caps total wall time and is not an idle timer. The separate opt-in `agentIdleTimeoutMs` fires after that long without real backend activity; ACP `session/update` re-arms it and synthetic progress heartbeats do not. Per-call values can tighten but cannot escape finite host ceilings. Every retry gets fresh clocks.\n- **Old journals stay usable.** Input formats below 2 replay positionally with `fallbackReason: "inputs-format-legacy"`. A current-format crash snapshot uses identity matching even without terminal-environment capture. Ancestor-scoped rows carried from \u22640.23 resume chains replay only while that ancestor run is still persisted. Journals resume across filesystem, environment, engine, Node, and V8 changes; `replayEligibility` reports those differences as diagnostics, never as gates.\n- **A background start returns immediately.** It sends no progress after it returns; collect progress with later bounded awaits. Background runs have no live checkpoint channel, so authored `headless` checkpoint modes apply. When a run\'s owner process dies, a pending whole-stop intent is applied under the reclaimed lease; otherwise cold preflights reconcile stale `pending`/`running` state to `paused` with `pauseReason:"interrupted"`. A live owner lease is never stolen because of a timeout.\n- A run paused with `reason: "auth_required"` resumes as a new run after that backend\'s credentials are configured.\n\n### Execution logs \u2014 the events resource\n\nEvery journaling run publishes an MCP resource at `workflow://runs/{runId}/events`. Subscribe to the canonical URI for advisory `resources/updated` hints, then read and paginate with `after`, `limit`, and `streamId`. Progress is coarse and redacted: `agentTranscript` rows are assistant/tool upserts partitioned by `(scope, callIndex, executionStartSeq)` and reduced by greatest revision per entry index. The durable cursor is authoritative when hints coalesce or a subscriber falls behind.\n\nEmbedding hosts can drive the same contract with `runDynamicWorkflow` / `WorkflowManager` from `@automatalabs/workflows`; the script contract is identical either way.\n'
   },
   {
     "id": "workflow/models-and-config",
@@ -32310,9 +32515,9 @@ var AUTHORING_DOC_TOPICS = [
       "workflow/api-control-flow",
       "workflow/checkpoints-and-quality"
     ],
-    "bytes": 6402,
-    "sha256": "630e7b4ced855ae4c592c87a38d35b6c77b6f2df288d0a9007659a3901447bad",
-    "text": '## The `meta` header\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\nEvery script must **begin** with `export const meta = {...}` as a plain object literal (no computed values \u2014 it is parsed from the source text before anything runs):\n\n```js\nexport const meta = {\n  name: "fix-flaky-tests",                        // required\n  description: "Find flaky tests and fix them",   // required\n  phases: [                                        // optional; one { title, detail?, model? } entry\n    { title: "Find", model: "opencode/zai/glm-5.2" },  // per phase() call, matched by exact title;\n    { title: "Fix" },                                  // a phase model is that phase\'s default\n  ],\n  model: "claude/sonnet",                          // optional run-wide default model\n  backends: { /* optional custom ACP agents \u2014 see "Custom ACP backends" */ },\n};\n```\n\nPer-agent model resolution order: explicit `agent({ model })` > `agent({ tier })` > the current phase\'s `model` > `meta.model` > the host session\'s default. So `meta.phases[].model` gives a whole phase a backend without repeating it on every call.\n\n## Fan-out: `parallel` and `pipeline`\n\n```js\n// parallel: an array of THUNKS (not promises!) run concurrently \u2014 a barrier that\n// resolves in input order. A failed slot resolves to null; filter before use.\nconst sweeps = (await parallel([\n  () => agent("Audit error handling in src/server", { label: "sweep:errors", schema: FINDINGS }),\n  () => agent("Audit input validation in src/api",  { label: "sweep:input",  schema: FINDINGS }),\n])).filter(Boolean);\n\n// pipeline: each item flows through the stages independently \u2014 NO barrier between\n// stages, so item A can be in stage 2 while item B is still in stage 1.\n// Stages receive (previousResult, originalItem, index).\nconst verified = (await pipeline(\n  sweeps.flatMap((s) => s.findings),\n  (f) => agent(`Adversarially verify this finding \u2014 try to refute it:\\n${JSON.stringify(f)}`,\n               { label: `verify:${f.file}`, schema: VERDICT }),\n  (verdict, f) => ({ ...f, real: verdict.real }),\n)).filter(Boolean).filter((f) => f.real);\n```\n\n**Default to `pipeline`** for multi-stage work. Add a `parallel` barrier only when the next stage needs *all* prior results at once: dedup across the full set, early-exit on a zero count, or prompts that compare "the other findings". The test is the **information dependency** \u2014 a barrier\'s cost is real, because the fastest worker idles for the slowest. All coordination lives in script code: agents cannot see each other, so never ask an agent to "check with the other reviewers" or "spawn helpers". Passing a promise instead of a thunk to `parallel` is a `TypeError` \u2014 wrap every call: `() => agent(...)`.\n\nFan-out also contends for the **working tree**, not just the concurrency limiter. Two agents running builds or test suites in the same checkout collide on build outputs, caches, and lockfiles, and concurrent `git fetch`es contend on the same `.git`. Give run-things agents `isolation: "worktree"` when the commits they must inspect are reachable from the run cwd\'s repository, or serialize them; fan out freely only the agents that just read.\n\nThe host caps concurrent agents per run (default 8); hand `parallel`/`pipeline` as many items as the task needs and let the limiter schedule them. The cap counts active agent attempts, not authored branches: queued branches begin as other attempts finish, and a branch that exhausts its timeout settles to `null` and frees its slot. `workflow(nameOrScript, args)` nests another workflow inline (one level deep, sharing this run\'s limiter) \u2014 inline script strings always work; saved names resolve when the host serves a workflows folder.\n\n## Failure semantics \u2014 design for `null`\n\n- A **recoverable** failure (timeout, empty output, transient execution error) is retried per the call\'s `retries` (default 0), then the call **resolves to `null`** \u2014 inside `parallel`/`pipeline` *and* as a bare `await agent(...)`. Null-check anything load-bearing, and set `retries: 1\u20132` on steps you can\'t afford to lose.\n- A host can settle one runaway in-flight call with MCP `{ action: "stop", runId, callIndex }` or SDK `manager.cancelAgentCall(runId, callIndex)`. The call resolves to `null` with `AGENT_CANCELLED`, skips every configured retry, and does not abort the run or its siblings. Its failed call record is not cached as a journal result, so a later resume runs that occurrence live.\n- A **non-recoverable** failure (schema never validated, script bug) throws and fails the run. You *may* `try/catch` around an `agent()` call to degrade gracefully \u2014 rethrow anything you can\'t meaningfully handle. In particular, **always rethrow pause-class errors** (`err.code === "PROVIDER_USAGE_LIMIT"` or `"AUTH_REQUIRED"`): they must propagate out of the script so the engine can pause the run resumably \u2014 swallowing one converts that pause into a fake, lossy completion.\n- A **provider quota wall, missing backend authentication, or opted-in durable checkpoint pauses a managed run instead of failing it** \u2014 the journal checkpoints and the host can resume after the provider quota refills, authentication completes, or a checkpoint decision is supplied. Direct `runner.run()` calls still receive the `AUTH_REQUIRED` error because they have no manager lifecycle.\n- Per-call knobs: `timeoutMs` and `retries`. A finite `timeoutMs` may shorten the host\'s run-level `agentTimeoutMs` ceiling; `null` or omission is uncapped only when the host supplied no ceiling. The timeout is total wall-clock time per attempt, and every retry gets a fresh clock.\n\n## Phases\n\n```js\nphase("Explore");   // open a named phase: subsequent agents group under it\n\nconst found = [];\nwhile (found.length < 20) {\n  const r = await agent("Find one more edge case not in: " + JSON.stringify(found.map((f) => f.name)),\n                        { label: `edge:${found.length}`, schema: EDGE });\n  if (!r) break;\n  found.push(r);\n}\n```\n\nTerminate every loop on a bound the script controls. The agent-count limit (`maxAgents`) is hard: once exhausted, further `agent()` calls throw `AGENT_LIMIT_EXCEEDED`. `phase()` groups agents in progress UIs and run logs; `log(msg)` (and `console.log`) append to the run log \u2014 narrate what matters, especially anything you drop.\n'
+    "bytes": 6494,
+    "sha256": "08569d83a9662ca094c3324a3fc737e4670876948ba863f04b01cca566afc2c0",
+    "text": '## The `meta` header\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\nEvery script must **begin** with `export const meta = {...}` as a plain object literal (no computed values \u2014 it is parsed from the source text before anything runs):\n\n```js\nexport const meta = {\n  name: "fix-flaky-tests",                        // required\n  description: "Find flaky tests and fix them",   // required\n  phases: [                                        // optional; one { title, detail?, model? } entry\n    { title: "Find", model: "opencode/zai/glm-5.2" },  // per phase() call, matched by exact title;\n    { title: "Fix" },                                  // a phase model is that phase\'s default\n  ],\n  model: "claude/sonnet",                          // optional run-wide default model\n  backends: { /* optional custom ACP agents \u2014 see "Custom ACP backends" */ },\n};\n```\n\nPer-agent model resolution order: explicit `agent({ model })` > `agent({ tier })` > the current phase\'s `model` > `meta.model` > the host session\'s default. So `meta.phases[].model` gives a whole phase a backend without repeating it on every call.\n\n## Fan-out: `parallel` and `pipeline`\n\n```js\n// parallel: an array of THUNKS (not promises!) run concurrently \u2014 a barrier that\n// resolves in input order. A failed slot resolves to null; filter before use.\nconst sweeps = (await parallel([\n  () => agent("Audit error handling in src/server", { label: "sweep:errors", schema: FINDINGS }),\n  () => agent("Audit input validation in src/api",  { label: "sweep:input",  schema: FINDINGS }),\n])).filter(Boolean);\n\n// pipeline: each item flows through the stages independently \u2014 NO barrier between\n// stages, so item A can be in stage 2 while item B is still in stage 1.\n// Stages receive (previousResult, originalItem, index).\nconst verified = (await pipeline(\n  sweeps.flatMap((s) => s.findings),\n  (f) => agent(`Adversarially verify this finding \u2014 try to refute it:\\n${JSON.stringify(f)}`,\n               { label: `verify:${f.file}`, schema: VERDICT }),\n  (verdict, f) => ({ ...f, real: verdict.real }),\n)).filter(Boolean).filter((f) => f.real);\n```\n\n**Default to `pipeline`** for multi-stage work. Add a `parallel` barrier only when the next stage needs *all* prior results at once: dedup across the full set, early-exit on a zero count, or prompts that compare "the other findings". The test is the **information dependency** \u2014 a barrier\'s cost is real, because the fastest worker idles for the slowest. All coordination lives in script code: agents cannot see each other, so never ask an agent to "check with the other reviewers" or "spawn helpers". Passing a promise instead of a thunk to `parallel` is a `TypeError` \u2014 wrap every call: `() => agent(...)`.\n\nFan-out also contends for the **working tree**, not just the concurrency limiter. Two agents running builds or test suites in the same checkout collide on build outputs, caches, and lockfiles, and concurrent `git fetch`es contend on the same `.git`. Give run-things agents `isolation: "worktree"` when the commits they must inspect are reachable from the run cwd\'s repository, or serialize them; fan out freely only the agents that just read.\n\nThe host caps concurrent agents per run (default 8); hand `parallel`/`pipeline` as many items as the task needs and let the limiter schedule them. The cap counts active agent attempts, not authored branches: queued branches begin as other attempts finish, and a branch that exhausts its timeout settles to `null` and frees its slot. `workflow(nameOrScript, args)` nests another workflow inline (one level deep, sharing this run\'s limiter) \u2014 inline script strings always work; saved names resolve when the host serves a workflows folder.\n\n## Failure semantics \u2014 design for `null`\n\n- A **recoverable** failure (timeout, empty output, transient execution error) is retried per the call\'s `retries` (default 0), then the call **resolves to `null`** \u2014 inside `parallel`/`pipeline` *and* as a bare `await agent(...)`. Null-check anything load-bearing, and set `retries: 1\u20132` on steps you can\'t afford to lose.\n- A host can settle one runaway in-flight call with MCP `{ action: "stop", runId, callIndex }` or SDK `manager.cancelAgentCall(runId, callIndex)`. The call resolves to `null` with `AGENT_CANCELLED`, skips every configured retry, and does not abort the run or its siblings. Its failed call record is not cached as a journal result, so a later resume runs that occurrence live.\n- A **non-recoverable** failure (schema never validated, script bug) throws and fails the run. You *may* `try/catch` around an `agent()` call to degrade gracefully \u2014 rethrow anything you can\'t meaningfully handle. In particular, **always rethrow pause-class errors** (`err.code === "PROVIDER_USAGE_LIMIT"` or `"AUTH_REQUIRED"`): they must propagate out of the script so the engine can pause the run resumably \u2014 swallowing one converts that pause into a fake, lossy completion.\n- A **provider quota wall, missing backend authentication, or opted-in durable checkpoint pauses a managed run instead of failing it** \u2014 the journal checkpoints and the host can resume after the provider quota refills, authentication completes, or a checkpoint decision is supplied. Direct `runner.run()` calls still receive the `AUTH_REQUIRED` error because they have no manager lifecycle.\n- Per-call knobs: `timeoutMs`, `idleTimeoutMs`, and `retries`. `timeoutMs` is total wall-clock time; `idleTimeoutMs` is opt-in no-backend-activity detection. Each may shorten but cannot bypass its finite host `agentTimeoutMs` / `agentIdleTimeoutMs` ceiling. Real ACP `session/update` traffic resets idle; synthetic progress heartbeats do not. Every retry gets fresh clocks.\n\n## Phases\n\n```js\nphase("Explore");   // open a named phase: subsequent agents group under it\n\nconst found = [];\nwhile (found.length < 20) {\n  const r = await agent("Find one more edge case not in: " + JSON.stringify(found.map((f) => f.name)),\n                        { label: `edge:${found.length}`, schema: EDGE });\n  if (!r) break;\n  found.push(r);\n}\n```\n\nTerminate every loop on a bound the script controls. The agent-count limit (`maxAgents`) is hard: once exhausted, further `agent()` calls throw `AGENT_LIMIT_EXCEEDED`. `phase()` groups agents in progress UIs and run logs; `log(msg)` (and `console.log`) append to the run log \u2014 narrate what matters, especially anything you drop.\n'
   },
   {
     "id": "workflow/checkpoints-and-quality",
@@ -32355,9 +32560,9 @@ var AUTHORING_DOC_TOPICS = [
       "workflow/api-resume-and-backends",
       "workflow/examples"
     ],
-    "bytes": 9234,
-    "sha256": "78708c97d4da00a1a17831fbc325456bf62556f9abf2e79745f3ac4df1eb0883",
-    "text": '## Determinism and resume\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\nRuns are journaled: every `agent()` and `checkpoint()` result is recorded under a deterministic call index. A new run may reuse eligible results from a terminal source run. Uncertainty always means live execution.\n\n> **Resume rule:** replay is content-addressed and fail-to-live on correspondence: a completed call replays when its identity and input fingerprint match uniquely. Filesystem or world state never gates replay.\n\n- Direct `Date.now()`, `Math.random()`, and no-arg `new Date()` / `Date()` calls fail static validation. The realm also blocks aliased or computed forms at runtime; `new Date(isoString)` is fine. Pass timestamps and random seeds through `args`.\n- The replay identity of an `agent()` call hashes: the prompt, the resolved `model`, `mode` when set, `configOptions` when non-empty (sorted keys), `tier`, `phase`, `agentType`, the resolved agent definition, and `schema`. The resolved agent definition includes its tool allowlist and denylist, model, isolation, and body prompt \u2014 editing a definition invalidates the calls that use it.\n- A separate input fingerprint hashes: the resolved label, per-call `cwd`, resolved isolation, `keepSession`, `images`, `mcpServers`, `meta`, `promptMeta`, and the approved script-backend digest.\n- Host `agentTimeoutMs`, `agentRetries`, and `concurrency`, plus per-call `timeoutMs` and `retries`, are operational bounds. They enter neither hash and may change freely on resume. A new run resolves them from its own request; it does not inherit the source values.\n- `args` is not hashed directly. New args that only raise a loop cap leave earlier identities unchanged, so those calls can replay. New args that change a prompt, model selection, phase, schema, call order, or runner-visible input make the affected calls run live. Unchanged independent calls may still replay.\n- Matching tries a unique exact `(kind, call path, identity hash)` row first (`"path-hash"`), then a unique `(kind, identity hash, input fingerprint)` row, so an unchanged call can replay as `"unique-hash"` after insertions or deletions. Source and current input fingerprints must be equal. Duplicate identities, duplicate content, consumed candidates, missing facts, and empty schema-less results run live. The engine never guesses by source order or occurrence.\n- Source admission requires: exact `cwd`, compatible call-path/input/checkpoint fingerprint formats, complete call/journal/allocation metadata, and a valid manifest and seed. Git HEAD and dirty digest, `environmentKey`, captured environment values, Node/V8, and producing engine version are diagnostics only. Environment differences may appear in `replayEligibility.provenanceChanges`; they never gate admission or matching.\n- A completed writer replays exactly like a reader. A live call, nested workflow, host checkpoint callback, or degraded worktree does not clear unrelated candidates. Nested child calls run live \u2014 they are outside the parent\'s journal \u2014 while matching root calls around them still replay. The engine does not reproduce file writes; a later live agent navigates the world it finds.\n- Replay costs zero current provider usage: a cached call returns its recorded result without spawning a session. Replayed session records keep their backend and session identity, rebound to the current call index, label, and phase.\n- A root call interrupted by `PROVIDER_USAGE_LIMIT` or `AUTH_REQUIRED` can continue its recorded session on either resume API. Continuation requires: the exact call index, identity hash, complete input fingerprint, non-worktree isolation, identical existing cwd, a coherent recorded session, and the runner\'s current backend/`poolKey`/reopen gates. A successful continuation finishes the unfinished turn and charges only its usage delta. Every failed gate runs fresh, and `fallbacks` records the reopen method or the exact skip reason. No script option controls this.\n- Completed checkpoint results replay when the identity and the `default`/`headless`/`timeoutMs` fingerprint match \u2014 headless results included. `checkpointReplies` keys always name the checkpoint index in the source run. A moved reply can follow intact prior correspondence; after a live divergence it must reach the exact recorded call site, so a different same-text branch cannot consume it.\n- `resumePolicy: "positional"` is a migration escape hatch for index/prefix matching. It cannot bypass format, metadata, manifest, cwd, or input checks. Marker-less, manual, and same-ID legacy journals keep historical hash-only positional behavior. Input formats below 2 use the `inputs-format-legacy` positional bridge and are rewritten under the current format on the next hop. A current-format crash snapshot with a valid identity manifest uses identity matching even without terminal-environment capture.\n- `label`, `cwd`, `mcpServers`, `images`, `meta`, `promptMeta`, and `keepSession` are not identity-hashed: changing one does not invalidate an ordinary replay. They are in the input fingerprint: changing one rejects continuation of an interrupted turn, and that occurrence runs fresh. To force a completed call to run again, change a hashed field \u2014 normally the prompt.\n- Keep call order deterministic. Derive iteration from `args` and prior agent results, never from ambient state.\n\nEvery `resumeFromRunId` result has a bounded `replayEligibility` summary. Background admission, foreground completion, both await shapes, and inspect expose the same fields: strategy, predicted replayable-prefix length, observed replayed prefix and counts, and the first non-replay when known. Active correspondence reasons include `strategy-live`, `positional-miss`, `positional-suffix`, `not-recorded`, `path-missing`, `inputs-missing`, `inputs-changed`, `ambiguous-identity`, `ambiguous-content`, `candidate-consumed`, `empty-output`, `worktree-degraded`, `seed-persistence-error`, and `resume-fatal-latch`. Older reason literals stay exported only so historical journals parse. Engine and input-format versions and environment provenance ride along as diagnostics.\n\nAn all-live outcome means correspondence could not be established \u2014 not that the world changed. Missing resume metadata, incompatible format literals, or an invalid manifest or seed disable new-format replay. If any source row lacks a captured path or input fact (possible past the raw-frame cap, or with a non-strict-JSON `meta` value), the whole source is `"manifest-invalid"`: dropping the row could make an ambiguous sibling look unique.\n\n### Worked resume \u2014 raise a loop cap\n\nThe following workflow requires eight reviews but lets the caller cap how many are attempted in one run:\n\n```js\nexport const meta = {\n  name: "resume-loop-cap",\n  description: "Run expensive review rounds up to an args-controlled cap",\n  phases: [{ title: "Review" }],\n};\n\nconst input = args && typeof args === "object" && !Array.isArray(args) ? args : {};\nconst numericCap = Number(input.maxRounds);\nconst maxRounds = Number.isInteger(numericCap) && numericCap > 0 ? numericCap : 8;\n\nphase("Review");\nconst rounds = [];\nfor (let i = 0; i < maxRounds; i += 1) {\n  rounds.push(\n    await agent(\n      `Review round ${i + 1}: inspect the repository and report unresolved release blockers.`,\n      { label: `review:${i + 1}`, phase: "Review" },\n    ),\n  );\n}\n\nif (maxRounds < 8) throw new Error(`review cap ${maxRounds} reached before 8 rounds`);\nreturn { rounds };\n```\n\nRun it with `args: { "maxRounds": 6 }`. Then send the same content (via `script`, or the absolute `scriptPath` you edit) with `args: { "maxRounds": 8 }` and the first result\'s `runId` as `resumeFromRunId`. Rounds 1\u20136 replay for zero current provider tokens; only rounds 7\u20138 run live, because the cap controls call count but is not interpolated into the round prompt. If every round prompt included `maxRounds`, all eight identities would change and all would run live. Resume always states its content; a bare `resumeFromRunId` never silently reuses the old script.\n\nGive repeated calls stable, descriptive labels and narrate decisions with `log()` \u2014 inspection by `labelGlob` then turns a pause or failure into a diagnosis instead of a guess.\n\n### Kill, patch, resume\n\nStop the live run with `{ action: "stop", runId }`. The returned `aborted` snapshot is the durable acknowledgement: resume is safe immediately, and a further await adds nothing. Edit the file. Start a new run with its absolute `scriptPath` and `resumeFromRunId`. Every completed call whose recorded identity and input fingerprint correspond replays, regardless of filesystem or environment drift. Read `replayEligibility` and the full `resumeReport` for the per-call decisions. A repeated stop of a terminal run is a successful no-op.\n\nRegistration, the per-action contracts, background collection, and the events resource are covered in **Running workflows** ([mcp-server-setup.md](mcp-server-setup.md)). Resume a durable checkpoint pause by re-sending the script with `resumeFromRunId` and `checkpointReplies` keyed by the source run\'s `checkpointContext.callIndex`.\n'
+    "bytes": 9274,
+    "sha256": "e62a5afd106e73ce1e7edd675573fb920fe09711173d7b23f1a04fd883f59ba2",
+    "text": '## Determinism and resume\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\nRuns are journaled: every `agent()` and `checkpoint()` result is recorded under a deterministic call index. A new run may reuse eligible results from a terminal source run. Uncertainty always means live execution.\n\n> **Resume rule:** replay is content-addressed and fail-to-live on correspondence: a completed call replays when its identity and input fingerprint match uniquely. Filesystem or world state never gates replay.\n\n- Direct `Date.now()`, `Math.random()`, and no-arg `new Date()` / `Date()` calls fail static validation. The realm also blocks aliased or computed forms at runtime; `new Date(isoString)` is fine. Pass timestamps and random seeds through `args`.\n- The replay identity of an `agent()` call hashes: the prompt, the resolved `model`, `mode` when set, `configOptions` when non-empty (sorted keys), `tier`, `phase`, `agentType`, the resolved agent definition, and `schema`. The resolved agent definition includes its tool allowlist and denylist, model, isolation, and body prompt \u2014 editing a definition invalidates the calls that use it.\n- A separate input fingerprint hashes: the resolved label, per-call `cwd`, resolved isolation, `keepSession`, `images`, `mcpServers`, `meta`, `promptMeta`, and the approved script-backend digest.\n- Host `agentTimeoutMs`, `agentIdleTimeoutMs`, `agentRetries`, and `concurrency`, plus per-call `timeoutMs`, `idleTimeoutMs`, and `retries`, are operational bounds. They enter neither hash and may change freely on resume. A new run resolves them from its own request; it does not inherit the source values.\n- `args` is not hashed directly. New args that only raise a loop cap leave earlier identities unchanged, so those calls can replay. New args that change a prompt, model selection, phase, schema, call order, or runner-visible input make the affected calls run live. Unchanged independent calls may still replay.\n- Matching tries a unique exact `(kind, call path, identity hash)` row first (`"path-hash"`), then a unique `(kind, identity hash, input fingerprint)` row, so an unchanged call can replay as `"unique-hash"` after insertions or deletions. Source and current input fingerprints must be equal. Duplicate identities, duplicate content, consumed candidates, missing facts, and empty schema-less results run live. The engine never guesses by source order or occurrence.\n- Source admission requires: exact `cwd`, compatible call-path/input/checkpoint fingerprint formats, complete call/journal/allocation metadata, and a valid manifest and seed. Git HEAD and dirty digest, `environmentKey`, captured environment values, Node/V8, and producing engine version are diagnostics only. Environment differences may appear in `replayEligibility.provenanceChanges`; they never gate admission or matching.\n- A completed writer replays exactly like a reader. A live call, nested workflow, host checkpoint callback, or degraded worktree does not clear unrelated candidates. Nested child calls run live \u2014 they are outside the parent\'s journal \u2014 while matching root calls around them still replay. The engine does not reproduce file writes; a later live agent navigates the world it finds.\n- Replay costs zero current provider usage: a cached call returns its recorded result without spawning a session. Replayed session records keep their backend and session identity, rebound to the current call index, label, and phase.\n- A root call interrupted by `PROVIDER_USAGE_LIMIT` or `AUTH_REQUIRED` can continue its recorded session on either resume API. Continuation requires: the exact call index, identity hash, complete input fingerprint, non-worktree isolation, identical existing cwd, a coherent recorded session, and the runner\'s current backend/`poolKey`/reopen gates. A successful continuation finishes the unfinished turn and charges only its usage delta. Every failed gate runs fresh, and `fallbacks` records the reopen method or the exact skip reason. No script option controls this.\n- Completed checkpoint results replay when the identity and the `default`/`headless`/`timeoutMs` fingerprint match \u2014 headless results included. `checkpointReplies` keys always name the checkpoint index in the source run. A moved reply can follow intact prior correspondence; after a live divergence it must reach the exact recorded call site, so a different same-text branch cannot consume it.\n- `resumePolicy: "positional"` is a migration escape hatch for index/prefix matching. It cannot bypass format, metadata, manifest, cwd, or input checks. Marker-less, manual, and same-ID legacy journals keep historical hash-only positional behavior. Input formats below 2 use the `inputs-format-legacy` positional bridge and are rewritten under the current format on the next hop. A current-format crash snapshot with a valid identity manifest uses identity matching even without terminal-environment capture.\n- `label`, `cwd`, `mcpServers`, `images`, `meta`, `promptMeta`, and `keepSession` are not identity-hashed: changing one does not invalidate an ordinary replay. They are in the input fingerprint: changing one rejects continuation of an interrupted turn, and that occurrence runs fresh. To force a completed call to run again, change a hashed field \u2014 normally the prompt.\n- Keep call order deterministic. Derive iteration from `args` and prior agent results, never from ambient state.\n\nEvery `resumeFromRunId` result has a bounded `replayEligibility` summary. Background admission, foreground completion, both await shapes, and inspect expose the same fields: strategy, predicted replayable-prefix length, observed replayed prefix and counts, and the first non-replay when known. Active correspondence reasons include `strategy-live`, `positional-miss`, `positional-suffix`, `not-recorded`, `path-missing`, `inputs-missing`, `inputs-changed`, `ambiguous-identity`, `ambiguous-content`, `candidate-consumed`, `empty-output`, `worktree-degraded`, `seed-persistence-error`, and `resume-fatal-latch`. Older reason literals stay exported only so historical journals parse. Engine and input-format versions and environment provenance ride along as diagnostics.\n\nAn all-live outcome means correspondence could not be established \u2014 not that the world changed. Missing resume metadata, incompatible format literals, or an invalid manifest or seed disable new-format replay. If any source row lacks a captured path or input fact (possible past the raw-frame cap, or with a non-strict-JSON `meta` value), the whole source is `"manifest-invalid"`: dropping the row could make an ambiguous sibling look unique.\n\n### Worked resume \u2014 raise a loop cap\n\nThe following workflow requires eight reviews but lets the caller cap how many are attempted in one run:\n\n```js\nexport const meta = {\n  name: "resume-loop-cap",\n  description: "Run expensive review rounds up to an args-controlled cap",\n  phases: [{ title: "Review" }],\n};\n\nconst input = args && typeof args === "object" && !Array.isArray(args) ? args : {};\nconst numericCap = Number(input.maxRounds);\nconst maxRounds = Number.isInteger(numericCap) && numericCap > 0 ? numericCap : 8;\n\nphase("Review");\nconst rounds = [];\nfor (let i = 0; i < maxRounds; i += 1) {\n  rounds.push(\n    await agent(\n      `Review round ${i + 1}: inspect the repository and report unresolved release blockers.`,\n      { label: `review:${i + 1}`, phase: "Review" },\n    ),\n  );\n}\n\nif (maxRounds < 8) throw new Error(`review cap ${maxRounds} reached before 8 rounds`);\nreturn { rounds };\n```\n\nRun it with `args: { "maxRounds": 6 }`. Then send the same content (via `script`, or the absolute `scriptPath` you edit) with `args: { "maxRounds": 8 }` and the first result\'s `runId` as `resumeFromRunId`. Rounds 1\u20136 replay for zero current provider tokens; only rounds 7\u20138 run live, because the cap controls call count but is not interpolated into the round prompt. If every round prompt included `maxRounds`, all eight identities would change and all would run live. Resume always states its content; a bare `resumeFromRunId` never silently reuses the old script.\n\nGive repeated calls stable, descriptive labels and narrate decisions with `log()` \u2014 inspection by `labelGlob` then turns a pause or failure into a diagnosis instead of a guess.\n\n### Kill, patch, resume\n\nStop the live run with `{ action: "stop", runId }`. The returned `aborted` snapshot is the durable acknowledgement: resume is safe immediately, and a further await adds nothing. Edit the file. Start a new run with its absolute `scriptPath` and `resumeFromRunId`. Every completed call whose recorded identity and input fingerprint correspond replays, regardless of filesystem or environment drift. Read `replayEligibility` and the full `resumeReport` for the per-call decisions. A repeated stop of a terminal run is a successful no-op.\n\nRegistration, the per-action contracts, background collection, and the events resource are covered in **Running workflows** ([mcp-server-setup.md](mcp-server-setup.md)). Resume a durable checkpoint pause by re-sending the script with `resumeFromRunId` and `checkpointReplies` keyed by the source run\'s `checkpointContext.callIndex`.\n'
   },
   {
     "id": "workflow/api-agents",
@@ -32370,9 +32575,9 @@ var AUTHORING_DOC_TOPICS = [
       "workflow/environment-and-tools",
       "workflow/api-control-flow"
     ],
-    "bytes": 8551,
-    "sha256": "84d2cb5639a385074b815fa8e13214138d1d59fa3f7fd34f206e4f9ce19d37d0",
-    "text": '# Workflow agent API reference\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\n## `agent(prompt, options?)` \u2014 full option table\n\nReturns the agent\'s final assistant text, or the schema-validated object when `schema` is set. Resolves to `null` when a *recoverable* failure survives all retries.\n\n| option | type | meaning |\n|---|---|---|\n| `label` | `string` | Display/telemetry name; also stamped on every live ACP event for this call. Always set it. Not part of the resume hash. |\n| `phase` | `string` | Assign this call to a phase explicitly (needed inside concurrent stages where the global `phase()` state would race). |\n| `schema` | JSON Schema object | Structured output. Plain object literal only \u2014 no schema builders exist in the realm. Part of the resume hash. |\n| `model` | `string` | Model spec: optional registered harness prefix plus a verbatim id, or a backend-only name. See [Model specs & routing](#model-specs--routing). Part of the resume hash. |\n| `tier` | `"small" \\| "medium" \\| "big"` | Coarse tier resolved from host config; beats phase/meta model, loses to explicit `model`. Part of the resume hash. |\n| `mode` | `string` | ACP session mode id advertised by the selected backend/model. **Strict**: unsupported/unadvertised ids fail before prompting (and automatic workflow preflight rejects them before admission). Read the selected `action:"config"` entry\'s `modes.availableModes` and copy only an exact id; `modes:null` means omit this field. Never infer a generic `"default"`. Part of the resume hash when set. |\n| `configOptions` | `Record<string, string \\| boolean>` | Exact ACP session option ids and authored values. Applied in ascending id order after model and before the prompt, with no aliases or coercion. `"model"` is reserved for the dedicated `model` field. Part of the resume hash only when non-empty, with sorted keys. With MCP, read the advertised-options table from `workflow` action `config` before choosing values. |\n| `agentType` | `string` | Bind a named subagent definition (tools allow/deny, model, isolation, role prompt). See [agentType definitions](#agenttype-definitions). Part of the resume hash. |\n| `isolation` | `"worktree"` | Run in a throwaway git worktree branched from the run cwd. **Always removed (worktree + branch) when the call ends** \u2014 edits are discarded; return work as data. Degrades to the shared tree outside a git repo (logged). |\n| `resume` | `{ filesystem: "read-only" }` | Deprecated compatibility annotation. It is recorded as legacy diagnostic provenance, is not sent to the runner or hashed, and has no effect on replay. New scripts should omit it. |\n| `cwd` | `string` | Per-session working directory; relative resolves against the run\'s base cwd. Overridden by worktree isolation. Not hashed. |\n| `timeoutMs` | `number \\| null` | Total wall-clock cap for each attempt. A finite value may tighten a finite host `agentTimeoutMs` ceiling but cannot raise or disable it. With no host ceiling, a finite value applies and `null`/omitted is uncapped. |\n| `retries` | `number` | Retries after *recoverable* failures (default 0, host-overridable). Exhausted retries \u21D2 the call resolves `null`. |\n| `mcpServers` | `McpServerConfig[]` | MCP servers attached to this session. Stdio shape: `{ name, command, args: [], env: [{ name, value }] }` (`args`/`env` required, `env` is name/value pairs, not a map); `{ type: "http" \\| "sse", name, url, headers: [] }` also accepted. Not hashed. |\n| `images` | `PromptImage[]` | Base64 image blocks appended to the prompt; backends without image support get a bracketed text note. Not hashed. |\n| `meta` | `object` | ACP `_meta` merged into `session/new` \u2014 session-scoped extension passthrough (pairs with custom backends). Not hashed. |\n| `promptMeta` | `object` | ACP `_meta` merged into `session/prompt` \u2014 turn-scoped passthrough. Backend-computed keys win on conflict. Not hashed. |\n| `keepSession` | `boolean` | Skip release-time best-effort `session/close`; the non-secret re-attach record lands in `WorkflowRunResult.agentSessions` for host-side `loadSession()` / `resumeSession()`. Usage/auth pause failures are kept open automatically for managed continuation. Not identity-hashed; included in the input fingerprint. |\n\nThe timeout clock measures the whole attempt, including backend startup, model/config setup, tool\nwork, and streamed output; it is not an idle timer. Each retry starts a fresh clock, so the maximum\ntimeout envelope is `(retries + 1) \xD7 resolved timeoutMs` (retries are clamped to 3). An exhausted\ntimeout is recoverable `AGENT_TIMEOUT`: the call resolves to `null`, releases its concurrency slot,\nand asks the ACP session to cancel. A session that keeps running after the cancellation grace is\nclosed where supported and its pooled child is recycled.\n\nEvery new run, including one admitted with `resumeFromRunId`, resolves host limits from that run\'s\nrequest. It does not inherit `agentTimeoutMs`, retries, concurrency, or agent-count values from\nits source, so pass every operational bound the resumed execution should use.\n\n## Model specs & routing\n\nA `model` string is resolved solely from its first segment, then delegated to the harness:\n\n| spec shape | routes to | notes |\n|---|---|---|\n| *(omitted)* | host-pinned/default backend | MCP: explicit `AGENTPRISM_DEFAULT_BACKEND` wins; when truly unset, zero-token readiness discovery pins one project default before validation/execution and preserves it across resume. SDK runner: configured default, historical fallback `claude`. The selected harness keeps its session default model. Most portable. |\n| `claude`, `codex`, `opencode`, `pi`, or `<custom-name>` | that registered harness | Backend-only: no model config call; the harness default remains active. |\n| `claude/<id>`, `codex/<id>`, `opencode/<id>`, `pi/<id>`, or `<custom-name>/<id>` | that registered harness | Match the first segment ASCII-case-insensitively and strip exactly one segment. Custom names take priority on collision. The remaining `<id>` is sent verbatim, including further `/` characters. For Pi, that remainder is its `<provider>/<model-id>` and Pi preserves any further slashes in the model id. |\n| any other string, including `anthropic/\u2026`, `openai/\u2026`, bare `opus`, or bare `gpt-\u2026` | host default backend | The **entire** authored string is sent verbatim; these are not routing aliases. |\n\nSelection is a single `session/set_config_option` with `configId: "model"` and the exact remaining string. There is no catalog matching, case folding, normalization, bracket parsing, nearest-neighbor selection, sibling effort/Fast option driving, retry, or echo verification. Brackets, dots, and provider-style prefixes are ordinary model-id characters.\n\nWhatever the harness returns is the outcome. A rejection follows the existing agent-error path with no resolution-specific code or model fallback event. `onModelFallback` and `WorkflowRunResult.fallbacks` remain public compatibility surfaces; model resolution does not emit entries, while pause recovery emits `kind: "continuation"` reattach/skip notices.\n\n## Structured output channels\n\nOne author API (`schema`), four fulfillment paths \u2014 chosen automatically per backend:\n\n| backend | channel |\n|---|---|\n| Claude | native `outputFormat`, schema normalized to Anthropic\'s structured-outputs subset (e.g. `oneOf` \u2192 `anyOf`; unsupported keywords/formats stripped on the wire) |\n| Codex | native strict `outputSchema` (OpenAI strict subset normalization) |\n| Pi | a client-hosted `StructuredOutput` MCP tool injected when the agent advertises HTTP MCP support; common prompt-embedded schema and validated final-text JSON fallback |\n| OpenCode / custom ACP | a client-hosted **`StructuredOutput` MCP tool** injected into the session when the agent advertises HTTP MCP support (an agent may show it as `structured_output_StructuredOutput`); otherwise prompt-embedded schema + JSON parse of the final message. Custom backends can opt out of tool injection with `structuredOutputTool: false`. |\n\nPi accepts stdio, Streamable HTTP, and SSE MCP servers; ACP-transport MCP hosting remains client-side.\n\nIn every channel the runner coerces + validates client-side and re-prompts a bounded number of times; the final miss fails the call with non-recoverable `SCHEMA_NONCOMPLIANCE`. Constraints stripped from the wire are still enforced client-side \u2014 an exotic schema keyword shows up as re-prompt churn, so keep schemas simple.\n'
+    "bytes": 8866,
+    "sha256": "cce59fffcb8a5e58e8a127220bf303a1d362d66b1216ecde0712b38d6e8eae47",
+    "text": '# Workflow agent API reference\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\n## `agent(prompt, options?)` \u2014 full option table\n\nReturns the agent\'s final assistant text, or the schema-validated object when `schema` is set. Resolves to `null` when a *recoverable* failure survives all retries.\n\n| option | type | meaning |\n|---|---|---|\n| `label` | `string` | Display/telemetry name; also stamped on every live ACP event for this call. Always set it. Not part of the resume hash. |\n| `phase` | `string` | Assign this call to a phase explicitly (needed inside concurrent stages where the global `phase()` state would race). |\n| `schema` | JSON Schema object | Structured output. Plain object literal only \u2014 no schema builders exist in the realm. Part of the resume hash. |\n| `model` | `string` | Model spec: optional registered harness prefix plus a verbatim id, or a backend-only name. See [Model specs & routing](#model-specs--routing). Part of the resume hash. |\n| `tier` | `"small" \\| "medium" \\| "big"` | Coarse tier resolved from host config; beats phase/meta model, loses to explicit `model`. Part of the resume hash. |\n| `mode` | `string` | ACP session mode id advertised by the selected backend/model. **Strict**: unsupported/unadvertised ids fail before prompting (and automatic workflow preflight rejects them before admission). Read the selected `action:"config"` entry\'s `modes.availableModes` and copy only an exact id; `modes:null` means omit this field. Never infer a generic `"default"`. Part of the resume hash when set. |\n| `configOptions` | `Record<string, string \\| boolean>` | Exact ACP session option ids and authored values. Applied in ascending id order after model and before the prompt, with no aliases or coercion. `"model"` is reserved for the dedicated `model` field. Part of the resume hash only when non-empty, with sorted keys. With MCP, read the advertised-options table from `workflow` action `config` before choosing values. |\n| `agentType` | `string` | Bind a named subagent definition (tools allow/deny, model, isolation, role prompt). See [agentType definitions](#agenttype-definitions). Part of the resume hash. |\n| `isolation` | `"worktree"` | Run in a throwaway git worktree branched from the run cwd. **Always removed (worktree + branch) when the call ends** \u2014 edits are discarded; return work as data. Degrades to the shared tree outside a git repo (logged). |\n| `resume` | `{ filesystem: "read-only" }` | Deprecated compatibility annotation. It is recorded as legacy diagnostic provenance, is not sent to the runner or hashed, and has no effect on replay. New scripts should omit it. |\n| `cwd` | `string` | Per-session working directory; relative resolves against the run\'s base cwd. Overridden by worktree isolation. Not hashed. |\n| `timeoutMs` | `number \\| null` | Total wall-clock cap for each attempt. A finite value may tighten a finite host `agentTimeoutMs` ceiling but cannot raise or disable it. With no host ceiling, a finite value applies and `null`/omitted is uncapped. |\n| `idleTimeoutMs` | `number \\| null` | No-backend-activity cap for each attempt. It may tighten a finite host `agentIdleTimeoutMs` ceiling but cannot raise or disable it. |\n| `retries` | `number` | Retries after *recoverable* failures (default 0, host-overridable). Exhausted retries \u21D2 the call resolves `null`. |\n| `mcpServers` | `McpServerConfig[]` | MCP servers attached to this session. Stdio shape: `{ name, command, args: [], env: [{ name, value }] }` (`args`/`env` required, `env` is name/value pairs, not a map); `{ type: "http" \\| "sse", name, url, headers: [] }` also accepted. Not hashed. |\n| `images` | `PromptImage[]` | Base64 image blocks appended to the prompt; backends without image support get a bracketed text note. Not hashed. |\n| `meta` | `object` | ACP `_meta` merged into `session/new` \u2014 session-scoped extension passthrough (pairs with custom backends). Not hashed. |\n| `promptMeta` | `object` | ACP `_meta` merged into `session/prompt` \u2014 turn-scoped passthrough. Backend-computed keys win on conflict. Not hashed. |\n| `keepSession` | `boolean` | Skip release-time best-effort `session/close`; the non-secret re-attach record lands in `WorkflowRunResult.agentSessions` for host-side `loadSession()` / `resumeSession()`. Usage/auth pause failures are kept open automatically for managed continuation. Not identity-hashed; included in the input fingerprint. |\n\nThe total-wall clock measures the whole attempt, including backend startup, model/config setup,\ntool work, and streamed output; it is not an idle timer. The separate idle clock is opt-in and\nre-arms on real backend activity (every ACP `session/update`), never synthetic progress heartbeats.\nSize it above the longest expected backend-silent local tool call. Each retry starts fresh clocks.\nExhaustion is recoverable `AGENT_TIMEOUT` or `AGENT_IDLE_TIMEOUT`: the call resolves to `null`,\nreleases its concurrency slot, and asks the ACP session to cancel. A session that keeps running\nafter the cancellation grace is closed where supported and its pooled child is recycled.\n\nEvery new run, including one admitted with `resumeFromRunId`, resolves host limits from that run\'s\nrequest. It does not inherit `agentTimeoutMs`, `agentIdleTimeoutMs`, retries, concurrency, or\nagent-count values from its source, so pass every operational bound the resumed execution should use.\n\n## Model specs & routing\n\nA `model` string is resolved solely from its first segment, then delegated to the harness:\n\n| spec shape | routes to | notes |\n|---|---|---|\n| *(omitted)* | host-pinned/default backend | MCP: explicit `AGENTPRISM_DEFAULT_BACKEND` wins; when truly unset, zero-token readiness discovery pins one project default before validation/execution and preserves it across resume. SDK runner: configured default, historical fallback `claude`. The selected harness keeps its session default model. Most portable. |\n| `claude`, `codex`, `opencode`, `pi`, or `<custom-name>` | that registered harness | Backend-only: no model config call; the harness default remains active. |\n| `claude/<id>`, `codex/<id>`, `opencode/<id>`, `pi/<id>`, or `<custom-name>/<id>` | that registered harness | Match the first segment ASCII-case-insensitively and strip exactly one segment. Custom names take priority on collision. The remaining `<id>` is sent verbatim, including further `/` characters. For Pi, that remainder is its `<provider>/<model-id>` and Pi preserves any further slashes in the model id. |\n| any other string, including `anthropic/\u2026`, `openai/\u2026`, bare `opus`, or bare `gpt-\u2026` | host default backend | The **entire** authored string is sent verbatim; these are not routing aliases. |\n\nSelection is a single `session/set_config_option` with `configId: "model"` and the exact remaining string. There is no catalog matching, case folding, normalization, bracket parsing, nearest-neighbor selection, sibling effort/Fast option driving, retry, or echo verification. Brackets, dots, and provider-style prefixes are ordinary model-id characters.\n\nWhatever the harness returns is the outcome. A rejection follows the existing agent-error path with no resolution-specific code or model fallback event. `onModelFallback` and `WorkflowRunResult.fallbacks` remain public compatibility surfaces; model resolution does not emit entries, while pause recovery emits `kind: "continuation"` reattach/skip notices.\n\n## Structured output channels\n\nOne author API (`schema`), four fulfillment paths \u2014 chosen automatically per backend:\n\n| backend | channel |\n|---|---|\n| Claude | native `outputFormat`, schema normalized to Anthropic\'s structured-outputs subset (e.g. `oneOf` \u2192 `anyOf`; unsupported keywords/formats stripped on the wire) |\n| Codex | native strict `outputSchema` (OpenAI strict subset normalization) |\n| Pi | a client-hosted `StructuredOutput` MCP tool injected when the agent advertises HTTP MCP support; common prompt-embedded schema and validated final-text JSON fallback |\n| OpenCode / custom ACP | a client-hosted **`StructuredOutput` MCP tool** injected into the session when the agent advertises HTTP MCP support (an agent may show it as `structured_output_StructuredOutput`); otherwise prompt-embedded schema + JSON parse of the final message. Custom backends can opt out of tool injection with `structuredOutputTool: false`. |\n\nPi accepts stdio, Streamable HTTP, and SSE MCP servers; ACP-transport MCP hosting remains client-side.\n\nIn every channel the runner coerces + validates client-side and re-prompts a bounded number of times; the final miss fails the call with non-recoverable `SCHEMA_NONCOMPLIANCE`. Constraints stripped from the wire are still enforced client-side \u2014 an exotic schema keyword shows up as re-prompt churn, so keep schemas simple.\n'
   },
   {
     "id": "workflow/api-control-flow",
@@ -32385,9 +32590,9 @@ var AUTHORING_DOC_TOPICS = [
       "workflow/checkpoints-and-quality",
       "workflow/api-agents"
     ],
-    "bytes": 6698,
-    "sha256": "9e32ea004addd2a6779c12e31d298169c1310569413c9c8d2767c61397ffde30",
-    "text": '# Workflow control-flow API reference\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\n## DSL globals \u2014 complete signatures\n\n```\nagent(prompt, options?)                    \u2192 Promise<string | object | null>\nparallel(thunks)                           \u2192 Promise<results[]>   // barrier; input order; failed slot = null\npipeline(items, ...stages)                 \u2192 Promise<results[]>   // no inter-stage barrier; stage(prev, original, index); failed item = null\nworkflow(nameOrScript, args?)              \u2192 Promise<unknown>     // one nesting level; names resolve from the host\'s workflows folder, inline scripts always work\ngate(thunk, validator, { attempts = 3 })   \u2192 { ok, value, verdict, attempts }\n    // thunk(feedback, attempt); validator(result) \u2192 { ok, feedback?, ... } | boolean | null (may be async / an agent call)\nretry(thunk, { attempts = 3, until? })     \u2192 last result           // thunk(attempt); stops early when until(result)\nverify(item, { reviewers = 2, threshold = 0.5, lens? })\n    \u2192 { real, realCount, total, votes: [{ real?, reason? }] }\n    // N adversarial reviewers prompted to REFUTE; lens (string | string[]) rotates focus per reviewer\njudgePanel(attempts, { judges = 3, rubric = "overall quality and correctness" })\n    \u2192 { index, attempt, score, judgments }  // mean 0\u20131 score per candidate; stable tie-break by index\nloopUntilDry({ round, key = JSON.stringify, consecutiveEmpty = 2, maxRounds = 50 })\n    \u2192 unique items[]   // round(i) returns items; stops after N dry rounds; agent-limit exhaustion returns the partial result\ncompletenessCheck(taskArgs, results)       \u2192 { complete, missing?: string[] }\ncheckpoint(promptText, options?)           \u2192 Promise<reply>       // journaled human gate; zero tokens\nphase(title)                               \u2192 void                 // open a named phase\nlog(message)                               \u2192 void                 // console.log/info/warn/error route here too\nargs                                       // the host-provided input value, verbatim\ncwd                                        // the run\'s base working directory (string); process.cwd() returns it too\n```\n\nFor `gate()`, `value` is the final producer result and `verdict` is the exact last completed\nvalidator return, including any extra structured fields. `{ ok: true }` and bare `true` pass;\n`{ ok: false, feedback? }`, bare `false`, and `null` reject. Only object feedback is threaded into\nthe next producer attempt. A producer result of `null` is still passed to the validator. Producer\nor validator exceptions propagate immediately, so no partial gate result is returned and no later\nattempt runs. An explicit unsupported `undefined` validator return is a rejection represented as\n`verdict: null`. If the script returns the gate result, its complete verdict is persisted and may\nreach the host; keep evidence concise and never put credentials or other secrets in verdict data.\n\n`verify`, `judgePanel`, and `completenessCheck` spawn their subagents on the run\'s default model \u2014 hand-roll with `parallel` + `agent` to pin panel members to specific backends.\n\n## `checkpoint()` options\n\n| option | type | meaning |\n|---|---|---|\n| `kind` | `"confirm" \\| "input" \\| "select"` | Reply shape: boolean-ish / free text / one of `choices`. Affects the journal hash and the host UI widget. |\n| `choices` | `string[]` | For `kind: "select"`. |\n| `default` | `unknown` | Reply taken in the default headless mode \u2014 journaled like a real reply. Defaults to `true`. |\n| `headless` | `"default" \\| "abort" \\| "pause"` | No live channel: `"default"` takes `default ?? true`, `"abort"` aborts, and `"pause"` creates a persisted `checkpoint_required` pause. Default `"default"`. |\n| `timeoutMs` | `number` | Deadline for the interactive prompt. |\n\nThe host supplies the live human channel (elicitation in the MCP server; `ExecOptions.confirm` in the SDK), and that channel wins even when `headless: "pause"` is declared. A durable pause carries non-secret `checkpointContext`; resume with `ExecOptions.checkpointReplies: { [context.callIndex]: decision }` or attach a live channel. On a new `resumeFromRunId` execution, reply keys always name indexes in the **source** recording; identity matching may inject that decision at a shifted current index. Completed host and headless checkpoint results both replay when identity and the checkpoint-options fingerprint over `default`, `headless`, and `timeoutMs` match. A changed option or ambiguous match runs fresh. Detached runs never pause for a checkpoint unless the author opts into `"pause"`.\n\n## Error codes (`WorkflowError.code`)\n\n| code | recoverable | engine behavior |\n|---|---|---|\n| `AGENT_TIMEOUT` | yes | Total wall-clock attempt cap exhausted. Every retry gets a fresh clock; after the final attempt the call resolves `null`, and ACP cancel escalates to close/recycle when the turn does not stop. |\n| `AGENT_CANCELLED` | yes | The host selected this in-flight call for cancellation. It resolves `null` immediately through an engine race, skips retries, leaves the run live, and is recorded as a failed call rather than a replayable journal result. |\n| `AGENT_EMPTY_OUTPUT` | yes | No assistant text on a schema-less call; same retry-then-`null`. |\n| `AGENT_EXECUTION_ERROR` | yes* | Generic agent failure (*refusal/truncation variants are non-recoverable). |\n| `SCHEMA_NONCOMPLIANCE` | no | Structured output never validated after the re-prompt ladder. Halts the run (catchable in-script). |\n| `PROVIDER_USAGE_LIMIT` | no | Quota/rate wall \u2014 the run **pauses** (journaled, resumable), with the provider\'s reset hint. |\n| `AGENT_LIMIT_EXCEEDED` | no | `maxAgents` cap hit. |\n| `AUTH_REQUIRED` | no | Backend needs authentication. `WorkflowManager` returns a resumable pause with `reason: "auth_required"` and redacted `authContext`; a direct runner throws. The host completes auth before resuming/retrying. |\n| `CHECKPOINT_REQUIRED` | no | `headless: "pause"` reached without a live channel. `WorkflowManager` returns `reason: "checkpoint_required"` plus non-secret `checkpointContext`; resume with `checkpointReplies` or live confirm. |\n| `SCRIPT_VALIDATION_ERROR` | no | Script failed parse/validation (bad meta, nondeterministic API, bad `meta.backends` shape). |\n| `SCRIPT_ERROR` | no | The script itself crashed (uncaught throw, floated rejection). |\n| `WORKFLOW_ABORTED` | \u2014 | Real cancellation (pause/stop/host signal) \u2014 never used for crashes. |\n\n`loopUntilDry` absorbs `AGENT_LIMIT_EXCEEDED` from its rounds and returns the partial result; everywhere else it propagates.\n'
+    "bytes": 6852,
+    "sha256": "7c7ad1129ead65b362723d231edd20011a86588d3b7a12f9618ba1618a91d271",
+    "text": '# Workflow control-flow API reference\n\n**Context:** JavaScript passed to the MCP `workflow` tool. Workflow scripts use `agent(prompt, options?)`; REPL evals use a different API.\n\n## DSL globals \u2014 complete signatures\n\n```\nagent(prompt, options?)                    \u2192 Promise<string | object | null>\nparallel(thunks)                           \u2192 Promise<results[]>   // barrier; input order; failed slot = null\npipeline(items, ...stages)                 \u2192 Promise<results[]>   // no inter-stage barrier; stage(prev, original, index); failed item = null\nworkflow(nameOrScript, args?)              \u2192 Promise<unknown>     // one nesting level; names resolve from the host\'s workflows folder, inline scripts always work\ngate(thunk, validator, { attempts = 3 })   \u2192 { ok, value, verdict, attempts }\n    // thunk(feedback, attempt); validator(result) \u2192 { ok, feedback?, ... } | boolean | null (may be async / an agent call)\nretry(thunk, { attempts = 3, until? })     \u2192 last result           // thunk(attempt); stops early when until(result)\nverify(item, { reviewers = 2, threshold = 0.5, lens? })\n    \u2192 { real, realCount, total, votes: [{ real?, reason? }] }\n    // N adversarial reviewers prompted to REFUTE; lens (string | string[]) rotates focus per reviewer\njudgePanel(attempts, { judges = 3, rubric = "overall quality and correctness" })\n    \u2192 { index, attempt, score, judgments }  // mean 0\u20131 score per candidate; stable tie-break by index\nloopUntilDry({ round, key = JSON.stringify, consecutiveEmpty = 2, maxRounds = 50 })\n    \u2192 unique items[]   // round(i) returns items; stops after N dry rounds; agent-limit exhaustion returns the partial result\ncompletenessCheck(taskArgs, results)       \u2192 { complete, missing?: string[] }\ncheckpoint(promptText, options?)           \u2192 Promise<reply>       // journaled human gate; zero tokens\nphase(title)                               \u2192 void                 // open a named phase\nlog(message)                               \u2192 void                 // console.log/info/warn/error route here too\nargs                                       // the host-provided input value, verbatim\ncwd                                        // the run\'s base working directory (string); process.cwd() returns it too\n```\n\nFor `gate()`, `value` is the final producer result and `verdict` is the exact last completed\nvalidator return, including any extra structured fields. `{ ok: true }` and bare `true` pass;\n`{ ok: false, feedback? }`, bare `false`, and `null` reject. Only object feedback is threaded into\nthe next producer attempt. A producer result of `null` is still passed to the validator. Producer\nor validator exceptions propagate immediately, so no partial gate result is returned and no later\nattempt runs. An explicit unsupported `undefined` validator return is a rejection represented as\n`verdict: null`. If the script returns the gate result, its complete verdict is persisted and may\nreach the host; keep evidence concise and never put credentials or other secrets in verdict data.\n\n`verify`, `judgePanel`, and `completenessCheck` spawn their subagents on the run\'s default model \u2014 hand-roll with `parallel` + `agent` to pin panel members to specific backends.\n\n## `checkpoint()` options\n\n| option | type | meaning |\n|---|---|---|\n| `kind` | `"confirm" \\| "input" \\| "select"` | Reply shape: boolean-ish / free text / one of `choices`. Affects the journal hash and the host UI widget. |\n| `choices` | `string[]` | For `kind: "select"`. |\n| `default` | `unknown` | Reply taken in the default headless mode \u2014 journaled like a real reply. Defaults to `true`. |\n| `headless` | `"default" \\| "abort" \\| "pause"` | No live channel: `"default"` takes `default ?? true`, `"abort"` aborts, and `"pause"` creates a persisted `checkpoint_required` pause. Default `"default"`. |\n| `timeoutMs` | `number` | Deadline for the interactive prompt. |\n\nThe host supplies the live human channel (elicitation in the MCP server; `ExecOptions.confirm` in the SDK), and that channel wins even when `headless: "pause"` is declared. A durable pause carries non-secret `checkpointContext`; resume with `ExecOptions.checkpointReplies: { [context.callIndex]: decision }` or attach a live channel. On a new `resumeFromRunId` execution, reply keys always name indexes in the **source** recording; identity matching may inject that decision at a shifted current index. Completed host and headless checkpoint results both replay when identity and the checkpoint-options fingerprint over `default`, `headless`, and `timeoutMs` match. A changed option or ambiguous match runs fresh. Detached runs never pause for a checkpoint unless the author opts into `"pause"`.\n\n## Error codes (`WorkflowError.code`)\n\n| code | recoverable | engine behavior |\n|---|---|---|\n| `AGENT_TIMEOUT` | yes | Total wall-clock attempt cap exhausted. Every retry gets a fresh clock; after the final attempt the call resolves `null`, and ACP cancel escalates to close/recycle when the turn does not stop. |\n| `AGENT_IDLE_TIMEOUT` | yes | Opt-in no-backend-activity cap exhausted. Real backend events re-arm it; retries and cancellation match `AGENT_TIMEOUT`. |\n| `AGENT_CANCELLED` | yes | The host selected this in-flight call for cancellation. It resolves `null` immediately through an engine race, skips retries, leaves the run live, and is recorded as a failed call rather than a replayable journal result. |\n| `AGENT_EMPTY_OUTPUT` | yes | No assistant text on a schema-less call; same retry-then-`null`. |\n| `AGENT_EXECUTION_ERROR` | yes* | Generic agent failure (*refusal/truncation variants are non-recoverable). |\n| `SCHEMA_NONCOMPLIANCE` | no | Structured output never validated after the re-prompt ladder. Halts the run (catchable in-script). |\n| `PROVIDER_USAGE_LIMIT` | no | Quota/rate wall \u2014 the run **pauses** (journaled, resumable), with the provider\'s reset hint. |\n| `AGENT_LIMIT_EXCEEDED` | no | `maxAgents` cap hit. |\n| `AUTH_REQUIRED` | no | Backend needs authentication. `WorkflowManager` returns a resumable pause with `reason: "auth_required"` and redacted `authContext`; a direct runner throws. The host completes auth before resuming/retrying. |\n| `CHECKPOINT_REQUIRED` | no | `headless: "pause"` reached without a live channel. `WorkflowManager` returns `reason: "checkpoint_required"` plus non-secret `checkpointContext`; resume with `checkpointReplies` or live confirm. |\n| `SCRIPT_VALIDATION_ERROR` | no | Script failed parse/validation (bad meta, nondeterministic API, bad `meta.backends` shape). |\n| `SCRIPT_ERROR` | no | The script itself crashed (uncaught throw, floated rejection). |\n| `WORKFLOW_ABORTED` | \u2014 | Real cancellation (pause/stop/host signal) \u2014 never used for crashes. |\n\n`loopUntilDry` absorbs `AGENT_LIMIT_EXCEEDED` from its rounds and returns the partial result; everywhere else it propagates.\n'
   },
   {
     "id": "workflow/api-resume-and-backends",
@@ -33553,11 +33758,13 @@ var WorkflowScriptResources = class {
     this.modernNotifier = modernNotifier;
     this.router = source instanceof WorkflowManager2 ? singleStoreRouter(source) : source.router;
     this.detachRunDeleted = this.router.onRunDeleted(this.onRunDeleted);
+    this.detachRunStopped = this.router.onRunStopped(({ runId }) => this.cancelPendingElicitation(runId));
     const previousOnClose = this.mcp.server.onclose;
     this.mcp.server.onclose = () => {
       for (const controller of this.elicitationControllers.values()) controller.abort();
       this.elicitationControllers.clear();
       for (const uri of [...this.eventSubscriptions.keys()]) this.closeEventSubscription(uri);
+      this.detachRunStopped();
       this.detachRunDeleted();
       previousOnClose?.();
     };
@@ -33567,6 +33774,7 @@ var WorkflowScriptResources = class {
   modernNotifier;
   router;
   detachRunDeleted;
+  detachRunStopped;
   subscriptions = /* @__PURE__ */ new Set();
   externalReaders = /* @__PURE__ */ new Map();
   eventSubscriptions = /* @__PURE__ */ new Map();
@@ -33955,6 +34163,43 @@ var WorkflowScriptResources = class {
   }
 };
 
+// ../mcp-server/src/workflow-stop.ts
+function requireDurableStoppedRun(manager, runId) {
+  const persistence = manager.getPersistence();
+  const persisted = persistence.load(runId);
+  if (persisted?.status !== "aborted") {
+    throw new ProtocolError(
+      ProtocolErrorCode.InternalError,
+      `Workflow stop for runId "${runId}" could not be durably acknowledged: the persisted status is ${persisted?.status ?? "missing"}, not aborted.`
+    );
+  }
+  if (persisted.eventLogIncomplete || persisted.eventStreamId === void 0 || persisted.eventSeq === void 0 || persisted.eventSeq < 1) {
+    throw new ProtocolError(
+      ProtocolErrorCode.InternalError,
+      `Workflow stop for runId "${runId}" could not be durably acknowledged: its stopped event is not durably readable.`
+    );
+  }
+  let stoppedEventIsDurable = false;
+  try {
+    const events = persistence.readEvents(runId, {
+      after: persisted.eventSeq - 1,
+      streamId: persisted.eventStreamId,
+      limit: 1
+    });
+    stoppedEventIsDurable = events.events.some(
+      (record2) => record2.seq === persisted.eventSeq && record2.event.type === "stopped"
+    );
+  } catch {
+    stoppedEventIsDurable = false;
+  }
+  if (!stoppedEventIsDurable) {
+    throw new ProtocolError(
+      ProtocolErrorCode.InternalError,
+      `Workflow stop for runId "${runId}" could not be durably acknowledged: its terminal stopped event is missing.`
+    );
+  }
+}
+
 // ../mcp-server/src/server.ts
 var SERVER_NAME = "agentprism-workflow";
 var DEFAULT_REQUEST_STATE_CODEC = createRequestStateCodec({
@@ -33962,7 +34207,7 @@ var DEFAULT_REQUEST_STATE_CODEC = createRequestStateCodec({
   bind: (ctx) => ctx.mcpReq.method
 });
 var require2 = createRequire(import.meta.url);
-var SERVER_VERSION = true ? "0.35.0" : require2("../package.json").version;
+var SERVER_VERSION = true ? "0.37.0" : require2("../package.json").version;
 var SERVER_INSTRUCTIONS = [
   "This server exposes three model-facing tools for authoring and orchestrating multi-agent work. workflow and repl spawn subagents over the same ACP backends \u2014 the registry built-ins Claude, Codex, OpenCode, and pi, plus any registered custom agents \u2014 and key their durable state by an absolute projectDir (required on the shared daemon; defaults to the server's own project in single-project mode). Backend credentials come from each agent's own login (claude, codex, opencode, pi), so there is nothing auth-shaped to configure here.",
   '\u2022 docs \u2014 SELECTIVE VERSION-MATCHED REFERENCE. Omit topic or use topic:"index" for the bounded catalog, then read exactly one workflow/* or repl/* topic. It embeds the selected text/markdown resource, runs no code, opens no backend, and needs no projectDir. Use it when the compact tool descriptions do not contain enough syntax or lifecycle detail.',
@@ -34549,6 +34794,17 @@ function formatStopSummary(result) {
   }
   return truncateUtf83(lines.join("\n"), 8192, "\u2026[text truncated]");
 }
+function formatPendingStopSummary(result) {
+  const lines = inspectionSummaryLines(result);
+  const owner = result.control.owner;
+  lines.splice(
+    2,
+    0,
+    `Stop request ${result.control.operationId} is durably pending; retry stop, inspect, or await to observe settlement.`,
+    owner === void 0 ? "No live execution owner is currently discoverable; a later lease holder will apply the intent." : `Execution owner: daemon pid ${owner.pid}${owner.version ? ` v${owner.version}` : ""}${owner.lameDuck ? " (draining)" : ""}.`
+  );
+  return truncateUtf83(lines.join("\n"), 8192, "\u2026[text truncated]");
+}
 function formatAgentCancellationSummary(status, cancellation) {
   const lines = inspectionSummaryLines(status);
   lines.splice(
@@ -34560,7 +34816,7 @@ function formatAgentCancellationSummary(status, cancellation) {
 }
 function readScriptAtAdmission(scriptPath) {
   try {
-    return readFileSync2(scriptPath, "utf8");
+    return readFileSync3(scriptPath, "utf8");
   } catch (error51) {
     const cause = error51 instanceof Error ? error51.message : String(error51);
     throw new ProtocolError(
@@ -34605,41 +34861,6 @@ async function settleForegroundRun(manager, started) {
     throw error51;
   }
 }
-function requireDurableStoppedRun(manager, runId) {
-  const persistence = manager.getPersistence();
-  const persisted = persistence.load(runId);
-  if (persisted?.status !== "aborted") {
-    throw new ProtocolError(
-      ProtocolErrorCode.InternalError,
-      `Workflow stop for runId "${runId}" could not be durably acknowledged: the persisted status is ${persisted?.status ?? "missing"}, not aborted.`
-    );
-  }
-  if (persisted.eventLogIncomplete || persisted.eventStreamId === void 0 || persisted.eventSeq === void 0 || persisted.eventSeq < 1) {
-    throw new ProtocolError(
-      ProtocolErrorCode.InternalError,
-      `Workflow stop for runId "${runId}" could not be durably acknowledged: its stopped event is not durably readable.`
-    );
-  }
-  let stoppedEventIsDurable = false;
-  try {
-    const events = persistence.readEvents(runId, {
-      after: persisted.eventSeq - 1,
-      streamId: persisted.eventStreamId,
-      limit: 1
-    });
-    stoppedEventIsDurable = events.events.some(
-      (record2) => record2.seq === persisted.eventSeq && record2.event.type === "stopped"
-    );
-  } catch {
-    stoppedEventIsDurable = false;
-  }
-  if (!stoppedEventIsDurable) {
-    throw new ProtocolError(
-      ProtocolErrorCode.InternalError,
-      `Workflow stop for runId "${runId}" could not be durably acknowledged: its terminal stopped event is missing.`
-    );
-  }
-}
 function normalizeTokenUsage(usage) {
   if (!usage) return void 0;
   return {
@@ -34663,7 +34884,7 @@ function persistedOutcome(persisted, status) {
   return {
     runId: persisted.runId,
     status: status.status,
-    ...persisted.limits === void 0 ? {} : { limits: persisted.limits },
+    ...status.limits === void 0 ? {} : { limits: status.limits },
     ...status.status === "completed" && persisted.result !== void 0 ? { result: persisted.result } : {},
     tokenUsage: normalizeTokenUsage(persisted.tokenUsage),
     logs: persisted.logs,
@@ -34920,7 +35141,7 @@ function createWorkflowServer(runner, options = {}) {
   const workflowToolOutputSchema = workflowToolOutputShape;
   const workflowToolConfig = {
     title: "Discover, validate, run, inspect, await, stop, or narrow-cancel an agent workflow",
-    description: 'Author and operate JavaScript agent workflows through one project-scoped tool. A script\'s first statement must be `export const meta = { name, description, phases? }`. When present, phases must be an array of objects shaped `{ title: string, detail?: string, model?: string }`, never an array of strings. Inside the deterministic script realm use agent(prompt, options?) for one subagent; parallel([thunks]) for a barrier; pipeline(items, ...stages) for streaming stages; checkpoint(prompt, options?) for a human gate; phase(title) and log(message) for progress; and return the final JSON-serializable value. Top-level await is supported. Imports, require, network APIs, Date.now(), and Math.random() are unavailable. Always label agent calls; schema is a plain JSON Schema object for structured results. The only agent option keys are label, phase, model, tier, mode, configOptions, schema, cwd, timeoutMs, retries, isolation:"worktree", resume, agentType, mcpServers, images, meta, promptMeta, and keepSession; unknown keys reject before admission. Every parallel entry must be a thunk: parallel([() => agent(...), () => agent(...)]). For deeper syntax, read docs topic workflow/quickstart and then one related workflow/* topic. Minimal script: `export const meta = { name: "review", description: "Review a target", phases: [{ title: "Review" }] }; phase("Review"); const report = await agent("Review " + args.target, { label: "review" }); return { report };`. Omit model for the server default (explicit AGENTPRISM_DEFAULT_BACKEND, else a zero-token auto-selected project pin), or use a backend name alone to preserve that backend\'s configured default. Before choosing a pinned model, mode, or configOptions, call action:"config" with projectDir and optional harnesses/modelFilter; after choosing a model, pass modelSpecs to read its model-specific options. Set mode only when that selected harness entry\'s modes.availableModes explicitly lists the exact id; modes:null means unsupported, so omit mode\u2014never infer a default from an absent value. Config opens no-prompt sessions, spends zero tokens, and starts no workflow. action:"run" automatically performs static validation, a mocked dry run, and routed config checks before admission. Invalid scripts return bounded diagnostics with status:"rejected" and create no run ID, reserve no background slot, and spend no tokens. Run, resume, inspect, await, or stop an admitted workflow through the same tool. The script orchestrates agent() subagents (and optional checkpoint() gates) over registry built-ins\u2014currently Claude, Codex, OpenCode, and pi\u2014ACP backends, plus registered custom agents. Supply exactly one of inline script or absolute scriptPath; path content is read once and snapshotted at admission. ' + (requireProjectDir ? "config and run REQUIRE projectDir (absolute): it is the discovery cwd and selects the project-scoped run store/default execution cwd. " : "run optionally takes projectDir (absolute) to select the project-scoped run store; default is this server's own project. ") + 'inspect/await/stop take only a runId \u2014 it locates its project store automatically. Foreground is the default and streams progress; background:true returns a durable runId for bounded action:"await" calls. run and await honor _meta.progressToken with notifications/progress while they block. Pass resumeFromRunId to execute a new run from a prior journal prefix. In hosts that render MCP Apps, every call of this tool shows a live self-updating run-monitor panel and the panel reports phase starts, pauses, and terminal outcomes on its own \u2014 do NOT poll action:"inspect" to check on a run there; prefer a single bounded action:"await". Use action:"inspect" with a runId when you need machine-readable status data: a safe bounded status, log tail, and attributed call previews. Use action:"stop" to durably abort a live run; add callIndex to cancel only that in-flight agent and keep the run live. labelGlob remains an output filter in both forms. A whole-run stop returns the final run fate; resume is safe immediately, and only agent-session wind-down can remain asynchronous. Every admitted script is readable at workflow://runs/{runId}/script and results include resource links. Background runs are tracked per project, capped at four active/starting runs, and use headless checkpoint semantics; checkpointReplies continue a checkpoint pause in a new run.',
+    description: 'Author and operate JavaScript agent workflows through one project-scoped tool. A script\'s first statement must be `export const meta = { name, description, phases? }`. When present, phases must be an array of objects shaped `{ title: string, detail?: string, model?: string }`, never an array of strings. Inside the deterministic script realm use agent(prompt, options?) for one subagent; parallel([thunks]) for a barrier; pipeline(items, ...stages) for streaming stages; checkpoint(prompt, options?) for a human gate; phase(title) and log(message) for progress; and return the final JSON-serializable value. Top-level await is supported. Imports, require, network APIs, Date.now(), and Math.random() are unavailable. Always label agent calls; schema is a plain JSON Schema object for structured results. The only agent option keys are label, phase, model, tier, mode, configOptions, schema, cwd, timeoutMs, idleTimeoutMs, retries, isolation:"worktree", resume, agentType, mcpServers, images, meta, promptMeta, and keepSession; unknown keys reject before admission. Every parallel entry must be a thunk: parallel([() => agent(...), () => agent(...)]). For deeper syntax, read docs topic workflow/quickstart and then one related workflow/* topic. Minimal script: `export const meta = { name: "review", description: "Review a target", phases: [{ title: "Review" }] }; phase("Review"); const report = await agent("Review " + args.target, { label: "review" }); return { report };`. Omit model for the server default (explicit AGENTPRISM_DEFAULT_BACKEND, else a zero-token auto-selected project pin), or use a backend name alone to preserve that backend\'s configured default. Before choosing a pinned model, mode, or configOptions, call action:"config" with projectDir and optional harnesses/modelFilter; after choosing a model, pass modelSpecs to read its model-specific options. Set mode only when that selected harness entry\'s modes.availableModes explicitly lists the exact id; modes:null means unsupported, so omit mode\u2014never infer a default from an absent value. Config opens no-prompt sessions, spends zero tokens, and starts no workflow. action:"run" automatically performs static validation, a mocked dry run, and routed config checks before admission. Invalid scripts return bounded diagnostics with status:"rejected" and create no run ID, reserve no background slot, and spend no tokens. Run, resume, inspect, await, or stop an admitted workflow through the same tool. The script orchestrates agent() subagents (and optional checkpoint() gates) over registry built-ins\u2014currently Claude, Codex, OpenCode, and pi\u2014ACP backends, plus registered custom agents. Supply exactly one of inline script or absolute scriptPath; path content is read once and snapshotted at admission. ' + (requireProjectDir ? "config and run REQUIRE projectDir (absolute): it is the discovery cwd and selects the project-scoped run store/default execution cwd. " : "run optionally takes projectDir (absolute) to select the project-scoped run store; default is this server's own project. ") + `inspect/await/stop locate the project store from runId and never accept projectDir. Foreground is the default and streams progress; background:true returns a durable runId for bounded action:"await" calls. run and await honor _meta.progressToken with notifications/progress while they block. Pass resumeFromRunId to execute a new run from a prior journal prefix. In hosts that render MCP Apps, every call of this tool shows a live self-updating run-monitor panel and the panel reports phase starts, pauses, and terminal outcomes on its own \u2014 do NOT poll action:"inspect" to check on a run there; prefer a single bounded action:"await". Use action:"inspect" with a runId when you need machine-readable status data: a safe bounded status, log tail, and attributed call previews. Use action:"stop" to durably abort through the run's execution owner; cross-generation control may return a durable pending operationId before final settlement. Add callIndex to cancel only that live agent and keep the run live. forceOwner explicitly authorizes terminating a superseded owner and is forbidden with callIndex. labelGlob remains an output filter. A final whole-run stop makes resume safe immediately; pending control must be retried or observed with inspect/await. Every admitted script is readable at workflow://runs/{runId}/script and results include resource links. Background runs are tracked per project, capped at four active/starting runs, and use headless checkpoint semantics; checkpointReplies continue a checkpoint pause in a new run.`,
     inputSchema: workflowToolInputSchema,
     outputSchema: workflowToolOutputSchema,
     annotations: void 0
@@ -35144,20 +35365,34 @@ function createWorkflowServer(runner, options = {}) {
             `Workflow run "${parsedInput.runId}" is already terminal (${persisted.status}); no agent call is in flight to cancel. Whole-run stop without callIndex is a successful no-op for terminal runs.`
           );
         }
-        if (!manager.getRun(parsedInput.runId)) {
-          throw new ProtocolError(
-            ProtocolErrorCode.InvalidParams,
-            `Workflow run "${parsedInput.runId}" is persisted as ${persisted.status}, but there is nothing live to cancel in this server process.`
-          );
-        }
         let cancellation;
-        try {
-          cancellation = await manager.cancelAgentCall(parsedInput.runId, parsedInput.callIndex);
-        } catch (error51) {
-          throw new ProtocolError(
-            error51 instanceof WorkflowError && error51.code === WorkflowErrorCode.PERSISTENCE_ERROR ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams,
-            error51 instanceof Error ? error51.message : String(error51)
-          );
+        if (!manager.getRun(parsedInput.runId)) {
+          if (!options.runControl) {
+            throw new ProtocolError(
+              ProtocolErrorCode.InvalidParams,
+              `Workflow run "${parsedInput.runId}" is persisted as ${persisted.status}, but there is nothing live to cancel in this server process.`
+            );
+          }
+          const routed = await options.runControl.control(manager, {
+            runId: parsedInput.runId,
+            callIndex: parsedInput.callIndex
+          });
+          if (routed.kind !== "agent") {
+            throw new ProtocolError(
+              ProtocolErrorCode.InternalError,
+              `Workflow agent cancellation returned an invalid routed outcome for runId "${parsedInput.runId}".`
+            );
+          }
+          cancellation = routed.cancellation;
+        } else {
+          try {
+            cancellation = await manager.cancelAgentCall(parsedInput.runId, parsedInput.callIndex);
+          } catch (error51) {
+            throw new ProtocolError(
+              error51 instanceof WorkflowError && error51.code === WorkflowErrorCode.PERSISTENCE_ERROR ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams,
+              error51 instanceof Error ? error51.message : String(error51)
+            );
+          }
         }
         const status2 = manager.inspectRun(parsedInput.runId, inspectionOptions);
         if (!status2) {
@@ -35189,22 +35424,97 @@ function createWorkflowServer(runner, options = {}) {
       if (!alreadyTerminal) {
         const live = manager.getRun(parsedInput.runId);
         if (!live) {
-          throw new ProtocolError(
-            ProtocolErrorCode.InvalidParams,
-            `Workflow run "${parsedInput.runId}" is persisted as ${persisted.status}, but there is nothing live to stop in this server process. Resume it with resumeFromRunId instead.`
-          );
-        }
-        stopped = manager.stop(parsedInput.runId);
-        if (!stopped) {
-          const current = manager.getPersistence().load(parsedInput.runId);
-          alreadyTerminal = current !== null && isAlreadyTerminalForStop(current.status);
-          if (!alreadyTerminal) {
-            throw new ProtocolError(
-              ProtocolErrorCode.InvalidParams,
-              `Workflow run "${parsedInput.runId}" could not be stopped; its persisted status is ${current?.status ?? persisted.status}.`
-            );
+          if (options.runControl) {
+            const routed = await options.runControl.control(manager, {
+              runId: parsedInput.runId,
+              forceOwner: parsedInput.forceOwner
+            });
+            if (routed.kind !== "whole") {
+              throw new ProtocolError(
+                ProtocolErrorCode.InternalError,
+                `Workflow stop returned an invalid routed outcome for runId "${parsedInput.runId}".`
+              );
+            }
+            if (routed.state === "pending") {
+              const pendingStatus = manager.inspectRun(parsedInput.runId, inspectionOptions);
+              if (!pendingStatus) {
+                throw new ProtocolError(
+                  ProtocolErrorCode.InvalidParams,
+                  `No workflow run found for runId "${parsedInput.runId}" in this server's project-scoped run store.`
+                );
+              }
+              if (pendingStatus.status !== "pending" && pendingStatus.status !== "running") {
+                throw new ProtocolError(
+                  ProtocolErrorCode.InternalError,
+                  `Workflow stop intent ${routed.operationId} remained pending but runId "${parsedInput.runId}" is ${pendingStatus.status}.`
+                );
+              }
+              const lineage2 = scriptResources.lineage(parsedInput.runId);
+              const projected2 = addInspectionResourceFields(
+                pendingStatus,
+                {
+                  scriptUri: workflowScriptUri(parsedInput.runId),
+                  lineage: lineage2,
+                  stopped: false,
+                  alreadyTerminal: false,
+                  control: {
+                    state: "pending",
+                    operationId: routed.operationId,
+                    requestedAt: routed.requestedAt,
+                    ...routed.owner === void 0 ? {} : { owner: routed.owner }
+                  }
+                },
+                inspectionRetentionMetadata(manager, parsedInput.runId, pendingStatus)
+              );
+              const result2 = {
+                ...projected2,
+                status: pendingStatus.status
+              };
+              const currentLink2 = scriptResources.links(lineage2).filter((link) => link.uri === workflowScriptUri(parsedInput.runId));
+              return {
+                structuredContent: { ...result2 },
+                content: [{ type: "text", text: formatPendingStopSummary(result2) }, ...currentLink2],
+                isError: false
+              };
+            }
+            stopped = routed.stopped;
+            alreadyTerminal = routed.alreadyTerminal;
+          } else {
+            const cold = manager.stopPersistedRun(parsedInput.runId);
+            stopped = cold.outcome === "stopped";
+            alreadyTerminal = cold.outcome === "already-terminal";
+            if (cold.outcome === "owned-elsewhere") {
+              throw new ProtocolError(
+                ProtocolErrorCode.InvalidParams,
+                `Workflow run "${parsedInput.runId}" is persisted as ${persisted.status} and is owned by another live process; this server has no daemon run-control router.`
+              );
+            }
+            if (cold.outcome === "missing") {
+              throw new ProtocolError(
+                ProtocolErrorCode.InvalidParams,
+                `No workflow run found for runId "${parsedInput.runId}" in this server's project-scoped run store.`
+              );
+            }
           }
         } else {
+          stopped = manager.stop(parsedInput.runId);
+          if (!stopped) {
+            const current = manager.getPersistence().load(parsedInput.runId);
+            alreadyTerminal = current !== null && isAlreadyTerminalForStop(current.status);
+            if (!alreadyTerminal) {
+              const cold = manager.stopPersistedRun(parsedInput.runId);
+              stopped = cold.outcome === "stopped";
+              alreadyTerminal = cold.outcome === "already-terminal";
+            }
+            if (!stopped && !alreadyTerminal) {
+              throw new ProtocolError(
+                ProtocolErrorCode.InvalidParams,
+                `Workflow run "${parsedInput.runId}" could not be stopped; its persisted status is ${current?.status ?? persisted.status}.`
+              );
+            }
+          }
+        }
+        if (stopped) {
           scriptResources.cancelPendingElicitation(parsedInput.runId);
           requireDurableStoppedRun(manager, parsedInput.runId);
         }
@@ -35523,6 +35833,7 @@ ${lines.join("\n")}`,
         concurrency: input.concurrency,
         agentRetries: input.agentRetries,
         agentTimeoutMs: input.agentTimeoutMs,
+        agentIdleTimeoutMs: input.agentIdleTimeoutMs,
         resumeFromRunId: input.resumeFromRunId,
         resumePolicy: input.resumePolicy,
         checkpointReplies: input.checkpointReplies
@@ -35693,24 +36004,24 @@ runId: ${started2.runId}
 }
 
 // ../mcp-server/src/shim/ensure-daemon.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync } from "node:fs";
+import { closeSync, mkdirSync as mkdirSync3, openSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname2 } from "node:path";
 import { spawn } from "node:child_process";
 
 // ../mcp-server/src/daemon/daemon-info.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { createHash as createHash2 } from "node:crypto";
 import {
-  chmodSync,
-  mkdirSync,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  chmodSync as chmodSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
   renameSync as renameSync2,
-  rmSync,
-  writeFileSync
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname, join as join3 } from "node:path";
 import { workflowHomeDir as workflowHomeDir2 } from "@automatalabs/workflows";
 async function probeHealthz(port, timeoutMs = 2e3) {
   try {
@@ -35726,22 +36037,22 @@ async function probeHealthz(port, timeoutMs = 2e3) {
   }
 }
 function daemonsDir() {
-  return join2(workflowHomeDir2(), "daemons");
+  return join3(workflowHomeDir2(), "daemons");
 }
 function daemonInfoPath(fingerprint = envFingerprint()) {
-  return join2(daemonsDir(), `${fingerprint}.json`);
+  return join3(daemonsDir(), `${fingerprint}.json`);
 }
 function daemonLockPath(fingerprint = envFingerprint()) {
-  return join2(daemonsDir(), `${fingerprint}.lock`);
+  return join3(daemonsDir(), `${fingerprint}.lock`);
 }
 function daemonInstancePath(pid) {
-  return join2(daemonsDir(), "instances", `${pid}.json`);
+  return join3(daemonsDir(), "instances", `${pid}.json`);
 }
 function legacyDaemonInfoPath() {
-  return join2(workflowHomeDir2(), "daemon.json");
+  return join3(workflowHomeDir2(), "daemon.json");
 }
 function daemonLogPath() {
-  return join2(workflowHomeDir2(), "logs", "daemon.log");
+  return join3(workflowHomeDir2(), "logs", "daemon.log");
 }
 function pidIsAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -35755,7 +36066,7 @@ function pidIsAlive(pid) {
 }
 function readInfoFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
     if (parsed.name !== DAEMON_NAME || typeof parsed.pid !== "number" || typeof parsed.port !== "number" || typeof parsed.url !== "string" || typeof parsed.version !== "string") {
       return void 0;
     }
@@ -35767,12 +36078,15 @@ function readInfoFile(path) {
 function readDaemonInfo(fingerprint = envFingerprint()) {
   return readInfoFile(daemonInfoPath(fingerprint));
 }
+function readDaemonInstance(pid) {
+  return readInfoFile(daemonInstancePath(pid));
+}
 function writeInfoFile(path, info) {
-  mkdirSync(dirname(path), { recursive: true });
-  const tmp = `${path}.${info.pid}.${randomUUID().slice(0, 8)}.tmp`;
-  writeFileSync(tmp, `${JSON.stringify(info, null, 2)}
+  mkdirSync2(dirname(path), { recursive: true });
+  const tmp = `${path}.${info.pid}.${randomUUID2().slice(0, 8)}.tmp`;
+  writeFileSync2(tmp, `${JSON.stringify(info, null, 2)}
 `, { mode: 384 });
-  chmodSync(tmp, 384);
+  chmodSync2(tmp, 384);
   renameSync2(tmp, path);
 }
 function writeDaemonInfo(info) {
@@ -35784,11 +36098,11 @@ function clearDaemonInfo(pid) {
   const fingerprint = instance?.envFingerprint ?? envFingerprint();
   const current = readDaemonInfo(fingerprint);
   try {
-    if (current !== void 0 && current.pid === pid) rmSync(daemonInfoPath(fingerprint), { force: true });
+    if (current !== void 0 && current.pid === pid) rmSync2(daemonInfoPath(fingerprint), { force: true });
   } catch {
   }
   try {
-    rmSync(daemonInstancePath(pid), { force: true });
+    rmSync2(daemonInstancePath(pid), { force: true });
   } catch {
   }
 }
@@ -35799,20 +36113,20 @@ function isSupersededBy(ownPid, fingerprint = envFingerprint()) {
 function listDaemonInstances() {
   const instances = [];
   const seen = /* @__PURE__ */ new Set();
-  const dir = join2(daemonsDir(), "instances");
+  const dir = join3(daemonsDir(), "instances");
   let files = [];
   try {
-    files = readdirSync2(dir);
+    files = readdirSync3(dir);
   } catch {
     files = [];
   }
   for (const file2 of files) {
     if (!file2.endsWith(".json")) continue;
-    const path = join2(dir, file2);
+    const path = join3(dir, file2);
     const info = readInfoFile(path);
     if (info === void 0 || !pidIsAlive(info.pid)) {
       try {
-        rmSync(path, { force: true });
+        rmSync2(path, { force: true });
       } catch {
       }
       continue;
@@ -35855,23 +36169,23 @@ function compareVersions(a, b) {
 }
 function claimSpawnLock(fingerprint = envFingerprint()) {
   const path = daemonLockPath(fingerprint);
-  mkdirSync(dirname(path), { recursive: true });
-  const lock = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), token: randomUUID() };
+  mkdirSync2(dirname(path), { recursive: true });
+  const lock = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString(), token: randomUUID2() };
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      writeFileSync(path, JSON.stringify(lock), { flag: "wx", mode: 384 });
+      writeFileSync2(path, JSON.stringify(lock), { flag: "wx", mode: 384 });
       return lock;
     } catch (err) {
       if (err.code !== "EEXIST") return null;
       let holder = null;
       try {
-        holder = JSON.parse(readFileSync3(path, "utf-8"));
+        holder = JSON.parse(readFileSync4(path, "utf-8"));
       } catch {
         holder = null;
       }
       if (holder !== null && pidIsAlive(holder.pid)) return null;
       try {
-        rmSync(path, { force: true });
+        rmSync2(path, { force: true });
       } catch {
         return null;
       }
@@ -35882,9 +36196,9 @@ function claimSpawnLock(fingerprint = envFingerprint()) {
 function releaseSpawnLock(lock, fingerprint = envFingerprint()) {
   const path = daemonLockPath(fingerprint);
   try {
-    const holder = JSON.parse(readFileSync3(path, "utf-8"));
+    const holder = JSON.parse(readFileSync4(path, "utf-8"));
     if (holder.token !== lock.token) return;
-    rmSync(path, { force: true });
+    rmSync2(path, { force: true });
   } catch {
   }
 }
@@ -35898,7 +36212,14 @@ async function probeLiveDaemon(fingerprint) {
   if (info === void 0 || !pidIsAlive(info.pid)) return void 0;
   const health = await probeHealthz(info.port);
   if (health === void 0 || health.pid !== info.pid) return void 0;
-  return { info, sessions: health.sessions, activeRuns: health.activeRuns, version: health.version };
+  return {
+    info,
+    sessions: health.sessions,
+    activeRuns: health.activeRuns,
+    inflightRequests: health.inflightRequests ?? 0,
+    controlProtocol: health.controlProtocol === 1 ? 1 : void 0,
+    version: health.version
+  };
 }
 async function waitForCurrentDaemon(fingerprint, timeoutMs) {
   const start = Date.now();
@@ -35924,7 +36245,7 @@ async function stopDaemon(pid, timeoutMs = 5e3) {
 }
 function spawnDetachedDaemon(args) {
   const logPath = daemonLogPath();
-  mkdirSync2(dirname2(logPath), { recursive: true });
+  mkdirSync3(dirname2(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const argv = [args.bundlePath, "--daemon-run"];
   if (args.port !== void 0) argv.push("--port", String(args.port));
@@ -35951,6 +36272,12 @@ async function ensureDaemonRunning(options) {
   };
   const live = await probeLiveDaemon(fingerprint);
   if (live !== void 0 && !isStale(live)) return adopt(live);
+  if (live !== void 0 && live.controlProtocol !== 1 && (live.activeRuns > 0 || live.inflightRequests > 0)) {
+    options.log(
+      `[${DAEMON_NAME}] compatibility drain: temporarily adopting stale daemon pid ${live.info.pid} (v${live.version}, ${live.activeRuns} run(s), ${live.inflightRequests} request(s) in flight) because it predates run-control v1`
+    );
+    return { ...live.info, compatibilityDrain: true };
+  }
   if (live !== void 0) {
     options.log(
       `[${DAEMON_NAME}] superseding stale daemon (pid ${live.info.pid}, ${live.sessions} session(s), ${live.activeRuns} run(s)): version v${live.version} \u2192 v${SERVER_VERSION} \u2014 spawning a successor and repointing discovery`
@@ -35967,6 +36294,12 @@ async function ensureDaemonRunning(options) {
   try {
     const raced = await probeLiveDaemon(fingerprint);
     if (raced !== void 0 && !isStale(raced)) return adopt(raced);
+    if (raced !== void 0 && raced.controlProtocol !== 1 && (raced.activeRuns > 0 || raced.inflightRequests > 0)) {
+      options.log(
+        `[${DAEMON_NAME}] compatibility drain retained under the spawn lock for stale daemon pid ${raced.info.pid}`
+      );
+      return { ...raced.info, compatibilityDrain: true };
+    }
     const superseding = raced !== void 0;
     spawnDaemon({ bundlePath: options.bundlePath, port: options.port, supersede: superseding });
     const info = await waitForCurrentDaemon(fingerprint, SPAWN_HEALTH_TIMEOUT_MS);
@@ -35987,6 +36320,7 @@ async function ensureDaemonRunning(options) {
 }
 
 // ../mcp-server/src/daemon/run-daemon.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { createAcpRunner } from "@automatalabs/workflows";
 
 // ../mcp-server/src/daemon/daemon-lifecycle.ts
@@ -36006,6 +36340,7 @@ function installDaemonLifecycle(options) {
   const reaper = setInterval(() => {
     const daemon = options.daemon;
     const superseded = daemon.isSuperseded();
+    void daemon.processPendingControlIntents?.();
     if (superseded) {
       if (!supersessionAnnounced) {
         supersessionAnnounced = true;
@@ -36013,11 +36348,9 @@ function installDaemonLifecycle(options) {
           `[agentprism-daemon] superseded by a newer daemon; draining \u2014 ${daemon.sessions.size} session(s), ${daemon.activeRunCount()} run(s), ${daemon.inflightRequestCount()} request(s) in flight`
         );
       }
-      if (daemon.activeRunCount() === 0) {
-        const migrated = daemon.evictDrainableSessions();
-        if (migrated.length > 0) {
-          log(`[agentprism-daemon] migrated ${migrated.length} idle session(s) to the successor: ${migrated.join(", ")}`);
-        }
+      const migrated = daemon.evictDrainableSessions();
+      if (migrated.length > 0) {
+        log(`[agentprism-daemon] migrated ${migrated.length} idle session(s) to the successor: ${migrated.join(", ")}`);
       }
     } else {
       supersessionAnnounced = false;
@@ -36026,7 +36359,7 @@ function installDaemonLifecycle(options) {
         log(`[agentprism-daemon] evicted ${evicted.length} idle session(s): ${evicted.join(", ")}`);
       }
     }
-    const busy = daemon.sessions.size > 0 || daemon.activeRunCount() > 0 || daemon.activeReplDrainCount() > 0;
+    const busy = daemon.sessions.size > 0 || daemon.activeRunCount() > 0 || daemon.inflightRequestCount() > 0 || daemon.activeReplDrainCount() > 0;
     if (busy) {
       idleSince = void 0;
       return;
@@ -36069,7 +36402,7 @@ function installDaemonLifecycle(options) {
 
 // ../mcp-server/src/daemon/http-daemon.ts
 import http from "node:http";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../../node_modules/.pnpm/@hono+node-server@1.19.14_hono@4.12.27/node_modules/@hono/node-server/dist/index.mjs
 import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
@@ -37032,16 +37365,16 @@ function validateRequest(headers, boundPort, env = process.env) {
 
 // ../mcp-server/src/daemon/request-state.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
 import { workflowHomeDir as workflowHomeDir3 } from "@automatalabs/workflows";
 function requestStateKeyPath(fingerprint) {
-  return join3(workflowHomeDir3(), "daemons", `${fingerprint}.request-state-key.json`);
+  return join4(workflowHomeDir3(), "daemons", `${fingerprint}.request-state-key.json`);
 }
 function decodeStoredKey(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(path, "utf8"));
+    parsed = JSON.parse(readFileSync5(path, "utf8"));
   } catch (error51) {
     throw new Error(`Unable to read the daemon requestState key at ${path}: ${String(error51)}`);
   }
@@ -37050,18 +37383,18 @@ function decodeStoredKey(path) {
   }
   const key = Buffer.from(parsed.key, "base64");
   if (key.byteLength !== 32) throw new Error(`Invalid daemon requestState key length at ${path}`);
-  chmodSync2(path, 384);
+  chmodSync3(path, 384);
   return key;
 }
 function loadOrCreateRequestStateKey(fingerprint) {
   const path = requestStateKeyPath(fingerprint);
-  mkdirSync3(dirname3(path), { recursive: true });
+  mkdirSync4(dirname3(path), { recursive: true });
   const key = randomBytes2(32);
   const stored = { version: 1, key: key.toString("base64") };
   try {
-    writeFileSync2(path, `${JSON.stringify(stored)}
+    writeFileSync3(path, `${JSON.stringify(stored)}
 `, { flag: "wx", mode: 384 });
-    chmodSync2(path, 384);
+    chmodSync3(path, 384);
     return key;
   } catch (error51) {
     if (error51.code !== "EEXIST") throw error51;
@@ -37069,6 +37402,337 @@ function loadOrCreateRequestStateKey(fingerprint) {
   }
 }
 
+// ../mcp-server/src/daemon/run-control-auth.ts
+import { createHash as createHash3, createHmac, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import { chmodSync as chmodSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname4, join as join5 } from "node:path";
+import { workflowHomeDir as workflowHomeDir4 } from "@automatalabs/workflows";
+var RUN_CONTROL_PATH = "/_agentprism/control/v1/run";
+var RUN_CONTROL_PROTOCOL = 1;
+var RUN_CONTROL_MAX_CLOCK_SKEW_MS = 3e4;
+function runControlKeyPath() {
+  return join5(workflowHomeDir4(), "daemons", "run-control-key.json");
+}
+function decodeStoredKey2(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync6(path, "utf8"));
+  } catch (error51) {
+    throw new Error(`Unable to read the daemon run-control key at ${path}: ${String(error51)}`);
+  }
+  if (parsed.version !== 1 || typeof parsed.key !== "string") {
+    throw new Error(`Invalid daemon run-control key file at ${path}`);
+  }
+  const key = Buffer.from(parsed.key, "base64");
+  if (key.byteLength !== 32) throw new Error(`Invalid daemon run-control key length at ${path}`);
+  chmodSync4(path, 384);
+  return key;
+}
+function loadOrCreateRunControlKey() {
+  const path = runControlKeyPath();
+  mkdirSync5(dirname4(path), { recursive: true });
+  const key = randomBytes3(32);
+  const stored = { version: 1, key: key.toString("base64") };
+  try {
+    writeFileSync4(path, `${JSON.stringify(stored)}
+`, { flag: "wx", mode: 384 });
+    chmodSync4(path, 384);
+    return key;
+  } catch (error51) {
+    if (error51.code !== "EEXIST") throw error51;
+    return decodeStoredKey2(path);
+  }
+}
+function signaturePayload(method, path, timestamp, operationId, body) {
+  const bodyHash = createHash3("sha256").update(body).digest("hex");
+  return `${method.toUpperCase()}
+${path}
+${timestamp}
+${operationId}
+${bodyHash}`;
+}
+function signRunControlRequest(key, method, path, operationId, body, now = Date.now()) {
+  const timestamp = String(now);
+  const signature = createHmac("sha256", key).update(signaturePayload(method, path, timestamp, operationId, body)).digest("hex");
+  return {
+    "x-agentprism-control-timestamp": timestamp,
+    "x-agentprism-control-operation": operationId,
+    "x-agentprism-control-signature": signature
+  };
+}
+function verifyRunControlRequest(key, input) {
+  if (!input.timestamp || !input.operationId || !input.signature) return false;
+  const timestamp = Number(input.timestamp);
+  const now = input.now ?? Date.now();
+  if (!Number.isSafeInteger(timestamp) || Math.abs(now - timestamp) > RUN_CONTROL_MAX_CLOCK_SKEW_MS) return false;
+  if (!/^[0-9a-f]{64}$/i.test(input.signature)) return false;
+  const expected = createHmac("sha256", key).update(signaturePayload(input.method, input.path, input.timestamp, input.operationId, input.body)).digest();
+  const actual = Buffer.from(input.signature, "hex");
+  return actual.byteLength === expected.byteLength && timingSafeEqual(actual, expected);
+}
+
+// ../mcp-server/src/daemon/run-control.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var FORWARD_TIMEOUT_MS = 5e3;
+var FORCE_TERM_WAIT_MS = 5e3;
+var FORCE_KILL_WAIT_MS = 2e3;
+function terminal(status) {
+  return status === "completed" || status === "failed" || status === "aborted";
+}
+function ownerView(owner) {
+  if (!owner) return void 0;
+  return {
+    pid: owner.pid,
+    ...owner.daemon?.instanceId === void 0 ? {} : { instanceId: owner.daemon.instanceId },
+    ...owner.daemon?.version === void 0 ? {} : { version: owner.daemon.version },
+    ...owner.health?.lameDuck === void 0 ? {} : { lameDuck: owner.health.lameDuck },
+    ...owner.health?.activeRuns === void 0 ? {} : { activeRuns: owner.health.activeRuns },
+    ...owner.daemon?.controlProtocol === 1 ? { controlProtocol: 1 } : {}
+  };
+}
+function actionableOwnerMessage(runId, owner, action) {
+  if (!owner) return `Workflow run "${runId}" has no discoverable live execution owner for ${action}.`;
+  const version2 = owner.daemon?.version ? ` v${owner.daemon.version}` : "";
+  const draining = owner.health?.lameDuck ? ", draining" : "";
+  const control = owner.daemon?.controlProtocol === 1 ? "control v1" : "no compatible run-control endpoint";
+  return `Workflow run "${runId}" is executing in daemon pid ${owner.pid}${version2} (${control}${draining}); ${action} could not be delivered.`;
+}
+async function waitForPidExit(pid, timeoutMs, alive) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!alive(pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return !alive(pid);
+}
+var DaemonRunControl = class {
+  constructor(options) {
+    this.options = options;
+    this.log = options.log ?? (() => void 0);
+    this.fetchImpl = options.fetch ?? fetch;
+    this.killProcess = options.kill ?? ((pid, signal) => process.kill(pid, signal));
+    this.isPidAlive = options.isPidAlive ?? pidIsAlive;
+  }
+  options;
+  log;
+  fetchImpl;
+  killProcess;
+  isPidAlive;
+  processingPending;
+  async resolveOwner(manager, runId) {
+    const lease = manager.getPersistence().inspectRunLease?.(runId);
+    if (!lease || !this.isPidAlive(lease.pid)) return void 0;
+    const daemon = readDaemonInstance(lease.pid);
+    if (daemon?.instanceId !== void 0 && lease.ownerId !== void 0 && daemon.instanceId !== lease.ownerId) {
+      return { pid: lease.pid, ownerId: lease.ownerId };
+    }
+    const health = daemon === void 0 ? void 0 : await probeHealthz(daemon.port, 1e3);
+    const verifiedHealth = health !== void 0 && health.pid === lease.pid && (lease.ownerId === void 0 || health.instanceId === void 0 || health.instanceId === lease.ownerId) ? health : void 0;
+    return { pid: lease.pid, ownerId: lease.ownerId, ...daemon ? { daemon } : {}, ...verifiedHealth ? { health: verifiedHealth } : {} };
+  }
+  controlCapable(owner) {
+    return owner.daemon?.controlProtocol === 1 && typeof owner.daemon.controlUrl === "string" && (owner.ownerId === void 0 || owner.daemon.instanceId === owner.ownerId);
+  }
+  async post(owner, request) {
+    const body = JSON.stringify(request);
+    const headers = signRunControlRequest(
+      this.options.key,
+      "POST",
+      RUN_CONTROL_PATH,
+      request.operationId,
+      body
+    );
+    const response = await this.fetchImpl(owner.daemon.controlUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body,
+      signal: AbortSignal.timeout(FORWARD_TIMEOUT_MS)
+    });
+    const value = await response.json();
+    if (!response.ok && value.ok !== false) throw new Error(`run-control owner returned HTTP ${response.status}`);
+    return value;
+  }
+  settledWhole(manager, runId) {
+    const current = manager.getPersistence().load(runId);
+    if (!current || !terminal(current.status)) return void 0;
+    if (current.status === "aborted") {
+      try {
+        requireDurableStoppedRun(manager, runId);
+        return { stopped: true, alreadyTerminal: false };
+      } catch {
+        return { stopped: false, alreadyTerminal: true };
+      }
+    }
+    return { stopped: false, alreadyTerminal: true };
+  }
+  applyWholeIntent(manager, intent) {
+    const before = manager.getPersistence().load(intent.runId);
+    if (!before) return { ok: false, code: "UNKNOWN_RUN", message: `No workflow run found for ${intent.runId}` };
+    if (terminal(before.status)) {
+      acknowledgeWholeStopIntent(manager, intent, this.options.ownInstanceId, "already-terminal");
+      return { ok: true, outcome: "already-terminal" };
+    }
+    const stopped = manager.getRun(intent.runId) ? manager.stop(intent.runId) ? { outcome: "stopped" } : { outcome: "owned-elsewhere" } : manager.stopPersistedRun(intent.runId);
+    if (stopped.outcome === "owned-elsewhere") {
+      return { ok: false, code: "NOT_OWNER", message: `Daemon no longer owns run ${intent.runId}` };
+    }
+    if (stopped.outcome === "missing") {
+      return { ok: false, code: "UNKNOWN_RUN", message: `No workflow run found for ${intent.runId}` };
+    }
+    if (stopped.outcome === "already-terminal") {
+      acknowledgeWholeStopIntent(manager, intent, this.options.ownInstanceId, "already-terminal");
+      return { ok: true, outcome: "already-terminal" };
+    }
+    requireDurableStoppedRun(manager, intent.runId);
+    acknowledgeWholeStopIntent(manager, intent, this.options.ownInstanceId, "stopped");
+    return { ok: true, outcome: "stopped" };
+  }
+  async applyLocal(request) {
+    const context = this.options.projects.storeFor(request.runId);
+    if (!context) return { ok: false, code: "UNKNOWN_RUN", message: `No workflow run found for ${request.runId}` };
+    const manager = context.manager;
+    if (request.action === "stop") {
+      const intent = readWholeStopIntent(manager, request.runId, request.operationId);
+      if (!intent) return { ok: false, code: "INVALID_OPERATION", message: "Durable stop intent is missing" };
+      return this.applyWholeIntent(manager, intent);
+    }
+    if (!manager.getRun(request.runId)) {
+      return { ok: false, code: "NOT_OWNER", message: `Daemon has no live run ${request.runId}` };
+    }
+    try {
+      const cancellation = await manager.cancelAgentCall(request.runId, request.callIndex);
+      return { ok: true, outcome: "agent-cancelled", cancellation };
+    } catch (error51) {
+      return {
+        ok: false,
+        code: "INVALID_OPERATION",
+        message: error51 instanceof Error ? error51.message : String(error51)
+      };
+    }
+  }
+  processPendingIntents() {
+    if (this.processingPending) return this.processingPending;
+    this.processingPending = (async () => {
+      for (const context of this.options.projects.stores()) {
+        for (const intent of listPendingWholeStopIntents(context.manager)) {
+          try {
+            const response = this.applyWholeIntent(context.manager, intent);
+            if (response.ok) {
+              this.log(`[agentprism-daemon] run-control ${intent.operationId} for ${intent.runId}: ${response.outcome}`);
+            }
+          } catch (error51) {
+            this.log(`[agentprism-daemon] run-control ${intent.operationId} for ${intent.runId} failed: ${String(error51)}`);
+          }
+        }
+      }
+    })().finally(() => {
+      this.processingPending = void 0;
+    });
+    return this.processingPending;
+  }
+  async forceOwner(manager, runId, owner) {
+    const lease = manager.getPersistence().inspectRunLease?.(runId);
+    const instance = readDaemonInstance(owner.pid);
+    if (!lease || lease.pid !== owner.pid || !instance || instance.pid !== owner.pid) {
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Refusing force stop for run "${runId}": owner identity changed.`);
+    }
+    if (owner.pid === this.options.ownPid) {
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Refusing force stop for run "${runId}": owner is this daemon.`);
+    }
+    if (lease.ownerId !== void 0 && instance.instanceId !== lease.ownerId) {
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Refusing force stop for run "${runId}": owner instance identity does not match the lease.`);
+    }
+    const current = readDaemonInfo(instance.envFingerprint);
+    if (!current || current.pid === owner.pid || !this.isPidAlive(current.pid)) {
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Refusing force stop for run "${runId}": owner is not a superseded daemon with a live successor.`);
+    }
+    const health = await probeHealthz(instance.port, 1e3);
+    if (lease.ownerId === void 0 && (health?.pid !== owner.pid || health.startedAt !== instance.startedAt)) {
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Refusing force stop for run "${runId}": legacy owner identity could not be revalidated.`);
+    }
+    this.log(
+      `[agentprism-daemon] force-stopping superseded owner pid ${owner.pid} for run ${runId}; ${health?.activeRuns ?? "unknown"} owned run(s) may be interrupted`
+    );
+    try {
+      this.killProcess(owner.pid, "SIGTERM");
+    } catch {
+    }
+    if (!await waitForPidExit(owner.pid, FORCE_TERM_WAIT_MS, this.isPidAlive)) {
+      this.killProcess(owner.pid, "SIGKILL");
+      if (!await waitForPidExit(owner.pid, FORCE_KILL_WAIT_MS, this.isPidAlive)) {
+        throw new ProtocolError(ProtocolErrorCode.InternalError, `Forced owner pid ${owner.pid} did not exit.`);
+      }
+    }
+  }
+  async control(manager, input) {
+    let owner = await this.resolveOwner(manager, input.runId);
+    if (input.callIndex !== void 0) {
+      if (!owner || !this.controlCapable(owner)) {
+        throw new ProtocolError(
+          ProtocolErrorCode.InvalidParams,
+          `${actionableOwnerMessage(input.runId, owner, "agent cancellation")} Per-agent cancellation requires the live control-capable owner.`
+        );
+      }
+      let response;
+      try {
+        response = await this.post(owner, {
+          operationId: randomUUID3(),
+          runId: input.runId,
+          action: "cancel-agent",
+          callIndex: input.callIndex
+        });
+      } catch (error51) {
+        throw new ProtocolError(
+          ProtocolErrorCode.InternalError,
+          `${actionableOwnerMessage(input.runId, owner, "agent cancellation")} ${String(error51)}`
+        );
+      }
+      if (!response.ok || response.outcome !== "agent-cancelled") {
+        throw new ProtocolError(
+          response.ok || response.code === "INTERNAL_ERROR" ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams,
+          response.ok ? "Owner returned an invalid agent-cancellation response." : response.message
+        );
+      }
+      return { kind: "agent", cancellation: response.cancellation };
+    }
+    const intent = createOrReuseWholeStopIntent(manager, input.runId, this.options.ownInstanceId);
+    if (owner && this.controlCapable(owner)) {
+      try {
+        await this.post(owner, { operationId: intent.operationId, runId: input.runId, action: "stop" });
+      } catch (error51) {
+        this.log(`[agentprism-daemon] run-control ${intent.operationId} forwarding to pid ${owner.pid} failed: ${String(error51)}`);
+      }
+      const settled = this.settledWhole(manager, input.runId);
+      if (settled) return { kind: "whole", state: "settled", ...settled };
+      owner = await this.resolveOwner(manager, input.runId);
+    }
+    if (input.forceOwner && owner) {
+      await this.forceOwner(manager, input.runId, owner);
+      owner = await this.resolveOwner(manager, input.runId);
+    }
+    if (!owner) {
+      const result = manager.stopPersistedRun(input.runId);
+      if (result.outcome === "stopped") {
+        requireDurableStoppedRun(manager, input.runId);
+        acknowledgeWholeStopIntent(manager, intent, this.options.ownInstanceId, "stopped");
+      } else if (result.outcome === "already-terminal") {
+        acknowledgeWholeStopIntent(manager, intent, this.options.ownInstanceId, "already-terminal");
+      } else if (result.outcome === "owned-elsewhere") {
+        owner = await this.resolveOwner(manager, input.runId);
+      }
+      const settled = this.settledWhole(manager, input.runId);
+      if (settled) return { kind: "whole", state: "settled", ...settled };
+    }
+    return {
+      kind: "whole",
+      state: "pending",
+      operationId: intent.operationId,
+      requestedAt: intent.requestedAt,
+      owner: ownerView(owner)
+    };
+  }
+};
+
 // ../mcp-server/src/daemon/session-registry.ts
 var SessionRegistry = class {
   sessions = /* @__PURE__ */ new Map();
@@ -37206,6 +37870,7 @@ function writeJsonRpcError(res, status, message, code = -32e3) {
   res.end(JSON.stringify({ jsonrpc: "2.0", error: { code, message }, id: null }));
 }
 var MAX_MCP_BODY_BYTES = 4 * 1024 * 1024;
+var MAX_CONTROL_BODY_BYTES = 64 * 1024;
 var BODY_REJECTED = /* @__PURE__ */ Symbol("body-rejected");
 async function readMcpJsonBody(req, res) {
   if (req.method !== "POST") return void 0;
@@ -37233,17 +37898,103 @@ async function readMcpJsonBody(req, res) {
     return BODY_REJECTED;
   }
 }
+function controlHeader(req, name) {
+  const value = req.headers[name];
+  return Array.isArray(value) ? value[0] : value;
+}
+function writeControlResponse(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function isInternalRunControlRequest(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const row = value;
+  const keys = Object.keys(row).sort();
+  if (typeof row.operationId !== "string" || !/^[0-9a-f-]{36}$/i.test(row.operationId) || typeof row.runId !== "string" || !/^[a-z0-9]+-[a-z0-9]+$/.test(row.runId)) return false;
+  if (row.action === "stop") {
+    return keys.join(",") === "action,operationId,runId";
+  }
+  return row.action === "cancel-agent" && Number.isSafeInteger(row.callIndex) && row.callIndex >= 0 && keys.join(",") === "action,callIndex,operationId,runId";
+}
+async function handleRunControlRequest(req, res, key, runControl) {
+  if (req.method !== "POST") {
+    writeControlResponse(res, 405, { ok: false, code: "INVALID_REQUEST", message: "Method Not Allowed" });
+    return;
+  }
+  const contentType = controlHeader(req, "content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") {
+    writeControlResponse(res, 415, { ok: false, code: "INVALID_REQUEST", message: "Content-Type must be application/json" });
+    return;
+  }
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.byteLength;
+    if (bytes > MAX_CONTROL_BODY_BYTES) {
+      writeControlResponse(res, 413, { ok: false, code: "INVALID_REQUEST", message: "Run-control body exceeds 64 KiB" });
+      return;
+    }
+    chunks.push(buffer);
+  }
+  const body = Buffer.concat(chunks).toString("utf8");
+  const operationId = controlHeader(req, "x-agentprism-control-operation");
+  if (!verifyRunControlRequest(key, {
+    method: req.method,
+    path: RUN_CONTROL_PATH,
+    body,
+    timestamp: controlHeader(req, "x-agentprism-control-timestamp"),
+    operationId,
+    signature: controlHeader(req, "x-agentprism-control-signature")
+  })) {
+    writeControlResponse(res, 401, { ok: false, code: "UNAUTHORIZED", message: "Invalid run-control signature" });
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    writeControlResponse(res, 400, { ok: false, code: "INVALID_REQUEST", message: "Invalid JSON" });
+    return;
+  }
+  if (!isInternalRunControlRequest(parsed) || parsed.operationId !== operationId) {
+    writeControlResponse(res, 400, { ok: false, code: "INVALID_REQUEST", message: "Invalid run-control request" });
+    return;
+  }
+  let response;
+  try {
+    response = await runControl.applyLocal(parsed);
+  } catch (error51) {
+    writeControlResponse(res, 500, {
+      ok: false,
+      code: "INTERNAL_ERROR",
+      message: error51 instanceof Error ? error51.message : String(error51)
+    });
+    return;
+  }
+  const status = response.ok ? 200 : response.code === "UNKNOWN_RUN" ? 404 : response.code === "NOT_OWNER" ? 409 : response.code === "INTERNAL_ERROR" ? 500 : 400;
+  writeControlResponse(res, status, response);
+}
 async function createDaemon(options) {
   const host = options.host ?? "127.0.0.1";
   const env = options.env ?? process.env;
   const log = options.log ?? ((line) => console.error(line));
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const ownPid = options.ownPid ?? process.pid;
+  const ownInstanceId = options.ownInstanceId ?? randomUUID4();
   const version2 = options.version ?? SERVER_VERSION;
   const isSuperseded = options.isSuperseded ?? (() => isSupersededBy(ownPid));
   const familyFingerprint = envFingerprint(env);
   const sessions = new SessionRegistry();
-  const projects = new WorkflowProjectRegistry(options.runner);
+  const projects = new WorkflowProjectRegistry(options.runner, { leaseOwnerId: ownInstanceId });
+  const runControlKey = loadOrCreateRunControlKey();
+  const runControl = new DaemonRunControl({
+    projects,
+    ownPid,
+    ownInstanceId,
+    key: runControlKey,
+    log
+  });
   const replDrainBoundMs = options.replDrainBoundMs ?? options.sessionTtlMs ?? REPL_DRAIN_BOUND_MS;
   const replPresence = new ReplPresenceLedger(replDrainBoundMs);
   sessions.onConnectionOpened = (sessionId) => replPresence.reconnect(sessionId);
@@ -37264,7 +38015,7 @@ async function createDaemon(options) {
   };
   modernHandler = createMcpHandler(
     () => {
-      const clientId = `modern:${randomUUID2()}`;
+      const clientId = `modern:${randomUUID4()}`;
       return createWorkflowServer(options.runner, {
         projects,
         requireProjectDir: true,
@@ -37276,7 +38027,8 @@ async function createDaemon(options) {
         protocolEra: "modern",
         requestStateCodec,
         disconnectReplClientOnClose: true,
-        modernNotifier
+        modernNotifier,
+        runControl
       });
     },
     {
@@ -37332,7 +38084,7 @@ async function createDaemon(options) {
       return;
     }
     const transport = new NodeStreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID2(),
+      sessionIdGenerator: () => randomUUID4(),
       eventStore: new BoundedEventStore(),
       onsessioninitialized: (sid) => {
         sessions.add({
@@ -37354,7 +38106,8 @@ async function createDaemon(options) {
       replPresence,
       replClientId: () => transport.sessionId,
       replDrainBoundMs,
-      replEvalBreakChannel: options.evalBreakChannel
+      replEvalBreakChannel: options.evalBreakChannel,
+      runControl
     });
     await server.connect(transport);
     const protocolOnClose = transport.onclose;
@@ -37381,6 +38134,10 @@ async function createDaemon(options) {
         return;
       }
       const url2 = new URL(req.url ?? "/", `http://${host}:${boundPort}`);
+      if (url2.pathname === RUN_CONTROL_PATH) {
+        await handleRunControlRequest(req, res, runControlKey, runControl);
+        return;
+      }
       if (url2.pathname === HEALTHZ_PATH && req.method === "GET") {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(
@@ -37394,6 +38151,8 @@ async function createDaemon(options) {
             activeRuns: projects.activeRunCount(),
             envFingerprint: familyFingerprint,
             projects: projects.snapshot(),
+            instanceId: ownInstanceId,
+            controlProtocol: RUN_CONTROL_PROTOCOL,
             lameDuck: isSuperseded(),
             inflightRequests: sessions.inflightCount() + modernInflight
           })
@@ -37426,6 +38185,8 @@ async function createDaemon(options) {
     port: boundPort,
     url: `http://${host}:${boundPort}${MCP_ENDPOINT_PATH}`,
     startedAt,
+    instanceId: ownInstanceId,
+    controlUrl: `http://${host}:${boundPort}${RUN_CONTROL_PATH}`,
     sessions,
     projects,
     activeRunCount: () => projects.activeRunCount(),
@@ -37433,6 +38194,7 @@ async function createDaemon(options) {
     inflightRequestCount: () => sessions.inflightCount() + modernInflight,
     isSuperseded,
     evictDrainableSessions: () => sessions.evictDrainable((sessionId) => replPresence.sessionHasBusyWorkspace(sessionId)),
+    processPendingControlIntents: () => runControl.processPendingIntents(),
     async close() {
       const closed = new Promise((resolvePromise) => {
         httpServer.close(() => resolvePromise());
@@ -37470,6 +38232,7 @@ async function runDaemon(options = {}) {
   const log = (line) => console.error(line);
   const runner = createAcpRunner();
   const supersede = options.supersede ?? false;
+  const instanceId = randomUUID5();
   let daemon;
   const sessionTtlMs = envInt(SESSION_IDLE_TTL_ENV, SESSION_IDLE_TTL_MS);
   const replDrainBoundMs = envInt(REPL_DRAIN_BOUND_ENV, REPL_DRAIN_BOUND_MS);
@@ -37479,7 +38242,7 @@ async function runDaemon(options = {}) {
     return `port ${port} is still held by ${holder.legacy ? "a legacy " : ""}daemon pid ${holder.info.pid} (v${holder.info.version}, started ${holder.info.startedAt})`;
   };
   const evalBreakChannel = createEvalBreakChannel2();
-  const daemonOptions = { runner, log, replDrainBoundMs, evalBreakChannel };
+  const daemonOptions = { runner, log, replDrainBoundMs, evalBreakChannel, ownInstanceId: instanceId };
   if (supersede) {
     let port = options.port ?? 0;
     try {
@@ -37513,6 +38276,9 @@ async function runDaemon(options = {}) {
     url: daemon.url,
     startedAt: daemon.startedAt,
     envFingerprint: envFingerprint(),
+    instanceId: daemon.instanceId,
+    controlUrl: daemon.controlUrl,
+    controlProtocol: 1,
     ...await evalBreakChannel.breakUrl().then((url2) => ({ replBreakUrl: url2 })).catch(() => ({}))
   });
   installDaemonLifecycle({
@@ -37575,7 +38341,9 @@ function formatInstance(instance, currentPid) {
     `${DAEMON_NAME} v${health?.version ?? info.version}`,
     `  pid:         ${info.pid}`,
     `  url:         ${info.url}`,
-    `  role:        ${role}`
+    `  role:        ${role}`,
+    `  instance:    ${health?.instanceId ?? info.instanceId ?? "legacy/unknown"}`,
+    `  run control: ${health?.controlProtocol === 1 || info.controlProtocol === 1 ? "v1" : "unavailable"}`
   ];
   if (health === void 0) {
     lines.push("  health:      not responding (pid alive, /healthz unreachable)");
@@ -37673,7 +38441,7 @@ async function runDaemonCommand(args, options) {
       const count = Number.isFinite(lines) && lines > 0 ? lines : 100;
       let content;
       try {
-        content = readFileSync5(daemonLogPath(), "utf-8");
+        content = readFileSync7(daemonLogPath(), "utf-8");
       } catch {
         console.log(`no daemon log at ${daemonLogPath()}`);
         return 0;
@@ -44640,24 +45408,24 @@ var require_compile2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     }
   }
   exports.compileSchema = compileSchema;
-  function resolveRef2(root, baseId, ref) {
+  function resolveRef2(root2, baseId, ref) {
     var _a3;
     ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
-    const schOrFunc = root.refs[ref];
+    const schOrFunc = root2.refs[ref];
     if (schOrFunc) return schOrFunc;
-    let _sch = resolve.call(this, root, ref);
+    let _sch = resolve.call(this, root2, ref);
     if (_sch === void 0) {
-      const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
+      const schema = (_a3 = root2.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
       const { schemaId } = this.opts;
       if (schema) _sch = new SchemaEnv({
         schema,
         schemaId,
-        root,
+        root: root2,
         baseId
       });
     }
     if (_sch === void 0) return;
-    return root.refs[ref] = inlineOrCompile.call(this, _sch);
+    return root2.refs[ref] = inlineOrCompile.call(this, _sch);
   }
   exports.resolveRef = resolveRef2;
   function inlineOrCompile(sch) {
@@ -44671,20 +45439,20 @@ var require_compile2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve(root, ref) {
+  function resolve(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string") ref = sch;
-    return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
+    return sch || this.schemas[ref] || resolveSchema.call(this, root2, ref);
   }
-  function resolveSchema(root, ref) {
+  function resolveSchema(root2, ref) {
     const p = this.opts.uriResolver.parse(ref);
     const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
-    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
-    if (Object.keys(root.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root);
+    let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root2.baseId, void 0);
+    if (Object.keys(root2.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root2);
     const id = (0, resolve_1.normalizeId)(refPath);
     const schOrRef = this.refs[id] || this.schemas[id];
     if (typeof schOrRef == "string") {
-      const sch = resolveSchema.call(this, root, schOrRef);
+      const sch = resolveSchema.call(this, root2, schOrRef);
       if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") return;
       return getJsonPointer.call(this, p, sch);
     }
@@ -44698,7 +45466,7 @@ var require_compile2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       return new SchemaEnv({
         schema,
         schemaId,
-        root,
+        root: root2,
         baseId
       });
     }
@@ -44712,7 +45480,7 @@ var require_compile2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     "dependencies",
     "definitions"
   ]);
-  function getJsonPointer(parsedRef, { baseId, schema, root }) {
+  function getJsonPointer(parsedRef, { baseId, schema, root: root2 }) {
     var _a3;
     if (((_a3 = parsedRef.fragment) === null || _a3 === void 0 ? void 0 : _a3[0]) !== "/") return;
     for (const part of parsedRef.fragment.slice(1).split("/")) {
@@ -44726,13 +45494,13 @@ var require_compile2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     let env;
     if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
       const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
-      env = resolveSchema.call(this, root, $ref);
+      env = resolveSchema.call(this, root2, $ref);
     }
     const { schemaId } = this.opts;
     env = env || new SchemaEnv({
       schema,
       schemaId,
-      root,
+      root: root2,
       baseId
     });
     if (env.schema !== env.root.schema) return env;
@@ -45597,11 +46365,11 @@ var require_core$32 = /* @__PURE__ */ __commonJSMin2(((exports) => {
       while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") keyRef = sch;
       if (sch === void 0) {
         const { schemaId } = this.opts;
-        const root = new compile_1.SchemaEnv({
+        const root2 = new compile_1.SchemaEnv({
           schema: {},
           schemaId
         });
-        sch = compile_1.resolveSchema.call(this, root, keyRef);
+        sch = compile_1.resolveSchema.call(this, root2, keyRef);
         if (!sch) return;
         this.refs[keyRef] = sch;
       }
@@ -45906,16 +46674,16 @@ var require_ref2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     code(cxt) {
       const { gen, schema: $ref, it } = cxt;
       const { baseId, schemaEnv: env, validateName, opts, self } = it;
-      const { root } = env;
-      if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef();
-      const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
+      const { root: root2 } = env;
+      if (($ref === "#" || $ref === "#/") && baseId === root2.baseId) return callRootRef();
+      const schOrEnv = compile_1.resolveRef.call(self, root2, baseId, $ref);
       if (schOrEnv === void 0) throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
       if (schOrEnv instanceof compile_1.SchemaEnv) return callValidate(schOrEnv);
       return inlineRefSchema(schOrEnv);
       function callRootRef() {
-        if (env === root) return callRef(cxt, validateName, env, env.$async);
-        const rootName = gen.scopeValue("root", { ref: root });
-        return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
+        if (env === root2) return callRef(cxt, validateName, env, env.$async);
+        const rootName = gen.scopeValue("root", { ref: root2 });
+        return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root2, root2.$async);
       }
       function callValidate(sch) {
         callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
@@ -47630,12 +48398,12 @@ var require_dynamicAnchor2 = /* @__PURE__ */ __commonJSMin2(((exports) => {
   exports.dynamicAnchor = dynamicAnchor;
   function _getValidate(cxt) {
     const { schemaEnv, schema, self } = cxt.it;
-    const { root, baseId, localRefs, meta: meta3 } = schemaEnv.root;
+    const { root: root2, baseId, localRefs, meta: meta3 } = schemaEnv.root;
     const { schemaId } = self.opts;
     const sch = new compile_1.SchemaEnv({
       schema,
       schemaId,
-      root,
+      root: root2,
       baseId,
       localRefs,
       meta: meta3
@@ -49032,8 +49800,8 @@ async function random(size) {
   const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
   let result = "";
   while (result.length < size) {
-    const randomBytes3 = await getRandomValues(size - result.length);
-    for (const randomByte of randomBytes3) {
+    const randomBytes4 = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes4) {
       if (randomByte < evenDistCutoff) {
         result += mask[randomByte % mask.length];
       }
@@ -51157,6 +51925,7 @@ async function runShim(options) {
   const info = await ensureDaemonRunning({ bundlePath: options.bundlePath, port: options.port, log });
   let replBreakUrl = info.replBreakUrl;
   let exiting = false;
+  let compatibilityDrainTimer;
   function fireOutOfBandBreak(projectDir) {
     if (typeof projectDir !== "string" || replBreakUrl === void 0) return;
     let key;
@@ -51277,6 +52046,27 @@ async function runShim(options) {
     log(`[${DAEMON_NAME} shim] fatal: ${reason}`);
     void shutdown(1);
   }
+  function armCompatibilityDrain(candidate) {
+    if (compatibilityDrainTimer !== void 0) {
+      clearInterval(compatibilityDrainTimer);
+      compatibilityDrainTimer = void 0;
+    }
+    if (candidate.compatibilityDrain !== true) return;
+    compatibilityDrainTimer = setInterval(() => {
+      void (async () => {
+        if (exiting || reinitializing) return;
+        const health = await probeHealthz(candidate.port, 1e3);
+        if (health === void 0 || health.pid !== candidate.pid || health.activeRuns === 0 && (health.inflightRequests ?? 0) === 0) {
+          if (compatibilityDrainTimer !== void 0) clearInterval(compatibilityDrainTimer);
+          compatibilityDrainTimer = void 0;
+          await startReinitialize(
+            health === void 0 ? "compatibility-drain predecessor became unavailable" : "compatibility-drain predecessor became idle"
+          );
+        }
+      })().catch((error51) => log(`[${DAEMON_NAME} shim] compatibility-drain monitor failed: ${String(error51)}`));
+    }, 1e3);
+    compatibilityDrainTimer.unref();
+  }
   async function startReinitialize(reason) {
     if (reinitializing || exiting) return;
     if (!recoveryAllowed()) {
@@ -51292,6 +52082,7 @@ async function runShim(options) {
       retireTransport(http2, reason);
       const fresh = await ensureDaemonRunning({ bundlePath: options.bundlePath, port: options.port, log });
       replBreakUrl = fresh.replBreakUrl;
+      armCompatibilityDrain(fresh);
       http2 = makeHttpTransport(fresh.url);
       await http2.start();
       if (cachedInitialize === void 0) {
@@ -51383,6 +52174,8 @@ async function runShim(options) {
   async function shutdown(code) {
     if (exiting) return;
     exiting = true;
+    if (compatibilityDrainTimer !== void 0) clearInterval(compatibilityDrainTimer);
+    compatibilityDrainTimer = void 0;
     await http2.terminateSession().catch(() => void 0);
     await http2.close().catch(() => void 0);
     await stdio.close().catch(() => void 0);
@@ -51391,6 +52184,7 @@ async function runShim(options) {
   stdio.onclose = () => void shutdown(0);
   process.once("SIGINT", () => void shutdown(0));
   process.once("SIGTERM", () => void shutdown(0));
+  armCompatibilityDrain(info);
   await http2.start();
   await stdio.start();
 }