@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -22,9 +22,37 @@ import { validateAsyncStatusLaneMetadata } from "../shared/lane-metadata.js";
 import { formatWorkflowPreflightPlanSummary, formatWorkflowPreflightWarningSummary } from "../../workflows/workflow-preflight.js";
 import { workflowGraphStageNodes } from "../shared/workflow-graph.js";
 import { formatTimeoutRecoveryLines, projectTimeoutRecovery } from "../shared/mutation-evidence.js";
+import { formatWorkflowChecklistText, projectWorkflowChecklist } from "../../workflows/workflow-checklist.js";
+import { childWatchdogProgressForModel } from "../../watchdog/child-status.js";
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function isAsyncStatusIsolationError(asyncDir, error) {
+  const statusPath = path.join(asyncDir, "status.json");
+  const message = getErrorMessage(error);
+  return /^(?:Failed to (?:inspect|read|parse|validate) async status file|Invalid async status file) '/.test(message) || message.startsWith(`Invalid async status '${statusPath}'`) || message.startsWith(`Invalid host step '${statusPath}`) || /^(workflowChildren|Invalid workflowChildren)/.test(message);
+}
+function isolateCorruptActiveRun(asyncDir, runId, error, now) {
+  const statusPath = path.join(asyncDir, "status.json");
+  const processTerminal = readProcessTerminal(asyncDir, { runId });
+  let markerAge;
+  try {
+    markerAge = activeRunMarkerAgeMs(asyncDir, now?.());
+  } catch (markerError) {
+    console.error(`Failed to inspect corrupt async active-run marker for '${runId}':`, markerError);
+  }
+  const markerCanBeReleased = processTerminal?.state === "observed" || markerAge !== undefined && markerAge > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS;
+  let markerAction = "active marker retained because runner liveness is unknown";
+  if (markerCanBeReleased) {
+    try {
+      releaseActiveRunIndex(asyncDir);
+      markerAction = processTerminal?.state === "observed" ? "active marker released after observed process-terminal proof" : "stale active marker released";
+    } catch (releaseError) {
+      markerAction = `failed to release active marker: ${getErrorMessage(releaseError)}`;
+    }
+  }
+  console.error(`[dm-subagents] Skipping corrupt active async run '${runId}' at '${statusPath}': ${getErrorMessage(error)}; ${markerAction}.`);
+}
 function isNotFoundError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
@@ -99,15 +127,18 @@ function deriveAsyncActivityState(asyncDir, status) {
   };
 }
 function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
-  validateAsyncStatusLaneMetadata(status, `Invalid async status '${path.join(asyncDir, "status.json")}'`);
+  const statusPath = path.join(asyncDir, "status.json");
+  validateAsyncStatusLaneMetadata(status, `Invalid async status '${statusPath}'`);
   const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
   if (workflowChildren && workflowChildren.workflowRunId !== status.runId)
-    throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': workflowChildren.workflowRunId does not match.`);
-  assertWorkflowGraphHostSteps(status.workflowGraph, path.join(asyncDir, "status.json"), status.runId);
+    throw new Error(`Invalid async status '${statusPath}': workflowChildren.workflowRunId does not match.`);
+  assertWorkflowGraphHostSteps(status.workflowGraph, statusPath, status.runId);
   const hostSteps = validHostStepNodes(status.workflowGraph);
   if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
-    throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
+    throw new Error(`Invalid async status '${statusPath}': sessionId must be a string.`);
   }
+  if (status.outputFile !== undefined && typeof status.outputFile !== "string")
+    throw new Error(`Invalid async status '${statusPath}': outputFile must be a string.`);
   const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
   const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }) ?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path.join(asyncDir, "status.json"));
   const nestedProjectionAllowed = nestedWarnings.length === 0;
@@ -147,11 +178,14 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
       ...step.lane ? { lane: step.lane } : {},
       ...step.worktreePath ? { worktreePath: step.worktreePath } : {},
       ...step.branch ? { branch: step.branch } : {},
+      ...step.provider ? { provider: step.provider } : {},
+      ...step.naming ? { naming: step.naming } : {},
       ...step.runId ? { runId: step.runId } : {},
       ...step.outputName ? { outputName: step.outputName } : {},
       ...step.structured ? { structured: step.structured } : {},
       status: step.status,
       ...step.runner ? { runner: step.runner } : {},
