@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/wait-completions.js

@@ -0,0 +1,155 @@
+import * as fs from "node:fs";
+import { readCompletionReplay, writeCompletionReplay } from "./completion-replay.js";
+import { fallbackResultPayloadPathForSessionRun, resultFilePath, resultPayloadPathForSessionRun } from "./result-files.js";
+import { parseWorkflowChildSummary } from "../../workflows/workflow-child-summary.js";
+import { projectTimeoutRecovery } from "../shared/mutation-evidence.js";
+function asNonEmptyString(value) {
+  return typeof value === "string" && value ? value : undefined;
+}
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function projectedUsage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const record = value;
+  const input = nonNegativeNumber(record.input);
+  const output = nonNegativeNumber(record.output);
+  const cacheRead = nonNegativeNumber(record.cacheRead);
+  const cacheWrite = nonNegativeNumber(record.cacheWrite);
+  const cost = nonNegativeNumber(record.cost);
+  const turns = nonNegativeNumber(record.turns);
+  if (input === undefined || output === undefined || cacheRead === undefined || cacheWrite === undefined || cost === undefined || turns === undefined || !Number.isSafeInteger(turns))
+    return;
+  return { input, output, cacheRead, cacheWrite, cost, turns };
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+}
+function isAccessDenied(error) {
+  const code = errorCode(error);
+  return code === "EPERM" || code === "EACCES";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export function toWaitCompletion(data, runId) {
+  const results = Array.isArray(data.results) ? data.results.flatMap((entry) => {
+    if (entry === null || typeof entry !== "object")
+      return [];
+    const child = entry;
+    const outputState = child.outputState === "present" || child.outputState === "absent" || child.outputState === "unknown" ? child.outputState : undefined;
+    const artifactPaths = child.artifactPaths !== null && typeof child.artifactPaths === "object" ? child.artifactPaths : undefined;
+    const agent = asNonEmptyString(child.agent);
+    const childRunId = asNonEmptyString(child.runId);
+    const usage = projectedUsage(child.usage);
+    const sessionFile = asNonEmptyString(child.sessionFile);
+    const error = asNonEmptyString(child.error);
+    const model = asNonEmptyString(child.model);
+    const contextOverflow = child.contextOverflow === true;
+    const timeoutRecovery = projectTimeoutRecovery(child.timeoutRecovery);
+    return [{
+      ...agent ? { agent } : {},
+      ...childRunId ? { runId: childRunId } : {},
+      ...usage ? { usage } : {},
+      ...sessionFile ? { sessionFile } : {},
+      ...typeof child.success === "boolean" ? { success: child.success } : {},
+      ...outputState ? { outputState } : {},
+      ...error ? { error } : {},
+      ...model ? { model } : {},
+      ...contextOverflow ? { contextOverflow: true } : {},
+      ...artifactPaths ? { artifactPaths } : {},
+      ...timeoutRecovery ? { timeoutRecovery } : {}
+    }];
+  }) : undefined;
+  const agent = asNonEmptyString(data.agent);
+  const mode = asNonEmptyString(data.mode);
+  const state = asNonEmptyString(data.state);
+  const workflowChildren = parseWorkflowChildSummary(data.workflowChildren);
+  if (workflowChildren && workflowChildren.workflowRunId !== runId)
+    throw new Error("workflowChildren.workflowRunId does not match its completion run id.");
+  return {
+    runId,
+    ...agent ? { agent } : {},
+    ...mode ? { mode } : {},
+    ...state ? { state } : {},
+    ...typeof data.success === "boolean" ? { success: data.success } : {},
+    ...results && results.length > 0 ? { results } : {},
+    ...workflowChildren ? { workflowChildren } : {}
+  };
+}
+export function recordWaitCompletion(state, runId, data, now, ttlMs, persistence) {
+  const store = state.completedResults ??= new Map;
+  for (const [key, entry] of store) {
+    if (now - entry.seenAt > ttlMs)
+      store.delete(key);
+  }
+  let completion = toWaitCompletion(data, runId);
+  if (persistence) {
+    try {
+      completion = writeCompletionReplay({
+        ...persistence,
+        runId,
+        completion,
+        data,
+        now,
+        ttlMs
+      }).completion;
+    } catch (error) {
+      console.error(`Failed to persist completion replay for '${runId}':`, error);
+    }
+  }
+  store.set(runId, { seenAt: now, completion });
+}
+export function collectWaitCompletions(terminal, state, resultsDir) {
+  if (terminal.length === 0)
+    return;
+  const completions = [];
+  for (const run of terminal) {
+    const recorded = state.completedResults?.get(run.id);
+    if (recorded) {
+      completions.push(recorded.completion);
+      continue;
+    }
+    const publicResultPath = resultFilePath(resultsDir, run.id);
+    let resultPath = publicResultPath;
+    try {
+      resultPath = run.sessionId ? resultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id) ?? publicResultPath : publicResultPath;
+    } catch (error) {
+      if (!isAccessDenied(error) || !run.sessionId)
+        throw error;
+      try {
+        resultPath = fallbackResultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id) ?? publicResultPath;
+      } catch (fallbackError) {
+        throw new Error(`Failed to read subagent result '${publicResultPath}': ${errorMessage(fallbackError)}`, {
+          cause: fallbackError instanceof Error ? fallbackError : undefined
+        });
+      }
+    }
+    try {
+      const raw = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+      completions.push(toWaitCompletion(raw, run.id));
+    } catch (error) {
+      if (errorCode(error) !== "ENOENT") {
+        throw new Error(`Failed to read subagent result '${resultPath}': ${errorMessage(error)}`, {
+          cause: error instanceof Error ? error : undefined
+        });
+      }
+      const late = state.completedResults?.get(run.id);
+      if (late) {
+        completions.push(late.completion);
+        continue;
+      }
+      try {
+        const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
+        if (replay)
+          completions.push(replay.completion);
+      } catch (replayError) {
+        throw new Error(`Failed to read completion replay for '${run.id}': ${errorMessage(replayError)}`, {
+          cause: replayError instanceof Error ? replayError : undefined
+        });
+      }
+    }
+  }
+  return completions.length > 0 ? completions : undefined;
+}

