@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -19,9 +19,6 @@ 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;
@@ -49,29 +46,6 @@ export function steerInboxClosedPath(asyncDir) {
 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.");
@@ -102,46 +76,6 @@ export function writeSteerRequestToExistingDir(dir, 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" };
@@ -197,128 +131,6 @@ export function requestAsyncSteer(asyncDir, payload, deps = {}) {
   }
   return requestPath;
 }
-export function enqueueStepSteer(asyncDir, index, request) {
-  assertChildIndex(index);
-  const { targetIndexes: _targetIndexes, ...singleTargetRequest } = request;
-  return writeSteerRequestToDir(stepSteerInboxDir(asyncDir, index), { ...singleTargetRequest, targetIndex: index, type: "steer" });
-}
-function parseSteerCapability(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw))
-    return;
-  const input = raw;
-  if (input.type !== "steer-capability" || input.protocolVersion !== 1)
-    return;
-  const { index, pid, readyAt, supported } = input;
-  if (typeof index !== "number" || !Number.isInteger(index) || index < 0 || index > 1e6)
-    return;
-  if (typeof pid !== "number" || typeof readyAt !== "number" || !Number.isInteger(pid) || pid <= 0 || !Number.isFinite(readyAt) || readyAt <= 0 || typeof supported !== "boolean")
-    return;
-  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;
@@ -336,27 +148,37 @@ function parseSteerRequest(raw) {
     ...typeof input.source === "string" && input.source.trim() ? { source: input.source } : {}
   };
 }
