@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-subagents/src/runs/foreground/execution.js

@@ -1,3 +1,4 @@
+import { dmRetryDelay, implementationMutationError, implementationToolsError } from "../../shared/dm-safeguards.js";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { discoverAgents, formatUnknownAgentError, unknownAgentDiagnosticContext } from "../../agents/agents.js";
@@ -39,6 +40,7 @@ import {
   boundStreamedToolCalls
 } from "../../shared/utils.js";
 import { resolveSkillsWithFallback } from "../../agents/skills.js";
+import { createPartialOutputTracker, formatPartialOutput } from "../shared/partial-output.js";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, resolveToolTimeoutMs, toolTimeoutCallKey, toolTimeoutFromEnv } from "../shared/tool-timeout.js";
 import { preflightLaunchCwd } from "../shared/launch-cwd.js";
 import { createJsonlWriter } from "../../shared/jsonl-writer.js";
@@ -47,12 +49,12 @@ import { resolvePermissionRules } from "../shared/permissions.js";
 import { applyThinkingSuffix, deriveForkPromptCacheKey } from "../shared/child-tool-plan.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
-import { resolveEffectiveThinking } from "../../shared/model-info.js";
+import { qualifyModelWithProvider, resolveEffectiveThinking } from "../../shared/model-info.js";
 import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
 import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.js";
 import { formatMidToolExitError, isOrdinaryToolForMidToolExit } from "../shared/process-signal.js";
 import { formatChildToolDiagnostic } from "../shared/tool-availability.js";