package/extensions/dm-subagents/src/runs/background/wait-config.js

@@ -0,0 +1,46 @@
+export const WAIT_TOOL_ENABLED_ENV = "DM_SUBAGENT_WAIT_TOOL_ENABLED";
+export const WAIT_TOOL_DEFAULT_TIMEOUT_MS_ENV = "DM_SUBAGENT_WAIT_TOOL_DEFAULT_TIMEOUT_MS";
+const TRUE_VALUES = new Set(["1", "true", "yes", "on", "enabled"]);
+const FALSE_VALUES = new Set(["0", "false", "no", "off", "disabled"]);
+function environmentValue(value) {
+  if (value === undefined)
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (TRUE_VALUES.has(normalized))
+    return true;
+  if (FALSE_VALUES.has(normalized))
+    return false;
+  throw new Error(`${WAIT_TOOL_ENABLED_ENV} must be one of true/false, 1/0, yes/no, on/off, or enabled/disabled.`);
+}
+function environmentDefaultTimeoutMs(value) {
+  if (value === undefined)
+    return;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    throw new Error(`${WAIT_TOOL_DEFAULT_TIMEOUT_MS_ENV} must be a positive integer.`);
+  return parsed;
+}
+function configuredValue(config) {
+  if (config === undefined)
+    return {};
+  if (typeof config === "boolean")
+    return { enabled: config };
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("config.waitTool must be a boolean or an object with optional enabled and defaultTimeoutMs values.");
+  }
+  const { enabled, defaultTimeoutMs } = config;
+  if (enabled !== undefined && typeof enabled !== "boolean")
+    throw new Error("config.waitTool.enabled must be a boolean.");
+  if (defaultTimeoutMs !== undefined && (!Number.isInteger(defaultTimeoutMs) || defaultTimeoutMs < 1)) {
+    throw new Error("config.waitTool.defaultTimeoutMs must be a positive integer.");
+  }
+  return { enabled, ...defaultTimeoutMs !== undefined ? { defaultTimeoutMs } : {} };
+}
+export function resolveWaitToolConfig(config, env = process.env) {
+  const configured = configuredValue(config);
+  const envDefaultTimeoutMs = environmentDefaultTimeoutMs(env[WAIT_TOOL_DEFAULT_TIMEOUT_MS_ENV]);
+  return {
+    enabled: environmentValue(env[WAIT_TOOL_ENABLED_ENV]) ?? configured.enabled ?? true,
+    ...envDefaultTimeoutMs ?? configured.defaultTimeoutMs !== undefined ? { defaultTimeoutMs: envDefaultTimeoutMs ?? configured.defaultTimeoutMs } : {}
+  };
+}

