@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/resume-guidance.js

@@ -0,0 +1,44 @@
+import * as fs from "node:fs";
+import { readAsyncRecoveryDescriptor } from "./async-resume.js";
+const INTERCOM_DETACH_ERROR = "detached for intercom coordination";
+function isIntercomDetached(run) {
+  return run.steps.some((step) => step.execution?.status === "detached" || step.error?.toLowerCase().includes(INTERCOM_DETACH_ERROR) === true) || run.error?.toLowerCase().includes(INTERCOM_DETACH_ERROR) === true;
+}
+function formatIntercomDetachGuidance(run) {
+  if (!isIntercomDetached(run))
+    return;
+  return `Run "${run.id}" detached for intercom coordination. Reply to the supervisor request first, then wait with bg_wait({ id: "${run.id}" }). Use subagent({ action: "status", id: "${run.id}" }) to recover the result; do not resume or launch a replacement while it remains detached.`;
+}
+export function formatAsyncReviveCommand(run) {
+  const step = run.steps.find((candidate) => candidate.status === "failed");
+  const sessionFile = step?.sessionFile ?? (run.steps.length === 1 ? run.sessionFile : undefined);
+  if (!step || !sessionFile || !fs.existsSync(sessionFile))
+    return;
+  try {
+    const descriptor = readAsyncRecoveryDescriptor(run.asyncDir);
+    if (!descriptor || descriptor.sourceRunId !== run.id || descriptor.agent !== step.agent)
+      return;
+  } catch {
+    return;
+  }
+  const index = run.steps.length === 1 ? "" : `, index: ${step.index}`;
+  return `subagent({ action: "resume", id: "${run.id}"${index}, message: "Continue from the persisted child session and report the result." })`;
+}
+export function formatResumeFirstFailedRunDetail(run) {
+  if (run.state !== "failed")
+    return;
+  const detachGuidance = formatIntercomDetachGuidance(run);
+  if (detachGuidance)
+    return detachGuidance;
+  const command = formatAsyncReviveCommand(run);
+  if (!command)
+    return;
+  return `Resume-first: failed run "${run.id}" has a persisted child session. Revive the original run with ${command} before reporting failure or launching a replacement. Launch a replacement only if revive fails or the user explicitly asks for one.`;
+}
+export function formatResumeFirstFailedRunsNote(runs) {
+  const failedRuns = runs.filter((run) => run.state === "failed" || run.state === "partial");
+  const detachGuidance = failedRuns.map(formatIntercomDetachGuidance).filter((guidance) => Boolean(guidance));
+  const resumable = failedRuns.filter((run) => !isIntercomDetached(run)).map((run) => ({ run, command: formatAsyncReviveCommand(run) })).filter((entry) => Boolean(entry.command));
+  const resumeGuidance = resumable.length === 0 ? "" : resumable.length === 1 ? ` Resume-first: failed run "${resumable[0].run.id}" has a persisted child session. Revive the original run with ${resumable[0].command} before reporting failure or launching a replacement. Launch a replacement only if revive fails or the user explicitly asks for one.` : ` Resume-first: ${resumable.length} failed runs have persisted child sessions. Inspect status and revive each original run before reporting failure or launching a replacement. Launch a replacement only if revive fails or the user explicitly asks for one.`;
+  return `${detachGuidance.length > 0 ? ` ${detachGuidance.join(" ")}` : ""}${resumeGuidance}`;
+}

package/extensions/dm-subagents/src/runs/background/retained-children.js

