@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/intercom/native-supervisor-channel.js

@@ -2,17 +2,14 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { Type } from "typebox";
-import {
-  SUBAGENT_CHILD_AGENT_ENV,
-  SUBAGENT_CHILD_INDEX_ENV,
-  SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV,
-  SUBAGENT_ORCHESTRATOR_TARGET_ENV,
-  SUBAGENT_RUN_ID_ENV,
-  SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV
-} from "../runs/shared/dm-args.js";
 import { INTERCOM_DETACH_REQUEST_EVENT, POLL_INTERVAL_MS, TEMP_ROOT_DIR } from "../shared/types.js";
 import { writeAtomicJson } from "../shared/atomic-json.js";
 import { shouldUseNativeFsWatch } from "../shared/watch-strategy.js";
+import {
+  SUPERVISOR_REQUEST_MESSAGE_TYPE,
+  SUPERVISOR_REPLY_ENTRY_TYPE,
+  supervisorReplyHint
+} from "./supervisor-ui.js";
 const SUPERVISOR_CHANNEL_ROOT = path.join(TEMP_ROOT_DIR, "supervisor-channels");
 const REQUESTS_DIR = "requests";
 const REPLIES_DIR = "replies";
@@ -23,13 +20,15 @@ const CHANNEL_POLL_MS = Math.min(POLL_INTERVAL_MS, 500);
 const CHANNEL_SAFETY_POLL_MS = 5000;
 const STALE_EMPTY_CHANNEL_AGE_MS = 60 * 1000;
 const STALE_EMPTY_CHANNEL_CLEANUP_INTERVAL_MS = 60 * 1000;