package/extensions/dm-subagents/src/runs/background/wait-subscriptions.js

@@ -0,0 +1,278 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { listAsyncRuns } from "./async-status.js";
+import { formatResumeFirstFailedRunDetail } from "./resume-guidance.js";
+import { readCompletionReplay } from "./completion-replay.js";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+import {
+  DIRS,
+  INTERCOM_DETACH_REQUEST_EVENT,
+  SUBAGENT_ASYNC_COMPLETE_EVENT,
+  SUBAGENT_CONTROL_EVENT,
+  SUBAGENT_CONTROL_INTERCOM_EVENT,
+  SUBAGENT_FOREGROUND_COMPLETE_EVENT,
+  SUBAGENT_RESULT_INTERCOM_EVENT
+} from "../../shared/types.js";
+const SUBSCRIPTION_VERSION = 1;
+const RECONCILE_INTERVAL_MS = 1000;
+const FOREIGN_SWEEP_INTERVAL_MS = 60000;
+const FOREIGN_SWEEP_GRACE_MS = 24 * 60 * 60 * 1000;
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function parseRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const record = value;
+  if (record.version !== SUBSCRIPTION_VERSION || typeof record.token !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(record.token) || typeof record.sessionId !== "string" || record.targetKind !== "async" && record.targetKind !== "foreground" || typeof record.runId !== "string" || typeof record.requestedId !== "string" || typeof record.createdAt !== "number" || typeof record.expiresAt !== "number")
+    return;
+  return record;
+}
+function needsAttention(run) {
+  return run.activityState === "needs_attention" || run.steps.some((step) => step.activityState === "needs_attention");
+}
+function subscriptionFile(dir, token) {
+  return path.join(dir, `${token}.json`);
+}
+export function formatWaitSubscriptions(state, now = Date.now()) {
+  const subscriptions = [...state.waitSubscriptions?.values() ?? []].sort((left, right) => left.createdAt - right.createdAt);
+  if (subscriptions.length === 0)
+    return;
+  const lines = [`Armed wait subscriptions (${subscriptions.length}):`];
+  for (const record of subscriptions) {
+    lines.push(`- ${record.token}: ${record.targetKind} run ${record.runId}, timeout in ${Math.max(0, record.expiresAt - now)}ms`);
+  }
+  return lines.join(`
+`);
+}
+export function createWaitSubscriptionManager(dm, state, options = {}) {
+  const asyncDirRoot = options.asyncDirRoot ?? DIRS.async;
+  const resultsDir = options.resultsDir ?? DIRS.results;
+  const subscriptionsDir = options.subscriptionsDir ?? path.join(path.dirname(asyncDirRoot), "wait-subscriptions");
+  const now = options.now ?? Date.now;
+  const subscriptions = state.waitSubscriptions ?? new Map;
+  state.waitSubscriptions = subscriptions;
+  const unresolvedRestoredForegroundTokens = new Set;
+  let disposed = false;
+  let lastForeignSweepAt = 0;
+  const sweepExpiredForeignSubscriptions = (force = false) => {
+    const sweptAt = now();
+    if (!force && sweptAt - lastForeignSweepAt < FOREIGN_SWEEP_INTERVAL_MS)
+      return;
+    lastForeignSweepAt = sweptAt;
+    let files;
+    try {
+      files = fs.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
+    } catch (error) {
+      if (!isNotFound(error))
+        console.error(`Failed to scan wait subscriptions in '${subscriptionsDir}':`, error);
+      return;
+    }
+    for (const file of files) {
+      const filePath = path.join(subscriptionsDir, file);
+      let record;
+      try {
+        record = parseRecord(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+      } catch (error) {
+        console.error(`Ignoring invalid wait subscription '${filePath}':`, error);
+        continue;
+      }
+      if (!record || file !== `${record.token}.json`)
+        continue;
+      if (record.sessionId === state.currentSessionId)
+        continue;
+      if (sweptAt < record.expiresAt + FOREIGN_SWEEP_GRACE_MS)
+        continue;
+      try {
+        fs.unlinkSync(filePath);
+      } catch (error) {
+        if (!isNotFound(error))
+          console.error(`Failed to remove expired wait subscription '${filePath}':`, error);
+      }
+    }
+  };
+  const remove = (record) => {
+    try {
+      fs.unlinkSync(subscriptionFile(subscriptionsDir, record.token));
+    } catch (error) {
+      if (!isNotFound(error))
+        throw error;
+    }
+    subscriptions.delete(record.token);
+    unresolvedRestoredForegroundTokens.delete(record.token);
+  };
+  const settle = (record, outcome, detail, completion) => {
+    if (disposed || state.currentSessionId !== record.sessionId)
+      return;
+    try {
+      remove(record);
+    } catch (error) {
+      console.error(`Failed to clear wait subscription '${record.token}'; it remains armed:`, error);
+      return;
+    }
+    try {
+      dm.sendMessage({
+        customType: "subagent-wait-subscription",
+        content: `Wait subscription ${record.token} fired for run ${record.runId}: ${outcome}. ${detail}`,
+        display: true,
+        details: {
+          token: record.token,
+          runId: record.runId,
+          outcome,
+          ...completion ? { completions: [completion] } : {}
+        }
+      }, { triggerTurn: true });
+    } catch (error) {
+      console.error(`Failed to deliver wait subscription '${record.token}' after clearing it:`, error);
+    }
+  };
+  const reconcileRecord = (record) => {
+    if (record.sessionId !== state.currentSessionId)
+      return;
+    if (now() >= record.expiresAt) {
+      settle(record, "timed out", "The targeted run may still be active; inspect its status before taking follow-up action.");
+      return;
+    }
+    if (record.targetKind === "foreground") {
+      const run = state.foregroundRuns?.get(record.runId);
+      if (!run && unresolvedRestoredForegroundTokens.has(record.token))
+        return;
+      if (run)
+        unresolvedRestoredForegroundTokens.delete(record.token);
+      if (!run || run.sessionId !== record.sessionId) {
+        settle(record, "could not be reconciled", "The remembered foreground run disappeared before completion was confirmed.");
+        return;
+      }
+      const detached = run.children.filter((child) => child.status === "detached");
+      if (detached.some((child) => child.activityState === "needs_attention" && child.currentTool === "contact_supervisor")) {
+        settle(record, "needs attention", "Reply to the pending supervisor request or inspect the run status.");
+        return;
+      }
+      if (detached.length === 0) {
+        const failed = run.children.some((child) => child.status === "failed");
+        settle(record, failed ? "failed" : "completed", "Inspect the run status for its final output.");
+      }
+      return;
+    }
+    const runs = listAsyncRuns(asyncDirRoot, {
+      sessionId: record.sessionId,
+      runId: record.runId,
+      exactRunId: true,
+      resultsDir,
+      kill: options.kill,
+      now
+    });
+    const run = runs.find((candidate) => candidate.id === record.runId);
+    if (!run) {
+      settle(record, "could not be reconciled", "The exact async run disappeared before a terminal result was confirmed.");
+      return;
+    }
+    if (needsAttention(run)) {
+      settle(record, "needs attention", "Inspect the run status and answer any pending supervisor request.");
+      return;
+    }
+    if (run.state !== "queued" && run.state !== "running") {
+      let completion;
+      try {
+        completion = readCompletionReplay(resultsDir, record.runId, { sessionId: record.sessionId, now: now() })?.completion;
+      } catch (error) {
+        console.error(`Failed to read completion replay for wait subscription '${record.token}':`, error);
+      }
+      const detail = formatResumeFirstFailedRunDetail(run) ?? "Inspect the run status for its final output.";
+      const archiveDetail = completion?.archivePath ? ` Completion archive: ${completion.archivePath}.` : "";
+      settle(record, run.state === "complete" ? "completed" : run.state, `${detail}${archiveDetail}`, completion);
+    }
+  };
+  const reconcile = () => {
+    if (disposed)
+      return;
+    sweepExpiredForeignSubscriptions();
+    if (!state.currentSessionId)
+      return;
+    for (const record of [...subscriptions.values()]) {
+      try {
+        reconcileRecord(record);
+      } catch (error) {
+        console.error(`Failed to reconcile wait subscription '${record.token}':`, error);
+        settle(record, "reconciliation failed", "The targeted run could not be reconciled. Inspect its status before taking follow-up action.");
+      }
+    }
+  };
+  const wakeChannels = [
+    INTERCOM_DETACH_REQUEST_EVENT,
+    SUBAGENT_ASYNC_COMPLETE_EVENT,
+    SUBAGENT_FOREGROUND_COMPLETE_EVENT,
+    SUBAGENT_CONTROL_EVENT,
+    SUBAGENT_CONTROL_INTERCOM_EVENT,
+    SUBAGENT_RESULT_INTERCOM_EVENT
+  ];
+  const unsubscribes = wakeChannels.map((channel) => dm.events.on(channel, reconcile));
+  const interval = setInterval(reconcile, options.pollIntervalMs ?? RECONCILE_INTERVAL_MS);
+  interval.unref?.();
+  return {
+    arm(input) {
+      const sessionId = state.currentSessionId;
+      if (!sessionId)
+        throw new Error("A wait subscription requires an active session identity.");
+      const createdAt = now();
+      const record = {
+        version: SUBSCRIPTION_VERSION,
+        token: randomUUID(),
+        sessionId,
+        targetKind: input.targetKind,
+        runId: input.runId,
+        requestedId: input.requestedId,
+        createdAt,
+        expiresAt: createdAt + input.timeoutMs
+      };
+      fs.mkdirSync(subscriptionsDir, { recursive: true });
+      writeAtomicJson(subscriptionFile(subscriptionsDir, record.token), record);
+      subscriptions.set(record.token, record);
+      return record;
+    },
+    restore() {
+      subscriptions.clear();
+      unresolvedRestoredForegroundTokens.clear();
+      sweepExpiredForeignSubscriptions(true);
+      if (!state.currentSessionId)
+        return;
+      let files;
+      try {
+        files = fs.readdirSync(subscriptionsDir).filter((file) => file.endsWith(".json"));
+      } catch (error) {
+        if (isNotFound(error))
+          return;
+        throw error;
+      }
+      for (const file of files) {
+        try {
+          const record = parseRecord(JSON.parse(fs.readFileSync(path.join(subscriptionsDir, file), "utf-8")));
+          if (!record || file !== `${record.token}.json`)
+            continue;
+          if (record.sessionId === state.currentSessionId) {
+            subscriptions.set(record.token, record);
+            if (record.targetKind === "foreground" && !state.foregroundRuns?.has(record.runId))
+              unresolvedRestoredForegroundTokens.add(record.token);
+          }
+        } catch (error) {
+          console.error(`Ignoring invalid wait subscription '${path.join(subscriptionsDir, file)}':`, error);
+        }
+      }
+      reconcile();
+    },
+    reconcile,
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      clearInterval(interval);
+      for (const unsubscribe of unsubscribes) {
+        try {
+          unsubscribe();
+        } catch {}
+      }
+      subscriptions.clear();
+    }
+  };
+}