-import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
+import { formatChildModelResolutionDiagnostic, formatInheritedProviderDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
 import { planAbortRecovery } from "../shared/abort-recovery.js";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.js";
 import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, hasSingleOutputChangedSinceSnapshot, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
@@ -121,6 +123,7 @@ function persistSingleResultMetadata(input) {
   const target = input.result;
   writeMetadata(input.metadataPath, {
     runId: input.runId,
+    parentSessionId: input.parentSessionId,
     agent: input.agent,
     task: PROMPT_REDACTED,
     exitCode: target.exitCode,
@@ -148,9 +151,6 @@ function persistSingleResultMetadata(input) {
     timestamp: Date.now()
   });
 }
-function formatTimeoutMessage(timeoutMs) {
-  return `Subagent timed out after ${timeoutMs}ms.`;
-}
 function resolveAttemptTimeout(options) {
   if (options.timeoutMs === undefined)
     return;
@@ -158,7 +158,7 @@ function resolveAttemptTimeout(options) {
   return {
     timeoutMs: options.timeoutMs,
     remainingMs: Math.max(0, deadlineAt - Date.now()),
-    message: formatTimeoutMessage(options.timeoutMs)
+    message: `Subagent timed out after ${options.timeoutMs}ms.`
   };
 }
 function buildPendingAcceptanceLedger(acceptance) {
@@ -231,8 +231,7 @@ function snapshotResult(result, progress) {
   };
 }
 function snapshotStreamResult(result, progress) {
-  const snapshot = snapshotResult(result, progress);
-  snapshot.messages = undefined;
+  const snapshot = snapshotResult({ ...result, messages: undefined }, progress);
   snapshot.toolCalls = boundStreamedToolCalls(result);
   return snapshot;
 }
@@ -315,6 +314,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     mcpDirectTools: agent.mcpDirectTools,
     cwd: options.cwd ?? runtimeCwd,
     intercomSessionName: options.intercomSessionName,
+    projectTrusted: options.projectTrusted,
     sessionName: childSessionName,
     orchestratorIntercomTarget: options.orchestratorIntercomTarget,
     runId: options.runId,
@@ -323,6 +323,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     nestedRoute: options.nestedRoute,
     runFanoutBudget: options.runFanoutBudget,
     parentSessionId: options.parentSessionId,
+    parentSessionFile: options.parentSessionFile,
     forkCacheKey: options.context === "fork" ? deriveForkPromptCacheKey(options.parentSessionId) : undefined,
     structuredOutput: options.structuredOutput,
     fast: options.fast ?? agent.fast,
@@ -441,6 +442,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       delete progress.cacheWrite;
   };
   const attemptTimeout = resolveAttemptTimeout(options);
+  let timeoutCause;
   if (attemptTimeout?.remainingMs === 0) {
     result.exitCode = 1;
     result.timedOut = true;
@@ -480,6 +482,8 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     }
   }
   const childSessions = options.childSessionFactory ?? childSessionFactory();
+  const partialOutput = createPartialOutputTracker();
+  let childPromptFailed = false;
   const exitCode = await new Promise((resolve) => {
     const jsonlWriter = createJsonlWriter(shared.jsonlPath, { pause() {}, resume() {} });
     let session;
@@ -488,6 +492,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     let sessionSettled = false;
     let lifecycleFinished = false;
     let detached = false;
+    let hostStopReason;
     let intercomStarted = false;
     let assistantError;
     let removeAbortListener;
@@ -685,7 +690,17 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       unsubscribe?.();
       onWatchdogStatus = undefined;
       jsonlWriter.close().catch(() => {});
-      Promise.resolve().then(() => session?.dispose()).catch(() => {
+      Promise.resolve().then(async () => {
+        if (code === 0 && !result.interrupted && !result.timedOut && !result.stopped && !abortedBySignal) {
+          try {
+            await session?.finishCommands?.();
+          } catch (error) {
+            result.error = error instanceof Error ? error.message : String(error);
+            code = 1;
+          }
+        }
+        await session?.dispose();
+      }).catch(() => {
         return;
       }).then(() => {
         resolve(code);
@@ -751,7 +766,7 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       const key = typeof event.toolCallId === "string" && event.toolCallId.length > 0 ? `id:${event.toolCallId}` : typeof event.toolName === "string" ? activeToolKeysByName.get(event.toolName)?.[0] : activeToolCalls.size === 1 ? [...activeToolCalls.keys()][0] : undefined;
       return key ? removeActiveToolCallKey(key) : undefined;
     };
-    const openToolAttentionTarget = (now) => [...activeToolCalls.values()].filter((active) => shouldEmitOpenToolAttention({ config: controlConfig, currentTool: active.tool, currentToolStartedAt: active.startedAt, now })).sort((left, right) => left.startedAt - right.startedAt)[0];
+    const openToolAttentionTarget = (now) => [...activeToolCalls.values()].filter((active) => !active.attentionEmitted && shouldEmitOpenToolAttention({ config: controlConfig, currentTool: active.tool, currentToolStartedAt: active.startedAt, now })).sort((left, right) => left.startedAt - right.startedAt)[0];
     const mutatingFailures = createMutatingFailureState();
     const mutatingFailureWindowMs = 5 * 60000;
     const currentToolDurationMs = (now) => progress.currentToolStartedAt ? Math.max(0, now - progress.currentToolStartedAt) : undefined;
@@ -775,13 +790,14 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
         tokens: progress.tokens,
         toolCount: progress.toolCount,
         currentTool: input.currentTool ?? progress.currentTool,
+        toolCallId: input.toolCallId,
         currentToolDurationMs: input.currentToolDurationMs ?? currentToolDurationMs(now),
         currentPath: input.currentPath ?? progress.currentPath,
         recentFailureSummary: input.recentFailureSummary,
         taskPreview: task
       });
       emitControlEvent(event);
-      return previous !== "needs_attention";
+      return previous !== "needs_attention" || input.reason === "tool_open_threshold";
     };
     const emitActiveLongRunning = (now, reason) => {
       if (!controlConfig.enabled || activeLongRunningNotified || progress.activityState === "needs_attention")
@@ -825,13 +841,15 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       if (idleState === "needs_attention") {
         return progress.activityState === "needs_attention" ? false : emitNeedsAttention(now);
       }
-      const toolAttentionTarget = progress.activityState !== "needs_attention" ? openToolAttentionTarget(now) : undefined;
+      const toolAttentionTarget = openToolAttentionTarget(now);
       if (toolAttentionTarget) {
+        toolAttentionTarget.attentionEmitted = true;
         const durationMs = Math.max(0, now - toolAttentionTarget.startedAt);
         return emitNeedsAttention(now, {
           message: `${agent.name} has had tool '${toolAttentionTarget.tool}' open for ${Math.floor(durationMs / 1000)}s`,
           reason: "tool_open_threshold",
           currentTool: toolAttentionTarget.tool,
+          toolCallId: toolAttentionTarget.key.startsWith("id:") ? toolAttentionTarget.key.slice(3) : undefined,
           currentPath: toolAttentionTarget.path,
           currentToolDurationMs: durationMs
         });
@@ -876,11 +894,15 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     const processEvent = (evt) => {
       if (lifecycleFinished)
         return;
+      partialOutput.observe(evt);
       jsonlWriter.writeLine(JSON.stringify(projectChildSessionEventForJson(evt)));
       shared.transcriptWriter?.writeChildEvent(evt);
       shared.orcaProgressTab?.event(evt);
-      if (evt.type === "compaction_start")
+      if (evt.type === "compaction_start") {
         compactionStartedReceived = true;
+        if (agentSettledReceived)
+          afterCompactionSettlement = true;
+      }
       if (evt.type === "compaction_end" && evt.willRetry === true) {
         compactionStartedReceived = false;
         afterCompactionSettlement = false;
@@ -1004,11 +1026,12 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
           }
           projectCompleteUsage();
           if (evt.message.model) {
-            progress.model = evt.message.model;
+            const observedModel = qualifyModelWithProvider(evt.message.model, evt.message.provider, options.availableModels);
+            progress.model = observedModel;
             if (!result.model)
-              result.model = evt.message.model;
+              result.model = observedModel;
             if (expectedModelForVerification && !hasToolCall) {
-              const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels, options.modelResponseAliases);
+              const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels, options.modelResponseAliases, session?.virtualModelId);
               if (modelVerificationError && !result.error)
                 result.error = modelVerificationError;
             }
@@ -1099,9 +1122,10 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
     }
     if (attemptTimeout) {
       timeoutTimer = setTimeout(() => {
-        if (sessionSettled || lifecycleFinished || interruptedByControl)
+        if (sessionSettled || lifecycleFinished || interruptedByControl || result.timedOut)
           return;
         result.timedOut = true;
+        timeoutCause = attemptTimeout.message;
         clearAllToolTimeouts();
         result.error = attemptTimeout.message;
         result.finalOutput = attemptTimeout.message;
@@ -1149,9 +1173,11 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
       }
     };
     const terminateForToolTimeout = (message) => {
-      if (sessionSettled || lifecycleFinished || interruptedByControl)
+      if (sessionSettled || lifecycleFinished || interruptedByControl || result.timedOut)
         return;
+      clearTimeout(timeoutTimer);
       result.timedOut = true;
+      timeoutCause = message;
       result.error = message;
       result.finalOutput = message;
       progress.status = "failed";
@@ -1199,6 +1225,8 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
         result.nativeMachine = { provider: "herdr", machineId: session.machineEvidence.machineId, ...session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}, ...session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {} };
       let closeError = result.error ?? toolDiagnosticError ?? assistantError;
       const promptErrorMessage = promptError === undefined ? undefined : promptError instanceof Error ? promptError.message : String(promptError);
+      if (promptError !== undefined)
+        childPromptFailed = true;
       if (!closeError && promptErrorMessage !== undefined) {
         closeError = promptErrorMessage;
       }
@@ -1206,12 +1234,20 @@ ${shared.acceptancePrompt}` : shared.systemPrompt,
         closeError = `${promptErrorMessage}
 
 ${formatChildModelResolutionDiagnostic({ agent: agent.name, model: launch.session.model, host: "parent", capabilityCeiling: launch.toolPlan.capabilityCeiling })}`;
+      } else if (session?.inheritedProvider && closeError !== undefined && (closeError === promptErrorMessage || closeError === assistantError) && progress.toolCount === 0 && (result.messages ?? []).every((message) => message.role !== "assistant" || message.stopReason === "error")) {
+        closeError = `${closeError}
+
+${formatInheritedProviderDiagnostic({ agent: agent.name, model: launch.session.model, provider: session.inheritedProvider, capabilityCeiling: launch.toolPlan.capabilityCeiling })}`;
       }
       const forcedDrainAfterFinalSuccess = (forced || forcedTermination) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !closeError;
       const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(result.messages ?? []);
-      if (!closeError && (abortedBySignal || session?.shutDown) && !result.interrupted && !result.timedOut) {
-        closeError = session?.shutDown ? "Subagent stopped because the parent session shut down." : STOPPED_BEFORE_COMPLETION_ERROR;
+      if (!closeError && (abortedBySignal || session?.shutDown || hostStopReason) && !result.interrupted && !result.timedOut) {
+        closeError = hostStopReason ?? (session?.shutDown ? "Subagent stopped because the parent session shut down." : STOPPED_BEFORE_COMPLETION_ERROR);
       }
+      if (hostStopReason && !result.interrupted && !result.timedOut)
+        result.stopped = true;
+      if (options.abortedAsStopped && abortedBySignal && !session?.shutDown && !result.interrupted && !result.timedOut)
+        result.stopped = true;
       if (!closeError && forced && !forcedDrainAfterFinalSuccess) {
         closeError = "Subagent session did not settle after it was aborted.";
       }
@@ -1307,9 +1343,19 @@ ${formatChildModelResolutionDiagnostic({ agent: agent.name, model: launch.sessio
         if (abortedBySignal || interruptedByControl || result.timedOut) {
           abortChild();
         }
-        options.onChildSession?.({ steer: (text) => created.steer(text), followUp: (text) => created.followUp(text) });
+        options.onChildSession?.({
+          steer: (text) => created.steer(text),
+          followUp: (text) => created.followUp(text),
+          stop: (reason) => {
+            if (sessionSettled || lifecycleFinished)
+              return;
+            hostStopReason = reason;
+            abortChild();
+          }
+        });
         messageBaseline = created.messages.length;
-        await created.prompt(`Task: ${task}`);
+        if (!hostStopReason)
+          await created.prompt(`Task: ${task}`);
         settle(undefined);
       } catch (error) {
         settle(error ?? new Error("Child session failed."));
@@ -1392,13 +1438,34 @@ ${formatChildModelResolutionDiagnostic({ agent: agent.name, model: launch.sessio
   };
   const remoteGitChanged = result.nativeMachine?.initialGit && result.nativeMachine.finalGit ? result.nativeMachine.initialGit.head !== result.nativeMachine.finalGit.head || result.nativeMachine.initialGit.dirty !== result.nativeMachine.finalGit.dirty : undefined;
   const mutationEvidence = result.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {} } : collectTrackedMutationEvidence(mutationSnapshot, options.cwd ?? runtimeCwd);
+  const mutationGuardError = result.exitCode === 0 && !result.error && agent.completionGuard !== false ? implementationMutationError({
+    agent: agent.name,
+    task: shared.originalTask ?? task,
+    tools: agent.tools,
+    mcpDirectTools: agent.mcpDirectTools,
+    attempted: mutationEvidence.attemptedMutation === true || progress.recentTools.some((tool) => /(?:edit|write|bash|shell|exec|apply_patch)/i.test(tool.tool)),
+    unavailable: mutationEvidence.unavailable
+  }) : undefined;
+  if (mutationGuardError) {
+    result.exitCode = 1;
+    result.error = mutationGuardError;
+    progress.status = "failed";
+    progress.error = mutationGuardError;
+  }
   const acceptanceOutput = getFinalOutput(result.messages ?? []);
+  const structuredText = result.structuredOutput === undefined ? undefined : JSON.stringify(result.structuredOutput, null, 2);
   let fullOutput = stripAcceptanceReport(acceptanceOutput);
-  if (!fullOutput.trim() && result.structuredOutput !== undefined)
-    fullOutput = JSON.stringify(result.structuredOutput, null, 2);
+  if (!fullOutput.trim() && structuredText !== undefined)
+    fullOutput = structuredText;
+  const partialCause = result.timedOut ? "timeout" : childPromptFailed && !abortedBySignal && !result.interrupted && !result.stopped ? "child error" : undefined;
+  const streamedPartial = partialCause ? partialOutput.text() : undefined;
+  if (partialCause && streamedPartial) {
+    const text = stripAcceptanceReport(streamedPartial);
+    fullOutput = partialCause === "timeout" ? text : formatPartialOutput(text, partialCause);
+    result.outputPartial = true;
+  }
   result.outputState = fullOutput.trim() || result.structuredOutput !== undefined ? "present" : "absent";
-  if (result.timedOut) {
-    const timeoutMessage = formatTimeoutMessage(options.timeoutMs ?? 0);
+  if (timeoutCause) {
     let requiredOutputMissing;
     if (options.outputMode === "file-only" && options.outputPath) {
       const outputChanged = hasSingleOutputChangedSinceSnapshot(options.outputPath, shared.outputSnapshot);
@@ -1417,17 +1484,17 @@ ${formatChildModelResolutionDiagnostic({ agent: agent.name, model: launch.sessio
       transcriptPath: shared.transcriptWriter ? shared.artifactPaths?.transcriptPath : undefined,
       artifactPaths: shared.artifactPaths
     });
-    fullOutput = fullOutput.trim() ? `${timeoutMessage}
+    fullOutput = fullOutput.trim() ? `${timeoutCause}
 
 ${result.timeoutRecovery.message}
 
 Partial output before timeout:
-${fullOutput}` : `${timeoutMessage}
+${fullOutput}` : `${timeoutCause}
 
 ${result.timeoutRecovery.message}`;
   }
   if (options.outputPath && result.exitCode === 0) {
-    const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot, options.outputClaimPath);
+    const resolvedOutput = resolveSingleOutput(options.outputPath, structuredText ?? fullOutput, shared.outputSnapshot, options.outputClaimPath);
     fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
     result.savedOutputPath = resolvedOutput.savedPath;
     result.outputSaveError = resolvedOutput.saveError;
@@ -1525,6 +1592,17 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
       ...options.capabilityCeiling ? { capabilityCeiling: options.capabilityCeiling } : {}
     }, options.context));
   }
