@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/control-channel.js

@@ -3,9 +3,28 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { POLL_INTERVAL_MS } from "../../shared/types.js";
-export const INTERRUPT_SIGNAL = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
+import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.js";
+import { resolveWatchPath } from "../../shared/utils.js";
+function writeJsonToExistingDir(filePath, payload) {
+  const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+  try {
+    fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+    fs.renameSync(tempPath, filePath);
+  } finally {
+    fs.rmSync(tempPath, { force: true });
+  }
+}
+const CONTROL_SAFETY_POLL_INTERVAL_MS = 5000;
 const STEER_REQUESTS_DIR = "steer-requests";
+const STOP_REQUESTS_DIR = "stop-requests";
+const REVIVAL_BRIEFS_DIR = "revival-briefs";
+export const MAX_STEER_QUEUE_SIZE = 20;
 const STEER_TARGETS_DIR = "steer-targets";
+const STEER_CAPABILITIES_DIR = "steer-capabilities";
+const STEER_ACKS_DIR = "steer-acks";
+const STEER_INBOX_CLOSED_FILE = "steer-inbox-closed.json";
+const MAX_STEER_MESSAGE_BYTES = 128 * 1024;
+const MAX_STEER_REQUEST_ID_LENGTH = 256;
 export function controlInboxDir(asyncDir) {
   return path.join(asyncDir, "control");
 }