package/extensions/dm-subagents/src/runs/background/wait-tool.js

@@ -0,0 +1,47 @@
+import { SubagentWaitParams } from "../../extension/schemas.js";
+import { resolveWaitToolConfig, waitForSubagents } from "./subagent-wait.js";
+import { finalizeToolResult } from "../../extension/tool-result.js";
+export function registerWaitTool(dm, state, enabled = resolveWaitToolConfig().enabled, subscriptions, defaultTimeoutMs) {
+  const description = `Wait for background, provider, or detached work that has no native completion notification, then return.
+
+Ordinary async subagent runs already notify this session natively when they complete or need attention. In an interactive chat, return control instead of calling this merely to wait. Use this tool for provider jobs, remembered detached foreground runs, or other background work without a native notification path. Headless runs auto-drain current-session subagent work at agent_end; use this tool only when the current turn must receive non-notifying background work results.
+
+• { } — return when the first initially active async run or registered provider item finishes, or when a subagent needs attention.
+• { all: true } — wait for every async run and provider item that was active when the call began.
+• { id: "..." } — wait for one async or remembered detached foreground subagent run (id or prefix).
+• { id: "...", nonBlocking: true } — resolve the prefix once, persist an exact-run wake subscription, and return immediately. Use this for detached work without native completion delivery; the originating interactive session wakes on completion, failure, attention, reconciliation failure, or timeout.
+• { stopOnAttention: false } — for blocking waits only, keep waiting through idle or long-thinking attention; supervisor/contact requests still stop the wait.
+• { timeoutMs: 600000 } — stop waiting after N ms; active work keeps running. Omitted values use waitTool.defaultTimeoutMs, then 30 minutes. Window expiry returns a non-error window_elapsed result with active work identities.
+
+Non-blocking subscriptions are visible in subagent status and differ from disabling waitTool: waitTool.enabled=false returns immediately without registering any future wake. Provider jobs are session-scoped and identified exactly, so replacing one job with another cannot hide a completion. Provider extensions must be explicitly loaded in this process. In a child agent, keep \`bg_wait\` (or the deprecated \`subagent_wait\` compatibility alias) in the child tool allowlist and load each provider through the agent's extensions or subagentOnlyExtensions; this tool never loads providers or grants tools itself.${enabled ? "" : `
+
+Configured behavior: bg_wait and its subagent_wait compatibility alias are disabled by config.waitTool or DM_SUBAGENT_WAIT_TOOL_ENABLED and return immediately without blocking.`}`;
+  const execute = async (_id, params, signal, onUpdate, ctx) => finalizeToolResult(await waitForSubagents(params, signal, {
+    state,
+    events: dm.events,
+    enabled,
+    ...defaultTimeoutMs !== undefined ? { defaultTimeoutMs } : {},
+    onUpdate,
+    ...subscriptions && ctx?.hasUI ? { subscribe: (input) => subscriptions.arm(input) } : {}
+  }));
+  const primaryTool = {
+    name: "bg_wait",
+    label: "Background Wait",
+    description,
+    parameters: SubagentWaitParams,
+    execute
+  };
+  dm.registerTool(primaryTool);
+  dm.registerTool({
+    ...primaryTool,
+    name: "wait",
+    label: "Wait",
+    description: "Compatibility alias for `bg_wait`."
+  });
+  dm.registerTool({
+    ...primaryTool,
+    name: "subagent_wait",
+    label: "Subagent Wait (deprecated)",
+    description: "Deprecated compatibility alias for `bg_wait`. Use `bg_wait` for background, provider, or detached work without a native completion notification. It has the same parameters and behavior."
+  });
+}

