@coresource/hz 0.20.2 → 0.20.4

package/dist/hz.mjs

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { readFileSync, realpathSync } from "fs";
 import { fileURLToPath } from "url";
-import { Command, CommanderError as CommanderError3 } from "commander";
+import { Command, CommanderError as CommanderError4 } from "commander";
 
 // src/cli-support.ts
 import { password } from "@inquirer/prompts";
@@ -28,6 +28,50 @@ function writeLine(stream, message = "") {
   stream.write(`${message}
 `);
 }
+function hasExitCode(error, exitCode) {
+  return error instanceof Error && "exitCode" in error && error.exitCode === exitCode;
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function isAbortPromptError(error) {
+  return error instanceof Error && error.name === "AbortPromptError";
+}
+function isInterruptedError(error) {
+  return hasExitCode(error, 130) || isAbortError(error) || isAbortPromptError(error);
+}
+function createSignalHandlerCoordinator(registerSignalHandler, exitProcess = (code) => process.exit(code)) {
+  if (!registerSignalHandler) {
+    return void 0;
+  }
+  let activeUnregister;
+  let cleanupInProgress = false;
+  return (signal, handler) => {
+    activeUnregister?.();
+    cleanupInProgress = false;
+    const wrappedHandler = () => {
+      if (cleanupInProgress) {
+        exitProcess(130);
+        return;
+      }
+      cleanupInProgress = true;
+      handler();
+    };
+    const underlyingUnregister = registerSignalHandler(signal, wrappedHandler);
+    const unregister = () => {
+      if (activeUnregister !== unregister) {
+        return;
+      }
+      activeUnregister = void 0;
+      cleanupInProgress = false;
+      if (typeof underlyingUnregister === "function") {
+        underlyingUnregister();
+      }
+    };
+    activeUnregister = unregister;
+    return unregister;
+  };
+}
 
 // src/config.ts
 import { open } from "fs/promises";
@@ -300,6 +344,9 @@ function formatNetworkError(error) {
   }
   return new ApiError("Unexpected error while contacting the Horizon API.");
 }
