@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/intercom/result-intercom.js

@@ -12,6 +12,8 @@ export function resolveSubagentResultStatus(input) {
     return "stopped";
   if (input.interrupted || input.state === "paused")
     return "paused";
+  if (input.state === "running" || input.state === "queued")
+    return "running";
   if (input.success === true)
     return "completed";
   if (isUnexplainedProcessSignal(input) && input.exitCode !== 0)
@@ -28,6 +30,7 @@ export function resolveSubagentResultStatus(input) {
 }
 function countStatuses(children) {
   const counts = {
+    running: 0,
     completed: 0,
     failed: 0,
     paused: 0,
@@ -41,6 +44,7 @@ function countStatuses(children) {
 }
 function formatStatusCounts(counts) {
   const parts = [
+    counts.running ? `${counts.running} running` : undefined,
     counts.completed ? `${counts.completed} completed` : undefined,
     counts.failed ? `${counts.failed} failed` : undefined,
     counts.stopped ? `${counts.stopped} stopped` : undefined,
@@ -71,6 +75,8 @@ function resolveGroupedStatus(children) {
     return "stopped";
   if (counts.paused > 0)
     return "paused";
+  if (counts.running > 0)
+    return "running";
   if (counts.completed > 0)
     return "completed";
   if (counts.detached > 0)

package/extensions/dm-subagents/src/intercom/supervisor-ui.js

@@ -0,0 +1,199 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@duckmind/dm-tui";
+import { safeTerminalText } from "../shared/display-text.js";
+export const SUPERVISOR_REQUEST_MESSAGE_TYPE = "subagent_supervisor_request";
+export const SUPERVISOR_REPLY_ENTRY_TYPE = "subagent_supervisor_reply";
+const MAX_FIELD_CHARS = 512;
+const MAX_BODY_CHARS = 8000;
+const MAX_INTERVIEW_CHARS = 4000;
+const MAX_RENDER_LINES = 36;
+const TRUNCATION_MARKER = "[truncated]";
+export function supervisorReplyHint(requestId) {
+  return `subagent_supervisor({ action: "reply", replyTo: "${requestId}", message: "..." })`;
+}
+function boundedText(value, maxChars) {
+  const safe = safeTerminalText(value);
+  if (safe.length <= maxChars)
+    return safe;
+  const prefixLength = Math.max(0, maxChars - TRUNCATION_MARKER.length - 1);
+  let prefix = "";
+  for (const character of safe) {
+    if (prefix.length + character.length > prefixLength)
+      break;
+    prefix += character;
+  }
+  return `${prefix} ${TRUNCATION_MARKER}`;
+}
+function displayText(value, maxChars, expanded) {
+  return expanded ? safeTerminalText(value) : boundedText(value, maxChars);
+}
+function boundedField(value, fallback = "unknown") {
+  return boundedText(typeof value === "string" ? value : value === undefined ? fallback : String(value), MAX_FIELD_CHARS);
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => {
+    if (!part || typeof part !== "object")
+      return "";
+    const text = part.text;
+    return typeof text === "string" ? text : "";
+  }).filter(Boolean).join(`
+`);
+}
+function interviewText(interview, expanded) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(interview, null, 2) ?? String(interview);
+  } catch {
+    serialized = "[unavailable]";
+  }
+  return displayText(serialized, MAX_INTERVIEW_CHARS, expanded);
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isSupervisorReason(value) {
+  return value === "need_decision" || value === "interview_request" || value === "progress_update";
+}
+function optionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function requestDetails(value) {
+  if (!isRecord(value))
+    return;
+  if (!optionalString(value.id) || !optionalString(value.requestId) || !optionalString(value.replyHint) || !optionalString(value.requestBody) || !optionalString(value.runId) || !optionalString(value.agent) || !optionalString(value.childTarget))
+    return;
+  if (value.reason !== undefined && !isSupervisorReason(value.reason))
+    return;
+  if (value.expectsReply !== undefined && typeof value.expectsReply !== "boolean")
+    return;
+  if (value.childIndex !== undefined && (typeof value.childIndex !== "number" || !Number.isFinite(value.childIndex)))
+    return;
+  return value;
+}
+function replyData(value) {
+  if (!isRecord(value))
+    return;
+  if (typeof value.requestId !== "string" || typeof value.runId !== "string" || typeof value.agent !== "string" || typeof value.message !== "string")
+    return;
+  if (value.reason !== undefined && !isSupervisorReason(value.reason))
+    return;
+  if (value.childTarget !== undefined && typeof value.childTarget !== "string")
+    return;
+  if (typeof value.childIndex !== "number" || !Number.isFinite(value.childIndex) || typeof value.createdAt !== "number" || !Number.isFinite(value.createdAt))
+    return;
+  return {
+    requestId: value.requestId,
+    ...value.reason === undefined ? {} : { reason: value.reason },
+    runId: value.runId,
+    agent: value.agent,
+    childIndex: value.childIndex,
+    ...value.childTarget === undefined ? {} : { childTarget: value.childTarget },
+    message: value.message,
+    createdAt: value.createdAt
+  };
+}
+function withRequestId(details) {
+  return boundedField(details.requestId ?? details.id);
+}
+function requestHeading(reason) {
+  if (reason === "interview_request")
+    return "⚠ Supervisor interview request";
+  if (reason === "progress_update")
+    return "ℹ Supervisor progress update";
+  return "⚠ Supervisor decision request";
+}
+function requestLines(message, details, expanded) {
+  const requestId = withRequestId(details);
+  const lines = [
+    `Reason: ${boundedField(details.reason)}`,
+    `Run: ${boundedField(details.runId)}`,
+    `Agent: ${boundedField(details.agent)}`,
+    `Child index: ${boundedField(details.childIndex)}`
+  ];
+  if (details.childTarget)
+    lines.push(`Child target: ${boundedField(details.childTarget)}`);
+  lines.push(`Request ID: ${requestId}`);
+  if (details.expectsReply)
+    lines.push(`Reply with: ${displayText(details.replyHint ?? supervisorReplyHint(requestId), MAX_BODY_CHARS, expanded)}`);
+  lines.push("", "Request:", displayText((details.requestBody ?? contentText(message.content)) || "(no request body)", MAX_BODY_CHARS, expanded));
+  if (details.interview !== undefined)
+    lines.push("", "Interview shape:", interviewText(details.interview, expanded));
+  return lines;
+}
+function replyLines(data, expanded) {
+  const requestId = boundedField(data.requestId);
+  const lines = [
+    ...data.reason ? [`Reason: ${boundedField(data.reason)}`] : [],
+    `Run: ${boundedField(data.runId)}`,
+    `Agent: ${boundedField(data.agent)}`,
+    `Child index: ${boundedField(data.childIndex)}`
+  ];
+  if (data.childTarget)
+    lines.push(`Child target: ${boundedField(data.childTarget)}`);
+  lines.push(`Reply to: ${requestId}`, "", "Reply:", displayText(data.message || "(empty reply)", MAX_BODY_CHARS, expanded));
+  return lines;
+}
+function renderCard(lines, heading, theme, width, expanded) {
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth < 3)
+    return [truncateToWidth(heading, safeWidth, "")];
+  const bodyWidth = safeWidth - 2;
+  const headerText = truncateToWidth(` ${heading} `, bodyWidth, "");
+  const headerPadding = Math.max(0, bodyWidth - visibleWidth(headerText));
+  const border = (text) => theme.fg("accent", text);
+  const rendered = [border(`╭${headerText}${"─".repeat(headerPadding)}╮`)];
+  let hidden = false;
+  let interiorLines = 0;
+  for (const line of lines) {
+    const wrapped = wrapTextWithAnsi(line, Math.max(1, bodyWidth));
+    for (const wrappedLine of wrapped.length > 0 ? wrapped : [""]) {
+      if (!expanded && interiorLines >= MAX_RENDER_LINES) {
+        hidden = true;
+        break;
+      }
+      const text = truncateToWidth(wrappedLine, bodyWidth, "");
+      rendered.push(border(`│${text}${" ".repeat(Math.max(0, bodyWidth - visibleWidth(text)))}│`));
+      interiorLines++;
+    }
+    if (hidden)
+      break;
+  }
+  if (hidden) {
+    const text = truncateToWidth(TRUNCATION_MARKER, bodyWidth, "");
+    rendered.push(border(`│${text}${" ".repeat(Math.max(0, bodyWidth - visibleWidth(text)))}│`));
+  }
+  rendered.push(border(`╰${"─".repeat(bodyWidth)}╯`));
+  return rendered;
+}
+
+class SupervisorCardComponent {
+  expanded;
+  heading;
+  lines;
+  theme;
+  constructor(heading, lines, theme, expanded) {
+    this.expanded = expanded;
+    this.heading = heading;
+    this.lines = lines;
+    this.theme = theme;
+  }
+  invalidate() {}
+  render(width) {
+    return renderCard(this.lines, this.heading, this.theme, width, this.expanded);
+  }
+}
+export function renderSupervisorRequest(message, options, theme) {
+  const details = requestDetails(message.details);
+  if (!details)
+    return;
+  return new SupervisorCardComponent(requestHeading(details.reason), requestLines(message, details, options.expanded), theme, options.expanded);
+}
+export function renderSupervisorReply(entry, options, theme) {
+  const data = replyData(entry.data);
+  if (!data)
+    return;
+  return new SupervisorCardComponent("↩ Supervisor reply to child", replyLines(data, options.expanded), theme, options.expanded);
+}

package/extensions/dm-subagents/src/missions/workflow-state.js

@@ -45,14 +45,21 @@ function windowsProcessStartKey(pid) {
     return;
   }
 }
+let currentProcessKey = null;
 function processStartKey(pid) {
+  if (pid !== process.pid)
+    return computeProcessStartKey(pid);
+  if (currentProcessKey === null)
+    currentProcessKey = computeProcessStartKey(pid);
+  return currentProcessKey;
+}
+function computeProcessStartKey(pid) {
   if (process.platform === "linux")
     return linuxProcessStartKey(pid) ?? psProcessStartKey(pid);
   if (process.platform === "win32")
     return windowsProcessStartKey(pid);
   return;
 }
-const CURRENT_PROCESS_KEY = processStartKey(process.pid);
 function readStateLockOwner(lockPath) {
   try {
     const owner = JSON.parse(fs.readFileSync(path.join(lockPath, "owner.json"), "utf-8"));
@@ -69,15 +76,15 @@ function readStateLockOwner(lockPath) {
   }
   return;
 }
-function stateLockIsStale(lockPath, now = Date.now()) {
+function stateLockIsStale(lockPath, options, now = Date.now()) {
   const owner = readStateLockOwner(lockPath);
   if (owner) {
-    if (!isProcessAlive(owner.pid))
+    if (!options.isProcessAlive(owner.pid))
       return true;
     if (owner.processKey) {
-      const currentProcessKey = owner.pid === process.pid ? CURRENT_PROCESS_KEY : processStartKey(owner.pid);
-      if (currentProcessKey)
-        return owner.processKey !== currentProcessKey;
+      const observedProcessKey = options.getProcessStartKey(owner.pid);
+      if (observedProcessKey)
+        return owner.processKey !== observedProcessKey;
       if (owner.pid === process.pid)
         return true;
     }
@@ -121,13 +128,13 @@ function waitForStateLock(delayMs, lockPath) {
     throw new Error(`Timed out acquiring mission state lock '${lockPath}'.`);
   waitForFileSystemRetry(delayMs);
 }
-function reclaimStaleStateLock(lockPath, reclaimPath) {
-  if (!stateLockIsStale(lockPath))
+function reclaimStaleStateLock(lockPath, reclaimPath, options) {
+  if (!stateLockIsStale(lockPath, options))
     return false;
   if (!tryMakeDirectory(reclaimPath, 448))
     return false;
   try {
-    if (!stateLockIsStale(lockPath))
+    if (!stateLockIsStale(lockPath, options))
       return false;
     fs.rmSync(lockPath, { recursive: true, force: true });
     return true;
@@ -135,7 +142,7 @@ function reclaimStaleStateLock(lockPath, reclaimPath) {
     fs.rmSync(reclaimPath, { recursive: true, force: true });
   }
 }
-function withStateFileLock(filePath, operation) {
+function withStateFileLock(filePath, operation, options) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   const lockPath = `${filePath}.lock`;
   const reclaimPath = `${lockPath}.reclaim`;
@@ -146,7 +153,7 @@ function withStateFileLock(filePath, operation) {
         fs.rmSync(reclaimPath, { recursive: true, force: true });
         continue;
       }
-      waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+      waitForStateLock(options.retryDelaysMs[attempt], lockPath);
       continue;
     }
     let acquired = false;
@@ -154,18 +161,19 @@ function withStateFileLock(filePath, operation) {
       acquired = tryMakeDirectory(lockPath, 448);
     } catch (error) {
       if (isRetryableFileSystemError(error)) {
-        waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+        waitForStateLock(options.retryDelaysMs[attempt], lockPath);
         continue;
       }
       throw new Error(`Failed to acquire mission state lock '${lockPath}': ${error instanceof Error ? error.message : String(error)}`);
     }
     if (!acquired) {
-      if (reclaimStaleStateLock(lockPath, reclaimPath))
+      if (reclaimStaleStateLock(lockPath, reclaimPath, options))
         continue;
-      waitForStateLock(DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS[attempt], lockPath);
+      waitForStateLock(options.retryDelaysMs[attempt], lockPath);
       continue;
     }
-    owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...CURRENT_PROCESS_KEY ? { processKey: CURRENT_PROCESS_KEY } : {} };
+    const key = options.getProcessStartKey(process.pid);
+    owner = { pid: process.pid, token: randomUUID(), createdAt: Date.now(), ...key ? { processKey: key } : {} };
     try {
       fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
     } catch (error) {
@@ -188,8 +196,13 @@ function validateStateKey(value) {
   }
   return value;
 }
-export function createMissionWorkflowState(location, missionId) {
+export function createMissionWorkflowState(location, missionId, options = {}) {
   const filePath = missionStatePath(location, missionId);
+  const lockOptions = {
+    isProcessAlive: options.isProcessAlive ?? isProcessAlive,
+    getProcessStartKey: options.getProcessStartKey ?? processStartKey,
+    retryDelaysMs: options.retryDelaysMs ?? DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS
+  };
   let loaded = false;
   let values = Object.create(null);
   const readStateFile = () => {
@@ -239,7 +252,7 @@ export function createMissionWorkflowState(location, missionId) {
         writePrivateAtomicJson(filePath, next);
         values = next;
         loaded = true;
-      });
+      }, lockOptions);
     }
   };
 }

package/extensions/dm-subagents/src/policy/authority.js

@@ -4,7 +4,9 @@ export const AUTHORITY_ACTIONS = [
   "spawnBudgetGrant",
   "scheduleCreate",
   "stopRun",
-  "steerRun"
+  "steerRun",
+  "inspectorOpen",
+  "projectOpen"
 ];
 const DEFAULT_AUTHORITY_POLICY = {
   discardWorktree: "confirm",
@@ -12,7 +14,9 @@ const DEFAULT_AUTHORITY_POLICY = {
   spawnBudgetGrant: "confirm",
   scheduleCreate: "auto",
   stopRun: "auto",
-  steerRun: "auto"
+  steerRun: "auto",
+  inspectorOpen: "auto",
+  projectOpen: "confirm"
 };
 export function resolveAuthorityDecision(input) {
   return input.policy?.[input.action] ?? DEFAULT_AUTHORITY_POLICY[input.action];

package/extensions/dm-subagents/src/profiles/profiles.js

@@ -58,10 +58,8 @@ function validateSubagentProfile(filePath, parsed) {
     if (thinking !== undefined && thinking !== false && typeof thinking !== "string") {
       throw new Error(`Profile '${filePath}' has invalid thinking for '${name}'; expected a string or false.`);
     }
-    const fallbackModels = override.fallbackModels;
-    if (fallbackModels !== undefined && fallbackModels !== false && (!Array.isArray(fallbackModels) || fallbackModels.some((item) => typeof item !== "string"))) {
-      throw new Error(`Profile '${filePath}' has invalid fallbackModels for '${name}'; expected an array of strings or false.`);
-    }
+    if (override.fallbackModels !== undefined)
+      throw new Error(`Profile '${filePath}' uses removed field fallbackModels for '${name}'; configure one model instead.`);
   }
   const disableBuiltins = subagents.disableBuiltins;
   if (disableBuiltins !== undefined && typeof disableBuiltins !== "boolean") {
@@ -333,10 +331,17 @@ export function applySubagentProfile(name) {
   const settingsPath = getUserSettingsPath();
   const settings = readSettingsFile(settingsPath);
   const existing = settings.subagents && typeof settings.subagents === "object" && !Array.isArray(settings.subagents) ? settings.subagents : {};
+  const agentOverrides = { ...profile.subagents.agentOverrides };
+  const existingOverrides = existing.agentOverrides && typeof existing.agentOverrides === "object" && !Array.isArray(existing.agentOverrides) ? existing.agentOverrides : {};
+  for (const [name, value] of Object.entries(existingOverrides)) {
+    const machine = value && typeof value === "object" && !Array.isArray(value) ? value.machine : undefined;
+    if (typeof machine === "string" && agentOverrides[name]?.machine === undefined)
+      agentOverrides[name] = { ...agentOverrides[name], machine };
+  }
   settings.subagents = {
     ...existing,
     ...profile.subagents,
-    agentOverrides: profile.subagents.agentOverrides
+    agentOverrides
   };
   writeJsonFile(settingsPath, settings);
   return { filePath, settingsPath };

package/extensions/dm-subagents/src/runs/background/active-async-capacity.js

@@ -6,6 +6,7 @@ import { TEMP_ROOT_DIR } from "../../shared/types.js";
 import { readStatus } from "../../shared/utils.js";
 import { checkPidLiveness } from "./stale-run-reconciler.js";
 import { readProcessTerminal } from "./process-terminal.js";
+import { isTerminalAsyncState as terminalState, readWorkflowChildProcessEvidence } from "./workflow-terminal-proof.js";
 export const ACTIVE_ASYNC_CAPACITY_DIR = path.join(TEMP_ROOT_DIR, "session-active-async-capacity");
 export const DEFAULT_ABANDONED_SLOT_RELEASE_AFTER_MS = 20 * 60 * 1000;
 export const MIN_ABANDONED_SLOT_RELEASE_AFTER_MS = 5 * 60 * 1000;
@@ -137,9 +138,6 @@ function appendAbandonedReleaseEvent(asyncDir, owner, evidence, now) {
 `, "utf-8");
   } catch {}
 }
-function terminalState(state) {
-  return state !== "queued" && state !== "running" && state !== "paused";
-}
 function runnerReleaseVerdict(owner, status, options) {
   if (!status)
     return { state: "retained", reason: "status file is missing or unreadable" };
@@ -204,33 +202,9 @@ function workflowReleaseVerdict(owner, status, liveWorkflowRunIds) {
     return { state: "retained", reason: `workflow is still ${status.state}` };
   if (liveWorkflowRunIds.has(owner.runId))
     return { state: "retained", reason: "workflow controller is still live" };
-  for (const step of status.steps ?? []) {
-    const label = step.workflowKey ?? step.agent;
-    if (step.status === "pending" || step.status === "running" || step.status === "paused")
-      return { state: "retained", reason: `workflow child ${label} is still ${step.status}` };
-    if (typeof step.async !== "boolean")
-      return { state: "retained", reason: `workflow child ${label} is missing async classification` };
-    if (!step.async)
-      continue;
-    if (!step.runId)
-      return { state: "retained", reason: `async workflow child ${label} is missing run id` };
-    const childDir = path.join(path.dirname(owner.asyncDir), step.runId);
-    if (!fs.existsSync(childDir))
-      return { state: "retained", reason: `async workflow child ${label} directory is missing` };
-    const childStatus = readStatus(childDir);
-    if (!childStatus)
-      return { state: "retained", reason: `async workflow child ${label} status is missing or unreadable` };
-    if (!terminalState(childStatus.state))
-      return { state: "retained", reason: `async workflow child ${label} is still ${childStatus.state}` };
-    if (!childStatus.processTerminal?.runnerProcessInstanceId)
-      return { state: "retained", reason: `async workflow child ${label} has no runner process identity` };
-    const proof = readProcessTerminal(childDir, {
-      runId: step.runId,
-      runnerProcessInstanceId: childStatus.processTerminal.runnerProcessInstanceId
-    });
-    if (proof?.state !== "observed" || proof.runId !== step.runId)
-      return { state: "retained", reason: `async workflow child ${label} process-terminal proof is ${proof?.state ?? "missing"}` };
-  }
+  const evidence = readWorkflowChildProcessEvidence(owner.asyncDir, status.steps);
+  if (evidence.state !== "observed")
+    return { state: "retained", reason: evidence.reason };
   return { state: "releasable", reason: "workflow is terminal, controller is gone, and async children have observed proof" };
 }
 function ownerReleaseVerdict(owner, liveWorkflowRunIds, options) {
@@ -307,6 +281,7 @@ function createSlot(poolDir, owner) {
 }
 function handleFor(owner, limit, options, rollbackOwner) {
   const rootDir = options.rootDir ?? ACTIVE_ASYNC_CAPACITY_DIR;
+  const writeOwner = options.writeOwner ?? writePrivateAtomicJson;
   const dir = slotDir(sessionDir(owner.ownerSessionId, rootDir), owner.slot);
   return {
     owner,
@@ -317,11 +292,7 @@ function handleFor(owner, limit, options, rollbackOwner) {
           return false;
         const next = { ...current, runnerProcessInstanceId, runnerStartedAt: options.now?.() ?? Date.now() };
         Object.assign(owner, next);
-        try {
-          writePrivateAtomicJson(path.join(dir, "owner.json"), next);
-        } catch (error) {
-          console.error(`Failed to bind active async capacity to runner '${runnerProcessInstanceId}'; capacity will remain occupied:`, error);
-        }
+        writeOwner(path.join(dir, "owner.json"), next);
         return true;
       });
       if (!claimed.acquired || !claimed.value)
@@ -359,6 +330,28 @@ function handleFor(owner, limit, options, rollbackOwner) {
       });
       return claimed.acquired && claimed.value;
     },
+    rollbackBeforeRunnerProceed(runnerProcessInstanceId) {
+      const claimed = withSlotClaim(dir, () => {
+        const current = matchingOwner(dir, owner);
+        if (!current)
+          return false;
+        const boundToRunner = current.runnerProcessInstanceId === runnerProcessInstanceId;
+        const bindingFailedBeforeProceed = current.runnerProcessInstanceId === undefined && current.runnerStartedAt === undefined && owner.runnerProcessInstanceId === runnerProcessInstanceId;
+        if (!boundToRunner && !bindingFailedBeforeProceed)
+          return false;
+        if (rollbackOwner) {
+          writePrivateAtomicJson(path.join(dir, "owner.json"), rollbackOwner);
+          Object.assign(owner, rollbackOwner);
+          return true;
+        }
+        const releasedDir = path.join(path.dirname(dir), `.${path.basename(dir)}.released-${randomUUID()}`);
+        fs.renameSync(dir, releasedDir);
+        options.afterSlotRename?.(releasedDir);
+        fs.rmSync(releasedDir, { recursive: true, force: true });
+        return true;
+      });
+      return claimed.acquired && claimed.value;
+    },
     reconcile(liveWorkflowRunIds) {
       return reconcileActiveAsyncCapacity(owner.ownerSessionId, limit, { ...options, rootDir, liveWorkflowRunIds });
     }

package/extensions/dm-subagents/src/runs/background/active-run-index.js

@@ -80,6 +80,23 @@ export function updateActiveRunIndex(asyncDir, state, toolCallId, options = {})
     }
     return;
   }
+  if (options.terminalIndexBeforeRelease) {
+    fs.mkdirSync(path.dirname(marker), { recursive: true });
+    fs.writeFileSync(marker, "", { flag: "a" });
+    const status = readStatus(asyncDir);
+    if (status?.state === state) {
+      try {
+        updateTerminalRunIndex(asyncDir, status);
+      } catch (error) {
+        if (options.retryCapacityErrors)
+          throw error;
+        console.error(`Failed to write async terminal-run index for '${asyncDir}':`, error);
+        return;
+      }
+    }
+    releaseActiveRunIndex(asyncDir);
+    return;
+  }
   releaseActiveRunIndex(asyncDir);
   const status = readStatus(asyncDir);
   if (status && status.state === state) {