@@ -0,0 +1,119 @@
+import * as fs from "node:fs";
+import { listAsyncRuns } from "./async-status.js";
+import { readAsyncRecoveryDescriptor } from "./async-resume.js";
+import { parallelHandoffPath, resolveRetainedWorktreeCwd } from "../shared/parallel-handoff.js";
+const MAX_RETAINED_CHILDREN = 10;
+const MAX_RETAINED_CHILD_CANDIDATES = 100;
+const MAX_TASK_SUMMARY_LENGTH = 120;
+function isRetainedChildState(state) {
+  return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped";
+}
+function isTerminalStepStatus(status) {
+  return status === "complete" || status === "completed" || status === "failed" || status === "paused" || status === "stopped";
+}
+function retainedSessionFile(sessionFile) {
+  if (!sessionFile)
+    return { state: "not-resumable", reason: "no persisted session file" };
+  if (!sessionFile.endsWith(".jsonl"))
+    return { state: "not-resumable", reason: "persisted session file is not a .jsonl file" };
+  try {
+    const stat = fs.lstatSync(sessionFile);
+    if (!stat.isFile() || stat.isSymbolicLink())
+      return { state: "not-resumable", reason: "persisted session file is not a regular file" };
+    return { state: "resumable", sessionPath: sessionFile };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return { state: "not-resumable", reason: `persisted session file is missing: ${sessionFile}` };
+    }
+    return { state: "not-resumable", reason: `persisted session file could not be inspected: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function childResumability(run, step) {
+  if (run.state === "stopped" || step.status === "stopped")
+    return { state: "not-resumable", reason: "stopped run" };
+  if (step.runner?.type === "external-cli" || step.runner?.type === "external-job")
+    return { state: "not-resumable", reason: "external runner" };
+  const session = retainedSessionFile(step.sessionFile ?? run.sessionFile);
+  if (session.state === "not-resumable")
+    return session;
+  let recoveryDescriptor;
+  try {
+    recoveryDescriptor = readAsyncRecoveryDescriptor(run.asyncDir);
+    if (!recoveryDescriptor)
+      return { state: "not-resumable", reason: "missing recovery descriptor" };
+    if (recoveryDescriptor.sourceRunId !== run.id)
+      return { state: "not-resumable", reason: `recovery descriptor belongs to run ${recoveryDescriptor.sourceRunId}` };
+    if (recoveryDescriptor.agent !== step.agent)
+      return { state: "not-resumable", reason: `recovery descriptor belongs to agent ${recoveryDescriptor.agent}` };
+  } catch (error) {
+    return { state: "not-resumable", reason: `invalid recovery descriptor: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  let requiredCwd;
+  try {
+    requiredCwd = resolveRetainedWorktreeCwd(parallelHandoffPath(run.asyncDir), run.id, step.index) ?? recoveryDescriptor.cwd ?? run.cwd;
+    if (!requiredCwd || !fs.statSync(requiredCwd).isDirectory())
+      return { state: "not-resumable", reason: `required cwd is missing: ${requiredCwd ?? "unknown"}` };
+  } catch (error) {
+    return { state: "not-resumable", reason: `resume dependency unavailable: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return session;
+}
+function boundedTaskSummary(value) {
+  const normalized = value?.replace(/\s+/g, " ").trim() ?? "";
+  return normalized.length > MAX_TASK_SUMMARY_LENGTH ? `${normalized.slice(0, MAX_TASK_SUMMARY_LENGTH - 1)}…` : normalized;
+}
+export function listRetainedChildren(asyncDirRoot, sessionId) {
+  const children = listAsyncRuns(asyncDirRoot, { sessionId, states: ["complete", "failed", "paused", "stopped"], entryLimit: MAX_RETAINED_CHILD_CANDIDATES, reconcile: false }).flatMap((run) => {
+    if (!run.parentWorkflowRunId || run.steps.length !== 1)
+      return [];
+    if (!isRetainedChildState(run.state))
+      return [];
+    const step = run.steps[0];
+    if (!isTerminalStepStatus(step.status))
+      return [];
+    const completedAt = run.endedAt ?? run.lastUpdate;
+    if (completedAt === undefined)
+      return [];
+    const resumability = childResumability(run, step);
+    return [{
+      runId: run.id,
+      ...run.parentWorkflowRunId ? { parentRunId: run.parentWorkflowRunId } : {},
+      ...run.workflowKey ? { workflowKey: run.workflowKey } : {},
+      state: run.state,
+      agent: step.agent,
+      taskSummary: boundedTaskSummary(step.description),
+      completedAt,
+      resumability,
+      ...resumability.state === "resumable" ? { sessionPath: resumability.sessionPath } : {},
+      ...step.tokens ?? run.totalTokens ? { tokenTotals: step.tokens ?? run.totalTokens } : {}
+    }];
+  }).sort((left, right) => right.completedAt - left.completedAt);
+  return children;
+}
+export function formatRetainedChildren(children) {
+  if (children.length === 0)
+    return "No retained workflow children in the active parent session. If a retained-writer challenge is required, launch a same-role fallback challenge and label it as fallback.";
+  const retained = children.slice(0, MAX_RETAINED_CHILDREN);
+  if (!retained.some((child) => child.resumability.state === "resumable")) {
+    const resumable = children.slice(MAX_RETAINED_CHILDREN).find((child) => child.resumability.state === "resumable");
+    if (resumable && retained.length === MAX_RETAINED_CHILDREN)
+      retained[MAX_RETAINED_CHILDREN - 1] = resumable;
+  }
+  const hasResumableChild = retained.some((child) => child.resumability.state === "resumable");
+  return [
+    `Retained workflow children (up to ${MAX_RETAINED_CHILDREN}; newest first, with a resumable child retained when available):`,
+    ...retained.flatMap((child) => [
+      `- ${child.runId} | ${child.agent} | ${child.state} | ${new Date(child.completedAt).toISOString()}`,
+      ...child.parentRunId ? [`  workflow: ${child.parentRunId}${child.workflowKey ? ` (${child.workflowKey})` : ""}`] : [],
+      `  task: ${child.taskSummary || "(no task summary)"}`,
+      child.resumability.state === "resumable" ? "  resumability: resumable" : `  resumability: not resumable (${child.resumability.reason})`,
+      ...child.resumability.state === "resumable" ? [
+        `  session: ${child.resumability.sessionPath}`,
+        `  resume: subagent({ action: "resume", id: "${child.runId}", message: "..." })`
+      ] : [],
+      ...child.tokenTotals ? [`  tokens: input ${child.tokenTotals.input}, output ${child.tokenTotals.output}, total ${child.tokenTotals.total}`] : []
+    ]),
+    ...hasResumableChild ? [] : ["No resumable retained child is listed. Launch a same-role fallback challenge and label it as fallback."]
+  ].join(`
+`);
+}

package/extensions/dm-subagents/src/runs/background/run-id-query.js

@@ -0,0 +1,5 @@
+export const MIN_SAFE_ASYNC_RUN_PREFIX_LENGTH = 8;
+const FULL_ASYNC_RUN_ID_LENGTH = 36;
+export function canScanAsyncRunPrefix(id) {
+  return id.length >= MIN_SAFE_ASYNC_RUN_PREFIX_LENGTH && id.length < FULL_ASYNC_RUN_ID_LENGTH;
+}

package/extensions/dm-subagents/src/runs/background/run-id-resolver.js

@@ -1,23 +1,99 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ASYNC_DIR, RESULTS_DIR } from "../../shared/types.js";
+import { DIRS } from "../../shared/types.js";
+import { readStatus } from "../../shared/utils.js";
 import { findAsyncRunPrefixMatches } from "./async-resume.js";
+import { resultCandidateFilesForToolCall, resultFilePath, resultPayloadPathForIndexedRun } from "./result-files.js";
+import { readActiveRunToolCallIndex } from "./active-run-index.js";
 import { assertSafeNestedId, findNestedRunMatchesById } from "../shared/nested-events.js";
 function exactAsyncLocation(id, asyncDirRoot, resultsDir) {
   const asyncDir = path.join(asyncDirRoot, id);
-  const resultPath = path.join(resultsDir, `${id}.json`);
-  if (!fs.existsSync(asyncDir) && !fs.existsSync(resultPath))
+  const asyncDirExists = fs.existsSync(asyncDir);
+  const resultPath = resultPathFor(resultsDir, id);
+  if (!asyncDirExists && !resultPath)
     return;
   return {
-    asyncDir: fs.existsSync(asyncDir) ? asyncDir : null,
-    resultPath: fs.existsSync(resultPath) ? resultPath : null,
+    asyncDir: asyncDirExists ? asyncDir : null,
+    resultPath,
     resolvedId: id
   };
 }
+function readWorkflowResultIdentity(resultPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return;
+  const record = parsed;
+  return {
+    ...typeof record.id === "string" ? { id: record.id } : {},
+    ...typeof record.runId === "string" ? { runId: record.runId } : {},
+    ...typeof record.toolCallId === "string" ? { toolCallId: record.toolCallId } : {}
+  };
+}
+function resultPathFor(resultsDir, runId) {
+  const resultPath = resultPayloadPathForIndexedRun(resultsDir, runId) ?? resultFilePath(resultsDir, runId);
+  return fs.existsSync(resultPath) ? resultPath : null;
+}
+function toolCallIdMatches(value, query) {
+  return value === query;
+}
+function indexedToolCallIdAsyncLocations(toolCallId, asyncDirRoot, resultsDir) {
+  const byId = new Map;
+  for (const entry of readActiveRunToolCallIndex(asyncDirRoot, toolCallId)) {
+    const asyncDir = path.join(asyncDirRoot, entry);
+    const status = readStatus(asyncDir);
+    if (!status || !toolCallIdMatches(status.toolCallId, toolCallId))
+      continue;
+    const runId = status.runId || entry;
+    byId.set(runId, { asyncDir, resultPath: resultPathFor(resultsDir, runId), resolvedId: runId });
+  }
+  for (const entry of resultCandidateFilesForToolCall(resultsDir, toolCallId)) {
+    const runIdFromFile = entry.slice(0, -".json".length);
+    const resultPath = resultPayloadPathForIndexedRun(resultsDir, runIdFromFile) ?? path.join(resultsDir, entry);
+    const identity = readWorkflowResultIdentity(resultPath);
+    if (!identity || !toolCallIdMatches(identity.toolCallId, toolCallId))
+      continue;
+    const runId = identity.runId ?? identity.id ?? runIdFromFile;
+    const asyncDir = path.join(asyncDirRoot, runId);
+    byId.set(runId, { asyncDir: fs.existsSync(asyncDir) ? asyncDir : null, resultPath, resolvedId: runId });
+  }
+  return [...byId.entries()].map(([id, location]) => ({ id, location }));
+}
 function foregroundIds(state) {
   if (!state)
     return [];
-  return [...new Set([...state.foregroundControls.keys(), ...state.foregroundRuns?.keys() ?? []])];
+  const remembered = state.currentSessionId ? [...state.foregroundRuns?.values() ?? []].filter((run) => run.sessionId === state.currentSessionId).map((run) => run.runId) : [];
+  return [...new Set([...state.foregroundControls.keys(), ...remembered])];
+}
+function hasExactForegroundId(state, id) {
+  if (!state)
+    return false;
+  if (state.foregroundControls.has(id))
+    return true;
+  const remembered = state.foregroundRuns?.get(id);
+  return Boolean(remembered && state.currentSessionId && remembered.sessionId === state.currentSessionId);
+}
+function exactLiveAsyncToolCallMatch(state, toolCallId, asyncDirRoot, resultsDir) {
+  if (!state?.asyncJobs)
+    return;
+  const matches = [...state.asyncJobs.values()].filter((job) => job.toolCallId === toolCallId);
+  if (matches.length > 1)
+    throw new Error(`Subagent tool-call id '${toolCallId}' is ambiguous across async runs. Use the returned asyncId instead.`);
+  const match = matches[0];
+  if (!match)
+    return;
+  return {
+    id: match.asyncId,
+    location: {
+      asyncDir: fs.existsSync(match.asyncDir) ? match.asyncDir : path.join(asyncDirRoot, match.asyncId),
+      resultPath: resultPathFor(resultsDir, match.asyncId),
+      resolvedId: match.asyncId
+    }
+  };
 }
 function nestedScopeFromState(state) {
   if (!state)
@@ -44,14 +120,22 @@ function asyncPrefixMatches(prefix, asyncDirRoot, resultsDir) {
 }
 export function resolveSubagentRunId(id, deps = {}) {
   assertSafeNestedId("id", id);
-  const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-  const resultsDir = deps.resultsDir ?? RESULTS_DIR;
+  const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
+  const resultsDir = deps.resultsDir ?? DIRS.results;
   const nestedScope = deps.nested ?? nestedScopeFromState(deps.state);
-  if (deps.state?.foregroundControls.has(id) || deps.state?.foregroundRuns?.has(id))
+  if (hasExactForegroundId(deps.state, id))
     return { kind: "foreground", id };
   const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
   if (exactAsync)
     return { kind: "async", id, location: exactAsync };
+  const exactLiveToolCallMatch = exactLiveAsyncToolCallMatch(deps.state, id, asyncDirRoot, resultsDir);
+  if (exactLiveToolCallMatch)
+    return { kind: "async", id: exactLiveToolCallMatch.id, location: exactLiveToolCallMatch.location };
+  const exactToolCallIdMatches = indexedToolCallIdAsyncLocations(id, asyncDirRoot, resultsDir);
+  if (exactToolCallIdMatches.length > 1)
+    throw new Error(`Subagent tool-call id '${id}' is ambiguous across async runs. Use the returned asyncId instead.`);
+  if (exactToolCallIdMatches[0])
+    return { kind: "async", id: exactToolCallIdMatches[0].id, location: exactToolCallIdMatches[0].location };
   const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
   if (exactNested.length > 1)
     throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);