@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-subagents/src/runs/background/scheduled-runs.js

@@ -9,6 +9,8 @@ import { validateExecutionAcceptance } from "../shared/acceptance.js";
 import { previewSimpleWorkflowRun } from "../../workflows/scripted-workflow.js";
 import { resolveGitRepositoryIdentity } from "../../workflows/chat-progress.js";
 import { getConfigDirName } from "../../shared/utils.js";
+import { normalizeWorktreeBaseRef } from "../shared/worktree.js";
+import { deepFreezeWorkflowArgs, normalizeWorkflowArgs } from "../../workflows/workflow-resources.js";
 export const SCHEDULED_RUN_ACTIONS = [
   "schedule.create",
   "schedule.list",
@@ -236,8 +238,18 @@ function parseScheduleTarget(value, file) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error(`Schedule record '${file}' has invalid trigger or target.`);
   const target = value;
-  if (typeof target.workflowScript === "string" && target.workflowScript.trim())
-    return { workflowScript: target.workflowScript.trim() };
+  if (typeof target.workflowScript === "string" && target.workflowScript.trim()) {
+    let baseRef;
+    try {
+      baseRef = normalizeWorktreeBaseRef(target.baseRef);
+    } catch (error) {
+      throw new Error(`Schedule record '${file}' has an invalid baseRef: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const normalizedArgs = normalizeWorkflowArgs(target.args);
+    if ("error" in normalizedArgs)
+      throw new Error(`Schedule record '${file}' has invalid args: ${normalizedArgs.error}`);
+    return { workflowScript: target.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...baseRef === undefined ? {} : { baseRef } };
+  }
   if (target.agent !== undefined || target.task !== undefined)
     throw new Error(`Schedule record '${file}' uses a removed legacy agent target; recreate it with target.workflowScript.`);
   throw new Error(`Schedule record '${file}' requires a workflowScript target.`);
@@ -261,6 +273,12 @@ function parseSchedule(value, file) {
       throw new Error(`Schedule record '${file}' has an invalid interval trigger.`);
   } else
     throw new Error(`Schedule record '${file}' has an unsupported trigger.`);
+  if (record.sessionOnly !== undefined && typeof record.sessionOnly !== "boolean")
+    throw new Error(`Schedule record '${file}' has invalid sessionOnly.`);
+  if (record.quiet !== undefined && typeof record.quiet !== "boolean")
+    throw new Error(`Schedule record '${file}' has invalid quiet.`);
+  if (record.sessionOnly === true && (typeof record.ownerSessionFile !== "string" || !record.ownerSessionFile.trim()))
+    throw new Error(`Schedule record '${file}' is session-only but has no owner session file.`);
   return { ...record, target: parseScheduleTarget(record.target, file) };
 }
 
@@ -357,12 +375,17 @@ function duePlannedAt(schedule, now) {
   return next + Math.floor((now - next) / schedule.trigger.everyMs) * schedule.trigger.everyMs;
 }
 function textResult(text, schedules, runs, isError = false) {
+  const publicSchedules = schedules?.map(publicScheduleRecord);
   return {
     content: [{ type: "text", text }],
     ...isError ? { isError: true } : {},
-    details: { mode: "management", results: [], schedules: { ...schedules ? { records: schedules } : {}, ...runs ? { runs } : {} } }
+    details: { mode: "management", results: [], schedules: { ...publicSchedules ? { records: publicSchedules } : {}, ...runs ? { runs } : {} } }
   };
 }
+function publicScheduleRecord(schedule) {
+  const { ownerSessionFile: _ownerSessionFile, ...rest } = schedule;
+  return rest;
+}
 function targetLabel(target) {
   const preview = previewSimpleWorkflowRun(target.workflowScript);
   return preview?.agent ? `workflowScript -> agent ${preview.agent}` : "workflowScript (dynamic)";
@@ -378,19 +401,28 @@ function sanitizeTarget(params) {
     return { error: "Scheduled runs require fresh context." };
   if (params.async === false)
     return { error: "Scheduled runs are always async." };
+  let baseRef;
+  try {
+    baseRef = normalizeWorktreeBaseRef(params.baseRef);
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
   const acceptanceErrors = validateExecutionAcceptance(params);
   if (acceptanceErrors.length)
     return { error: acceptanceErrors.join(" ") };
-  return { target: { workflowScript: params.workflowScript.trim() } };
+  const normalizedArgs = normalizeWorkflowArgs(params.args);
+  if ("error" in normalizedArgs)
+    return { error: normalizedArgs.error };
+  return { target: { workflowScript: params.workflowScript.trim(), args: deepFreezeWorkflowArgs(normalizedArgs.args), ...baseRef === undefined ? {} : { baseRef } } };
 }
-function executionParams(schedule) {
+function executionParams(schedule, quiet = false) {
   return {
     ...schedule.target,
     async: true,
     context: "fresh",
     cwd: schedule.cwd,
     mission: false,
-    scheduleOrigin: { id: schedule.id, ...schedule.name ? { name: schedule.name } : {} },
+    scheduleOrigin: { id: schedule.id, ...schedule.name ? { name: schedule.name } : {}, ...quiet ? { quiet: true } : {} },
     ...schedule.timeoutMs === undefined ? {} : { timeoutMs: schedule.timeoutMs }
   };
 }
@@ -410,6 +442,19 @@ function snapshotContext(ctx, cwd) {
   });
   return { ...ctx, cwd, sessionManager };
 }
+function normalizedSessionFile(value) {
+  if (!value || !value.trim())
+    return;
+  const normalized = path.normalize(path.resolve(value));
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function scheduleBelongsToSession(schedule, ctx) {
+  if (schedule.sessionOnly !== true)
+    return true;
+  const ownerSessionFile = normalizedSessionFile(schedule.ownerSessionFile);
+  const currentSessionFile = normalizedSessionFile(ctx.sessionManager.getSessionFile());
+  return ownerSessionFile !== undefined && ownerSessionFile === currentSessionFile;
+}
 export function listScheduledRunSummaries(cwd, root) {
   return new ScheduleStore(scheduledRunStorePath(cwd, undefined, root), root === undefined ? path.resolve(cwd) : undefined).list();
 }
@@ -534,6 +579,16 @@ export class ScheduledRunManager {
       return textResult("Mission attachment is deferred from this first schedule slice.", undefined, undefined, true);
     if (params.on !== undefined || params.timezone !== undefined || every === "day" || every === "week" || every === "month" || every === "year")
       return textResult("Calendar schedules are deferred from this first safe slice. Use a fixed interval such as every:'24h' or every:'7d'.", undefined, undefined, true);
+    if (params.quiet !== undefined && typeof params.quiet !== "boolean")
+      return textResult("quiet must be a boolean.", undefined, undefined, true);
+    if (at && params.quiet === true)
+      return textResult("quiet is only supported for recurring schedules.", undefined, undefined, true);
+    const sessionOnly = params.sessionOnly === true;
+    if (sessionOnly && params.cwd !== undefined && !samePath(params.cwd, ctx.cwd))
+      return textResult("sessionOnly schedules cannot use an explicit cross-project cwd.", undefined, undefined, true);
+    const ownerSessionFile = sessionOnly ? ctx.sessionManager.getSessionFile() : undefined;
+    if (sessionOnly && !ownerSessionFile)
+      return textResult("sessionOnly schedules require a persisted current session.", undefined, undefined, true);
     const sessionId = ctx.sessionManager.getSessionId() ?? "unknown";
     if (this.deps.resolveCapabilityCeiling?.(sessionId))
       return textResult("Cannot persist a schedule while a capability ceiling is active.", undefined, undefined, true);
@@ -564,6 +619,8 @@ export class ScheduledRunManager {
       catchUp: params.catchUp ?? "latest",
       ...params.timeoutMs === undefined ? {} : { timeoutMs: params.timeoutMs },
       paused: false,
+      ...sessionOnly ? { sessionOnly: true, ownerSessionFile: path.resolve(ownerSessionFile) } : {},
+      ...trigger.kind === "interval" && params.quiet === true ? { quiet: true } : {},
       createdAt: timestamp(now),
       updatedAt: timestamp(now)
     };
@@ -573,6 +630,8 @@ export class ScheduledRunManager {
     return textResult(`Created schedule ${id}.
 Name: ${schedule.name}
 Trigger: ${at ? `at ${at}` : `every ${every}`}
+Session only: ${schedule.sessionOnly === true ? "yes" : "no"}
+Quiet: ${schedule.quiet === true ? "yes" : "no"}
 Next: ${schedule.trigger.nextRunAt}
 Target: ${targetLabel(schedule.target)}`, [schedule]);
   }
@@ -580,12 +639,12 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
     const schedules = this.requireStore().list().sort((a, b) => (a.trigger.nextRunAt ?? "").localeCompare(b.trigger.nextRunAt ?? ""));
     if (!schedules.length)
       return textResult("No project schedules.", []);
-    return textResult([`Project schedules: ${schedules.length}`, ...schedules.map((item) => `- ${item.id} | ${item.paused ? "paused" : item.activeRunId ? "running" : "scheduled"} | ${item.trigger.nextRunAt ?? "no next run"} | ${item.name}`)].join(`
+    return textResult([`Project schedules: ${schedules.length}`, ...schedules.map((item) => `- ${item.id} | ${item.paused ? "paused" : item.activeRunId ? "running" : "scheduled"} | ${item.trigger.nextRunAt ?? "no next run"} | ${item.sessionOnly === true ? "session-only" : "project"} | ${item.name}`)].join(`
 `), schedules);
   }
   show(params) {
     const schedule = this.resolve(params);
-    return textResult([`Schedule: ${schedule.id}`, `Name: ${schedule.name}`, `State: ${schedule.paused ? "paused" : schedule.activeRunId ? "running" : "scheduled"}`, `Target: ${targetLabel(schedule.target)}`, `CWD: ${shortenPath(schedule.cwd)}`, `Next: ${schedule.trigger.nextRunAt ?? "none"}`, `Catch up: ${schedule.catchUp}`, schedule.activeRunId ? `Active run: ${schedule.activeRunId}` : undefined].filter(Boolean).join(`
+    return textResult([`Schedule: ${schedule.id}`, `Name: ${schedule.name}`, `State: ${schedule.paused ? "paused" : schedule.activeRunId ? "running" : "scheduled"}`, `Session only: ${schedule.sessionOnly === true ? "yes" : "no"}`, `Quiet: ${schedule.quiet === true ? "yes" : "no"}`, `Target: ${targetLabel(schedule.target)}`, `CWD: ${shortenPath(schedule.cwd)}`, `Next: ${schedule.trigger.nextRunAt ?? "none"}`, `Catch up: ${schedule.catchUp}`, schedule.activeRunId ? `Active run: ${schedule.activeRunId}` : undefined].filter(Boolean).join(`
 `), [schedule]);
   }
   history(params) {
@@ -612,12 +671,31 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
   async runManual(params) {
     const store = this.requireStore();
     const schedule = this.resolve(params);
-    const run = await this.launch(store, schedule, this.now(), "manual", false);
+    const context = this.requireContext(store);
+    if (!scheduleBelongsToSession(schedule, context)) {
+      return textResult(`Skipped schedule ${schedule.id}: current session is not its owner.`, [schedule]);
+    }
+    if (params.quiet !== undefined && typeof params.quiet !== "boolean")
+      return textResult("quiet must be a boolean.", undefined, undefined, true);
+    const run = await this.launch(store, schedule, this.now(), "manual", false, params.quiet === true);
+    const updated = store.get(schedule.id);
+    if (run.state === "running") {
+      const now = this.now();
+      if (updated.trigger.kind === "interval")
+        updated.trigger.nextRunAt = timestamp(now + updated.trigger.everyMs);
+      else
+        updated.trigger.nextRunAt = undefined;
+      updated.updatedAt = timestamp(now);
+      store.write(updated);
+      store.appendEvent(updated, "schedule.manual_satisfied");
+      this.arm(updated, store);
+    }
     return textResult(`Manual schedule run ${run.id}: ${run.state}${run.asyncId ? ` (async ${run.asyncId})` : ""}.`, [store.get(schedule.id)], [run], run.state === "failed_launch");
   }
   async runDue() {
     const store = this.requireStore();
-    const due = store.list().filter((schedule) => !schedule.paused && nextRunAt(schedule) !== undefined && nextRunAt(schedule) <= this.now());
+    const context = this.requireContext(store);
+    const due = store.list().filter((schedule) => scheduleBelongsToSession(schedule, context) && !schedule.paused && nextRunAt(schedule) !== undefined && nextRunAt(schedule) <= this.now());
     const runs = [];
     for (const schedule of due) {
       const planned = duePlannedAt(schedule, this.now());
@@ -630,9 +708,17 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
   }
   remove(params) {
     const schedule = this.resolve(params);
-    if (schedule.activeRunId)
-      return textResult(`Schedule ${schedule.id} has active run ${schedule.activeRunId}; stop that run before deleting the schedule.`, [schedule], undefined, true);
     const store = this.requireStore();
+    if (schedule.activeRunId) {
+      const run = store.history(schedule.id).find((item) => item.id === schedule.activeRunId);
+      let terminal = false;
+      if (run?.scheduleId === schedule.id && run.state === "running" && run.asyncId && run.asyncDir) {
+        const status = readJson(path.join(run.asyncDir, "status.json"), "async status");
+        terminal = status.runId === run.asyncId && typeof status.state === "string" && ["complete", "failed", "stopped", "rejected"].includes(status.state);
+      }
+      if (!terminal)
+        return textResult(`Schedule ${schedule.id} has active run ${schedule.activeRunId}; stop that run before deleting the schedule.`, [schedule], undefined, true);
+    }
     this.clearTimer(store, schedule.id);
     store.appendEvent(schedule, "schedule.deleted");
     store.delete(schedule.id);
@@ -643,6 +729,8 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       this.restoreOne(store, schedule);
   }
   restoreOne(store, schedule, notBefore, rearm = true) {
+    if (!scheduleBelongsToSession(schedule, this.requireContext(store)))
+      return;
     if (schedule.activeRunId) {
       const run = store.history(schedule.id).find((item) => item.id === schedule.activeRunId);
       if (run?.state === "running" && run.asyncId)
@@ -721,6 +809,8 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
     const schedule = store.find(id);
     if (!schedule)
       return;
+    if (!scheduleBelongsToSession(schedule, this.requireContext(store)))
+      return;
     const planned = duePlannedAt(schedule, this.now());
     if (planned === undefined || schedule.paused)
       return;
@@ -728,8 +818,9 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       return this.arm(schedule, store);
     await this.launch(store, schedule, planned, "timer", true);
   }
-  async launch(store, schedule, planned, dueReason, advance) {
+  async launch(store, schedule, planned, dueReason, advance, quiet) {
     const now = this.now();
+    const nextRunAtBeforeClaim = schedule.trigger.nextRunAt;
     const run = { schemaVersion: 1, id: this.randomId(), scheduleId: schedule.id, plannedAt: timestamp(planned), dueReason, state: "running", startedAt: timestamp(now) };
     if (schedule.activeRunId) {
       run.state = "skipped";
@@ -772,7 +863,7 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
     store.write(schedule);
     store.writeRun(schedule, run, "schedule.run.started");
     try {
-      const result = await this.deps.launch(executionParams(schedule), this.requireContext(store), new AbortController().signal);
+      const result = await this.deps.launch(executionParams(schedule, dueReason === "manual" ? quiet === true : schedule.quiet === true), this.requireContext(store), new AbortController().signal);
       const asyncId = result.details?.asyncId ?? result.details?.runId;
       if (result.isError || !asyncId)
         throw new Error(result.content.find((item) => item.type === "text")?.text ?? "Scheduled launch failed.");
@@ -786,12 +877,15 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       run.state = "failed_launch";
       run.completedAt = timestamp(this.now());
       run.error = error instanceof Error ? error.message : String(error);
-      schedule.activeRunId = undefined;
-      schedule.updatedAt = timestamp(this.now());
-      store.write(schedule);
-      store.writeRun(schedule, run, "schedule.run.failed");
+      const latest = store.get(schedule.id);
+      latest.activeRunId = undefined;
+      if (!advance && nextRunAtBeforeClaim)
+        latest.trigger.nextRunAt = nextRunAtBeforeClaim;
+      latest.updatedAt = timestamp(this.now());
+      store.write(latest);
+      store.writeRun(latest, run, "schedule.run.failed");
       fs.rmSync(lockPath, { force: true });
-      this.arm(schedule, store);
+      this.arm(latest, store);
       return run;
     }
   }
@@ -844,7 +938,10 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
   selectProject(cwd, ctx) {
     const projectCwd = path.resolve(cwd);
     const root = scheduledRunStorePath(projectCwd, undefined, this.deps.storeRoot);
-    if (path.resolve(ctx.cwd) === projectCwd)
+    const isBoundContext = path.resolve(ctx.cwd) === projectCwd;
+    const previousContext = this.contexts.get(root);
+    const contextChanged = isBoundContext && previousContext !== undefined && normalizedSessionFile(previousContext.sessionManager.getSessionFile()) !== normalizedSessionFile(ctx.sessionManager.getSessionFile());
+    if (isBoundContext)
       this.contexts.set(root, snapshotContext(ctx, projectCwd));
     else if (!this.contexts.has(root))
       throw new Error(`Cannot use project '${projectCwd}' until that project has been opened in this runtime.`);
@@ -853,6 +950,8 @@ Target: ${targetLabel(schedule.target)}`, [schedule]);
       store = new ScheduleStore(root, this.deps.storeRoot === undefined ? projectCwd : undefined);
       this.stores.set(root, store);
       this.restore(store);
+    } else if (contextChanged) {
+      this.restore(store);
     }
     this.store = store;
   }

package/extensions/dm-subagents/src/runs/background/stale-run-reconciler.js

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { resultFilePath, resultPayloadPathForSessionRun, writeAsyncResultFile } from "./result-files.js";
 import { updateActiveRunIndex } from "./active-run-index.js";
+import { readProcessTerminal } from "./process-terminal.js";
 import { readStatus } from "../../shared/utils.js";
 import { DIRS } from "../../shared/types.js";
 import { resolveEffectiveThinking } from "../../shared/model-info.js";
@@ -62,6 +63,8 @@ function regularFileExists(filePath) {
 function readResultRepairData(resultPath) {
   try {
     const data = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+    if (data.error !== undefined && typeof data.error !== "string")
+      throw new Error(`Invalid async result file '${resultPath}': error must be a string.`);
     const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "partial" ? "partial" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
     const results = Array.isArray(data.results) ? data.results.map((entry, index) => {
       if (!entry || typeof entry !== "object" || Array.isArray(entry))
@@ -73,7 +76,7 @@ function readResultRepairData(resultPath) {
         throw new Error(`Invalid async result file '${resultPath}': results[${index}].thinking must be a string.`);
       return child;
     }) : undefined;
-    return { state, ...results ? { results } : {} };
+    return { state, ...data.error ? { error: data.error } : {}, ...results ? { results } : {} };
   } catch (error) {
     if (isNotFoundError(error))
       return;
@@ -89,10 +92,14 @@ function childState(overallState, child) {
     return "failed";
   return overallState;
 }
+function failureDiagnostic(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
 function terminalStatusFromResult(status, resultPath, now) {
   const repair = readResultRepairData(resultPath);
   if (!repair)
     return;
+  const rootError = failureDiagnostic(status.error) ?? failureDiagnostic(repair.error) ?? repair.results?.map((child) => child.success === false ? failureDiagnostic(child.error) : undefined).find(Boolean);
   const steps = (status.steps ?? []).map((step, index) => {
     if (step.status !== "running" && step.status !== "pending")
       return step;
@@ -112,14 +119,14 @@ function terminalStatusFromResult(status, resultPath, now) {
       sessionFile: step.sessionFile ?? child?.sessionFile,
       model,
       thinking,
-      attemptedModels: child?.attemptedModels ?? step.attemptedModels,
-      modelAttempts: child?.modelAttempts ?? step.modelAttempts,
+      requestedModel: child?.requestedModel ?? step.requestedModel,
       contextOverflow: child?.contextOverflow ?? step.contextOverflow
     };
   });
   const terminalStatus = {
     ...status,
     state: repair.state,
+    ...rootError && (repair.state === "failed" || repair.state === "partial") ? { error: rootError } : {},
     ...status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
       processTerminal: { version: 1, state: "unknown", runId: status.runId, runnerProcessInstanceId: "observer-unavailable", reason: "observer-unavailable" }
     } : {},
@@ -160,7 +167,10 @@ function buildStartedStatus(asyncDir, startedRun, now) {
 function buildFailedRepair(status, asyncDir, now, reason) {
   const runId = status.runId || path.basename(asyncDir);
   const pid = typeof status.pid === "number" ? status.pid : "unknown";
-  const baseMessage = reason ?? `Async runner process ${pid} exited or disappeared before writing a result. Marked run failed by stale-run reconciliation.`;
+  const terminal = readProcessTerminal(asyncDir, { runId }) ?? status.processTerminal;
+  const runnerExit = terminal?.state === "observed" || terminal?.state === "unknown" ? terminal.instances?.find((instance) => instance.kind === "runner" && instance.processInstanceId === terminal.runnerProcessInstanceId) : undefined;
+  const exitText = runnerExit?.kind === "runner" ? `exited with code ${runnerExit.exitCode ?? "none"}${runnerExit.signal ? ` (signal ${runnerExit.signal})` : ""}` : "exited or disappeared";
+  const baseMessage = reason ?? `Async runner process ${pid} ${exitText} before writing a result. Marked run failed by stale-run reconciliation.`;
   const diagnostics = readRunnerStartupDiagnostics(asyncDir);
   const message = diagnostics ? `${baseMessage}
 
@@ -206,8 +216,7 @@ ${diagnostics}` : baseMessage;
         error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
         success: step.status === "complete" || step.status === "completed",
         model: step.model,
-        attemptedModels: step.attemptedModels,
-        modelAttempts: step.modelAttempts,
+        requestedModel: step.requestedModel,
         contextOverflow: step.contextOverflow,
         sessionFile: step.sessionFile
       })),
@@ -294,9 +303,10 @@ export function checkPidLiveness(pid, kill = process.kill) {
     return "unknown";
   }
 }
-export function reconcileAsyncRun(asyncDir, options = {}) {
+export function reconcileAsyncRun(asyncDir, options = {}, observeStatus) {
   const now = options.now?.() ?? Date.now();
   const status = readStatus(asyncDir);
+  observeStatus?.(status);
   const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
   const effectiveStatus = status ?? startedStatus;
   if (!effectiveStatus)
@@ -317,9 +327,22 @@ export function reconcileAsyncRun(asyncDir, options = {}) {
   if (existingResultPath) {
     const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued" ? terminalStatusFromResult(effectiveStatus, existingResultPath, now) : undefined;
     if (terminalStatus) {
-      writeAtomicJson(path.join(asyncDir, "status.json"), terminalStatus);
-      updateActiveRunIndex(asyncDir, terminalStatus.state, terminalStatus.toolCallId);
-      return { status: terminalStatus, repaired: true, resultPath: existingResultPath, message: "Existing async result file was used to repair stale running status." };
+      const currentStatus = readStatus(asyncDir);
+      const currentRootError = failureDiagnostic(currentStatus?.error);
+      const currentTerminal = currentStatus?.processTerminal?.state === "observed" || currentStatus?.processTerminal?.state === "unknown" ? currentStatus.processTerminal : undefined;
+      const steps = terminalStatus.steps?.map((step, index) => {
+        const currentStepTerminal = currentStatus?.steps?.[index]?.processTerminal;
+        return currentStepTerminal?.state === "observed" || currentStepTerminal?.state === "unknown" ? { ...step, processTerminal: currentStepTerminal } : step;
+      });
+      const statusToWrite = {
+        ...terminalStatus,
+        ...currentRootError ? { error: currentRootError } : {},
+        ...currentTerminal ? { processTerminal: currentTerminal } : {},
+        ...steps ? { steps } : {}
+      };
+      writeAtomicJson(statusPath, statusToWrite);
+      updateActiveRunIndex(asyncDir, statusToWrite.state, statusToWrite.toolCallId);
+      return { status: statusToWrite, repaired: true, resultPath: existingResultPath, message: "Existing async result file was used to repair stale running status." };
     }
     if (effectiveStatus.displayDismissedAt === undefined)
       return { status: effectiveStatus, repaired: false, resultPath: existingResultPath };

package/extensions/dm-subagents/src/runs/background/steering.js

@@ -9,8 +9,26 @@ export const STEERING_MESSAGE_PREVIEW_LIMIT = 160;
 export function steeringMessagePreview(message) {
   return previewDisplayText(redactSecretValues(message), STEERING_MESSAGE_PREVIEW_LIMIT);
 }
+export function takeMatchingAcceptedSteer(accepted, messageText) {
+  const index = accepted.findIndex((entry) => entry.text === messageText);
+  if (index < 0)
+    return;
+  const [entry] = accepted.splice(index, 1);
+  return entry;
+}
+export function unconsumedSteerReason(mode) {
+  return mode === "follow_up" ? "child completed before consuming follow-up" : "child completed before consuming steering";
+}
 export function steeringReceipt(message, receipt) {
-  return `${receipt} Message: ${JSON.stringify(steeringMessagePreview(message))}`;
+  const preview = steeringMessagePreview(message);
+  const longestFence = Math.max(2, ...[...preview.matchAll(/`{3,}/g)].map((match) => match[0].length));
+  const fence = "`".repeat(longestFence + 1);
+  return `${receipt}
+
+Message sent:
+${fence}text
+${preview}
+${fence}`;
 }
 export function createSteeringStatus() {
   return { requested: 0, scheduled: 0, pending: 0, delivered: 0, failed: 0, recovered: 0, recent: [] };
@@ -76,7 +94,9 @@ export function updateSteeringTarget(status, requestId, index, state, now, field
       target.replacementRunId = fields.replacementRunId;
     return target;
   }
-  if ((target.state === "routed" || target.state === "queued") && state !== "routed" && state !== "queued")
+  const wasPending = target.state === "routed" || target.state === "queued";
+  const nowPending = state === "routed" || state === "queued";
+  if (wasPending && !nowPending)
     status.pending = Math.max(0, status.pending - 1);
   target.state = state;
   if (state === "routed")
@@ -97,7 +117,8 @@ export function updateSteeringTarget(status, requestId, index, state, now, field
     target.reason = fields.reason;
   if (fields.replacementRunId)
     target.replacementRunId = fields.replacementRunId;
-  incrementStateCount(status, state);
+  if (!wasPending || !nowPending)
+    incrementStateCount(status, state);
   return target;
 }
 export function findSteeringRequest(status, requestId) {