@coresource/hz 0.1.0

package/dist/hz.mjs

@@ -0,0 +1,4767 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import path7 from "path";
+import { fileURLToPath } from "url";
+import { Command, CommanderError as CommanderError3 } from "commander";
+
+// src/cli-support.ts
+import { password } from "@inquirer/prompts";
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+function createCliContext(dependencies = {}) {
+  return {
+    env: dependencies.env ?? process.env,
+    homeDir: dependencies.homeDir,
+    stderr: dependencies.stderr ?? process.stderr,
+    stdout: dependencies.stdout ?? process.stdout,
+    promptForApiKey: dependencies.promptForApiKey ?? (async (message) => password({ message }))
+  };
+}
+function writeLine(stream, message = "") {
+  stream.write(`${message}
+`);
+}
+
+// src/config.ts
+import { open } from "fs/promises";
+import {
+  chmod,
+  mkdir,
+  readFile,
+  rename,
+  rm
+} from "fs/promises";
+import os from "os";
+import path from "path";
+var DEFAULT_ENDPOINT = "https://horizon.lvlzero.ai";
+var ConfigError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "ConfigError";
+    this.code = code;
+  }
+};
+function hasOwnEnv(env, key) {
+  return Object.prototype.hasOwnProperty.call(env, key);
+}
+function normalizeEndpoint(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return DEFAULT_ENDPOINT;
+  }
+  const candidate = value.trim();
+  try {
+    return new URL(candidate).toString().replace(/\/$/, "");
+  } catch {
+    throw new ConfigError(
+      `Invalid endpoint URL: ${candidate}`,
+      "invalid_config"
+    );
+  }
+}
+function resolveHomeDir(options = {}) {
+  return options.homeDir ?? options.env?.HOME ?? os.homedir();
+}
+function resolveConfigPath(options = {}) {
+  if (options.configPath) {
+    return options.configPath;
+  }
+  return path.join(resolveHomeDir(options), ".factory", "config.json");
+}
+async function readConfig(options = {}) {
+  const configPath = resolveConfigPath(options);
+  try {
+    const raw = await readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || Array.isArray(parsed) || typeof parsed !== "object") {
+      throw new ConfigError(
+        `Invalid JSON object in ${configPath}`,
+        "invalid_config"
+      );
+    }
+    const apiKey = typeof parsed.apiKey === "string" ? parsed.apiKey : void 0;
+    return {
+      ...parsed,
+      ...apiKey ? { apiKey } : {},
+      endpoint: normalizeEndpoint(parsed.endpoint)
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { endpoint: DEFAULT_ENDPOINT };
+    }
+    if (error instanceof SyntaxError) {
+      throw new ConfigError(
+        `Invalid JSON in ${configPath}`,
+        "invalid_config"
+      );
+    }
+    throw error;
+  }
+}
+async function writeConfig(config, options = {}) {
+  const configPath = resolveConfigPath(options);
+  const configDir = path.dirname(configPath);
+  const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+  const payload = JSON.stringify(
+    {
+      ...config,
+      endpoint: normalizeEndpoint(config.endpoint)
+    },
+    null,
+    2
+  ).concat("\n");
+  await mkdir(configDir, { recursive: true, mode: 448 });
+  const handle = await open(tempPath, "w", 384);
+  try {
+    await handle.writeFile(payload, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close();
+    await rm(tempPath, { force: true });
+    throw error;
+  }
+  await handle.close();
+  await chmod(tempPath, 384);
+  await rename(tempPath, configPath);
+  await chmod(configPath, 384);
+  return configPath;
+}
+async function clearStoredApiKey(options = {}) {
+  const current = await readConfig(options);
+  const { apiKey: _apiKey, ...rest } = current;
+  return writeConfig(rest, options);
+}
+async function getAuthConfig(options = {}) {
+  const env = options.env ?? process.env;
+  const storedConfig = await readConfig(options);
+  if (hasOwnEnv(env, "HZ_API_KEY")) {
+    const envApiKey = (env.HZ_API_KEY ?? "").trim();
+    if (envApiKey.length === 0) {
+      throw new ConfigError(
+        "HZ_API_KEY is set but empty. Remove it or set a valid API key.",
+        "invalid_env"
+      );
+    }
+    return {
+      ...storedConfig,
+      apiKey: envApiKey,
+      apiKeySource: "env"
+    };
+  }
+  const storedApiKey = storedConfig.apiKey?.trim() ?? "";
+  if (storedApiKey.length === 0) {
+    throw new ConfigError(
+      "No API key configured. Run `hz auth login`.",
+      "auth_required"
+    );
+  }
+  return {
+    ...storedConfig,
+    apiKey: storedApiKey,
+    apiKeySource: "config"
+  };
+}
+
+// src/api-client.ts
+import { setTimeout as delay } from "timers/promises";
+var ApiError = class extends Error {
+  payload;
+  retriable;
+  status;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ApiError";
+    this.payload = options.payload;
+    this.retriable = options.retriable ?? false;
+    this.status = options.status;
+  }
+};
+function resolveUrl(endpoint, requestPath) {
+  const base = endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+  return new URL(requestPath.replace(/^\//, ""), base).toString();
+}
+function isRetriableStatus(status) {
+  return status === 429 || status >= 500;
+}
+function maskHeaders(headers) {
+  const masked = {};
+  for (const [key, value] of headers.entries()) {
+    masked[key] = key.toLowerCase() === "authorization" ? "Bearer ***" : value;
+  }
+  return masked;
+}
+function sanitizeBody(body) {
+  if (body === void 0) {
+    return "";
+  }
+  try {
+    return JSON.stringify(body);
+  } catch {
+    return "[unserializable body]";
+  }
+}
+async function parseResponseBody(response) {
+  if (response.status === 204) {
+    return void 0;
+  }
+  const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+  const text = await response.text();
+  if (text.length === 0) {
+    return void 0;
+  }
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { raw: text };
+    }
+  }
+  return text;
+}
+function toRetryDelayMs(attempt, response) {
+  if (response?.status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    const retryAfterSeconds = Number.parseInt(retryAfter ?? "", 10);
+    if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds >= 0) {
+      return retryAfterSeconds * 1e3;
+    }
+  }
+  return 200 * 2 ** attempt;
+}
+function formatHttpError(response, payload) {
+  if (response.status === 401) {
+    return new ApiError(
+      "Authentication failed. Run `hz auth login` to configure a valid API key.",
+      { payload, status: 401 }
+    );
+  }
+  if (response.status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    const retrySuffix = retryAfter ? ` Retry after ${retryAfter} seconds.` : "";
+    return new ApiError(
+      `Rate limited by the Horizon API (429).${retrySuffix}`,
+      { payload, retriable: true, status: 429 }
+    );
+  }
+  if (response.status >= 500) {
+    return new ApiError(
+      `Horizon API returned ${response.status}. Please try again shortly.`,
+      { payload, retriable: true, status: response.status }
+    );
+  }
+  if (payload && typeof payload === "object") {
+    const message = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : `Request failed with status ${response.status}.`;
+    return new ApiError(message, { payload, status: response.status });
+  }
+  return new ApiError(`Request failed with status ${response.status}.`, {
+    payload,
+    status: response.status
+  });
+}
+function formatNetworkError(error) {
+  if (error instanceof ApiError) {
+    return error;
+  }
+  if (error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    return new ApiError(
+      "The request timed out before the Horizon API responded."
+    );
+  }
+  const causeCode = error instanceof Error && typeof error.cause?.code === "string" ? error.cause.code : void 0;
+  if (causeCode === "ENOTFOUND" || causeCode === "EAI_AGAIN") {
+    return new ApiError(
+      "DNS lookup failed while contacting the Horizon API."
+    );
+  }
+  if (causeCode === "DEPTH_ZERO_SELF_SIGNED_CERT" || causeCode === "ERR_TLS_CERT_ALTNAME_INVALID" || causeCode === "CERT_HAS_EXPIRED") {
+    return new ApiError(
+      "TLS verification failed while connecting to the Horizon API."
+    );
+  }
+  if (error instanceof TypeError && /timeout|aborted/i.test(error.message)) {
+    return new ApiError(
+      "The request timed out before the Horizon API responded."
+    );
+  }
+  if (error instanceof TypeError && /fetch failed/i.test(error.message)) {
+    return new ApiError(
+      "Network request failed while contacting the Horizon API."
+    );
+  }
+  if (error instanceof Error) {
+    return new ApiError(error.message);
+  }
+  return new ApiError("Unexpected error while contacting the Horizon API.");
+}
+function createApiClient(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const sleep = options.sleep ?? ((ms) => delay(ms).then(() => void 0));
+  const retryCount = options.retryCount ?? 2;
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  return {
+    async request(request) {
+      const url = resolveUrl(options.config.endpoint, request.path);
+      const method = request.method ?? "GET";
+      const headers = new Headers(request.headers);
+      headers.set("accept", "application/json");
+      headers.set("authorization", `Bearer ${options.config.apiKey}`);
+      let body;
+      if (request.body !== void 0) {
+        headers.set("content-type", "application/json");
+        body = JSON.stringify(request.body);
+      }
+      if (options.verbose) {
+        options.onVerboseLog?.(
+          `[hz] request ${method} ${url} headers=${JSON.stringify(maskHeaders(headers))} body=${sanitizeBody(request.body)}`
+        );
+      }
+      for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+        const signal = AbortSignal.timeout(request.timeoutMs ?? timeoutMs);
+        try {
+          const response = await fetchImpl(url, {
+            method,
+            headers,
+            body,
+            signal
+          });
+          if (options.verbose) {
+            options.onVerboseLog?.(
+              `[hz] response ${response.status} ${method} ${url}`
+            );
+          }
+          if (response.ok) {
+            return await parseResponseBody(response);
+          }
+          const payload = await parseResponseBody(response);
+          if (isRetriableStatus(response.status) && attempt < retryCount) {
+            await sleep(toRetryDelayMs(attempt, response));
+            continue;
+          }
+          throw formatHttpError(response, payload);
+        } catch (error) {
+          if (error instanceof ApiError) {
+            throw error;
+          }
+          const formatted = formatNetworkError(error);
+          throw formatted;
+        }
+      }
+      throw new ApiError("Request failed after retries.");
+    }
+  };
+}
+
+// src/commands/auth.ts
+function trimValue(value) {
+  return value?.trim() ?? "";
+}
+function normalizeEndpoint2(value) {
+  const candidate = trimValue(value);
+  if (candidate.length === 0) {
+    throw new CliError("Endpoint URL is required.");
+  }
+  try {
+    return new URL(candidate).toString().replace(/\/$/, "");
+  } catch {
+    throw new CliError(`Invalid endpoint URL: ${candidate}`);
+  }
+}
+async function validateApiKey(apiKey, endpoint, unauthorizedMessage) {
+  const client = createApiClient({
+    config: {
+      apiKey,
+      apiKeySource: "config",
+      endpoint
+    }
+  });
+  try {
+    return await client.request({
+      method: "POST",
+      path: "/internal/api-keys/validate",
+      body: { key: apiKey }
+    });
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 401) {
+      throw new CliError(unauthorizedMessage);
+    }
+    throw error;
+  }
+}
+async function resolveOrganizationName(apiKey, endpoint, tenantId) {
+  const base = endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
+  try {
+    const response = await fetch(new URL("api/session", base), {
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload.allowed_tenants)) {
+      return null;
+    }
+    const match = payload.allowed_tenants.find(
+      (tenant) => trimValue(tenant?.tenant_id) === tenantId
+    );
+    const displayName = trimValue(match?.display_name);
+    return displayName.length > 0 ? displayName : null;
+  } catch {
+    return null;
+  }
+}
+function registerAuthCommands(program, context) {
+  const auth = program.command("auth").description("Manage authentication");
+  auth.command("login").description("Store an API key in ~/.factory/config.json").option("--endpoint <url>", "API endpoint to use").option("--key <apiKey>", "API key to store locally").action(async (options) => {
+    const existing = await readConfig({
+      env: context.env,
+      homeDir: context.homeDir
+    });
+    const apiKey = trimValue(options.key) || trimValue(await context.promptForApiKey("Enter your Horizon API key"));
+    if (apiKey.length === 0) {
+      throw new CliError(
+        "API key is required. Pass --key or provide a value interactively."
+      );
+    }
+    const endpoint = trimValue(options.endpoint).length > 0 ? normalizeEndpoint2(options.endpoint ?? "") : existing.endpoint;
+    const validation = await validateApiKey(
+      apiKey,
+      endpoint,
+      "The supplied API key is invalid or revoked."
+    );
+    const configPath = await writeConfig(
+      {
+        ...existing,
+        apiKey,
+        endpoint
+      },
+      {
+        env: context.env,
+        homeDir: context.homeDir
+      }
+    );
+    writeLine(
+      context.stdout,
+      `Authenticated tenant ${validation.tenant_id}${trimValue(validation.key_name) ? ` with key "${trimValue(validation.key_name)}"` : ""}.`
+    );
+    writeLine(context.stdout, `Saved API key to ${configPath}.`);
+    writeLine(context.stdout, `Using endpoint ${endpoint}.`);
+  });
+  auth.command("logout").description("Remove the stored API key").action(async () => {
+    const config = await readConfig({
+      env: context.env,
+      homeDir: context.homeDir
+    });
+    if (!config.apiKey) {
+      writeLine(context.stdout, "You are already logged out.");
+      return;
+    }
+    await clearStoredApiKey({
+      env: context.env,
+      homeDir: context.homeDir
+    });
+    writeLine(
+      context.stdout,
+      `Removed the stored API key from ${resolveConfigPath({
+        env: context.env,
+        homeDir: context.homeDir
+      })}.`
+    );
+  });
+  auth.command("whoami").description("Show the currently configured authentication context").action(async () => {
+    const config = await getAuthConfig({
+      env: context.env,
+      homeDir: context.homeDir
+    });
+    const validation = await validateApiKey(
+      config.apiKey,
+      config.endpoint,
+      "Authentication failed: the configured API key is invalid or revoked. Run `hz auth login` to update it."
+    );
+    const organizationName = await resolveOrganizationName(
+      config.apiKey,
+      config.endpoint,
+      validation.tenant_id
+    ) ?? validation.tenant_id;
+    const keyName = trimValue(validation.key_name) || "(unnamed key)";
+    writeLine(context.stdout, `Tenant ID: ${validation.tenant_id}`);
+    writeLine(
+      context.stdout,
+      `Organization: ${organizationName}`
+    );
+    writeLine(context.stdout, `Key name: ${keyName}`);
+    writeLine(context.stdout, `Endpoint: ${config.endpoint}`);
+    writeLine(context.stdout, `Credential source: ${config.apiKeySource}`);
+  });
+}
+
+// src/commands/mission-support.ts
+import pc from "picocolors";
+function isRecord(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asNullableNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+async function createMissionApiClient(context, command, dependencies = {}) {
+  const authConfig = await getAuthConfig({
+    env: context.env,
+    homeDir: context.homeDir
+  });
+  const globalOptions = typeof command?.optsWithGlobals === "function" ? command.optsWithGlobals() : {};
+  return createApiClient({
+    config: authConfig,
+    onVerboseLog: (message) => writeLine(context.stderr, message),
+    sleep: dependencies.sleep,
+    verbose: globalOptions.verbose === true
+  });
+}
+function normalizeMissionSummaries(value) {
+  if (!Array.isArray(value)) {
+    throw new CliError("Mission list response was not an array.");
+  }
+  return value.map((entry) => normalizeMissionSummary(entry));
+}
+function normalizeMissionSummary(value) {
+  if (!isRecord(value)) {
+    throw new CliError("Mission list entry was not an object.");
+  }
+  const missionId = asNonEmptyString(value.missionId);
+  if (!missionId) {
+    throw new CliError("Mission list entry is missing a missionId.");
+  }
+  return {
+    completedFeatures: asFiniteNumber(value.completedFeatures),
+    createdAt: asNonEmptyString(value.createdAt),
+    missionId,
+    passedAssertions: asFiniteNumber(value.passedAssertions),
+    state: asNonEmptyString(value.state) ?? "unknown",
+    totalAssertions: asFiniteNumber(value.totalAssertions),
+    totalFeatures: asFiniteNumber(value.totalFeatures)
+  };
+}
+function normalizeMissionState(value) {
+  if (!isRecord(value)) {
+    throw new CliError("Mission state response was not an object.");
+  }
+  const missionId = asNonEmptyString(value.missionId);
+  if (!missionId) {
+    throw new CliError("Mission state response is missing a missionId.");
+  }
+  return {
+    completedFeatures: asFiniteNumber(value.completedFeatures),
+    createdAt: asNonEmptyString(value.createdAt),
+    currentFeatureId: asNonEmptyString(value.currentFeatureId),
+    currentWorkerSessionId: asNonEmptyString(value.currentWorkerSessionId),
+    estimatedCostUsd: asNullableNumber(value.estimatedCostUsd),
+    inferenceTokensUsed: asNullableNumber(value.inferenceTokensUsed),
+    missionId,
+    passedAssertions: asFiniteNumber(value.passedAssertions),
+    sandboxMinutesUsed: asNullableNumber(value.sandboxMinutesUsed),
+    sealedMilestones: asFiniteNumber(value.sealedMilestones),
+    state: asNonEmptyString(value.state) ?? "unknown",
+    totalAssertions: asFiniteNumber(value.totalAssertions),
+    totalFeatures: asFiniteNumber(value.totalFeatures),
+    totalMilestones: asFiniteNumber(value.totalMilestones),
+    updatedAt: asNonEmptyString(value.updatedAt)
+  };
+}
+function normalizeMissionFeatures(value) {
+  if (!Array.isArray(value)) {
+    throw new CliError("Mission features response was not an array.");
+  }
+  return value.map((entry) => {
+    if (!isRecord(entry)) {
+      throw new CliError("Mission feature entry was not an object.");
+    }
+    const id = asNonEmptyString(entry.id);
+    if (!id) {
+      throw new CliError("Mission feature entry is missing an id.");
+    }
+    return {
+      id,
+      milestone: asNonEmptyString(entry.milestone),
+      status: asNonEmptyString(entry.status) ?? "unknown"
+    };
+  });
+}
+function normalizeMissionAssertions(value) {
+  if (!Array.isArray(value)) {
+    throw new CliError("Mission assertions response was not an array.");
+  }
+  return value.map((entry) => {
+    if (!isRecord(entry)) {
+      throw new CliError("Mission assertion entry was not an object.");
+    }
+    const id = asNonEmptyString(entry.id);
+    if (!id) {
+      throw new CliError("Mission assertion entry is missing an id.");
+    }
+    return {
+      id,
+      milestone: asNonEmptyString(entry.milestone),
+      status: asNonEmptyString(entry.status) ?? "unknown"
+    };
+  });
+}
+function normalizeMissionMilestones(value) {
+  if (!Array.isArray(value)) {
+    throw new CliError("Mission milestones response was not an array.");
+  }
+  return value.map((entry) => {
+    if (!isRecord(entry)) {
+      throw new CliError("Mission milestone entry was not an object.");
+    }
+    const name = asNonEmptyString(entry.name);
+    if (!name) {
+      throw new CliError("Mission milestone entry is missing a name.");
+    }
+    return {
+      assertionCount: asFiniteNumber(entry.assertionCount),
+      completedFeatureCount: asFiniteNumber(entry.completedFeatureCount),
+      featureCount: asFiniteNumber(entry.featureCount),
+      name,
+      passedAssertionCount: asFiniteNumber(entry.passedAssertionCount),
+      state: asNonEmptyString(entry.state) ?? "unknown"
+    };
+  });
+}
+function truncateMissionId(missionId, limit = 12) {
+  return missionId.length > limit ? `${missionId.slice(0, limit)}\u2026` : missionId;
+}
+function formatMissionState(state) {
+  switch (state) {
+    case "completed":
+      return pc.green(state);
+    case "cancelled":
+    case "failed":
+    case "budget_exceeded":
+      return pc.red(state);
+    case "paused":
+    case "triage_needed":
+      return pc.yellow(state);
+    case "worker_running":
+    case "dispatching":
+      return pc.cyan(state);
+    case "orchestrator_turn":
+      return pc.magenta(state);
+    default:
+      return state;
+  }
+}
+function formatDateTime(value) {
+  if (!value) {
+    return "\u2014";
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  const iso = date.toISOString();
+  return `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
+}
+function formatCurrency(value) {
+  return value === null ? "\u2014" : `$${value.toFixed(2)}`;
+}
+function formatPercent(part, total) {
+  if (total <= 0) {
+    return "0.0%";
+  }
+  return `${(part / total * 100).toFixed(1)}%`;
+}
+function plainCell(value) {
+  return {
+    display: value,
+    width: value.length
+  };
+}
+function coloredCell(display, plainValue) {
+  return {
+    display,
+    width: plainValue.length
+  };
+}
+function padCell(cell, width) {
+  return `${cell.display}${" ".repeat(Math.max(0, width - cell.width))}`;
+}
+function renderTable(stdout, headers, rows) {
+  const widths = headers.map(
+    (header, index) => Math.max(
+      header.length,
+      ...rows.map((row) => row[index]?.width ?? 0)
+    )
+  );
+  writeLine(
+    stdout,
+    headers.map((header, index) => header.padEnd(widths[index])).join("  ")
+  );
+  writeLine(
+    stdout,
+    widths.map((width) => "-".repeat(width)).join("  ")
+  );
+  for (const row of rows) {
+    writeLine(
+      stdout,
+      row.map((cell, index) => padCell(cell, widths[index])).join("  ")
+    );
+  }
+}
+
+// src/commands/mission-list.ts
+function registerMissionListCommand(mission, context, dependencies = {}) {
+  mission.command("list").description("List recent missions").action(async (_options, command) => {
+    const apiClient = await createMissionApiClient(context, command, dependencies);
+    const missions = normalizeMissionSummaries(
+      await apiClient.request({
+        path: "/missions"
+      })
+    );
+    if (missions.length === 0) {
+      writeLine(context.stdout, "No missions found");
+      return;
+    }
+    renderTable(
+      context.stdout,
+      ["Mission ID", "State", "Created", "Features", "Assertions"],
+      missions.map((missionSummary) => [
+        plainCell(truncateMissionId(missionSummary.missionId)),
+        coloredCell(
+          formatMissionState(missionSummary.state),
+          missionSummary.state
+        ),
+        plainCell(formatDateTime(missionSummary.createdAt)),
+        plainCell(
+          `${missionSummary.completedFeatures}/${missionSummary.totalFeatures}`
+        ),
+        plainCell(
+          `${missionSummary.passedAssertions}/${missionSummary.totalAssertions}`
+        )
+      ])
+    );
+  });
+}
+
+// src/commands/mission-lifecycle.ts
+import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
+import path3 from "path";
+import { CommanderError } from "commander";
+import pc4 from "picocolors";
+
+// src/monitor.ts
+import { setTimeout as delay2 } from "timers/promises";
+import ora from "ora";
+import pc3 from "picocolors";
+import WebSocket from "ws";
+
+// src/state.ts
+import { createHash } from "crypto";
+import { open as open2 } from "fs/promises";
+import {
+  chmod as chmod2,
+  mkdir as mkdir2,
+  readFile as readFile2,
+  readdir,
+  rename as rename2,
+  rm as rm2
+} from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+var StateError = class extends Error {
+  code;
+  constructor(message, code = "invalid_state") {
+    super(message);
+    this.name = "StateError";
+    this.code = code;
+  }
+};
+var REPO_ID_PATTERN = /^[A-Za-z0-9._-]+$/;
+var PHASE_ORDER = {
+  idle: 0,
+  planning_started: 1,
+  clarification_resolved: 2,
+  mission_draft_approved: 3,
+  manifests_written: 4,
+  uploading: 5,
+  mission_created: 6
+};
+var UPLOAD_STATUS_ORDER = {
+  pending: 0,
+  requested: 1,
+  uploading: 2,
+  uploaded: 3,
+  blob_exists: 3
+};
+function resolveHomeDir2(options = {}) {
+  return options.homeDir ?? process.env.HOME ?? os2.homedir();
+}
+function resolveLaunchesDir(options = {}) {
+  return path2.join(resolveHomeDir2(options), ".factory", "cloud-launches");
+}
+function normalizeTask(task) {
+  const normalized = task.trim();
+  if (normalized.length === 0) {
+    throw new StateError("Task description must not be empty.", "invalid_input");
+  }
+  return normalized;
+}
+function normalizeRepoPaths(repoPaths, options = {}) {
+  if (repoPaths.length === 0) {
+    throw new StateError("At least one repo path is required.", "invalid_input");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const normalized = repoPaths.map((repoPath) => {
+    const trimmed = repoPath.trim();
+    if (trimmed.length === 0) {
+      throw new StateError("Repo paths must not be empty.", "invalid_input");
+    }
+    return path2.resolve(cwd, trimmed);
+  });
+  return [...new Set(normalized)].sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function normalizeLaunchId(launchId) {
+  const normalized = launchId.trim();
+  if (normalized.length === 0) {
+    throw new StateError("Launch ID must not be empty.", "invalid_input");
+  }
+  return normalized;
+}
+function normalizeRepoId(repoId) {
+  const normalized = repoId.trim();
+  if (!REPO_ID_PATTERN.test(normalized)) {
+    throw new StateError(
+      `Invalid repo ID: ${repoId}`,
+      "invalid_input"
+    );
+  }
+  return normalized;
+}
+function normalizeSessionId(sessionId) {
+  const normalized = sessionId.trim();
+  if (normalized.length === 0) {
+    throw new StateError("Session ID must not be empty.", "invalid_input");
+  }
+  return normalized;
+}
+function normalizeMissionId(missionId) {
+  const normalized = missionId.trim();
+  if (normalized.length === 0) {
+    throw new StateError("Mission ID must not be empty.", "invalid_input");
+  }
+  return normalized;
+}
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stableValue(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value).sort(
+      (left, right) => left.localeCompare(right)
+    )) {
+      const child = value[key];
+      if (child !== void 0) {
+        result[key] = stableValue(child);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function serializeJson(value) {
+  try {
+    return JSON.stringify(stableValue(value), null, 2).concat("\n");
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new StateError(
+        `State payload must be JSON-serializable: ${error.message}`,
+        "invalid_input"
+      );
+    }
+    throw new StateError(
+      "State payload must be JSON-serializable.",
+      "invalid_input"
+    );
+  }
+}
+function isJsonObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function isUploadRepoStatus(value) {
+  return typeof value === "string" && Object.hasOwn(UPLOAD_STATUS_ORDER, value);
+}
+function isTerminalUploadStatus(status) {
+  return status === "uploaded" || status === "blob_exists";
+}
+async function ensureDirectory(dirPath) {
+  await mkdir2(dirPath, { recursive: true, mode: 448 });
+}
+async function writeJsonAtomically(filePath, value) {
+  const payload = serializeJson(value);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await ensureDirectory(path2.dirname(filePath));
+  const handle = await open2(tempPath, "w", 384);
+  try {
+    await handle.writeFile(payload, "utf8");
+    await handle.sync();
+  } catch (error) {
+    await handle.close();
+    await rm2(tempPath, { force: true });
+    throw error;
+  }
+  await handle.close();
+  await chmod2(tempPath, 384);
+  await rename2(tempPath, filePath);
+  await chmod2(filePath, 384);
+}
+async function readJsonIfExists(filePath) {
+  try {
+    const raw = await readFile2(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return null;
+    }
+    if (error instanceof SyntaxError) {
+      throw new StateError(`Invalid JSON in ${filePath}`, "invalid_state");
+    }
+    throw error;
+  }
+}
+function toLaunchRequestRecord(value, filePath) {
+  if (value === null) {
+    return null;
+  }
+  if (!isJsonObject(value)) {
+    throw new StateError(`Expected ${filePath} to contain a JSON object.`, "invalid_state");
+  }
+  if (typeof value.task !== "string" || !Array.isArray(value.repos) || value.repos.some((repo) => typeof repo !== "string") || typeof value.sessionId !== "string") {
+    throw new StateError(`Invalid request state in ${filePath}`, "invalid_state");
+  }
+  return {
+    task: value.task,
+    repos: [...value.repos],
+    sessionId: value.sessionId
+  };
+}
+function toUploadStateRecord(value, filePath) {
+  if (value === null) {
+    return null;
+  }
+  if (!isJsonObject(value) || !isJsonObject(value.repos)) {
+    throw new StateError(`Invalid upload state in ${filePath}`, "invalid_state");
+  }
+  const repos = {};
+  for (const [repoId, repoState] of Object.entries(value.repos)) {
+    if (!isJsonObject(repoState) || !isUploadRepoStatus(repoState.status)) {
+      throw new StateError(
+        `Invalid upload repo state for ${repoId} in ${filePath}`,
+        "invalid_state"
+      );
+    }
+    repos[repoId] = {
+      ...repoState,
+      status: repoState.status
+    };
+  }
+  if (value.remoteLaunchId !== void 0 && typeof value.remoteLaunchId !== "string") {
+    throw new StateError(`Invalid remoteLaunchId in ${filePath}`, "invalid_state");
+  }
+  return {
+    ...typeof value.remoteLaunchId === "string" ? { remoteLaunchId: value.remoteLaunchId } : {},
+    repos
+  };
+}
+function toMissionRecord(value, filePath) {
+  if (value === null) {
+    return null;
+  }
+  if (!isJsonObject(value) || typeof value.missionId !== "string") {
+    throw new StateError(`Invalid mission state in ${filePath}`, "invalid_state");
+  }
+  return { missionId: value.missionId };
+}
+function resolvePhase(snapshot) {
+  if (snapshot.mission) {
+    return "mission_created";
+  }
+  if (snapshot.uploadState) {
+    return "uploading";
+  }
+  if (Object.keys(snapshot.repoManifests).length > 0) {
+    return "manifests_written";
+  }
+  if (snapshot.missionDraft) {
+    return "mission_draft_approved";
+  }
+  if (snapshot.clarification) {
+    return "clarification_resolved";
+  }
+  if (snapshot.request) {
+    return "planning_started";
+  }
+  return "idle";
+}
+function buildResumeState(snapshot) {
+  const manifestRepoIds = Object.keys(snapshot.repoManifests).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const uploadedRepoIds = manifestRepoIds.filter(
+    (repoId) => isTerminalUploadStatus(snapshot.uploadState?.repos[repoId]?.status ?? "pending")
+  );
+  const pendingUploadRepoIds = manifestRepoIds.filter(
+    (repoId) => !uploadedRepoIds.includes(repoId)
+  );
+  return {
+    skipPlanning: snapshot.phase === "mission_draft_approved" || snapshot.phase === "manifests_written" || snapshot.phase === "uploading" || snapshot.phase === "mission_created",
+    skipMissionCreation: snapshot.mission !== null,
+    missionId: snapshot.mission?.missionId ?? null,
+    manifestRepoIds,
+    pendingUploadRepoIds,
+    uploadedRepoIds
+  };
+}
+function validateSnapshot(snapshot) {
+  if (snapshot.clarification && !snapshot.request) {
+    throw new StateError(
+      "Clarification state exists without request.json",
+      "invalid_state"
+    );
+  }
+  if (snapshot.missionDraft && !snapshot.request) {
+    throw new StateError(
+      "Mission draft exists without request.json",
+      "invalid_state"
+    );
+  }
+  if (Object.keys(snapshot.repoManifests).length > 0 && !snapshot.missionDraft) {
+    throw new StateError(
+      "Repo manifests exist without mission-draft.json",
+      "invalid_state"
+    );
+  }
+  if (snapshot.uploadState && Object.keys(snapshot.repoManifests).length === 0) {
+    throw new StateError(
+      "upload-state.json exists without any repo manifests",
+      "invalid_state"
+    );
+  }
+  if (snapshot.uploadState) {
+    for (const repoId of Object.keys(snapshot.uploadState.repos)) {
+      if (!Object.hasOwn(snapshot.repoManifests, repoId)) {
+        throw new StateError(
+          `Upload state references unknown repo manifest: ${repoId}`,
+          "invalid_state"
+        );
+      }
+    }
+  }
+  if (snapshot.mission && !snapshot.uploadState) {
+    throw new StateError(
+      "mission.json exists without upload-state.json",
+      "invalid_state"
+    );
+  }
+}
+function compareJson(left, right) {
+  return serializeJson(left) === serializeJson(right);
+}
+function phaseAtLeast(current, expected) {
+  return PHASE_ORDER[current] >= PHASE_ORDER[expected];
+}
+function assertNoBackwardTransition(current, target, action) {
+  if (PHASE_ORDER[current] > PHASE_ORDER[target]) {
+    throw new StateError(
+      `Cannot move backward from ${current} while trying to ${action}.`,
+      "invalid_transition"
+    );
+  }
+}
+function createDeterministicLaunchId(input, options = {}) {
+  const hash = createHash("sha256").update(
+    serializeJson({
+      task: normalizeTask(input.task),
+      repos: normalizeRepoPaths(input.repoPaths, options)
+    })
+  ).digest("hex");
+  return `loc_${hash.slice(0, 24)}`;
+}
+function resolveLaunchPaths(launchId, options = {}) {
+  const normalizedLaunchId = normalizeLaunchId(launchId);
+  const launchesDir = resolveLaunchesDir(options);
+  const launchDir = path2.join(launchesDir, normalizedLaunchId);
+  const reposDir = path2.join(launchDir, "repos");
+  return {
+    launchesDir,
+    launchDir,
+    reposDir,
+    requestPath: path2.join(launchDir, "request.json"),
+    clarificationPath: path2.join(launchDir, "clarification.json"),
+    missionDraftPath: path2.join(launchDir, "mission-draft.json"),
+    uploadStatePath: path2.join(launchDir, "upload-state.json"),
+    missionPath: path2.join(launchDir, "mission.json")
+  };
+}
+async function ensureLaunchLayout(paths) {
+  await ensureDirectory(paths.launchesDir);
+  await ensureDirectory(paths.launchDir);
+  await ensureDirectory(paths.reposDir);
+}
+async function readRepoManifests(reposDir) {
+  const manifests = {};
+  let entries;
+  try {
+    entries = await readdir(reposDir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return manifests;
+    }
+    throw error;
+  }
+  for (const entry of entries.sort((left, right) => left.localeCompare(right))) {
+    if (!entry.endsWith(".manifest.json")) {
+      continue;
+    }
+    const repoId = entry.slice(0, -".manifest.json".length);
+    manifests[repoId] = await readJsonIfExists(path2.join(reposDir, entry)) ?? null;
+  }
+  return manifests;
+}
+async function loadLaunchSnapshot(launchId, options = {}) {
+  const paths = resolveLaunchPaths(launchId, options);
+  await ensureLaunchLayout(paths);
+  const request = toLaunchRequestRecord(
+    await readJsonIfExists(paths.requestPath),
+    paths.requestPath
+  );
+  const clarification = await readJsonIfExists(paths.clarificationPath);
+  const missionDraft = await readJsonIfExists(paths.missionDraftPath);
+  const repoManifests = await readRepoManifests(paths.reposDir);
+  const uploadState = toUploadStateRecord(
+    await readJsonIfExists(paths.uploadStatePath),
+    paths.uploadStatePath
+  );
+  const mission = toMissionRecord(
+    await readJsonIfExists(paths.missionPath),
+    paths.missionPath
+  );
+  const phase = resolvePhase({
+    launchId,
+    paths,
+    request,
+    clarification,
+    missionDraft,
+    repoManifests,
+    uploadState,
+    mission
+  });
+  const snapshotWithoutResume = {
+    launchId: normalizeLaunchId(launchId),
+    paths,
+    phase,
+    request,
+    clarification,
+    missionDraft,
+    repoManifests,
+    uploadState,
+    mission
+  };
+  validateSnapshot(snapshotWithoutResume);
+  return {
+    ...snapshotWithoutResume,
+    resume: buildResumeState(snapshotWithoutResume)
+  };
+}
+async function prepareLaunch(input, options = {}) {
+  const launchId = createDeterministicLaunchId(input, options);
+  return loadLaunchSnapshot(launchId, options);
+}
+async function recordPlanningStart(input, options = {}) {
+  const launchId = createDeterministicLaunchId(input, options);
+  const snapshot = await loadLaunchSnapshot(launchId, options);
+  const requestRecord = {
+    task: normalizeTask(input.task),
+    repos: normalizeRepoPaths(input.repoPaths, options),
+    sessionId: normalizeSessionId(input.sessionId)
+  };
+  if (snapshot.request) {
+    if (compareJson(snapshot.request, requestRecord)) {
+      return snapshot;
+    }
+    throw new StateError(
+      "request.json already exists with different content.",
+      "invalid_transition"
+    );
+  }
+  assertNoBackwardTransition(snapshot.phase, "planning_started", "record planning state");
+  await writeJsonAtomically(snapshot.paths.requestPath, requestRecord);
+  return loadLaunchSnapshot(launchId, options);
+}
+async function recordClarification(launchId, clarification, options = {}) {
+  const snapshot = await loadLaunchSnapshot(launchId, options);
+  if (!snapshot.request) {
+    throw new StateError(
+      "Cannot record clarification before request.json exists.",
+      "invalid_transition"
+    );
+  }
+  if (snapshot.clarification) {
+    if (compareJson(snapshot.clarification, clarification)) {
+      return snapshot;
+    }
+    throw new StateError(
+      "clarification.json already exists with different content.",
+      "invalid_transition"
+    );
+  }
+  assertNoBackwardTransition(snapshot.phase, "clarification_resolved", "record clarification");
+  await writeJsonAtomically(snapshot.paths.clarificationPath, clarification);
+  return loadLaunchSnapshot(snapshot.launchId, options);
+}
+async function recordMissionDraft(launchId, missionDraft, options = {}) {
+  const snapshot = await loadLaunchSnapshot(launchId, options);
+  if (!snapshot.request) {
+    throw new StateError(
+      "Cannot record mission draft before request.json exists.",
+      "invalid_transition"
+    );
+  }
+  if (snapshot.missionDraft) {
+    if (compareJson(snapshot.missionDraft, missionDraft)) {
+      return snapshot;
+    }
+    throw new StateError(
+      "mission-draft.json already exists with different content.",
+      "invalid_transition"
+    );
+  }
+  assertNoBackwardTransition(snapshot.phase, "mission_draft_approved", "record mission draft");
+  await writeJsonAtomically(snapshot.paths.missionDraftPath, missionDraft);
+  return loadLaunchSnapshot(snapshot.launchId, options);
+}
+async function recordRepoManifest(launchId, repoId, manifest, options = {}) {
+  const normalizedRepoId = normalizeRepoId(repoId);
+  const snapshot = await loadLaunchSnapshot(launchId, options);
+  if (!snapshot.missionDraft) {
+    throw new StateError(
+      "Cannot record repo manifests before mission-draft.json exists.",
+      "invalid_transition"
+    );
+  }
+  const existingManifest = snapshot.repoManifests[normalizedRepoId];
+  if (existingManifest !== void 0) {
+    if (compareJson(existingManifest, manifest)) {
+      return snapshot;
+    }
+    throw new StateError(
+      `Manifest for ${normalizedRepoId} already exists with different content.`,
+      "invalid_transition"
+    );
+  }
+  if (phaseAtLeast(snapshot.phase, "uploading")) {
+    throw new StateError(
+      "Cannot add repo manifests after upload-state.json exists.",
+      "invalid_transition"
+    );
+  }
+  await writeJsonAtomically(
+    path2.join(snapshot.paths.reposDir, `${normalizedRepoId}.manifest.json`),
+    manifest
+  );
+  return loadLaunchSnapshot(snapshot.launchId, options);
+}
+function normalizeUploadUpdate(update) {
+  return Object.fromEntries(
+    Object.entries(update).filter(([, value]) => value !== void 0)
+  );
+}
+async function updateRepoUploadState(launchId, update, options = {}) {
+  const normalizedRepoId = normalizeRepoId(update.repoId);
+  const snapshot = await loadLaunchSnapshot(launchId, options);
+  if (!snapshot.missionDraft) {
+    throw new StateError(
+      "Cannot update upload state before mission-draft.json exists.",
+      "invalid_transition"
+    );
+  }
+  if (!Object.hasOwn(snapshot.repoManifests, normalizedRepoId)) {
+    throw new StateError(
+      `Cannot update upload state for ${normalizedRepoId} before its manifest exists.`,
+      "invalid_transition"
+    );
+  }
+  if (snapshot.phase === "mission_created") {
+    throw new StateError(
+      "Cannot update upload-state.json after mission.json exists.",
+      "invalid_transition"
+    );
+  }
+  const currentState = snapshot.uploadState ?? { repos: {} };
+  const currentRepoState = currentState.repos[normalizedRepoId];
+  const nextStatus = update.status;
+  const currentStatus = currentRepoState?.status;
+  if (currentStatus) {
+    const currentRank = UPLOAD_STATUS_ORDER[currentStatus];
+    const nextRank = UPLOAD_STATUS_ORDER[nextStatus];
+    if (nextRank < currentRank) {
+      throw new StateError(
+        `Cannot move upload state for ${normalizedRepoId} backward from ${currentStatus} to ${nextStatus}.`,
+        "invalid_transition"
+      );
+    }
+    if (nextRank === currentRank && currentStatus !== nextStatus) {
+      throw new StateError(
+        `Cannot replace upload state ${currentStatus} with ${nextStatus} for ${normalizedRepoId}.`,
+        "invalid_transition"
+      );
+    }
+  }
+  const remoteLaunchId = update.remoteLaunchId?.trim();
+  if (currentState.remoteLaunchId && remoteLaunchId && currentState.remoteLaunchId !== remoteLaunchId) {
+    throw new StateError(
+      "upload-state.json already records a different remoteLaunchId.",
+      "invalid_transition"
+    );
+  }
+  const { repoId: _repoId, remoteLaunchId: _ignoredRemoteLaunchId, ...rest } = normalizeUploadUpdate(update);
+  const repoState = {
+    ...currentRepoState ?? {},
+    ...rest,
+    status: nextStatus
+  };
+  const nextState = {
+    ...currentState.remoteLaunchId || remoteLaunchId ? { remoteLaunchId: currentState.remoteLaunchId ?? remoteLaunchId } : {},
+    repos: {
+      ...currentState.repos,
+      [normalizedRepoId]: repoState
+    }
+  };
+  await writeJsonAtomically(snapshot.paths.uploadStatePath, nextState);
+  return loadLaunchSnapshot(snapshot.launchId, options);
+}
+async function recordMissionCreated(launchId, missionId, options = {}) {
+  const normalizedMissionId = normalizeMissionId(missionId);
+  const snapshot = await loadLaunchSnapshot(launchId, options);
+  if (!snapshot.uploadState) {
+    throw new StateError(
+      "Cannot record mission.json before upload-state.json exists.",
+      "invalid_transition"
+    );
+  }
+  const manifestRepoIds = Object.keys(snapshot.repoManifests);
+  const incompleteRepos = manifestRepoIds.filter((repoId) => {
+    const status = snapshot.uploadState?.repos[repoId]?.status;
+    return status === void 0 || !isTerminalUploadStatus(status);
+  });
+  if (incompleteRepos.length > 0) {
+    throw new StateError(
+      `Cannot record mission.json before uploads finish for: ${incompleteRepos.join(", ")}`,
+      "invalid_transition"
+    );
+  }
+  if (snapshot.mission) {
+    if (snapshot.mission.missionId === normalizedMissionId) {
+      return snapshot;
+    }
+    throw new StateError(
+      `mission.json already exists with a different mission ID (${snapshot.mission.missionId}).`,
+      "invalid_transition"
+    );
+  }
+  await writeJsonAtomically(snapshot.paths.missionPath, {
+    missionId: normalizedMissionId
+  });
+  return loadLaunchSnapshot(snapshot.launchId, options);
+}
+
+// src/mission.ts
+function asNonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asNullableNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isRecord2(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function toMissionDraft(value) {
+  if (!isRecord2(value)) {
+    throw new CliError(
+      "Cannot create a mission before mission-draft.json has been written."
+    );
+  }
+  return value;
+}
+function toRepoRefs(value) {
+  const repoIds = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  if (repoIds.length === 0) {
+    throw new CliError(
+      "Cannot create a mission before repo manifests have been recorded."
+    );
+  }
+  return repoIds.map((repoId) => {
+    const manifest = value[repoId];
+    if (!isRecord2(manifest)) {
+      throw new CliError(`Saved repo manifest ${repoId} is invalid.`);
+    }
+    return manifest;
+  });
+}
+function normalizeBudgetDetails(value) {
+  const details = isRecord2(value) ? value : {};
+  const warnAtBudgetPercent = Object.hasOwn(details, "warnAtBudgetPercent") ? asNullableNumber2(details.warnAtBudgetPercent) : void 0;
+  return {
+    exceeded: Array.isArray(details.exceeded) ? details.exceeded.filter(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    ) : [],
+    maxInferenceCost: asNullableNumber2(details.maxInferenceCost),
+    maxInferenceTokens: asNullableNumber2(details.maxInferenceTokens),
+    percent_used: asNullableNumber2(details.percent_used),
+    totalCost: asNullableNumber2(details.totalCost),
+    totalTokens: asNullableNumber2(details.totalTokens),
+    ...warnAtBudgetPercent === void 0 ? {} : { warnAtBudgetPercent }
+  };
+}
+async function createMissionFromLaunch(options) {
+  const snapshot = await loadLaunchSnapshot(options.launchId, {
+    cwd: options.cwd,
+    homeDir: options.homeDir
+  });
+  if (snapshot.mission?.missionId) {
+    return {
+      created: false,
+      missionId: snapshot.mission.missionId,
+      state: null
+    };
+  }
+  const remoteLaunchId = asNonEmptyString2(snapshot.uploadState?.remoteLaunchId);
+  if (!remoteLaunchId) {
+    throw new CliError(
+      "Cannot create a mission before the remote launch has been finalized."
+    );
+  }
+  if (snapshot.resume.pendingUploadRepoIds.length > 0) {
+    throw new CliError(
+      `Cannot create a mission while uploads are still pending for: ${snapshot.resume.pendingUploadRepoIds.join(", ")}`
+    );
+  }
+  const missionDraft = toMissionDraft(snapshot.missionDraft);
+  const repoRefs = toRepoRefs(snapshot.repoManifests);
+  const clarificationSummary = snapshot.clarification ?? null;
+  const response = await options.apiClient.request({
+    body: {
+      clarificationSummary,
+      launchId: remoteLaunchId,
+      missionDraft,
+      repoRefs
+    },
+    method: "POST",
+    path: "/missions"
+  });
+  const missionId = asNonEmptyString2(response.missionId);
+  if (!missionId) {
+    throw new CliError("Mission creation did not return a mission ID.");
+  }
+  await recordMissionCreated(options.launchId, missionId, {
+    cwd: options.cwd,
+    homeDir: options.homeDir
+  });
+  return {
+    created: true,
+    missionId,
+    state: asNonEmptyString2(response.state)
+  };
+}
+async function startMission(apiClient, missionId) {
+  const response = await apiClient.request({
+    body: {},
+    method: "POST",
+    path: `/missions/${missionId}/mission/start`
+  });
+  const type = asNonEmptyString2(response.type);
+  switch (type) {
+    case "dispatched": {
+      const featureId = asNonEmptyString2(response.featureId);
+      const workerSessionId = asNonEmptyString2(response.workerSessionId);
+      if (!featureId || !workerSessionId) {
+        throw new CliError(
+          "Mission start returned `dispatched` without featureId or workerSessionId."
+        );
+      }
+      return {
+        featureId,
+        type,
+        workerSessionId
+      };
+    }
+    case "no_work":
+    case "completed":
+      return { type };
+    case "budget_exceeded":
+      return {
+        details: normalizeBudgetDetails(response.details),
+        state: asNonEmptyString2(response.state),
+        type
+      };
+    default:
+      throw new CliError(
+        `Mission start returned an unexpected response type: ${type ?? "unknown"}.`
+      );
+  }
+}
+
+// src/triage.ts
+import {
+  input as defaultInputPrompt,
+  select as defaultSelectPrompt
+} from "@inquirer/prompts";
+import pc2 from "picocolors";
+var TRIAGE_PROGRESS_PAGE_SIZE = 200;
+var AUTO_DISMISS_RATIONALE = "Auto-dismissed by `hz mission run --yes`.";
+function isRecord3(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function asNonEmptyString3(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.map((entry) => asNonEmptyString3(entry)).filter((entry) => entry !== null) : [];
+}
+function normalizeFeature(value) {
+  if (!isRecord3(value)) {
+    throw new CliError("Mission feature entry was not an object.");
+  }
+  const id = asNonEmptyString3(value.id);
+  if (!id) {
+    throw new CliError("Mission feature entry is missing an id.");
+  }
+  return {
+    attemptCount: asFiniteNumber2(value.attemptCount),
+    description: asNonEmptyString3(value.description) ?? "No description provided.",
+    expectedBehavior: asStringArray(value.expectedBehavior),
+    fulfills: asStringArray(value.fulfills),
+    id,
+    isFixFeature: value.isFixFeature === true,
+    milestone: asNonEmptyString3(value.milestone),
+    preconditions: asStringArray(value.preconditions),
+    skillName: asNonEmptyString3(value.skillName),
+    status: asNonEmptyString3(value.status) ?? "unknown",
+    verificationSteps: asStringArray(value.verificationSteps),
+    workerSessionIds: asStringArray(value.workerSessionIds)
+  };
+}
+function normalizeAssertion(value) {
+  if (!isRecord3(value)) {
+    throw new CliError("Mission assertion entry was not an object.");
+  }
+  const id = asNonEmptyString3(value.id);
+  if (!id) {
+    throw new CliError("Mission assertion entry is missing an id.");
+  }
+  return {
+    description: asNonEmptyString3(value.description) ?? "",
+    id,
+    milestone: asNonEmptyString3(value.milestone),
+    ownerFeatureId: asNonEmptyString3(value.ownerFeatureId),
+    status: asNonEmptyString3(value.status) ?? "unknown",
+    title: asNonEmptyString3(value.title) ?? id
+  };
+}
+function normalizeSuggestedAction(value) {
+  if (!isRecord3(value)) {
+    return null;
+  }
+  const type = asNonEmptyString3(value.type);
+  if (!type) {
+    return null;
+  }
+  return {
+    command: asNonEmptyString3(value.command) ?? void 0,
+    details: asNonEmptyString3(value.details) ?? void 0,
+    exitCode: typeof value.exitCode === "number" ? value.exitCode : void 0,
+    issue: asNonEmptyString3(value.issue) ?? void 0,
+    suggestedFix: asNonEmptyString3(value.suggestedFix) ?? void 0,
+    successState: asNonEmptyString3(value.successState) ?? void 0,
+    type
+  };
+}
+function normalizeProgressEvent(value) {
+  if (!isRecord3(value)) {
+    return null;
+  }
+  return {
+    data: value.data,
+    seq: asFiniteNumber2(value.seq),
+    type: asNonEmptyString3(value.type)
+  };
+}
+async function defaultPromptSelect(options) {
+  return defaultSelectPrompt({
+    choices: options.choices.map((choice) => ({
+      description: choice.description,
+      name: choice.name,
+      value: choice.value
+    })),
+    message: options.message
+  });
+}
+async function defaultPromptInput(options) {
+  return defaultInputPrompt({
+    default: options.default,
+    message: options.message
+  });
+}
+function buildIssueId(featureId) {
+  return `triage:${featureId}`;
+}
+async function fetchTriageFeatures(apiClient, missionId) {
+  const response = await apiClient.request({
+    path: `/missions/${missionId}/features`
+  });
+  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) {
+  const response = await apiClient.request({
+    path: `/missions/${missionId}/assertions`
+  });
+  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) {
+  const eventsByFeature = /* @__PURE__ */ new Map();
+  let since = 0;
+  for (; ; ) {
+    const response = await apiClient.request({
+      path: `/missions/${missionId}/progress?since=${since}&limit=${TRIAGE_PROGRESS_PAGE_SIZE}`
+    });
+    if (!Array.isArray(response) || response.length === 0) {
+      break;
+    }
+    let lastSeq = since;
+    for (const rawEvent of response) {
+      const event = normalizeProgressEvent(rawEvent);
+      if (!event) {
+        continue;
+      }
+      lastSeq = Math.max(lastSeq, event.seq);
+      if (event.type !== "triage.needed" || !isRecord3(event.data)) {
+        continue;
+      }
+      const featureId = asNonEmptyString3(event.data.featureId);
+      if (!featureId) {
+        continue;
+      }
+      const suggestedActions = Array.isArray(event.data.suggestedActions) ? event.data.suggestedActions.map((entry) => normalizeSuggestedAction(entry)).filter((entry) => entry !== null) : [];
+      const existing = eventsByFeature.get(featureId);
+      if (!existing || event.seq >= existing.seq) {
+        eventsByFeature.set(featureId, {
+          seq: event.seq,
+          suggestedActions
+        });
+      }
+    }
+    if (lastSeq <= since) {
+      break;
+    }
+    since = lastSeq;
+  }
+  return new Map(
+    [...eventsByFeature.entries()].map(([featureId, event]) => [
+      featureId,
+      event.suggestedActions
+    ])
+  );
+}
+function describeSuggestedAction(action) {
+  switch (action.type) {
+    case "resolve_blocking_issue":
+      return action.suggestedFix ? `${action.issue ?? "Blocking issue"} (${action.suggestedFix})` : action.issue ?? "Blocking issue";
+    case "finish_remaining_work":
+      return action.details ?? "Finish the remaining implementation work.";
+    case "fix_failed_verification":
+      return action.command ? `Fix failed verification: ${action.command}${action.exitCode === void 0 ? "" : ` (exit ${action.exitCode})`}` : "Fix a failed verification command.";
+    case "review_failed_handoff":
+      return action.successState ? `Review a ${action.successState} handoff before redispatching.` : "Review the failed handoff before redispatching.";
+    default:
+      return action.details ?? action.issue ?? action.command ?? action.type;
+  }
+}
+function buildFailureDescription(feature, suggestedActions) {
+  const blockingIssue = suggestedActions.find(
+    (action) => action.type === "resolve_blocking_issue" && action.issue
+  );
+  if (blockingIssue?.issue) {
+    return blockingIssue.issue;
+  }
+  const remainingWork = suggestedActions.find(
+    (action) => action.type === "finish_remaining_work" && action.details
+  );
+  if (remainingWork?.details) {
+    return remainingWork.details;
+  }
+  const failedVerification = suggestedActions.find(
+    (action) => action.type === "fix_failed_verification" && action.command
+  );
+  if (failedVerification?.command) {
+    return `Verification failed: ${failedVerification.command}${failedVerification.exitCode === void 0 ? "" : ` (exit ${failedVerification.exitCode})`}.`;
+  }
+  return `Worker handoff for ${feature.id} requires orchestrator triage.`;
+}
+function buildTriageItem(feature, allAssertions, suggestedActionsByFeature) {
+  const assertions = allAssertions.filter(
+    (assertion) => assertion.ownerFeatureId === feature.id || feature.fulfills.includes(assertion.id)
+  );
+  const suggestedActions = [...suggestedActionsByFeature.get(feature.id) ?? []];
+  return {
+    assertions,
+    failureDescription: buildFailureDescription(feature, suggestedActions),
+    feature,
+    issueId: buildIssueId(feature.id),
+    suggestedActions
+  };
+}
+function writeItemBlock(stdout, item) {
+  writeLine(stdout);
+  writeLine(stdout, pc2.bold(`Triage required for ${pc2.cyan(item.feature.id)}`));
+  writeLine(stdout, `Failure: ${item.failureDescription}`);
+  writeLine(
+    stdout,
+    `Affected assertions: ${item.assertions.length === 0 ? "none recorded" : item.assertions.map((assertion) => `${assertion.id} (${assertion.status})`).join(", ")}`
+  );
+  if (item.suggestedActions.length > 0) {
+    writeLine(stdout, "Suggested actions:");
+    for (const action of item.suggestedActions) {
+      writeLine(stdout, `- ${describeSuggestedAction(action)}`);
+    }
+  }
+  writeLine(
+    stdout,
+    "Available actions: dismiss, create-fix, reassign assertions, skip"
+  );
+}
+function buildActionChoices(item) {
+  return [
+    {
+      description: "Record a rationale and continue monitoring.",
+      name: "dismiss",
+      value: "dismiss"
+    },
+    {
+      description: "Create a follow-up fix feature automatically.",
+      name: "create-fix",
+      value: "create-fix"
+    },
+    {
+      description: item.assertions.length === 0 ? "No affected assertions are available to move." : "Move affected assertions to another feature.",
+      name: "reassign assertions",
+      value: "reassign-assertions"
+    },
+    {
+      description: "Leave this item unresolved for now.",
+      name: "skip",
+      value: "skip"
+    }
+  ];
+}
+function generateFixFeatureId(sourceFeatureId, features) {
+  const existingIds = new Set(features.map((feature) => feature.id));
+  const baseId = `${sourceFeatureId}-fix`;
+  if (!existingIds.has(baseId)) {
+    return baseId;
+  }
+  for (let suffix = 2; suffix < 1e3; suffix += 1) {
+    const candidate = `${baseId}-${suffix}`;
+    if (!existingIds.has(candidate)) {
+      return candidate;
+    }
+  }
+  throw new CliError(`Could not generate a unique fix feature id for ${sourceFeatureId}.`);
+}
+function toFixFeaturePayload(item, features) {
+  const id = generateFixFeatureId(item.feature.id, features);
+  const milestone = item.feature.milestone;
+  if (!milestone) {
+    throw new CliError(
+      `Cannot create a fix feature for ${item.feature.id} because it has no milestone.`
+    );
+  }
+  return {
+    description: `Resolve triage for ${item.feature.id}: ${item.failureDescription}`,
+    expectedBehavior: item.feature.expectedBehavior.length > 0 ? [...item.feature.expectedBehavior] : [`Resolve triage issues for ${item.feature.id}.`],
+    fulfills: [],
+    id,
+    milestone,
+    preconditions: [],
+    skillName: item.feature.skillName,
+    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) {
+  const trimmedRationale = rationale.trim();
+  if (trimmedRationale.length === 0) {
+    throw new CliError("Dismissal rationale is required.");
+  }
+  await apiClient.request({
+    body: {
+      items: [
+        {
+          issueId: item.issueId,
+          rationale: trimmedRationale
+        }
+      ]
+    },
+    method: "POST",
+    path: `/missions/${missionId}/triage/dismiss`
+  });
+}
+async function createFixFeature(apiClient, missionId, item, features) {
+  const feature = toFixFeaturePayload(item, features);
+  await apiClient.request({
+    body: { feature },
+    method: "POST",
+    path: `/missions/${missionId}/triage/create-fix`
+  });
+  return feature;
+}
+async function reassignAssertions(apiClient, missionId, item, features, promptSelect) {
+  if (item.assertions.length === 0) {
+    return 0;
+  }
+  const destinationChoices = features.filter((feature) => feature.id !== item.feature.id).map((feature) => ({
+    description: feature.milestone ? `Milestone: ${feature.milestone} \xB7 Status: ${feature.status}` : `Status: ${feature.status}`,
+    name: feature.id,
+    value: feature.id
+  }));
+  if (destinationChoices.length === 0) {
+    return 0;
+  }
+  const moves = [];
+  for (const assertion of item.assertions) {
+    const targetFeatureId = await promptSelect({
+      choices: destinationChoices,
+      message: `Move ${assertion.id} to which feature?`
+    });
+    const targetFeature = features.find((feature) => feature.id === targetFeatureId);
+    const targetMilestone = targetFeature?.milestone ?? assertion.milestone ?? item.feature.milestone;
+    if (!targetFeature || !targetMilestone) {
+      throw new CliError(
+        `Cannot move ${assertion.id} because the selected feature has no milestone.`
+      );
+    }
+    moves.push({
+      assertionId: assertion.id,
+      toFeatureId: targetFeature.id,
+      toMilestone: targetMilestone
+    });
+  }
+  if (moves.length === 0) {
+    return 0;
+  }
+  await apiClient.request({
+    body: { moves },
+    method: "POST",
+    path: `/missions/${missionId}/triage/reassign-assertions`
+  });
+  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, pc2.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,
+      pc2.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 ${pc2.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 ${pc2.cyan(createdFeature.id)} for ${pc2.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;
+          writeLine(
+            options.stdout,
+            pc2.yellow(
+              `No assertions were reassigned for ${pc2.cyan(item.feature.id)}.`
+            )
+          );
+          break;
+        }
+        result.movedAssertions += moved;
+        writeLine(
+          options.stdout,
+          `Reassigned ${moved} assertion${moved === 1 ? "" : "s"} for ${pc2.cyan(item.feature.id)}.`
+        );
+        break;
+      }
+      case "skip":
+      default:
+        result.skipped += 1;
+        writeLine(
+          options.stdout,
+          pc2.dim(`Skipped triage for ${item.feature.id}; it will remain unresolved.`)
+        );
+        break;
+    }
+    result.handledFeatureIds.push(item.feature.id);
+  }
+  return result;
+}
+
+// src/monitor.ts
+var ALL_MISSION_CHANNELS = [
+  "assertions",
+  "features",
+  "handoffs",
+  "milestones",
+  "progress",
+  "state",
+  "triage",
+  "workers"
+];
+var INITIAL_RECONNECT_DELAY_MS = 250;
+var MAX_RECONNECT_DELAY_MS = 4e3;
+function asNonEmptyString4(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asFiniteNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isRecord4(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function defaultCreateSpinner(text) {
+  const spinner = ora({ text });
+  return {
+    get text() {
+      return spinner.text;
+    },
+    set text(value) {
+      spinner.text = value;
+    },
+    fail(message) {
+      if (message) {
+        spinner.text = message;
+      }
+      spinner.fail();
+    },
+    start(message) {
+      if (message) {
+        spinner.text = message;
+      }
+      spinner.start();
+    },
+    stop() {
+      spinner.stop();
+    },
+    succeed(message) {
+      if (message) {
+        spinner.text = message;
+      }
+      spinner.succeed();
+    }
+  };
+}
+function defaultCreateWebSocket(url, options) {
+  return new WebSocket(url, { headers: options.headers });
+}
+function defaultRegisterSignalHandler(signal, handler) {
+  process.once(signal, handler);
+  return () => {
+    process.off(signal, handler);
+  };
+}
+function createMissionWebSocketUrl(endpoint, missionId) {
+  const url = new URL(`/ws/missions/${missionId}`, endpoint);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.toString();
+}
+function formatCurrency2(amount) {
+  return amount === null ? "?" : `$${amount.toFixed(2)}`;
+}
+function formatBudgetUsage(details) {
+  const parts = [];
+  if (details.totalCost !== null || details.maxInferenceCost !== null) {
+    parts.push(`${formatCurrency2(details.totalCost)} / ${formatCurrency2(details.maxInferenceCost)}`);
+  }
+  if (details.totalTokens !== null || details.maxInferenceTokens !== null) {
+    parts.push(
+      `${details.totalTokens ?? "?"} tokens / ${details.maxInferenceTokens ?? "?"} tokens`
+    );
+  }
+  if (details.percent_used !== null) {
+    parts.push(`${details.percent_used}% used`);
+  }
+  return parts.join(" \xB7 ");
+}
+function formatSummaryLine(summary) {
+  return `${summary.completedFeatures}/${summary.totalFeatures} features \xB7 ${summary.passedAssertions}/${summary.totalAssertions} assertions`;
+}
+function formatSpinnerText(missionId, summary) {
+  return `${pc3.cyan(missionId)} ${pc3.bold(summary.state)} \xB7 ${formatSummaryLine(summary)}`;
+}
+function normalizeSummary(missionId, value) {
+  if (!isRecord4(value)) {
+    throw new Error("Progress summary response was not a JSON object.");
+  }
+  return {
+    completedFeatures: asFiniteNumber3(value.completedFeatures),
+    currentFeatureId: asNonEmptyString4(value.currentFeatureId),
+    currentWorkerSessionId: asNonEmptyString4(value.currentWorkerSessionId),
+    dispatchedFeatures: asFiniteNumber3(value.dispatchedFeatures),
+    failedFeatures: asFiniteNumber3(value.failedFeatures),
+    head: asFiniteNumber3(value.head),
+    lastEventAt: asNonEmptyString4(value.lastEventAt),
+    lastEventType: asNonEmptyString4(value.lastEventType),
+    missionId: asNonEmptyString4(value.missionId) ?? missionId,
+    needsTriageFeatures: asFiniteNumber3(value.needsTriageFeatures),
+    openMilestones: asFiniteNumber3(value.openMilestones),
+    passedAssertions: asFiniteNumber3(value.passedAssertions),
+    pendingAssertions: asFiniteNumber3(value.pendingAssertions),
+    pendingFeatures: asFiniteNumber3(value.pendingFeatures),
+    runningFeatures: asFiniteNumber3(value.runningFeatures),
+    sealedMilestones: asFiniteNumber3(value.sealedMilestones),
+    state: asNonEmptyString4(value.state) ?? "unknown",
+    totalAssertions: asFiniteNumber3(value.totalAssertions),
+    totalFeatures: asFiniteNumber3(value.totalFeatures),
+    totalMilestones: asFiniteNumber3(value.totalMilestones)
+  };
+}
+function parseMissionEvent(message) {
+  const text = readWebSocketMessageText(message);
+  if (!text) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(text);
+    return isRecord4(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+function readWebSocketMessageText(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message instanceof ArrayBuffer) {
+    return new TextDecoder().decode(message);
+  }
+  if (ArrayBuffer.isView(message)) {
+    return new TextDecoder().decode(message);
+  }
+  return "";
+}
+function parseProgressEvent(event) {
+  return isRecord4(event) ? event : null;
+}
+function buildBackfillDescription(event) {
+  const type = asNonEmptyString4(event.type) ?? "event";
+  const data = isRecord4(event.data) ? event.data : {};
+  const featureId = asNonEmptyString4(data.featureId);
+  const milestone = asNonEmptyString4(data.milestone);
+  const assertionId = asNonEmptyString4(data.assertionId);
+  if (featureId) {
+    return `Backfilled ${type} for ${pc3.cyan(featureId)}.`;
+  }
+  if (assertionId) {
+    return `Backfilled ${type} for ${pc3.cyan(assertionId)}.`;
+  }
+  if (milestone) {
+    return `Backfilled ${type} for milestone ${pc3.cyan(milestone)}.`;
+  }
+  return `Backfilled ${type}.`;
+}
+function safeCloseSocket(socket, code = 1e3, reason = "closed") {
+  if (!socket) {
+    return;
+  }
+  try {
+    socket.close(code, reason);
+  } catch {
+  }
+}
+async function waitForSocketOpen(socket) {
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const settle = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      callback();
+    };
+    socket.on("open", () => settle(resolve));
+    socket.on("error", (error) => {
+      settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+    });
+    socket.on("close", () => {
+      settle(() => reject(new Error("WebSocket closed before opening.")));
+    });
+  });
+}
+function toReconnectDelay(attempt) {
+  return Math.min(MAX_RECONNECT_DELAY_MS, INITIAL_RECONNECT_DELAY_MS * 2 ** attempt);
+}
+async function fetchSummary(apiClient, missionId) {
+  const response = await apiClient.request({
+    path: `/missions/${missionId}/progress/summary`
+  });
+  return normalizeSummary(missionId, response);
+}
+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));
+  let summary = await fetchSummary(options.apiClient, options.missionId);
+  let lastSeen = summary.head;
+  let pausedForBudget = false;
+  let pausedForTriage = false;
+  let reconnectAttempt = 0;
+  let connectedOnce = false;
+  let interrupted = false;
+  let triageInFlight = false;
+  let activeSocket = null;
+  let settleActiveConnection = null;
+  let startInFlight = false;
+  const spinner = createSpinner(formatSpinnerText(options.missionId, summary));
+  spinner.start();
+  writeLine(
+    options.stdout,
+    `Monitoring mission ${pc3.cyan(options.missionId)} \xB7 ${formatSummaryLine(summary)}`
+  );
+  const updateSpinner = () => {
+    spinner.text = formatSpinnerText(options.missionId, summary);
+  };
+  const refreshSummary = async () => {
+    summary = await fetchSummary(options.apiClient, options.missionId);
+    lastSeen = Math.max(lastSeen, summary.head);
+    updateSpinner();
+    return summary;
+  };
+  const completedResult = async () => {
+    await refreshSummary();
+    const message = `Mission completed \xB7 ${formatSummaryLine(summary)}`;
+    spinner.succeed(message);
+    writeLine(options.stdout, pc3.green(message));
+    return {
+      exitCode: 0,
+      reason: "completed",
+      summary
+    };
+  };
+  const budgetExceededResult = async (details) => {
+    pausedForBudget = true;
+    await refreshSummary();
+    const message = `Budget exceeded \xB7 ${formatBudgetUsage(details)}`;
+    spinner.fail(message);
+    writeLine(options.stdout, pc3.red(message));
+    return {
+      exitCode: 1,
+      reason: "budget_exceeded",
+      summary
+    };
+  };
+  const completeTriage = async () => {
+    if (triageInFlight) {
+      return null;
+    }
+    triageInFlight = true;
+    try {
+      const triageResult = await runTriageInteraction({
+        apiClient: options.apiClient,
+        autoApprove: options.autoApprove,
+        missionId: options.missionId,
+        promptInput: options.promptInput,
+        promptSelect: options.promptSelect,
+        stdout: options.stdout
+      });
+      if (triageResult.totalItems === 0) {
+        writeLine(
+          options.stdout,
+          pc3.dim("No triage items required action. Resuming the orchestration loop.")
+        );
+      } else {
+        writeLine(
+          options.stdout,
+          pc3.green(
+            `Triage complete \xB7 ${triageResult.dismissed} dismissed \xB7 ${triageResult.createdFixes} fix features \xB7 ${triageResult.movedAssertions} assertions moved \xB7 ${triageResult.skipped} skipped`
+          )
+        );
+      }
+    } finally {
+      triageInFlight = false;
+      pausedForTriage = false;
+    }
+    await refreshSummary();
+    return maybeAutoStart();
+  };
+  const interruptedResult = () => {
+    spinner.fail("Monitoring stopped.");
+    writeLine(
+      options.stdout,
+      pc3.yellow("Interrupted. Local state is saved. Remote mission continues.")
+    );
+    return {
+      exitCode: 130,
+      reason: "interrupted",
+      summary
+    };
+  };
+  const maybeAutoStart = async () => {
+    if (startInFlight || triageInFlight || pausedForBudget || pausedForTriage || summary.state !== "orchestrator_turn") {
+      return null;
+    }
+    startInFlight = true;
+    try {
+      const result = await startMission(options.apiClient, options.missionId);
+      switch (result.type) {
+        case "dispatched":
+          writeLine(
+            options.stdout,
+            `Dispatching ${pc3.cyan(result.featureId)} (${pc3.dim(result.workerSessionId)}).`
+          );
+          return null;
+        case "no_work":
+          writeLine(
+            options.stdout,
+            pc3.dim("No eligible work is available yet. Waiting for updates.")
+          );
+          return null;
+        case "completed":
+          return completedResult();
+        case "budget_exceeded":
+          return budgetExceededResult(result.details);
+      }
+    } finally {
+      startInFlight = false;
+    }
+  };
+  const unregisterSignalHandler = registerSignalHandler("SIGINT", () => {
+    interrupted = true;
+    safeCloseSocket(activeSocket, 1e3, "SIGINT");
+    settleActiveConnection?.(interruptedResult());
+  });
+  try {
+    for (; ; ) {
+      if (interrupted) {
+        return interruptedResult();
+      }
+      const socket = createWebSocket(
+        createMissionWebSocketUrl(options.endpoint, options.missionId),
+        {
+          headers: {
+            authorization: `Bearer ${options.apiKey}`
+          }
+        }
+      );
+      activeSocket = socket;
+      try {
+        await waitForSocketOpen(socket);
+      } catch (error) {
+        if (interrupted) {
+          return interruptedResult();
+        }
+        const delayMs2 = toReconnectDelay(reconnectAttempt);
+        reconnectAttempt += 1;
+        writeLine(
+          options.stdout,
+          pc3.yellow(
+            `WebSocket connection failed: ${error instanceof Error ? error.message : String(error)}. Reconnecting in ${delayMs2} ms...`
+          )
+        );
+        await sleep(delayMs2);
+        continue;
+      }
+      reconnectAttempt = 0;
+      socket.send(
+        JSON.stringify({
+          channels: [...ALL_MISSION_CHANNELS],
+          type: "subscribe"
+        })
+      );
+      const connectionResult = await new Promise(
+        async (resolve) => {
+          let settled = false;
+          let pending = Promise.resolve();
+          const resolveOnce = (result) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            resolve(result);
+          };
+          settleActiveConnection = resolveOnce;
+          const processLiveEvent = async (event) => {
+            const type = asNonEmptyString4(event.type);
+            if (!type) {
+              return null;
+            }
+            const data = isRecord4(event.data) ? event.data : {};
+            switch (type) {
+              case "state_changed": {
+                const state = asNonEmptyString4(data.state) ?? "unknown";
+                writeLine(options.stdout, `Mission state \u2192 ${pc3.cyan(state)}`);
+                await refreshSummary();
+                if (state === "completed") {
+                  return completedResult();
+                }
+                if (state === "orchestrator_turn") {
+                  return maybeAutoStart();
+                }
+                return null;
+              }
+              case "feature_updated": {
+                const featureId = asNonEmptyString4(data.featureId) ?? "feature";
+                const status = asNonEmptyString4(data.status) ?? "updated";
+                if (status === "needs_triage") {
+                  pausedForTriage = true;
+                }
+                writeLine(
+                  options.stdout,
+                  `Feature ${pc3.cyan(featureId)} \u2192 ${pc3.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 ${pc3.cyan(milestone)} \u2192 ${pc3.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 ${pc3.cyan(assertionId)} \u2192 ${pc3.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 ${pc3.cyan(featureId)} (${status}).`
+                );
+                return null;
+              }
+              case "triage_needed": {
+                pausedForTriage = true;
+                const featureId = asNonEmptyString4(data.featureId) ?? "feature";
+                writeLine(
+                  options.stdout,
+                  pc3.yellow(
+                    `Triage is required for ${pc3.cyan(featureId)}. Auto-start is paused.`
+                  )
+                );
+                return completeTriage();
+              }
+              case "worker_timeout": {
+                const featureId = asNonEmptyString4(data.featureId) ?? "feature";
+                writeLine(
+                  options.stdout,
+                  pc3.yellow(`Worker timed out for ${pc3.cyan(featureId)}.`)
+                );
+                await refreshSummary();
+                return null;
+              }
+              case "budget_warning": {
+                const details = normalizeBudgetDetails(data);
+                writeLine(
+                  options.stdout,
+                  pc3.yellow(`Budget warning \xB7 ${formatBudgetUsage(details)}`)
+                );
+                await refreshSummary();
+                return null;
+              }
+              case "budget_exceeded":
+                return budgetExceededResult(normalizeBudgetDetails(data));
+              default:
+                return null;
+            }
+          };
+          socket.on("message", (message) => {
+            pending = pending.then(async () => {
+              const event = parseMissionEvent(message);
+              if (!event) {
+                return;
+              }
+              const result = await processLiveEvent(event);
+              if (!result) {
+                return;
+              }
+              safeCloseSocket(socket, 1e3, result.reason);
+              resolveOnce(result);
+            }).catch((error) => {
+              writeLine(
+                options.stdout,
+                pc3.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,
+              pc3.yellow(
+                `WebSocket error: ${error instanceof Error ? error.message : String(error)}`
+              )
+            );
+            safeCloseSocket(socket, 1011, "socket_error");
+          });
+          socket.on("close", () => {
+            void pending.finally(() => {
+              if (settled) {
+                return;
+              }
+              if (interrupted) {
+                resolveOnce(interruptedResult());
+                return;
+              }
+              resolveOnce("reconnect");
+            });
+          });
+          if (connectedOnce && lastSeen > 0) {
+            const events = await options.apiClient.request({
+              path: `/missions/${options.missionId}/progress?since=${lastSeen}`
+            });
+            for (const rawEvent of events) {
+              const event = parseProgressEvent(rawEvent);
+              if (!event) {
+                continue;
+              }
+              lastSeen = Math.max(lastSeen, asFiniteNumber3(event.seq));
+              writeLine(options.stdout, pc3.dim(buildBackfillDescription(event)));
+            }
+          }
+          connectedOnce = true;
+          await refreshSummary();
+          const initialStartResult = await maybeAutoStart();
+          if (initialStartResult) {
+            safeCloseSocket(socket, 1e3, initialStartResult.reason);
+            resolveOnce(initialStartResult);
+          }
+        }
+      );
+      settleActiveConnection = null;
+      activeSocket = null;
+      if (connectionResult !== "reconnect") {
+        return connectionResult;
+      }
+      if (interrupted) {
+        return interruptedResult();
+      }
+      const delayMs = toReconnectDelay(reconnectAttempt);
+      reconnectAttempt += 1;
+      writeLine(
+        options.stdout,
+        pc3.yellow(`Reconnecting to mission updates in ${delayMs} ms...`)
+      );
+      await sleep(delayMs);
+    }
+  } finally {
+    const unregister = typeof unregisterSignalHandler === "function" ? unregisterSignalHandler : void 0;
+    unregister?.();
+  }
+}
+
+// src/commands/mission-lifecycle.ts
+function asNonEmptyString5(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function writeSection(stdout, title) {
+  writeLine(stdout);
+  writeLine(stdout, pc4.bold(title));
+}
+function summarizeAssertions(assertions) {
+  return assertions.reduce(
+    (summary, assertion) => ({
+      passed: summary.passed + (assertion.status === "passed" ? 1 : 0),
+      total: summary.total + 1
+    }),
+    { passed: 0, total: 0 }
+  );
+}
+function renderMissionSnapshot(stdout, snapshot) {
+  writeLine(stdout, `Mission ${snapshot.state.missionId}`);
+  writeLine(stdout, `State: ${snapshot.state.state}`);
+  writeLine(
+    stdout,
+    `Features: ${snapshot.state.completedFeatures}/${snapshot.state.totalFeatures}`
+  );
+  writeLine(
+    stdout,
+    `Assertions: ${snapshot.state.passedAssertions}/${snapshot.state.totalAssertions}`
+  );
+  writeLine(
+    stdout,
+    `Milestones: ${snapshot.state.sealedMilestones}/${snapshot.state.totalMilestones} sealed`
+  );
+  if (snapshot.features.length > 0) {
+    writeSection(stdout, "Features");
+    for (const feature of snapshot.features) {
+      const milestone = feature.milestone ? ` (${feature.milestone})` : "";
+      writeLine(stdout, `- ${feature.id}${milestone} \u2014 ${feature.status}`);
+    }
+  }
+  if (snapshot.milestones.length > 0) {
+    writeSection(stdout, "Milestones");
+    for (const milestone of snapshot.milestones) {
+      writeLine(
+        stdout,
+        `- ${milestone.name} (${milestone.state}) \xB7 ${milestone.completedFeatureCount}/${milestone.featureCount} features \xB7 ${milestone.passedAssertionCount}/${milestone.assertionCount} assertions`
+      );
+    }
+  }
+  if (snapshot.assertions.length > 0) {
+    const assertionSummary = summarizeAssertions(snapshot.assertions);
+    writeSection(stdout, "Assertions");
+    writeLine(
+      stdout,
+      `Overall: ${assertionSummary.passed}/${assertionSummary.total} passed (${formatPercent(assertionSummary.passed, assertionSummary.total)})`
+    );
+  }
+}
+async function fetchMissionStateRecord(apiClient, missionId) {
+  return normalizeMissionState(
+    await apiClient.request({
+      path: `/missions/${missionId}/mission/state`
+    })
+  );
+}
+async function fetchMissionSnapshot(apiClient, missionId) {
+  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))
+  ]);
+  return {
+    assertions,
+    features,
+    milestones,
+    state
+  };
+}
+async function createMissionClientContext(context, command, dependencies, homeDir) {
+  const authConfig = await getAuthConfig({
+    env: context.env,
+    homeDir
+  });
+  const globalOptions = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {};
+  return {
+    apiClient: createApiClient({
+      config: authConfig,
+      onVerboseLog: (message) => writeLine(context.stderr, message),
+      sleep: dependencies.sleep,
+      verbose: globalOptions.verbose === true
+    }),
+    authConfig,
+    homeDir
+  };
+}
+function resolveLifecycleHomeDir(context) {
+  return resolveHomeDir({
+    env: context.env,
+    homeDir: context.homeDir
+  });
+}
+async function findMostRecentMissionId(homeDir) {
+  const launchesDir = path3.join(homeDir, ".factory", "cloud-launches");
+  let entries;
+  try {
+    entries = await readdir2(launchesDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+  const candidates = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+      const missionPath = path3.join(launchesDir, entry.name, "mission.json");
+      try {
+        const [raw, missionStats] = await Promise.all([
+          readFile3(missionPath, "utf8"),
+          stat(missionPath)
+        ]);
+        const parsed = JSON.parse(raw);
+        const missionId = asNonEmptyString5(parsed.missionId);
+        if (!missionId) {
+          return null;
+        }
+        return {
+          missionId,
+          updatedAtMs: missionStats.mtimeMs
+        };
+      } catch (error) {
+        if (error instanceof SyntaxError || error.code === "ENOENT") {
+          return null;
+        }
+        throw error;
+      }
+    })
+  );
+  const latest = candidates.filter((candidate) => candidate !== null).sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs || right.missionId.localeCompare(left.missionId)
+  )[0];
+  return latest?.missionId ?? null;
+}
+async function resolveMissionId(missionId, context, command, homeDir) {
+  const explicitMissionId = asNonEmptyString5(missionId);
+  if (explicitMissionId) {
+    return explicitMissionId;
+  }
+  const detectedMissionId = await findMostRecentMissionId(homeDir);
+  if (detectedMissionId) {
+    writeLine(
+      context.stdout,
+      `Using the most recent local mission: ${pc4.cyan(detectedMissionId)}`
+    );
+    return detectedMissionId;
+  }
+  writeLine(
+    context.stderr,
+    "Mission ID is required when no recent local mission state is available."
+  );
+  command.help({ error: true });
+}
+async function fetchMissionStateAfterConflict(apiClient, missionId, error) {
+  try {
+    return await fetchMissionStateRecord(apiClient, missionId);
+  } catch {
+    throw error;
+  }
+}
+async function fetchMissionSnapshotAfterConflict(apiClient, missionId, error) {
+  try {
+    return await fetchMissionSnapshot(apiClient, missionId);
+  } catch {
+    throw error;
+  }
+}
+async function runLifecycleMutation(action, missionIdValue, command, context, dependencies) {
+  const homeDir = resolveLifecycleHomeDir(context);
+  const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
+  const { apiClient } = await createMissionClientContext(
+    context,
+    command,
+    dependencies,
+    homeDir
+  );
+  try {
+    const response = await apiClient.request({
+      method: "POST",
+      path: `/missions/${missionId}/mission/${action}`
+    });
+    const nextState = asNonEmptyString5(response.state) ?? (action === "pause" ? "paused" : "cancelled");
+    if (action === "pause") {
+      writeLine(
+        context.stdout,
+        `Mission ${pc4.cyan(missionId)} paused. Current state: ${pc4.bold(nextState)}.`
+      );
+      return;
+    }
+    writeLine(
+      context.stdout,
+      `Mission ${pc4.cyan(missionId)} cancelled. This action is irreversible. Current state: ${pc4.bold(nextState)}.`
+    );
+  } catch (error) {
+    if (!(error instanceof ApiError) || error.status !== 409) {
+      throw error;
+    }
+    const missionState = await fetchMissionStateAfterConflict(
+      apiClient,
+      missionId,
+      error
+    );
+    const verb = action === "pause" ? "paused" : "cancelled";
+    writeLine(
+      context.stdout,
+      `Mission ${pc4.cyan(missionId)} cannot be ${verb} because it is currently ${pc4.bold(missionState.state)}.`
+    );
+    throw new CommanderError(1, `mission-${action}`, "");
+  }
+}
+function resolveResumeExitCode(state) {
+  switch (state) {
+    case "cancelled":
+    case "completed":
+      return 0;
+    case "failed":
+    case "paused":
+      return 1;
+    default:
+      return null;
+  }
+}
+async function runMissionResume(missionIdValue, command, context, dependencies) {
+  const homeDir = resolveLifecycleHomeDir(context);
+  const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
+  const { apiClient, authConfig } = await createMissionClientContext(
+    context,
+    command,
+    dependencies,
+    homeDir
+  );
+  let snapshot = await fetchMissionSnapshot(apiClient, missionId);
+  if (snapshot.state.state === "paused") {
+    try {
+      const response = await apiClient.request({
+        method: "POST",
+        path: `/missions/${missionId}/mission/resume`
+      });
+      const nextState = asNonEmptyString5(response.state) ?? "orchestrator_turn";
+      writeLine(
+        context.stdout,
+        `Mission ${pc4.cyan(missionId)} resumed. Current state: ${pc4.bold(nextState)}.`
+      );
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 409) {
+        throw error;
+      }
+      snapshot = await fetchMissionSnapshotAfterConflict(
+        apiClient,
+        missionId,
+        error
+      );
+      writeLine(
+        context.stdout,
+        `Mission ${pc4.cyan(missionId)} is currently ${pc4.bold(snapshot.state.state)}. Reconnecting to live updates if available.`
+      );
+    }
+    snapshot = await fetchMissionSnapshot(apiClient, missionId);
+  } else if (snapshot.state.state !== "cancelled" && snapshot.state.state !== "completed") {
+    writeLine(
+      context.stdout,
+      `Reconnecting to mission ${pc4.cyan(missionId)} from state ${pc4.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", "");
+  }
+}
+function registerMissionLifecycleCommands(mission, context, dependencies = {}) {
+  mission.command("pause").description("Pause a mission").argument("[missionId]").action(async (missionId, _options, command) => {
+    await runLifecycleMutation(
+      "pause",
+      missionId,
+      command,
+      context,
+      dependencies
+    );
+  });
+  mission.command("resume").description("Resume a mission").argument("[missionId]").action(async (missionId, _options, command) => {
+    await runMissionResume(missionId, command, context, dependencies);
+  });
+  mission.command("cancel").description("Cancel a mission").argument("[missionId]").action(async (missionId, _options, command) => {
+    await runLifecycleMutation(
+      "cancel",
+      missionId,
+      command,
+      context,
+      dependencies
+    );
+  });
+}
+
+// src/commands/mission-run.ts
+import { stat as stat3 } from "fs/promises";
+import path6 from "path";
+import { CommanderError as CommanderError2 } from "commander";
+
+// src/planning.ts
+import {
+  confirm as defaultConfirmPrompt,
+  input as defaultInputPrompt2,
+  select as defaultSelectPrompt2
+} from "@inquirer/prompts";
+import ora2 from "ora";
+import pc5 from "picocolors";
+var DEFAULT_ANALYSIS_TIMEOUT_MS = 5 * 60 * 1e3;
+var DEFAULT_POLL_INTERVAL_MS = 5e3;
+var FREE_TEXT_OPTION_ID = "free_text";
+function isRecord5(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function asNonEmptyString6(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asStringArray2(value) {
+  return Array.isArray(value) ? value.map((item) => asNonEmptyString6(item)).filter((item) => item !== null) : [];
+}
+function extractQuestions(payload) {
+  if (!payload || !Array.isArray(payload.questions)) {
+    return [];
+  }
+  return payload.questions.filter((question) => isRecord5(question)).map((question) => ({
+    detailPrompt: asNonEmptyString6(question.detailPrompt) ?? void 0,
+    freeTextOptionId: asNonEmptyString6(question.freeTextOptionId) ?? void 0,
+    id: asNonEmptyString6(question.id) ?? "question",
+    inputDefault: asNonEmptyString6(question.inputDefault) ?? void 0,
+    options: Array.isArray(question.options) ? question.options.filter((option) => isRecord5(option)).map((option) => ({
+      description: asNonEmptyString6(option.description) ?? void 0,
+      id: asNonEmptyString6(option.id) ?? "option",
+      label: asNonEmptyString6(option.label) ?? "Option"
+    })) : [],
+    references: asStringArray2(question.references),
+    text: asNonEmptyString6(question.text) ?? "Clarification required."
+  }));
+}
+function extractMilestones(payload) {
+  if (!payload || !Array.isArray(payload.milestones)) {
+    return [];
+  }
+  return payload.milestones.filter((milestone) => isRecord5(milestone)).map((milestone) => ({
+    description: asNonEmptyString6(milestone.description) ?? void 0,
+    name: asNonEmptyString6(milestone.name) ?? "milestone",
+    testableOutcomes: asStringArray2(milestone.testableOutcomes)
+  }));
+}
+function looksLikeMissionDraft(value) {
+  return isRecord5(value) && typeof value.taskDescription === "string" && Array.isArray(value.milestones) && Array.isArray(value.features) && Array.isArray(value.assertions);
+}
+function extractDraft(payload) {
+  if (!payload) {
+    return null;
+  }
+  if (looksLikeMissionDraft(payload.draft)) {
+    return payload.draft;
+  }
+  if (looksLikeMissionDraft(payload)) {
+    return payload;
+  }
+  return null;
+}
+function countItems(payload, key) {
+  const value = payload[key];
+  return Array.isArray(value) ? value.length : 0;
+}
+function formatBudgetSummary(draft) {
+  if (!isRecord5(draft.config) || !isRecord5(draft.config.budget)) {
+    return "unknown";
+  }
+  const budget = draft.config.budget;
+  if (typeof budget.usd === "number" && Number.isFinite(budget.usd)) {
+    return `$${budget.usd.toFixed(2)}`;
+  }
+  try {
+    return JSON.stringify(budget);
+  } catch {
+    return "unknown";
+  }
+}
+function extractFailures(error) {
+  return error instanceof ApiError && isRecord5(error.payload) ? asStringArray2(error.payload.failures) : [];
+}
+function extractErrorCode(error) {
+  if (!(error instanceof ApiError) || !isRecord5(error.payload)) {
+    return null;
+  }
+  return asNonEmptyString6(error.payload.error);
+}
+function extractRound(payload) {
+  return typeof payload?.round === "number" && Number.isFinite(payload.round) ? payload.round : 1;
+}
+function defaultCreateSpinner2(text) {
+  const spinner = ora2({ text });
+  return {
+    get text() {
+      return spinner.text;
+    },
+    set text(value) {
+      spinner.text = value;
+    },
+    fail(message) {
+      if (message) {
+        spinner.text = message;
+      }
+      spinner.fail();
+    },
+    start(message) {
+      if (message) {
+        spinner.text = message;
+      }
+      spinner.start();
+    },
+    stop() {
+      spinner.stop();
+    },
+    succeed(message) {
+      if (message) {
+        spinner.text = message;
+      }
+      spinner.succeed();
+    }
+  };
+}
+async function defaultPromptSelect2(options) {
+  return defaultSelectPrompt2({
+    choices: options.choices.map((choice) => ({
+      description: choice.description,
+      name: choice.name,
+      value: choice.value
+    })),
+    message: options.message
+  });
+}
+async function defaultPromptInput2(options) {
+  return defaultInputPrompt2({
+    default: options.default,
+    message: options.message
+  });
+}
+async function defaultPromptConfirm(options) {
+  return defaultConfirmPrompt({
+    default: options.default,
+    message: options.message
+  });
+}
+async function getPlanningSession(client, sessionId) {
+  return client.request({
+    path: `/plan/${sessionId}`
+  });
+}
+async function postClarification(client, sessionId, body) {
+  return client.request({
+    body,
+    method: "POST",
+    path: `/plan/${sessionId}/clarify`
+  });
+}
+async function postMilestoneConfirmation(client, sessionId, body) {
+  return client.request({
+    body,
+    method: "POST",
+    path: `/plan/${sessionId}/confirm-milestones`
+  });
+}
+async function postDraftApproval(client, sessionId) {
+  return client.request({
+    method: "POST",
+    path: `/plan/${sessionId}/approve`
+  });
+}
+function writeSection2(stdout, title) {
+  writeLine(stdout);
+  writeLine(stdout, pc5.bold(title));
+}
+function renderQuestion(stdout, question, index) {
+  writeLine(stdout, `${index + 1}. ${question.text}`);
+  if (question.references && question.references.length > 0) {
+    writeLine(stdout, `   ${pc5.dim(`References: ${question.references.join(", ")}`)}`);
+  }
+}
+function renderMilestones(stdout, milestones, reviewRound) {
+  writeSection2(stdout, `Milestone review round ${reviewRound}`);
+  milestones.forEach((milestone, index) => {
+    writeLine(stdout, `${index + 1}. ${pc5.cyan(milestone.name)}`);
+    if (milestone.description) {
+      writeLine(stdout, `   ${milestone.description}`);
+    }
+    const outcomes = milestone.testableOutcomes ?? [];
+    for (const outcome of outcomes) {
+      writeLine(stdout, `   - ${outcome}`);
+    }
+  });
+}
+function renderDraftSummary(stdout, payload, draft) {
+  writeSection2(stdout, "Draft summary");
+  writeLine(stdout, `Milestones: ${countItems(payload, "milestones") || countItems(draft, "milestones")}`);
+  writeLine(stdout, `Features: ${countItems(payload, "features") || countItems(draft, "features")}`);
+  writeLine(stdout, `Assertions: ${countItems(payload, "assertions") || countItems(draft, "assertions")}`);
+  writeLine(stdout, `Budget: ${formatBudgetSummary(draft)}`);
+}
+function renderFailures(stdout, failures) {
+  writeSection2(stdout, "Unresolved clarification items");
+  failures.forEach((failure) => {
+    writeLine(stdout, `- ${failure}`);
+  });
+}
+async function promptForAnswers(options, questions, round) {
+  if (options.autoApprove) {
+    return {
+      answers: [],
+      transcript: []
+    };
+  }
+  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) {
+      const choices = question.options.map((option) => ({
+        description: option.description,
+        name: option.label,
+        value: option.id
+      }));
+      const optionId2 = await promptSelect({
+        choices,
+        message: question.text
+      });
+      const selectedOption = question.options.find((option) => option.id === optionId2);
+      answers.push({
+        optionId: optionId2,
+        questionId: question.id
+      });
+      transcript.push({
+        answer: selectedOption?.label ?? optionId2,
+        optionId: optionId2,
+        question: question.text,
+        questionId: question.id,
+        references: question.references ?? [],
+        round
+      });
+      continue;
+    }
+    const detail = await promptInput({
+      default: question.inputDefault,
+      message: question.detailPrompt ?? question.text
+    });
+    const optionId = question.freeTextOptionId ?? FREE_TEXT_OPTION_ID;
+    answers.push({
+      detail,
+      optionId,
+      questionId: question.id
+    });
+    transcript.push({
+      answer: detail,
+      optionId,
+      question: question.text,
+      questionId: question.id,
+      references: question.references ?? [],
+      round
+    });
+  }
+  return {
+    answers,
+    transcript
+  };
+}
+async function waitForAnalysis(options, sessionId) {
+  const createSpinner = options.createSpinner ?? defaultCreateSpinner2;
+  const sleep = options.sleep ?? (async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  });
+  const now = options.now ?? (() => Date.now());
+  const timeoutMs = options.timeoutMs ?? DEFAULT_ANALYSIS_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const deadline = now() + timeoutMs;
+  const spinner = createSpinner("Analyzing repository for planning...");
+  spinner.start();
+  try {
+    let session = await getPlanningSession(options.client, sessionId);
+    while (session.state === "created" || session.state === "analyzing") {
+      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);
+    }
+    spinner.succeed("Analysis complete.");
+    return session;
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    spinner.fail("Planning analysis failed.");
+    throw error;
+  }
+}
+async function resolveClarification(options, sessionId, initialPayload) {
+  let payload = initialPayload;
+  const localTranscript = [];
+  while (payload.state === "clarifying") {
+    let questions = extractQuestions(payload);
+    let round = extractRound(payload);
+    if (questions.length === 0) {
+      payload = await postClarification(options.client, sessionId, {});
+      questions = extractQuestions(payload);
+      round = extractRound(payload);
+    }
+    if (payload.state !== "clarifying") {
+      break;
+    }
+    writeSection2(options.stdout, `Clarification round ${round}`);
+    questions.forEach((question, index) => renderQuestion(options.stdout, question, index));
+    const prompted = await promptForAnswers(options, questions, round);
+    localTranscript.push(...prompted.transcript);
+    try {
+      payload = await postClarification(options.client, sessionId, {
+        answers: prompted.answers
+      });
+    } catch (error) {
+      if (extractErrorCode(error) !== "resolvedness_gate_failed") {
+        throw error;
+      }
+      const failures = extractFailures(error);
+      renderFailures(options.stdout, failures);
+      if (!options.force) {
+        throw new CliError(
+          `Planning clarification is still unresolved: ${failures.join(", ")}`
+        );
+      }
+      writeLine(
+        options.stdout,
+        pc5.yellow("Proceeding because --force is enabled.")
+      );
+      payload = await postMilestoneConfirmation(options.client, sessionId, {});
+      return {
+        payload,
+        persistedClarification: {
+          forced: true,
+          roundsCompleted: round,
+          sessionId,
+          transcript: localTranscript,
+          unresolvedItems: failures
+        }
+      };
+    }
+  }
+  if (localTranscript.length === 0 && !Array.isArray(payload.clarificationTranscript)) {
+    return {
+      payload,
+      persistedClarification: null
+    };
+  }
+  return {
+    payload,
+    persistedClarification: {
+      forced: false,
+      roundsCompleted: extractRound(payload),
+      sessionId,
+      transcript: Array.isArray(payload.clarificationTranscript) ? payload.clarificationTranscript : localTranscript,
+      unresolvedItems: []
+    }
+  };
+}
+async function resolveMilestones(options, sessionId, initialPayload) {
+  let reviewRound = 1;
+  let payload = initialPayload;
+  if (extractMilestones(payload).length === 0) {
+    payload = await postMilestoneConfirmation(options.client, sessionId, {});
+  }
+  while (true) {
+    const milestones = extractMilestones(payload);
+    renderMilestones(options.stdout, milestones, reviewRound);
+    const confirmed = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm)({
+      default: true,
+      message: "Do these milestones look correct?"
+    });
+    if (confirmed) {
+      return postMilestoneConfirmation(options.client, sessionId, {
+        confirmed: true
+      });
+    }
+    const feedback = await (options.promptInput ?? defaultPromptInput2)({
+      message: "What should change about these milestones?"
+    });
+    payload = await postMilestoneConfirmation(options.client, sessionId, {
+      confirmed: false,
+      feedback
+    });
+    reviewRound += 1;
+  }
+}
+async function resolveDraft(options, sessionId, payload) {
+  const directDraft = extractDraft(payload);
+  if (directDraft) {
+    return {
+      draft: directDraft,
+      payload
+    };
+  }
+  const approvedPayload = await postDraftApproval(options.client, sessionId);
+  const approvedDraft = extractDraft(approvedPayload);
+  if (!approvedDraft) {
+    throw new CliError("Planner did not return a mission draft.");
+  }
+  return {
+    draft: approvedDraft,
+    payload: approvedPayload
+  };
+}
+async function runPlanningFlow(options) {
+  if (options.existingMissionDraft) {
+    writeLine(
+      options.stdout,
+      pc5.cyan("Skipping planning because mission-draft.json already exists.")
+    );
+    return {
+      cancelled: false,
+      draft: options.existingMissionDraft,
+      sessionId: options.existingSessionId ?? "",
+      skippedPlanning: true
+    };
+  }
+  const sessionId = asNonEmptyString6(options.existingSessionId) ?? asNonEmptyString6(
+    (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);
+    }
+  }
+  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"}.`
+    );
+  }
+  const { draft, payload: summaryPayload } = await resolveDraft(
+    options,
+    sessionId,
+    payload
+  );
+  renderDraftSummary(options.stdout, summaryPayload, draft);
+  const approved = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm)({
+    default: true,
+    message: "Approve this draft and continue to upload?"
+  });
+  if (!approved) {
+    writeLine(options.stdout, pc5.yellow("Planning cancelled before upload."));
+    return {
+      cancelled: true,
+      draft,
+      sessionId,
+      skippedPlanning: false
+    };
+  }
+  await options.persistMissionDraft(draft);
+  writeLine(options.stdout, pc5.green("Saved approved mission draft."));
+  return {
+    cancelled: false,
+    draft,
+    sessionId,
+    skippedPlanning: false
+  };
+}
+
+// src/upload.ts
+import { confirm } from "@inquirer/prompts";
+import { createReadStream as createReadStream2 } from "fs";
+import path5 from "path";
+import { Transform as Transform2 } from "stream";
+import ora3 from "ora";
+import pc6 from "picocolors";
+
+// src/snapshot.ts
+import { execFile } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { createReadStream, createWriteStream } from "fs";
+import {
+  lstat,
+  mkdir as mkdir3,
+  readlink,
+  readdir as readdir3,
+  rename as rename3,
+  rm as rm3,
+  stat as stat2
+} from "fs/promises";
+import path4 from "path";
+import { createInterface } from "readline";
+import { Transform } from "stream";
+import { pipeline } from "stream/promises";
+import { promisify } from "util";
+import * as tar from "tar";
+import { createZstdCompress } from "zlib";
+var execFileAsync = promisify(execFile);
+var EPOCH_DATE = /* @__PURE__ */ new Date(0);
+var SNAPSHOT_SCHEMA_VERSION = 1;
+var GIT_DIR_NAME = ".git";
+var GIT_EXCLUDED_RULES = [".git/", "gitignored files"];
+var NON_GIT_EXCLUDED_RULES = [
+  ".git/",
+  "node_modules/",
+  ".DS_Store",
+  "__pycache__/",
+  ".env"
+];
+var REPO_ID_PATTERN2 = /^[A-Za-z0-9._-]+$/;
+var SECRET_PATTERNS = [
+  {
+    kind: "stripe_live_key",
+    message: "Found a Stripe live secret key.",
+    regex: /sk_live_[A-Za-z0-9]+/g
+  },
+  {
+    kind: "aws_access_key",
+    message: "Found an AWS access key ID.",
+    regex: /AKIA[0-9A-Z]{16}/g
+  },
+  {
+    kind: "github_personal_access_token",
+    message: "Found a GitHub personal access token.",
+    regex: /ghp_[A-Za-z0-9]+/g
+  },
+  {
+    kind: "private_key",
+    message: "Found a private key header.",
+    regex: /-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----/g
+  }
+];
+var SnapshotError = class extends Error {
+  code;
+  constructor(message, code = "snapshot_failed") {
+    super(message);
+    this.name = "SnapshotError";
+    this.code = code;
+  }
+};
+var SecretDetectionError = class extends SnapshotError {
+  failures;
+  constructor(failures) {
+    const summary = failures.map(
+      (failure) => `${failure.localPath}: ${failure.findings.map((finding) => finding.filePath).join(", ")}`
+    ).join("; ");
+    super(
+      `Secret scan detected findings in ${failures.length} repo(s): ${summary}`,
+      "secrets_detected"
+    );
+    this.name = "SecretDetectionError";
+    this.failures = failures;
+  }
+};
+function compareStrings(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}
+function toPosixPath(filePath) {
+  return filePath.split(path4.sep).join(path4.posix.sep);
+}
+function splitNullTerminatedBuffer(buffer) {
+  return buffer.toString("utf8").split("\0").filter((entry) => entry.length > 0);
+}
+function sanitizeIdentifier(value) {
+  const sanitized = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+  return sanitized.length > 0 ? sanitized : "repo";
+}
+function createPathHash(value, length = 8) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, length);
+}
+function normalizeArchiveMode(mode) {
+  return mode & 73 ? 493 : 420;
+}
+function buildTreeShaInput(entries) {
+  return JSON.stringify(
+    entries.map((entry) => ({
+      linkTarget: entry.linkTarget ?? null,
+      mode: entry.mode,
+      path: entry.relativePath,
+      sha256: entry.sha256 ?? null,
+      size: entry.size,
+      type: entry.type
+    }))
+  );
+}
+async function ensureDirectory2(dirPath) {
+  await mkdir3(dirPath, { recursive: true });
+}
+async function validateDirectoryPath(repoPath, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const absolutePath = path4.resolve(cwd, repoPath);
+  let directoryStats;
+  try {
+    directoryStats = await stat2(absolutePath);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      throw new SnapshotError(
+        `Repo path does not exist: ${repoPath}`,
+        "invalid_repo"
+      );
+    }
+    throw error;
+  }
+  if (!directoryStats.isDirectory()) {
+    throw new SnapshotError(
+      `Repo path is not a directory: ${repoPath}`,
+      "invalid_repo"
+    );
+  }
+  return absolutePath;
+}
+async function resolveRepositoryInputs(repoPaths, options) {
+  if (repoPaths.length === 0) {
+    throw new SnapshotError("At least one repo path is required.", "invalid_repo");
+  }
+  const absolutePaths = await Promise.all(
+    repoPaths.map((repoPath) => validateDirectoryPath(repoPath, options))
+  );
+  const counts = /* @__PURE__ */ new Map();
+  const baseNames = absolutePaths.map(
+    (absolutePath) => sanitizeIdentifier(path4.basename(absolutePath))
+  );
+  for (const baseName of baseNames) {
+    counts.set(baseName, (counts.get(baseName) ?? 0) + 1);
+  }
+  return absolutePaths.map((absolutePath, index) => {
+    const baseName = baseNames[index];
+    const pathHash = createPathHash(absolutePath);
+    const repoId = `${baseName}-${pathHash}`;
+    const mountAs = (counts.get(baseName) ?? 0) > 1 ? `${baseName}-${pathHash}` : baseName;
+    if (!REPO_ID_PATTERN2.test(repoId)) {
+      throw new SnapshotError(
+        `Generated repo ID is invalid for ${absolutePath}`,
+        "invalid_repo"
+      );
+    }
+    return {
+      repoId,
+      localPath: absolutePath,
+      mountAs
+    };
+  });
+}
+async function readSha256(filePath) {
+  const hash = createHash2("sha256");
+  const stream = createReadStream(filePath);
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+function matchSecretPatterns(line, relativePath, lineNumber) {
+  const findings = [];
+  for (const pattern of SECRET_PATTERNS) {
+    pattern.regex.lastIndex = 0;
+    if (pattern.regex.test(line)) {
+      findings.push({
+        kind: pattern.kind,
+        filePath: relativePath,
+        line: lineNumber,
+        message: pattern.message
+      });
+    }
+  }
+  return findings;
+}
+async function scanRegularFileForSecrets(filePath, relativePath) {
+  const findings = [];
+  const basename = path4.posix.basename(relativePath);
+  if (basename.startsWith(".env")) {
+    findings.push({
+      kind: "env_file",
+      filePath: relativePath,
+      line: null,
+      message: "Found a .env-style file."
+    });
+  }
+  const input = createReadStream(filePath, { encoding: "utf8" });
+  const lines = createInterface({
+    input,
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  let lineNumber = 0;
+  for await (const line of lines) {
+    lineNumber += 1;
+    findings.push(...matchSecretPatterns(line, relativePath, lineNumber));
+  }
+  return findings;
+}
+async function classifyRepositoryEntry(repoPath, relativePath) {
+  const absolutePath = path4.join(repoPath, relativePath);
+  const entryStats = await lstat(absolutePath);
+  if (entryStats.isDirectory()) {
+    return null;
+  }
+  if (entryStats.isSymbolicLink()) {
+    return {
+      absolutePath,
+      linkTarget: await readlink(absolutePath),
+      mode: 493,
+      relativePath,
+      size: 0,
+      type: "symlink"
+    };
+  }
+  if (!entryStats.isFile()) {
+    return null;
+  }
+  return {
+    absolutePath,
+    mode: normalizeArchiveMode(entryStats.mode),
+    relativePath,
+    sha256: await readSha256(absolutePath),
+    size: entryStats.size,
+    type: "file"
+  };
+}
+function shouldIgnoreNonGitEntry(relativePath, isDirectory) {
+  const normalizedPath = toPosixPath(relativePath);
+  const basename = path4.posix.basename(normalizedPath);
+  const segments = normalizedPath.split(path4.posix.sep);
+  if (segments.includes(GIT_DIR_NAME)) {
+    return true;
+  }
+  if (isDirectory) {
+    return basename === "node_modules" || basename === "__pycache__";
+  }
+  return basename === ".DS_Store" || basename === ".env";
+}
+async function walkNonGitEntries(repoPath, currentRelativePath = "") {
+  const currentAbsolutePath = path4.join(repoPath, currentRelativePath);
+  const dirEntries = await readdir3(currentAbsolutePath, { withFileTypes: true });
+  const results = [];
+  for (const dirEntry of dirEntries.sort(
+    (left, right) => compareStrings(left.name, right.name)
+  )) {
+    const relativePath = currentRelativePath ? path4.posix.join(currentRelativePath, dirEntry.name) : dirEntry.name;
+    if (shouldIgnoreNonGitEntry(relativePath, dirEntry.isDirectory())) {
+      continue;
+    }
+    if (dirEntry.isDirectory()) {
+      results.push(...await walkNonGitEntries(repoPath, relativePath));
+      continue;
+    }
+    results.push(relativePath);
+  }
+  return results;
+}
+async function pathExists(filePath) {
+  try {
+    await lstat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isGitBackedRepository(repoPath) {
+  return pathExists(path4.join(repoPath, GIT_DIR_NAME));
+}
+async function runGitCommand(repoPath, args, options = {}) {
+  const encoding = options.encoding ?? "utf8";
+  try {
+    const result = await execFileAsync("git", [...args], {
+      cwd: repoPath,
+      encoding,
+      maxBuffer: 32 * 1024 * 1024
+    });
+    return result.stdout;
+  } catch (error) {
+    if (options.allowFailure) {
+      return null;
+    }
+    const stderr = error instanceof Error && "stderr" in error && typeof error.stderr === "string" ? error.stderr.trim() : "";
+    const reason = stderr.length > 0 ? `: ${stderr}` : "";
+    throw new SnapshotError(
+      `Git command failed in ${repoPath}${reason}`,
+      "git_failed"
+    );
+  }
+}
+function parseGitStatus(output) {
+  const records = splitNullTerminatedBuffer(output);
+  const parsed = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    const code = record.slice(0, 2);
+    const currentPath = record.slice(3);
+    if (code.includes("R") || code.includes("C")) {
+      const nextPath = records[index + 1] ?? currentPath;
+      parsed.push({ code, path: nextPath });
+      index += 1;
+      continue;
+    }
+    parsed.push({ code, path: currentPath });
+  }
+  return parsed;
+}
+async function discoverGitEntries(repoPath) {
+  const trackedOutput = await runGitCommand(repoPath, ["ls-files", "-z"], {
+    encoding: "buffer"
+  });
+  const statusOutput = await runGitCommand(
+    repoPath,
+    ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=no"],
+    { encoding: "buffer" }
+  );
+  const branchOutput = await runGitCommand(
+    repoPath,
+    ["branch", "--show-current"],
+    { allowFailure: true, encoding: "utf8" }
+  );
+  const headOutput = await runGitCommand(
+    repoPath,
+    ["rev-parse", "HEAD"],
+    { allowFailure: true, encoding: "utf8" }
+  );
+  const trackedEntries = splitNullTerminatedBuffer(trackedOutput);
+  const statusRecords = parseGitStatus(statusOutput);
+  const untrackedEntries = statusRecords.filter((record) => record.code === "??").map((record) => record.path);
+  const candidateEntries = [.../* @__PURE__ */ new Set([...trackedEntries, ...untrackedEntries])].map((entry) => toPosixPath(entry)).filter((entry) => !entry.startsWith(".git/") && entry !== ".git");
+  const relativePaths = [];
+  for (const entry of candidateEntries.sort(compareStrings)) {
+    if (await pathExists(path4.join(repoPath, entry))) {
+      relativePaths.push(entry);
+    }
+  }
+  const branch = typeof branchOutput === "string" && branchOutput.trim().length > 0 ? branchOutput.trim() : null;
+  const headCommit = typeof headOutput === "string" && headOutput.trim().length > 0 ? headOutput.trim() : null;
+  return {
+    branch,
+    dirty: statusRecords.length > 0,
+    excludedRules: GIT_EXCLUDED_RULES,
+    headCommit,
+    relativePaths
+  };
+}
+async function discoverRepositoryEntries(input) {
+  if (await isGitBackedRepository(input.localPath)) {
+    const gitInfo = await discoverGitEntries(input.localPath);
+    return {
+      ...gitInfo,
+      isGitBacked: true,
+      warnings: []
+    };
+  }
+  return {
+    branch: null,
+    dirty: true,
+    excludedRules: NON_GIT_EXCLUDED_RULES,
+    headCommit: null,
+    isGitBacked: false,
+    relativePaths: (await walkNonGitEntries(input.localPath)).sort(compareStrings),
+    warnings: [
+      `Repo ${input.localPath} is not git-backed; using filesystem walk with default ignores.`
+    ]
+  };
+}
+async function analyzeRepository(input) {
+  const discovered = await discoverRepositoryEntries(input);
+  const entries = [];
+  const secretFindings = [];
+  for (const relativePath of discovered.relativePaths) {
+    const entry = await classifyRepositoryEntry(input.localPath, relativePath);
+    if (!entry) {
+      continue;
+    }
+    if (entry.type === "file") {
+      secretFindings.push(
+        ...await scanRegularFileForSecrets(entry.absolutePath, relativePath)
+      );
+    }
+    entries.push(entry);
+  }
+  entries.sort((left, right) => compareStrings(left.relativePath, right.relativePath));
+  secretFindings.sort((left, right) => {
+    const pathCompare = compareStrings(left.filePath, right.filePath);
+    if (pathCompare !== 0) {
+      return pathCompare;
+    }
+    const leftLine = left.line ?? -1;
+    const rightLine = right.line ?? -1;
+    if (leftLine !== rightLine) {
+      return leftLine - rightLine;
+    }
+    return compareStrings(left.kind, right.kind);
+  });
+  const treeSha256 = createHash2("sha256").update(buildTreeShaInput(entries)).digest("hex");
+  return {
+    branch: discovered.branch,
+    dirty: discovered.dirty,
+    entries,
+    excludedRules: discovered.excludedRules,
+    headCommit: discovered.headCommit,
+    input,
+    isGitBacked: discovered.isGitBacked,
+    secretFindings,
+    treeSha256,
+    warnings: discovered.warnings
+  };
+}
+async function writeDeterministicArchive(analysis, outputDir) {
+  await ensureDirectory2(outputDir);
+  const finalArchivePath = path4.join(outputDir, `${analysis.input.repoId}.tar.zst`);
+  const tempArchivePath = `${finalArchivePath}.${process.pid}.${Date.now()}.tmp`;
+  const archiveHash = createHash2("sha256");
+  let archiveBytes = 0;
+  const meter = new Transform({
+    transform(chunk, _encoding, callback) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      archiveHash.update(buffer);
+      archiveBytes += buffer.length;
+      callback(null, buffer);
+    }
+  });
+  const tarStream = tar.c(
+    {
+      cwd: analysis.input.localPath,
+      mtime: EPOCH_DATE,
+      noMtime: false,
+      onWriteEntry(entry) {
+        entry.mtime = EPOCH_DATE;
+        if (entry.stat) {
+          entry.stat.atime = EPOCH_DATE;
+          entry.stat.ctime = EPOCH_DATE;
+          entry.stat.mode = normalizeArchiveMode(entry.stat.mode);
+          entry.stat.mtime = EPOCH_DATE;
+          entry.stat.uid = 0;
+          entry.stat.gid = 0;
+        }
+        entry.myuid = 0;
+        entry.myuser = "";
+        entry.portable = false;
+      },
+      portable: true,
+      preservePaths: false
+    },
+    analysis.entries.map((entry) => entry.relativePath)
+  );
+  try {
+    await pipeline(
+      tarStream,
+      createZstdCompress(),
+      meter,
+      createWriteStream(tempArchivePath, { mode: 384 })
+    );
+    await rename3(tempArchivePath, finalArchivePath);
+  } catch (error) {
+    await rm3(tempArchivePath, { force: true });
+    if (error instanceof SnapshotError) {
+      throw error;
+    }
+    throw new SnapshotError(
+      `Failed to create repo snapshot for ${analysis.input.localPath}: ${error instanceof Error ? error.message : String(error)}`,
+      "snapshot_failed"
+    );
+  }
+  return {
+    archiveBytes,
+    archivePath: finalArchivePath,
+    archiveSha256: archiveHash.digest("hex")
+  };
+}
+async function snapshotRepositories(options) {
+  const resolvedInputs = await resolveRepositoryInputs(options.repoPaths, options);
+  const analyses = await Promise.all(
+    resolvedInputs.map((input) => analyzeRepository(input))
+  );
+  const secretFailures = analyses.filter(
+    (analysis) => analysis.secretFindings.length > 0 && options.allowSecrets !== true
+  ).map((analysis) => ({
+    findings: analysis.secretFindings,
+    localPath: analysis.input.localPath,
+    repoId: analysis.input.repoId
+  }));
+  if (secretFailures.length > 0) {
+    throw new SecretDetectionError(secretFailures);
+  }
+  const snapshots = [];
+  for (const analysis of analyses) {
+    const archive = await writeDeterministicArchive(analysis, options.outputDir);
+    const warnings = [...analysis.warnings];
+    if (analysis.secretFindings.length > 0 && options.allowSecrets === true) {
+      warnings.push(
+        `Secrets detected in ${analysis.input.localPath}; proceeding because --allow-secrets is enabled.`
+      );
+    }
+    snapshots.push({
+      archivePath: archive.archivePath,
+      manifest: {
+        archiveBytes: archive.archiveBytes,
+        archiveSha256: archive.archiveSha256,
+        blobKey: `blobs/repos/${archive.archiveSha256}.tar.zst`,
+        branch: analysis.branch,
+        dirty: analysis.dirty,
+        excludedRules: analysis.excludedRules,
+        headCommit: analysis.headCommit,
+        includedFileCount: analysis.entries.length,
+        localPath: analysis.input.localPath,
+        mountAs: analysis.input.mountAs,
+        repoId: analysis.input.repoId,
+        schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+        treeSha256: analysis.treeSha256
+      },
+      secretFindings: analysis.secretFindings,
+      warnings
+    });
+  }
+  return snapshots;
+}
+
+// src/upload.ts
+function defaultCreateSpinner3(text) {
+  const spinner = ora3({ text });
+  spinner.start();
+  return spinner;
+}
+async function defaultPromptConfirm2(options) {
+  return confirm({
+    default: options.default,
+    message: options.message
+  });
+}
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  return `${value.toFixed(value >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+}
+function formatDuration(milliseconds) {
+  if (milliseconds < 1e3) {
+    return `${Math.max(1, Math.round(milliseconds))} ms`;
+  }
+  return `${(milliseconds / 1e3).toFixed(1)} s`;
+}
+function formatRate(bytesTransferred, elapsedMs) {
+  const safeElapsedMs = Math.max(elapsedMs, 1);
+  const bytesPerSecond = bytesTransferred * 1e3 / safeElapsedMs;
+  return `${formatBytes(Math.max(1, Math.round(bytesPerSecond)))}/s`;
+}
+function formatFinding(finding) {
+  const location = finding.line === null ? finding.filePath : `${finding.filePath}:${finding.line}`;
+  return `${location} \u2014 ${finding.message}`;
+}
+function normalizeLaunchId2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function normalizeExistingBlobs(value) {
+  if (!Array.isArray(value)) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(
+    value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+  );
+}
+function isTerminalUploadStatus2(status) {
+  return status === "uploaded" || status === "blob_exists";
+}
+function renderSafetyGate(stdout, repos, existingBlobs) {
+  writeLine(stdout, pc6.bold("Upload safety check"));
+  writeLine(stdout, "Repos queued for upload:");
+  for (const repo of repos) {
+    const cleanliness = repo.manifest.dirty ? pc6.yellow("dirty") : pc6.green("clean");
+    const secretSummary = repo.secretFindings.length > 0 ? pc6.red(`${repo.secretFindings.length} finding(s)`) : pc6.green("no findings");
+    const dedupSummary = existingBlobs.has(repo.manifest.archiveSha256) ? pc6.cyan("blob already exists remotely") : "new upload";
+    writeLine(
+      stdout,
+      `- ${pc6.cyan(repo.manifest.repoId)} \u2014 ${repo.manifest.localPath}`
+    );
+    writeLine(
+      stdout,
+      `  Status: ${cleanliness}; archive ${formatBytes(repo.manifest.archiveBytes)}; ${dedupSummary}; secret scan ${secretSummary}`
+    );
+    if (repo.warnings.length > 0) {
+      for (const warning of repo.warnings) {
+        writeLine(stdout, `  Warning: ${warning}`);
+      }
+    }
+    if (repo.secretFindings.length > 0) {
+      for (const finding of repo.secretFindings) {
+        writeLine(stdout, `  Secret: ${formatFinding(finding)}`);
+      }
+    }
+  }
+  writeLine(stdout, "Secret scan results are shown above.");
+}
+function assertArtifactsMatchPersistedState(repos, persistedManifests) {
+  const persistedRepoIds = Object.keys(persistedManifests).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const currentRepoIds = repos.map((repo) => repo.manifest.repoId).sort((left, right) => left.localeCompare(right));
+  if (JSON.stringify(currentRepoIds) !== JSON.stringify(persistedRepoIds)) {
+    throw new CliError(
+      "Current repo set does not match the saved upload manifests. Start a new launch for updated repos."
+    );
+  }
+}
+async function createRemoteLaunch(options, repos, taskDescription) {
+  const response = await options.apiClient.request({
+    body: {
+      ...taskDescription ? {
+        requestSummary: {
+          repoCount: repos.length,
+          task: taskDescription
+        }
+      } : {},
+      repos: repos.map((repo) => ({
+        archiveBytes: repo.manifest.archiveBytes,
+        archiveSha256: repo.manifest.archiveSha256,
+        repoId: repo.manifest.repoId
+      }))
+    },
+    method: "POST",
+    path: "/launches"
+  });
+  const remoteLaunchId = normalizeLaunchId2(response.launchId);
+  if (remoteLaunchId.length === 0) {
+    throw new CliError("Launch creation did not return a launch ID.");
+  }
+  return {
+    existingBlobs: normalizeExistingBlobs(response.existingBlobs),
+    remoteLaunchId
+  };
+}
+async function uploadArchive(options, repo, uploadUrl) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const createSpinner = options.createSpinner ?? defaultCreateSpinner3;
+  const spinner = createSpinner(
+    `Uploading ${repo.manifest.repoId} 0 B / ${formatBytes(repo.manifest.archiveBytes)} (0 B/s)`
+  );
+  spinner.start(spinner.text);
+  const startedAt = Date.now();
+  let bytesTransferred = 0;
+  const meter = new Transform2({
+    transform(chunk, _encoding, callback) {
+      bytesTransferred += Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk));
+      const elapsedMs2 = Date.now() - startedAt;
+      spinner.text = `Uploading ${repo.manifest.repoId} ${formatBytes(bytesTransferred)} / ${formatBytes(repo.manifest.archiveBytes)} (${formatRate(bytesTransferred, elapsedMs2)})`;
+      callback(null, chunk);
+    }
+  });
+  let response;
+  try {
+    const body = createReadStream2(repo.archivePath).pipe(meter);
+    const requestInit = {
+      body,
+      duplex: "half",
+      headers: {
+        "content-length": String(repo.manifest.archiveBytes)
+      },
+      method: "PUT"
+    };
+    response = await fetchImpl(uploadUrl, requestInit);
+  } catch (error) {
+    spinner.fail(`Upload failed for ${repo.manifest.repoId}`);
+    throw new CliError(
+      `Upload failed for ${repo.manifest.repoId}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    spinner.fail(`Upload failed for ${repo.manifest.repoId}`);
+    throw new CliError(
+      `Upload failed for ${repo.manifest.repoId}: HTTP ${response.status}${detail ? ` ${detail}` : ""}`
+    );
+  }
+  const elapsedMs = Date.now() - startedAt;
+  spinner.succeed(
+    `Uploaded ${repo.manifest.repoId} ${formatBytes(bytesTransferred)} in ${formatDuration(elapsedMs)} (${formatRate(bytesTransferred, elapsedMs)})`
+  );
+}
+async function processRepoUpload(options, repo, remoteLaunchId) {
+  const snapshot = await loadLaunchSnapshot(options.launchId, {
+    cwd: options.cwd,
+    homeDir: options.homeDir
+  });
+  const existingStatus = snapshot.uploadState?.repos[repo.manifest.repoId]?.status;
+  if (existingStatus !== "uploading") {
+    await updateRepoUploadState(
+      options.launchId,
+      {
+        remoteLaunchId,
+        repoId: repo.manifest.repoId,
+        status: "requested"
+      },
+      {
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      }
+    );
+  }
+  const response = await options.apiClient.request({
+    body: repo.manifest,
+    method: "POST",
+    path: `/launches/${remoteLaunchId}/repos/${repo.manifest.repoId}`
+  });
+  if (response.status === "blob_exists") {
+    await updateRepoUploadState(
+      options.launchId,
+      {
+        remoteLaunchId,
+        repoId: repo.manifest.repoId,
+        status: "blob_exists"
+      },
+      {
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      }
+    );
+    writeLine(
+      options.stdout,
+      pc6.cyan(`Skipping upload for ${repo.manifest.repoId}; blob already exists remotely.`)
+    );
+    return;
+  }
+  const uploadUrl = typeof response.uploadUrl === "string" ? response.uploadUrl : null;
+  if (response.status !== "upload_required" || !uploadUrl) {
+    throw new CliError(
+      `Launch repo ${repo.manifest.repoId} did not return a usable upload URL.`
+    );
+  }
+  await updateRepoUploadState(
+    options.launchId,
+    {
+      remoteLaunchId,
+      repoId: repo.manifest.repoId,
+      status: "uploading"
+    },
+    {
+      cwd: options.cwd,
+      homeDir: options.homeDir
+    }
+  );
+  await uploadArchive(options, repo, uploadUrl);
+  await updateRepoUploadState(
+    options.launchId,
+    {
+      remoteLaunchId,
+      repoId: repo.manifest.repoId,
+      status: "uploaded"
+    },
+    {
+      cwd: options.cwd,
+      homeDir: options.homeDir
+    }
+  );
+}
+async function runUploadPipeline(options) {
+  const promptConfirm = options.promptConfirm ?? defaultPromptConfirm2;
+  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: path5.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: path5.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) {
+      throw new CliError(
+        "Secret scan findings blocked the upload. Re-run with `--allow-secrets` to proceed."
+      );
+    }
+    if (options.autoApprove !== true && !await promptConfirm({
+      default: false,
+      message: "Proceed with launch upload?"
+    })) {
+      writeLine(
+        options.stdout,
+        pc6.yellow("Upload cancelled before creating a remote launch.")
+      );
+      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,
+        pc6.cyan(
+          `Remote dedup will reuse ${existingBlobs.size} existing blob${existingBlobs.size === 1 ? "" : "s"}.`
+        )
+      );
+    }
+    for (const repo of repos) {
+      await recordRepoManifest(
+        options.launchId,
+        repo.manifest.repoId,
+        repo.manifest,
+        {
+          cwd: options.cwd,
+          homeDir: options.homeDir
+        }
+      );
+    }
+  }
+  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,
+        pc6.cyan(`Skipping ${repo.manifest.repoId}; already completed in upload-state.json.`)
+      );
+      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,
+        pc6.red(
+          error instanceof Error ? error.message : `Upload failed for ${repo.manifest.repoId}.`
+        )
+      );
+    }
+  }
+  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,
+    pc6.green(`Upload complete. Remote launch ${remoteLaunchId} is finalized.`)
+  );
+  return {
+    finalized: true,
+    remoteLaunchId
+  };
+}
+
+// src/commands/mission-run.ts
+function collectValues(value, previous = []) {
+  return [...previous, value];
+}
+async function resolveRepoPaths(repoValues, cwd = process.cwd()) {
+  if (repoValues.length === 0) {
+    throw new CliError("At least one `--repo` path is required.");
+  }
+  const resolved = [...new Set(repoValues.map((repoPath) => path6.resolve(cwd, repoPath)))];
+  for (const repoPath of resolved) {
+    let repoStats;
+    try {
+      repoStats = await stat3(repoPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new CliError(`Repo path does not exist: ${repoPath}`);
+      }
+      throw error;
+    }
+    if (!repoStats.isDirectory()) {
+      throw new CliError(`Repo path is not a directory: ${repoPath}`);
+    }
+  }
+  return resolved.sort((left, right) => left.localeCompare(right));
+}
+function resolveTaskDescription(taskDescription) {
+  const trimmed = taskDescription.trim();
+  if (trimmed.length === 0) {
+    throw new CliError("Task description must not be empty.");
+  }
+  return trimmed;
+}
+function registerMissionRunCommand(mission, context, dependencies = {}) {
+  mission.command("run").description("Create and run a mission").argument("<taskDescription>").option(
+    "--repo <path>",
+    "Repository path to include in the planning request",
+    collectValues,
+    []
+  ).option("--yes", "Automatically approve all planning prompts").option("--force", "Continue if clarification remains unresolved").option(
+    "--allow-secrets",
+    "Allow uploads to continue when the secret scan reports findings"
+  ).action(
+    async (taskDescription, options, command) => {
+      const task = resolveTaskDescription(taskDescription);
+      const repoPaths = await resolveRepoPaths(options.repo ?? []);
+      const homeDir = resolveHomeDir({
+        env: context.env,
+        homeDir: context.homeDir
+      });
+      const authConfig = await getAuthConfig({
+        env: context.env,
+        homeDir
+      });
+      const launchSnapshot = await prepareLaunch(
+        {
+          repoPaths,
+          task
+        },
+        {
+          cwd: process.cwd(),
+          homeDir
+        }
+      );
+      const globalOptions = command.optsWithGlobals();
+      const client = createApiClient({
+        config: authConfig,
+        onVerboseLog: (message) => writeLine(context.stderr, message),
+        sleep: dependencies.sleep,
+        verbose: globalOptions.verbose === true
+      });
+      const result = await runPlanningFlow({
+        autoApprove: options.yes === true,
+        client,
+        createSpinner: dependencies.createSpinner,
+        existingMissionDraft: launchSnapshot.missionDraft,
+        existingSessionId: launchSnapshot.request?.sessionId,
+        force: options.force === true,
+        now: dependencies.now,
+        persistClarification: async (clarification) => {
+          await recordClarification(launchSnapshot.launchId, clarification, {
+            cwd: process.cwd(),
+            homeDir
+          });
+        },
+        persistMissionDraft: async (draft) => {
+          await recordMissionDraft(launchSnapshot.launchId, draft, {
+            cwd: process.cwd(),
+            homeDir
+          });
+        },
+        persistSessionId: async (sessionId) => {
+          await recordPlanningStart(
+            {
+              repoPaths,
+              sessionId,
+              task
+            },
+            {
+              cwd: process.cwd(),
+              homeDir
+            }
+          );
+        },
+        promptConfirm: dependencies.promptConfirm,
+        promptInput: dependencies.promptInput,
+        promptSelect: dependencies.promptSelect,
+        repoPaths,
+        sleep: dependencies.sleep,
+        stdout: context.stdout,
+        taskDescription: task
+      });
+      if (!result.cancelled && !result.skippedPlanning) {
+        writeLine(
+          context.stdout,
+          `Planning is complete. Draft saved to ${launchSnapshot.paths.missionDraftPath}.`
+        );
+      }
+      if (result.cancelled) {
+        return;
+      }
+      const uploadResult = await runUploadPipeline({
+        allowSecrets: options.allowSecrets === true,
+        apiClient: client,
+        autoApprove: options.yes === true,
+        createSpinner: dependencies.createSpinner,
+        cwd: process.cwd(),
+        homeDir,
+        launchId: launchSnapshot.launchId,
+        promptConfirm: dependencies.promptConfirm,
+        repoPaths,
+        stdout: context.stdout
+      });
+      if (!uploadResult.finalized) {
+        return;
+      }
+      const mission2 = await createMissionFromLaunch({
+        apiClient: client,
+        cwd: process.cwd(),
+        homeDir,
+        launchId: launchSnapshot.launchId
+      });
+      writeLine(
+        context.stdout,
+        mission2.created ? `Created mission ${mission2.missionId}.` : `Resuming mission ${mission2.missionId}.`
+      );
+      const monitorResult = await monitorMission({
+        apiClient: client,
+        apiKey: authConfig.apiKey,
+        autoApprove: options.yes === true,
+        createSpinner: dependencies.createSpinner,
+        createWebSocket: dependencies.createWebSocket,
+        endpoint: authConfig.endpoint,
+        missionId: mission2.missionId,
+        promptInput: dependencies.promptInput,
+        promptSelect: dependencies.promptSelect,
+        registerSignalHandler: dependencies.registerSignalHandler,
+        sleep: dependencies.sleep,
+        stdout: context.stdout
+      });
+      if (monitorResult.exitCode !== 0) {
+        throw new CommanderError2(monitorResult.exitCode, "mission-monitor", "");
+      }
+    }
+  );
+}
+
+// src/commands/mission-status.ts
+import pc7 from "picocolors";
+function writeSection3(stdout, title) {
+  writeLine(stdout);
+  writeLine(stdout, pc7.bold(title));
+}
+function normalizeMilestoneOrder(milestones, features, assertions) {
+  const known = new Map(milestones.map((milestone) => [milestone.name, milestone]));
+  for (const feature of features) {
+    if (!feature.milestone || known.has(feature.milestone)) {
+      continue;
+    }
+    known.set(feature.milestone, {
+      assertionCount: 0,
+      completedFeatureCount: 0,
+      featureCount: 0,
+      name: feature.milestone,
+      passedAssertionCount: 0,
+      state: "unknown"
+    });
+  }
+  for (const assertion of assertions) {
+    if (!assertion.milestone || known.has(assertion.milestone)) {
+      continue;
+    }
+    known.set(assertion.milestone, {
+      assertionCount: 0,
+      completedFeatureCount: 0,
+      featureCount: 0,
+      name: assertion.milestone,
+      passedAssertionCount: 0,
+      state: "unknown"
+    });
+  }
+  return [...known.values()];
+}
+function summarizeAssertions2(assertions) {
+  return assertions.reduce(
+    (summary, assertion) => ({
+      passed: summary.passed + (assertion.status === "passed" ? 1 : 0),
+      total: summary.total + 1
+    }),
+    { passed: 0, total: 0 }
+  );
+}
+function summarizeAssertionsByMilestone(assertions) {
+  const summary = /* @__PURE__ */ new Map();
+  for (const assertion of assertions) {
+    const milestone = assertion.milestone ?? "unassigned";
+    const current = summary.get(milestone) ?? { passed: 0, total: 0 };
+    current.total += 1;
+    if (assertion.status === "passed") {
+      current.passed += 1;
+    }
+    summary.set(milestone, current);
+  }
+  return summary;
+}
+function renderMissionOverview(stdout, missionState) {
+  writeLine(stdout, `Mission ${missionState.missionId}`);
+  writeLine(stdout, `State: ${missionState.state}`);
+  writeLine(stdout, `Created: ${formatDateTime(missionState.createdAt)}`);
+  writeLine(stdout, `Updated: ${formatDateTime(missionState.updatedAt)}`);
+  writeLine(
+    stdout,
+    `Features: ${missionState.completedFeatures}/${missionState.totalFeatures}`
+  );
+  writeLine(
+    stdout,
+    `Assertions: ${missionState.passedAssertions}/${missionState.totalAssertions}`
+  );
+  writeLine(
+    stdout,
+    `Milestones: ${missionState.sealedMilestones}/${missionState.totalMilestones} sealed`
+  );
+}
+function renderActiveWorker(stdout, missionState) {
+  writeSection3(stdout, "Active worker");
+  writeLine(stdout, `Feature: ${missionState.currentFeatureId ?? "none"}`);
+  writeLine(
+    stdout,
+    `Worker session: ${missionState.currentWorkerSessionId ?? "none"}`
+  );
+}
+function renderBudget(stdout, missionState) {
+  if (missionState.estimatedCostUsd === null && missionState.inferenceTokensUsed === null && missionState.sandboxMinutesUsed === null) {
+    return;
+  }
+  writeSection3(stdout, "Budget / usage");
+  writeLine(stdout, `Estimated cost: ${formatCurrency(missionState.estimatedCostUsd)}`);
+  writeLine(
+    stdout,
+    `Inference tokens: ${missionState.inferenceTokensUsed ?? "\u2014"}`
+  );
+  writeLine(
+    stdout,
+    `Sandbox minutes: ${missionState.sandboxMinutesUsed ?? "\u2014"}`
+  );
+}
+function renderMilestones2(stdout, milestones, features) {
+  writeSection3(stdout, "Milestones");
+  for (const milestone of milestones) {
+    writeLine(
+      stdout,
+      `- ${pc7.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
+    );
+    for (const feature of milestoneFeatures) {
+      writeLine(stdout, `  \u2022 ${feature.id} \u2014 ${feature.status}`);
+    }
+  }
+}
+function renderAssertionSummary(stdout, milestones, assertions) {
+  writeSection3(stdout, "Assertion pass rates");
+  const overall = summarizeAssertions2(assertions);
+  writeLine(
+    stdout,
+    `Overall: ${overall.passed}/${overall.total} passed (${formatPercent(overall.passed, overall.total)})`
+  );
+  const byMilestone = summarizeAssertionsByMilestone(assertions);
+  for (const milestone of milestones) {
+    const summary = byMilestone.get(milestone.name) ?? {
+      passed: milestone.passedAssertionCount,
+      total: milestone.assertionCount
+    };
+    writeLine(
+      stdout,
+      `- ${milestone.name}: ${summary.passed}/${summary.total} passed (${formatPercent(summary.passed, summary.total)})`
+    );
+  }
+}
+function registerMissionStatusCommand(mission, context, dependencies = {}) {
+  mission.command("status").description("Show the status of a mission").argument("<missionId>").action(async (missionId, command) => {
+    const apiClient = await createMissionApiClient(context, command, dependencies);
+    const missionState = normalizeMissionState(
+      await apiClient.request({
+        path: `/missions/${missionId}/mission/state`
+      })
+    );
+    const [features, milestones, assertions] = await Promise.all([
+      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))
+    ]);
+    const milestoneList = normalizeMilestoneOrder(
+      milestones,
+      features,
+      assertions
+    );
+    renderMissionOverview(context.stdout, missionState);
+    renderActiveWorker(context.stdout, missionState);
+    renderBudget(context.stdout, missionState);
+    renderMilestones2(context.stdout, milestoneList, features);
+    renderAssertionSummary(context.stdout, milestoneList, assertions);
+  });
+}
+
+// src/commands/mission.ts
+function registerMissionCommands(program, context, dependencies = {}) {
+  const mission = program.command("mission").description("Manage missions");
+  registerMissionRunCommand(mission, context, dependencies);
+  registerMissionStatusCommand(mission, context, dependencies);
+  registerMissionListCommand(mission, context, dependencies);
+  registerMissionLifecycleCommands(mission, context, dependencies);
+}
+
+// src/cli.ts
+function readPackageVersion() {
+  const packagePath = fileURLToPath(new URL("../package.json", import.meta.url));
+  const packageJson = JSON.parse(
+    readFileSync(packagePath, "utf8")
+  );
+  return packageJson.version ?? "0.0.0";
+}
+function createProgram(dependencies = {}) {
+  const context = createCliContext(dependencies);
+  const program = new Command();
+  program.name("hz").description("Horizon CLI").version(readPackageVersion()).showHelpAfterError("(run `hz --help` for usage)").showSuggestionAfterError(true);
+  program.configureOutput({
+    writeErr: (value) => context.stderr.write(value),
+    writeOut: (value) => context.stdout.write(value)
+  });
+  program.option("--verbose", "show request and response details");
+  registerAuthCommands(program, context);
+  registerMissionCommands(program, context, dependencies);
+  return program;
+}
+function isEntrypoint() {
+  const entryPath = process.argv[1];
+  if (!entryPath) {
+    return false;
+  }
+  return path7.resolve(entryPath) === fileURLToPath(import.meta.url);
+}
+function writeError(stream, message) {
+  writeLine(stream, `Error: ${message}`);
+}
+function handleRunError(error, stderr) {
+  if (error instanceof CommanderError3) {
+    return error.exitCode;
+  }
+  if (error instanceof CliError) {
+    writeError(stderr, error.message);
+    return error.exitCode;
+  }
+  if (error instanceof ConfigError) {
+    writeError(stderr, error.message);
+    return 1;
+  }
+  if (error instanceof Error) {
+    writeError(stderr, error.message);
+    return 1;
+  }
+  writeError(stderr, "Unexpected CLI error.");
+  return 1;
+}
+async function runCli(argv, dependencies = {}) {
+  const program = createProgram(dependencies);
+  program.exitOverride();
+  try {
+    await program.parseAsync(argv, { from: "user" });
+    return 0;
+  } catch (error) {
+    return handleRunError(error, dependencies.stderr ?? process.stderr);
+  }
+}
+async function main() {
+  const exitCode = await runCli(process.argv.slice(2));
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}
+if (isEntrypoint()) {
+  await main();
+}
+export {
+  runCli
+};
+//# sourceMappingURL=hz.mjs.map