+const MAX_SUPERVISOR_REQUEST_CORRELATIONS = 256;
+const SUPERVISOR_REQUEST_CORRELATION_RETENTION_MS = 10 * 60 * 1000;
 const ContactSupervisorParamsSchema = Type.Object({
   reason: Type.String({ enum: ["need_decision", "interview_request", "progress_update"] }),
   message: Type.Optional(Type.String()),
   interview: Type.Optional(Type.Unsafe({ type: "object", additionalProperties: true }))
 }, { additionalProperties: false });
 const IntercomParamsSchema = Type.Object({
-  action: Type.String({ enum: ["list", "send", "ask", "reply", "pending", "status"] }),
+  action: Type.String({ enum: ["list", "pending", "status", "reply"] }),
   to: Type.Optional(Type.String()),
   message: Type.Optional(Type.String()),
   replyTo: Type.Optional(Type.String())
@@ -50,28 +49,6 @@ function requestPath(channelDir, requestId) {
 function replyPath(channelDir, requestId) {
   return path.join(channelDir, REPLIES_DIR, `${safeSegment(requestId)}.json`);
 }
-function readTextEnv(name) {
-  const value = process.env[name]?.trim();
-  return value ? value : undefined;
-}
-function readChildMetadata() {
-  const channelDir = readTextEnv(SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV);
-  const runId = readTextEnv(SUBAGENT_RUN_ID_ENV);
-  const agent = readTextEnv(SUBAGENT_CHILD_AGENT_ENV);
-  const rawIndex = readTextEnv(SUBAGENT_CHILD_INDEX_ENV);
-  const orchestratorSessionId = readTextEnv(SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV);
-  if (!channelDir || !runId || !agent || !orchestratorSessionId || rawIndex === undefined || !/^\d+$/.test(rawIndex))
-    return;
-  return {
-    channelDir,
-    runId,
-    agent,
-    childIndex: Number(rawIndex),
-    orchestratorTarget: readTextEnv(SUBAGENT_ORCHESTRATOR_TARGET_ENV),
-    orchestratorSessionId,
-    childTarget: readTextEnv("DM_SUBAGENT_INTERCOM_SESSION_NAME")
-  };
-}
 function reasonHeading(reason) {
   if (reason === "interview_request")
     return "Subagent requests a structured supervisor interview.";
@@ -79,26 +56,6 @@ function reasonHeading(reason) {
     return "Subagent progress update.";
   return "Subagent needs a supervisor decision.";
 }
-function formatChildMessage(input) {
-  const lines = [
-    reasonHeading(input.reason),
-    `Run: ${input.runId}`,
-    `Agent: ${input.agent}`,
-    `Child index: ${input.childIndex}`
-  ];
-  if (input.childTarget)
-    lines.push(`Child intercom target: ${input.childTarget}`);
-  lines.push("");
-  if (input.message?.trim())
-    lines.push(input.message.trim());
-  if (input.reason === "interview_request") {
-    lines.push("", "Structured response requested. Reply with JSON, optionally fenced in ```json, matching the requested interview shape.");
-    if (input.interview !== undefined)
-      lines.push(JSON.stringify(input.interview, null, "\t"));
-  }
-  return lines.join(`
-`).trimEnd();
-}
 function parseStructuredReply(message) {
   const trimmed = message.trim();
   const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1]?.trim();
@@ -150,12 +107,9 @@ async function waitForReply(channelDir, requestId, deadline, signal) {
   }
   throw new Error("Timed out waiting for supervisor reply.");
 }
-async function sendSupervisorRequest(params, signal) {
-  const metadata = readChildMetadata();
-  if (!metadata)
-    throw new Error("Native supervisor channel is not available for this subagent.");
-  if (params.reason !== "progress_update" && !params.message?.trim() && params.reason !== "interview_request") {
-    throw new Error("message is required for supervisor decisions.");
+async function sendSupervisorRequest(params, metadata, signal, toolCallId) {
+  if (!params.message?.trim() && params.reason !== "interview_request") {
+    throw new Error("message is required for supervisor decisions and progress updates.");
   }
   ensureSupervisorChannelDir(metadata.channelDir);
   const requestId = randomUUID();
@@ -163,7 +117,8 @@ async function sendSupervisorRequest(params, signal) {
   const createdAt = Date.now();
   const replyDeadline = createdAt + askTimeoutMs();
   const expiresAt = expectsReply ? replyDeadline : undefined;
-  const message = formatChildMessage({ ...metadata, reason: params.reason, message: params.message, interview: params.interview });
+  const message = params.message?.trim() ?? "";
+  const requestToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : undefined;
   const request = {
     type: "subagent.supervisor.request",
     id: requestId,
@@ -177,6 +132,7 @@ async function sendSupervisorRequest(params, signal) {
     runId: metadata.runId,
     agent: metadata.agent,
     childIndex: metadata.childIndex,
+    ...requestToolCallId ? { toolCallId: requestToolCallId } : {},
     ...metadata.childTarget ? { childTarget: metadata.childTarget } : {},
     ...params.interview !== undefined ? { interview: params.interview } : {}
   };
@@ -217,16 +173,16 @@ function hasTool(dm, name) {
     return false;
   }
 }
-export function registerNativeSupervisorClient(dm) {
-  if (!readChildMetadata() || hasTool(dm, "contact_supervisor"))
+export function registerNativeSupervisorClient(dm, metadata) {
+  if (!metadata || hasTool(dm, "contact_supervisor"))
     return;
   const tool = {
     name: "contact_supervisor",
     label: "Contact Supervisor",
     description: "Contact the parent/supervisor session for a blocking decision, structured interview, or progress update.",
     parameters: ContactSupervisorParamsSchema,
-    execute(_id, params, signal) {
-      return sendSupervisorRequest(params, signal);
+    execute(id, params, signal) {
+      return sendSupervisorRequest(params, metadata, signal, id);
     }
   };
   dm.registerTool(tool);
@@ -240,29 +196,36 @@ function parseRequestFile(file, channelDir) {
       return;
     if (parsed.reason !== "need_decision" && parsed.reason !== "interview_request" && parsed.reason !== "progress_update")
       return;
-    if (typeof parsed.message !== "string" || !parsed.message)
+    if (typeof parsed.message !== "string" || !parsed.message.trim() && parsed.reason !== "interview_request")
       return;
     if (typeof parsed.runId !== "string" || typeof parsed.agent !== "string" || typeof parsed.childIndex !== "number")
       return;
-    return { ...parsed, channelDir, requestFile: file };
+    return {
+      ...parsed,
+      ...typeof parsed.toolCallId === "string" && parsed.toolCallId.length > 0 ? { toolCallId: parsed.toolCallId } : { toolCallId: undefined },
+      channelDir,
+      requestFile: file
+    };
   } catch {
     return;
   }
 }
-function listRequestFiles() {
-  let channelEntries;
-  try {
-    channelEntries = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return [];
-    throw error;
+function isMissingSupervisorDirectory(error, platform) {
+  const code = error.code;
+  return code === "ENOENT" || platform === "win32" && code === "UNKNOWN";
+}
+function listRequestFiles(channelDirs, platform) {
+  if (!channelDirs) {
+    try {
+      channelDirs = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(SUPERVISOR_CHANNEL_ROOT, entry.name));
+    } catch (error) {
+      if (isMissingSupervisorDirectory(error, platform))
+        return [];
+      throw error;
+    }
   }
   const files = [];
-  for (const entry of channelEntries) {
-    if (!entry.isDirectory())
-      continue;
-    const channelDir = path.join(SUPERVISOR_CHANNEL_ROOT, entry.name);
+  for (const channelDir of channelDirs) {
     const requestsDir = path.join(channelDir, REQUESTS_DIR);
     let requestEntries;
     try {
@@ -277,11 +240,11 @@ function listRequestFiles() {
   }
   return files;
 }
-function readDirectoryEntries(dir) {
+function readDirectoryEntries(dir, platform) {
   try {
     return fs.readdirSync(dir, { withFileTypes: true });
   } catch (error) {
-    if (error.code === "ENOENT")
+    if (isMissingSupervisorDirectory(error, platform))
       return [];
     return;
   }
@@ -306,16 +269,16 @@ function removeEmptyDirectory(dir) {
     throw error;
   }
 }
-function removeStaleEmptySupervisorChannel(channelDir, nowMs) {
+function removeStaleEmptySupervisorChannel(channelDir, nowMs, platform) {
   const requestsDir = path.join(channelDir, REQUESTS_DIR);
   const repliesDir = path.join(channelDir, REPLIES_DIR);
   const newestKnownMtimeMs = Math.max(directoryMtimeMs(channelDir), directoryMtimeMs(requestsDir), directoryMtimeMs(repliesDir));
   if (nowMs - newestKnownMtimeMs < STALE_EMPTY_CHANNEL_AGE_MS)
     return false;
-  const requestEntries = readDirectoryEntries(requestsDir);
+  const requestEntries = readDirectoryEntries(requestsDir, platform);
   if (!requestEntries || requestEntries.length > 0)
     return false;
-  const replyEntries = readDirectoryEntries(repliesDir);
+  const replyEntries = readDirectoryEntries(repliesDir, platform);
   if (!replyEntries || replyEntries.length > 0)
     return false;
   if (!removeEmptyDirectory(requestsDir))
@@ -326,12 +289,12 @@ function removeStaleEmptySupervisorChannel(channelDir, nowMs) {
     return false;
   return true;
 }
-function cleanupStaleEmptySupervisorChannels(nowMs = Date.now()) {
+function cleanupStaleEmptySupervisorChannels(nowMs = Date.now(), platform = process.platform) {
   let channelEntries;
   try {
     channelEntries = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true });
   } catch (error) {
-    if (error.code === "ENOENT")
+    if (isMissingSupervisorDirectory(error, platform))
       return 0;
     throw error;
   }
@@ -340,22 +303,14 @@ function cleanupStaleEmptySupervisorChannels(nowMs = Date.now()) {
     if (!entry.isDirectory())
       continue;
     try {
-      if (removeStaleEmptySupervisorChannel(path.join(SUPERVISOR_CHANNEL_ROOT, entry.name), nowMs))
+      if (removeStaleEmptySupervisorChannel(path.join(SUPERVISOR_CHANNEL_ROOT, entry.name), nowMs, platform))
         removed++;
     } catch {}
   }
   return removed;
 }
-function currentContextSessionId(state, ctx) {
-  try {
-    const sessionId = ctx.sessionManager.getSessionId();
-    if (sessionId)
-      return sessionId;
-  } catch {}
-  return state.currentSessionId ?? undefined;
-}
-function requestMatchesContext(request, state, ctx) {
-  const currentSessionId = currentContextSessionId(state, ctx);
+function requestMatchesOwner(request, state) {
+  const currentSessionId = state.supervisorOwnerSessionId;
   return Boolean(currentSessionId && request.orchestratorSessionId === currentSessionId);
 }
 function rememberedForegroundChild(request, state) {
@@ -414,8 +369,8 @@ function requestRunInactive(request, state) {
   const stepStatus = asyncJob.steps?.[request.childIndex]?.status;
   return stepStatus === "complete" || stepStatus === "completed" || stepStatus === "failed" || stepStatus === "paused";
 }
-function requestLifecycle(request, state, ctx, now) {
-  if (ctx && !requestMatchesContext(request, state, ctx))
+function requestLifecycle(request, state, now, runState) {
+  if (!requestMatchesOwner(request, state))
     return "wrong-session";
   if (!fs.existsSync(request.requestFile))
     return "missing";
@@ -423,7 +378,7 @@ function requestLifecycle(request, state, ctx, now) {
     return "resolved";
   if (request.expectsReply && now > requestExpiresAt(request, now))
     return "expired";
-  if (request.expectsReply && requestRunInactive(request, state))
+  if (request.expectsReply && requestRunInactive(request, runState))
     return "inactive";
   return "pending";
 }
@@ -431,27 +386,44 @@ function cleanupRequestLifecycle(request, lifecycle) {
   if (lifecycle === "resolved" || lifecycle === "expired" || lifecycle === "inactive")
     removeRequestFile(request.requestFile);
 }
-function refreshPendingRequests(pending, state, ctx) {
+function refreshPendingRequests(pending, state, onLifecycle, runState) {
   const now = Date.now();
   for (const request of pending.values()) {
-    const lifecycle = requestLifecycle(request, state, ctx, now);
+    const lifecycle = requestLifecycle(request, state, now, runState(request));
     if (lifecycle === "pending")
       continue;
     pending.delete(request.id);
+    onLifecycle(request, lifecycle);
     cleanupRequestLifecycle(request, lifecycle);
   }
 }
 function formatPendingLine(request) {
-  const replyHint = request.expectsReply ? ` Reply: ${NATIVE_SUPERVISOR_TOOL_NAME}({ action: "reply", replyTo: "${request.id}", message: "..." })` : "";
-  return `- ${request.id}: ${request.agent} [${request.runId}#${request.childIndex}] ${request.reason}.${replyHint}`;
+  const replyHint = request.expectsReply ? ` Reply: ${supervisorReplyHint(request.id)}` : "";
+  const header = `- ${request.id}: ${request.agent} [${request.runId}#${request.childIndex}] ${request.reason}.${replyHint}`;
+  return request.message ? `${header}
+  ${request.message.replace(/\n/g, `
+  `)}` : header;
 }
 function requestVisibleText(request) {
-  const lines = [request.message];
-  if (request.expectsReply) {
-    lines.push("", `Reply with: ${NATIVE_SUPERVISOR_TOOL_NAME}({ action: "reply", replyTo: "${request.id}", message: "..." })`);
+  const lines = [
+    reasonHeading(request.reason),
+    `Run: ${request.runId}`,
+    `Agent: ${request.agent}`,
+    `Child index: ${request.childIndex}`
+  ];
+  lines.push("");
+  if (request.message)
+    lines.push(request.message);
+  if (request.reason === "interview_request") {
+    lines.push("", "Structured response requested. Reply with JSON, optionally fenced in ```json, matching the requested interview shape.");
+    if (request.interview !== undefined)
+      lines.push(JSON.stringify(request.interview, null, "\t"));
   }
+  if (request.expectsReply)
+    lines.push("", `Reply with: ${supervisorReplyHint(request.id)}`);
+  lines.push("", `Live guidance: subagent({ action: "steer", id: ${JSON.stringify(request.runId)}, index: ${request.childIndex}, message: "..." })${request.expectsReply ? " (Reply to the pending request first.)" : ""}`);
   return lines.join(`
-`);
+`).trimEnd();
 }
 function writeReply(request, message) {
   if (!message.trim())
@@ -464,6 +436,26 @@ function writeReply(request, message) {
   };
   writeAtomicJson(replyPath(request.channelDir, request.id), reply);
   removeRequestFile(request.requestFile);
+  return reply;
+}
+function appendSupervisorReplyEntry(dm, request, reply) {
+  const appendEntry = dm.appendEntry;
+  if (typeof appendEntry !== "function")
+    return;
+  try {
+    appendEntry.call(dm, SUPERVISOR_REPLY_ENTRY_TYPE, {
+      requestId: request.id,
+      reason: request.reason,
+      runId: request.runId,
+      agent: request.agent,
+      childIndex: request.childIndex,
+      ...request.childTarget ? { childTarget: request.childTarget } : {},
+      message: reply.message,
+      createdAt: reply.createdAt
+    });
+  } catch (error) {
+    console.error("Failed to journal native supervisor reply:", error);
+  }
 }
 function resolvePendingRequest(pending, params) {
   if (params.replyTo) {
@@ -480,6 +472,7 @@ function resolvePendingRequest(pending, params) {
       return matches[0];
     if (matches.length > 1)
       throw new Error(`Multiple pending supervisor requests match '${params.to}'. Use replyTo.`);
+    throw new Error(`No pending supervisor request matches '${params.to}'. Use replyTo.`);
   }
   if (requests.length === 1)
     return requests[0];
@@ -497,14 +490,15 @@ function publicPendingRequests(pending) {
     expectsReply: request.expectsReply
   }));
 }
-function buildParentSupervisorTool(pending, state) {
+function buildParentSupervisorTool(dm, pending, state, onLifecycle, discover, runState) {
   return {
     name: NATIVE_SUPERVISOR_TOOL_NAME,
     label: "Subagent Supervisor",
     description: "Native dm-subagents supervisor channel. Use reply/pending/status to answer child subagent requests without overriding dm-intercom.",
     parameters: IntercomParamsSchema,
     async execute(_id, params) {
-      refreshPendingRequests(pending, state, state.lastUiContext ?? undefined);
+      discover();
+      refreshPendingRequests(pending, state, onLifecycle, runState);
       const input = params;
       if (input.action === "status") {
         return { content: [{ type: "text", text: `Native supervisor channel active. Pending replies: ${pending.size}.` }], details: { active: true, pending: pending.size, root: SUPERVISOR_CHANNEL_ROOT } };
@@ -516,14 +510,13 @@ function buildParentSupervisorTool(pending, state) {
       }
       if (input.action === "reply") {
         const request = resolvePendingRequest(pending, input);
-        writeReply(request, input.message ?? "");
+        const reply = writeReply(request, input.message ?? "");
+        appendSupervisorReplyEntry(dm, request, reply);
+        onLifecycle(request, "resolved");
         pending.delete(request.id);
         clearForegroundSupervisorAttention(request, pending, state);
         return { content: [{ type: "text", text: `Replied to supervisor request ${request.id}.` }], details: { replyTo: request.id, runId: request.runId, agent: request.agent } };
       }
-      if (input.action === "send" || input.action === "ask") {
-        throw new Error("The native subagent supervisor handles replies only. Child agents initiate asks with contact_supervisor.");
-      }
       throw new Error(`Unsupported supervisor action: ${input.action}`);
     }
   };
@@ -531,7 +524,72 @@ function buildParentSupervisorTool(pending, state) {
 export function createNativeSupervisorChannel(dm, state, deps = {}) {
   const watch = deps.watch ?? fs.watch;
   const timers = deps.timers ?? globalThis;
+  const runState = (request) => {
+    for (const ownerState of deps.getCurrentOwnerStates?.() ?? []) {
+      if (ownerState.asyncJobs.has(request.runId))
+        return ownerState;
+    }
+    return state;
+  };
   const pending = new Map;
+  const requestCorrelations = new Map;
+  const correlationKey = (request) => {
+    if (!request.toolCallId)
+      return;
+    return JSON.stringify([request.runId, request.agent, request.childIndex, request.toolCallId]);
+  };
+  const pruneRequestCorrelations = (now = Date.now()) => {
+    for (const [key, correlation] of requestCorrelations) {
+      if (correlation.state === "resolved" && now - correlation.updatedAt > SUPERVISOR_REQUEST_CORRELATION_RETENTION_MS)
+        requestCorrelations.delete(key);
+    }
+    while (requestCorrelations.size > MAX_SUPERVISOR_REQUEST_CORRELATIONS) {
+      const oldest = requestCorrelations.keys().next().value;
+      if (oldest === undefined)
+        break;
+      requestCorrelations.delete(oldest);
+    }
+  };
+  const rememberPendingRequest = (request) => {
+    const key = correlationKey(request);
+    if (!key || !request.expectsReply)
+      return;
+    requestCorrelations.set(key, { request, state: "pending", updatedAt: Date.now() });
+    pruneRequestCorrelations();
+  };
+  const rememberResolvedRequest = (request) => {
+    const key = correlationKey(request);
+    if (!key || !request.expectsReply)
+      return;
+    requestCorrelations.set(key, { request, state: "resolved", updatedAt: Date.now() });
+    pruneRequestCorrelations();
+  };
+  const observeRequestLifecycle = (request, lifecycle) => {
+    if (lifecycle !== "wrong-session")
+      rememberResolvedRequest(request);
+  };
+  const getSupervisorRequestState = (event) => {
+    if (event.currentTool === "intercom" || event.index === undefined)
+      return "unknown";
+    const toolCallId = typeof event.toolCallId === "string" && event.toolCallId.length > 0 ? event.toolCallId : undefined;
+    if (!toolCallId)
+      return "unknown";
+    pruneRequestCorrelations();
+    const key = correlationKey({ runId: event.runId, agent: event.agent, childIndex: event.index, toolCallId });
+    if (!key)
+      return "unknown";
+    const correlation = requestCorrelations.get(key);
+    if (!correlation)
+      return "unknown";
+    if (correlation.state === "resolved")
+      return "resolved";
+    const now = Date.now();
+    if (!fs.existsSync(correlation.request.requestFile) || fs.existsSync(replyPath(correlation.request.channelDir, correlation.request.id)) || now > requestExpiresAt(correlation.request, now) || requestRunInactive(correlation.request, runState(correlation.request))) {
+      rememberResolvedRequest(correlation.request);
+      return "resolved";
+    }
+    return "pending";
+  };
   const seenFiles = new Set;
   const requestWatchers = new Map;
   let rootWatcher;
@@ -541,84 +599,104 @@ export function createNativeSupervisorChannel(dm, state, deps = {}) {
   let started = false;
   let lastStaleCleanupAt = 0;
   const platform = deps.platform ?? process.platform;
-  const useNativeWatcher = () => shouldUseNativeFsWatch("supervisor-channel", platform) && platform !== "win32";
+  const useNativeWatcher = () => !deps.getChannelDirs && shouldUseNativeFsWatch("supervisor-channel", platform) && platform !== "win32";
   const hasTransportDemand = () => {
     if (pending.size > 0)
       return true;
     if (state.foregroundControls.size > 0)
       return true;
-    return [...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running");
+    if (deps.getChannelDirs?.().dirs.length)
+      return true;
+    if ([...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running"))
+      return true;
+    for (const ownerState of deps.getCurrentOwnerStates?.() ?? []) {
+      for (const job of ownerState.asyncJobs.values()) {
+        if (job.status === "queued" || job.status === "running")
+          return true;
+      }
+    }
+    return false;
   };
   const registerParentTools = () => {
     if (!hasTool(dm, NATIVE_SUPERVISOR_TOOL_NAME))
-      dm.registerTool(buildParentSupervisorTool(pending, state));
+      dm.registerTool(buildParentSupervisorTool(dm, pending, state, observeRequestLifecycle, () => poll(), runState));
   };
   const cleanupStaleChannelsIfDue = () => {
+    if (deps.getChannelDirs)
+      return;
     const nowMs = Date.now();
     if (nowMs - lastStaleCleanupAt < STALE_EMPTY_CHANNEL_CLEANUP_INTERVAL_MS)
       return;
     lastStaleCleanupAt = nowMs;
     try {
-      cleanupStaleEmptySupervisorChannels(nowMs);
+      cleanupStaleEmptySupervisorChannels(nowMs, platform);
     } catch {}
   };
   const poll = () => {
     cleanupStaleChannelsIfDue();
-    const ctx = state.lastUiContext;
-    if (!ctx)
-      return;
-    refreshPendingRequests(pending, state, ctx);
+    refreshPendingRequests(pending, state, observeRequestLifecycle, runState);
     const now = Date.now();
-    for (const { channelDir, file } of listRequestFiles()) {
+    const channels = deps.getChannelDirs?.();
+    for (const { channelDir, file } of listRequestFiles(channels?.dirs, platform)) {
       if (seenFiles.has(file))
         continue;
       const request = parseRequestFile(file, channelDir);
-      if (!request || !requestMatchesContext(request, state, ctx))
+      if (!request || !requestMatchesOwner(request, state))
         continue;
-      const lifecycle = requestLifecycle(request, state, undefined, now);
+      const lifecycle = requestLifecycle(request, state, now, runState(request));
       if (lifecycle !== "pending") {
         seenFiles.add(file);
+        observeRequestLifecycle(request, lifecycle);
         cleanupRequestLifecycle(request, lifecycle);
         continue;
       }
       seenFiles.add(file);
-      if (request.expectsReply) {
-        pending.set(request.id, request);
-        markForegroundSupervisorAttention(request, state);
-      } else {
+      if (!request.expectsReply) {
         removeRequestFile(request.requestFile);
+        continue;
       }
-      dm.sendMessage({
-        customType: "subagent_supervisor_request",
-        content: requestVisibleText(request),
-        display: true,
-        details: {
-          id: request.id,
-          reason: request.reason,
-          expectsReply: request.expectsReply,
-          runId: request.runId,
-          agent: request.agent,
-          childIndex: request.childIndex
-        }
-      }, { triggerTurn: true });
-      if (request.expectsReply) {
-        dm.events?.emit(INTERCOM_DETACH_REQUEST_EVENT, {
-          requestId: request.id,
-          runId: request.runId,
-          agent: request.agent,
-          childIndex: request.childIndex
-        });
-        if (pending.has(request.id))
-          markForegroundSupervisorAttention(request, state);
+      rememberPendingRequest(request);
+      pending.set(request.id, request);
+      markForegroundSupervisorAttention(request, state);
+      try {
+        dm.sendMessage({
+          customType: SUPERVISOR_REQUEST_MESSAGE_TYPE,
+          content: requestVisibleText(request),
+          display: true,
+          details: {
+            id: request.id,
+            requestId: request.id,
+            reason: request.reason,
+            expectsReply: request.expectsReply,
+            runId: request.runId,
+            agent: request.agent,
+            childIndex: request.childIndex,
+            ...request.childTarget ? { childTarget: request.childTarget } : {},
+            ...request.interview !== undefined ? { interview: request.interview } : {},
+            requestBody: request.message,
+            replyHint: supervisorReplyHint(request.id)
+          }
+        }, { triggerTurn: true });
+      } catch (error) {
+        console.error(`Failed to surface supervisor request ${request.id} as a user turn:`, error);
       }
+      dm.events?.emit(INTERCOM_DETACH_REQUEST_EVENT, {
+        requestId: request.id,
+        runId: request.runId,
+        agent: request.agent,
+        childIndex: request.childIndex
+      });
+      if (pending.has(request.id))
+        markForegroundSupervisorAttention(request, state);
     }
+    channels?.retire?.();
   };
   const startPolling = () => {
     if (poller)
       return;
     poller = timers.setInterval(() => {
       poll();
-      if (!useNativeWatcher() && platform === "darwin" && !hasTransportDemand()) {
+      if (!useNativeWatcher() && (platform === "darwin" || deps.getChannelDirs) && !hasTransportDemand()) {
         if (poller)
           timers.clearInterval(poller);
         poller = undefined;
@@ -659,7 +737,7 @@ export function createNativeSupervisorChannel(dm, state, deps = {}) {
     try {
       channelEntries = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true });
     } catch (error) {
-      if (error.code === "ENOENT")
+      if (isMissingSupervisorDirectory(error, platform))
         return;
       startPolling();
       return;
@@ -682,6 +760,7 @@ export function createNativeSupervisorChannel(dm, state, deps = {}) {
     deferredWatcherRefresh.unref?.();
   };
   return {
+    registerTools: registerParentTools,
     activateTransport: () => {
       if (!started)
         return;
@@ -689,12 +768,36 @@ export function createNativeSupervisorChannel(dm, state, deps = {}) {
       if (!useNativeWatcher() && hasTransportDemand())
         startPolling();
     },
+    findPendingAsks: (target) => {
+      const channelDir = resolveSupervisorChannelDir(target.runId, target.agent, target.childIndex);
+      let files;
+      try {
+        files = fs.readdirSync(path.join(channelDir, REQUESTS_DIR));
+      } catch (error) {
+        if (isMissingSupervisorDirectory(error, platform))
+          return [];
+        throw error;
+      }
+      const now = Date.now();
+      return files.filter((file) => file.endsWith(".json")).flatMap((file) => {
+        const request = parseRequestFile(path.join(channelDir, REQUESTS_DIR, file), channelDir);
+        return request?.expectsReply && request.runId === target.runId && request.agent === target.agent && request.childIndex === target.childIndex && requestLifecycle(request, state, now, runState(request)) === "pending" ? [request.id] : [];
+      }).sort();
+    },
+    hasPendingRequests: () => {
+      if (!started)
+        return false;
+      poll();
+      return pending.size > 0;
+    },
     start: () => {
       if (started)
         return;
       started = true;
       registerParentTools();
       poll();
+      if (deps.getChannelDirs)
+        return;
       try {
         fs.mkdirSync(SUPERVISOR_CHANNEL_ROOT, { recursive: true });
         if (!useNativeWatcher()) {
@@ -737,8 +840,10 @@ export function createNativeSupervisorChannel(dm, state, deps = {}) {
         timers.clearImmediate(deferredWatcherRefresh);
       deferredWatcherRefresh = undefined;
       pending.clear();
+      requestCorrelations.clear();
       seenFiles.clear();
     },
-    pending
+    pending,
+    getSupervisorRequestState
   };
 }