@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/subagent-prompt-runtime.js

@@ -1,13 +1,36 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { registerNativeSupervisorClient } from "../../intercom/native-supervisor-channel.js";
-import { consumeSteerRequestsFromDir, writeSteerRequestToDir } from "../background/control-channel.js";
-import { SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_STEER_INBOX_ENV } from "./dm-args.js";
-import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.js";
-import { TOOL_BUDGET_ENV, decodeToolBudgetEnv, shouldBlockToolForBudget, toolBudgetBlockedMessage, toolBudgetSoftNudge } from "./tool-budget.js";
+import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.js";
+import { decodePermissionRules, permissionDecision, PERMISSION_AUDIT_PATH_ENV, PERMISSION_POLICY_ENV } from "./permissions.js";
+import { consumeSteerRequestsFromDir, MAX_STEER_QUEUE_SIZE, steerAckPathFromDir, writeSteerAckAt, writeSteerCapabilityAt, writeSteerRequestToDir } from "../background/control-channel.js";
+import { SUBAGENT_CHILD_AGENT_ENV, SUBAGENT_CHILD_INDEX_ENV, SUBAGENT_FANOUT_CHILD_ENV, SUBAGENT_FORK_CACHE_KEY_ENV, SUBAGENT_INHERIT_GLOBAL_CONTEXT_ENV, SUBAGENT_STEER_ACK_DIR_ENV, SUBAGENT_STEER_CAPABILITY_ENV, SUBAGENT_STEER_INBOX_ENV } from "./dm-args.js";
+import { RUNTIME_EXTENSION_ACK_EVENT, RUNTIME_EXTENSION_ACK_PATH_ENV, isRuntimeAcknowledgedExtensionId, writeRuntimeAcknowledgedExtensions } from "./runtime-acknowledged-extensions.js";
+import { createStructuredOutputToolParameters, STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.js";
+import {
+  CHILD_TOOL_DIAGNOSTIC_PATH_ENV,
+  formatChildToolDiagnostic,
+  MCP_DIRECT_CHILD_TOOLS_ENV,
+  REQUIRED_CHILD_TOOLS_ENV,
+  writeChildToolDiagnostic
+} from "./tool-availability.js";
+import { TOOL_BUDGET_ENV, TOOL_BUDGET_ZERO_AUTH_ENV, decodeToolBudgetEnv, shouldBlockToolForBudget, toolBudgetBlockedMessage, toolBudgetSoftNudge } from "./tool-budget.js";
+import { resolveCurrentSessionId } from "../../shared/session-identity.js";
+import { getAgentDir, resolveWatchPath } from "../../shared/utils.js";
+import { registerChildWatchdog } from "../../watchdog/register-child.js";
+import { CHILD_WATCHDOG_CONFIG_ENV, decodeChildWatchdogConfig } from "../../watchdog/child-status.js";
+import { requestWatchdogPermission } from "../../watchdog/permission-arbiter.js";
+import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../watchdog/types.js";
+import { resolveWaitToolConfig } from "../background/wait-config.js";
+import { registerWaitTool } from "../background/wait-tool.js";
+import { drainOutstandingWork } from "../background/auto-drain.js";
 const SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV = "DM_SUBAGENT_INHERIT_PROJECT_CONTEXT";
 const SUBAGENT_INHERIT_SKILLS_ENV = "DM_SUBAGENT_INHERIT_SKILLS";
 export const SUBAGENT_INTERCOM_SESSION_NAME_ENV = "DM_SUBAGENT_INTERCOM_SESSION_NAME";
+export const SUBAGENT_SESSION_NAME_ENV = "DM_SUBAGENT_SESSION_NAME";
+const STEERING_LEGACY_SETTLE_FALLBACK_MS = 1000;
+const STEERING_SAFETY_POLL_INTERVAL_MS = 5000;
 const STRUCTURED_OUTPUT_INSTRUCTIONS = [
   "This subagent step has a strict structured output contract.",
   "Your final action must be to call the `structured_output` tool with JSON matching the provided schema.",
@@ -41,7 +64,12 @@ const PARENT_ONLY_CUSTOM_MESSAGE_TYPES = new Set([
   "subagent-control-notice"
 ]);
 const SUBAGENT_ORCHESTRATION_SKILL_NAME_PATTERN = /<name>\s*dm-subagents\s*<\/name>/;
-const PROJECT_CONTEXT_HEADER = `
+const PROJECT_CONTEXT_XML_HEADER = `
+
+<project_context>
+
+`;
+const PROJECT_CONTEXT_LEGACY_HEADER = `
 
 # Project Context
 
@@ -59,6 +87,66 @@ function readBooleanEnv(name) {
     return;
   return value !== "0";
 }
+function readRequiredChildTools() {
+  const encoded = process.env[REQUIRED_CHILD_TOOLS_ENV]?.trim();
+  if (!encoded)
+    return;
+  const required = JSON.parse(encoded);
+  if (!Array.isArray(required) || required.some((name) => typeof name !== "string" || !name)) {
+    throw new Error(`Invalid ${REQUIRED_CHILD_TOOLS_ENV} payload.`);
+  }
+  return required;
+}
+function readMcpDirectChildTools() {
+  const encoded = process.env[MCP_DIRECT_CHILD_TOOLS_ENV]?.trim();
+  if (!encoded)
+    return;
+  try {
+    const tools = JSON.parse(encoded);
+    if (!Array.isArray(tools) || tools.some((name) => typeof name !== "string" || !name))
+      return;
+    return tools;
+  } catch {
+    return;
+  }
+}
+function refreshChildToolDiagnostic(dm) {
+  const filePath = process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV]?.trim();
+  const required = readRequiredChildTools();
+  if (!filePath || !required)
+    return;
+  const available = dm.getAllTools().map((tool) => tool.name);
+  return writeChildToolDiagnostic(filePath, required, available, process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim(), readMcpDirectChildTools());
+}
+function registerRuntimeExtensionAcknowledgements(dm) {
+  const outputPath = process.env[RUNTIME_EXTENSION_ACK_PATH_ENV]?.trim();
+  if (!outputPath)
+    return;
+  const ids = [];
+  let finalized = false;
+  const acknowledge = (payload) => {
+    if (finalized || !payload || typeof payload !== "object")
+      return;
+    const id = payload.id;
+    if (isRuntimeAcknowledgedExtensionId(id))
+      ids.push(id);
+    return;
+  };
+  const finalize = () => {
+    if (finalized)
+      return;
+    finalized = true;
+    writeRuntimeAcknowledgedExtensions(outputPath, ids);
+    return;
+  };
+  try {
+    const events = dm.events;
+    events?.on?.(RUNTIME_EXTENSION_ACK_EVENT, acknowledge);
+    const onRuntimeEvent = dm.on;
+    onRuntimeEvent("agent_end", finalize);
+    onRuntimeEvent("session_shutdown", finalize);
+  } catch {}
+}
 function findSectionEnd(prompt, startIndex, nextHeaders) {
   let endIndex = prompt.length;
   for (const header of nextHeaders) {
@@ -70,11 +158,71 @@ function findSectionEnd(prompt, startIndex, nextHeaders) {
   return endIndex;
 }
 export function stripProjectContext(prompt) {
-  const startIndex = prompt.indexOf(PROJECT_CONTEXT_HEADER);
-  if (startIndex === -1)
+  const xmlStartIndex = prompt.indexOf(PROJECT_CONTEXT_XML_HEADER);
+  if (xmlStartIndex !== -1) {
+    const closingTag = "</project_context>";
+    const closingIndex = prompt.indexOf(closingTag, xmlStartIndex + PROJECT_CONTEXT_XML_HEADER.length);
+    if (closingIndex !== -1) {
+      return `${prompt.slice(0, xmlStartIndex)}${prompt.slice(closingIndex + closingTag.length)}`;
+    }
+  }
+  const legacyStartIndex = prompt.indexOf(PROJECT_CONTEXT_LEGACY_HEADER);
+  if (legacyStartIndex === -1)
     return prompt;
-  const endIndex = findSectionEnd(prompt, startIndex + PROJECT_CONTEXT_HEADER.length, [SKILLS_HEADER, DATE_HEADER]);
-  return `${prompt.slice(0, startIndex)}${prompt.slice(endIndex)}`;
+  const endIndex = findSectionEnd(prompt, legacyStartIndex + PROJECT_CONTEXT_LEGACY_HEADER.length, [SKILLS_HEADER, DATE_HEADER]);
+  return `${prompt.slice(0, legacyStartIndex)}${prompt.slice(endIndex)}`;
+}
+const GLOBAL_CONTEXT_FILE_NAMES = new Set(["agents.md", "agents.override.md", "claude.md"]);
+function canonicalDirectory(dir) {
+  try {
+    return fs.realpathSync(dir);
+  } catch {
+    return path.resolve(dir);
+  }
+}
+function expandContextPath(filePath) {
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  return filePath === "~" ? home ?? filePath : /^~[\\/]/.test(filePath) ? path.join(home ?? "~", filePath.slice(2)) : filePath;
+}
+function isContextFilePath(filePath) {
+  return GLOBAL_CONTEXT_FILE_NAMES.has(path.basename(expandContextPath(filePath)).toLowerCase());
+}
+function isGlobalContextFile(filePath) {
+  const expanded = expandContextPath(filePath);
+  if (!isContextFilePath(filePath))
+    return false;
+  return canonicalDirectory(path.dirname(expanded)) === canonicalDirectory(getAgentDir());
+}
+function stripGlobalInstructionsFromXmlContext(context) {
+  const block = /<project_instructions\s+path=(["'])(.*?)\1\s*>[\s\S]*?<\/project_instructions>\s*/gi;
+  return context.replace(block, (match, _quote, filePath) => isGlobalContextFile(filePath) ? "" : match);
+}
+function stripGlobalInstructionsFromLegacyContext(context) {
+  const sections = [...context.matchAll(/^## ([^\r\n]+)(?:\r?\n|$)/gm)].filter((match) => isContextFilePath(match[1].trim()));
+  let rewritten = "";
+  let cursor = 0;
+  for (let index = 0;index < sections.length; index++) {
+    const section = sections[index];
+    const start = section.index;
+    const end = sections[index + 1]?.index ?? context.length;
+    rewritten += context.slice(cursor, start);
+    if (!isGlobalContextFile(section[1].trim()))
+      rewritten += context.slice(start, end);
+    cursor = end;
+  }
+  return `${rewritten}${context.slice(cursor)}`;
+}
+export function stripGlobalContext(prompt) {
+  const rewrittenXml = prompt.replace(/<project_context>[\s\S]*?<\/project_context>/gi, (context) => {
+    const rewritten = stripGlobalInstructionsFromXmlContext(context);
+    return /<project_instructions\b/i.test(rewritten) ? rewritten : "";
+  });
+  const legacyStartIndex = rewrittenXml.indexOf(PROJECT_CONTEXT_LEGACY_HEADER);
+  if (legacyStartIndex === -1)
+    return rewrittenXml;
+  const legacyEndIndex = findSectionEnd(rewrittenXml, legacyStartIndex + PROJECT_CONTEXT_LEGACY_HEADER.length, [SKILLS_HEADER, DATE_HEADER]);
+  const legacyContext = rewrittenXml.slice(legacyStartIndex, legacyEndIndex);
+  return `${rewrittenXml.slice(0, legacyStartIndex)}${stripGlobalInstructionsFromLegacyContext(legacyContext)}${rewrittenXml.slice(legacyEndIndex)}`;
 }
 export function stripInheritedSkills(prompt) {
   const startIndex = prompt.indexOf(SKILLS_HEADER);
@@ -100,6 +248,9 @@ export function rewriteSubagentPrompt(prompt, options) {
   if (!options.inheritProjectContext) {
     rewritten = stripProjectContext(rewritten);
   }
+  if (!options.inheritGlobalContext) {
+    rewritten = stripGlobalContext(rewritten);
+  }
   if (!options.inheritSkills) {
     rewritten = stripInheritedSkills(rewritten);
   }
@@ -115,7 +266,11 @@ ${rewritten}`;
 }
 function isParentOnlySubagentMessage(message) {
   const m = message;
-  return m?.role === "custom" && typeof m.customType === "string" && PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(m.customType);
+  if (m?.role !== "custom" || typeof m.customType !== "string")
+    return false;
+  if (m.customType === SUBAGENT_WATCHDOG_WARNING_TYPE)
+    return true;
+  return PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(m.customType);
 }
 function isSubagentToolResultMessage(message) {
   const m = message;
@@ -125,6 +280,62 @@ function isSubagentToolCallBlock(block) {
   const b = block;
   return b?.type === "toolCall" && b.name === "subagent";
 }
+const PORTABLE_TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const MAX_PORTABLE_TOOL_ID_LENGTH = 64;
+const COMPOSITE_TOOL_ID_APIS = new Set([
+  "azure-openai-responses",
+  "cursor-native",
+  "openai-completions",
+  "openai-responses"
+]);
+const PROMPT_CACHE_KEY_APIS = new Set([
+  "azure-openai-responses",
+  "openai-codex-responses",
+  "openai-completions",
+  "openai-responses"
+]);
+export function rewriteForkCacheProviderRequest(event, ctx) {
+  const forkCacheKey = process.env[SUBAGENT_FORK_CACHE_KEY_ENV]?.trim();
+  if (!forkCacheKey || !PROMPT_CACHE_KEY_APIS.has(ctx?.model?.api ?? ""))
+    return;
+  if (!event || typeof event !== "object")
+    return;
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return;
+  if (typeof payload.prompt_cache_key !== "string")
+    return;
+  return { ...payload, prompt_cache_key: forkCacheKey };
+}
+function portableToolId(id) {
+  if (PORTABLE_TOOL_ID_PATTERN.test(id) && id.length <= MAX_PORTABLE_TOOL_ID_LENGTH)
+    return id;
+  const encoded = `tool_${Buffer.from(id).toString("base64url") || "empty"}`;
+  if (encoded.length <= MAX_PORTABLE_TOOL_ID_LENGTH)
+    return encoded;
+  return `tool_${createHash("sha256").update(id).digest("base64url")}`;
+}
+function sanitizeToolHistoryMessage(message) {
+  const m = message;
+  if (m?.role === "toolResult" && typeof m.toolCallId === "string") {
+    const toolCallId = portableToolId(m.toolCallId);
+    return toolCallId === m.toolCallId ? message : { ...m, toolCallId };
+  }
+  if (m?.role !== "assistant" || !Array.isArray(m.content))
+    return message;
+  let changed = false;
+  const content = m.content.map((block) => {
+    const b = block;
+    if (b?.type !== "toolCall" || typeof b.id !== "string")
+      return block;
+    const id = portableToolId(b.id);
+    if (id === b.id)
+      return block;
+    changed = true;
+    return { ...b, id };
+  });
+  return changed ? { ...m, content } : message;
+}
 function stripAssistantSubagentToolCallBlocks(message) {
   const m = message;
   if (m?.role !== "assistant" || !Array.isArray(m.content))
@@ -136,8 +347,9 @@ function stripAssistantSubagentToolCallBlocks(message) {
     return;
   return { ...m, content: filteredContent };
 }
-export function stripParentOnlySubagentMessages(messages) {
+export function stripParentOnlySubagentMessages(messages, options = {}) {
   const preserveCurrentFanoutToolHistory = process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1";
+  const sanitizeToolIds = options.sanitizeToolIds ?? true;
   let changed = false;
   const filtered = [];
   for (const message of messages) {
@@ -150,15 +362,16 @@ export function stripParentOnlySubagentMessages(messages) {
       changed = true;
       continue;
     }
-    if (stripped !== message)
+    const sanitized = sanitizeToolIds ? sanitizeToolHistoryMessage(stripped) : stripped;
+    if (stripped !== message || sanitized !== stripped)
       changed = true;
-    filtered.push(stripped);
+    filtered.push(sanitized);
   }
   return changed ? filtered : messages;
 }
 export function formatSteerMessage(request) {
   return [
-    "Mid-run steering from the parent orchestrator:",
+    request.mode === "follow_up" ? "Queued follow-up from the parent orchestrator:" : "Mid-run steering from the parent orchestrator:",
     "",
     request.message,
     "",
@@ -166,13 +379,69 @@ export function formatSteerMessage(request) {
   ].join(`
 `);
 }
-function registerToolBudget(pi, budget) {
+export function registerPermissionGate(dm, requestPermission = requestWatchdogPermission) {
+  const rules = decodePermissionRules(process.env[PERMISSION_POLICY_ENV]);
+  if (!rules)
+    return;
+  const onRuntimeEvent = dm.on;
+  onRuntimeEvent("tool_call", async (event, ctx) => {
+    const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
+    const decision = permissionDecision(rules, toolName);
+    if (decision === "allow")
+      return;
+    if (decision === "deny")
+      return { block: true, reason: `Blocked by dm-subagents permission rule: '${toolName}' is denied.` };
+    const rawWatchdogConfig = process.env[CHILD_WATCHDOG_CONFIG_ENV];
+    let timeoutMs = 30000;
+    try {
+      timeoutMs = decodeChildWatchdogConfig(rawWatchdogConfig)?.agentEndTimeoutMs ?? timeoutMs;
+    } catch {}
+    if (ctx.signal?.aborted)
+      return { block: true, reason: "Blocked by dm-subagents permission rule: Watchdog permission decision was cancelled." };
+    let timeout;
+    let abort;
+    let result;
+    try {
+      result = await Promise.race([
+        requestPermission({
+          ctx,
+          toolName,
+          args: event.input ?? {},
+          rawWatchdogConfig,
+          auditPath: process.env[PERMISSION_AUDIT_PATH_ENV],
+          ...ctx.signal ? { signal: ctx.signal } : {}
+        }),
+        new Promise((resolve) => {
+          if (!ctx.signal)
+            return;
+          abort = () => resolve({ approved: false, reason: "Watchdog permission decision was cancelled.", source: "watchdog" });
+          ctx.signal.addEventListener("abort", abort, { once: true });
+        }),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new Error(`Watchdog permission decision timed out after ${timeoutMs}ms.`)), timeoutMs);
+        })
+      ]);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return { block: true, reason: `Blocked by dm-subagents permission rule: Watchdog permission arbiter failed closed: ${reason}` };
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+      if (abort)
+        ctx.signal?.removeEventListener("abort", abort);
+    }
+    if (result.approved)
+      return;
+    return { block: true, reason: `Blocked by dm-subagents permission rule: ${result.reason}` };
+  });
+}
+function registerToolBudget(dm, budget) {
   if (!budget)
     return;
   let toolCount = 0;
   let softNudged = false;
-  const sendUserMessage = pi.sendUserMessage;
-  const onRuntimeEvent = pi.on;
+  const sendUserMessage = dm.sendUserMessage;
+  const onRuntimeEvent = dm.on;
   onRuntimeEvent("tool_call", (event) => {
     const toolName = typeof event.toolName === "string" ? event.toolName : "tool";
     toolCount++;
@@ -187,32 +456,78 @@ function registerToolBudget(pi, budget) {
     return { block: true, reason: toolBudgetBlockedMessage(budget, toolName, toolCount) };
   });
 }
-function registerSteeringInbox(pi) {
+export function registerSteeringInbox(dm, deps = {}) {
   const steerInbox = process.env[SUBAGENT_STEER_INBOX_ENV]?.trim();
   if (!steerInbox)
     return;
-  const sendUserMessage = pi.sendUserMessage;
-  if (typeof sendUserMessage !== "function")
-    return;
-  let canSteer = false;
+  const capabilityPath = process.env[SUBAGENT_STEER_CAPABILITY_ENV]?.trim();
+  const ackDir = process.env[SUBAGENT_STEER_ACK_DIR_ENV]?.trim();
+  const sendUserMessage = dm.sendUserMessage;
+  const childIndex = Number(process.env[SUBAGENT_CHILD_INDEX_ENV]);
+  const pending = new Map;
+  const queued = [];
   let disposed = false;
+  let agentRunning = false;
+  let inTurn = false;
+  let awaitingSettlement = false;
   let flushing = false;
   let started = false;
+  let canSteer = typeof sendUserMessage === "function";
   let watcher;
   let interval;
+  let safetyInterval;
+  let settleFallback;
+  const legacySettleFallbackMs = deps.legacySettleFallbackMs ?? STEERING_LEGACY_SETTLE_FALLBACK_MS;
+  const acknowledge = (request, state, message, deliveryStatus) => {
+    if (!ackDir || !Number.isInteger(childIndex) || childIndex < 0)
+      return;
+    writeSteerAckAt(steerAckPathFromDir(ackDir, request.id), {
+      requestId: request.id,
+      index: childIndex,
+      ts: Date.now(),
+      state,
+      ...deliveryStatus ? { deliveryStatus } : {},
+      message
+    });
+  };
+  const publishCapability = () => {
+    if (!capabilityPath || !Number.isInteger(childIndex) || childIndex < 0)
+      return;
+    writeSteerCapabilityAt(capabilityPath, { index: childIndex, pid: process.pid, readyAt: Date.now(), supported: canSteer });
+  };
   const flush = () => {
-    if (disposed || flushing || !canSteer)
+    if (disposed || flushing)
       return;
     flushing = true;
     try {
       const requests = consumeSteerRequestsFromDir(steerInbox);
       for (let index = 0;index < requests.length; index++) {
         const request = requests[index];
+        if (!canSteer || typeof sendUserMessage !== "function") {
+          acknowledge(request, "failed", "Child DM session does not support sendUserMessage steering.");
+          continue;
+        }
+        const requestedMode = request.mode ?? "steer";
+        const autoCanUseIdle = requestedMode === "auto" && !agentRunning && !awaitingSettlement;
+        const delivery = requestedMode === "follow_up" || requestedMode === "auto" && (inTurn || awaitingSettlement) ? "followUp" : "steer";
+        const pendingFollowUps = [...pending.values()].reduce((count, entries) => count + entries.filter((entry) => entry.deliveryStatus === "queued").length, 0);
+        if (delivery === "followUp" && queued.length + pendingFollowUps >= MAX_STEER_QUEUE_SIZE) {
+          acknowledge(request, "failed", `Follow-up queue is full (${MAX_STEER_QUEUE_SIZE} messages).`);
+          continue;
+        }
+        const formatted = formatSteerMessage(request);
+        const entries = pending.get(formatted) ?? [];
+        entries.push({ request, deliveryStatus: delivery === "followUp" ? "queued" : "delivered" });
+        pending.set(formatted, entries);
         try {
-          sendUserMessage(formatSteerMessage(request), { deliverAs: "steer" });
-        } catch {
-          for (const pending of requests.slice(index))
-            writeSteerRequestToDir(steerInbox, pending);
+          sendUserMessage(formatted, autoCanUseIdle ? undefined : { deliverAs: delivery });
+        } catch (error) {
+          entries.pop();
+          if (entries.length === 0)
+            pending.delete(formatted);
+          acknowledge(request, "failed", error instanceof Error ? error.message : String(error));
+          for (const retry of requests.slice(index + 1))
+            writeSteerRequestToDir(steerInbox, retry);
           break;
         }
       }
@@ -220,87 +535,238 @@ function registerSteeringInbox(pi) {
       flushing = false;
     }
   };
+  const onInput = (event) => {
+    if (disposed || !event || typeof event !== "object")
+      return;
+    const input = event;
+    if (input.source !== "extension")
+      return;
+    const text = typeof input.text === "string" ? input.text : typeof input.content === "string" ? input.content : undefined;
+    if (!text)
+      return;
+    const entries = pending.get(text);
+    const entry = entries?.shift();
+    if (!entry)
+      return;
+    if (entries?.length === 0)
+      pending.delete(text);
+    if (entry.deliveryStatus === "queued") {
+      queued.push({ request: entry.request, ready: !inTurn });
+      acknowledge(entry.request, "queued", "DM queued the correlated follow-up input.", "queued");
+    } else {
+      acknowledge(entry.request, "delivered", "DM accepted the correlated steering input.", "delivered");
+    }
+    return;
+  };
   const start = () => {
     if (started || disposed)
       return;
     try {
       fs.mkdirSync(steerInbox, { recursive: true });
+      publishCapability();
     } catch {
       return;
     }
     started = true;
-    try {
-      watcher = fs.watch(steerInbox, () => flush());
-      watcher.on("error", () => {});
-    } catch {
-      watcher = undefined;
+    const startPolling = () => {
+      if (interval || disposed)
+        return;
+      interval = (deps.timers?.setInterval ?? setInterval)(flush, 250);
+      interval.unref?.();
+    };
+    const startSafetyPolling = () => {
+      if (safetyInterval || disposed)
+        return;
+      safetyInterval = (deps.timers?.setInterval ?? setInterval)(flush, deps.safetyPollIntervalMs ?? STEERING_SAFETY_POLL_INTERVAL_MS);
+      safetyInterval.unref?.();
+    };
+    if (!shouldUseNativeFsWatch("child-steering-inbox", deps.platform)) {
+      startPolling();
+    } else {
+      try {
+        watcher = (deps.watch ?? fs.watch)(resolveWatchPath(steerInbox, deps.nativeRealpath), () => flush());
+        watcher.on("error", startPolling);
+        startSafetyPolling();
+      } catch {
+        watcher = undefined;
+        startPolling();
+      }
     }
-    interval = setInterval(flush, 250);
-    interval.unref?.();
   };
   const activate = () => {
     start();
-    canSteer = true;
     flush();
     return;
   };
-  const onRuntimeEvent = pi.on;
+  const clearSettleFallback = () => {
+    if (!settleFallback)
+      return;
+    clearTimeout(settleFallback);
+    settleFallback = undefined;
+  };
+  const markSettled = () => {
+    clearSettleFallback();
+    agentRunning = false;
+    inTurn = false;
+    awaitingSettlement = false;
+    return activate();
+  };
+  const armLegacySettleFallback = () => {
+    clearSettleFallback();
+    settleFallback = setTimeout(() => {
+      settleFallback = undefined;
+      if (disposed || !awaitingSettlement)
+        return;
+      agentRunning = false;
+      inTurn = false;
+      awaitingSettlement = false;
+      activate();
+    }, legacySettleFallbackMs);
+    settleFallback.unref?.();
+  };
+  const onRuntimeEvent = dm.on;
+  onRuntimeEvent("input", onInput);
   onRuntimeEvent("session_start", () => start());
-  for (const eventName of ["message_start", "message_update", "message_end", "tool_execution_start", "tool_execution_end", "turn_end"]) {
+  onRuntimeEvent("agent_start", () => {
+    clearSettleFallback();
+    agentRunning = true;
+    awaitingSettlement = false;
+    return activate();
+  });
+  onRuntimeEvent("agent_end", (event) => {
+    inTurn = false;
+    if (event?.willRetry === true) {
+      clearSettleFallback();
+      agentRunning = true;
+      awaitingSettlement = true;
+      return activate();
+    }
+    agentRunning = true;
+    awaitingSettlement = true;
+    armLegacySettleFallback();
+    return activate();
+  });
+  onRuntimeEvent("agent_settled", markSettled);
+  onRuntimeEvent("session_compact", () => {
+    const unresolved = [...pending.values()].flat();
+    pending.clear();
+    for (const entry of unresolved) {
+      try {
+        writeSteerRequestToDir(steerInbox, { ...entry.request, mode: "follow_up" });
+      } catch (error) {
+        acknowledge(entry.request, "failed", `Could not retry steering after compaction: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return activate();
+  });
+  onRuntimeEvent("turn_start", () => {
+    clearSettleFallback();
+    agentRunning = true;
+    awaitingSettlement = false;
+    inTurn = true;
+    const next = queued.findIndex((entry) => entry.ready);
+    if (next >= 0) {
+      const [entry] = queued.splice(next, 1);
+      if (entry)
+        acknowledge(entry.request, "delivered", "DM delivered the queued follow-up at a turn boundary.", "delivered");
+    }
+    return activate();
+  });
+  onRuntimeEvent("turn_end", () => {
+    inTurn = false;
+    for (const entry of queued)
+      entry.ready = true;
+    return activate();
+  });
+  for (const eventName of ["message_start", "message_update", "message_end", "tool_execution_start", "tool_execution_end"]) {
     onRuntimeEvent(eventName, activate);
   }
   onRuntimeEvent("session_shutdown", () => {
+    for (const entry of queued)
+      acknowledge(entry.request, "failed", "Run ended before queued follow-up delivery.", "queued");
+    for (const entries of pending.values()) {
+      for (const entry of entries)
+        acknowledge(entry.request, "failed", "Run ended before DM confirmed steering input delivery.");
+    }
     disposed = true;
+    clearSettleFallback();
     try {
       watcher?.close();
     } catch {}
     if (interval)
-      clearInterval(interval);
+      (deps.timers?.clearInterval ?? clearInterval)(interval);
+    if (safetyInterval)
+      (deps.timers?.clearInterval ?? clearInterval)(safetyInterval);
   });
 }
-export default function registerSubagentPromptRuntime(pi) {
-  registerSteeringInbox(pi);
-  registerToolBudget(pi, decodeToolBudgetEnv(process.env[TOOL_BUDGET_ENV]));
+export default function registerSubagentPromptRuntime(dm) {
+  registerRuntimeExtensionAcknowledgements(dm);
+  registerSteeringInbox(dm);
+  registerPermissionGate(dm);
+  registerToolBudget(dm, decodeToolBudgetEnv(process.env[TOOL_BUDGET_ENV], { allowZero: process.env[TOOL_BUDGET_ZERO_AUTH_ENV] === "1" }));
+  registerChildWatchdog(dm);
+  const waitToolConfig = resolveWaitToolConfig();
+  const waitState = {
+    baseCwd: "",
+    currentSessionId: null,
+    asyncJobs: new Map,
+    foregroundControls: new Map,
+    lastForegroundControlId: null,
+    cleanupTimers: new Map,
+    lastUiContext: null,
+    poller: null,
+    completionSeen: new Map,
+    watcher: null,
+    watcherRestartTimer: null,
+    resultFileCoalescer: { schedule: () => false, clear: () => {} }
+  };
+  if (typeof dm.registerTool === "function")
+    registerWaitTool(dm, waitState, waitToolConfig.enabled, undefined, waitToolConfig.defaultTimeoutMs);
   let nativeSupervisorClientRegistered = false;
-  let nativeSupervisorFallbackRegistered = false;
   const registerNativeSupervisorClientOnce = () => {
     if (nativeSupervisorClientRegistered)
       return;
     nativeSupervisorClientRegistered = true;
-    registerNativeSupervisorClient(pi, { includeIntercomFallback: false });
+    registerNativeSupervisorClient(dm);
   };
-  const registerNativeSupervisorFallbackOnce = () => {
+  const onRuntimeEvent = dm.on;
+  onRuntimeEvent("session_start", (_event, ctx) => {
+    const sessionManager = ctx?.sessionManager;
+    waitState.currentSessionId = sessionManager ? resolveCurrentSessionId(sessionManager) : null;
     registerNativeSupervisorClientOnce();
-    if (nativeSupervisorFallbackRegistered)
+  });
+  onRuntimeEvent("agent_start", () => {
+    const diagnostic = refreshChildToolDiagnostic(dm);
+    if (diagnostic)
+      throw new Error(formatChildToolDiagnostic(diagnostic));
+  });
+  onRuntimeEvent("agent_end", async (_event, ctx) => {
+    if (ctx?.hasUI === true)
       return;
-    nativeSupervisorFallbackRegistered = true;
-    registerNativeSupervisorClient(pi);
-  };
-  const onRuntimeEvent = pi.on;
-  onRuntimeEvent("session_start", registerNativeSupervisorClientOnce);
+    await drainOutstandingWork({ state: waitState, events: dm.events });
+  });
   const structuredOutputPath = process.env[STRUCTURED_OUTPUT_CAPTURE_ENV];
+  const structuredAcceptanceReportPath = process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV];
   const structuredSchemaPath = process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
   if (structuredOutputPath && structuredSchemaPath) {
     const schema = JSON.parse(fs.readFileSync(structuredSchemaPath, "utf-8"));
-    const parameters = {
-      type: "object",
-      properties: { value: schema },
-      required: ["value"],
-      additionalProperties: false
-    };
-    const registerTool = pi.registerTool;
+    const parameters = createStructuredOutputToolParameters(schema, { acceptanceReport: Boolean(structuredAcceptanceReportPath) });
+    const registerTool = dm.registerTool;
     registerTool({
       name: "structured_output",
       label: "Structured Output",
       description: "Submit the required final structured output for this subagent step. This terminates the step.",
       parameters,
       async execute(_id, params) {
-        const validation = validateStructuredOutputValue(schema, params.value);
+        const validation = await validateStructuredOutputValue(schema, params.value);
         if (validation.status === "invalid") {
           throw new Error(`Structured output validation failed: ${validation.message}`);
         }
         fs.mkdirSync(path.dirname(structuredOutputPath), { recursive: true });
         fs.writeFileSync(structuredOutputPath, JSON.stringify(params.value), { mode: 384 });
+        if (structuredAcceptanceReportPath && params.acceptanceReport !== undefined) {
+          fs.writeFileSync(structuredAcceptanceReportPath, JSON.stringify(params.acceptanceReport), { mode: 384 });
+        }
         return {
           content: [{ type: "text", text: "Structured output captured." }],
           details: { path: structuredOutputPath },
@@ -309,28 +775,40 @@ export default function registerSubagentPromptRuntime(pi) {
       }
     });
   }
-  onRuntimeEvent("context", (event) => {
-    const messages = stripParentOnlySubagentMessages(event.messages);
+  onRuntimeEvent("before_provider_request", (event, ctx) => rewriteForkCacheProviderRequest(event, ctx));
+  onRuntimeEvent("context", (event, ctx) => {
+    if (!event || typeof event !== "object" || !("messages" in event) || !Array.isArray(event.messages))
+      return;
+    const messages = stripParentOnlySubagentMessages(event.messages, {
+      sanitizeToolIds: !COMPOSITE_TOOL_ID_APIS.has(ctx?.model?.api ?? "")
+    });
     if (messages === event.messages)
       return;
     return { messages };
   });
   onRuntimeEvent("before_agent_start", async (event) => {
-    registerNativeSupervisorFallbackOnce();
+    if (!event || typeof event !== "object" || !("systemPrompt" in event) || typeof event.systemPrompt !== "string")
+      return;
+    registerNativeSupervisorClientOnce();
     const intercomSessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
-    if (intercomSessionName && typeof pi.setSessionName === "function") {
-      pi.setSessionName(intercomSessionName);
+    const displaySessionName = process.env[SUBAGENT_SESSION_NAME_ENV]?.trim();
+    const childSessionName = intercomSessionName || displaySessionName;
+    if (childSessionName && typeof dm.setSessionName === "function") {
+      dm.setSessionName(childSessionName);
     }
     const inheritProjectContext = readBooleanEnv(SUBAGENT_INHERIT_PROJECT_CONTEXT_ENV);
+    const inheritGlobalContext = readBooleanEnv(SUBAGENT_INHERIT_GLOBAL_CONTEXT_ENV);
     const inheritSkills = readBooleanEnv(SUBAGENT_INHERIT_SKILLS_ENV);
     const fanoutChild = readBooleanEnv(SUBAGENT_FANOUT_CHILD_ENV);
-    if (inheritProjectContext === undefined && inheritSkills === undefined && fanoutChild === undefined)
-      return;
-    const rewritten = rewriteSubagentPrompt(event.systemPrompt, {
-      inheritProjectContext: inheritProjectContext ?? true,
-      inheritSkills: inheritSkills ?? true,
-      fanoutChild: fanoutChild === true
-    });
+    let rewritten = event.systemPrompt;
+    if (inheritProjectContext !== undefined || inheritGlobalContext !== undefined || inheritSkills !== undefined || fanoutChild !== undefined) {
+      rewritten = rewriteSubagentPrompt(event.systemPrompt, {
+        inheritProjectContext: inheritProjectContext ?? true,
+        inheritGlobalContext: inheritGlobalContext ?? true,
+        inheritSkills: inheritSkills ?? true,
+        fanoutChild: fanoutChild === true
+      });
+    }
     if (rewritten === event.systemPrompt)
       return;
     return { systemPrompt: rewritten };