-export function consumeSteerRequestsFromDir(dir, fsImpl = fs) {
-  if (!fsImpl.existsSync(dir))
-    return [];
+export function consumeSteerRequestsFromDir(dir, fsImpl = fs, onError = () => {}) {
   let entries;
   try {
     entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
-  } catch {
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      onError(error);
     return [];
   }
   const requests = [];
   for (const entry of entries) {
     const requestPath = path.join(dir, entry);
     let parsed;
+    let text;
     try {
-      parsed = parseSteerRequest(JSON.parse(fsImpl.readFileSync(requestPath, "utf-8")));
+      text = fsImpl.readFileSync(requestPath, "utf-8");
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        onError(error);
+      continue;
+    }
+    try {
+      parsed = parseSteerRequest(JSON.parse(text));
     } catch {
       parsed = undefined;
     }
     try {
       fsImpl.rmSync(requestPath, { recursive: true });
-    } catch {
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        onError(error);
       continue;
     }
     if (parsed)
@@ -364,8 +186,8 @@ export function consumeSteerRequestsFromDir(dir, fsImpl = fs) {
   }
   return requests.sort((left, right) => left.ts - right.ts || left.id.localeCompare(right.id));
 }
-export function consumeSteerRequests(asyncDir, fsImpl = fs) {
-  return consumeSteerRequestsFromDir(steerRequestsDir(asyncDir), fsImpl);
+export function consumeSteerRequests(asyncDir, fsImpl = fs, onError) {
+  return consumeSteerRequestsFromDir(steerRequestsDir(asyncDir), fsImpl, onError);
 }
 export function queueRevivalBrief(asyncDir, request) {
   const dir = path.join(controlInboxDir(asyncDir), REVIVAL_BRIEFS_DIR);
@@ -428,39 +250,51 @@ function parseStopRequest(raw) {
     ...validStopChildId(parsed.childId) ? { childId: parsed.childId } : {}
   };
 }
-function consumeStopRequestFile(requestPath, fsImpl) {
+function consumeStopRequestFile(requestPath, fsImpl, onError) {
+  let text;
+  try {
+    text = fsImpl.readFileSync(requestPath, "utf-8");
+  } catch (error) {
+    if (!(error instanceof Error && ("code" in error) && error.code === "ENOENT"))
+      onError?.(error);
+    return;
+  }
   let request;
   try {
-    request = parseStopRequest(JSON.parse(fsImpl.readFileSync(requestPath, "utf-8")));
+    request = parseStopRequest(JSON.parse(text));
   } catch {
     request = undefined;
   }
   try {
     fsImpl.rmSync(requestPath, { force: true, recursive: true });
-  } catch {
+  } catch (error) {
+    if (!(error instanceof Error && ("code" in error) && error.code === "ENOENT"))
+      onError?.(error);
     return;
   }
   return request;
 }
-export function consumeStopRequestPayloads(asyncDir, fsImpl = fs) {
+export function consumeStopRequestPayloads(asyncDir, fsImpl = fs, onError) {
   const dir = stopRequestsDir(asyncDir);
   const requests = [];
   if (fsImpl.existsSync(dir)) {
     let entries;
     try {
       entries = fsImpl.readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
-    } catch {
+    } catch (error) {
+      if (!(error instanceof Error && ("code" in error) && error.code === "ENOENT"))
+        onError?.(error);
       entries = [];
     }
     for (const entry of entries) {
-      const request = consumeStopRequestFile(path.join(dir, entry), fsImpl);
+      const request = consumeStopRequestFile(path.join(dir, entry), fsImpl, onError);
       if (request)
         requests.push(request);
     }
   }
   const legacyPath = stopRequestPath(asyncDir);
   if (fsImpl.existsSync(legacyPath)) {
-    const request = consumeStopRequestFile(legacyPath, fsImpl);
+    const request = consumeStopRequestFile(legacyPath, fsImpl, onError);
     if (request)
       requests.push(request);
   }
@@ -482,78 +316,93 @@ export function watchAsyncControlInbox(asyncDir, opts) {
   const fsImpl = opts.fs ?? fs;
   const timers = opts.timers ?? { setInterval, clearInterval };
   const dir = controlInboxDir(asyncDir);
+  const report = (error, phase, request) => {
+    try {
+      if (opts.onError)
+        opts.onError(error, phase, request);
+      else
+        console.error(`Control inbox ${phase} failed:`, error);
+    } catch (reportError) {
+      console.error("Control inbox error reporter failed:", reportError);
+    }
+  };
+  const dirs = [
+    ...opts.onInterrupt || opts.onTimeout || opts.onStop ? [dir] : [],
+    ...opts.onStop ? [stopRequestsDir(asyncDir)] : [],
+    ...opts.onSteer ? [steerRequestsDir(asyncDir)] : []
+  ];
+  if (dirs.length === 0)
+    return () => {};
   try {
-    fsImpl.mkdirSync(dir, { recursive: true });
-  } catch {}
+    for (const target of dirs)
+      fsImpl.mkdirSync(target, { recursive: true });
+  } catch (error) {
+    report(error, "install");
+  }
   let disposed = false;
   const check = () => {
     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 {}
+      if (opts.onStop)
+        for (const request of consumeStopRequestPayloads(asyncDir, fsImpl, (error) => report(error, "scan"))) {
+          try {
+            opts.onStop(request);
+          } catch (error) {
+            report(error, "callback");
+          }
+        }
+      if (opts.onTimeout && consumeTimeoutRequest(asyncDir, fsImpl)) {
+        try {
+          opts.onTimeout();
+        } catch (error) {
+          report(error, "callback");
+        }
+      }
+      if (opts.onInterrupt && consumeInterruptRequest(asyncDir, fsImpl)) {
+        try {
+          opts.onInterrupt();
+        } catch (error) {
+          report(error, "callback");
+        }
+      }
+      if (opts.onSteer)
+        for (const request of consumeSteerRequestsFromDir(steerRequestsDir(asyncDir), fsImpl, (error) => report(error, "scan"))) {
+          try {
+            opts.onSteer(request);
+          } catch (error) {
+            report(error, "callback", request);
+          }
+        }
+    } catch (error) {
+      report(error, "scan");
+    }
   };
   check();
   const watchers = [];
-  const watchedDirs = new Set;
   let interval;
   let safetyInterval;
   const startPolling = () => {
     if (interval || disposed)
       return;
+    if (safetyInterval) {
+      timers.clearInterval(safetyInterval);
+      safetyInterval = undefined;
+    }
     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 {
     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();
+      for (const target of dirs) {
+        const watcher = fsImpl.watch(resolveWatchPath(target, fsImpl.realpathSync.native), check);
+        watcher.on?.("error", startPolling);
+        watchers.push(watcher);
+      }
+      if (!interval) {
+        safetyInterval = timers.setInterval(check, opts.safetyPollIntervalMs ?? CONTROL_SAFETY_POLL_INTERVAL_MS);
+        safetyInterval.unref?.();
+      }
     } else {
       startPolling();
     }

package/extensions/dm-subagents/src/runs/background/fleet-view.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { safeTerminalText } from "../../shared/display-text.js";
+import { safeTerminalText, truncateDisplayText } from "../../shared/display-text.js";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.js";
 import { formatActivityLabel } from "../../shared/status-format.js";
 import {
@@ -14,6 +14,10 @@ import { isTrustedRecordedSessionFile } from "../../shared/session-file-trust.js
 const DEFAULT_TRANSCRIPT_LINES = 80;
 const MAX_TRANSCRIPT_LINES = 500;
 const TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+const MAX_TRANSCRIPT_LINE_CHARS = 2000;
+const MAX_TRANSCRIPT_BODY_BYTES = 32 * 1024;
+const TRANSCRIPT_LINE_OMISSION = "… [content omitted]";
+const TRANSCRIPT_BODY_OMISSION = "  … [earlier lines omitted]";
 function transcriptLineLimit(value) {
   if (value === undefined)
     return DEFAULT_TRANSCRIPT_LINES;
@@ -288,7 +292,14 @@ function formatDetachedForegroundFleetLines(runs) {
   }
   return lines;
 }
-function formatAsyncFleetLines(runs) {
+function externalCliStepFacts(step, now) {
+  if (step.runner?.type !== "external-cli")
+    return;
+  const process = step.externalProcess;
+  const elapsed = process ? process.durationMs ?? Math.max(0, (process.endedAt ?? now) - process.startedAt) : undefined;
+  return `external-cli${elapsed !== undefined ? ` · ${formatDuration(elapsed)}` : ""}`;
+}
+function formatAsyncFleetLines(runs, now = Date.now()) {
   if (runs.length === 0)
     return [];
   const lines = ["Async runs:"];
@@ -307,7 +318,7 @@ function formatAsyncFleetLines(runs) {
       const phase = step.phase ? `[${step.phase}] ` : "";
       const stepActivity = formatActivityFacts(step);
       const modelThinking = formatModelThinking(step.model, step.thinking);
-      const parts = [`${step.index}. ${phase}${display}${stepContext ? ` ${stepContext}` : ""}`, step.status, stepActivity, modelThinking].filter(Boolean);
+      const parts = [`${step.index}. ${phase}${display}${stepContext ? ` ${stepContext}` : ""}`, step.status, externalCliStepFacts(step, now), stepActivity, modelThinking].filter(Boolean);
       lines.push(`  ${parts.join(" | ")}`);
       const output = path.join(run.asyncDir, `output-${step.index}.log`);
       if (fs.existsSync(output))
@@ -372,7 +383,7 @@ export function inspectSubagentFleet(_params, deps = {}) {
   const detachedForegroundLines = formatDetachedForegroundFleetLines(detachedForegroundRuns);
   if (detachedForegroundLines.length)
     lines.push(...detachedForegroundLines, "");
-  const asyncLines = formatAsyncFleetLines(asyncRuns);
+  const asyncLines = formatAsyncFleetLines(asyncRuns, deps.now?.() ?? Date.now());
   if (asyncLines.length)
     lines.push(...asyncLines, "");
   lines.push("Commands:");
@@ -447,16 +458,54 @@ function appendTranscriptBody(lines, sourceLabel, sourceLines, truncated) {
     lines.push("  (no transcript lines available yet)");
     return;
   }
-  for (const line of sourceLines)
-    lines.push(`  ${line}`);
+  const body = [];
+  let bytes = 0;
+  for (let index = sourceLines.length - 1;index >= 0; index--) {
+    const safe = safeTerminalText(`  ${sourceLines[index]}`);
+    const lineLimit = MAX_TRANSCRIPT_LINE_CHARS + 2;
+    const line = safe.length <= lineLimit ? safe : truncateDisplayText(safe, lineLimit - TRANSCRIPT_LINE_OMISSION.length) + TRANSCRIPT_LINE_OMISSION;
+    const size = Buffer.byteLength(line) + 1;
+    if (bytes + size > MAX_TRANSCRIPT_BODY_BYTES) {
+      const markerBytes = Buffer.byteLength(TRANSCRIPT_BODY_OMISSION) + 1;
+      while (bytes + markerBytes > MAX_TRANSCRIPT_BODY_BYTES)
+        bytes -= Buffer.byteLength(body.pop()) + 1;
+      body.push(TRANSCRIPT_BODY_OMISSION);
+      break;
+    }
+    body.push(line);
+    bytes += size;
+  }
+  lines.push(...body.reverse());
+}
+function resolveWorkflowTranscriptChild(status, asyncDir, options) {
+  if (status.mode !== "workflow" || options.index === undefined)
+    return;
+  const step = status.steps?.[options.index];
+  if (step?.async !== true || typeof step.runId !== "string" || !/^[A-Za-z0-9_-]+$/.test(step.runId) || step.runId === status.runId)
+    return;
+  try {
+    const asyncRoot = fs.realpathSync(path.dirname(asyncDir));
+    const childDir = path.join(asyncRoot, step.runId);
+    if (fs.realpathSync(childDir) !== childDir || fs.lstatSync(path.join(childDir, "status.json")).isSymbolicLink())
+      return;
+    const childStatus = readStatus(childDir);
+    return childStatus?.runId === step.runId && childStatus.parentWorkflowRunId === status.runId && typeof step.workflowKey === "string" && step.workflowKey.length > 0 && childStatus.workflowKey === step.workflowKey && typeof status.sessionId === "string" && status.sessionId.length > 0 && childStatus.sessionId === status.sessionId ? { status: childStatus, asyncDir: childDir } : undefined;
+  } catch (error) {
+    if (isNotFoundError(error))
+      return;
+    throw error;
+  }
 }
 export function formatAsyncRunTranscript(status, asyncDir, options = {}) {
+  const workflowChild = resolveWorkflowTranscriptChild(status, asyncDir, options);
+  if (workflowChild)
+    return formatAsyncRunTranscript(workflowChild.status, workflowChild.asyncDir, { ...options, index: undefined });
   const lineLimit = transcriptLineLimit(options.lines);
   const selected = selectTranscriptStep(status, options);
   const stepOutputPath = selected.index !== undefined ? path.join(asyncDir, `output-${selected.index}.log`) : undefined;
   const runOutputPath = resolveMaybeRelative(asyncDir, status.outputFile);
   const logPath = path.join(asyncDir, `subagent-log-${status.runId}.md`);
-  const outputPaths = selected.index !== undefined ? uniqueStrings([stepOutputPath, runOutputPath && stepOutputPath && path.resolve(runOutputPath) === path.resolve(stepOutputPath) ? runOutputPath : undefined]) : uniqueStrings([runOutputPath]);
+  const outputPaths = selected.index !== undefined ? uniqueStrings([selected.step?.externalProcess?.finalOutputPath, stepOutputPath, runOutputPath && stepOutputPath && path.resolve(runOutputPath) === path.resolve(stepOutputPath) ? runOutputPath : undefined]) : uniqueStrings([runOutputPath]);
   const sessionFile = selected.index !== undefined ? selected.step?.sessionFile : status.sessionFile;
   const eventsPath = path.join(asyncDir, "events.jsonl");
   const context = contextModeLabel(status.context ?? summarizeContextModes((status.steps ?? []).map((step) => step.context)));
@@ -472,14 +521,22 @@ export function formatAsyncRunTranscript(status, asyncDir, options = {}) {
   let transcriptLines = [];
   let transcriptSource = "Transcript tail";
   let truncated = false;
-  for (const outputPath of outputPaths) {
+  const externalProcess = selected.step?.runner?.type === "external-cli" ? selected.step.externalProcess : undefined;
+  const externalLogPaths = externalProcess ? [
+    { path: externalProcess.stderrPath, label: "External stderr tail" },
+    { path: externalProcess.stdoutPath, label: "External stdout tail" }
+  ] : [];
+  const runningExternal = selected.step?.status === "running" && externalProcess;
+  const sources = runningExternal ? [...externalLogPaths, ...outputPaths.map((outputPath) => ({ path: outputPath, label: "Transcript tail" }))] : [...outputPaths.map((outputPath) => ({ path: outputPath, label: "Transcript tail" })), ...externalLogPaths];
+  for (const source of sources) {
+    const outputPath = source.path;
     const tail = readContainedTextTail(outputPath, lineLimit, [asyncDir], "output");
     if (tail.error)
       warnings.push(`Output read failed for ${tail.path}: ${tail.error}`);
-    if (tail.lines.length === 0)
+    if (!tail.lines.some((line) => line.trim().length > 0))
       continue;
     transcriptLines = tail.lines;
-    transcriptSource = `Transcript tail from ${tail.path}`;
+    transcriptSource = `${source.label} from ${tail.path}`;
     truncated = tail.truncated;
     break;
   }