package/extensions/dm-subagents/src/runs/foreground/async-dismiss-action.js

@@ -0,0 +1,81 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+import { DIRS } from "../../shared/types.js";
+import { readStatus } from "../../shared/utils.js";
+import { updateActiveRunIndex } from "../background/active-run-index.js";
+import { reconcileAsyncRun } from "../background/stale-run-reconciler.js";
+import { resultFilePath } from "../background/result-files.js";
+export function dismissRecoveredWorkflow(state, location) {
+  const asyncDir = location.asyncDir;
+  const runId = location.resolvedId ?? (asyncDir ? path.basename(asyncDir) : "requested");
+  if (!asyncDir) {
+    return {
+      content: [{ type: "text", text: `Recovered workflow '${runId}' has no disk status to dismiss.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
+  const status = readStatus(asyncDir);
+  if (!status || status.mode !== "workflow") {
+    return {
+      content: [{ type: "text", text: `Run '${runId}' is not a recovered workflow.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
+  if (!state.currentSessionId || status.sessionId !== state.currentSessionId) {
+    return {
+      content: [{ type: "text", text: `Recovered workflow '${runId}' was not found in the active session.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
+  if (state.workflowControllers?.has(status.runId) || state.workflowControllers?.has(runId)) {
+    return {
+      content: [{ type: "text", text: `Workflow '${runId}' still has a live controller and cannot be dismissed.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
+  if (status.state !== "running") {
+    return {
+      content: [{ type: "text", text: `Recovered workflow '${runId}' is ${status.state}, not running.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
+  let latestStatus = status;
+  const resultPath = resultFilePath(DIRS.results, status.runId);
+  if (fs.existsSync(resultPath)) {
+    const reconciled = reconcileAsyncRun(asyncDir).status;
+    if (reconciled && reconciled.state !== "running") {
+      return {
+        content: [{ type: "text", text: `Recovered workflow '${runId}' is ${reconciled.state}, not running.` }],
+        isError: true,
+        details: { mode: "management", results: [] }
+      };
+    }
+    if (reconciled)
+      latestStatus = reconciled;
+  }
+  const dismissed = { ...latestStatus, displayDismissedAt: Date.now() };
+  writeAtomicJson(path.join(asyncDir, "status.json"), dismissed);
+  const repaired = reconcileAsyncRun(asyncDir).status;
+  if (repaired && repaired.state !== "running") {
+    return {
+      content: [{ type: "text", text: `Recovered workflow '${runId}' is ${repaired.state}, not running.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
+  updateActiveRunIndex(asyncDir, "complete");
+  state.asyncJobs.delete(status.runId);
+  state.asyncJobs.delete(runId);
+  state.fleetJobs?.delete(status.runId);
+  state.fleetJobs?.delete(runId);
+  return {
+    content: [{ type: "text", text: `Dismissed recovered workflow ${status.runId} from the display. No running work was terminated.` }],
+    details: { mode: "management", results: [] }
+  };
+}