@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-subagents/src/extension/public-execution.js

@@ -1,4 +1,17 @@
 import { normalizeWorktreeBaseRef } from "../runs/shared/worktree.js";
+const RAW_SCRIPT_FORMS = "workflow: true or a workflow script path";
+const REMOVED_WORKFLOW_SCRIPT = 'workflowScript was removed; write the script in one ```js workflow block in this reply and call subagent({ workflow: true }), or pass a script file as workflow: "./path/to/script.js".';
+const REMOVED_WORKFLOW_SCRIPT_PATH = `workflowScriptPath was removed; pass the script file as workflow: "./path/to/script.js" (a workflow value containing '/' is a path).`;
+export function isWorkflowScriptPath(workflow) {
+  return workflow.includes("/") || workflow.includes("\\");
+}
+export function removedModelWorkflowFieldError(params) {
+  if (Object.hasOwn(params, "workflowScript"))
+    return REMOVED_WORKFLOW_SCRIPT;
+  if (Object.hasOwn(params, "workflowScriptPath"))
+    return REMOVED_WORKFLOW_SCRIPT_PATH;
+  return;
+}
 export function validateWorkflowCapacityOverrides(params) {
   for (const [name, value] of [
     ["globalConcurrencyLimit", params.globalConcurrencyLimit],
@@ -8,7 +21,7 @@ export function validateWorkflowCapacityOverrides(params) {
       return `${name} must be a positive safe integer.`;
   }
 }
-export function normalizePublicSubagentExecution(params) {
+export function normalizePublicSubagentExecution(params, options = {}) {
   for (const field of ["resource", "resourceProvenance", "workflowResource", "workflowResourceProvenance", "workflowResourcePermit", "resourcePermit", "permit"]) {
     if (Object.hasOwn(params, field) && params[field] !== undefined) {
       return { ok: false, error: "Public execution does not accept workflow resource provenance or permit fields.", mode: params.action === undefined ? "workflow" : "management" };
@@ -21,19 +34,23 @@ export function normalizePublicSubagentExecution(params) {
       return { ok: false, error: error instanceof Error ? error.message : String(error), mode: params.action === undefined ? "workflow" : "management" };
     }
   }
-  if (params.workflowScript !== undefined && params.workflowScriptPath !== undefined) {
-    return { ok: false, error: "workflowScript and workflowScriptPath are mutually exclusive.", mode: "workflow" };
+  if (params.workflowScriptPath !== undefined) {
+    return { ok: false, error: REMOVED_WORKFLOW_SCRIPT_PATH, mode: params.action === undefined ? "workflow" : "management" };
   }
-  const hasNamedWorkflow = params.workflow !== undefined;
-  if (hasNamedWorkflow && (typeof params.workflow !== "string" || !params.workflow.trim())) {
-    return { ok: false, error: "workflow must be a non-empty named workflow resource.", mode: "workflow" };
+  if (params.workflow === "true")
+    params = { ...params, workflow: true };
+  const workflow = params.workflow;
+  if (workflow !== undefined && workflow !== true && (typeof workflow !== "string" || !workflow.trim())) {
+    return { ok: false, error: "workflow must be true (the ```js workflow block in this reply), a script path containing '/', or a named workflow resource.", mode: "workflow" };
   }
-  if (hasNamedWorkflow && (params.workflowScript !== undefined || params.workflowScriptPath !== undefined)) {
-    return { ok: false, error: "workflow is mutually exclusive with workflowScript and workflowScriptPath.", mode: "workflow" };
+  const hasNamedWorkflow = typeof workflow === "string" && !isWorkflowScriptPath(workflow);
+  if (workflow !== undefined && params.workflowScript !== undefined) {
+    return { ok: false, error: "workflow cannot be combined with an internal workflowScript.", mode: "workflow" };
   }
-  const hasWorkflowInput = params.workflowScript !== undefined || params.workflowScriptPath !== undefined || hasNamedWorkflow;
+  const hasRawScript = params.workflowScript !== undefined || workflow !== undefined && !hasNamedWorkflow;
+  const hasWorkflowInput = hasRawScript || hasNamedWorkflow;
   if (!hasWorkflowInput && params.args !== undefined) {
-    return { ok: false, error: "args requires workflow, workflowScript, or workflowScriptPath.", mode: "workflow" };
+    return { ok: false, error: "args requires workflow.", mode: "workflow" };
   }
   const hasCapacityOverride = params.globalConcurrencyLimit !== undefined || params.maxSubagentSpawnsPerRun !== undefined;
   if (hasCapacityOverride) {
@@ -41,17 +58,17 @@ export function normalizePublicSubagentExecution(params) {
     if (capacityOverrideError)
       return { ok: false, error: capacityOverrideError, mode: params.action === undefined ? "workflow" : "management" };
     const validatesSpawnBudget = typeof params.action === "string" && params.action.trim() === "validate" && params.globalConcurrencyLimit === undefined && params.maxSubagentSpawnsPerRun !== undefined;
-    if (params.action !== undefined && !validatesSpawnBudget || hasNamedWorkflow || params.workflowScript === undefined && params.workflowScriptPath === undefined) {
-      return { ok: false, error: "Workflow capacity overrides are only supported on top-level workflowScript or workflowScriptPath calls; validate accepts maxSubagentSpawnsPerRun for static budget checks.", mode: params.action === undefined ? "workflow" : "management" };
+    if (params.action !== undefined && !validatesSpawnBudget || !hasRawScript) {
+      return { ok: false, error: `Workflow capacity overrides are only supported on top-level ${RAW_SCRIPT_FORMS} calls; validate accepts maxSubagentSpawnsPerRun for static budget checks.`, mode: params.action === undefined ? "workflow" : "management" };
     }
   }
   if (params.preflight !== undefined && !hasWorkflowInput) {
-    return { ok: false, error: "preflight requires workflowScript or workflowScriptPath.", mode: params.action === undefined ? "workflow" : "management" };
+    return { ok: false, error: `preflight requires ${RAW_SCRIPT_FORMS}.`, mode: params.action === undefined ? "workflow" : "management" };
   }
-  if (params.preflight !== undefined && hasNamedWorkflow && params.workflowScript === undefined && params.workflowScriptPath === undefined) {
+  if (params.preflight !== undefined && hasNamedWorkflow) {
     return { ok: false, error: "preflight is not supported with named workflow resources.", mode: "workflow" };
   }
-  const hasValidWorkflowInput = typeof params.workflowScript === "string" && Boolean(params.workflowScript.trim()) || typeof params.workflowScriptPath === "string" && Boolean(params.workflowScriptPath.trim()) || typeof params.workflow === "string" && Boolean(params.workflow.trim());
+  const hasValidWorkflowInput = workflow !== undefined || typeof params.workflowScript === "string" && Boolean(params.workflowScript.trim());
   if (params.isolation !== undefined) {
     if (params.isolation !== "none" && params.isolation !== "worktree") {
       return { ok: false, error: "isolation must be 'none' or 'worktree'.", mode: hasWorkflowInput ? "workflow" : "management" };
@@ -71,7 +88,7 @@ export function normalizePublicSubagentExecution(params) {
   }
   const action = params.action;
   if (action !== undefined && (typeof action !== "string" || !action.trim())) {
-    return { ok: false, error: "action must be a non-empty management/control action, or omit action and use workflowScript.", mode: "management" };
+    return { ok: false, error: "action must be a non-empty management/control action, or omit action and use workflow.", mode: "management" };
   }
   const normalizedAction = typeof action === "string" ? action.trim() : undefined;
   if (params.baseRef !== undefined && normalizedAction !== undefined && normalizedAction !== "resume" && normalizedAction !== "schedule.create") {
@@ -81,55 +98,68 @@ export function normalizePublicSubagentExecution(params) {
     return { ok: false, error: "Named workflow resource execution must omit action.", mode: "management" };
   }
   if (params.clarify !== undefined) {
-    return { ok: false, error: "Public workflowScript execution does not support clarify UI.", mode: "workflow" };
+    return { ok: false, error: "Public workflow execution does not support clarify UI.", mode: "workflow" };
   }
   if (params.chainName !== undefined) {
-    return { ok: false, error: "Durable chain management was removed; use workflowScript or /prompt-workflow for repeatable workflows.", mode: "management" };
+    return { ok: false, error: "Durable chain management was removed; use a workflow script or /prompt-workflow for repeatable workflows.", mode: "management" };
   }
   if (params.config && typeof params.config === "object" && !Array.isArray(params.config) && Object.prototype.hasOwnProperty.call(params.config, "steps")) {
-    return { ok: false, error: "Durable chain definitions were removed; use workflowScript or /prompt-workflow for repeatable workflows.", mode: "management" };
+    return { ok: false, error: "Durable chain definitions were removed; use a workflow script or /prompt-workflow for repeatable workflows.", mode: "management" };
   }
   if (params.resume !== undefined) {
-    return { ok: false, error: "Top-level resume execution is not available. Put resume on a workflowScript runs.run/runs.all item.", mode: "workflow" };
+    return { ok: false, error: "Top-level resume execution is not available. Put resume on a workflow script runs.run/runs.all item.", mode: "workflow" };
   }
-  const hasLegacyOrchestration = params.tasks !== undefined || params.chain !== undefined || params.parallel !== undefined || params.concurrency !== undefined || params.chainDir !== undefined;
+  const legacyOrchestrationAction = ["parallel", "tasks", "chain"].includes(normalizedAction?.toLowerCase() ?? "");
+  const hasStructuredWorkflow = options.structuredWorkflows === true && !legacyOrchestrationAction && (params.tasks !== undefined || params.chain !== undefined);
+  const hasLegacyOrchestration = !hasStructuredWorkflow && (params.tasks !== undefined || params.chain !== undefined) || params.parallel !== undefined || params.concurrency !== undefined || params.chainDir !== undefined;
   if (hasLegacyOrchestration) {
-    return { ok: false, error: "Legacy top-level chain and parallel inputs were removed; use workflowScript.", mode: normalizedAction ? "management" : "workflow" };
+    return { ok: false, error: `Legacy top-level chain and parallel inputs were removed; use a workflow script (${RAW_SCRIPT_FORMS}).`, mode: normalizedAction ? "management" : "workflow" };
+  }
+  if (hasStructuredWorkflow) {
+    if (params.tasks !== undefined && params.chain !== undefined) {
+      return { ok: false, error: "Pass either tasks or chain, not both.", mode: "workflow" };
+    }
+    const field = params.tasks !== undefined ? "tasks" : "chain";
+    for (const [name, value] of [["action", params.action], ["agent", params.agent], ["step", params.step]]) {
+      if (value !== undefined)
+        return { ok: false, error: `${field} cannot be combined with ${name}.`, mode: normalizedAction ? "management" : "workflow" };
+    }
+    return { ok: true, params };
   }
   if (normalizedAction !== undefined) {
     const legacyAction = normalizedAction.toLowerCase();
     if (legacyAction === "append-step") {
-      return { ok: false, error: "Legacy append-step control was removed from the public subagent tool; use current workflowScript orchestration.", mode: "management" };
+      return { ok: false, error: "Legacy append-step control was removed from the public subagent tool; use workflow script orchestration.", mode: "management" };
     }
     if (legacyAction === "approve-checkpoint" || legacyAction === "reject-checkpoint") {
-      return { ok: false, error: "Legacy checkpoint approval controls were removed from the public subagent tool; use current workflowScript orchestration.", mode: "management" };
+      return { ok: false, error: "Legacy checkpoint approval controls were removed from the public subagent tool; use workflow script orchestration.", mode: "management" };
     }
     if (legacyAction === "single") {
       return { ok: false, error: "action='single' is not supported. Omit action and pass { agent, task } for one child.", mode: "workflow" };
     }
     if (legacyAction === "parallel" || legacyAction === "tasks" || legacyAction === "chain") {
-      return { ok: false, error: "Legacy top-level chain and parallel inputs were removed; use workflowScript.", mode: "workflow" };
+      return { ok: false, error: `Legacy top-level chain and parallel inputs were removed; use a workflow script (${RAW_SCRIPT_FORMS}).`, mode: "workflow" };
     }
     if (normalizedAction === "validate") {
       if (params.agent !== undefined || params.task !== undefined || params.step !== undefined) {
-        return { ok: false, error: "validate requires workflowScript or workflowScriptPath and does not accept direct agent, task, or step execution fields.", mode: "management" };
+        return { ok: false, error: `validate requires ${RAW_SCRIPT_FORMS} and does not accept direct agent, task, or step execution fields.`, mode: "management" };
       }
       if (!hasValidWorkflowInput) {
-        return { ok: false, error: "validate requires a non-empty workflowScript or workflowScriptPath.", mode: "management" };
+        return { ok: false, error: `validate requires ${RAW_SCRIPT_FORMS}.`, mode: "management" };
       }
       return { ok: true, params: { ...params, action: normalizedAction } };
     }
     if (normalizedAction === "schedule.create") {
       if (params.agent !== undefined || params.task !== undefined || params.step !== undefined) {
-        return { ok: false, error: "schedule.create requires workflowScript or workflowScriptPath and does not accept direct agent, task, or step execution fields.", mode: "management" };
+        return { ok: false, error: `schedule.create requires ${RAW_SCRIPT_FORMS} and does not accept direct agent, task, or step execution fields.`, mode: "management" };
       }
       if (!hasValidWorkflowInput) {
-        return { ok: false, error: "schedule.create requires a non-empty workflowScript or workflowScriptPath.", mode: "management" };
+        return { ok: false, error: `schedule.create requires ${RAW_SCRIPT_FORMS}.`, mode: "management" };
       }
       return { ok: true, params: { ...params, action: normalizedAction } };
     }
     if (hasWorkflowInput) {
-      return { ok: false, error: "Workflow execution must omit action; only validate and schedule.create accept action with workflowScript or workflowScriptPath.", mode: "management" };
+      return { ok: false, error: `Workflow execution must omit action; only validate and schedule.create accept action with ${RAW_SCRIPT_FORMS}.`, mode: "management" };
     }
     if (params.task !== undefined) {
       return { ok: false, error: "Structured single-child task cannot be combined with a management/control action.", mode: "management" };
@@ -137,10 +167,10 @@ export function normalizePublicSubagentExecution(params) {
     return { ok: true, params: { ...params, action: normalizedAction } };
   }
   if (params.step !== undefined) {
-    return { ok: false, error: "step is not a public execution field; use workflowScript for orchestration.", mode: "workflow" };
+    return { ok: false, error: `step is not a public execution field; use a workflow script (${RAW_SCRIPT_FORMS}) for orchestration.`, mode: "workflow" };
   }
   if (hasWorkflowInput && (params.agent !== undefined || params.task !== undefined)) {
-    return { ok: false, error: "Structured single-child execution cannot be combined with workflow, workflowScript, or workflowScriptPath.", mode: "workflow" };
+    return { ok: false, error: "Structured single-child execution cannot be combined with workflow.", mode: "workflow" };
   }
   if (params.agent !== undefined || params.task !== undefined) {
     if (typeof params.agent !== "string" || !params.agent.trim()) {
@@ -159,7 +189,7 @@ export function normalizePublicSubagentExecution(params) {
     };
   }
   if (!hasValidWorkflowInput) {
-    return { ok: false, error: "Execution requires either { agent, task? } for one child, a named workflow resource, or a non-empty workflowScript or workflowScriptPath for orchestration.", mode: "workflow" };
+    return { ok: false, error: "Execution requires either { agent, task? } for one child or workflow (true, a script path, or a named workflow resource) for orchestration.", mode: "workflow" };
   }
   return { ok: true, params };
 }

package/extensions/dm-subagents/src/extension/reply-workflow-script.js

@@ -0,0 +1,65 @@
+const WORKFLOW_FENCE = /^```(?:js|javascript) workflow[ \t]*$/;
+const PLAIN_JS_FENCE = /^```(?:js|javascript)[ \t]*$/;
+const OPEN_FENCE = /^(`{3,}|~{3,})/;
+const CLOSE_FENCE = /^(`{3,}|~{3,})[ \t]*$/;
+const FILE_FALLBACK = 'Or write the script to a file and pass its path, such as workflow: "./script.js".';
+export function readReplyWorkflowScript(sessionManager, toolCallId) {
+  const branch = sessionManager.getBranch();
+  for (let index = branch.length - 1;index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type !== "message")
+      continue;
+    const message = entry.message;
+    if (message?.role !== "assistant" || !Array.isArray(message.content))
+      continue;
+    if (!message.content.some((block) => block.type === "toolCall" && block.id === toolCallId))
+      continue;
+    return scriptFromReply(message.content);
+  }
+  return { error: 'workflow: true only works from a model subagent tool call whose assistant message contains the ```js workflow block; other callers must pass a script path such as workflow: "./script.js".' };
+}
+function scriptFromReply(content) {
+  const replyCalls = content.filter((block) => block.type === "toolCall" && block.name === "subagent" && (block.arguments?.workflow === true || block.arguments?.workflow === "true")).length;
+  if (replyCalls > 1)
+    return { error: `This reply has ${replyCalls} subagent calls with workflow: true; a reply can carry only one. Pass other scripts as workflow file paths.` };
+  if (!content.some((block) => block.type === "text"))
+    return { error: 'The assistant message that issued this call has no text in the session, so the reply\'s visible text, including any ```js workflow block, never reached it. Write the script to a file and pass its path, such as workflow: "./script.js".' };
+  const text = content.flatMap((block) => block.type === "text" && typeof block.text === "string" ? [block.text] : []).join(`
+`);
+  const { tagged, plain, unclosed } = workflowBlocks(text);
+  if (unclosed)
+    return { error: "The script's fenced block in this reply is not closed." };
+  const blocks = tagged.length > 0 ? tagged : plain.length === 1 ? plain : [];
+  if (blocks.length !== 1) {
+    const untagged = tagged.length === 0 && plain.length > 1 ? ` This reply has ${plain.length} untagged js blocks; open the script's block with the line "\`\`\`js workflow".` : "";
+    return { error: `workflow: true needs one fenced block in the same reply as the tool call, opened with the exact line "\`\`\`js workflow" and closed with "\`\`\`"; found ${tagged.length}.${untagged} ${FILE_FALLBACK}` };
+  }
+  const script = blocks[0];
+  if (!script.trim())
+    return { error: "The script's fenced block in this reply is empty." };
+  return { script };
+}
+function workflowBlocks(text) {
+  const lines = text.split(`
+`);
+  const tagged = [];
+  const plain = [];
+  let fence;
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index].replace(/\r$/, "");
+    if (!fence) {
+      const open = OPEN_FENCE.exec(line);
+      if (open)
+        fence = { marker: open[1], kind: WORKFLOW_FENCE.test(line) ? "tagged" : PLAIN_JS_FENCE.test(line) ? "plain" : undefined, start: index + 1 };
+      continue;
+    }
+    const close = CLOSE_FENCE.exec(line);
+    if (!close || close[1][0] !== fence.marker[0] || close[1].length < fence.marker.length)
+      continue;
+    if (fence.kind)
+      (fence.kind === "tagged" ? tagged : plain).push(lines.slice(fence.start, index).join(`
+`));
+    fence = undefined;
+  }
+  return { tagged, plain, unclosed: fence?.kind === "tagged" || fence?.kind === "plain" && tagged.length === 0 };
+}

package/extensions/dm-subagents/src/extension/rpc.js

@@ -1,7 +1,7 @@
 import * as path from "node:path";
 import { Compile } from "typebox/compile";
 import { resolveAsyncRunLocation } from "../runs/background/async-resume.js";
-import { deliverStopRequest } from "../runs/background/control-channel.js";
+import { deliverAsyncRunStop } from "../runs/foreground/async-stop-action.js";
 import { reconcileAsyncRun } from "../runs/background/stale-run-reconciler.js";
 import { resolveCurrentSessionId } from "../shared/session-identity.js";
 import {
@@ -13,7 +13,8 @@ import {
 } from "../shared/types.js";
 import { sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.js";
 import { readStatus } from "../shared/utils.js";
-import { SubagentParams } from "./schemas.js";
+import { SubagentFlatParams } from "./schemas.js";
+import { disabledFeatureUseError } from "../shared/disabled-features.js";
 import { normalizePublicSubagentExecution } from "./public-execution.js";
 import { collectSubagentCost, SUBAGENT_COST_REPORT_VERSION } from "../slash/subagent-cost.js";
 import { ASYNC_STATUS_SNAPSHOT_KIND, ASYNC_STATUS_SNAPSHOT_VERSION, buildAsyncStatusSnapshotForState } from "../runs/background/async-status-snapshot.js";
@@ -196,6 +197,9 @@ function buildFleetStatus(state, keyState, sessionId) {
   const omitted = Math.max(0, totalActive - entries.length);
   return { version: 1, entries, totalActive, topLevelAsyncCapacity: state.activeAsyncCapacity ?? { used: 0, limit: 0 }, omitted };
 }
+function enabledManagementActions(options) {
+  return SUBAGENT_RPC_MANAGEMENT_ACTIONS.filter((action) => !options.disabledFeatures?.actions.has(action));
+}
 
 class SubagentRpcError extends Error {
   code;
@@ -205,7 +209,7 @@ class SubagentRpcError extends Error {
     this.code = code;
   }
 }
-const subagentParamsValidator = Compile(SubagentParams);
+const subagentParamsValidator = Compile(SubagentFlatParams);
 export function subagentRpcReplyEvent(requestId) {
   return `${SUBAGENT_RPC_REPLY_EVENT_PREFIX}${requestId}`;
 }
@@ -290,14 +294,14 @@ function sessionData(ctx) {
     sessionFile: ctx.sessionManager.getSessionFile() ?? null
   };
 }
-function pingData(ctx) {
+function pingData(ctx, options) {
   return {
     version: SUBAGENT_RPC_PROTOCOL_VERSION,
     methods: [...SUBAGENT_RPC_METHODS],
     capabilities: {
       status: true,
       statusProjection: { version: 1, untargeted: "in-memory-when-ready", targeted: "executor" },
-      managementActions: [...SUBAGENT_RPC_MANAGEMENT_ACTIONS],
+      managementActions: enabledManagementActions(options),
       fleetStatus: { version: 1 },
       asyncStatusSnapshot: { kind: ASYNC_STATUS_SNAPSHOT_KIND, version: ASYNC_STATUS_SNAPSHOT_VERSION },
       asyncSpawn: true,
@@ -329,10 +333,11 @@ async function executeChecked(options, ctx, requestId, method, params) {
   failIfToolError(result);
   return dataFromToolResult(result);
 }
-function manageParams(params) {
+function manageParams(params, options) {
   const input = assertRecordParams(params, "manage");
   if (typeof input.action !== "string" || !SUBAGENT_RPC_MANAGEMENT_ACTIONS.includes(input.action)) {
-    throw new SubagentRpcError("invalid_params", `RPC manage action must be one of: ${SUBAGENT_RPC_MANAGEMENT_ACTIONS.join(", ")}.`);
+    const enabled = enabledManagementActions(options);
+    throw new SubagentRpcError("invalid_params", enabled.length > 0 ? `RPC manage action must be one of: ${enabled.join(", ")}.` : "RPC manage actions are all disabled by config.");
   }
   if (input.id !== undefined && (typeof input.id !== "string" || !input.id.trim())) {
     throw new SubagentRpcError("invalid_params", "RPC manage id must be a non-empty string.");
@@ -353,8 +358,24 @@ function manageParams(params) {
   assertSubagentParams(output, "RPC manage params");
   return output;
 }
-function spawnParams(params) {
-  const input = assertRecordParams(params, "spawn");
+function spawnParams(params, options) {
+  const { script, ...input } = assertRecordParams(params, "spawn");
+  if (Object.hasOwn(input, "workflowScript"))
+    throw new SubagentRpcError("invalid_params", "RPC spawn workflowScript was removed; pass inline script text as script.");
+  if (Object.hasOwn(input, "workflowScriptPath"))
+    throw new SubagentRpcError("invalid_params", 'RPC spawn workflowScriptPath was removed; pass the file as workflow: "./path/to/script.js".');
+  if (input.workflow === true || input.workflow === "true")
+    throw new SubagentRpcError("invalid_params", 'RPC spawn has no reply block for workflow: true; pass inline script text as script or a file as workflow: "./path/to/script.js".');
+  if (script !== undefined) {
+    if (typeof script !== "string" || !script.trim())
+      throw new SubagentRpcError("invalid_params", "RPC spawn script must be a non-empty string.");
+    if (input.workflow !== undefined)
+      throw new SubagentRpcError("invalid_params", "RPC spawn script cannot be combined with workflow.");
+    input.workflowScript = script;
+  }
+  const disabledFeatureError = options.disabledFeatures?.features.has("workflow-scripts") ? disabledFeatureUseError(input, options.disabledFeatures, "RPC spawn") : undefined;
+  if (disabledFeatureError)
+    throw new SubagentRpcError("invalid_params", disabledFeatureError);
   const normalized = normalizePublicSubagentExecution(input);
   if (!normalized.ok)
     throw new SubagentRpcError("invalid_params", normalized.error);
@@ -501,8 +522,9 @@ function stopAsyncRun(params, options, ctx) {
   if (status.sessionId !== currentSessionId) {
     throw new SubagentRpcError("not_found", `Async run '${runId}' was not found in the active session.`);
   }
-  if (status.state !== "running") {
-    throw new SubagentRpcError("invalid_state", `Async run ${runId} is ${status.state}; stop only supports running async runs.`);
+  const pausedWholeRun = status.state === "paused" && childId === undefined;
+  if (status.state !== "running" && status.state !== "queued" && !pausedWholeRun) {
+    throw new SubagentRpcError("invalid_state", `Async run ${runId} is ${status.state}; stop only supports running or queued async runs, or a paused whole run.`);
   }
   if (childId !== undefined) {
     const resolution = resolveAsyncStatusChild(status, childId);
@@ -514,14 +536,18 @@ function stopAsyncRun(params, options, ctx) {
     }
   }
   try {
-    deliverStopRequest({
+    const failure = deliverAsyncRunStop({
       asyncDir: location.asyncDir,
+      status,
+      resultsDir,
       pid: status.pid,
       kill: options.kill,
       now: options.now,
       source: "rpc-stop",
       ...child ? { targetIndex: child.index, childId: child.id } : {}
     });
+    if (failure)
+      throw new Error(`Stop request persisted for paused async run ${runId}, but terminal proof is not ready (${failure}). Retry stop after runner shutdown is observed.`);
   } catch (error) {
     throw new SubagentRpcError("execution_failed", error instanceof Error ? error.message : String(error));
   }
@@ -539,14 +565,14 @@ function stopAsyncRun(params, options, ctx) {
 async function handleRequest(request, options, fleetKeys) {
   const ctx = options.getContext();
   if (request.method === "ping")
-    return pingData(ctx);
+    return pingData(ctx, options);
   if (!ctx)
     throw new SubagentRpcError("no_active_session", "No active extension context for subagent RPC.");
   if (request.method === "manage") {
-    return executeChecked(options, ctx, request.requestId, request.method, manageParams(request.params));
+    return executeChecked(options, ctx, request.requestId, request.method, manageParams(request.params, options));
   }
   if (request.method === "spawn") {
-    return executeChecked(options, ctx, request.requestId, request.method, spawnParams(request.params));
+    return executeChecked(options, ctx, request.requestId, request.method, spawnParams(request.params, options));
   }
   if (request.method === "status") {
     const statusParams = normalizeStatusParams(request.params);
@@ -653,7 +679,7 @@ export function registerSubagentRpcBridge(options) {
   });
   return {
     emitReady: (ctx) => {
-      options.events.emit(SUBAGENT_RPC_READY_EVENT, pingData(ctx ?? options.getContext()));
+      options.events.emit(SUBAGENT_RPC_READY_EVENT, pingData(ctx ?? options.getContext(), options));
     },
     dispose: () => {
       if (typeof unsubscribe === "function")