@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -10,8 +10,9 @@ import {
   SUBAGENT_RUN_ID_ENV,
   SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV
 } from "../runs/shared/dm-args.js";
-import { POLL_INTERVAL_MS, TEMP_ROOT_DIR } from "../shared/types.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";
 const SUPERVISOR_CHANNEL_ROOT = path.join(TEMP_ROOT_DIR, "supervisor-channels");
 const REQUESTS_DIR = "requests";
 const REPLIES_DIR = "replies";
@@ -19,6 +20,9 @@ export const NATIVE_SUPERVISOR_TOOL_NAME = "subagent_supervisor";
 const MAX_MESSAGE_BYTES = 64 * 1024;
 const DEFAULT_ASK_TIMEOUT_MS = 10 * 60 * 1000;
 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 ContactSupervisorParamsSchema = Type.Object({
   reason: Type.String({ enum: ["need_decision", "interview_request", "progress_update"] }),
   message: Type.Optional(Type.String()),
@@ -131,9 +135,8 @@ function delay(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-async function waitForReply(channelDir, requestId, signal) {
+async function waitForReply(channelDir, requestId, deadline, signal) {
   const file = replyPath(channelDir, requestId);
-  const deadline = Date.now() + askTimeoutMs();
   while (Date.now() <= deadline) {
     if (signal?.aborted)
       throw new Error("Supervisor request cancelled.");
@@ -157,11 +160,15 @@ async function sendSupervisorRequest(params, signal) {
   ensureSupervisorChannelDir(metadata.channelDir);
   const requestId = randomUUID();
   const expectsReply = params.reason !== "progress_update";
+  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 request = {
     type: "subagent.supervisor.request",
     id: requestId,
-    createdAt: Date.now(),
+    createdAt,
+    ...expiresAt !== undefined ? { expiresAt } : {},
     reason: params.reason,
     message,
     expectsReply,
@@ -183,65 +190,46 @@ async function sendSupervisorRequest(params, signal) {
       details: { delivered: true, requestId, reason: params.reason }
     };
   }
-  const reply = await waitForReply(metadata.channelDir, requestId, signal);
-  const details = { requestId, reason: params.reason };
-  if (params.reason === "interview_request") {
-    const structured = parseStructuredReply(reply.message);
-    if (structured.error)
-      details.structuredReplyParseError = structured.error;
-    else
-      details.structuredReply = structured.value;
-  }
-  return {
-    content: [{ type: "text", text: `**Reply from supervisor:**
+  try {
+    const reply = await waitForReply(metadata.channelDir, requestId, replyDeadline, signal);
+    const details = { requestId, reason: params.reason };
+    if (params.reason === "interview_request") {
+      const structured = parseStructuredReply(reply.message);
+      if (structured.error)
+        details.structuredReplyParseError = structured.error;
+      else
+        details.structuredReply = structured.value;
+    }
+    return {
+      content: [{ type: "text", text: `**Reply from supervisor:**
 ${reply.message}` }],
-    details
-  };
+      details
+    };
+  } catch (error) {
+    removeRequestFile(requestPath(metadata.channelDir, requestId));
+    throw error;
+  }
 }
-function hasTool(pi, name) {
+function hasTool(dm, name) {
   try {
-    return pi.getAllTools?.().some((tool) => tool.name === name) === true;
+    return dm.getAllTools?.().some((tool) => tool.name === name) === true;
   } catch {
     return false;
   }
 }
-export function registerNativeSupervisorClient(pi, options = {}) {
-  if (!readChildMetadata())
+export function registerNativeSupervisorClient(dm) {
+  if (!readChildMetadata() || hasTool(dm, "contact_supervisor"))
     return;
-  const includeIntercomFallback = options.includeIntercomFallback !== false;
-  if (!hasTool(pi, "contact_supervisor")) {
-    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);
-      }
-    };
-    pi.registerTool(tool);
-  }
-  if (includeIntercomFallback && !hasTool(pi, "intercom")) {
-    const tool = {
-      name: "intercom",
-      label: "Intercom",
-      description: "Native supervisor-channel intercom fallback for subagents. Prefer contact_supervisor when available.",
-      parameters: IntercomParamsSchema,
-      async execute(_id, params, signal) {
-        const action = params.action;
-        if (action === "status")
-          return { content: [{ type: "text", text: "Native supervisor channel is active." }], details: { active: true } };
-        if (action === "list")
-          return { content: [{ type: "text", text: "Supervisor session available through contact_supervisor." }], details: { sessions: [] } };
-        if (action === "send")
-          return sendSupervisorRequest({ reason: "progress_update", message: params.message ?? "" }, signal);
-        if (action === "ask")
-          return sendSupervisorRequest({ reason: "need_decision", message: params.message ?? "" }, signal);
-        throw new Error("Native child intercom supports status, list, send, and ask. Use parent intercom reply from the supervisor session.");
-      }
-    };
-    pi.registerTool(tool);
-  }
+  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);
+    }
+  };
+  dm.registerTool(tool);
 }
 function parseRequestFile(file, channelDir) {
   try {
@@ -289,6 +277,75 @@ function listRequestFiles() {
   }
   return files;
 }
+function readDirectoryEntries(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    return;
+  }
+}
+function directoryMtimeMs(dir) {
+  try {
+    return fs.statSync(dir).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function removeEmptyDirectory(dir) {
+  try {
+    fs.rmdirSync(dir);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT")
+      return true;
+    if (code === "ENOTEMPTY" || code === "EEXIST" || code === "EPERM" || code === "EBUSY")
+      return false;
+    throw error;
+  }
+}
+function removeStaleEmptySupervisorChannel(channelDir, nowMs) {
+  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);
+  if (!requestEntries || requestEntries.length > 0)
+    return false;
+  const replyEntries = readDirectoryEntries(repliesDir);
+  if (!replyEntries || replyEntries.length > 0)
+    return false;
+  if (!removeEmptyDirectory(requestsDir))
+    return false;
+  if (!removeEmptyDirectory(repliesDir))
+    return false;
+  if (!removeEmptyDirectory(channelDir))
+    return false;
+  return true;
+}
+function cleanupStaleEmptySupervisorChannels(nowMs = Date.now()) {
+  let channelEntries;
+  try {
+    channelEntries = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return 0;
+    throw error;
+  }
+  let removed = 0;
+  for (const entry of channelEntries) {
+    if (!entry.isDirectory())
+      continue;
+    try {
+      if (removeStaleEmptySupervisorChannel(path.join(SUPERVISOR_CHANNEL_ROOT, entry.name), nowMs))
+        removed++;
+    } catch {}
+  }
+  return removed;
+}
 function currentContextSessionId(state, ctx) {
   try {
     const sessionId = ctx.sessionManager.getSessionId();
@@ -301,6 +358,89 @@ function requestMatchesContext(request, state, ctx) {
   const currentSessionId = currentContextSessionId(state, ctx);
   return Boolean(currentSessionId && request.orchestratorSessionId === currentSessionId);
 }
+function rememberedForegroundChild(request, state) {
+  const run = state.foregroundRuns?.get(request.runId);
+  const child = run?.children.find((candidate) => candidate.index === request.childIndex && candidate.agent === request.agent) ?? run?.children[request.childIndex];
+  return run && child ? { run, child } : undefined;
+}
+function markForegroundSupervisorAttention(request, state) {
+  const remembered = rememberedForegroundChild(request, state);
+  if (!remembered || remembered.child.status !== "detached")
+    return;
+  const updatedAt = Date.now();
+  remembered.run.updatedAt = updatedAt;
+  remembered.child.activityState = "needs_attention";
+  remembered.child.lastActivityAt = request.createdAt;
+  remembered.child.currentTool = "contact_supervisor";
+  remembered.child.currentToolStartedAt = request.createdAt;
+  remembered.child.updatedAt = updatedAt;
+}
+function clearForegroundSupervisorAttention(request, pending, state) {
+  if ([...pending.values()].some((candidate) => candidate.expectsReply && candidate.runId === request.runId && candidate.agent === request.agent && candidate.childIndex === request.childIndex))
+    return;
+  const remembered = rememberedForegroundChild(request, state);
+  if (!remembered || remembered.child.status !== "detached")
+    return;
+  const updatedAt = Date.now();
+  remembered.run.updatedAt = updatedAt;
+  remembered.child.activityState = undefined;
+  remembered.child.lastActivityAt = updatedAt;
+  remembered.child.currentTool = undefined;
+  remembered.child.currentToolStartedAt = undefined;
+  remembered.child.updatedAt = updatedAt;
+}
+function removeRequestFile(file) {
+  try {
+    fs.rmSync(file, { force: true });
+  } catch {}
+}
+function requestExpiresAt(request, now) {
+  const expiresAt = request.expiresAt;
+  if (typeof expiresAt === "number" && Number.isFinite(expiresAt))
+    return expiresAt;
+  return Number.isFinite(request.createdAt) ? request.createdAt + askTimeoutMs() : now;
+}
+function requestRunInactive(request, state) {
+  if (state.foregroundControls.has(request.runId))
+    return false;
+  const foreground = rememberedForegroundChild(request, state);
+  if (foreground)
+    return foreground.child.status !== "detached";
+  const asyncJob = state.asyncJobs.get(request.runId);
+  if (!asyncJob)
+    return false;
+  if (asyncJob.status === "complete" || asyncJob.status === "failed" || asyncJob.status === "paused")
+    return true;
+  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))
+    return "wrong-session";
+  if (!fs.existsSync(request.requestFile))
+    return "missing";
+  if (request.expectsReply && fs.existsSync(replyPath(request.channelDir, request.id)))
+    return "resolved";
+  if (request.expectsReply && now > requestExpiresAt(request, now))
+    return "expired";
+  if (request.expectsReply && requestRunInactive(request, state))
+    return "inactive";
+  return "pending";
+}
+function cleanupRequestLifecycle(request, lifecycle) {
+  if (lifecycle === "resolved" || lifecycle === "expired" || lifecycle === "inactive")
+    removeRequestFile(request.requestFile);
+}
+function refreshPendingRequests(pending, state, ctx) {
+  const now = Date.now();
+  for (const request of pending.values()) {
+    const lifecycle = requestLifecycle(request, state, ctx, now);
+    if (lifecycle === "pending")
+      continue;
+    pending.delete(request.id);
+    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}`;
@@ -323,9 +463,7 @@ function writeReply(request, message) {
     message: message.trim()
   };
   writeAtomicJson(replyPath(request.channelDir, request.id), reply);
-  try {
-    fs.rmSync(request.requestFile, { force: true });
-  } catch {}
+  removeRequestFile(request.requestFile);
 }
 function resolvePendingRequest(pending, params) {
   if (params.replyTo) {
@@ -359,13 +497,14 @@ function publicPendingRequests(pending) {
     expectsReply: request.expectsReply
   }));
 }
-function buildParentIntercomTool(pending, name = "intercom") {
+function buildParentSupervisorTool(pending, state) {
   return {
-    name,
-    label: name === "intercom" ? "Intercom" : "Subagent Supervisor",
-    description: name === "intercom" ? "Native dm-subagents supervisor channel. Use reply/pending/status to answer child subagent requests." : "Native dm-subagents supervisor channel. Use reply/pending/status to answer child subagent requests without overriding the optional intercom compatibility extension.",
+    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);
       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 } };
@@ -379,44 +518,77 @@ function buildParentIntercomTool(pending, name = "intercom") {
         const request = resolvePendingRequest(pending, input);
         writeReply(request, input.message ?? "");
         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("Native dm-subagents intercom currently handles supervisor replies. Child agents initiate asks with contact_supervisor.");
+        throw new Error("The native subagent supervisor handles replies only. Child agents initiate asks with contact_supervisor.");
       }
-      throw new Error(`Unsupported intercom action: ${input.action}`);
+      throw new Error(`Unsupported supervisor action: ${input.action}`);
     }
   };
 }
-export function createNativeSupervisorChannel(pi, state) {
+export function createNativeSupervisorChannel(dm, state, deps = {}) {
+  const watch = deps.watch ?? fs.watch;
+  const timers = deps.timers ?? globalThis;
   const pending = new Map;
   const seenFiles = new Set;
+  const requestWatchers = new Map;
+  let rootWatcher;
   let poller;
+  let safetyPoller;
+  let deferredWatcherRefresh;
+  let started = false;
+  let lastStaleCleanupAt = 0;
+  const platform = deps.platform ?? process.platform;
+  const useNativeWatcher = () => 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");
+  };
   const registerParentTools = () => {
-    if (!hasTool(pi, NATIVE_SUPERVISOR_TOOL_NAME))
-      pi.registerTool(buildParentIntercomTool(pending, NATIVE_SUPERVISOR_TOOL_NAME));
-    if (!hasTool(pi, "intercom"))
-      pi.registerTool(buildParentIntercomTool(pending));
+    if (!hasTool(dm, NATIVE_SUPERVISOR_TOOL_NAME))
+      dm.registerTool(buildParentSupervisorTool(pending, state));
+  };
+  const cleanupStaleChannelsIfDue = () => {
+    const nowMs = Date.now();
+    if (nowMs - lastStaleCleanupAt < STALE_EMPTY_CHANNEL_CLEANUP_INTERVAL_MS)
+      return;
+    lastStaleCleanupAt = nowMs;
+    try {
+      cleanupStaleEmptySupervisorChannels(nowMs);
+    } catch {}
   };
   const poll = () => {
+    cleanupStaleChannelsIfDue();
     const ctx = state.lastUiContext;
     if (!ctx)
       return;
+    refreshPendingRequests(pending, state, ctx);
+    const now = Date.now();
     for (const { channelDir, file } of listRequestFiles()) {
       if (seenFiles.has(file))
         continue;
       const request = parseRequestFile(file, channelDir);
       if (!request || !requestMatchesContext(request, state, ctx))
         continue;
+      const lifecycle = requestLifecycle(request, state, undefined, now);
+      if (lifecycle !== "pending") {
+        seenFiles.add(file);
+        cleanupRequestLifecycle(request, lifecycle);
+        continue;
+      }
       seenFiles.add(file);
-      if (request.expectsReply)
+      if (request.expectsReply) {
         pending.set(request.id, request);
-      else {
-        try {
-          fs.rmSync(request.requestFile, { force: true });
-        } catch {}
+        markForegroundSupervisorAttention(request, state);
+      } else {
+        removeRequestFile(request.requestFile);
       }
-      pi.sendMessage({
+      dm.sendMessage({
         customType: "subagent_supervisor_request",
         content: requestVisibleText(request),
         display: true,
@@ -428,22 +600,142 @@ export function createNativeSupervisorChannel(pi, state) {
           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);
+      }
+    }
+  };
+  const startPolling = () => {
+    if (poller)
+      return;
+    poller = timers.setInterval(() => {
+      poll();
+      if (!useNativeWatcher() && platform === "darwin" && !hasTransportDemand()) {
+        if (poller)
+          timers.clearInterval(poller);
+        poller = undefined;
+      }
+    }, CHANNEL_POLL_MS);
+    poller.unref?.();
+  };
+  const startSafetyPolling = () => {
+    if (safetyPoller)
+      return;
+    safetyPoller = timers.setInterval(() => {
+      watchExistingRequestDirs();
+      poll();
+    }, CHANNEL_SAFETY_POLL_MS);
+    safetyPoller.unref?.();
+  };
+  const watchRequestDir = (requestsDir) => {
+    if (requestWatchers.has(requestsDir))
+      return;
+    try {
+      const watcher = watch(requestsDir, () => poll());
+      watcher.on("error", () => {
+        try {
+          watcher.close();
+        } catch {}
+        requestWatchers.delete(requestsDir);
+        startPolling();
       });
+      watcher.unref?.();
+      requestWatchers.set(requestsDir, watcher);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        startPolling();
     }
   };
+  const watchExistingRequestDirs = () => {
+    let channelEntries;
+    try {
+      channelEntries = fs.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      startPolling();
+      return;
+    }
+    for (const entry of channelEntries) {
+      if (entry.isDirectory())
+        watchRequestDir(path.join(SUPERVISOR_CHANNEL_ROOT, entry.name, REQUESTS_DIR));
+    }
+  };
+  const scheduleWatcherRefresh = () => {
+    if (deferredWatcherRefresh)
+      return;
+    deferredWatcherRefresh = timers.setImmediate(() => {
+      deferredWatcherRefresh = undefined;
+      if (!started)
+        return;
+      watchExistingRequestDirs();
+      poll();
+    });
+    deferredWatcherRefresh.unref?.();
+  };
   return {
+    activateTransport: () => {
+      if (!started)
+        return;
+      poll();
+      if (!useNativeWatcher() && hasTransportDemand())
+        startPolling();
+    },
     start: () => {
-      if (poller)
+      if (started)
         return;
+      started = true;
       registerParentTools();
       poll();
-      poller = setInterval(poll, CHANNEL_POLL_MS);
-      poller.unref?.();
+      try {
+        fs.mkdirSync(SUPERVISOR_CHANNEL_ROOT, { recursive: true });
+        if (!useNativeWatcher()) {
+          if (platform === "win32")
+            startPolling();
+          return;
+        }
+        watchExistingRequestDirs();
+        rootWatcher = watch(SUPERVISOR_CHANNEL_ROOT, () => {
+          watchExistingRequestDirs();
+          poll();
+          scheduleWatcherRefresh();
+        });
+        rootWatcher.on("error", startPolling);
+        startSafetyPolling();
+        scheduleWatcherRefresh();
+      } catch {
+        startPolling();
+      }
     },
     dispose: () => {
+      started = false;
+      try {
+        rootWatcher?.close();
+      } catch {}
+      rootWatcher = undefined;
+      for (const watcher of requestWatchers.values()) {
+        try {
+          watcher.close();
+        } catch {}
+      }
+      requestWatchers.clear();
       if (poller)
-        clearInterval(poller);
+        timers.clearInterval(poller);
       poller = undefined;
+      if (safetyPoller)
+        timers.clearInterval(safetyPoller);
+      safetyPoller = undefined;
+      if (deferredWatcherRefresh)
+        timers.clearImmediate(deferredWatcherRefresh);
+      deferredWatcherRefresh = undefined;
       pending.clear();
       seenFiles.clear();
     },