@@ -15,20 +34,114 @@ export function interruptRequestPath(asyncDir) {
 export function timeoutRequestPath(asyncDir) {
   return path.join(controlInboxDir(asyncDir), "timeout.json");
 }
+export function stopRequestPath(asyncDir) {
+  return path.join(controlInboxDir(asyncDir), "stop.json");
+}
+export function stopRequestsDir(asyncDir) {
+  return path.join(controlInboxDir(asyncDir), STOP_REQUESTS_DIR);
+}
 export function steerRequestsDir(asyncDir) {
   return path.join(controlInboxDir(asyncDir), STEER_REQUESTS_DIR);
 }
+export function steerInboxClosedPath(asyncDir) {
+  return path.join(controlInboxDir(asyncDir), STEER_INBOX_CLOSED_FILE);
+}
+export function closeSteerInbox(asyncDir, state, write = writeAtomicJson) {
+  write(steerInboxClosedPath(asyncDir), { version: 1, closedAt: Date.now(), state });
+}
 export function stepSteerInboxDir(asyncDir, index) {
+  assertChildIndex(index);
   return path.join(controlInboxDir(asyncDir), STEER_TARGETS_DIR, String(index));
 }
+export function steerCapabilitiesDir(asyncDir) {
+  return path.join(controlInboxDir(asyncDir), STEER_CAPABILITIES_DIR);
+}
+export function steerCapabilityPath(asyncDir, index) {
+  assertChildIndex(index);
+  return path.join(steerCapabilitiesDir(asyncDir), `${index}.json`);
+}
+export function steerAcksDir(asyncDir, index) {
+  assertChildIndex(index);
+  return path.join(controlInboxDir(asyncDir), STEER_ACKS_DIR, String(index));
+}
+function steerAckFileName(requestId) {
+  return `${Buffer.from(requestId).toString("base64url")}.json`;
+}
+export function steerAckPathFromDir(dir, requestId) {
+  if (!/^[^\s]+$/.test(requestId) || requestId.length > 256)
+    throw new Error("steer acknowledgment requestId is invalid.");
+  return path.join(dir, steerAckFileName(requestId));
+}
+function assertChildIndex(index) {
+  if (!Number.isInteger(index) || index < 0 || index > 1e6)
+    throw new Error("child index must be a non-negative integer.");
+}
+function validStopChildId(childId) {
+  return typeof childId === "string" && Boolean(childId.trim()) && childId.length <= 256 && !/[\r\n]/.test(childId);
+}
 function steerRequestFileName(request) {
   return `${String(request.ts).padStart(13, "0")}-${Buffer.from(request.id).toString("base64url")}.json`;
 }
+function stopRequestFileName(request) {
+  return `${String(request.ts ?? 0).padStart(13, "0")}-${randomUUID()}.json`;
+}
+function validSteerRequest(request) {
+  return request.type === "steer" && typeof request.id === "string" && /^[^\s]+$/.test(request.id) && request.id.length <= MAX_STEER_REQUEST_ID_LENGTH && typeof request.ts === "number" && Number.isFinite(request.ts) && request.ts > 0 && typeof request.message === "string" && Boolean(request.message.trim()) && Buffer.byteLength(request.message, "utf8") <= MAX_STEER_MESSAGE_BYTES && (request.mode === undefined || request.mode === "steer" || request.mode === "follow_up" || request.mode === "auto") && (request.targetIndex === undefined || Number.isInteger(request.targetIndex) && request.targetIndex >= 0 && request.targetIndex <= 1e6) && (request.targetIndexes === undefined || request.targetIndex === undefined && Array.isArray(request.targetIndexes) && request.targetIndexes.length > 0 && request.targetIndexes.length <= 1000 && request.targetIndexes.every((index) => Number.isInteger(index) && index >= 0 && index <= 1e6) && new Set(request.targetIndexes).size === request.targetIndexes.length) && (request.source === undefined || typeof request.source === "string" && Boolean(request.source.trim()) && request.source.length <= 256);
+}
 export function writeSteerRequestToDir(dir, request) {
+  if (!validSteerRequest(request))
+    throw new Error("steer request is malformed or exceeds transport limits.");
   const requestPath = path.join(dir, steerRequestFileName(request));
   writeAtomicJson(requestPath, request);
   return requestPath;
 }
+export function writeSteerRequestToExistingDir(dir, request) {
+  if (!validSteerRequest(request))
+    throw new Error("steer request is malformed or exceeds transport limits.");
+  const requestPath = path.join(dir, steerRequestFileName(request));
+  writeJsonToExistingDir(requestPath, request);
+  return requestPath;
+}
+export function writeSteerCapabilityAt(filePath, capability) {
+  assertChildIndex(capability.index);
+  if (!Number.isInteger(capability.pid) || capability.pid <= 0)
+    throw new Error("steer capability pid must be a positive integer.");
+  if (!Number.isFinite(capability.readyAt) || capability.readyAt <= 0)
+    throw new Error("steer capability readyAt must be a finite timestamp.");
+  const record = { type: "steer-capability", protocolVersion: 1, ...capability };
+  writeAtomicJson(filePath, record);
+  return filePath;
+}
+export function writeSteerCapability(asyncDir, capability) {
+  return writeSteerCapabilityAt(steerCapabilityPath(asyncDir, capability.index), capability);
+}
+function steerAckWritePath(filePath, ack) {
+  const parsed = path.parse(filePath);
+  const stateOrder = ack.state === "queued" ? "0" : ack.state === "delivered" ? "1" : "2";
+  const timestamp = String(Math.trunc(ack.ts)).padStart(13, "0");
+  for (let suffix = 0;suffix < 1000; suffix += 1) {
+    const candidate = path.join(parsed.dir, `${parsed.name}-${timestamp}-${stateOrder}-${ack.state}${suffix === 0 ? "" : `-${suffix}`}${parsed.ext}`);
+    if (!fs.existsSync(candidate))
+      return candidate;
+  }
+  throw new Error("steer acknowledgment queue is full.");
+}
+export function writeSteerAckAt(filePath, ack) {
+  assertChildIndex(ack.index);
+  if (!/^[^\s]+$/.test(ack.requestId) || ack.requestId.length > 256)
+    throw new Error("steer acknowledgment requestId is invalid.");
+  if (!Number.isFinite(ack.ts) || ack.ts <= 0)
+    throw new Error("steer acknowledgment ts must be a finite timestamp.");
+  if (!ack.message.trim() || ack.message.length > 1000)
+    throw new Error("steer acknowledgment message is invalid.");
+  const record = { type: "steer-ack", protocolVersion: 1, ...ack, message: ack.message.trim() };
+  const ackPath = steerAckWritePath(filePath, ack);
+  writeAtomicJson(ackPath, record);
+  return ackPath;
+}
+export function writeSteerAck(asyncDir, ack) {
+  return writeSteerAckAt(path.join(steerAcksDir(asyncDir, ack.index), steerAckFileName(ack.requestId)), ack);
+}
 export function requestAsyncInterrupt(asyncDir, payload = {}, deps = {}) {
   const requestPath = interruptRequestPath(asyncDir);
   const request = { ...payload, ts: payload.ts ?? deps.now?.() ?? Date.now(), type: "interrupt" };
@@ -41,56 +154,199 @@ export function requestAsyncTimeout(asyncDir, payload = {}, deps = {}) {
   writeAtomicJson(requestPath, request);
   return requestPath;
 }
+export function requestAsyncStop(asyncDir, payload = {}, deps = {}) {
+  if (payload.targetIndex !== undefined)
+    assertChildIndex(payload.targetIndex);
+  if (payload.childId !== undefined && !validStopChildId(payload.childId)) {
+    throw new Error("stop childId must be a non-empty string without newlines and at most 256 characters.");
+  }
+  const request = { ...payload, ts: payload.ts ?? deps.now?.() ?? Date.now(), type: "stop" };
+  const requestPath = path.join(stopRequestsDir(asyncDir), stopRequestFileName(request));
+  writeAtomicJson(requestPath, request);
+  return requestPath;
+}
 export function requestAsyncSteer(asyncDir, payload, deps = {}) {
   const message = payload.message.trim();
   if (!message)
     throw new Error("steer message must not be empty.");
-  if (payload.targetIndex !== undefined && (!Number.isInteger(payload.targetIndex) || payload.targetIndex < 0)) {
-    throw new Error("steer targetIndex must be a non-negative integer.");
+  if (Buffer.byteLength(message, "utf8") > MAX_STEER_MESSAGE_BYTES)
+    throw new Error(`steer message exceeds ${MAX_STEER_MESSAGE_BYTES} UTF-8 bytes.`);
+  if (payload.targetIndex !== undefined && (!Number.isInteger(payload.targetIndex) || payload.targetIndex < 0 || payload.targetIndex > 1e6)) {
+    throw new Error("steer targetIndex must be an integer between 0 and 1000000.");
+  }
+  if (payload.targetIndexes !== undefined && (!Array.isArray(payload.targetIndexes) || payload.targetIndex !== undefined || payload.targetIndexes.length === 0 || payload.targetIndexes.length > 1000 || payload.targetIndexes.some((index) => !Number.isInteger(index) || index < 0 || index > 1e6) || new Set(payload.targetIndexes).size !== payload.targetIndexes.length)) {
+    throw new Error("steer targetIndexes must contain 1-1000 unique non-negative integers and cannot be combined with targetIndex.");
   }
+  const closedPath = steerInboxClosedPath(asyncDir);
+  if (fs.existsSync(closedPath))
+    throw new Error("Async run no longer accepts steering requests.");
   const request = {
     type: "steer",
     id: payload.id ?? deps.randomId?.() ?? randomUUID(),
     ts: payload.ts ?? deps.now?.() ?? Date.now(),
     message,
+    ...payload.mode && payload.mode !== "steer" ? { mode: payload.mode } : {},
     ...payload.targetIndex !== undefined ? { targetIndex: payload.targetIndex } : {},
+    ...payload.targetIndexes !== undefined ? { targetIndexes: [...payload.targetIndexes] } : {},
     ...payload.source ? { source: payload.source } : {}
   };
-  return writeSteerRequestToDir(steerRequestsDir(asyncDir), request);
+  const requestPath = writeSteerRequestToDir(steerRequestsDir(asyncDir), request);
+  if (fs.existsSync(closedPath)) {
+    fs.rmSync(requestPath, { force: true });
+    throw new Error("Async run stopped accepting steering before the request was committed.");
+  }
+  return requestPath;
 }
 export function enqueueStepSteer(asyncDir, index, request) {
-  if (!Number.isInteger(index) || index < 0)
-    throw new Error("steer child index must be a non-negative integer.");
-  return writeSteerRequestToDir(stepSteerInboxDir(asyncDir, index), { ...request, targetIndex: index, type: "steer" });
+  assertChildIndex(index);
+  const { targetIndexes: _targetIndexes, ...singleTargetRequest } = request;
+  return writeSteerRequestToDir(stepSteerInboxDir(asyncDir, index), { ...singleTargetRequest, targetIndex: index, type: "steer" });
 }
-function parseSteerRequest(raw) {
+function parseSteerCapability(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw))
     return;
   const input = raw;
-  if (input.type !== "steer")
+  if (input.type !== "steer-capability" || input.protocolVersion !== 1)
     return;
-  if (typeof input.id !== "string" || !input.id.trim())
+  const { index, pid, readyAt, supported } = input;
+  if (typeof index !== "number" || !Number.isInteger(index) || index < 0 || index > 1e6)
     return;
-  if (typeof input.ts !== "number" || !Number.isFinite(input.ts))
+  if (typeof pid !== "number" || typeof readyAt !== "number" || !Number.isInteger(pid) || pid <= 0 || !Number.isFinite(readyAt) || readyAt <= 0 || typeof supported !== "boolean")
     return;
-  if (typeof input.message !== "string" || !input.message.trim())
+  return { type: "steer-capability", protocolVersion: 1, index, pid, readyAt, supported };
+}
+function parseSteerAck(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const input = raw;
+  if (input.type !== "steer-ack" || input.protocolVersion !== 1 || typeof input.requestId !== "string" || !/^[^\s]+$/.test(input.requestId) || input.requestId.length > 256)
+    return;
+  const { index, ts, state, message } = input;
+  if (typeof index !== "number" || typeof ts !== "number" || !Number.isInteger(index) || index < 0 || index > 1e6 || !Number.isFinite(ts) || ts <= 0)
+    return;
+  if (state !== "delivered" && state !== "queued" && state !== "failed")
+    return;
+  if (input.deliveryStatus !== undefined && input.deliveryStatus !== "delivered" && input.deliveryStatus !== "queued")
+    return;
+  if (typeof message !== "string" || !message.trim() || message.length > 1000)
+    return;
+  return { type: "steer-ack", protocolVersion: 1, requestId: input.requestId, index, ts, state, ...input.deliveryStatus ? { deliveryStatus: input.deliveryStatus } : {}, message: message.trim() };
+}
+export function readSteerCapability(asyncDir, index) {
+  try {
+    return parseSteerCapability(JSON.parse(fs.readFileSync(steerCapabilityPath(asyncDir, index), "utf-8")));
+  } catch {
+    return;
+  }
+}
+export function consumeSteerCapabilities(asyncDir, fsImpl = fs) {
+  const dir = steerCapabilitiesDir(asyncDir);
+  if (!fsImpl.existsSync(dir))
+    return [];
+  const capabilities = [];
+  for (const entry of fsImpl.readdirSync(dir).filter((name) => /^\d+\.json$/.test(name)).sort()) {
+    try {
+      const capability = parseSteerCapability(JSON.parse(fsImpl.readFileSync(path.join(dir, entry), "utf-8")));
+      if (capability)
+        capabilities.push(capability);
+    } catch {}
+  }
+  return capabilities;
+}
+export function consumeSteerAckFromDir(dir, requestId, fsImpl = fs) {
+  if (!fsImpl.existsSync(dir))
+    return;
+  let entries;
+  try {
+    entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const target = path.join(dir, entry);
+    let ack;
+    try {
+      ack = parseSteerAck(JSON.parse(fsImpl.readFileSync(target, "utf-8")));
+    } catch {
+      ack = undefined;
+    }
+    if (ack?.requestId !== requestId)
+      continue;
+    try {
+      fsImpl.rmSync(target, { force: true });
+    } catch {
+      return;
+    }
+    return ack;
+  }
+  return;
+}
+export function consumeSteerAcks(asyncDir, fsImpl = fs) {
+  const root = path.join(controlInboxDir(asyncDir), STEER_ACKS_DIR);
+  if (!fsImpl.existsSync(root))
+    return [];
+  const acks = [];
+  let indexNames;
+  try {
+    indexNames = fsImpl.readdirSync(root).filter((name) => /^\d+$/.test(name));
+  } catch {
+    return [];
+  }
+  for (const indexName of indexNames) {
+    const dir = path.join(root, indexName);
+    let entries;
+    try {
+      entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const target = path.join(dir, entry);
+      let ack;
+      try {
+        ack = parseSteerAck(JSON.parse(fsImpl.readFileSync(target, "utf-8")));
+      } catch {
+        ack = undefined;
+      }
+      try {
+        fsImpl.rmSync(target, { force: true });
+      } catch {
+        continue;
+      }
+      if (ack)
+        acks.push(ack);
+    }
+  }
+  return acks;
+}
+function parseSteerRequest(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
     return;
-  if (input.targetIndex !== undefined && (!Number.isInteger(input.targetIndex) || input.targetIndex < 0))
+  const input = raw;
+  if (!validSteerRequest(input))
     return;
   return {
     type: "steer",
     id: input.id.trim(),
     ts: input.ts,
     message: input.message.trim(),
+    ...input.mode ? { mode: input.mode } : {},
     ...input.targetIndex !== undefined ? { targetIndex: input.targetIndex } : {},
+    ...input.targetIndexes !== undefined ? { targetIndexes: [...input.targetIndexes] } : {},
     ...typeof input.source === "string" && input.source.trim() ? { source: input.source } : {}
   };
 }
 export function consumeSteerRequestsFromDir(dir, fsImpl = fs) {
   if (!fsImpl.existsSync(dir))
     return [];
+  let entries;
+  try {
+    entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
+  } catch {
+    return [];
+  }
   const requests = [];
-  for (const entry of fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort()) {
+  for (const entry of entries) {
     const requestPath = path.join(dir, entry);
     let parsed;
     try {
@@ -111,6 +367,27 @@ export function consumeSteerRequestsFromDir(dir, fsImpl = fs) {
 export function consumeSteerRequests(asyncDir, fsImpl = fs) {
   return consumeSteerRequestsFromDir(steerRequestsDir(asyncDir), fsImpl);
 }
+export function queueRevivalBrief(asyncDir, request) {
+  const dir = path.join(controlInboxDir(asyncDir), REVIVAL_BRIEFS_DIR);
+  const queued = fs.existsSync(dir) ? fs.readdirSync(dir).filter((entry) => entry.endsWith(".json")).length : 0;
+  if (queued >= MAX_STEER_QUEUE_SIZE)
+    throw new Error(`Follow-up queue is full (${MAX_STEER_QUEUE_SIZE} messages).`);
+  return writeSteerRequestToDir(dir, { ...request, mode: "follow_up" });
+}
+export function readRevivalBriefs(asyncDir) {
+  const dir = path.join(controlInboxDir(asyncDir), REVIVAL_BRIEFS_DIR);
+  if (!fs.existsSync(dir))
+    return [];
+  return fs.readdirSync(dir).filter((entry) => entry.endsWith(".json")).sort().flatMap((entry) => {
+    const filePath = path.join(dir, entry);
+    try {
+      const request = parseSteerRequest(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+      return request ? [{ request, path: filePath }] : [];
+    } catch {
+      return [];
+    }
+  });
+}
 export function consumeInterruptRequest(asyncDir, fsImpl = fs) {
   const requestPath = interruptRequestPath(asyncDir);
   if (!fsImpl.existsSync(requestPath))
@@ -129,25 +406,78 @@ export function consumeTimeoutRequest(asyncDir, fsImpl = fs) {
   } catch {}
   return true;
 }
-export function deliverInterruptRequest(input) {
-  const requestPath = requestAsyncInterrupt(input.asyncDir, input.source ? { source: input.source } : {}, { now: input.now });
-  if (typeof input.pid === "number" && input.pid > 0) {
+export function consumeStopRequest(asyncDir, fsImpl = fs) {
+  return consumeStopRequestPayload(asyncDir, fsImpl) !== undefined;
+}
+function parseStopRequest(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const parsed = raw;
+  if (parsed.type !== "stop")
+    return;
+  if (Object.hasOwn(parsed, "targetIndex") && !(Number.isInteger(parsed.targetIndex) && parsed.targetIndex >= 0 && parsed.targetIndex <= 1e6))
+    return;
+  if (Object.hasOwn(parsed, "childId") && !validStopChildId(parsed.childId))
+    return;
+  return {
+    type: "stop",
+    ...typeof parsed.ts === "number" ? { ts: parsed.ts } : {},
+    ...typeof parsed.source === "string" ? { source: parsed.source } : {},
+    ...typeof parsed.reason === "string" ? { reason: parsed.reason } : {},
+    ...parsed.targetIndex !== undefined ? { targetIndex: parsed.targetIndex } : {},
+    ...validStopChildId(parsed.childId) ? { childId: parsed.childId } : {}
+  };
+}
+function consumeStopRequestFile(requestPath, fsImpl) {
+  let request;
+  try {
+    request = parseStopRequest(JSON.parse(fsImpl.readFileSync(requestPath, "utf-8")));
+  } catch {
+    request = undefined;
+  }
+  try {
+    fsImpl.rmSync(requestPath, { force: true, recursive: true });
+  } catch {
+    return;
+  }
+  return request;
+}
+export function consumeStopRequestPayloads(asyncDir, fsImpl = fs) {
+  const dir = stopRequestsDir(asyncDir);
+  const requests = [];
+  if (fsImpl.existsSync(dir)) {
+    let entries;
     try {
-      (input.kill ?? process.kill)(input.pid, input.signal ?? INTERRUPT_SIGNAL);
-    } catch (error) {
-      if (error?.code === "ENOSYS") {
-        return;
-      }
-      try {
-        fs.rmSync(requestPath, { force: true });
-      } catch {}
-      throw error;
+      entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
+    } catch {
+      entries = [];
+    }
+    for (const entry of entries) {
+      const request = consumeStopRequestFile(path.join(dir, entry), fsImpl);
+      if (request)
+        requests.push(request);
     }
   }
+  const legacyPath = stopRequestPath(asyncDir);
+  if (fsImpl.existsSync(legacyPath)) {
+    const request = consumeStopRequestFile(legacyPath, fsImpl);
+    if (request)
+      requests.push(request);
+  }
+  return requests.sort((left, right) => (left.ts ?? 0) - (right.ts ?? 0));
+}
+export function consumeStopRequestPayload(asyncDir, fsImpl = fs) {
+  return consumeStopRequestPayloads(asyncDir, fsImpl)[0];
+}
+export function deliverInterruptRequest(input) {
+  requestAsyncInterrupt(input.asyncDir, input.source ? { source: input.source } : {}, { now: input.now });
 }
 export function deliverTimeoutRequest(input) {
   requestAsyncTimeout(input.asyncDir, input.source ? { source: input.source } : {}, { now: input.now });
 }
+export function deliverStopRequest(input) {
+  requestAsyncStop(input.asyncDir, { ...input.source ? { source: input.source } : {}, ...input.targetIndex !== undefined ? { targetIndex: input.targetIndex } : {}, ...input.childId ? { childId: input.childId } : {} }, { now: input.now });
+}
 export function watchAsyncControlInbox(asyncDir, opts) {
   const fsImpl = opts.fs ?? fs;
   const timers = opts.timers ?? { setInterval, clearInterval };
@@ -160,31 +490,88 @@ export function watchAsyncControlInbox(asyncDir, opts) {
     if (disposed)
       return;
     try {
+      for (const stopRequest of consumeStopRequestPayloads(asyncDir, fsImpl))
+        opts.onStop?.(stopRequest);
       if (consumeTimeoutRequest(asyncDir, fsImpl))
         opts.onTimeout?.();
       if (consumeInterruptRequest(asyncDir, fsImpl))
         opts.onInterrupt();
       for (const request of consumeSteerRequests(asyncDir, fsImpl))
         opts.onSteer?.(request);
+      for (const capability of consumeSteerCapabilities(asyncDir, fsImpl))
+        opts.onSteerCapability?.(capability);
+      for (const ack of consumeSteerAcks(asyncDir, fsImpl))
+        opts.onSteerAck?.(ack);
     } catch {}
   };
   check();
-  let watcher;
+  const watchers = [];
+  const watchedDirs = new Set;
+  let interval;
+  let safetyInterval;
+  const startPolling = () => {
+    if (interval || disposed)
+      return;
+    interval = timers.setInterval(check, opts.pollIntervalMs ?? POLL_INTERVAL_MS);
+    interval.unref?.();
+  };
+  const startSafetyPolling = () => {
+    if (safetyInterval || disposed)
+      return;
+    safetyInterval = timers.setInterval(check, opts.safetyPollIntervalMs ?? CONTROL_SAFETY_POLL_INTERVAL_MS);
+    safetyInterval.unref?.();
+  };
+  const watchDir = (target, create = false) => {
+    if (disposed || watchedDirs.has(target))
+      return;
+    if (create)
+      fsImpl.mkdirSync(target, { recursive: true });
+    const watcher = fsImpl.watch(resolveWatchPath(target, fsImpl.realpathSync.native), () => {
+      watchExistingSteerAckDirs();
+      check();
+    });
+    watcher.on?.("error", startPolling);
+    watchers.push(watcher);
+    watchedDirs.add(target);
+  };
+  const watchExistingSteerAckDirs = () => {
+    const ackRoot = path.join(dir, STEER_ACKS_DIR);
+    let entries;
+    try {
+      entries = fsImpl.readdirSync(ackRoot).filter((name) => /^\d+$/.test(name));
+    } catch {
+      return;
+    }
+    for (const entry of entries)
+      watchDir(path.join(ackRoot, entry));
+  };
   try {
-    watcher = fsImpl.watch(dir, () => check());
-    watcher.on?.("error", () => {});
+    if (shouldUseNativeFsWatch("runner-control-inbox", opts.platform)) {
+      watchDir(dir);
+      watchDir(stopRequestsDir(asyncDir), true);
+      watchDir(steerRequestsDir(asyncDir), true);
+      watchDir(steerCapabilitiesDir(asyncDir), true);
+      watchDir(path.join(dir, STEER_ACKS_DIR), true);
+      watchExistingSteerAckDirs();
+      startSafetyPolling();
+    } else {
+      startPolling();
+    }
   } catch {
-    watcher = undefined;
+    startPolling();
   }
-  const interval = timers.setInterval(check, opts.pollIntervalMs ?? POLL_INTERVAL_MS);
-  interval.unref?.();
   return () => {
     if (disposed)
       return;
     disposed = true;
-    try {
-      watcher?.close();
-    } catch {}
-    timers.clearInterval(interval);
+    for (const watcher of watchers) {
+      try {
+        watcher.close();
+      } catch {}
+    }
+    if (interval)
+      timers.clearInterval(interval);
+    if (safetyInterval)
+      timers.clearInterval(safetyInterval);
   };
 }