+function isAbortError2(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
 function createApiClient(options) {
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const sleep = options.sleep ?? ((ms) => delay(ms).then(() => void 0));
@@ -323,7 +370,8 @@ function createApiClient(options) {
         );
       }
       for (let attempt = 0; attempt <= retryCount; attempt += 1) {
-        const signal = AbortSignal.timeout(request.timeoutMs ?? timeoutMs);
+        const timeoutSignal = AbortSignal.timeout(request.timeoutMs ?? timeoutMs);
+        const signal = request.signal ? AbortSignal.any([request.signal, timeoutSignal]) : timeoutSignal;
         try {
           const response = await fetchImpl(url, {
             method,
@@ -346,6 +394,9 @@ function createApiClient(options) {
           }
           throw formatHttpError(response, payload);
         } catch (error) {
+          if (isAbortError2(error)) {
+            throw error;
+          }
           if (error instanceof ApiError) {
             throw error;
           }
@@ -552,11 +603,11 @@ function normalizeMissionSummary(value) {
   return {
     completedFeatures: asFiniteNumber(value.completedFeatures),
     createdAt: asNonEmptyString(value.createdAt),
-    description: asNonEmptyString(value.description) ?? asNonEmptyString(value.taskDescription),
+    description: asNonEmptyString(value.description),
     missionId,
     passedAssertions: asFiniteNumber(value.passedAssertions),
     state: asNonEmptyString(value.state) ?? "unknown",
-    taskDescription: asNonEmptyString(value.taskDescription) ?? asNonEmptyString(value.description),
+    taskDescription: asNonEmptyString(value.taskDescription),
     totalAssertions: asFiniteNumber(value.totalAssertions),
     totalFeatures: asFiniteNumber(value.totalFeatures)
   };
@@ -811,70 +862,87 @@ function registerMissionInfoCommand(mission, context, dependencies = {}) {
 }
 
 // src/commands/mission-list.ts
-async function resolveMissionDescription(apiClient, missionSummary) {
-  if (missionSummary.taskDescription || missionSummary.description) {
-    return missionSummary.taskDescription ?? missionSummary.description;
-  }
-  try {
-    const missionState = normalizeMissionState(
-      await apiClient.request({
-        path: `/missions/${missionSummary.missionId}/mission/state`
-      })
-    );
-    return missionState.taskDescription;
-  } catch {
-    return null;
-  }
-}
+import { CommanderError } from "commander";
+import pc3 from "picocolors";
 function registerMissionListCommand(mission, context, dependencies = {}) {
   mission.command("list").description("List recent missions").action(async (_options, command) => {
-    const apiClient = await createMissionApiClient(context, command, dependencies);
-    const missionSummaries = normalizeMissionSummaries(
-      await apiClient.request({
-        path: "/missions"
-      })
+    const registerSignalHandler = createSignalHandlerCoordinator(
+      dependencies.registerSignalHandler
     );
-    if (missionSummaries.length === 0) {
-      writeLine(context.stdout, "No missions found");
-      return;
+    const abortController = new AbortController();
+    let interrupted = false;
+    const unregisterSignalHandler = registerSignalHandler?.("SIGINT", () => {
+      interrupted = true;
+      if (!abortController.signal.aborted) {
+        abortController.abort();
+      }
+      writeLine(
+        context.stdout,
+        pc3.yellow(
+          "Interrupted. Remote mission state is preserved. Re-run `hz mission list` when ready."
+        )
+      );
+    });
+    try {
+      const apiClient = await createMissionApiClient(context, command, dependencies);
+      const missionSummaries = normalizeMissionSummaries(
+        await apiClient.request({
+          path: "/missions",
+          signal: abortController.signal
+        })
+      );
+      if (interrupted) {
+        throw new CommanderError(130, "mission-list", "");
+      }
+      if (missionSummaries.length === 0) {
+        writeLine(context.stdout, "No missions found");
+        return;
+      }
+      renderTable(
+        context.stdout,
+        ["Mission ID", "State", "Created", "Features", "Assertions", "Description"],
+        missionSummaries.map((missionSummary) => [
+          plainCell(missionSummary.missionId),
+          coloredCell(
+            formatMissionState(missionSummary.state),
+            missionSummary.state
+          ),
+          plainCell(formatDateTime(missionSummary.createdAt)),
+          plainCell(
+            `${missionSummary.completedFeatures}/${missionSummary.totalFeatures}`
+          ),
+          plainCell(
+            `${missionSummary.passedAssertions}/${missionSummary.totalAssertions}`
+          ),
+          plainCell(
+            summarizeMissionDescription(
+              missionSummary.description ?? missionSummary.taskDescription
+            )
+          )
+        ])
+      );
+    } catch (error) {
+      if (interrupted && isAbortError(error)) {
+        throw new CommanderError(130, "mission-list", "");
+      }
+      throw error;
+    } finally {
+      if (typeof unregisterSignalHandler === "function") {
+        unregisterSignalHandler();
+      }
     }
-    const missions = await Promise.all(
-      missionSummaries.map(async (missionSummary) => ({
-        ...missionSummary,
-        description: await resolveMissionDescription(apiClient, missionSummary)
-      }))
-    );
-    renderTable(
-      context.stdout,
-      ["Mission ID", "State", "Created", "Features", "Assertions", "Description"],
-      missions.map((missionSummary) => [
-        plainCell(missionSummary.missionId),
-        coloredCell(
-          formatMissionState(missionSummary.state),
-          missionSummary.state
-        ),
-        plainCell(formatDateTime(missionSummary.createdAt)),
-        plainCell(
-          `${missionSummary.completedFeatures}/${missionSummary.totalFeatures}`
-        ),
-        plainCell(
-          `${missionSummary.passedAssertions}/${missionSummary.totalAssertions}`
-        ),
-        plainCell(summarizeMissionDescription(missionSummary.description))
-      ])
-    );
   });
 }
 
 // src/commands/mission-lifecycle.ts
 import { confirm as defaultConfirmPrompt } from "@inquirer/prompts";
-import { CommanderError } from "commander";
-import pc6 from "picocolors";
+import { CommanderError as CommanderError2 } from "commander";
+import pc7 from "picocolors";
 
 // src/monitor.ts
 import { setTimeout as delay2 } from "timers/promises";
 import ora from "ora";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 import WebSocket from "ws";
 
 // src/state.ts
@@ -1641,7 +1709,7 @@ import {
   input as defaultInputPrompt,
   select as defaultSelectPrompt
 } from "@inquirer/prompts";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 var TRIAGE_PROGRESS_PAGE_SIZE = 200;
 var AUTO_DISMISS_RATIONALE = "Auto-dismissed by `hz mission run --yes`.";
 function isRecord3(value) {
@@ -1725,48 +1793,63 @@ function normalizeProgressEvent(value) {
   };
 }
 async function defaultPromptSelect(options) {
-  return defaultSelectPrompt({
-    choices: options.choices.map((choice) => ({
-      description: choice.description,
-      name: choice.name,
-      value: choice.value
-    })),
-    message: options.message
-  });
+  return defaultSelectPrompt(
+    {
+      choices: options.choices.map((choice) => ({
+        description: choice.description,
+        name: choice.name,
+        value: choice.value
+      })),
+      message: options.message
+    },
+    { signal: options.signal }
+  );
 }
 async function defaultPromptInput(options) {
-  return defaultInputPrompt({
-    default: options.default,
-    message: options.message
-  });
+  return defaultInputPrompt(
+    {
+      default: options.default,
+      message: options.message
+    },
+    { signal: options.signal }
+  );
 }
 function buildIssueId(featureId) {
   return `triage:${featureId}`;
 }
-async function fetchTriageFeatures(apiClient, missionId) {
+function throwIfInterrupted(signal) {
+  if (signal?.aborted) {
+    throw new CliError("Triage interrupted.", 130);
+  }
+}
+async function fetchTriageFeatures(apiClient, missionId, signal) {
   const response = await apiClient.request({
-    path: `/missions/${missionId}/features`
+    path: `/missions/${missionId}/features`,
+    signal
   });
   if (!Array.isArray(response)) {
     throw new CliError("Mission features response was not an array.");
   }
   return response.map((feature) => normalizeFeature(feature));
 }
-async function fetchAssertions(apiClient, missionId) {
+async function fetchAssertions(apiClient, missionId, signal) {
   const response = await apiClient.request({
-    path: `/missions/${missionId}/assertions`
+    path: `/missions/${missionId}/assertions`,
+    signal
   });
   if (!Array.isArray(response)) {
     throw new CliError("Mission assertions response was not an array.");
   }
   return response.map((assertion) => normalizeAssertion(assertion));
 }
-async function fetchLatestTriageEvents(apiClient, missionId) {
+async function fetchLatestTriageEvents(apiClient, missionId, signal) {
   const eventsByFeature = /* @__PURE__ */ new Map();
   let since = 0;
   for (; ; ) {
+    throwIfInterrupted(signal);
     const response = await apiClient.request({
-      path: `/missions/${missionId}/progress?since=${since}&limit=${TRIAGE_PROGRESS_PAGE_SIZE}`
+      path: `/missions/${missionId}/progress?since=${since}&limit=${TRIAGE_PROGRESS_PAGE_SIZE}`,
+      signal
     });
     if (!Array.isArray(response) || response.length === 0) {
       break;
@@ -1856,7 +1939,7 @@ function buildTriageItem(feature, allAssertions, suggestedActionsByFeature) {
 }
 function writeItemBlock(stdout, item) {
   writeLine(stdout);
-  writeLine(stdout, pc3.bold(`Triage required for ${pc3.cyan(item.feature.id)}`));
+  writeLine(stdout, pc4.bold(`Triage required for ${pc4.cyan(item.feature.id)}`));
   writeLine(stdout, `Failure: ${item.failureDescription}`);
   writeLine(
     stdout,
@@ -1930,11 +2013,12 @@ function toFixFeaturePayload(item, features) {
     verificationSteps: item.feature.verificationSteps.length > 0 ? [...item.feature.verificationSteps] : [`Verify that ${item.feature.id} no longer requires triage.`]
   };
 }
-async function dismissItem(apiClient, missionId, item, rationale) {
+async function dismissItem(apiClient, missionId, item, rationale, signal) {
   const trimmedRationale = rationale.trim();
   if (trimmedRationale.length === 0) {
     throw new CliError("Dismissal rationale is required.");
   }
+  throwIfInterrupted(signal);
   await apiClient.request({
     body: {
       items: [
@@ -1945,19 +2029,22 @@ async function dismissItem(apiClient, missionId, item, rationale) {
       ]
     },
     method: "POST",
-    path: `/missions/${missionId}/triage/dismiss`
+    path: `/missions/${missionId}/triage/dismiss`,
+    signal
   });
 }
-async function createFixFeature(apiClient, missionId, item, features) {
+async function createFixFeature(apiClient, missionId, item, features, signal) {
   const feature = toFixFeaturePayload(item, features);
+  throwIfInterrupted(signal);
   await apiClient.request({
     body: { feature },
     method: "POST",
-    path: `/missions/${missionId}/triage/create-fix`
+    path: `/missions/${missionId}/triage/create-fix`,
+    signal
   });
   return feature;
 }
-async function reassignAssertions(apiClient, missionId, item, features, promptSelect) {
+async function reassignAssertions(apiClient, missionId, item, features, promptSelect, signal) {
   if (item.assertions.length === 0) {
     return 0;
   }
@@ -1971,9 +2058,11 @@ async function reassignAssertions(apiClient, missionId, item, features, promptSe
   }
   const moves = [];
   for (const assertion of item.assertions) {
+    throwIfInterrupted(signal);
     const targetFeatureId = await promptSelect({
       choices: destinationChoices,
-      message: `Move ${assertion.id} to which feature?`
+      message: `Move ${assertion.id} to which feature?`,
+      signal
     });
     const targetFeature = features.find((feature) => feature.id === targetFeatureId);
     const targetMilestone = targetFeature?.milestone ?? assertion.milestone ?? item.feature.milestone;
@@ -1991,149 +2080,174 @@ async function reassignAssertions(apiClient, missionId, item, features, promptSe
   if (moves.length === 0) {
     return 0;
   }
+  throwIfInterrupted(signal);
   await apiClient.request({
     body: { moves },
     method: "POST",
-    path: `/missions/${missionId}/triage/reassign-assertions`
+    path: `/missions/${missionId}/triage/reassign-assertions`,
+    signal
   });
   return moves.length;
 }
 async function runTriageInteraction(options) {
   const promptSelect = options.promptSelect ?? defaultPromptSelect;
   const promptInput = options.promptInput ?? defaultPromptInput;
-  const [features, assertions, suggestedActionsByFeature] = await Promise.all([
-    fetchTriageFeatures(options.apiClient, options.missionId),
-    fetchAssertions(options.apiClient, options.missionId),
-    fetchLatestTriageEvents(options.apiClient, options.missionId)
-  ]);
-  const triageItems = features.filter((feature) => feature.status === "needs_triage").map((feature) => buildTriageItem(feature, assertions, suggestedActionsByFeature));
-  if (triageItems.length === 0) {
-    writeLine(options.stdout, pc3.dim("No outstanding triage items were found."));
-    return {
+  try {
+    throwIfInterrupted(options.signal);
+    const [features, assertions, suggestedActionsByFeature] = await Promise.all([
+      fetchTriageFeatures(options.apiClient, options.missionId, options.signal),
+      fetchAssertions(options.apiClient, options.missionId, options.signal),
+      fetchLatestTriageEvents(options.apiClient, options.missionId, options.signal)
+    ]);
+    throwIfInterrupted(options.signal);
+    const triageItems = features.filter((feature) => feature.status === "needs_triage").map((feature) => buildTriageItem(feature, assertions, suggestedActionsByFeature));
+    if (triageItems.length === 0) {
+      writeLine(options.stdout, pc4.dim("No outstanding triage items were found."));
+      return {
+        createdFixes: 0,
+        dismissed: 0,
+        handledFeatureIds: [],
+        movedAssertions: 0,
+        skipped: 0,
+        totalItems: 0
+      };
+    }
+    if (options.autoApprove) {
+      writeLine(
+        options.stdout,
+        pc4.yellow(
+          `Auto-dismissing triage items: ${triageItems.map((item) => item.feature.id).join(", ")}`
+        )
+      );
+      throwIfInterrupted(options.signal);
+      await options.apiClient.request({
+        body: {
+          items: triageItems.map((item) => ({
+            issueId: item.issueId,
+            rationale: AUTO_DISMISS_RATIONALE
+          }))
+        },
+        method: "POST",
+        path: `/missions/${options.missionId}/triage/dismiss`,
+        signal: options.signal
+      });
+      return {
+        createdFixes: 0,
+        dismissed: triageItems.length,
+        handledFeatureIds: triageItems.map((item) => item.feature.id),
+        movedAssertions: 0,
+        skipped: 0,
+        totalItems: triageItems.length
+      };
+    }
+    const result = {
       createdFixes: 0,
       dismissed: 0,
       handledFeatureIds: [],
       movedAssertions: 0,
       skipped: 0,
-      totalItems: 0
-    };
-  }
-  if (options.autoApprove) {
-    writeLine(
-      options.stdout,
-      pc3.yellow(
-        `Auto-dismissing triage items: ${triageItems.map((item) => item.feature.id).join(", ")}`
-      )
-    );
-    await options.apiClient.request({
-      body: {
-        items: triageItems.map((item) => ({
-          issueId: item.issueId,
-          rationale: AUTO_DISMISS_RATIONALE
-        }))
-      },
-      method: "POST",
-      path: `/missions/${options.missionId}/triage/dismiss`
-    });
-    return {
-      createdFixes: 0,
-      dismissed: triageItems.length,
-      handledFeatureIds: triageItems.map((item) => item.feature.id),
-      movedAssertions: 0,
-      skipped: 0,
       totalItems: triageItems.length
     };
-  }
-  const result = {
-    createdFixes: 0,
-    dismissed: 0,
-    handledFeatureIds: [],
-    movedAssertions: 0,
-    skipped: 0,
-    totalItems: triageItems.length
-  };
-  const mutableFeatures = [...features];
-  for (const item of triageItems) {
-    writeItemBlock(options.stdout, item);
-    const action = await promptSelect({
-      choices: buildActionChoices(item),
-      message: `Choose triage action for ${item.feature.id}`
-    });
-    switch (action) {
-      case "dismiss": {
-        const rationale = await promptInput({
-          message: `Why are you dismissing triage for ${item.feature.id}?`
-        });
-        await dismissItem(options.apiClient, options.missionId, item, rationale);
-        result.dismissed += 1;
-        writeLine(options.stdout, `Dismissed triage for ${pc3.cyan(item.feature.id)}.`);
-        break;
-      }
-      case "create-fix": {
-        const createdFeature = await createFixFeature(
-          options.apiClient,
-          options.missionId,
-          item,
-          mutableFeatures
-        );
-        mutableFeatures.push({
-          attemptCount: 0,
-          description: createdFeature.description,
-          expectedBehavior: [...createdFeature.expectedBehavior],
-          fulfills: [],
-          id: createdFeature.id,
-          isFixFeature: true,
-          milestone: createdFeature.milestone,
-          preconditions: [...createdFeature.preconditions],
-          skillName: createdFeature.skillName,
-          status: "pending",
-          verificationSteps: [...createdFeature.verificationSteps],
-          workerSessionIds: []
-        });
-        result.createdFixes += 1;
-        writeLine(
-          options.stdout,
-          `Created fix feature ${pc3.cyan(createdFeature.id)} for ${pc3.cyan(item.feature.id)}.`
-        );
-        break;
-      }
-      case "reassign-assertions": {
-        const moved = await reassignAssertions(
-          options.apiClient,
-          options.missionId,
-          item,
-          mutableFeatures,
-          promptSelect
-        );
-        if (moved === 0) {
-          result.skipped += 1;
+    const mutableFeatures = [...features];
+    for (const item of triageItems) {
+      throwIfInterrupted(options.signal);
+      writeItemBlock(options.stdout, item);
+      const action = await promptSelect({
+        choices: buildActionChoices(item),
+        message: `Choose triage action for ${item.feature.id}`,
+        signal: options.signal
+      });
+      throwIfInterrupted(options.signal);
+      switch (action) {
+        case "dismiss": {
+          const rationale = await promptInput({
+            message: `Why are you dismissing triage for ${item.feature.id}?`,
+            signal: options.signal
+          });
+          await dismissItem(
+            options.apiClient,
+            options.missionId,
+            item,
+            rationale,
+            options.signal
+          );
+          result.dismissed += 1;
+          writeLine(options.stdout, `Dismissed triage for ${pc4.cyan(item.feature.id)}.`);
+          break;
+        }
+        case "create-fix": {
+          const createdFeature = await createFixFeature(
+            options.apiClient,
+            options.missionId,
+            item,
+            mutableFeatures,
+            options.signal
+          );
+          mutableFeatures.push({
+            attemptCount: 0,
+            description: createdFeature.description,
+            expectedBehavior: [...createdFeature.expectedBehavior],
+            fulfills: [],
+            id: createdFeature.id,
+            isFixFeature: true,
+            milestone: createdFeature.milestone,
+            preconditions: [...createdFeature.preconditions],
+            skillName: createdFeature.skillName,
+            status: "pending",
+            verificationSteps: [...createdFeature.verificationSteps],
+            workerSessionIds: []
+          });
+          result.createdFixes += 1;
           writeLine(
             options.stdout,
-            pc3.yellow(
-              `No assertions were reassigned for ${pc3.cyan(item.feature.id)}.`
-            )
+            `Created fix feature ${pc4.cyan(createdFeature.id)} for ${pc4.cyan(item.feature.id)}.`
           );
           break;
         }
-        result.movedAssertions += moved;
-        writeLine(
-          options.stdout,
-          `Reassigned ${moved} assertion${moved === 1 ? "" : "s"} for ${pc3.cyan(item.feature.id)}.`
-        );
-        break;
+        case "reassign-assertions": {
+          const moved = await reassignAssertions(
+            options.apiClient,
+            options.missionId,
+            item,
+            mutableFeatures,
+            promptSelect,
+            options.signal
+          );
+          if (moved === 0) {
+            result.skipped += 1;
+            writeLine(
+              options.stdout,
+              pc4.yellow(
+                `No assertions were reassigned for ${pc4.cyan(item.feature.id)}.`
+              )
+            );
+            break;
+          }
+          result.movedAssertions += moved;
+          writeLine(
+            options.stdout,
+            `Reassigned ${moved} assertion${moved === 1 ? "" : "s"} for ${pc4.cyan(item.feature.id)}.`
+          );
+          break;
+        }
+        case "skip":
+        default:
+          result.skipped += 1;
+          writeLine(
+            options.stdout,
+            pc4.dim(`Skipped triage for ${item.feature.id}; it will remain unresolved.`)
+          );
+          break;
       }
-      case "skip":
-      default:
-        result.skipped += 1;
-        writeLine(
-          options.stdout,
-          pc3.dim(`Skipped triage for ${item.feature.id}; it will remain unresolved.`)
-        );
-        break;
+      result.handledFeatureIds.push(item.feature.id);
+    }
+    return result;
+  } catch (error) {
+    if (options.signal?.aborted || isInterruptedError(error)) {
+      throw new CliError("Triage interrupted.", 130);
     }
-    result.handledFeatureIds.push(item.feature.id);
+    throw error;
   }
-  return result;
 }
 
 // src/monitor.ts
@@ -2226,7 +2340,19 @@ function formatSummaryLine(summary) {
   return `${summary.completedFeatures}/${summary.totalFeatures} features \xB7 ${summary.passedAssertions}/${summary.totalAssertions} assertions`;
 }
 function formatSpinnerText(missionId, summary) {
-  return `${pc4.cyan(missionId)} ${pc4.bold(summary.state)} \xB7 ${formatSummaryLine(summary)}`;
+  return `${pc5.cyan(missionId)} ${pc5.bold(summary.state)} \xB7 ${formatSummaryLine(summary)}`;
+}
+function shouldShowMilestoneUpdate(status, verbose) {
+  if (verbose) {
+    return true;
+  }
+  return status === "sealed" || status === "completed";
+}
+function shouldShowFeatureUpdate(status, verbose) {
+  if (verbose) {
+    return true;
+  }
+  return status === "completed" || status === "failed" || status === "needs_triage";
 }
 function normalizeSummary(missionId, value) {
   if (!isRecord4(value)) {
@@ -2289,13 +2415,13 @@ function buildBackfillDescription(event) {
   const milestone = asNonEmptyString4(data.milestone);
   const assertionId = asNonEmptyString4(data.assertionId);
   if (featureId) {
-    return `Backfilled ${type} for ${pc4.cyan(featureId)}.`;
+    return `Backfilled ${type} for ${pc5.cyan(featureId)}.`;
   }
   if (assertionId) {
-    return `Backfilled ${type} for ${pc4.cyan(assertionId)}.`;
+    return `Backfilled ${type} for ${pc5.cyan(assertionId)}.`;
   }
   if (milestone) {
-    return `Backfilled ${type} for milestone ${pc4.cyan(milestone)}.`;
+    return `Backfilled ${type} for milestone ${pc5.cyan(milestone)}.`;
   }
   return `Backfilled ${type}.`;
 }
@@ -2334,13 +2460,36 @@ async function fetchSummary(apiClient, missionId) {
   const response = await apiClient.request({
     path: `/missions/${missionId}/progress/summary`
   });
-  return normalizeSummary(missionId, response);
+  const summary = normalizeSummary(missionId, response);
+  try {
+    const authoritativeState = normalizeMissionState(
+      await apiClient.request({
+        path: `/missions/${missionId}/mission/state`
+      })
+    );
+    return {
+      ...summary,
+      completedFeatures: authoritativeState.completedFeatures,
+      currentFeatureId: authoritativeState.currentFeatureId,
+      currentWorkerSessionId: authoritativeState.currentWorkerSessionId,
+      lastEventAt: authoritativeState.updatedAt,
+      state: authoritativeState.state,
+      passedAssertions: authoritativeState.passedAssertions,
+      sealedMilestones: authoritativeState.sealedMilestones,
+      totalAssertions: authoritativeState.totalAssertions,
+      totalFeatures: authoritativeState.totalFeatures,
+      totalMilestones: authoritativeState.totalMilestones
+    };
+  } catch {
+    return summary;
+  }
 }
 async function monitorMission(options) {
   const createSpinner = options.createSpinner ?? defaultCreateSpinner;
   const createWebSocket = options.createWebSocket ?? defaultCreateWebSocket;
   const registerSignalHandler = options.registerSignalHandler ?? defaultRegisterSignalHandler;
   const sleep = options.sleep ?? ((ms) => delay2(ms).then(() => void 0));
+  const verbose = options.verbose === true;
   let summary = await fetchSummary(options.apiClient, options.missionId);
   let lastSeen = summary.head;
   let pausedForBudget = false;
@@ -2348,7 +2497,9 @@ async function monitorMission(options) {
   let reconnectAttempt = 0;
   let connectedOnce = false;
   let interrupted = false;
+  let interruptionReported = false;
   let triageInFlight = false;
+  const interruptionController = new AbortController();
   let activeSocket = null;
   let settleActiveConnection = null;
   let startInFlight = false;
@@ -2356,7 +2507,7 @@ async function monitorMission(options) {
   spinner.start();
   writeLine(
     options.stdout,
-    `Monitoring mission ${pc4.cyan(options.missionId)} \xB7 ${formatSummaryLine(summary)}`
+    `Monitoring mission ${pc5.cyan(options.missionId)} \xB7 ${formatSummaryLine(summary)}`
   );
   const updateSpinner = () => {
     spinner.text = formatSpinnerText(options.missionId, summary);
@@ -2371,7 +2522,7 @@ async function monitorMission(options) {
     await refreshSummary();
     const message = `Mission completed \xB7 ${formatSummaryLine(summary)}`;
     spinner.succeed(message);
-    writeLine(options.stdout, pc4.green(message));
+    writeLine(options.stdout, pc5.green(message));
     return {
       exitCode: 0,
       reason: "completed",
@@ -2383,7 +2534,7 @@ async function monitorMission(options) {
     await refreshSummary();
     const message = `Budget exceeded \xB7 ${formatBudgetUsage(details)}`;
     spinner.fail(message);
-    writeLine(options.stdout, pc4.red(message));
+    writeLine(options.stdout, pc5.red(message));
     return {
       exitCode: 1,
       reason: "budget_exceeded",
@@ -2402,21 +2553,27 @@ async function monitorMission(options) {
         missionId: options.missionId,
         promptInput: options.promptInput,
         promptSelect: options.promptSelect,
+        signal: interruptionController.signal,
         stdout: options.stdout
       });
       if (triageResult.totalItems === 0) {
         writeLine(
           options.stdout,
-          pc4.dim("No triage items required action. Resuming the orchestration loop.")
+          pc5.dim("No triage items required action. Resuming the orchestration loop.")
         );
       } else {
         writeLine(
           options.stdout,
-          pc4.green(
+          pc5.green(
             `Triage complete \xB7 ${triageResult.dismissed} dismissed \xB7 ${triageResult.createdFixes} fix features \xB7 ${triageResult.movedAssertions} assertions moved \xB7 ${triageResult.skipped} skipped`
           )
         );
       }
+    } catch (error) {
+      if (interrupted && error instanceof CliError && error.exitCode === 130) {
+        return interruptedResult();
+      }
+      throw error;
     } finally {
       triageInFlight = false;
       pausedForTriage = false;
@@ -2425,11 +2582,14 @@ async function monitorMission(options) {
     return maybeAutoStart();
   };
   const interruptedResult = () => {
-    spinner.fail("Monitoring stopped.");
-    writeLine(
-      options.stdout,
-      pc4.yellow("Interrupted. Local state is saved. Remote mission continues.")
-    );
+    if (!interruptionReported) {
+      interruptionReported = true;
+      spinner.fail("Monitoring stopped.");
+      writeLine(
+        options.stdout,
+        pc5.yellow("Interrupted. Local state is saved. Remote mission continues.")
+      );
+    }
     return {
       exitCode: 130,
       reason: "interrupted",
@@ -2445,16 +2605,20 @@ async function monitorMission(options) {
       const result = await startMission(options.apiClient, options.missionId);
       switch (result.type) {
         case "dispatched":
-          writeLine(
-            options.stdout,
-            `Dispatching ${pc4.cyan(result.featureId)} (${pc4.dim(result.workerSessionId)}).`
-          );
+          if (verbose) {
+            writeLine(
+              options.stdout,
+              `Dispatching ${pc5.cyan(result.featureId)} (${pc5.dim(result.workerSessionId)}).`
+            );
+          }
           return null;
         case "no_work":
-          writeLine(
-            options.stdout,
-            pc4.dim("No eligible work is available yet. Waiting for updates.")
-          );
+          if (verbose) {
+            writeLine(
+              options.stdout,
+              pc5.dim("No eligible work is available yet. Waiting for updates.")
+            );
+          }
           return null;
         case "completed":
           return completedResult();
@@ -2467,6 +2631,9 @@ async function monitorMission(options) {
   };
   const unregisterSignalHandler = registerSignalHandler("SIGINT", () => {
     interrupted = true;
+    if (!interruptionController.signal.aborted) {
+      interruptionController.abort();
+    }
     safeCloseSocket(activeSocket, 1e3, "SIGINT");
     settleActiveConnection?.(interruptedResult());
   });
@@ -2492,12 +2659,14 @@ async function monitorMission(options) {
         }
         const delayMs2 = toReconnectDelay(reconnectAttempt);
         reconnectAttempt += 1;
-        writeLine(
-          options.stdout,
-          pc4.yellow(
-            `WebSocket connection failed: ${error instanceof Error ? error.message : String(error)}. Reconnecting in ${delayMs2} ms...`
-          )
-        );
+        if (verbose) {
+          writeLine(
+            options.stdout,
+            pc5.yellow(
+              `WebSocket connection failed: ${error instanceof Error ? error.message : String(error)}. Reconnecting in ${delayMs2} ms...`
+            )
+          );
+        }
         await sleep(delayMs2);
         continue;
       }
@@ -2529,7 +2698,9 @@ async function monitorMission(options) {
             switch (type) {
               case "state_changed": {
                 const state = asNonEmptyString4(data.state) ?? "unknown";
-                writeLine(options.stdout, `Mission state \u2192 ${pc4.cyan(state)}`);
+                if (verbose) {
+                  writeLine(options.stdout, `Mission state \u2192 ${pc5.cyan(state)}`);
+                }
                 await refreshSummary();
                 if (state === "completed") {
                   return completedResult();
@@ -2545,40 +2716,48 @@ async function monitorMission(options) {
                 if (status === "needs_triage") {
                   pausedForTriage = true;
                 }
-                writeLine(
-                  options.stdout,
-                  `Feature ${pc4.cyan(featureId)} \u2192 ${pc4.bold(status)}`
-                );
+                if (shouldShowFeatureUpdate(status, verbose)) {
+                  writeLine(
+                    options.stdout,
+                    `Feature ${pc5.cyan(featureId)} \u2192 ${pc5.bold(status)}`
+                  );
+                }
                 await refreshSummary();
                 return null;
               }
               case "milestone_updated": {
                 const milestone = asNonEmptyString4(data.milestone) ?? "milestone";
                 const status = asNonEmptyString4(data.status) ?? "updated";
-                writeLine(
-                  options.stdout,
-                  `Milestone ${pc4.cyan(milestone)} \u2192 ${pc4.bold(status)}`
-                );
+                if (shouldShowMilestoneUpdate(status, verbose)) {
+                  writeLine(
+                    options.stdout,
+                    `Milestone ${pc5.cyan(milestone)} \u2192 ${pc5.bold(status)}`
+                  );
+                }
                 await refreshSummary();
                 return null;
               }
               case "assertion_updated": {
                 const assertionId = asNonEmptyString4(data.assertionId) ?? "assertion";
                 const status = asNonEmptyString4(data.status) ?? "updated";
-                writeLine(
-                  options.stdout,
-                  `Assertion ${pc4.cyan(assertionId)} \u2192 ${pc4.bold(status)}`
-                );
+                if (verbose) {
+                  writeLine(
+                    options.stdout,
+                    `Assertion ${pc5.cyan(assertionId)} \u2192 ${pc5.bold(status)}`
+                  );
+                }
                 await refreshSummary();
                 return null;
               }
               case "handoff_received": {
                 const featureId = asNonEmptyString4(data.featureId) ?? "feature";
                 const status = asNonEmptyString4(data.status) ?? "received";
-                writeLine(
-                  options.stdout,
-                  `Handoff received for ${pc4.cyan(featureId)} (${status}).`
-                );
+                if (verbose) {
+                  writeLine(
+                    options.stdout,
+                    `Handoff received for ${pc5.cyan(featureId)} (${status}).`
+                  );
+                }
                 return null;
               }
               case "triage_needed": {
@@ -2586,8 +2765,8 @@ async function monitorMission(options) {
                 const featureId = asNonEmptyString4(data.featureId) ?? "feature";
                 writeLine(
                   options.stdout,
-                  pc4.yellow(
-                    `Triage is required for ${pc4.cyan(featureId)}. Auto-start is paused.`
+                  pc5.yellow(
+                    `Triage is required for ${pc5.cyan(featureId)}. Auto-start is paused.`
                   )
                 );
                 return completeTriage();
@@ -2596,7 +2775,7 @@ async function monitorMission(options) {
                 const featureId = asNonEmptyString4(data.featureId) ?? "feature";
                 writeLine(
                   options.stdout,
-                  pc4.yellow(`Worker timed out for ${pc4.cyan(featureId)}.`)
+                  pc5.yellow(`Worker timed out for ${pc5.cyan(featureId)}.`)
                 );
                 await refreshSummary();
                 return null;
@@ -2605,7 +2784,7 @@ async function monitorMission(options) {
                 const details = normalizeBudgetDetails(data);
                 writeLine(
                   options.stdout,
-                  pc4.yellow(`Budget warning \xB7 ${formatBudgetUsage(details)}`)
+                  pc5.yellow(`Budget warning \xB7 ${formatBudgetUsage(details)}`)
                 );
                 await refreshSummary();
                 return null;
@@ -2629,23 +2808,27 @@ async function monitorMission(options) {
               safeCloseSocket(socket, 1e3, result.reason);
               resolveOnce(result);
             }).catch((error) => {
-              writeLine(
-                options.stdout,
-                pc4.yellow(
-                  `Monitoring update failed: ${error instanceof Error ? error.message : String(error)}. Reconnecting...`
-                )
-              );
+              if (verbose) {
+                writeLine(
+                  options.stdout,
+                  pc5.yellow(
+                    `Monitoring update failed: ${error instanceof Error ? error.message : String(error)}. Reconnecting...`
+                  )
+                );
+              }
               safeCloseSocket(socket, 1011, "processing_error");
               resolveOnce("reconnect");
             });
           });
           socket.on("error", (error) => {
-            writeLine(
-              options.stdout,
-              pc4.yellow(
-                `WebSocket error: ${error instanceof Error ? error.message : String(error)}`
-              )
-            );
+            if (verbose) {
+              writeLine(
+                options.stdout,
+                pc5.yellow(
+                  `WebSocket error: ${error instanceof Error ? error.message : String(error)}`
+                )
+              );
+            }
             safeCloseSocket(socket, 1011, "socket_error");
           });
           socket.on("close", () => {
@@ -2670,7 +2853,9 @@ async function monitorMission(options) {
                 continue;
               }
               lastSeen = Math.max(lastSeen, asFiniteNumber3(event.seq));
-              writeLine(options.stdout, pc4.dim(buildBackfillDescription(event)));
+              if (verbose) {
+                writeLine(options.stdout, pc5.dim(buildBackfillDescription(event)));
+              }
             }
           }
           connectedOnce = true;
@@ -2692,13 +2877,15 @@ async function monitorMission(options) {
       }
       const delayMs = toReconnectDelay(reconnectAttempt);
       reconnectAttempt += 1;
-      writeLine(
-        options.stdout,
-        pc4.yellow(`Reconnecting to mission updates in ${delayMs} ms...`)
-      );
-      await sleep(delayMs);
-    }
-  } finally {
+      if (verbose) {
+        writeLine(
+          options.stdout,
+          pc5.yellow(`Reconnecting to mission updates in ${delayMs} ms...`)
+        );
+      }
+      await sleep(delayMs);
+    }
+  } finally {
     const unregister = typeof unregisterSignalHandler === "function" ? unregisterSignalHandler : void 0;
     unregister?.();
   }
@@ -2707,7 +2894,7 @@ async function monitorMission(options) {
 // src/commands/mission-id.ts
 import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
 import path3 from "path";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 function asNonEmptyString5(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -2767,7 +2954,7 @@ async function resolveMissionId(missionId, context, command, homeDir) {
   if (detectedMissionId) {
     writeLine(
       context.stdout,
-      `Using the most recent local mission: ${pc5.cyan(detectedMissionId)}`
+      `Using the most recent local mission: ${pc6.cyan(detectedMissionId)}`
     );
     return detectedMissionId;
   }
@@ -2789,14 +2976,46 @@ function asFiniteNumber4(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 async function defaultPromptConfirm(options) {
-  return defaultConfirmPrompt({
-    default: options.default,
-    message: options.message
+  return defaultConfirmPrompt(
+    {
+      default: options.default,
+      message: options.message
+    },
+    { signal: options.signal }
+  );
+}
+function createLifecycleInterruptContext(registerSignalHandler, stdout, message) {
+  const coordinatedRegisterSignalHandler = createSignalHandlerCoordinator(
+    registerSignalHandler
+  );
+  const interruptState = {
+    abortController: new AbortController(),
+    interrupted: false
+  };
+  const unregisterSignalHandler = coordinatedRegisterSignalHandler?.("SIGINT", () => {
+    if (interruptState.interrupted) {
+      return;
+    }
+    interruptState.interrupted = true;
+    if (!interruptState.abortController.signal.aborted) {
+      interruptState.abortController.abort();
+    }
+    writeLine(stdout, pc7.yellow(message));
   });
+  return {
+    interruptState,
+    registerSignalHandler: coordinatedRegisterSignalHandler,
+    unregisterSignalHandler
+  };
+}
+function throwIfInterrupted2(interruptState, commandName) {
+  if (interruptState.interrupted) {
+    throw new CommanderError2(130, commandName, "");
+  }
 }
 function writeSection(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc6.bold(title));
+  writeLine(stdout, pc7.bold(title));
 }
 function summarizeAssertions(assertions) {
   return assertions.reduce(
@@ -2847,19 +3066,20 @@ function renderMissionSnapshot(stdout, snapshot) {
     );
   }
 }
-async function fetchMissionStateRecord(apiClient, missionId) {
+async function fetchMissionStateRecord(apiClient, missionId, signal) {
   return normalizeMissionState(
     await apiClient.request({
-      path: `/missions/${missionId}/mission/state`
+      path: `/missions/${missionId}/mission/state`,
+      signal
     })
   );
 }
-async function fetchMissionSnapshot(apiClient, missionId) {
+async function fetchMissionSnapshot(apiClient, missionId, signal) {
   const [state, features, milestones, assertions] = await Promise.all([
-    fetchMissionStateRecord(apiClient, missionId),
-    apiClient.request({ path: `/missions/${missionId}/features` }).then((value) => normalizeMissionFeatures(value)),
-    apiClient.request({ path: `/missions/${missionId}/milestones` }).then((value) => normalizeMissionMilestones(value)),
-    apiClient.request({ path: `/missions/${missionId}/assertions` }).then((value) => normalizeMissionAssertions(value))
+    fetchMissionStateRecord(apiClient, missionId, signal),
+    apiClient.request({ path: `/missions/${missionId}/features`, signal }).then((value) => normalizeMissionFeatures(value)),
+    apiClient.request({ path: `/missions/${missionId}/milestones`, signal }).then((value) => normalizeMissionMilestones(value)),
+    apiClient.request({ path: `/missions/${missionId}/assertions`, signal }).then((value) => normalizeMissionAssertions(value))
   ]);
   return {
     assertions,
@@ -2885,16 +3105,16 @@ async function createMissionClientContext(context, command, dependencies, homeDi
     homeDir
   };
 }
-async function fetchMissionStateAfterConflict(apiClient, missionId, error) {
+async function fetchMissionStateAfterConflict(apiClient, missionId, error, signal) {
   try {
-    return await fetchMissionStateRecord(apiClient, missionId);
+    return await fetchMissionStateRecord(apiClient, missionId, signal);
   } catch {
     throw error;
   }
 }
-async function fetchMissionSnapshotAfterConflict(apiClient, missionId, error) {
+async function fetchMissionSnapshotAfterConflict(apiClient, missionId, error, signal) {
   try {
-    return await fetchMissionSnapshot(apiClient, missionId);
+    return await fetchMissionSnapshot(apiClient, missionId, signal);
   } catch {
     throw error;
   }
@@ -2949,11 +3169,11 @@ function normalizeMissionDeleteResponse(value) {
 function formatMissionDeleteStatus(status) {
   switch (status) {
     case "success":
-      return pc6.green(status);
+      return pc7.green(status);
     case "failed":
-      return pc6.red(status);
+      return pc7.red(status);
     case "skipped":
-      return pc6.yellow(status);
+      return pc7.yellow(status);
     default:
       return status;
   }
@@ -3022,7 +3242,7 @@ function renderMissionDeleteResponse(stdout, response) {
   if (failedSteps.length > 0) {
     writeLine(
       stdout,
-      pc6.yellow(
+      pc7.yellow(
         `Warning: Mission cleanup completed with cleanup warnings (${failedSteps.length} failed step${failedSteps.length === 1 ? "" : "s"}).`
       )
     );
@@ -3047,39 +3267,58 @@ async function runLifecycleMutation(action, missionIdValue, command, context, de
     dependencies,
     homeDir
   );
+  const {
+    interruptState,
+    unregisterSignalHandler
+  } = createLifecycleInterruptContext(
+    dependencies.registerSignalHandler,
+    context.stdout,
+    "Interrupted. Remote mission state is preserved. Re-run this command to check or retry the lifecycle change."
+  );
   try {
     const response = await apiClient.request({
       body: {},
       method: "POST",
-      path: `/missions/${missionId}/mission/${action}`
+      path: `/missions/${missionId}/mission/${action}`,
+      signal: interruptState.abortController.signal
     });
+    throwIfInterrupted2(interruptState, `mission-${action}`);
     const nextState = asNonEmptyString6(response.state) ?? (action === "pause" ? "paused" : "cancelled");
     if (action === "pause") {
       writeLine(
         context.stdout,
-        `Mission ${pc6.cyan(missionId)} paused. Current state: ${pc6.bold(nextState)}.`
+        `Mission ${pc7.cyan(missionId)} paused. Current state: ${pc7.bold(nextState)}.`
       );
       return;
     }
     writeLine(
       context.stdout,
-      `Mission ${pc6.cyan(missionId)} cancelled. This action is irreversible. Current state: ${pc6.bold(nextState)}.`
+      `Mission ${pc7.cyan(missionId)} cancelled. This action is irreversible. Current state: ${pc7.bold(nextState)}.`
     );
   } catch (error) {
+    if (interruptState.interrupted && isInterruptedError(error)) {
+      throw new CommanderError2(130, `mission-${action}`, "");
+    }
     if (!(error instanceof ApiError) || error.status !== 409) {
       throw error;
     }
     const missionState = await fetchMissionStateAfterConflict(
       apiClient,
       missionId,
-      error
+      error,
+      interruptState.abortController.signal
     );
+    throwIfInterrupted2(interruptState, `mission-${action}`);
     const verb = action === "pause" ? "paused" : "cancelled";
     writeLine(
       context.stdout,
-      `Mission ${pc6.cyan(missionId)} cannot be ${verb} because it is currently ${pc6.bold(missionState.state)}.`
+      `Mission ${pc7.cyan(missionId)} cannot be ${verb} because it is currently ${pc7.bold(missionState.state)}.`
     );
-    throw new CommanderError(1, `mission-${action}`, "");
+    throw new CommanderError2(1, `mission-${action}`, "");
+  } finally {
+    if (typeof unregisterSignalHandler === "function") {
+      unregisterSignalHandler();
+    }
   }
 }
 function buildDeleteConfirmationMessage(missionId, forceDelete) {
@@ -3094,33 +3333,56 @@ function buildDeleteConfirmationMessage(missionId, forceDelete) {
 async function runMissionDelete(missionIdValue, options, command, context, dependencies) {
   const homeDir = resolveMissionCommandHomeDir(context);
   const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
-  if (options.yes !== true) {
-    const confirmed = await (dependencies.promptConfirm ?? defaultPromptConfirm)({
-      default: false,
-      message: buildDeleteConfirmationMessage(missionId, options.force === true)
-    });
-    if (!confirmed) {
-      writeLine(context.stdout, pc6.yellow("Mission deletion cancelled."));
-      return;
-    }
-  }
-  const { apiClient } = await createMissionClientContext(
-    context,
-    command,
-    dependencies,
-    homeDir
-  );
-  const query = options.force === true ? "?force=true" : "";
-  const response = normalizeMissionDeleteResponse(
-    await apiClient.request({
-      method: "DELETE",
-      path: `/missions/${missionId}${query}`
-    })
+  const {
+    interruptState,
+    unregisterSignalHandler
+  } = createLifecycleInterruptContext(
+    dependencies.registerSignalHandler,
+    context.stdout,
+    "Interrupted. Remote mission state is preserved. Mission deletion was not attempted."
   );
-  if (!response.deleted) {
-    throw new CliError(`Mission ${missionId} was not deleted.`, 1);
+  try {
+    if (options.yes !== true) {
+      const confirmed = await (dependencies.promptConfirm ?? defaultPromptConfirm)({
+        default: false,
+        message: buildDeleteConfirmationMessage(missionId, options.force === true),
+        signal: interruptState.abortController.signal
+      });
+      throwIfInterrupted2(interruptState, "mission-delete");
+      if (!confirmed) {
+        writeLine(context.stdout, pc7.yellow("Mission deletion cancelled."));
+        return;
+      }
+    }
+    const { apiClient } = await createMissionClientContext(
+      context,
+      command,
+      dependencies,
+      homeDir
+    );
+    const query = options.force === true ? "?force=true" : "";
+    const response = normalizeMissionDeleteResponse(
+      await apiClient.request({
+        method: "DELETE",
+        path: `/missions/${missionId}${query}`,
+        signal: interruptState.abortController.signal
+      })
+    );
+    throwIfInterrupted2(interruptState, "mission-delete");
+    if (!response.deleted) {
+      throw new CliError(`Mission ${missionId} was not deleted.`, 1);
+    }
+    renderMissionDeleteResponse(context.stdout, response);
+  } catch (error) {
+    if (interruptState.interrupted && isInterruptedError(error)) {
+      throw new CommanderError2(130, "mission-delete", "");
+    }
+    throw error;
+  } finally {
+    if (typeof unregisterSignalHandler === "function") {
+      unregisterSignalHandler();
+    }
   }
-  renderMissionDeleteResponse(context.stdout, response);
 }
 function resolveResumeExitCode(state) {
   switch (state) {
@@ -3154,66 +3416,99 @@ async function runMissionResume(missionIdValue, command, context, dependencies)
     dependencies,
     homeDir
   );
-  let snapshot = await fetchMissionSnapshot(apiClient, missionId);
-  if (snapshot.state.state === "paused") {
-    try {
-      const response = await apiClient.request({
-        body: {},
-        method: "POST",
-        path: `/missions/${missionId}/mission/resume`
-      });
-      const nextState = asNonEmptyString6(response.state) ?? "orchestrator_turn";
-      writeLine(
-        context.stdout,
-        `Mission ${pc6.cyan(missionId)} resumed. Current state: ${pc6.bold(nextState)}.`
-      );
-    } catch (error) {
-      if (!(error instanceof ApiError) || error.status !== 409) {
-        throw error;
+  const lifecycleSignals = createLifecycleInterruptContext(
+    dependencies.registerSignalHandler,
+    context.stdout,
+    "Interrupted. Remote mission continues. Re-run this command to reconnect when ready."
+  );
+  try {
+    let snapshot = await fetchMissionSnapshot(
+      apiClient,
+      missionId,
+      lifecycleSignals.interruptState.abortController.signal
+    );
+    throwIfInterrupted2(lifecycleSignals.interruptState, "mission-resume");
+    if (snapshot.state.state === "paused") {
+      try {
+        const response = await apiClient.request({
+          body: {},
+          method: "POST",
+          path: `/missions/${missionId}/mission/resume`,
+          signal: lifecycleSignals.interruptState.abortController.signal
+        });
+        throwIfInterrupted2(lifecycleSignals.interruptState, "mission-resume");
+        const nextState = asNonEmptyString6(response.state) ?? "orchestrator_turn";
+        writeLine(
+          context.stdout,
+          `Mission ${pc7.cyan(missionId)} resumed. Current state: ${pc7.bold(nextState)}.`
+        );
+      } catch (error) {
+        if (lifecycleSignals.interruptState.interrupted && isInterruptedError(error)) {
+          throw new CommanderError2(130, "mission-resume", "");
+        }
+        if (!(error instanceof ApiError) || error.status !== 409) {
+          throw error;
+        }
+        snapshot = await fetchMissionSnapshotAfterConflict(
+          apiClient,
+          missionId,
+          error,
+          lifecycleSignals.interruptState.abortController.signal
+        );
+        throwIfInterrupted2(lifecycleSignals.interruptState, "mission-resume");
+        writeLine(
+          context.stdout,
+          `Mission ${pc7.cyan(missionId)} is currently ${pc7.bold(snapshot.state.state)}. Reconnecting to live updates if available.`
+        );
       }
-      snapshot = await fetchMissionSnapshotAfterConflict(
+      snapshot = await fetchMissionSnapshot(
         apiClient,
         missionId,
-        error
+        lifecycleSignals.interruptState.abortController.signal
       );
+      throwIfInterrupted2(lifecycleSignals.interruptState, "mission-resume");
+    } else if (snapshot.state.state !== "cancelled" && snapshot.state.state !== "completed") {
       writeLine(
         context.stdout,
-        `Mission ${pc6.cyan(missionId)} is currently ${pc6.bold(snapshot.state.state)}. Reconnecting to live updates if available.`
+        `Reconnecting to mission ${pc7.cyan(missionId)} from state ${pc7.bold(snapshot.state.state)}.`
       );
     }
-    snapshot = await fetchMissionSnapshot(apiClient, missionId);
-  } else if (snapshot.state.state !== "cancelled" && snapshot.state.state !== "completed") {
-    writeLine(
-      context.stdout,
-      `Reconnecting to mission ${pc6.cyan(missionId)} from state ${pc6.bold(snapshot.state.state)}.`
-    );
-  }
-  renderMissionSnapshot(context.stdout, snapshot);
-  const resumeExitCode = resolveResumeExitCode(snapshot.state.state);
-  if (resumeExitCode === 0) {
-    return;
-  }
-  if (resumeExitCode === 1) {
-    throw new CliError(
-      `Mission ${missionId} is currently ${snapshot.state.state}.`,
-      1
-    );
-  }
-  const monitorResult = await monitorMission({
-    apiClient,
-    apiKey: authConfig.apiKey,
-    createSpinner: dependencies.createSpinner,
-    createWebSocket: dependencies.createWebSocket,
-    endpoint: authConfig.endpoint,
-    missionId,
-    promptInput: dependencies.promptInput,
-    promptSelect: dependencies.promptSelect,
-    registerSignalHandler: dependencies.registerSignalHandler,
-    sleep: dependencies.sleep,
-    stdout: context.stdout
-  });
-  if (monitorResult.exitCode !== 0) {
-    throw new CommanderError(monitorResult.exitCode, "mission-monitor", "");
+    renderMissionSnapshot(context.stdout, snapshot);
+    const resumeExitCode = resolveResumeExitCode(snapshot.state.state);
+    if (resumeExitCode === 0) {
+      return;
+    }
+    if (resumeExitCode === 1) {
+      throw new CliError(
+        `Mission ${missionId} is currently ${snapshot.state.state}.`,
+        1
+      );
+    }
+    const monitorResult = await monitorMission({
+      apiClient,
+      apiKey: authConfig.apiKey,
+      createSpinner: dependencies.createSpinner,
+      createWebSocket: dependencies.createWebSocket,
+      endpoint: authConfig.endpoint,
+      missionId,
+      promptInput: dependencies.promptInput,
+      promptSelect: dependencies.promptSelect,
+      registerSignalHandler: lifecycleSignals.registerSignalHandler,
+      sleep: dependencies.sleep,
+      stdout: context.stdout
+    });
+    if (monitorResult.exitCode !== 0) {
+      throw new CommanderError2(monitorResult.exitCode, "mission-monitor", "");
+    }
+  } catch (error) {
+    if (lifecycleSignals.interruptState.interrupted && isInterruptedError(error)) {
+      throw new CommanderError2(130, "mission-resume", "");
+    }
+    throw error;
+  } finally {
+    if (typeof lifecycleSignals.unregisterSignalHandler === "function") {
+      lifecycleSignals.unregisterSignalHandler();
+    }
   }
 }
 async function runMissionWatch(missionIdValue, command, context, dependencies) {
@@ -3225,37 +3520,58 @@ async function runMissionWatch(missionIdValue, command, context, dependencies) {
     dependencies,
     homeDir
   );
-  const snapshot = await fetchMissionSnapshot(apiClient, missionId);
-  writeLine(
+  const lifecycleSignals = createLifecycleInterruptContext(
+    dependencies.registerSignalHandler,
     context.stdout,
-    `Watching mission ${pc6.cyan(missionId)} from state ${pc6.bold(snapshot.state.state)}.`
+    "Interrupted. Remote mission continues. Re-run this command to reconnect when ready."
   );
-  renderMissionSnapshot(context.stdout, snapshot);
-  const watchExitCode = resolveWatchExitCode(snapshot.state.state);
-  if (watchExitCode === 0) {
-    return;
-  }
-  if (watchExitCode === 1) {
-    throw new CliError(
-      `Mission ${missionId} is currently ${snapshot.state.state}.`,
-      1
+  try {
+    const snapshot = await fetchMissionSnapshot(
+      apiClient,
+      missionId,
+      lifecycleSignals.interruptState.abortController.signal
     );
-  }
-  const monitorResult = await monitorMission({
-    apiClient,
-    apiKey: authConfig.apiKey,
-    createSpinner: dependencies.createSpinner,
-    createWebSocket: dependencies.createWebSocket,
-    endpoint: authConfig.endpoint,
-    missionId,
-    promptInput: dependencies.promptInput,
-    promptSelect: dependencies.promptSelect,
-    registerSignalHandler: dependencies.registerSignalHandler,
-    sleep: dependencies.sleep,
-    stdout: context.stdout
-  });
-  if (monitorResult.exitCode !== 0) {
-    throw new CommanderError(monitorResult.exitCode, "mission-monitor", "");
+    throwIfInterrupted2(lifecycleSignals.interruptState, "mission-watch");
+    writeLine(
+      context.stdout,
+      `Watching mission ${pc7.cyan(missionId)} from state ${pc7.bold(snapshot.state.state)}.`
+    );
+    renderMissionSnapshot(context.stdout, snapshot);
+    const watchExitCode = resolveWatchExitCode(snapshot.state.state);
+    if (watchExitCode === 0) {
+      return;
+    }
+    if (watchExitCode === 1) {
+      throw new CliError(
+        `Mission ${missionId} is currently ${snapshot.state.state}.`,
+        1
+      );
+    }
+    const monitorResult = await monitorMission({
+      apiClient,
+      apiKey: authConfig.apiKey,
+      createSpinner: dependencies.createSpinner,
+      createWebSocket: dependencies.createWebSocket,
+      endpoint: authConfig.endpoint,
+      missionId,
+      promptInput: dependencies.promptInput,
+      promptSelect: dependencies.promptSelect,
+      registerSignalHandler: lifecycleSignals.registerSignalHandler,
+      sleep: dependencies.sleep,
+      stdout: context.stdout
+    });
+    if (monitorResult.exitCode !== 0) {
+      throw new CommanderError2(monitorResult.exitCode, "mission-monitor", "");
+    }
+  } catch (error) {
+    if (lifecycleSignals.interruptState.interrupted && isInterruptedError(error)) {
+      throw new CommanderError2(130, "mission-watch", "");
+    }
+    throw error;
+  } finally {
+    if (typeof lifecycleSignals.unregisterSignalHandler === "function") {
+      lifecycleSignals.unregisterSignalHandler();
+    }
   }
 }
 function registerMissionLifecycleCommands(mission, context, dependencies = {}) {
@@ -3295,7 +3611,7 @@ function registerMissionLifecycleCommands(mission, context, dependencies = {}) {
 }
 
 // src/commands/mission-resources.ts
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 function isRecord6(value) {
   return value !== null && !Array.isArray(value) && typeof value === "object";
 }
@@ -3344,7 +3660,7 @@ function formatBytes(value) {
 }
 function writeSection2(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc7.bold(title));
+  writeLine(stdout, pc8.bold(title));
 }
 function renderMetricTable(stdout, rows) {
   renderTable(
@@ -3647,7 +3963,7 @@ function registerMissionResourcesCommand(mission, context, dependencies = {}) {
 // src/commands/mission-run.ts
 import { stat as stat3 } from "fs/promises";
 import path7 from "path";
-import { CommanderError as CommanderError2 } from "commander";
+import { CommanderError as CommanderError3 } from "commander";
 
 // src/planning.ts
 import path4 from "path";
@@ -3657,7 +3973,7 @@ import {
   select as defaultSelectPrompt2
 } from "@inquirer/prompts";
 import ora2 from "ora";
-import pc8 from "picocolors";
+import pc9 from "picocolors";
 var DEFAULT_ANALYSIS_TIMEOUT_MS = 5 * 60 * 1e3;
 var DEFAULT_POLL_INTERVAL_MS = 5e3;
 var FREE_TEXT_OPTION_ID = "free_text";
@@ -3670,11 +3986,36 @@ function asNonEmptyString8(value) {
 function asStringArray2(value) {
   return Array.isArray(value) ? value.map((item) => asNonEmptyString8(item)).filter((item) => item !== null) : [];
 }
+function asCodeSnippets(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const snippets = [];
+  const dedupe = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    const snippet = asNonEmptyString8(
+      typeof entry === "string" ? entry : isRecord7(entry) ? entry.snippet ?? entry.code ?? entry.code_evidence ?? entry.content : void 0
+    );
+    if (!snippet) {
+      continue;
+    }
+    const pathValue = isRecord7(entry) ? asNonEmptyString8(entry.path ?? entry.file_path ?? entry.filePath) : null;
+    const key = `${pathValue ?? ""}\0${snippet}`;
+    if (dedupe.has(key)) {
+      continue;
+    }
+    dedupe.add(key);
+    snippets.push(pathValue ? { path: pathValue, snippet } : { snippet });
+  }
+  return snippets;
+}
 function extractQuestions(payload) {
   if (!payload || !Array.isArray(payload.questions)) {
     return [];
   }
   return payload.questions.filter((question) => isRecord7(question)).map((question) => ({
+    codeSnippets: asCodeSnippets(question.codeSnippets ?? question.code_snippets ?? question.snippets),
+    context: asNonEmptyString8(question.context) ?? void 0,
     detailPrompt: asNonEmptyString8(question.detailPrompt) ?? void 0,
     freeTextOptionId: asNonEmptyString8(question.freeTextOptionId) ?? void 0,
     id: asNonEmptyString8(question.id) ?? "question",
@@ -3743,6 +4084,54 @@ function extractErrorCode(error) {
 function extractRound(payload) {
   return typeof payload?.round === "number" && Number.isFinite(payload.round) ? payload.round : 1;
 }
+function isAbortError3(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function isAbortPromptError2(error) {
+  return error instanceof Error && error.name === "AbortPromptError";
+}
+function isInterruptedError2(error) {
+  return error instanceof CliError && error.exitCode === 130 || isAbortError3(error) || isAbortPromptError2(error);
+}
+function throwIfInterrupted3(interruption) {
+  if (interruption.interrupted) {
+    throw new CliError("Planning interrupted.", 130);
+  }
+}
+function interruptPlanning(interruption) {
+  if (interruption.interrupted) {
+    return;
+  }
+  interruption.interrupted = true;
+  interruption.activeSpinner?.stop();
+  interruption.activeSpinner = void 0;
+  interruption.releaseActiveWait?.();
+  interruption.releaseActiveWait = void 0;
+  if (!interruption.abortController.signal.aborted) {
+    interruption.abortController.abort();
+  }
+  writeLine(
+    interruption.stdout,
+    pc9.yellow("Interrupted. Re-run this command to resume the planning session.")
+  );
+}
+async function waitForInterruptibleDelay(sleep, ms, interruption) {
+  throwIfInterrupted3(interruption);
+  let resolveWait;
+  await Promise.race([
+    sleep(ms).then(() => {
+      resolveWait?.();
+    }),
+    new Promise((resolve) => {
+      resolveWait = () => resolve();
+      interruption.releaseActiveWait = resolveWait;
+    })
+  ]);
+  if (interruption.releaseActiveWait === resolveWait) {
+    interruption.releaseActiveWait = void 0;
+  }
+  throwIfInterrupted3(interruption);
+}
 function defaultCreateSpinner2(text) {
   const spinner = ora2({ text });
   return {
@@ -3776,66 +4165,96 @@ function defaultCreateSpinner2(text) {
   };
 }
 async function defaultPromptSelect2(options) {
-  return defaultSelectPrompt2({
-    choices: options.choices.map((choice) => ({
-      description: choice.description,
-      name: choice.name,
-      value: choice.value
-    })),
-    message: options.message
-  });
+  return defaultSelectPrompt2(
+    {
+      choices: options.choices.map((choice) => ({
+        description: choice.description,
+        name: choice.name,
+        value: choice.value
+      })),
+      message: options.message
+    },
+    { signal: options.signal }
+  );
 }
 async function defaultPromptInput2(options) {
-  return defaultInputPrompt2({
-    default: options.default,
-    message: options.message
-  });
+  return defaultInputPrompt2(
+    {
+      default: options.default,
+      message: options.message
+    },
+    { signal: options.signal }
+  );
 }
 async function defaultPromptConfirm2(options) {
-  return defaultConfirmPrompt2({
-    default: options.default,
-    message: options.message
-  });
+  return defaultConfirmPrompt2(
+    {
+      default: options.default,
+      message: options.message
+    },
+    { signal: options.signal }
+  );
 }
-async function getPlanningSession(client, sessionId) {
+async function getPlanningSession(client, sessionId, signal) {
   return client.request({
-    path: `/plan/${sessionId}`
+    path: `/plan/${sessionId}`,
+    signal
   });
 }
-async function postClarification(client, sessionId, body) {
+async function postClarification(client, sessionId, signal, body) {
   return client.request({
     body,
     method: "POST",
-    path: `/plan/${sessionId}/clarify`
+    path: `/plan/${sessionId}/clarify`,
+    signal
   });
 }
-async function postMilestoneConfirmation(client, sessionId, body) {
+async function postMilestoneConfirmation(client, sessionId, signal, body) {
   return client.request({
     body,
     method: "POST",
-    path: `/plan/${sessionId}/confirm-milestones`
+    path: `/plan/${sessionId}/confirm-milestones`,
+    signal
   });
 }
-async function postDraftApproval(client, sessionId) {
+async function postDraftApproval(client, sessionId, signal) {
   return client.request({
     method: "POST",
-    path: `/plan/${sessionId}/approve`
+    path: `/plan/${sessionId}/approve`,
+    signal
   });
 }
 function writeSection3(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc8.bold(title));
+  writeLine(stdout, pc9.bold(title));
+}
+function formatInlineSnippet(snippet) {
+  return snippet.replace(/\s+/g, " ").trim();
+}
+function isFreeTextQuestion(question) {
+  return Boolean(question.freeTextOptionId) || !question.options || question.options.length === 0;
 }
 function renderQuestion(stdout, question, index) {
   writeLine(stdout, `${index + 1}. ${question.text}`);
   if (question.references && question.references.length > 0) {
-    writeLine(stdout, `   ${pc8.dim(`References: ${question.references.join(", ")}`)}`);
+    writeLine(stdout, `   ${pc9.dim(`References: ${question.references.join(", ")}`)}`);
+  }
+  if (question.context) {
+    writeLine(stdout, `   ${pc9.dim(`Context: ${question.context}`)}`);
+  }
+  if (question.codeSnippets && question.codeSnippets.length > 0) {
+    writeLine(stdout, `   ${pc9.dim("Code:")}`);
+    for (const codeSnippet of question.codeSnippets) {
+      const renderedSnippet = formatInlineSnippet(codeSnippet.snippet);
+      const label = codeSnippet.path ? `${codeSnippet.path}: ` : "";
+      writeLine(stdout, `   ${label}${renderedSnippet}`);
+    }
   }
 }
 function renderMilestones(stdout, milestones, reviewRound) {
   writeSection3(stdout, `Milestone review round ${reviewRound}`);
   milestones.forEach((milestone, index) => {
-    writeLine(stdout, `${index + 1}. ${pc8.cyan(milestone.name)}`);
+    writeLine(stdout, `${index + 1}. ${pc9.cyan(milestone.name)}`);
     if (milestone.description) {
       writeLine(stdout, `   ${milestone.description}`);
     }
@@ -3923,24 +4342,28 @@ function buildAutoApprovedDetail(question, taskDescription, repoPaths) {
   }
   return `${task}. Use ${repoPhrase} as the source of truth.${references}`;
 }
-async function promptForAnswers(options, questions, round) {
+async function promptForAnswers(options, interruption, questions, round) {
   const promptSelect = options.promptSelect ?? defaultPromptSelect2;
   const promptInput = options.promptInput ?? defaultPromptInput2;
   const answers = [];
   const transcript = [];
   for (const question of questions) {
-    if (question.options && question.options.length > 0) {
+    throwIfInterrupted3(interruption);
+    if (!isFreeTextQuestion(question)) {
+      const selectableOptions = question.options ?? [];
       const autoSelectedOption = options.autoApprove ? pickAutoApprovedOption(question, options.taskDescription, options.repoPaths) : null;
-      const choices = question.options.map((option) => ({
+      const choices = selectableOptions.map((option) => ({
         description: option.description,
         name: option.label,
         value: option.id
       }));
       const optionId2 = autoSelectedOption?.id ?? await promptSelect({
         choices,
-        message: question.text
+        message: question.text,
+        signal: interruption.abortController.signal
       });
-      const selectedOption = question.options.find((option) => option.id === optionId2);
+      throwIfInterrupted3(interruption);
+      const selectedOption = selectableOptions.find((option) => option.id === optionId2);
       answers.push({
         optionId: optionId2,
         questionId: question.id
@@ -3957,9 +4380,11 @@ async function promptForAnswers(options, questions, round) {
     }
     const detail = options.autoApprove ? buildAutoApprovedDetail(question, options.taskDescription, options.repoPaths) : await promptInput({
       default: question.inputDefault,
-      message: question.detailPrompt ?? question.text
+      message: question.detailPrompt ?? question.text,
+      signal: interruption.abortController.signal
     });
-    const optionId = question.freeTextOptionId ?? FREE_TEXT_OPTION_ID;
+    throwIfInterrupted3(interruption);
+    const optionId = FREE_TEXT_OPTION_ID;
     answers.push({
       detail,
       optionId,
@@ -3979,7 +4404,7 @@ async function promptForAnswers(options, questions, round) {
     transcript
   };
 }
-async function waitForAnalysis(options, sessionId) {
+async function waitForAnalysis(options, interruption, sessionId) {
   const createSpinner = options.createSpinner ?? defaultCreateSpinner2;
   const sleep = options.sleep ?? (async (ms) => {
     await new Promise((resolve) => setTimeout(resolve, ms));
@@ -3989,49 +4414,81 @@ async function waitForAnalysis(options, sessionId) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const deadline = now() + timeoutMs;
   const spinner = createSpinner("Analyzing repository for planning...");
+  interruption.activeSpinner = spinner;
   spinner.start();
   try {
-    let session = await getPlanningSession(options.client, sessionId);
+    throwIfInterrupted3(interruption);
+    let session = await getPlanningSession(
+      options.client,
+      sessionId,
+      interruption.abortController.signal
+    );
     while (session.state === "created" || session.state === "analyzing") {
+      throwIfInterrupted3(interruption);
       if (now() >= deadline) {
         spinner.fail("Planning analysis timed out.");
         throw new CliError("Planning analysis timed out after 5 minutes.");
       }
-      await sleep(pollIntervalMs);
-      session = await getPlanningSession(options.client, sessionId);
+      await waitForInterruptibleDelay(sleep, pollIntervalMs, interruption);
+      session = await getPlanningSession(
+        options.client,
+        sessionId,
+        interruption.abortController.signal
+      );
     }
+    throwIfInterrupted3(interruption);
     spinner.succeed("Analysis complete.");
     return session;
   } catch (error) {
+    if (isInterruptedError2(error)) {
+      throw error;
+    }
     if (error instanceof CliError) {
       throw error;
     }
     spinner.fail("Planning analysis failed.");
     throw error;
+  } finally {
+    if (interruption.activeSpinner === spinner) {
+      interruption.activeSpinner = void 0;
+    }
   }
 }
-async function resolveClarification(options, sessionId, initialPayload) {
+async function resolveClarification(options, interruption, sessionId, initialPayload) {
   let payload = initialPayload;
   const localTranscript = [];
   while (payload.state === "clarifying") {
+    throwIfInterrupted3(interruption);
     let questions = extractQuestions(payload);
     let round = extractRound(payload);
     if (questions.length === 0) {
-      payload = await postClarification(options.client, sessionId, {});
+      payload = await postClarification(
+        options.client,
+        sessionId,
+        interruption.abortController.signal,
+        {}
+      );
       questions = extractQuestions(payload);
       round = extractRound(payload);
     }
+    throwIfInterrupted3(interruption);
     if (payload.state !== "clarifying") {
       break;
     }
     writeSection3(options.stdout, `Clarification round ${round}`);
     questions.forEach((question, index) => renderQuestion(options.stdout, question, index));
-    const prompted = await promptForAnswers(options, questions, round);
+    const prompted = await promptForAnswers(options, interruption, questions, round);
     localTranscript.push(...prompted.transcript);
     try {
-      payload = await postClarification(options.client, sessionId, {
-        answers: prompted.answers
-      });
+      throwIfInterrupted3(interruption);
+      payload = await postClarification(
+        options.client,
+        sessionId,
+        interruption.abortController.signal,
+        {
+          answers: prompted.answers
+        }
+      );
     } catch (error) {
       if (extractErrorCode(error) !== "resolvedness_gate_failed") {
         throw error;
@@ -4045,9 +4502,15 @@ async function resolveClarification(options, sessionId, initialPayload) {
       }
       writeLine(
         options.stdout,
-        pc8.yellow("Proceeding because --force is enabled.")
+        pc9.yellow("Proceeding because --force is enabled.")
+      );
+      throwIfInterrupted3(interruption);
+      payload = await postMilestoneConfirmation(
+        options.client,
+        sessionId,
+        interruption.abortController.signal,
+        {}
       );
-      payload = await postMilestoneConfirmation(options.client, sessionId, {});
       return {
         payload,
         persistedClarification: {
@@ -4077,35 +4540,55 @@ async function resolveClarification(options, sessionId, initialPayload) {
     }
   };
 }
-async function resolveMilestones(options, sessionId, initialPayload) {
+async function resolveMilestones(options, interruption, sessionId, initialPayload) {
   let reviewRound = 1;
   let payload = initialPayload;
   if (extractMilestones(payload).length === 0) {
-    payload = await postMilestoneConfirmation(options.client, sessionId, {});
+    payload = await postMilestoneConfirmation(
+      options.client,
+      sessionId,
+      interruption.abortController.signal,
+      {}
+    );
   }
   while (true) {
+    throwIfInterrupted3(interruption);
     const milestones = extractMilestones(payload);
     renderMilestones(options.stdout, milestones, reviewRound);
     const confirmed = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm2)({
       default: true,
-      message: "Do these milestones look correct?"
+      message: "Do these milestones look correct?",
+      signal: interruption.abortController.signal
     });
+    throwIfInterrupted3(interruption);
     if (confirmed) {
-      return postMilestoneConfirmation(options.client, sessionId, {
-        confirmed: true
-      });
+      return postMilestoneConfirmation(
+        options.client,
+        sessionId,
+        interruption.abortController.signal,
+        {
+          confirmed: true
+        }
+      );
     }
     const feedback = await (options.promptInput ?? defaultPromptInput2)({
-      message: "What should change about these milestones?"
-    });
-    payload = await postMilestoneConfirmation(options.client, sessionId, {
-      confirmed: false,
-      feedback
+      message: "What should change about these milestones?",
+      signal: interruption.abortController.signal
     });
+    throwIfInterrupted3(interruption);
+    payload = await postMilestoneConfirmation(
+      options.client,
+      sessionId,
+      interruption.abortController.signal,
+      {
+        confirmed: false,
+        feedback
+      }
+    );
     reviewRound += 1;
   }
 }
-async function resolveDraft(options, sessionId, payload) {
+async function resolveDraft(options, interruption, sessionId, payload) {
   const directDraft = extractDraft(payload);
   if (directDraft) {
     return {
@@ -4113,7 +4596,11 @@ async function resolveDraft(options, sessionId, payload) {
       payload
     };
   }
-  const approvedPayload = await postDraftApproval(options.client, sessionId);
+  const approvedPayload = await postDraftApproval(
+    options.client,
+    sessionId,
+    interruption.abortController.signal
+  );
   const approvedDraft = extractDraft(approvedPayload);
   if (!approvedDraft) {
     throw new CliError("Planner did not return a mission draft.");
@@ -4127,7 +4614,7 @@ async function runPlanningFlow(options) {
   if (options.existingMissionDraft) {
     writeLine(
       options.stdout,
-      pc8.cyan("Skipping planning because mission-draft.json already exists.")
+      pc9.cyan("Skipping planning because mission-draft.json already exists.")
     );
     return {
       cancelled: false,
@@ -4136,69 +4623,113 @@ async function runPlanningFlow(options) {
       skippedPlanning: true
     };
   }
-  const sessionId = asNonEmptyString8(options.existingSessionId) ?? asNonEmptyString8(
-    (await options.client.request({
-      body: {
-        repos: options.repoPaths,
-        task_description: options.taskDescription
-      },
-      method: "POST",
-      path: "/plan/create",
-      timeoutMs: 3e4
-    })).session_id
-  );
-  if (!sessionId) {
-    throw new CliError("Planner did not return a session id.");
-  }
-  if (options.existingSessionId) {
-    writeLine(options.stdout, `Resuming planning session ${sessionId}.`);
-  } else {
-    await options.persistSessionId(sessionId);
-    writeLine(options.stdout, `Created planning session ${sessionId}.`);
-  }
-  let payload = await waitForAnalysis(options, sessionId);
-  if (payload.state === "clarifying") {
-    const clarification = await resolveClarification(options, sessionId, payload);
-    payload = clarification.payload;
-    if (clarification.persistedClarification) {
-      await options.persistClarification(clarification.persistedClarification);
+  const interruption = {
+    abortController: new AbortController(),
+    interrupted: false,
+    stdout: options.stdout
+  };
+  let sessionId = asNonEmptyString8(options.existingSessionId) ?? "";
+  const unregisterSignalHandler = options.registerSignalHandler?.("SIGINT", () => {
+    interruptPlanning(interruption);
+  });
+  try {
+    sessionId = sessionId || asNonEmptyString8(
+      (await options.client.request({
+        body: {
+          repos: options.repoPaths,
+          task_description: options.taskDescription
+        },
+        method: "POST",
+        path: "/plan/create",
+        signal: interruption.abortController.signal,
+        timeoutMs: 3e4
+      })).session_id
+    ) || "";
+    if (!sessionId) {
+      throw new CliError("Planner did not return a session id.");
     }
-  }
-  if (payload.state === "confirming") {
-    payload = await resolveMilestones(options, sessionId, payload);
-  }
-  if (payload.state !== "complete") {
-    throw new CliError(
-      `Planner returned an unexpected state after milestone confirmation: ${payload.state ?? "unknown"}.`
+    if (options.existingSessionId) {
+      writeLine(options.stdout, `Resuming planning session ${sessionId}.`);
+    } else {
+      await options.persistSessionId(sessionId);
+      throwIfInterrupted3(interruption);
+      writeLine(options.stdout, `Created planning session ${sessionId}.`);
+    }
+    let payload = await waitForAnalysis(options, interruption, sessionId);
+    throwIfInterrupted3(interruption);
+    if (payload.state === "clarifying") {
+      const clarification = await resolveClarification(
+        options,
+        interruption,
+        sessionId,
+        payload
+      );
+      payload = clarification.payload;
+      throwIfInterrupted3(interruption);
+      if (clarification.persistedClarification) {
+        await options.persistClarification(clarification.persistedClarification);
+        throwIfInterrupted3(interruption);
+      }
+    }
+    throwIfInterrupted3(interruption);
+    if (payload.state === "confirming") {
+      payload = await resolveMilestones(options, interruption, sessionId, payload);
+    }
+    throwIfInterrupted3(interruption);
+    if (payload.state !== "complete") {
+      throw new CliError(
+        `Planner returned an unexpected state after milestone confirmation: ${payload.state ?? "unknown"}.`
+      );
+    }
+    const { draft, payload: summaryPayload } = await resolveDraft(
+      options,
+      interruption,
+      sessionId,
+      payload
     );
-  }
-  const { draft, payload: summaryPayload } = await resolveDraft(
-    options,
-    sessionId,
-    payload
-  );
-  renderDraftSummary(options.stdout, summaryPayload, draft);
-  const approved = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm2)({
-    default: true,
-    message: "Approve this draft and continue to upload?"
-  });
-  if (!approved) {
-    writeLine(options.stdout, pc8.yellow("Planning cancelled before upload."));
+    throwIfInterrupted3(interruption);
+    renderDraftSummary(options.stdout, summaryPayload, draft);
+    const approved = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm2)({
+      default: true,
+      message: "Approve this draft and continue to upload?",
+      signal: interruption.abortController.signal
+    });
+    throwIfInterrupted3(interruption);
+    if (!approved) {
+      writeLine(options.stdout, pc9.yellow("Planning cancelled before upload."));
+      return {
+        cancelled: true,
+        draft,
+        sessionId,
+        skippedPlanning: false
+      };
+    }
+    await options.persistMissionDraft(draft);
+    throwIfInterrupted3(interruption);
+    writeLine(options.stdout, pc9.green("Saved approved mission draft."));
     return {
-      cancelled: true,
+      cancelled: false,
       draft,
       sessionId,
       skippedPlanning: false
     };
+  } catch (error) {
+    if (interruption.interrupted && isInterruptedError2(error)) {
+      return {
+        cancelled: false,
+        draft: null,
+        exitCode: 130,
+        interrupted: true,
+        sessionId,
+        skippedPlanning: false
+      };
+    }
+    throw error;
+  } finally {
+    if (typeof unregisterSignalHandler === "function") {
+      unregisterSignalHandler();
+    }
   }
-  await options.persistMissionDraft(draft);
-  writeLine(options.stdout, pc8.green("Saved approved mission draft."));
-  return {
-    cancelled: false,
-    draft,
-    sessionId,
-    skippedPlanning: false
-  };
 }
 
 // src/upload.ts
@@ -4207,7 +4738,7 @@ import { createReadStream as createReadStream2 } from "fs";
 import path6 from "path";
 import { Transform as Transform2 } from "stream";
 import ora3 from "ora";
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 
 // src/snapshot.ts
 import { execFile } from "child_process";
@@ -4645,10 +5176,16 @@ async function writeDeterministicArchive(analysis, outputDir) {
   const tempArchivePath = `${finalArchivePath}.${process.pid}.${Date.now()}.tmp`;
   const archiveHash = createHash2("sha256");
   let archiveBytes = 0;
-  const meter = new Transform({
+  const archiveHashMeter = new Transform({
     transform(chunk, _encoding, callback) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       archiveHash.update(buffer);
+      callback(null, buffer);
+    }
+  });
+  const outputMeter = new Transform({
+    transform(chunk, _encoding, callback) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       archiveBytes += buffer.length;
       callback(null, buffer);
     }
@@ -4680,8 +5217,9 @@ async function writeDeterministicArchive(analysis, outputDir) {
   try {
     await pipeline(
       tarStream,
+      archiveHashMeter,
       createZstdCompress(),
-      meter,
+      outputMeter,
       createWriteStream(tempArchivePath, { mode: 384 })
     );
     await rename3(tempArchivePath, finalArchivePath);
@@ -4759,8 +5297,41 @@ async function defaultPromptConfirm3(options) {
   return confirm({
     default: options.default,
     message: options.message
+  }, {
+    signal: options.signal
   });
 }
+function isAbortError4(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function isAbortPromptError3(error) {
+  return error instanceof Error && error.name === "AbortPromptError";
+}
+function isInterruptedError3(error) {
+  return error instanceof CliError && error.exitCode === 130 || isAbortError4(error) || isAbortPromptError3(error);
+}
+function throwIfInterrupted4(interruption) {
+  if (interruption.interrupted) {
+    throw new CliError("Upload interrupted.", 130);
+  }
+}
+function interruptUpload(interruption) {
+  if (interruption.interrupted) {
+    return;
+  }
+  interruption.interrupted = true;
+  interruption.activeSpinner?.stop();
+  interruption.activeSpinner = void 0;
+  if (!interruption.abortController.signal.aborted) {
+    interruption.abortController.abort();
+  }
+  writeLine(
+    interruption.stdout,
+    pc10.yellow(
+      "Interrupted. Local upload state is saved and any remote launch is preserved. Re-run this command to resume the upload."
+    )
+  );
+}
 function formatBytes2(bytes) {
   if (!Number.isFinite(bytes) || bytes < 1024) {
     return `${bytes} B`;
@@ -4804,15 +5375,15 @@ function isTerminalUploadStatus2(status) {
   return status === "uploaded" || status === "blob_exists";
 }
 function renderSafetyGate(stdout, repos, existingBlobs) {
-  writeLine(stdout, pc9.bold("Upload safety check"));
+  writeLine(stdout, pc10.bold("Upload safety check"));
   writeLine(stdout, "Repos queued for upload:");
   for (const repo of repos) {
-    const cleanliness = repo.manifest.dirty ? pc9.yellow("dirty") : pc9.green("clean");
-    const secretSummary = repo.secretFindings.length > 0 ? pc9.red(`${repo.secretFindings.length} finding(s)`) : pc9.green("no findings");
-    const dedupSummary = existingBlobs.has(repo.manifest.archiveSha256) ? pc9.cyan("blob already exists remotely") : "new upload";
+    const cleanliness = repo.manifest.dirty ? pc10.yellow("dirty") : pc10.green("clean");
+    const secretSummary = repo.secretFindings.length > 0 ? pc10.red(`${repo.secretFindings.length} finding(s)`) : pc10.green("no findings");
+    const dedupSummary = existingBlobs.has(repo.manifest.archiveSha256) ? pc10.cyan("blob already exists remotely") : "new upload";
     writeLine(
       stdout,
-      `- ${pc9.cyan(repo.manifest.repoId)} \u2014 ${repo.manifest.localPath}`
+      `- ${pc10.cyan(repo.manifest.repoId)} \u2014 ${repo.manifest.localPath}`
     );
     writeLine(
       stdout,
@@ -4842,7 +5413,7 @@ function assertArtifactsMatchPersistedState(repos, persistedManifests) {
     );
   }
 }
-async function createRemoteLaunch(options, repos, taskDescription) {
+async function createRemoteLaunch(options, repos, taskDescription, signal) {
   const response = await options.apiClient.request({
     body: {
       ...taskDescription ? {
@@ -4858,7 +5429,8 @@ async function createRemoteLaunch(options, repos, taskDescription) {
       }))
     },
     method: "POST",
-    path: "/launches"
+    path: "/launches",
+    signal
   });
   const remoteLaunchId = normalizeLaunchId2(response.launchId);
   if (remoteLaunchId.length === 0) {
@@ -4869,12 +5441,13 @@ async function createRemoteLaunch(options, repos, taskDescription) {
     remoteLaunchId
   };
 }
-async function uploadArchive(options, repo, uploadUrl) {
+async function uploadArchive(options, repo, uploadUrl, signal, interruption) {
   const fetchImpl = options.fetch ?? globalThis.fetch;
   const createSpinner = options.createSpinner ?? defaultCreateSpinner3;
   const spinner = createSpinner(
     `Uploading ${repo.manifest.repoId} 0 B / ${formatBytes2(repo.manifest.archiveBytes)} (0 B/s)`
   );
+  interruption.activeSpinner = spinner;
   spinner.start(spinner.text);
   const startedAt = Date.now();
   let bytesTransferred = 0;
@@ -4886,27 +5459,49 @@ async function uploadArchive(options, repo, uploadUrl) {
       callback(null, chunk);
     }
   });
+  const archiveStream = createReadStream2(repo.archivePath);
+  const abortStream = () => {
+    archiveStream.destroy();
+    meter.destroy();
+  };
+  if (signal.aborted) {
+    abortStream();
+  } else {
+    signal.addEventListener("abort", abortStream, { once: true });
+  }
   let response;
   try {
-    const body = createReadStream2(repo.archivePath).pipe(meter);
+    const body = archiveStream.pipe(meter);
     const requestInit = {
       body,
       duplex: "half",
       headers: {
         "content-length": String(repo.manifest.archiveBytes)
       },
-      method: "PUT"
+      method: "PUT",
+      signal
     };
     response = await fetchImpl(uploadUrl, requestInit);
   } catch (error) {
+    if (isInterruptedError3(error)) {
+      throw error;
+    }
     spinner.fail(`Upload failed for ${repo.manifest.repoId}`);
+    if (interruption.activeSpinner === spinner) {
+      interruption.activeSpinner = void 0;
+    }
     throw new CliError(
       `Upload failed for ${repo.manifest.repoId}: ${error instanceof Error ? error.message : String(error)}`
     );
+  } finally {
+    signal.removeEventListener("abort", abortStream);
   }
   if (!response.ok) {
     const detail = await response.text().catch(() => "");
     spinner.fail(`Upload failed for ${repo.manifest.repoId}`);
+    if (interruption.activeSpinner === spinner) {
+      interruption.activeSpinner = void 0;
+    }
     throw new CliError(
       `Upload failed for ${repo.manifest.repoId}: HTTP ${response.status}${detail ? ` ${detail}` : ""}`
     );
@@ -4915,8 +5510,38 @@ async function uploadArchive(options, repo, uploadUrl) {
   spinner.succeed(
     `Uploaded ${repo.manifest.repoId} ${formatBytes2(bytesTransferred)} in ${formatDuration(elapsedMs)} (${formatRate(bytesTransferred, elapsedMs)})`
   );
+  if (interruption.activeSpinner === spinner) {
+    interruption.activeSpinner = void 0;
+  }
+}
+async function persistCreatedLaunchState(options, remoteLaunchId, repos) {
+  for (const repo of repos) {
+    await recordRepoManifest(
+      options.launchId,
+      repo.manifest.repoId,
+      repo.manifest,
+      {
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      }
+    );
+  }
+  for (const repo of repos) {
+    await updateRepoUploadState(
+      options.launchId,
+      {
+        remoteLaunchId,
+        repoId: repo.manifest.repoId,
+        status: "pending"
+      },
+      {
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      }
+    );
+  }
 }
-async function processRepoUpload(options, repo, remoteLaunchId) {
+async function processRepoUpload(options, repo, remoteLaunchId, signal, interruption) {
   const snapshot = await loadLaunchSnapshot(options.launchId, {
     cwd: options.cwd,
     homeDir: options.homeDir
@@ -4939,7 +5564,8 @@ async function processRepoUpload(options, repo, remoteLaunchId) {
   const response = await options.apiClient.request({
     body: repo.manifest,
     method: "POST",
-    path: `/launches/${remoteLaunchId}/repos/${repo.manifest.repoId}`
+    path: `/launches/${remoteLaunchId}/repos/${repo.manifest.repoId}`,
+    signal
   });
   if (response.status === "blob_exists") {
     await updateRepoUploadState(
@@ -4956,7 +5582,7 @@ async function processRepoUpload(options, repo, remoteLaunchId) {
     );
     writeLine(
       options.stdout,
-      pc9.cyan(`Skipping upload for ${repo.manifest.repoId}; blob already exists remotely.`)
+      pc10.cyan(`Skipping upload for ${repo.manifest.repoId}; blob already exists remotely.`)
     );
     return;
   }
@@ -4978,7 +5604,7 @@ async function processRepoUpload(options, repo, remoteLaunchId) {
       homeDir: options.homeDir
     }
   );
-  await uploadArchive(options, repo, uploadUrl);
+  await uploadArchive(options, repo, uploadUrl, signal, interruption);
   await updateRepoUploadState(
     options.launchId,
     {
@@ -4994,152 +5620,193 @@ async function processRepoUpload(options, repo, remoteLaunchId) {
 }
 async function runUploadPipeline(options) {
   const promptConfirm = options.promptConfirm ?? defaultPromptConfirm3;
+  const interruption = {
+    abortController: new AbortController(),
+    interrupted: false,
+    stdout: options.stdout
+  };
+  let remoteLaunchId = null;
+  const unregisterSignalHandler = options.registerSignalHandler?.("SIGINT", () => {
+    interruptUpload(interruption);
+  });
   const launchSnapshot = await loadLaunchSnapshot(options.launchId, {
     cwd: options.cwd,
     homeDir: options.homeDir
   });
-  if (!launchSnapshot.missionDraft) {
-    throw new CliError(
-      "Cannot start uploads before a mission draft has been approved."
-    );
-  }
-  let repos;
   try {
-    repos = await snapshotRepositories({
-      allowSecrets: options.allowSecrets === true,
-      cwd: options.cwd,
-      outputDir: path6.join(launchSnapshot.paths.launchDir, "archives"),
-      repoPaths: options.repoPaths
-    });
-  } catch (error) {
-    if (!(error instanceof SecretDetectionError) || options.allowSecrets === true) {
-      throw error;
-    }
-    repos = await snapshotRepositories({
-      allowSecrets: true,
-      cwd: options.cwd,
-      outputDir: path6.join(launchSnapshot.paths.launchDir, "archives"),
-      repoPaths: options.repoPaths
-    });
-    repos = repos.map((repo) => ({
-      ...repo,
-      warnings: repo.warnings.filter(
-        (warning) => !warning.includes("--allow-secrets is enabled")
-      )
-    }));
-  }
-  if (Object.keys(launchSnapshot.repoManifests).length > 0) {
-    assertArtifactsMatchPersistedState(
-      repos,
-      launchSnapshot.repoManifests
-    );
-  }
-  let existingBlobs = /* @__PURE__ */ new Set();
-  let remoteLaunchId = launchSnapshot.uploadState?.remoteLaunchId ?? null;
-  if (!remoteLaunchId) {
-    renderSafetyGate(options.stdout, repos, existingBlobs);
-    const hasSecretFindings = repos.some((repo) => repo.secretFindings.length > 0);
-    if (hasSecretFindings && options.allowSecrets !== true) {
+    if (!launchSnapshot.missionDraft) {
       throw new CliError(
-        "Secret scan findings blocked the upload. Re-run with `--allow-secrets` to proceed."
+        "Cannot start uploads before a mission draft has been approved."
       );
     }
-    if (options.autoApprove !== true && !await promptConfirm({
-      default: false,
-      message: "Proceed with launch upload?"
-    })) {
-      writeLine(
-        options.stdout,
-        pc9.yellow("Upload cancelled before creating a remote launch.")
+    let repos;
+    try {
+      repos = await snapshotRepositories({
+        allowSecrets: options.allowSecrets === true,
+        cwd: options.cwd,
+        outputDir: path6.join(launchSnapshot.paths.launchDir, "archives"),
+        repoPaths: options.repoPaths
+      });
+    } catch (error) {
+      if (!(error instanceof SecretDetectionError) || options.allowSecrets === true) {
+        throw error;
+      }
+      repos = await snapshotRepositories({
+        allowSecrets: true,
+        cwd: options.cwd,
+        outputDir: path6.join(launchSnapshot.paths.launchDir, "archives"),
+        repoPaths: options.repoPaths
+      });
+      repos = repos.map((repo) => ({
+        ...repo,
+        warnings: repo.warnings.filter(
+          (warning) => !warning.includes("--allow-secrets is enabled")
+        )
+      }));
+    }
+    if (Object.keys(launchSnapshot.repoManifests).length > 0) {
+      assertArtifactsMatchPersistedState(
+        repos,
+        launchSnapshot.repoManifests
       );
-      return {
-        finalized: false,
-        remoteLaunchId: null
-      };
     }
-    const createdLaunch = await createRemoteLaunch(
-      options,
-      repos,
-      launchSnapshot.request?.task ?? null
-    );
-    existingBlobs = createdLaunch.existingBlobs;
-    remoteLaunchId = createdLaunch.remoteLaunchId;
-    if (existingBlobs.size > 0) {
-      writeLine(
-        options.stdout,
-        pc9.cyan(
-          `Remote dedup will reuse ${existingBlobs.size} existing blob${existingBlobs.size === 1 ? "" : "s"}.`
-        )
+    throwIfInterrupted4(interruption);
+    let existingBlobs = /* @__PURE__ */ new Set();
+    remoteLaunchId = launchSnapshot.uploadState?.remoteLaunchId ?? null;
+    if (!remoteLaunchId) {
+      renderSafetyGate(options.stdout, repos, existingBlobs);
+      const hasSecretFindings = repos.some((repo) => repo.secretFindings.length > 0);
+      if (hasSecretFindings && options.allowSecrets !== true) {
+        throw new CliError(
+          "Secret scan findings blocked the upload. Re-run with `--allow-secrets` to proceed."
+        );
+      }
+      throwIfInterrupted4(interruption);
+      if (options.autoApprove !== true && !await promptConfirm({
+        default: false,
+        message: "Proceed with launch upload?",
+        signal: interruption.abortController.signal
+      })) {
+        writeLine(
+          options.stdout,
+          pc10.yellow("Upload cancelled before creating a remote launch.")
+        );
+        return {
+          finalized: false,
+          remoteLaunchId: null
+        };
+      }
+      throwIfInterrupted4(interruption);
+      const createdLaunch = await createRemoteLaunch(
+        options,
+        repos,
+        launchSnapshot.request?.task ?? null,
+        interruption.abortController.signal
       );
+      existingBlobs = createdLaunch.existingBlobs;
+      remoteLaunchId = createdLaunch.remoteLaunchId;
+      await persistCreatedLaunchState(options, remoteLaunchId, repos);
+      throwIfInterrupted4(interruption);
+      if (existingBlobs.size > 0) {
+        writeLine(
+          options.stdout,
+          pc10.cyan(
+            `Remote dedup will reuse ${existingBlobs.size} existing blob${existingBlobs.size === 1 ? "" : "s"}.`
+          )
+        );
+      }
     }
+    const currentSnapshot = await loadLaunchSnapshot(options.launchId, {
+      cwd: options.cwd,
+      homeDir: options.homeDir
+    });
+    const uploadStates = new Map(
+      Object.entries(currentSnapshot.uploadState?.repos ?? {}).map(
+        ([repoId, state]) => [repoId, state?.status]
+      )
+    );
+    const failures = [];
     for (const repo of repos) {
-      await recordRepoManifest(
-        options.launchId,
-        repo.manifest.repoId,
-        repo.manifest,
-        {
+      throwIfInterrupted4(interruption);
+      if (isTerminalUploadStatus2(uploadStates.get(repo.manifest.repoId))) {
+        writeLine(
+          options.stdout,
+          pc10.cyan(`Skipping ${repo.manifest.repoId}; already completed in upload-state.json.`)
+        );
+        continue;
+      }
+      try {
+        await processRepoUpload(
+          options,
+          repo,
+          remoteLaunchId,
+          interruption.abortController.signal,
+          interruption
+        );
+        const refreshedSnapshot = await loadLaunchSnapshot(options.launchId, {
           cwd: options.cwd,
           homeDir: options.homeDir
+        });
+        uploadStates.set(
+          repo.manifest.repoId,
+          refreshedSnapshot.uploadState?.repos[repo.manifest.repoId]?.status
+        );
+      } catch (error) {
+        if (interruption.interrupted || isInterruptedError3(error)) {
+          throw error;
         }
-      );
+        failures.push(repo.manifest.repoId);
+        writeLine(
+          options.stdout,
+          pc10.red(
+            error instanceof Error ? error.message : `Upload failed for ${repo.manifest.repoId}.`
+          )
+        );
+      }
     }
-  }
-  const uploadStates = new Map(
-    Object.entries(launchSnapshot.uploadState?.repos ?? {}).map(
-      ([repoId, state]) => [repoId, state?.status]
-    )
-  );
-  const failures = [];
-  for (const repo of repos) {
-    if (isTerminalUploadStatus2(uploadStates.get(repo.manifest.repoId))) {
-      writeLine(
-        options.stdout,
-        pc9.cyan(`Skipping ${repo.manifest.repoId}; already completed in upload-state.json.`)
+    if (failures.length > 0) {
+      throw new CliError(
+        `Upload failed for ${failures.join(", ")}. Re-run the command to resume the remaining repos.`
       );
-      continue;
     }
-    try {
-      await processRepoUpload(options, repo, remoteLaunchId);
-      const refreshedSnapshot = await loadLaunchSnapshot(options.launchId, {
-        cwd: options.cwd,
-        homeDir: options.homeDir
-      });
-      uploadStates.set(
-        repo.manifest.repoId,
-        refreshedSnapshot.uploadState?.repos[repo.manifest.repoId]?.status
-      );
-    } catch (error) {
-      failures.push(repo.manifest.repoId);
-      writeLine(
-        options.stdout,
-        pc9.red(
-          error instanceof Error ? error.message : `Upload failed for ${repo.manifest.repoId}.`
-        )
+    throwIfInterrupted4(interruption);
+    const finalizeResponse = await options.apiClient.request({
+      method: "POST",
+      path: `/launches/${remoteLaunchId}/finalize`,
+      signal: interruption.abortController.signal
+    });
+    if (finalizeResponse.status !== "complete") {
+      throw new CliError(
+        `Remote launch ${remoteLaunchId} did not finalize successfully.`
       );
     }
-  }
-  if (failures.length > 0) {
-    throw new CliError(
-      `Upload failed for ${failures.join(", ")}. Re-run the command to resume the remaining repos.`
-    );
-  }
-  const finalizeResponse = await options.apiClient.request({
-    method: "POST",
-    path: `/launches/${remoteLaunchId}/finalize`
-  });
-  if (finalizeResponse.status !== "complete") {
-    throw new CliError(
-      `Remote launch ${remoteLaunchId} did not finalize successfully.`
+    writeLine(
+      options.stdout,
+      pc10.green(`Upload complete. Remote launch ${remoteLaunchId} is finalized.`)
     );
+    return {
+      finalized: true,
+      remoteLaunchId
+    };
+  } catch (error) {
+    if (interruption.interrupted && isInterruptedError3(error)) {
+      return {
+        exitCode: 130,
+        finalized: false,
+        interrupted: true,
+        remoteLaunchId
+      };
+    }
+    throw error;
+  } finally {
+    if (typeof unregisterSignalHandler === "function") {
+      unregisterSignalHandler();
+    }
+    if (interruption.activeSpinner) {
+      interruption.activeSpinner.stop();
+      interruption.activeSpinner = void 0;
+    }
   }
-  writeLine(
-    options.stdout,
-    pc9.green(`Upload complete. Remote launch ${remoteLaunchId} is finalized.`)
-  );
-  return {
-    finalized: true,
-    remoteLaunchId
-  };
 }
 
 // src/commands/mission-run.ts
@@ -5212,6 +5879,9 @@ function registerMissionRunCommand(mission, context, dependencies = {}) {
         sleep: dependencies.sleep,
         verbose: globalOptions.verbose === true
       });
+      const registerSignalHandler = createSignalHandlerCoordinator(
+        dependencies.registerSignalHandler
+      );
       const result = await runPlanningFlow({
         autoApprove: options.yes === true,
         client,
@@ -5248,11 +5918,15 @@ function registerMissionRunCommand(mission, context, dependencies = {}) {
         promptConfirm: dependencies.promptConfirm,
         promptInput: dependencies.promptInput,
         promptSelect: dependencies.promptSelect,
+        registerSignalHandler,
         repoPaths,
         sleep: dependencies.sleep,
         stdout: context.stdout,
         taskDescription: task
       });
+      if (result.exitCode && result.exitCode !== 0) {
+        throw new CommanderError3(result.exitCode, "mission-planning", "");
+      }
       if (!result.cancelled && !result.skippedPlanning) {
         writeLine(
           context.stdout,
@@ -5271,9 +5945,13 @@ function registerMissionRunCommand(mission, context, dependencies = {}) {
         homeDir,
         launchId: launchSnapshot.launchId,
         promptConfirm: dependencies.promptConfirm,
+        registerSignalHandler,
         repoPaths,
         stdout: context.stdout
       });
+      if (uploadResult.exitCode && uploadResult.exitCode !== 0) {
+        throw new CommanderError3(uploadResult.exitCode, "mission-upload", "");
+      }
       if (!uploadResult.finalized) {
         return;
       }
@@ -5297,22 +5975,23 @@ function registerMissionRunCommand(mission, context, dependencies = {}) {
         missionId: mission2.missionId,
         promptInput: dependencies.promptInput,
         promptSelect: dependencies.promptSelect,
-        registerSignalHandler: dependencies.registerSignalHandler,
+        registerSignalHandler,
         sleep: dependencies.sleep,
-        stdout: context.stdout
+        stdout: context.stdout,
+        verbose: globalOptions.verbose === true
       });
       if (monitorResult.exitCode !== 0) {
-        throw new CommanderError2(monitorResult.exitCode, "mission-monitor", "");
+        throw new CommanderError3(monitorResult.exitCode, "mission-monitor", "");
       }
     }
   );
 }
 
 // src/commands/mission-status.ts
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 function writeSection4(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc10.bold(title));
+  writeLine(stdout, pc11.bold(title));
 }
 function normalizeMilestoneOrder(milestones, features, assertions) {
   const known = new Map(milestones.map((milestone) => [milestone.name, milestone]));
@@ -5412,7 +6091,7 @@ function renderMilestones2(stdout, milestones, features) {
   for (const milestone of milestones) {
     writeLine(
       stdout,
-      `- ${pc10.cyan(milestone.name)} (${milestone.state}) \xB7 ${milestone.completedFeatureCount}/${milestone.featureCount} features \xB7 ${milestone.passedAssertionCount}/${milestone.assertionCount} assertions`
+      `- ${pc11.cyan(milestone.name)} (${milestone.state}) \xB7 ${milestone.completedFeatureCount}/${milestone.featureCount} features \xB7 ${milestone.passedAssertionCount}/${milestone.assertionCount} assertions`
     );
     const milestoneFeatures = features.filter(
       (feature) => feature.milestone === milestone.name
@@ -5510,7 +6189,7 @@ function writeError(stream, message) {
   writeLine(stream, `Error: ${message}`);
 }
 function handleRunError(error, stderr) {
-  if (error instanceof CommanderError3) {
+  if (error instanceof CommanderError4) {
     return error.exitCode;
   }
   if (error instanceof CliError) {