@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -1,9 +1,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { RESULTS_DIR } from "../../shared/types.js";
+import { resultFilePath, resultPayloadPathForSessionRun, writeAsyncResultFile } from "./result-files.js";
+import { updateActiveRunIndex } from "./active-run-index.js";
+import { readStatus } from "../../shared/utils.js";
+import { DIRS } from "../../shared/types.js";
+import { resolveEffectiveThinking } from "../../shared/model-info.js";
 import { normalizeParallelGroups } from "./parallel-groups.js";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent } from "../shared/nested-events.js";
+import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.js";
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -45,31 +50,30 @@ function appendJsonlBestEffort(filePath, payload) {
 `, "utf-8");
   } catch {}
 }
-function readStatusFile(asyncDir) {
-  const statusPath = path.join(asyncDir, "status.json");
-  let content;
+function regularFileExists(filePath) {
   try {
-    content = fs.readFileSync(statusPath, "utf-8");
+    return fs.statSync(filePath).isFile();
   } catch (error) {
     if (isNotFoundError(error))
-      return null;
-    throw new Error(`Failed to read async status file '${statusPath}': ${getErrorMessage(error)}`, {
-      cause: error instanceof Error ? error : undefined
-    });
-  }
-  try {
-    return JSON.parse(content);
-  } catch (error) {
-    throw new Error(`Failed to parse async status file '${statusPath}': ${getErrorMessage(error)}`, {
-      cause: error instanceof Error ? error : undefined
-    });
+      return false;
+    throw error;
   }
 }
 function readResultRepairData(resultPath) {
   try {
     const data = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
-    const state = data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
-    return { state, ...Array.isArray(data.results) ? { results: data.results } : {} };
+    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))
+        return {};
+      const child = entry;
+      if (child.model !== undefined && typeof child.model !== "string")
+        throw new Error(`Invalid async result file '${resultPath}': results[${index}].model must be a string.`);
+      if (child.thinking !== undefined && typeof child.thinking !== "string")
+        throw new Error(`Invalid async result file '${resultPath}': results[${index}].thinking must be a string.`);
+      return child;
+    }) : undefined;
+    return { state, ...results ? { results } : {} };
   } catch (error) {
     if (isNotFoundError(error))
       return;
@@ -94,27 +98,39 @@ function terminalStatusFromResult(status, resultPath, now) {
       return step;
     const child = repair.results?.[index];
     const state = childState(repair.state, child);
+    const model = child?.model ?? step.model;
+    const thinking = resolveEffectiveThinking(model, child?.thinking ?? step.thinking);
     return {
       ...step,
       status: state === "complete" ? "complete" : state,
       endedAt: step.endedAt ?? now,
       durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
       exitCode: step.exitCode ?? (state === "complete" || state === "paused" ? 0 : 1),
-      error: state === "failed" ? step.error ?? child?.error : step.error,
+      error: state === "failed" || state === "partial" || state === "stopped" ? step.error ?? child?.error : step.error,
+      stopped: state === "stopped" ? true : step.stopped,
+      sessionName: step.sessionName ?? child?.sessionName,
       sessionFile: step.sessionFile ?? child?.sessionFile,
-      model: step.model ?? child?.model,
-      attemptedModels: step.attemptedModels ?? child?.attemptedModels,
-      modelAttempts: step.modelAttempts ?? child?.modelAttempts
+      model,
+      thinking,
+      attemptedModels: child?.attemptedModels ?? step.attemptedModels,
+      modelAttempts: child?.modelAttempts ?? step.modelAttempts,
+      contextOverflow: child?.contextOverflow ?? step.contextOverflow
     };
   });
-  return {
+  const terminalStatus = {
     ...status,
     state: repair.state,
+    ...status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
+      processTerminal: { version: 1, state: "unknown", runId: status.runId, runnerProcessInstanceId: "observer-unavailable", reason: "observer-unavailable" }
+    } : {},
+    ...repair.state === "stopped" ? { stopped: true } : {},
     activityState: undefined,
     lastUpdate: now,
     endedAt: status.endedAt ?? now,
     steps
   };
+  delete terminalStatus.displayDismissedAt;
+  return terminalStatus;
 }
 function buildStartedStatus(asyncDir, startedRun, now) {
   const startedAt = startedRun.startedAt ?? now;
@@ -124,6 +140,7 @@ function buildStartedStatus(asyncDir, startedRun, now) {
   return {
     runId: startedRun.runId || path.basename(asyncDir),
     ...startedRun.sessionId ? { sessionId: startedRun.sessionId } : {},
+    ...startedRun.completionOwnerId ? { completionOwnerId: startedRun.completionOwnerId } : {},
     mode: startedRun.mode ?? "single",
     state: "running",
     pid: startedRun.pid,
@@ -162,6 +179,9 @@ ${diagnostics}` : baseMessage;
   const repairedStatus = {
     ...status,
     state: "failed",
+    ...status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
+      processTerminal: { version: 1, state: "unknown", runId, runnerProcessInstanceId: "observer-unavailable", reason: "stale-repair" }
+    } : {},
     activityState: undefined,
     lastUpdate: now,
     endedAt: now,
@@ -175,17 +195,20 @@ ${diagnostics}` : baseMessage;
       id: runId,
       agent: resultAgent,
       mode: status.mode,
+      ...status.completionOwnerId ? { completionOwnerId: status.completionOwnerId } : {},
       success: false,
       state: "failed",
       summary: message,
       results: repairedSteps.map((step) => ({
         agent: step.agent,
+        ...step.sessionName ? { sessionName: step.sessionName } : {},
         output: step.status === "complete" || step.status === "completed" ? "" : message,
         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,
+        contextOverflow: step.contextOverflow,
         sessionFile: step.sessionFile
       })),
       exitCode: 1,
@@ -199,20 +222,22 @@ ${diagnostics}` : baseMessage;
 }
 function writeFailedRepair(asyncDir, status, resultPath, now, reason) {
   const repair = buildFailedRepair(status, asyncDir, now, reason);
-  writeAtomicJson(resultPath, repair.result);
+  if (repair.result.sessionId)
+    writeAsyncResultFile(resultPath, repair.result);
   writeAtomicJson(path.join(asyncDir, "status.json"), repair.status);
+  updateActiveRunIndex(asyncDir, repair.status.state, repair.status.toolCallId);
   appendJsonlBestEffort(path.join(asyncDir, "events.jsonl"), {
     type: "subagent.run.repaired_stale",
     ts: now,
     runId: repair.status.runId,
     pid: status.pid,
-    resultPath,
+    ...repair.result.sessionId ? { resultPath } : {},
     message: repair.message
   });
-  return { status: repair.status, repaired: true, resultPath, message: repair.message };
+  return { status: repair.status, repaired: true, ...repair.result.sessionId ? { resultPath } : {}, message: repair.message };
 }
 function terminal(state) {
-  return state === "complete" || state === "failed" || state === "paused";
+  return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped" || state === "rejected";
 }
 function* nestedRuns(children) {
   for (const child of children ?? []) {
@@ -231,7 +256,7 @@ export function reconcileNestedAsyncDescendants(route, options = {}) {
       continue;
     const result = reconcileAsyncRun(asyncDir, {
       ...options,
-      resultsDir: path.join(options.resultsDir ?? RESULTS_DIR, "nested", route.rootRunId)
+      resultsDir: path.join(options.resultsDir ?? DIRS.results, "nested", route.rootRunId)
     });
     const status = result.status;
     if (!status)
@@ -271,20 +296,36 @@ export function checkPidLiveness(pid, kill = process.kill) {
 }
 export function reconcileAsyncRun(asyncDir, options = {}) {
   const now = options.now?.() ?? Date.now();
-  const status = readStatusFile(asyncDir);
+  const status = readStatus(asyncDir);
   const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
   const effectiveStatus = status ?? startedStatus;
   if (!effectiveStatus)
     return { status: null, repaired: false };
+  assertWorkflowGraphHostSteps(effectiveStatus.workflowGraph, path.join(asyncDir, "status.json"), effectiveStatus.runId);
+  const statusPath = path.join(asyncDir, "status.json");
+  for (const [index, step] of (effectiveStatus.steps ?? []).entries()) {
+    const stepRecord = step;
+    if (stepRecord.model !== undefined && typeof stepRecord.model !== "string")
+      throw new Error(`Invalid async status file '${statusPath}': steps[${index}].model must be a string.`);
+    if (stepRecord.thinking !== undefined && typeof stepRecord.thinking !== "string")
+      throw new Error(`Invalid async status file '${statusPath}': steps[${index}].thinking must be a string.`);
+  }
   const runId = effectiveStatus.runId || path.basename(asyncDir);
-  const resultPath = path.join(options.resultsDir ?? RESULTS_DIR, `${runId}.json`);
-  if (fs.existsSync(resultPath)) {
-    const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued" ? terminalStatusFromResult(effectiveStatus, resultPath, now) : undefined;
+  const resultsDir = options.resultsDir ?? DIRS.results;
+  const resultPath = resultFilePath(resultsDir, runId);
+  const existingResultPath = effectiveStatus.sessionId ? resultPayloadPathForSessionRun(resultsDir, effectiveStatus.sessionId, runId) ?? (regularFileExists(resultPath) ? resultPath : undefined) : regularFileExists(resultPath) ? resultPath : undefined;
+  if (existingResultPath) {
+    const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued" ? terminalStatusFromResult(effectiveStatus, existingResultPath, now) : undefined;
     if (terminalStatus) {
       writeAtomicJson(path.join(asyncDir, "status.json"), terminalStatus);
-      return { status: terminalStatus, repaired: true, resultPath, message: "Existing async result file was used to repair stale running status." };
+      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." };
     }
-    return { status: effectiveStatus, repaired: false, resultPath };
+    if (effectiveStatus.displayDismissedAt === undefined)
+      return { status: effectiveStatus, repaired: false, resultPath: existingResultPath };
+  }
+  if (effectiveStatus.displayDismissedAt !== undefined) {
+    return { status: null, repaired: false, resultPath };
   }
   if (effectiveStatus.state !== "running" || typeof effectiveStatus.pid !== "number") {
     return { status: status ?? null, repaired: false, resultPath };

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

@@ -0,0 +1,221 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { readStatus } from "../../shared/utils.js";
+import { previewDisplayText } from "../../shared/display-text.js";
+import { redactSecretValues } from "../shared/permissions.js";
+export const MAX_STEERING_REQUESTS = 20;
+export const STEERING_MESSAGE_PREVIEW_LIMIT = 160;
+export function steeringMessagePreview(message) {
+  return previewDisplayText(redactSecretValues(message), STEERING_MESSAGE_PREVIEW_LIMIT);
+}
+export function steeringReceipt(message, receipt) {
+  return `${receipt} Message: ${JSON.stringify(steeringMessagePreview(message))}`;
+}
+export function createSteeringStatus() {
+  return { requested: 0, scheduled: 0, pending: 0, delivered: 0, failed: 0, recovered: 0, recent: [] };
+}
+export function steeringStatus(status) {
+  return status.steering ?? createSteeringStatus();
+}
+export function recordSteeringRequest(status, input) {
+  const existing = status.recent.find((request) => request.id === input.id);
+  if (existing)
+    return existing;
+  const request = {
+    id: input.id,
+    requestedAt: input.requestedAt,
+    ...input.source ? { source: input.source } : {},
+    messagePreview: steeringMessagePreview(input.message),
+    targets: input.targets.map((target) => ({ index: target.index, state: target.state, ...target.reason ? { reason: target.reason } : {} }))
+  };
+  status.requested++;
+  status.lastRequestedAt = input.requestedAt;
+  status.recent = [...status.recent, request].slice(-MAX_STEERING_REQUESTS);
+  for (const target of request.targets)
+    incrementStateCount(status, target.state);
+  return request;
+}
+function incrementStateCount(status, state) {
+  if (state === "scheduled")
+    status.scheduled++;
+  else if (state === "routed" || state === "queued")
+    status.pending++;
+  else if (state === "delivered" || state === "late")
+    status.delivered++;
+  else if (state === "failed")
+    status.failed++;
+  else if (state === "recovered")
+    status.recovered++;
+}
+export function updateSteeringTarget(status, requestId, index, state, now, fields = {}) {
+  const request = status.recent.find((candidate) => candidate.id === requestId);
+  const target = request?.targets.find((candidate) => candidate.index === index);
+  if (!target)
+    return;
+  if (state === "late" && target.state === "recovered") {
+    if (target.lateDeliveredAt === undefined) {
+      target.lateDeliveredAt = now;
+      status.delivered++;
+      status.lastDeliveredAt = now;
+    }
+    if (fields.reason)
+      target.reason = fields.reason;
+    return target;
+  }
+  if (target.state === state) {
+    if (state === "routed" && target.routedAt === undefined)
+      target.routedAt = now;
+    if (state === "delivered" && target.deliveredAt === undefined)
+      target.deliveredAt = now;
+    if (state === "late" && target.lateDeliveredAt === undefined)
+      target.lateDeliveredAt = now;
+    if (fields.reason)
+      target.reason = fields.reason;
+    if (fields.replacementRunId)
+      target.replacementRunId = fields.replacementRunId;
+    return target;
+  }
+  if ((target.state === "routed" || target.state === "queued") && state !== "routed" && state !== "queued")
+    status.pending = Math.max(0, status.pending - 1);
+  target.state = state;
+  if (state === "routed")
+    target.routedAt = now;
+  if (state === "delivered") {
+    target.deliveredAt = now;
+    status.lastDeliveredAt = now;
+  }
+  if (state === "late") {
+    target.lateDeliveredAt = now;
+    status.lastDeliveredAt = now;
+  }
+  if (state === "failed")
+    target.failedAt = now;
+  if (state === "recovered")
+    target.recoveredAt = now;
+  if (fields.reason)
+    target.reason = fields.reason;
+  if (fields.replacementRunId)
+    target.replacementRunId = fields.replacementRunId;
+  incrementStateCount(status, state);
+  return target;
+}
+export function findSteeringRequest(status, requestId) {
+  return status.recent.find((request) => request.id === requestId);
+}
+export function actionResultFromSteeringStatus(status, sourceRunId, requestId, replacementRunId) {
+  const request = findSteeringRequest(status, requestId);
+  if (!request)
+    return;
+  const targets = request.targets.map((target) => ({
+    index: target.index,
+    state: target.state,
+    ...target.deliveredAt !== undefined ? { deliveredAt: target.deliveredAt } : {},
+    ...target.lateDeliveredAt !== undefined ? { lateDeliveredAt: target.lateDeliveredAt } : {},
+    ...target.reason ? { reason: target.reason } : {},
+    ...target.replacementRunId ? { replacementRunId: target.replacementRunId } : {}
+  }));
+  const states = targets.map((target) => target.state);
+  let state = "pending";
+  if (states.length > 0 && states.every((candidate) => candidate === "delivered"))
+    state = "delivered";
+  else if (states.length > 0 && states.every((candidate) => candidate === "scheduled"))
+    state = "scheduled";
+  else if (states.length > 0 && states.every((candidate) => candidate === "recovered"))
+    state = "recovered";
+  else if (states.length > 0 && states.every((candidate) => candidate === "failed" || candidate === "late"))
+    state = "failed";
+  else if (states.some((candidate) => candidate === "failed" || candidate === "late") && states.some((candidate) => candidate !== "failed" && candidate !== "late"))
+    state = "partial";
+  const effectiveReplacementRunId = replacementRunId ?? request.targets.find((target) => target.replacementRunId)?.replacementRunId;
+  const deliveryStatus = states.length > 0 && states.every((candidate) => candidate === "delivered" || candidate === "recovered") ? "delivered" : "queued";
+  return { requestId, state, deliveryStatus, sourceRunId, ...effectiveReplacementRunId ? { replacementRunId: effectiveReplacementRunId } : {}, targets };
+}
+export function steeringActionIsTerminal(result) {
+  return (result?.targets.length ?? 0) > 0 && result?.targets.every((target) => target.state === "queued" || target.state === "delivered") === true || result?.state === "delivered" || result?.state === "scheduled" || result?.state === "partial" || result?.state === "recovered" || result?.state === "failed";
+}
+export function terminalSteeringNoticeState(status, requestId) {
+  const request = status.recent.find((candidate) => candidate.id === requestId);
+  if (!request || request.targets.some((target) => target.state === "routed" || target.state === "queued" || target.state === "scheduled"))
+    return;
+  const hasSuccess = request.targets.some((target) => target.state === "delivered" || target.state === "recovered");
+  const hasFailure = request.targets.some((target) => target.state === "failed" || target.state === "late");
+  if (hasSuccess && hasFailure)
+    return "partial";
+  return hasFailure ? "failed" : undefined;
+}
+export function claimSteeringRecovery(asyncDir, input) {
+  const recoveryDir = path.join(asyncDir, "control", "steer-recovery");
+  fs.mkdirSync(recoveryDir, { recursive: true, mode: 448 });
+  const claimPath = path.join(recoveryDir, "claim.json");
+  let fd;
+  try {
+    fd = fs.openSync(claimPath, "wx", 384);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error("Another steering recovery is already committed for this source run.");
+    }
+    throw error;
+  }
+  let writeError;
+  try {
+    fs.writeFileSync(fd, JSON.stringify({ version: 1, ...input }, null, 2), "utf-8");
+    fs.fsyncSync(fd);
+  } catch (error) {
+    writeError = error;
+  } finally {
+    fs.closeSync(fd);
+  }
+  if (writeError !== undefined) {
+    fs.rmSync(claimPath, { force: true });
+    throw writeError;
+  }
+  const markerPath = path.join(recoveryDir, `${Buffer.from(input.requestId).toString("base64url")}.json`);
+  try {
+    writePrivateAtomicJson(markerPath, { version: 1, ...input });
+  } catch (error) {
+    fs.rmSync(claimPath, { force: true });
+    throw error;
+  }
+  return { claimPath, markerPath };
+}
+export function readSteeringStatus(asyncDir) {
+  return readStatus(asyncDir)?.steering;
+}
+export function remainingSteeringRecoveryLimits(descriptor, status, now = Date.now()) {
+  const limits = {};
+  if (descriptor.absoluteDeadlineAt !== undefined) {
+    const timeoutMs = descriptor.absoluteDeadlineAt - now;
+    if (timeoutMs <= 0)
+      throw new Error("Source run has no remaining deadline budget; it remains paused.");
+    limits.timeoutMs = timeoutMs;
+    limits.absoluteDeadlineAt = descriptor.absoluteDeadlineAt;
+  }
+  if (descriptor.initialToolBudget) {
+    const consumed = status.toolBudget?.toolCount ?? status.toolCount ?? 0;
+    const hard = descriptor.initialToolBudget.hard - consumed;
+    if (hard <= 0)
+      throw new Error("Source run has no remaining tool budget; it remains paused.");
+    const soft = descriptor.initialToolBudget.soft === undefined ? undefined : descriptor.initialToolBudget.soft - consumed;
+    limits.toolBudget = {
+      hard,
+      ...soft !== undefined && soft > 0 && soft < hard ? { soft } : {},
+      block: descriptor.initialToolBudget.block
+    };
+  }
+  return limits;
+}
+export async function waitForSteeringAction(input) {
+  const deadline = Date.now() + input.timeoutMs;
+  while (Date.now() <= deadline) {
+    if (input.signal?.aborted)
+      return;
+    const status = readSteeringStatus(input.asyncDir);
+    const result = status ? actionResultFromSteeringStatus(status, input.sourceRunId, input.requestId) : undefined;
+    if (steeringActionIsTerminal(result))
+      return result;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(50, Math.max(1, deadline - Date.now()))));
+  }
+  const status = readSteeringStatus(input.asyncDir);
+  return status ? actionResultFromSteeringStatus(status, input.sourceRunId, input.requestId) : undefined;
+}