+      ...step.externalProcess ? { externalProcess: step.externalProcess } : {},
       ...stepActivityState ? { activityState: stepActivityState } : {},
       ...stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {},
       ...step.currentTool ? { currentTool: step.currentTool } : {},
@@ -171,7 +205,7 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
       ...step.contextLimit !== undefined ? { contextLimit: step.contextLimit } : {},
       ...step.thinking ? { thinking: step.thinking } : {},
       ...step.thinkingCeiling ? { thinkingCeiling: step.thinkingCeiling } : {},
-      ...step.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
+      ...step.requestedModel ? { requestedModel: step.requestedModel } : {},
       ...step.sessionFile ? { sessionFile: step.sessionFile } : {},
       ...step.transcriptPath ? { transcriptPath: step.transcriptPath } : {},
       ...step.error ? { error: step.error } : {},
@@ -191,7 +225,7 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
       ...step.execution ? { execution: step.execution } : {},
       ...step.review ? { review: step.review } : {},
       ...step.effects ? { effects: step.effects } : {},
-      ...step.watchdog ? { watchdog: step.watchdog } : {},
+      ...step.watchdog ? { watchdog: childWatchdogProgressForModel(step.watchdog) } : {},
       ...step.processTerminal ? { processTerminal: sanitizeProcessTerminal(step.processTerminal, { runId: status.runId, runnerProcessInstanceId: step.processTerminal.runnerProcessInstanceId }, `${path.join(asyncDir, "status.json")} step ${index}`) } : {},
       ...timeoutRecovery ? { timeoutRecovery } : {},
       ...step.capabilityCeiling ? { capabilityCeiling: step.capabilityCeiling } : {},
@@ -292,7 +326,7 @@ function sortRuns(runs) {
     return bTime - aTime;
   });
 }
-export function listAsyncRuns(asyncDirRoot, options = {}) {
+export function listAsyncRuns(asyncDirRoot, options = {}, observeStatus) {
   let entries;
   const activeEntries = new Set;
   const wantsActive = options.states === undefined || options.states.some(isActiveAsyncState);
@@ -312,6 +346,7 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
             indexed.add(entry);
             activeEntries.add(entry);
           } else {
+            observeStatus?.(null);
             updateActiveRunIndex(path.join(asyncDirRoot, entry), "failed");
           }
         }
@@ -325,6 +360,7 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
   } catch (error) {
     if (isNotFoundError(error))
       return [];
+    observeStatus?.(null);
     throw new Error(`Failed to list async runs in '${asyncDirRoot}': ${getErrorMessage(error)}`, {
       cause: error instanceof Error ? error : undefined
     });
@@ -343,17 +379,37 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
   };
   for (const entry of entries) {
     const asyncDir = path.join(asyncDirRoot, entry);
-    const reconciliation = options.reconcile === false ? undefined : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
-    const status = reconciliation?.status ?? readStatus(asyncDir);
+    let status;
+    try {
+      if (options.sessionId !== undefined) {
+        const stored = readStatus(asyncDir);
+        if (stored && stored.sessionId !== options.sessionId) {
+          observeStatus?.(stored);
+          continue;
+        }
+      }
+      const reconciliation = options.reconcile === false ? undefined : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now }, observeStatus);
+      status = reconciliation?.status ?? readStatus(asyncDir);
+      if (options.reconcile === false)
+        observeStatus?.(status);
+    } catch (error) {
+      observeStatus?.(null);
+      if (!activeEntries.has(entry) || !isAsyncStatusIsolationError(asyncDir, error))
+        throw error;
+      isolateCorruptActiveRun(asyncDir, entry, error, options.now);
+      continue;
+    }
     if (!status) {
+      observeStatus?.(null);
       if (activeEntries.has(entry))
         updateActiveRunIndex(asyncDir, "failed");
       continue;
     }
     if (activeEntries.has(entry) && !isActiveAsyncState(status.state)) {
       const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId });
-      if (processTerminal?.state === "observed" || (activeRunMarkerAgeMs(asyncDir, options.now?.()) ?? 0) > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS)
-        releaseActiveRunIndex(asyncDir);
+      if (processTerminal?.state === "observed" || (activeRunMarkerAgeMs(asyncDir, options.now?.()) ?? 0) > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS) {
+        updateActiveRunIndex(asyncDir, status.state, status.toolCallId, { terminalIndexBeforeRelease: true });
+      }
     }
     if (status.displayDismissedAt !== undefined)
       continue;
@@ -369,10 +425,20 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
         if (nestedRoute)
           reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
       } catch (error) {
+        observeStatus?.(null);
         nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
       }
     }
-    const summary = statusToSummary(asyncDir, status, nestedWarnings, nestedRoute);
+    let summary;
+    try {
+      summary = statusToSummary(asyncDir, status, nestedWarnings, nestedRoute);
+    } catch (error) {
+      observeStatus?.(null);
+      if (!activeEntries.has(entry) || !isAsyncStatusIsolationError(asyncDir, error))
+        throw error;
+      isolateCorruptActiveRun(asyncDir, entry, error, options.now);
+      continue;
+    }
     runs.push(summary);
   }
   const sorted = sortRuns(runs);
@@ -421,7 +487,7 @@ function formatStepLine(step) {
   if (step.lane)
     parts.push(`lane ${step.lane.key}`);
   if (step.worktreePath)
-    parts.push(`worktree ${shortenPath(step.worktreePath)} · branch ${step.branch ?? "unknown"}`);
+    parts.push(`worktree ${shortenPath(step.worktreePath)} · branch ${step.branch ?? "unknown"}${step.provider ? ` · provider ${step.provider}` : ""}`);
   return parts.join(" | ");
 }
 function formatHostStepLine(row) {
@@ -513,6 +579,17 @@ export function formatAsyncRunList(runs, heading = "Active async runs") {
     const preflightWarning = formatWorkflowPreflightWarningSummary(run.workflow?.preflightWarnings, { indent: "  " });
     if (preflightWarning)
       lines.push(preflightWarning);
+    if (run.mode === "workflow") {
+      const checklist = projectWorkflowChecklist({
+        graph: run.workflowGraph,
+        steps: run.steps,
+        hostSteps: run.hostSteps,
+        preflight: run.preflight,
+        trace: run.workflow?.trace,
+        now: run.lastUpdate ?? run.endedAt ?? Date.now()
+      });
+      lines.push(...formatWorkflowChecklistText(checklist, "  ", { includeItems: false }));
+    }
     for (const step of run.steps) {
       lines.push(`  ${formatStepLine(step)}`);
       lines.push(...formatTimeoutRecoveryLines(step.timeoutRecovery, "    "));

package/extensions/dm-subagents/src/runs/background/auto-drain.js

@@ -1,46 +1,70 @@
 import { snapshotBackgroundWork } from "../../api/background-work.js";
-import { DIRS } from "../../shared/types.js";
 import { listAsyncRuns } from "./async-status.js";
-import { waitForSubagents } from "./subagent-wait.js";
+import { waitForSubagents, waitRunScopes } from "./subagent-wait.js";
 export const DEFAULT_AUTO_DRAIN_TIMEOUT_MS = 30 * 60 * 1000;
 function resultText(value) {
   return value.content.map((part) => part.type === "text" ? part.text : "").join(" ").trim();
 }
-function hasOutstandingWork(sessionId, nowMs) {
-  const asyncRuns = listAsyncRuns(DIRS.async, {
+function hasOutstandingWork(deps, sessionId, nowMs, observation) {
+  const asyncRuns = waitRunScopes(deps).flatMap(({ asyncDirRoot, resultsDir }) => listAsyncRuns(asyncDirRoot, {
     states: ["queued", "running"],
     sessionId,
-    resultsDir: DIRS.results,
-    now: () => nowMs
-  });
-  return asyncRuns.length > 0 || snapshotBackgroundWork(sessionId, nowMs).items.length > 0;
+    resultsDir,
+    now: () => nowMs,
+    includeNested: false
+  }, observation?.status));
+  const detachedForeground = [...deps.state.foregroundRuns?.values() ?? []].some((run) => run.sessionId === sessionId && run.children.some((child) => child.status === "detached"));
+  return asyncRuns.length > 0 || snapshotBackgroundWork(sessionId, nowMs).items.length > 0 || detachedForeground;
 }
-export async function drainOutstandingWork(deps) {
+export async function drainOutstandingWork(deps, observation) {
   const sessionId = deps.state.currentSessionId;
-  if (!sessionId)
-    throw new Error("Cannot auto-drain background work without an active session identity.");
-  const now = deps.now ?? Date.now;
-  const timeoutMs = deps.timeoutMs ?? DEFAULT_AUTO_DRAIN_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-    throw new Error("Auto-drain timeoutMs must be a positive finite number.");
-  const deadlineAt = now() + timeoutMs;
-  const hasWork = deps.hasWork ?? hasOutstandingWork;
-  const wait = deps.wait ?? waitForSubagents;
-  while (hasWork(sessionId, now())) {
-    const remainingMs = deadlineAt - now();
-    if (remainingMs <= 0) {
-      throw new Error(`Auto-drain timed out after ${timeoutMs}ms with background work still active in session '${sessionId}'.`);
-    }
-    const waitResult = await wait({ all: true, timeoutMs: remainingMs }, undefined, {
-      state: deps.state,
-      events: deps.events,
-      now,
-      stopOnAttention: false,
-      failOnFailedRuns: true,
-      failOnAttention: true
-    });
-    if (waitResult.isError) {
-      throw new Error(`Auto-drain failed for session '${sessionId}': ${resultText(waitResult) || "bg_wait returned an error without details"}.`);
+  observation?.begin(sessionId, !deps.hasWork && !deps.wait && !deps.now && !deps.hasPendingSupervisorRequest);
+  try {
+    if (!sessionId)
+      throw new Error("Cannot auto-drain background work without an active session identity.");
+    const now = deps.now ?? Date.now;
+    const timeoutMs = deps.timeoutMs ?? DEFAULT_AUTO_DRAIN_TIMEOUT_MS;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+      throw new Error("Auto-drain timeoutMs must be a positive finite number.");
+    const deadlineAt = now() + timeoutMs;
+    const hasWork = deps.hasWork ?? ((id, time) => hasOutstandingWork(deps, id, time, observation));
+    const wait = deps.wait ?? waitForSubagents;
+    while (true) {
+      if (deps.state.currentSessionId !== sessionId)
+        throw new Error("Auto-drain stopped because the active session changed.");
+      if (deps.hasPendingSupervisorRequest?.())
+        break;
+      const work = hasWork(sessionId, now());
+      observation?.predicate(work);
+      if (!work)
+        break;
+      const remainingMs = deadlineAt - now();
+      if (remainingMs <= 0) {
+        throw new Error(`Auto-drain timed out after ${timeoutMs}ms with background work still active in session '${sessionId}'.`);
+      }
+      const waitResult = await wait({ all: true, timeoutMs: remainingMs }, undefined, {
+        state: deps.state,
+        asyncDirRoot: deps.asyncDirRoot,
+        resultsDir: deps.resultsDir,
+        nestedRootRunId: deps.nestedRootRunId,
+        events: deps.events,
+        now,
+        stopOnAttention: false,
+        failOnFailedRuns: true,
+        failOnAttention: true,
+        hasPendingSupervisorRequest: deps.hasPendingSupervisorRequest
+      });
+      if (waitResult.isError) {
+        throw new Error(`Auto-drain failed for session '${sessionId}': ${resultText(waitResult) || "bg_wait returned an error without details"}.`);
+      }
+      if (waitResult.details.wait?.reason === "supervisor_request")
+        break;
+      if (deps.hasPendingSupervisorRequest?.())
+        break;
     }
+    observation?.complete();
+  } catch (error) {
+    observation?.deny();
+    throw error;
   }
 }

package/extensions/dm-subagents/src/runs/background/binary-bootstrap.js

@@ -0,0 +1,54 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
+import * as piCore from "@duckmind/dm-agent-core";
+import * as piAi from "@duckmind/dm-ai/compat";
+import * as piTui from "@duckmind/dm-tui";
+import * as sdk from "@duckmind/dm-coding-agent";
+import * as typebox from "typebox";
+import * as typeboxCompile from "typebox/compile";
+import * as typeboxValue from "typebox/value";
+import { installRunnerHttpDispatcher } from "./runner-http-dispatcher.js";
+import { runConfiguredSubagent, validateSubagentRunConfig } from "./subagent-runner-bootstrap.js";
+import { getAgentDir } from "../../shared/utils.js";
+export default async function runBinaryBootstrap() {
+  const configPath = process.env.DM_SUBAGENT_RUNNER_CONFIG;
+  delete process.env.DM_SUBAGENT_RUNNER_CONFIG;
+  try {
+    if (!configPath || !path.isAbsolute(configPath))
+      throw new Error("Missing absolute DM_SUBAGENT_RUNNER_CONFIG path");
+    const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    validateSubagentRunConfig(rawConfig);
+    const config = rawConfig;
+    try {
+      fs.unlinkSync(configPath);
+    } catch {}
+    installRunnerHttpDispatcher({ agentDir: getAgentDir(), cwd: process.cwd() });
+    await runConfiguredSubagent(config, {
+      loadPiCodingAgent: async () => sdk,
+      loadExecutionModule: async () => {
+        const jiti = createJiti(import.meta.url, {
+          tryNative: false,
+          moduleCache: false,
+          virtualModules: {
+            "@duckmind/dm-agent-core": piCore,
+            "@duckmind/dm-ai": piAi,
+            "@duckmind/dm-ai/compat": piAi,
+            "@duckmind/dm-tui": piTui,
+            "@duckmind/dm-coding-agent": sdk,
+            typebox,
+            "typebox/compile": typeboxCompile,
+            "typebox/value": typeboxValue
+          }
+        });
+        const runner = `./subagent-runner${path.extname(fileURLToPath(import.meta.url))}`;
+        return jiti.import(runner);
+      }
+    });
+    process.exit(0);
+  } catch (error) {
+    console.error("Subagent binary runner error:", error);
+    process.exit(1);
+  }
+}

package/extensions/dm-subagents/src/runs/background/chain-append.js

@@ -145,7 +145,7 @@ function statusStepForTask(task) {
     model: task.model,
     ...task.contextLimit !== undefined ? { contextLimit: task.contextLimit } : {},
     thinking: task.thinking,
-    attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+    requestedModel: task.requestedModel,
     recentTools: [],
     recentOutput: []
   };

package/extensions/dm-subagents/src/runs/background/chain-root-attachment.js

@@ -4,22 +4,6 @@ import { resultFilePath, resultPayloadPathForSessionRun } from "./result-files.j
 import { readStatus } from "../../shared/utils.js";
 const TERMINAL_STATES = new Set(["complete", "failed", "partial", "paused", "stopped"]);
 const TERMINAL_STEP_STATUSES = new Set(["complete", "completed", "failed", "partial", "paused", "stopped"]);
-function usageFromAttempts(attempts) {
-  if (!attempts?.length)
-    return;
-  const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-  for (const attempt of attempts) {
-    if (!attempt.usage)
-      continue;
-    usage.input += attempt.usage.input;
-    usage.output += attempt.usage.output;
-    usage.cacheRead += attempt.usage.cacheRead;
-    usage.cacheWrite += attempt.usage.cacheWrite;
-    usage.cost += attempt.usage.cost;
-    usage.turns += attempt.usage.turns;
-  }
-  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0 ? usage : undefined;
-}
 function readResultFile(resultPath) {
   try {
     return JSON.parse(fs.readFileSync(resultPath, "utf-8"));
@@ -43,6 +27,8 @@ function selectedStatusStep(status, index) {
 function isTerminalStatus(status, index) {
   if (!status)
     return false;
+  if (status.mode === "single" && status.parentWorkflowRunId && (!status.processTerminal || status.processTerminal.state === "pending"))
+    return TERMINAL_STATES.has(status.state);
   const step = selectedStatusStep(status, index);
   if (step && TERMINAL_STEP_STATUSES.has(step.status))
     return true;
@@ -72,7 +58,6 @@ function outputFromTerminalStatus(root, status, step) {
   const message = step?.error ?? status.error ?? (stopped ? "Subagent stopped by user." : `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`);
   const partialStatus = status.state === "partial" || step?.status === "partial";
   const execution = step?.execution ?? (partialStatus ? { status: "partial", success: false, exitCode: 1, error: message } : undefined);
-  const usage = usageFromAttempts(step?.modelAttempts);
   return {
     agent,
     output: message,
@@ -84,11 +69,9 @@ function outputFromTerminalStatus(root, status, step) {
     ...step?.sessionName ? { sessionName: step.sessionName } : {},
     ...step?.sessionFile ?? status.sessionFile ? { sessionFile: step?.sessionFile ?? status.sessionFile } : {},
     ...step?.model ? { model: step.model } : {},
-    ...step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
-    ...step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {},
+    ...step?.requestedModel ? { requestedModel: step.requestedModel } : {},
     ...step?.contextOverflow ? { contextOverflow: true } : {},
     ...step?.totalCost ? { totalCost: step.totalCost } : {},
-    ...usage ? { usage } : {},
     ...step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {},
     ...step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {},
     ...step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: step.structuredOutputSchemaPath } : {},
@@ -100,7 +83,6 @@ function outputFromTerminalStatus(root, status, step) {
 }
 function outputFromTimeout(root, status, message) {
   const step = selectedStatusStep(status, root.index);
-  const usage = usageFromAttempts(step?.modelAttempts);
   return {
     agent: step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent",
     output: message,
@@ -111,11 +93,9 @@ function outputFromTimeout(root, status, message) {
     ...step?.sessionName ? { sessionName: step.sessionName } : {},
     ...step?.sessionFile ?? status?.sessionFile ? { sessionFile: step?.sessionFile ?? status?.sessionFile } : {},
     ...step?.model ? { model: step.model } : {},
-    ...step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
-    ...step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {},
+    ...step?.requestedModel ? { requestedModel: step.requestedModel } : {},
     ...step?.contextOverflow ? { contextOverflow: true } : {},
     ...step?.totalCost ? { totalCost: step.totalCost } : {},
-    ...usage ? { usage } : {},
     ...step?.transcriptPath ? { transcriptPath: step.transcriptPath } : {}
   };
 }
@@ -130,9 +110,13 @@ function buildImportedResult(root, status, result) {
   const success = state === "complete" && !timedOut && !stopped;
   const error = child?.error ?? (success ? undefined : stopped ? "Subagent stopped by user." : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
   const execution = state ? { status: state === "complete" ? "completed" : state, success, exitCode: success ? 0 : 1, ...error ? { error } : {} } : undefined;
-  const usage = child?.usage ?? usageFromAttempts(step?.modelAttempts);
+  const usage = child?.usage;
   return {
     agent,
+    importedPublication: {
+      ...typeof result.sessionId === "string" ? { sessionId: result.sessionId } : {},
+      ...typeof result.toolCallId === "string" ? { toolCallId: result.toolCallId } : {}
+    },
     output: success ? output : output || error || "",
     success,
     exitCode: success ? 0 : 1,
@@ -143,8 +127,7 @@ function buildImportedResult(root, status, result) {
     ...child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile ? { sessionFile: child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile } : {},
     ...child?.intercomTarget ? { intercomTarget: child.intercomTarget } : {},
     ...child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {},
-    ...child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {},
-    ...child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {},
+    ...child?.requestedModel ?? step?.requestedModel ? { requestedModel: child?.requestedModel ?? step?.requestedModel } : {},
     ...child?.contextOverflow || step?.contextOverflow ? { contextOverflow: true } : {},
     ...child?.totalCost ?? step?.totalCost ? { totalCost: child?.totalCost ?? step?.totalCost } : {},
     ...usage ? { usage } : {},
@@ -153,6 +136,7 @@ function buildImportedResult(root, status, result) {
     ...child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath } : {},
     ...child?.acceptance ?? step?.acceptance ? { acceptance: child?.acceptance ?? step?.acceptance } : {},
     ...child?.artifactPaths ? { artifactPaths: child.artifactPaths } : {},
+    ...child?.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {},
     ...child?.outputSaveError ? { outputSaveError: child.outputSaveError } : {},
     ...child?.transcriptPath ?? step?.transcriptPath ? { transcriptPath: child?.transcriptPath ?? step?.transcriptPath } : {},
     ...child?.transcriptError ? { transcriptError: child.transcriptError } : {},