+  const toolContractError = implementationToolsError(agent.name, task, agent.tools, agent.mcpDirectTools);
+  if (toolContractError && agent.completionGuard !== false)
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
+      agent: agentName,
+      task,
+      exitCode: 1,
+      messages: [],
+      usage: emptyUsage(),
+      error: toolContractError
+    }, options.context));
   const acceptanceErrors = validateAcceptanceInput(options.acceptance);
   if (acceptanceErrors.length > 0) {
     return redactResultPrompt(withRunContext({
@@ -1602,7 +1680,7 @@ ${acceptancePrompt}` : task;
       error: "Skills not found: dm-subagents"
     }, options.context));
   }
-  const systemPrompt = buildEffectiveSystemPrompt({ agent, resolvedSkills, cwd: skillCwd, ...options.outputPath ? { outputPath: options.outputPath } : {} });
+  const systemPrompt = buildEffectiveSystemPrompt({ agent, resolvedSkills, cwd: skillCwd });
   const { model: selectedModel, requestedModel } = resolveModelSelection(options.modelOverride ?? agent.model, options.availableModels, agent.modelProvider ?? options.preferredModelProvider, {
     scope: options.modelScope,
     primaryModelFromParent: options.modelOverrideFromParent,
@@ -1667,6 +1745,7 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       metadataPath: artifactPathsResult?.metadataPath,
       enabled: options.artifactConfig?.enabled !== false && options.artifactConfig?.includeMetadata !== false,
       runId: options.runId,
+      parentSessionId: options.parentSessionId,
       agent: agentName,
       task,
       result: target
@@ -1695,6 +1774,7 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
   const verifyModel = Boolean(candidate) && !options.modelOverrideFromParent;
   let lastResult;
   let recoveryPrompt = task;
+  let recoveredCompaction = false;
   let stagedIndexBaseline;
   if (effectiveAcceptance.preserveStagedIndex) {
     try {
@@ -1711,7 +1791,7 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       }, options.context));
     }
   }
-  for (let attemptIndex = 0;attemptIndex < 2; attemptIndex++) {
+  for (let attemptIndex = 0;attemptIndex < 5; attemptIndex++) {
     const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
     const attemptResult = await runSingleAttempt(runtimeCwd, agent, recoveryPrompt, candidate, attemptOptions, {
       sessionEnabled,
@@ -1735,12 +1815,30 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
     totalDurationMs += attemptResult.progressSummary?.durationMs ?? 0;
     if (attemptResult.exitCode === 0 && !attemptResult.error)
       break;
+    const retryDelay = dmRetryDelay({
+      exitCode: attemptResult.exitCode,
+      error: attemptResult.error,
+      finalOutput: attemptResult.finalOutput,
+      messages: attemptResult.messages ?? [],
+      toolCount: attemptResult.progressSummary?.toolCount ?? 0,
+      durationMs: attemptResult.progressSummary?.durationMs ?? Number.POSITIVE_INFINITY,
+      usage: attemptResult.usage,
+      stopped: attemptResult.stopped,
+      timedOut: attemptResult.timedOut,
+      interrupted: attemptResult.interrupted,
+      observedMutationAttempt: attemptResult.outputPartial || attemptResult.toolBudgetBlocked
+    }, attemptIndex);
+    if (retryDelay !== undefined && !options.signal?.aborted && !options.interruptSignal?.aborted) {
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      if (!options.signal?.aborted && !options.interruptSignal?.aborted)
+        continue;
+    }
     const recovery = planAbortRecovery({
       messages: attemptResult.messages ?? [],
       error: attemptResult.error,
       processSignal: attemptResult.processSignal,
       sessionAvailable: Boolean(options.sessionFile && existsSync(options.sessionFile)),
-      alreadyResumed: attemptIndex > 0,
+      alreadyResumed: recoveredCompaction,
       stopped: attemptResult.stopped || attemptResult.detached || Boolean(detachedReason) || Boolean(options.workflowChildPermitLaunch) || options.signal?.aborted,
       interrupted: attemptResult.interrupted || options.interruptSignal?.aborted,
       timedOut: attemptResult.timedOut,
@@ -1752,6 +1850,7 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       afterCompactionSettlement: attemptResult[AFTER_COMPACTION_SETTLEMENT]
     });
     if (recovery.action === "resume") {
+      recoveredCompaction = true;
       recoveryPrompt = recovery.prompt;
       attemptNotes.push("[abort-recovery] compaction abort after useful progress; resuming the retained child session once on the same model.");
       continue;
@@ -2002,6 +2101,7 @@ export async function runSync(runtimeCwd, agents, agentName, task, options) {
         metadataPath: failedResult.artifactPaths?.metadataPath,
         enabled: options.artifactConfig?.enabled !== false && options.artifactConfig?.includeMetadata !== false,
         runId: options.runId,
+        parentSessionId: options.parentSessionId,
         agent: failedResult.agent,
         task: failedResult.task,
         result: failedResult

package/extensions/dm-subagents/src/runs/foreground/foreground-history.js

@@ -38,6 +38,7 @@ function compactChild(child) {
     ...child.error ? { error: child.error } : {},
     ...!outputPath && child.finalOutput ? { finalOutput: boundedTail(child.finalOutput) } : {},
     ...child.outputState ? { outputState: child.outputState } : {},
+    ...child.outputPartial ? { outputPartial: true } : {},
     ...child.outputMode ? { outputMode: child.outputMode } : {},
     ...child.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {},
     ...child.outputSaveError ? { outputSaveError: child.outputSaveError } : {},

package/extensions/dm-subagents/src/runs/foreground/prompt-audit.js

@@ -1,3 +1,4 @@
+import { streamSimple } from "@duckmind/dm-ai/compat";
 import { agentStreamOptions } from "../../shared/agent-stream-options.js";
 import { opencodeSessionHeaders } from "../../shared/opencode-session-headers.js";
 const livePrompts = new WeakMap;
@@ -34,14 +35,13 @@ export async function rewritePromptWithGuidance(input) {
   const model = input.ctx.model;
   if (!model)
     throw new Error("Prompt redo needs the current session model to rewrite the authored task.");
-  const [{ Agent }, { convertToLlm }, { streamSimple }] = await Promise.all([
+  const [{ Agent }, { convertToLlm }] = await Promise.all([
     import("@duckmind/dm-agent-core"),
-    import("@duckmind/dm-coding-agent"),
-    import("@duckmind/dm-ai/compat")
+    import("@duckmind/dm-coding-agent")
   ]);
   const auth = await resolveRewriteAuth(input.ctx, model);
-  const registeredProvider = input.ctx.modelRegistry.getRegisteredProviderConfig?.(model.provider);
-  const baseStreamFn = input.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === model.api ? registeredProvider.streamSimple : streamSimple);
+  const registryStream = input.ctx.modelRegistry.streamSimple;
+  const baseStreamFn = input.streamFn ?? (registryStream ? (nextModel, context, streamOptions) => registryStream.call(input.ctx.modelRegistry, nextModel, context, streamOptions) : (nextModel, context, streamOptions) => streamSimple(nextModel, context, streamOptions));
   const sessionId = input.ctx.sessionManager.getSessionId();
   const streamFn = (nextModel, context, streamOptions) => baseStreamFn(nextModel, context, {
     ...streamOptions,