@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/intercom/result-intercom.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
+import { isUnexplainedProcessSignal } from "../runs/shared/process-signal.js";
 import {
   SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
   SUBAGENT_RESULT_INTERCOM_EVENT
@@ -7,10 +8,16 @@ import {
 export function resolveSubagentResultStatus(input) {
   if (input.detached)
     return "detached";
+  if (input.stopped || input.state === "stopped")
+    return "stopped";
   if (input.interrupted || input.state === "paused")
     return "paused";
-  if (typeof input.success === "boolean")
-    return input.success ? "completed" : "failed";
+  if (input.success === true)
+    return "completed";
+  if (isUnexplainedProcessSignal(input) && input.exitCode !== 0)
+    return "stopped";
+  if (input.success === false)
+    return "failed";
   if (input.state === "complete")
     return "completed";
   if (input.state === "failed")
@@ -24,6 +31,7 @@ function countStatuses(children) {
     completed: 0,
     failed: 0,
     paused: 0,
+    stopped: 0,
     detached: 0
   };
   for (const child of children) {
@@ -35,15 +43,32 @@ function formatStatusCounts(counts) {
   const parts = [
     counts.completed ? `${counts.completed} completed` : undefined,
     counts.failed ? `${counts.failed} failed` : undefined,
+    counts.stopped ? `${counts.stopped} stopped` : undefined,
     counts.paused ? `${counts.paused} paused` : undefined,
     counts.detached ? `${counts.detached} detached` : undefined
   ].filter((part) => Boolean(part));
   return parts.length ? parts.join(", ") : "0 results";
 }
+function countOutputStates(children) {
+  const counts = { present: 0, absent: 0, unknown: 0 };
+  for (const child of children)
+    counts[child.outputState ?? "unknown"] += 1;
+  return counts;
+}
+function formatOutputCounts(counts) {
+  const parts = [
+    counts.present ? `${counts.present} present` : undefined,
+    counts.absent ? `${counts.absent} absent` : undefined,
+    counts.unknown ? `${counts.unknown} unknown` : undefined
+  ].filter((part) => Boolean(part));
+  return parts.length ? parts.join(", ") : "0 outputs";
+}
 function resolveGroupedStatus(children) {
   const counts = countStatuses(children);
   if (counts.failed > 0)
     return "failed";
+  if (counts.stopped > 0)
+    return "stopped";
   if (counts.paused > 0)
     return "paused";
   if (counts.completed > 0)
@@ -66,6 +91,7 @@ function compactNestedRun(run, depth = 0) {
     })),
     ...run.asyncDir ? { asyncDir: run.asyncDir } : {},
     ...run.sessionId ? { sessionId: run.sessionId } : {},
+    ...run.sessionName ? { sessionName: run.sessionName } : {},
     ...run.sessionFile ? { sessionFile: run.sessionFile } : {},
     ...run.intercomTarget ? { intercomTarget: run.intercomTarget } : {},
     ...run.ownerIntercomTarget ? { ownerIntercomTarget: run.ownerIntercomTarget } : {},
@@ -75,6 +101,8 @@ function compactNestedRun(run, depth = 0) {
     state: run.state,
     ...run.agent ? { agent: run.agent } : {},
     ...run.agents?.length ? { agents: run.agents.slice(0, 12) } : {},
+    ...run.model ? { model: run.model } : {},
+    ...run.thinking ? { thinking: run.thinking } : {},
     ...run.currentStep !== undefined ? { currentStep: run.currentStep } : {},
     ...run.chainStepCount !== undefined ? { chainStepCount: run.chainStepCount } : {},
     ...run.parallelGroups?.length ? { parallelGroups: run.parallelGroups.slice(0, 8) } : {},
@@ -92,7 +120,10 @@ function compactNestedRun(run, depth = 0) {
     ...run.error ? { error: run.error } : {},
     ...run.steps?.length ? { steps: run.steps.slice(0, 12).map((step) => ({
       agent: step.agent,
+      ...step.sessionName ? { sessionName: step.sessionName } : {},
       status: step.status,
+      ...step.model ? { model: step.model } : {},
+      ...step.thinking ? { thinking: step.thinking } : {},
       ...step.sessionFile ? { sessionFile: step.sessionFile } : {},
       ...step.activityState ? { activityState: step.activityState } : {},
       ...step.lastActivityAt !== undefined ? { lastActivityAt: step.lastActivityAt } : {},
@@ -166,14 +197,19 @@ function asyncResumeGuidance(input) {
 }
 function formatSubagentResultIntercomMessage(input) {
   const counts = countStatuses(input.children);
+  const outputCounts = countOutputStates(input.children);
   const lines = [
     "subagent results",
     "",
     `Run: ${input.runId}`,
     `Mode: ${input.mode}`,
-    `Status: ${input.status}`,
-    `Children: ${formatStatusCounts(counts)}`
+    `Process status: ${input.status}`,
+    `Children: ${formatStatusCounts(counts)}`,
+    `Outputs: ${formatOutputCounts(outputCounts)} (semantic adequacy unassessed)`
   ];
+  if (input.children.some((child) => child.status === "failed" && child.outputState === "present")) {
+    lines.push("Recovery: At least one failed process produced output. Inspect that output before retrying; output presence does not establish task completion.");
+  }
   if (input.mode === "chain" && typeof input.chainSteps === "number") {
     lines.push(`Chain steps: ${input.chainSteps}`);
   }
@@ -181,6 +217,8 @@ function formatSubagentResultIntercomMessage(input) {
     lines.push(`Async id: ${input.asyncId}`);
   if (input.asyncDir)
     lines.push(`Async dir: ${input.asyncDir}`);
+  if (input.parallelHandoff)
+    lines.push(`Parallel handoff: ${input.parallelHandoff.path}`);
   const resumeGuidance = asyncResumeGuidance(input);
   if (resumeGuidance)
     lines.push(resumeGuidance);
@@ -191,7 +229,7 @@ function formatSubagentResultIntercomMessage(input) {
   for (let index = 0;index < input.children.length; index++) {
     const child = input.children[index];
     lines.push("");
-    lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
+    lines.push(`${index + 1}. ${child.agent} — process ${child.status} · output ${child.outputState ?? "unknown"}`);
     if (child.intercomTarget)
       lines.push(`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`);
     if (child.artifactPath)
@@ -208,6 +246,7 @@ function formatSubagentResultIntercomMessage(input) {
 export function buildSubagentResultIntercomPayload(input) {
   const children = input.children.map((child) => ({
     ...child,
+    outputState: child.outputState ?? "unknown",
     summary: child.summary.trim() || "(no output)",
     children: compactNestedResultChildren(child.children)
   }));
@@ -225,6 +264,7 @@ export function buildSubagentResultIntercomPayload(input) {
     ...input.asyncId ? { asyncId: input.asyncId } : {},
     ...input.asyncDir ? { asyncDir: input.asyncDir } : {},
     ...typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {},
+    ...input.parallelHandoff ? { parallelHandoff: input.parallelHandoff } : {},
     ...firstChild?.agent ? { agent: firstChild.agent } : {},
     ...firstChild?.index !== undefined ? { index: firstChild.index } : {},
     ...firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {},
@@ -240,8 +280,6 @@ export async function deliverSubagentResultIntercomEvent(events, payload, timeou
 export async function deliverSubagentIntercomMessageEvent(events, to, message, timeoutMs = 500, extra = {}) {
   if (typeof events.on !== "function" || typeof events.emit !== "function")
     return false;
-  if (events.listenerCount?.(SUBAGENT_RESULT_INTERCOM_EVENT) === 0)
-    return true;
   const requestId = typeof extra.requestId === "string" ? extra.requestId : randomUUID();
   return new Promise((resolve) => {
     let settled = false;
@@ -294,6 +332,8 @@ export function formatSubagentResultReceipt(input) {
     `Run: ${input.runId}`,
     `Children: ${formatStatusCounts(counts)}`
   ];
+  if (input.payload.parallelHandoff)
+    lines.push(`Parallel handoff: ${input.payload.parallelHandoff.path}`);
   const artifacts = input.payload.children.filter((child) => typeof child.artifactPath === "string");
   if (artifacts.length > 0) {
     lines.push("Artifacts:");

package/extensions/dm-subagents/src/missions/actions.js

@@ -0,0 +1,394 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  MISSION_STATUSES
+} from "./types.js";
+import { missionStatePath } from "./workflow-state.js";
+import {
+  createMission,
+  listGlobalMissions,
+  listMissions,
+  missionRecordPath,
+  readMission,
+  resolveMissionStoreLocation,
+  updateMission,
+  validateMissionId
+} from "./store.js";
+export const MISSION_ACTIONS = [
+  "mission.create",
+  "mission.list",
+  "mission.show",
+  "mission.update",
+  "mission.resolve-decision",
+  "mission.attach-run",
+  "mission.close"
+];
+function textResult(text, details) {
+  return { content: [{ type: "text", text }], details };
+}
+function requireMissionId(params) {
+  return validateMissionId(params.missionId, "missionId");
+}
+function validateStatus(value, label) {
+  if (typeof value !== "string" || !MISSION_STATUSES.includes(value)) {
+    throw new Error(`${label} must be one of ${MISSION_STATUSES.join(", ")}`);
+  }
+  return value;
+}
+export function validateMissionLaunch(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("mission must be an object");
+  const input = value;
+  for (const key of Object.keys(input)) {
+    if (key !== "title" && key !== "summary" && key !== "objective" && key !== "goal" && key !== "budget" && key !== "labels")
+      throw new Error(`mission.${key} is unknown`);
+  }
+  if (input.title !== undefined && input.summary !== undefined)
+    throw new Error("mission.title and mission.summary cannot both be set");
+  const title = input.title ?? input.summary;
+  if (typeof title !== "string" || !title.trim())
+    throw new Error("mission.title or mission.summary must be a non-empty string");
+  if (input.objective !== undefined && (typeof input.objective !== "string" || !input.objective.trim()))
+    throw new Error("mission.objective must be a non-empty string");
+  if (input.goal !== undefined && input.goal !== true)
+    throw new Error("mission.goal must be true when supplied");
+  const budget = input.budget;
+  if (budget !== undefined && (!budget || typeof budget !== "object" || Array.isArray(budget) || !Number.isSafeInteger(budget.tokens) || budget.tokens < 1)) {
+    throw new Error("mission.budget.tokens must be a positive integer");
+  }
+  if (input.goal === true && budget === undefined)
+    throw new Error("mission.budget is required when mission.goal is true");
+  if (input.labels !== undefined && (!Array.isArray(input.labels) || input.labels.some((label) => typeof label !== "string" || !label.trim()))) {
+    throw new Error("mission.labels must contain only non-empty strings");
+  }
+  return {
+    title: title.trim(),
+    ...typeof input.objective === "string" ? { objective: input.objective.trim() } : {},
+    ...input.goal === true ? { goal: true } : {},
+    ...budget !== undefined ? { budget: { tokens: budget.tokens } } : {},
+    ...input.labels !== undefined ? { labels: input.labels.map((label) => label.trim()) } : {}
+  };
+}
+function validateArtifact(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`missionUpdate.artifacts[${index}] must be an object`);
+  const input = value;
+  const kinds = ["status", "output", "patch", "manifest", "review", "note", "other"];
+  if (typeof input.kind !== "string" || !kinds.includes(input.kind))
+    throw new Error(`missionUpdate.artifacts[${index}].kind is invalid`);
+  if (typeof input.path !== "string" || !input.path.trim())
+    throw new Error(`missionUpdate.artifacts[${index}].path must be a non-empty string`);
+  if (input.description !== undefined && (typeof input.description !== "string" || !input.description.trim()))
+    throw new Error(`missionUpdate.artifacts[${index}].description must be a non-empty string`);
+  return {
+    kind: input.kind,
+    path: input.path,
+    ...typeof input.description === "string" ? { description: input.description } : {}
+  };
+}
+function validateReceipt(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`missionUpdate.receipts[${index}] must be an object`);
+  const input = value;
+  for (const key of Object.keys(input)) {
+    if (!["kind", "status", "title", "url", "description"].includes(key))
+      throw new Error(`missionUpdate.receipts[${index}].${key} is unknown`);
+  }
+  const kinds = ["pull_request", "ci", "deployment", "release"];
+  const statuses = ["pending", "ready", "succeeded", "failed"];
+  if (typeof input.kind !== "string" || !kinds.includes(input.kind))
+    throw new Error(`missionUpdate.receipts[${index}].kind is invalid`);
+  if (typeof input.status !== "string" || !statuses.includes(input.status))
+    throw new Error(`missionUpdate.receipts[${index}].status is invalid`);
+  for (const field of ["title", "url"]) {
+    if (typeof input[field] !== "string" || !input[field].trim())
+      throw new Error(`missionUpdate.receipts[${index}].${field} must be a non-empty string`);
+  }
+  try {
+    new URL(input.url);
+  } catch {
+    throw new Error(`missionUpdate.receipts[${index}].url must be an absolute URL`);
+  }
+  if (input.description !== undefined && (typeof input.description !== "string" || !input.description.trim()))
+    throw new Error(`missionUpdate.receipts[${index}].description must be a non-empty string`);
+  return {
+    kind: input.kind,
+    status: input.status,
+    title: input.title.trim(),
+    url: input.url.trim(),
+    ...typeof input.description === "string" ? { description: input.description.trim() } : {}
+  };
+}
+function validateMissionUpdate(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("missionUpdate must be an object");
+  const input = value;
+  for (const key of Object.keys(input)) {
+    if (!["title", "objective", "goal", "budget", "status", "summary", "labels", "artifacts", "receipts", "decisions"].includes(key))
+      throw new Error(`missionUpdate.${key} is unknown`);
+  }
+  const update = {};
+  for (const field of ["title", "objective", "summary"]) {
+    const candidate = input[field];
+    if (candidate === undefined)
+      continue;
+    if (typeof candidate !== "string" || !candidate.trim())
+      throw new Error(`missionUpdate.${field} must be a non-empty string`);
+    update[field] = candidate.trim();
+  }
+  if (input.goal !== undefined) {
+    if (typeof input.goal === "boolean")
+      update.goal = input.goal ? { status: "active" } : false;
+    else {
+      if (!input.goal || typeof input.goal !== "object" || Array.isArray(input.goal) || typeof input.goal.paused !== "boolean" || Object.keys(input.goal).some((key) => key !== "paused")) {
+        throw new Error("missionUpdate.goal must be boolean or { paused: boolean }");
+      }
+      update.goal = { status: input.goal.paused ? "paused" : "active" };
+    }
+  }
+  if (input.budget !== undefined) {
+    if (!input.budget || typeof input.budget !== "object" || Array.isArray(input.budget) || !Number.isSafeInteger(input.budget.tokens) || input.budget.tokens < 1) {
+      throw new Error("missionUpdate.budget.tokens must be a positive integer");
+    }
+    update.budget = { tokens: input.budget.tokens };
+  }
+  if (input.status !== undefined)
+    update.status = validateStatus(input.status, "missionUpdate.status");
+  if (input.labels !== undefined) {
+    if (!Array.isArray(input.labels) || input.labels.some((label) => typeof label !== "string" || !label.trim()))
+      throw new Error("missionUpdate.labels must contain only non-empty strings");
+    update.labels = input.labels;
+  }
+  if (input.artifacts !== undefined) {
+    if (!Array.isArray(input.artifacts))
+      throw new Error("missionUpdate.artifacts must be an array");
+    update.addArtifacts = input.artifacts.map(validateArtifact);
+  }
+  if (input.receipts !== undefined) {
+    if (!Array.isArray(input.receipts))
+      throw new Error("missionUpdate.receipts must be an array");
+    update.addReceipts = input.receipts.map(validateReceipt);
+  }
+  if (input.decisions !== undefined) {
+    if (!Array.isArray(input.decisions))
+      throw new Error("missionUpdate.decisions must be an array");
+    update.addDecisions = input.decisions.map((value, index) => {
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`missionUpdate.decisions[${index}] must be an object`);
+      const decision = value;
+      if (typeof decision.title !== "string" || !decision.title.trim())
+        throw new Error(`missionUpdate.decisions[${index}].title must be a non-empty string`);
+      if (decision.options !== undefined && (!Array.isArray(decision.options) || decision.options.some((option) => typeof option !== "string" || !option.trim())))
+        throw new Error(`missionUpdate.decisions[${index}].options must contain only non-empty strings`);
+      return {
+        title: decision.title.trim(),
+        ...typeof decision.prompt === "string" && decision.prompt.trim() ? { prompt: decision.prompt } : {},
+        ...Array.isArray(decision.options) ? { options: decision.options } : {},
+        ...typeof decision.recommendation === "string" && decision.recommendation.trim() ? { recommendation: decision.recommendation } : {}
+      };
+    });
+  }
+  if (Object.keys(update).length === 0)
+    throw new Error("missionUpdate must include at least one supported field");
+  return update;
+}
+function refreshLinkedRunStatus(location, record) {
+  const warnings = [];
+  const updates = record.runs.flatMap((run) => {
+    if (!run.asyncDir)
+      return [];
+    const statusPath = path.join(run.asyncDir, "status.json");
+    if (!fs.existsSync(statusPath))
+      return [];
+    let status;
+    try {
+      status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+    } catch (error) {
+      warnings.push(`Failed to read linked run status '${statusPath}': ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+    if (!status || typeof status !== "object" || Array.isArray(status)) {
+      warnings.push(`Linked run status '${statusPath}' must be an object`);
+      return [];
+    }
+    const state = status.state;
+    if (typeof state !== "string" || !state.trim()) {
+      warnings.push(`Linked run status '${statusPath}' is missing state`);
+      return [];
+    }
+    if (state === run.status)
+      return [];
+    return [{
+      ...run,
+      status: state,
+      ...!["queued", "running"].includes(state) && !run.completedAt ? { completedAt: new Date().toISOString() } : {}
+    }];
+  });
+  if (updates.length === 0)
+    return { record, warnings };
+  const merged = record.runs.map((run) => updates.find((update) => update.runId === run.runId && update.childIndex === run.childIndex) ?? run);
+  const states = merged.map((run) => run.status);
+  const status = record.status === "completed" || record.status === "failed" || record.status === "cancelled" ? record.status : record.goal && !states.some((state) => state === "queued" || state === "running" || state === "active") ? "active" : states.some((state) => state === "queued" || state === "running" || state === "active") ? "active" : states.some((state) => state === "paused") ? "waiting" : states.some((state) => state === "failed") ? "failed" : states.some((state) => state === "stopped" || state === "rejected" || state === "cancelled") ? "cancelled" : states.length > 0 && states.every((state) => state === "complete" || state === "completed") ? "completed" : record.status;
+  return { record: updateMission(location, record.id, { status, addRuns: updates }), warnings };
+}
+function formatMission(record) {
+  const lines = [
+    `Mission: ${record.id}`,
+    `Title: ${record.title}`,
+    `Status: ${record.status}`,
+    `Objective: ${record.objective}`,
+    `Updated: ${record.updatedAt}`
+  ];
+  if (record.goal && record.budget)
+    lines.push(`Goal mode: ${record.goal.status}`, `Budget: ${record.usage?.tokens ?? 0}/${record.budget.tokens} tokens`);
+  if (record.summary)
+    lines.push(`Summary: ${record.summary}`);
+  if (record.labels?.length)
+    lines.push(`Labels: ${record.labels.join(", ")}`);
+  if (record.runs.length) {
+    lines.push("Runs:");
+    for (const run of record.runs)
+      lines.push(`  ${run.runId} (${run.mode}${run.status ? `, ${run.status}` : ""})${run.asyncDir ? ` — ${run.asyncDir}` : ""}`);
+  }
+  if (record.workflowChildren.length) {
+    lines.push("Workflow children:");
+    for (const child of record.workflowChildren) {
+      const identity = child.runId ? `${child.key} (${child.runId})` : child.key;
+      const heartbeat = child.heartbeat ? `; heartbeat ${child.heartbeat.status ?? child.status}${child.heartbeat.phase ? `/${child.heartbeat.phase}` : ""} at ${child.heartbeat.updatedAt}` : "";
+      const recovery = child.sessionPath ? `; session ${child.sessionPath}` : child.artifactPaths.length ? `; artifacts ${child.artifactPaths.length}` : "";
+      lines.push(`  ${identity}: ${child.status}${child.agent ? ` — ${child.agent}` : ""}${child.phase ? ` [${child.phase}]` : ""}; updated ${child.updatedAt}${heartbeat}${recovery}`);
+    }
+  }
+  if (record.decisions.length) {
+    lines.push("Decisions:");
+    for (const decision of record.decisions) {
+      lines.push(`  ${decision.id}: ${decision.status} — ${decision.title}${decision.resolution ? `; resolution: ${decision.resolution}` : ""}`);
+    }
+  }
+  if (record.artifacts.length) {
+    lines.push("Artifacts:");
+    for (const artifact of record.artifacts)
+      lines.push(`  ${artifact.kind}: ${artifact.path}`);
+  }
+  if (record.receipts.length) {
+    lines.push("Delivery receipts:");
+    for (const receipt of record.receipts)
+      lines.push(`  ${receipt.kind} (${receipt.status}): ${receipt.title} — ${receipt.url}`);
+  }
+  return lines.join(`
+`);
+}
+export function handleMissionAction(action, params, ctx) {
+  const location = resolveMissionStoreLocation({
+    projectRoot: ctx.cwd,
+    ...ctx.config ? { config: ctx.config } : {},
+    ...ctx.agentDir ? { agentDir: ctx.agentDir } : {}
+  });
+  if (action === "mission.create") {
+    const mission = validateMissionLaunch(params.mission);
+    const record = createMission(location, {
+      title: mission.title,
+      objective: mission.objective ?? mission.title,
+      ...mission.goal === true ? { goal: true } : {},
+      ...mission.budget ? { budget: mission.budget } : {},
+      status: params.missionStatus ? validateStatus(params.missionStatus, "missionStatus") : "planned",
+      ...mission.labels ? { labels: mission.labels } : {},
+      ...ctx.currentSessionId ? { ownerSessionId: ctx.currentSessionId } : {}
+    }, new Date, ctx.config?.retainTerminal);
+    return textResult(`Created mission ${record.id}: ${record.title}`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
+  }
+  if (action === "mission.list") {
+    if (params.missionScope !== undefined && params.missionScope !== "project" && params.missionScope !== "global") {
+      throw new Error('missionScope must be "project" or "global"');
+    }
+    if (params.missionScope === "global") {
+      const listed = listGlobalMissions(location.globalIndexDir);
+      const lines = listed.entries.length === 0 ? ["No indexed missions."] : listed.entries.map((entry) => `${entry.missionId}  ${entry.status}${entry.stale ? " [stale]" : ""}  ${entry.title}  ${entry.projectRoot}`);
+      if (listed.warnings.length)
+        lines.push("", ...listed.warnings.map((warning) => `Warning: ${warning}`));
+      return textResult(lines.join(`
+`), { mode: "management", results: [], missions: { globalEntries: listed.entries, warnings: listed.warnings } });
+    }
+    const listed = listMissions(location);
+    const lines = listed.records.length === 0 ? ["No project missions."] : listed.records.map((record) => {
+      const open = record.decisions.filter((decision) => decision.status === "open").length;
+      const resolved = record.decisions.length - open;
+      return `${record.id}  ${record.status}  ${record.title}  ${record.updatedAt}${record.decisions.length ? `  decisions: ${open} open, ${resolved} resolved` : ""}`;
+    });
+    if (listed.warnings.length)
+      lines.push("", ...listed.warnings.map((warning) => `Warning: ${warning}`));
+    return textResult(lines.join(`
+`), { mode: "management", results: [], missions: { records: listed.records, warnings: listed.warnings } });
+  }
+  if (action === "mission.show") {
+    const refreshed = refreshLinkedRunStatus(location, readMission(location, requireMissionId(params)));
+    const lines = [formatMission(refreshed.record), `State: ${missionStatePath(location, refreshed.record.id)}`];
+    if (refreshed.warnings.length)
+      lines.push("", ...refreshed.warnings.map((warning) => `Warning: ${warning}`));
+    return textResult(lines.join(`
+`), {
+      mode: "management",
+      results: [],
+      missionId: refreshed.record.id,
+      missionPath: pathFor(refreshed.record.id),
+      mission: refreshed.record,
+      missions: { warnings: refreshed.warnings }
+    });
+  }
+  if (action === "mission.update") {
+    const record = updateMission(location, requireMissionId(params), validateMissionUpdate(params.missionUpdate));
+    return textResult(`Updated mission ${record.id}.
+
+${formatMission(record)}`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
+  }
+  if (action === "mission.resolve-decision") {
+    const missionId = requireMissionId(params);
+    const decisionId = validateMissionId(params.id, "id");
+    if (typeof params.summary !== "string" || !params.summary.trim())
+      throw new Error("mission.resolve-decision requires a non-empty summary");
+    const record = updateMission(location, missionId, { resolveDecision: { id: decisionId, resolution: params.summary.trim() } });
+    return textResult(`Resolved decision ${decisionId} for mission ${record.id}.
+
+${formatMission(record)}`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
+  }
+  if (action === "mission.attach-run") {
+    const missionId = requireMissionId(params);
+    const runId = params.runId ?? params.id;
+    if (typeof runId !== "string" || !runId.trim())
+      throw new Error("mission.attach-run requires runId or id");
+    const rawMode = params.runMode ?? "external";
+    if (!["single", "parallel", "chain", "workflow", "scheduled", "external"].includes(rawMode))
+      throw new Error("runMode is invalid");
+    const mode = rawMode;
+    if (params.dir !== undefined && !params.dir.trim())
+      throw new Error("dir must be a non-empty string");
+    if (params.runStatus !== undefined && !params.runStatus.trim())
+      throw new Error("runStatus must be a non-empty string");
+    const record = updateMission(location, missionId, {
+      status: "active",
+      addRuns: [{
+        runId: runId.trim(),
+        mode,
+        ...params.dir ? { asyncDir: params.dir } : {},
+        ...params.agent ? { agent: params.agent } : {},
+        ...params.runStatus ? { status: params.runStatus } : {},
+        startedAt: new Date().toISOString()
+      }]
+    });
+    return textResult(`Attached run ${runId} to mission ${record.id}.`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
+  }
+  const missionId = requireMissionId(params);
+  const status = params.missionStatus ?? "completed";
+  if (status !== "completed" && status !== "failed" && status !== "cancelled")
+    throw new Error("mission.close missionStatus must be completed, failed, or cancelled");
+  if (params.summary !== undefined && !params.summary.trim())
+    throw new Error("summary must be a non-empty string");
+  const record = updateMission(location, missionId, {
+    status,
+    ...params.summary !== undefined ? { summary: params.summary.trim() } : {}
+  });
+  return textResult(`Closed mission ${record.id} as ${record.status}.`, { mode: "management", results: [], missionId: record.id, missionPath: pathFor(record.id), mission: record });
+  function pathFor(missionId) {
+    return missionRecordPath(location, missionId);
+  }
+}