@coresource/hz 0.20.0 → 0.20.2

package/dist/hz.mjs

@@ -867,10 +867,9 @@ function registerMissionListCommand(mission, context, dependencies = {}) {
 }
 
 // src/commands/mission-lifecycle.ts
-import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
-import path3 from "path";
+import { confirm as defaultConfirmPrompt } from "@inquirer/prompts";
 import { CommanderError } from "commander";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 
 // src/monitor.ts
 import { setTimeout as delay2 } from "timers/promises";
@@ -2705,13 +2704,99 @@ async function monitorMission(options) {
   }
 }
 
-// src/commands/mission-lifecycle.ts
+// src/commands/mission-id.ts
+import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
+import path3 from "path";
+import pc5 from "picocolors";
 function asNonEmptyString5(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function resolveMissionCommandHomeDir(context) {
+  return resolveHomeDir({
+    env: context.env,
+    homeDir: context.homeDir
+  });
+}
+async function findMostRecentMissionId(homeDir) {
+  const launchesDir = path3.join(homeDir, ".hz", "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: ${pc5.cyan(detectedMissionId)}`
+    );
+    return detectedMissionId;
+  }
+  writeLine(
+    context.stderr,
+    "Mission ID is required when no recent local mission state is available."
+  );
+  command.help({ error: true });
+}
+
+// src/commands/mission-lifecycle.ts
+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 asFiniteNumber4(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+async function defaultPromptConfirm(options) {
+  return defaultConfirmPrompt({
+    default: options.default,
+    message: options.message
+  });
+}
 function writeSection(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc5.bold(title));
+  writeLine(stdout, pc6.bold(title));
 }
 function summarizeAssertions(assertions) {
   return assertions.reduce(
@@ -2800,72 +2885,6 @@ async function createMissionClientContext(context, command, dependencies, homeDi
     homeDir
   };
 }
-function resolveLifecycleHomeDir(context) {
-  return resolveHomeDir({
-    env: context.env,
-    homeDir: context.homeDir
-  });
-}
-async function findMostRecentMissionId(homeDir) {
-  const launchesDir = path3.join(homeDir, ".hz", "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: ${pc5.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);
@@ -2880,8 +2899,147 @@ async function fetchMissionSnapshotAfterConflict(apiClient, missionId, error) {
     throw error;
   }
 }
+function normalizeMissionDeleteStep(value) {
+  if (!isRecord5(value)) {
+    return {
+      detail: null,
+      launchId: null,
+      objectsDeleted: null,
+      rowsDeleted: null,
+      status: "unknown",
+      tables: {}
+    };
+  }
+  const rawTables = isRecord5(value.tables) ? value.tables : {};
+  const tables = {};
+  for (const [tableName, count] of Object.entries(rawTables)) {
+    const normalizedCount = asFiniteNumber4(count);
+    if (normalizedCount !== null) {
+      tables[tableName] = normalizedCount;
+    }
+  }
+  return {
+    detail: asNonEmptyString6(value.detail),
+    launchId: asNonEmptyString6(value.launch_id),
+    objectsDeleted: asFiniteNumber4(value.objects_deleted),
+    rowsDeleted: asFiniteNumber4(value.rows_deleted),
+    status: asNonEmptyString6(value.status) ?? "unknown",
+    tables
+  };
+}
+function normalizeMissionDeleteResponse(value) {
+  if (!isRecord5(value)) {
+    throw new CliError("Mission delete response was not an object.");
+  }
+  const missionId = asNonEmptyString6(value.mission_id);
+  if (!missionId) {
+    throw new CliError("Mission delete response is missing a mission_id.");
+  }
+  const rawSteps = isRecord5(value.steps) ? value.steps : {};
+  const steps = {};
+  for (const [stepName, stepValue] of Object.entries(rawSteps)) {
+    steps[stepName] = normalizeMissionDeleteStep(stepValue);
+  }
+  return {
+    deleted: value.deleted === true,
+    missionId,
+    steps
+  };
+}
+function formatMissionDeleteStatus(status) {
+  switch (status) {
+    case "success":
+      return pc6.green(status);
+    case "failed":
+      return pc6.red(status);
+    case "skipped":
+      return pc6.yellow(status);
+    default:
+      return status;
+  }
+}
+function formatMissionDeleteStepSummary(step) {
+  const parts = [];
+  if (step.detail) {
+    parts.push(step.detail);
+  }
+  if (step.rowsDeleted !== null) {
+    parts.push(`rows deleted: ${step.rowsDeleted}`);
+  }
+  if (step.objectsDeleted !== null) {
+    parts.push(`objects deleted: ${step.objectsDeleted}`);
+  }
+  const tableEntries = Object.entries(step.tables).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  if (tableEntries.length > 0) {
+    parts.push(
+      `tables: ${tableEntries.map(([tableName, count]) => `${tableName}=${count}`).join(", ")}`
+    );
+  }
+  if (step.launchId) {
+    parts.push(`launch id: ${step.launchId}`);
+  }
+  return parts.join(" \xB7 ") || "\u2014";
+}
+function sortMissionDeleteSteps(steps) {
+  const orderedSteps = [
+    "cancel",
+    "revoke_key",
+    "fleet_db",
+    "missions_db",
+    "r2_objects",
+    "kv_entries",
+    "planner_session",
+    "orphaned_launch",
+    "do_storage"
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const stepName of orderedSteps) {
+    const step = steps[stepName];
+    if (!step) {
+      continue;
+    }
+    seen.add(stepName);
+    result.push([stepName, step]);
+  }
+  for (const [stepName, step] of Object.entries(steps).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    if (seen.has(stepName)) {
+      continue;
+    }
+    result.push([stepName, step]);
+  }
+  return result;
+}
+function renderMissionDeleteResponse(stdout, response) {
+  writeLine(stdout, `Mission ${response.missionId} deleted successfully.`);
+  const failedSteps = Object.entries(response.steps).filter(
+    ([, step]) => step.status === "failed"
+  );
+  if (failedSteps.length > 0) {
+    writeLine(
+      stdout,
+      pc6.yellow(
+        `Warning: Mission cleanup completed with cleanup warnings (${failedSteps.length} failed step${failedSteps.length === 1 ? "" : "s"}).`
+      )
+    );
+  }
+  writeSection(stdout, "Cleanup steps");
+  renderTable(
+    stdout,
+    ["Step", "Status", "Result"],
+    sortMissionDeleteSteps(response.steps).map(([stepName, step]) => [
+      plainCell(stepName),
+      coloredCell(formatMissionDeleteStatus(step.status), step.status),
+      plainCell(formatMissionDeleteStepSummary(step))
+    ])
+  );
+}
 async function runLifecycleMutation(action, missionIdValue, command, context, dependencies) {
-  const homeDir = resolveLifecycleHomeDir(context);
+  const homeDir = resolveMissionCommandHomeDir(context);
   const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
   const { apiClient } = await createMissionClientContext(
     context,
@@ -2895,17 +3053,17 @@ async function runLifecycleMutation(action, missionIdValue, command, context, de
       method: "POST",
       path: `/missions/${missionId}/mission/${action}`
     });
-    const nextState = asNonEmptyString5(response.state) ?? (action === "pause" ? "paused" : "cancelled");
+    const nextState = asNonEmptyString6(response.state) ?? (action === "pause" ? "paused" : "cancelled");
     if (action === "pause") {
       writeLine(
         context.stdout,
-        `Mission ${pc5.cyan(missionId)} paused. Current state: ${pc5.bold(nextState)}.`
+        `Mission ${pc6.cyan(missionId)} paused. Current state: ${pc6.bold(nextState)}.`
       );
       return;
     }
     writeLine(
       context.stdout,
-      `Mission ${pc5.cyan(missionId)} cancelled. This action is irreversible. Current state: ${pc5.bold(nextState)}.`
+      `Mission ${pc6.cyan(missionId)} cancelled. This action is irreversible. Current state: ${pc6.bold(nextState)}.`
     );
   } catch (error) {
     if (!(error instanceof ApiError) || error.status !== 409) {
@@ -2919,11 +3077,51 @@ async function runLifecycleMutation(action, missionIdValue, command, context, de
     const verb = action === "pause" ? "paused" : "cancelled";
     writeLine(
       context.stdout,
-      `Mission ${pc5.cyan(missionId)} cannot be ${verb} because it is currently ${pc5.bold(missionState.state)}.`
+      `Mission ${pc6.cyan(missionId)} cannot be ${verb} because it is currently ${pc6.bold(missionState.state)}.`
     );
     throw new CommanderError(1, `mission-${action}`, "");
   }
 }
+function buildDeleteConfirmationMessage(missionId, forceDelete) {
+  const lines = [
+    `Are you sure you want to delete mission ${missionId}? This cannot be undone.`
+  ];
+  if (forceDelete) {
+    lines.push("This will cancel the running mission and delete all resources.");
+  }
+  return lines.join("\n");
+}
+async function runMissionDelete(missionIdValue, options, command, context, dependencies) {
+  const homeDir = resolveMissionCommandHomeDir(context);
+  const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
+  if (options.yes !== true) {
+    const confirmed = await (dependencies.promptConfirm ?? defaultPromptConfirm)({
+      default: false,
+      message: buildDeleteConfirmationMessage(missionId, options.force === true)
+    });
+    if (!confirmed) {
+      writeLine(context.stdout, pc6.yellow("Mission deletion cancelled."));
+      return;
+    }
+  }
+  const { apiClient } = await createMissionClientContext(
+    context,
+    command,
+    dependencies,
+    homeDir
+  );
+  const query = options.force === true ? "?force=true" : "";
+  const response = normalizeMissionDeleteResponse(
+    await apiClient.request({
+      method: "DELETE",
+      path: `/missions/${missionId}${query}`
+    })
+  );
+  if (!response.deleted) {
+    throw new CliError(`Mission ${missionId} was not deleted.`, 1);
+  }
+  renderMissionDeleteResponse(context.stdout, response);
+}
 function resolveResumeExitCode(state) {
   switch (state) {
     case "cancelled":
@@ -2948,7 +3146,7 @@ function resolveWatchExitCode(state) {
   }
 }
 async function runMissionResume(missionIdValue, command, context, dependencies) {
-  const homeDir = resolveLifecycleHomeDir(context);
+  const homeDir = resolveMissionCommandHomeDir(context);
   const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
   const { apiClient, authConfig } = await createMissionClientContext(
     context,
@@ -2964,10 +3162,10 @@ async function runMissionResume(missionIdValue, command, context, dependencies)
         method: "POST",
         path: `/missions/${missionId}/mission/resume`
       });
-      const nextState = asNonEmptyString5(response.state) ?? "orchestrator_turn";
+      const nextState = asNonEmptyString6(response.state) ?? "orchestrator_turn";
       writeLine(
         context.stdout,
-        `Mission ${pc5.cyan(missionId)} resumed. Current state: ${pc5.bold(nextState)}.`
+        `Mission ${pc6.cyan(missionId)} resumed. Current state: ${pc6.bold(nextState)}.`
       );
     } catch (error) {
       if (!(error instanceof ApiError) || error.status !== 409) {
@@ -2980,14 +3178,14 @@ async function runMissionResume(missionIdValue, command, context, dependencies)
       );
       writeLine(
         context.stdout,
-        `Mission ${pc5.cyan(missionId)} is currently ${pc5.bold(snapshot.state.state)}. Reconnecting to live updates if available.`
+        `Mission ${pc6.cyan(missionId)} is currently ${pc6.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 ${pc5.cyan(missionId)} from state ${pc5.bold(snapshot.state.state)}.`
+      `Reconnecting to mission ${pc6.cyan(missionId)} from state ${pc6.bold(snapshot.state.state)}.`
     );
   }
   renderMissionSnapshot(context.stdout, snapshot);
@@ -3019,7 +3217,7 @@ async function runMissionResume(missionIdValue, command, context, dependencies)
   }
 }
 async function runMissionWatch(missionIdValue, command, context, dependencies) {
-  const homeDir = resolveLifecycleHomeDir(context);
+  const homeDir = resolveMissionCommandHomeDir(context);
   const missionId = await resolveMissionId(missionIdValue, context, command, homeDir);
   const { apiClient, authConfig } = await createMissionClientContext(
     context,
@@ -3030,7 +3228,7 @@ async function runMissionWatch(missionIdValue, command, context, dependencies) {
   const snapshot = await fetchMissionSnapshot(apiClient, missionId);
   writeLine(
     context.stdout,
-    `Watching mission ${pc5.cyan(missionId)} from state ${pc5.bold(snapshot.state.state)}.`
+    `Watching mission ${pc6.cyan(missionId)} from state ${pc6.bold(snapshot.state.state)}.`
   );
   renderMissionSnapshot(context.stdout, snapshot);
   const watchExitCode = resolveWatchExitCode(snapshot.state.state);
@@ -3085,6 +3283,365 @@ function registerMissionLifecycleCommands(mission, context, dependencies = {}) {
       dependencies
     );
   });
+  mission.command("delete").description("Delete a mission and clean up its resources").argument("[missionId]").option("--force", "Force-cancel active missions before deletion").option("--yes", "Skip the confirmation prompt").action(async (missionId, options, command) => {
+    await runMissionDelete(
+      missionId,
+      options,
+      command,
+      context,
+      dependencies
+    );
+  });
+}
+
+// src/commands/mission-resources.ts
+import pc7 from "picocolors";
+function isRecord6(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+function asBoolean(value) {
+  return value === true;
+}
+function asFiniteNumber5(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asNullableNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asNonEmptyString7(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function formatInteger(value) {
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 0
+  }).format(value);
+}
+function formatDecimal(value, maximumFractionDigits = 2) {
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits,
+    minimumFractionDigits: 0
+  }).format(value);
+}
+function formatPercentValue(value) {
+  return `${formatDecimal(value, 2)}%`;
+}
+function formatBoolean(value) {
+  return value ? "yes" : "no";
+}
+function formatCents(value) {
+  return formatCurrency(value / 100);
+}
+function formatBytes(value) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let size = value;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex += 1;
+  }
+  const formatted = unitIndex === 0 ? formatInteger(size) : formatDecimal(size, 2);
+  return `${formatted} ${units[unitIndex]}`;
+}
+function writeSection2(stdout, title) {
+  writeLine(stdout);
+  writeLine(stdout, pc7.bold(title));
+}
+function renderMetricTable(stdout, rows) {
+  renderTable(
+    stdout,
+    ["Metric", "Value"],
+    rows.map(([label, value]) => [plainCell(label), plainCell(value)])
+  );
+}
+function renderOptionalTable(stdout, title, headers, rows, emptyMessage) {
+  writeLine(stdout);
+  writeLine(stdout, title);
+  if (rows.length === 0) {
+    writeLine(stdout, emptyMessage);
+    return;
+  }
+  renderTable(
+    stdout,
+    headers,
+    rows.map((row) => row.map((value) => plainCell(value)))
+  );
+}
+function normalizeInferenceByModel(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (!isRecord6(entry)) {
+      return [];
+    }
+    const model = asNonEmptyString7(entry.model);
+    if (!model) {
+      return [];
+    }
+    return [{
+      costUsd: asFiniteNumber5(entry.cost_usd),
+      model,
+      requests: asFiniteNumber5(entry.requests),
+      standardTokens: asFiniteNumber5(entry.standard_tokens),
+      tokens: asFiniteNumber5(entry.tokens)
+    }];
+  });
+}
+function normalizeInferenceByFeature(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (!isRecord6(entry)) {
+      return [];
+    }
+    const featureId = asNonEmptyString7(entry.feature_id);
+    if (!featureId) {
+      return [];
+    }
+    return [{
+      costUsd: asFiniteNumber5(entry.cost_usd),
+      featureId,
+      requests: asFiniteNumber5(entry.requests),
+      standardTokens: asFiniteNumber5(entry.standard_tokens),
+      tokens: asFiniteNumber5(entry.tokens)
+    }];
+  });
+}
+function normalizeSandboxByClass(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (!isRecord6(entry)) {
+      return [];
+    }
+    const instanceClass = asNonEmptyString7(entry.instance_class);
+    if (!instanceClass) {
+      return [];
+    }
+    return [{
+      containers: asFiniteNumber5(entry.containers),
+      costCents: asFiniteNumber5(entry.cost_cents),
+      instanceClass,
+      minutes: asFiniteNumber5(entry.minutes)
+    }];
+  });
+}
+function normalizeSandboxContainers(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (!isRecord6(entry)) {
+      return [];
+    }
+    const containerName = asNonEmptyString7(entry.container_name);
+    if (!containerName) {
+      return [];
+    }
+    return [{
+      containerName,
+      createdAt: asNonEmptyString7(entry.created_at),
+      endedAt: asNonEmptyString7(entry.ended_at),
+      featureId: asNonEmptyString7(entry.feature_id),
+      instanceClass: asNonEmptyString7(entry.instance_class) ?? "unknown",
+      startedAt: asNonEmptyString7(entry.started_at),
+      status: asNonEmptyString7(entry.status) ?? "unknown",
+      workerSessionId: asNonEmptyString7(entry.worker_session_id)
+    }];
+  });
+}
+function normalizeStorageD1Rows(value) {
+  if (!isRecord6(value)) {
+    return {};
+  }
+  const normalized = {};
+  for (const [key, count] of Object.entries(value)) {
+    normalized[key] = asFiniteNumber5(count);
+  }
+  return normalized;
+}
+function normalizeMissionResourceSummary(value) {
+  if (!isRecord6(value)) {
+    throw new Error("Mission resources response was not an object.");
+  }
+  const missionId = asNonEmptyString7(value.mission_id);
+  if (!missionId) {
+    throw new Error("Mission resources response is missing a mission_id.");
+  }
+  const inference = isRecord6(value.inference) ? value.inference : {};
+  const sandboxCompute = isRecord6(value.sandbox_compute) ? value.sandbox_compute : {};
+  const storage = isRecord6(value.storage) ? value.storage : {};
+  const storageR2 = isRecord6(storage.r2) ? storage.r2 : {};
+  const storageDo = isRecord6(storage.do_storage) ? storage.do_storage : {};
+  const budget = isRecord6(value.budget) ? value.budget : {};
+  return {
+    budget: {
+      exceeded: asBoolean(budget.exceeded),
+      maxInferenceCostUsd: asNullableNumber3(budget.max_inference_cost_usd),
+      maxInferenceTokens: asNullableNumber3(budget.max_inference_tokens),
+      percentUsed: asFiniteNumber5(budget.percent_used),
+      warning: asBoolean(budget.warning)
+    },
+    inference: {
+      byFeature: normalizeInferenceByFeature(inference.by_feature),
+      byModel: normalizeInferenceByModel(inference.by_model),
+      totalCostUsd: asFiniteNumber5(inference.total_cost_usd),
+      totalRequests: asFiniteNumber5(inference.total_requests),
+      totalStandardTokens: asFiniteNumber5(inference.total_standard_tokens),
+      totalTokens: asFiniteNumber5(inference.total_tokens)
+    },
+    missionId,
+    sandboxCompute: {
+      byClass: normalizeSandboxByClass(sandboxCompute.by_class),
+      containers: normalizeSandboxContainers(sandboxCompute.containers),
+      totalContainers: asFiniteNumber5(sandboxCompute.total_containers),
+      totalCostCents: asFiniteNumber5(sandboxCompute.total_cost_cents),
+      totalMinutes: asFiniteNumber5(sandboxCompute.total_minutes)
+    },
+    snapshotAt: asNonEmptyString7(value.snapshot_at),
+    storage: {
+      d1Rows: normalizeStorageD1Rows(storage.d1_rows),
+      doStorage: {
+        progressEventCount: asFiniteNumber5(storageDo.progress_event_count)
+      },
+      r2: {
+        objectCount: asFiniteNumber5(storageR2.object_count),
+        totalBytes: asFiniteNumber5(storageR2.total_bytes)
+      }
+    },
+    tenantId: asNonEmptyString7(value.tenant_id)
+  };
+}
+function renderMissionResourceSummary(stdout, summary) {
+  writeLine(stdout, `Mission ${summary.missionId}`);
+  writeLine(stdout, `Tenant: ${summary.tenantId ?? "\u2014"}`);
+  writeLine(stdout, `Snapshot: ${formatDateTime(summary.snapshotAt)}`);
+  writeSection2(stdout, "Inference");
+  renderMetricTable(stdout, [
+    ["Total tokens", formatInteger(summary.inference.totalTokens)],
+    ["Standard tokens", formatInteger(summary.inference.totalStandardTokens)],
+    ["Cost", formatCurrency(summary.inference.totalCostUsd)],
+    ["Requests", formatInteger(summary.inference.totalRequests)]
+  ]);
+  renderOptionalTable(
+    stdout,
+    "By model",
+    ["Model", "Tokens", "Standard tokens", "Cost", "Requests"],
+    summary.inference.byModel.map((entry) => [
+      entry.model,
+      formatInteger(entry.tokens),
+      formatInteger(entry.standardTokens),
+      formatCurrency(entry.costUsd),
+      formatInteger(entry.requests)
+    ]),
+    "No per-model inference usage recorded."
+  );
+  renderOptionalTable(
+    stdout,
+    "By feature",
+    ["Feature", "Tokens", "Standard tokens", "Cost", "Requests"],
+    summary.inference.byFeature.map((entry) => [
+      entry.featureId,
+      formatInteger(entry.tokens),
+      formatInteger(entry.standardTokens),
+      formatCurrency(entry.costUsd),
+      formatInteger(entry.requests)
+    ]),
+    "No per-feature inference usage recorded."
+  );
+  writeSection2(stdout, "Sandbox compute");
+  renderMetricTable(stdout, [
+    ["Total containers", formatInteger(summary.sandboxCompute.totalContainers)],
+    ["Total minutes", formatInteger(summary.sandboxCompute.totalMinutes)],
+    ["Cost", formatCents(summary.sandboxCompute.totalCostCents)]
+  ]);
+  renderOptionalTable(
+    stdout,
+    "Per class",
+    ["Instance class", "Containers", "Minutes", "Cost"],
+    summary.sandboxCompute.byClass.map((entry) => [
+      entry.instanceClass,
+      formatInteger(entry.containers),
+      formatInteger(entry.minutes),
+      formatCents(entry.costCents)
+    ]),
+    "No sandbox class breakdown recorded."
+  );
+  renderOptionalTable(
+    stdout,
+    "Containers",
+    [
+      "Container",
+      "Feature",
+      "Worker",
+      "Class",
+      "Status",
+      "Created",
+      "Started",
+      "Ended"
+    ],
+    summary.sandboxCompute.containers.map((entry) => [
+      entry.containerName,
+      entry.featureId ?? "\u2014",
+      entry.workerSessionId ?? "\u2014",
+      entry.instanceClass,
+      entry.status,
+      formatDateTime(entry.createdAt),
+      formatDateTime(entry.startedAt),
+      formatDateTime(entry.endedAt)
+    ]),
+    "No sandbox containers recorded."
+  );
+  writeSection2(stdout, "Storage");
+  renderMetricTable(stdout, [
+    ["R2 objects", formatInteger(summary.storage.r2.objectCount)],
+    ["R2 bytes", formatBytes(summary.storage.r2.totalBytes)],
+    [
+      "Progress events",
+      formatInteger(summary.storage.doStorage.progressEventCount)
+    ]
+  ]);
+  renderOptionalTable(
+    stdout,
+    "D1 rows",
+    ["Table", "Rows"],
+    Object.entries(summary.storage.d1Rows).sort(([left], [right]) => left.localeCompare(right)).map(([tableName, count]) => [tableName, formatInteger(count)]),
+    "No mission D1 rows recorded."
+  );
+  writeSection2(stdout, "Budget");
+  renderMetricTable(stdout, [
+    [
+      "Max inference cost",
+      summary.budget.maxInferenceCostUsd === null ? "\u2014" : formatCurrency(summary.budget.maxInferenceCostUsd)
+    ],
+    [
+      "Max inference tokens",
+      summary.budget.maxInferenceTokens === null ? "\u2014" : formatInteger(summary.budget.maxInferenceTokens)
+    ],
+    ["Percent used", formatPercentValue(summary.budget.percentUsed)],
+    ["Exceeded", formatBoolean(summary.budget.exceeded)],
+    ["Warning", formatBoolean(summary.budget.warning)]
+  ]);
+}
+function registerMissionResourcesCommand(mission, context, dependencies = {}) {
+  mission.command("resources").description("Show resource usage for a mission").argument("[missionId]").action(async (missionIdValue, _options, command) => {
+    const homeDir = resolveMissionCommandHomeDir(context);
+    const missionId = await resolveMissionId(
+      missionIdValue,
+      context,
+      command,
+      homeDir
+    );
+    const apiClient = await createMissionApiClient(context, command, dependencies);
+    const summary = normalizeMissionResourceSummary(
+      await apiClient.request({
+        path: `/missions/${missionId}/resources`
+      })
+    );
+    renderMissionResourceSummary(context.stdout, summary);
+  });
 }
 
 // src/commands/mission-run.ts
@@ -3095,54 +3652,54 @@ import { CommanderError as CommanderError2 } from "commander";
 // src/planning.ts
 import path4 from "path";
 import {
-  confirm as defaultConfirmPrompt,
+  confirm as defaultConfirmPrompt2,
   input as defaultInputPrompt2,
   select as defaultSelectPrompt2
 } from "@inquirer/prompts";
 import ora2 from "ora";
-import pc6 from "picocolors";
+import pc8 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) {
+function isRecord7(value) {
   return value !== null && !Array.isArray(value) && typeof value === "object";
 }
-function asNonEmptyString6(value) {
+function asNonEmptyString8(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) : [];
+  return Array.isArray(value) ? value.map((item) => asNonEmptyString8(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"
+  return payload.questions.filter((question) => isRecord7(question)).map((question) => ({
+    detailPrompt: asNonEmptyString8(question.detailPrompt) ?? void 0,
+    freeTextOptionId: asNonEmptyString8(question.freeTextOptionId) ?? void 0,
+    id: asNonEmptyString8(question.id) ?? "question",
+    inputDefault: asNonEmptyString8(question.inputDefault) ?? void 0,
+    options: Array.isArray(question.options) ? question.options.filter((option) => isRecord7(option)).map((option) => ({
+      description: asNonEmptyString8(option.description) ?? void 0,
+      id: asNonEmptyString8(option.id) ?? "option",
+      label: asNonEmptyString8(option.label) ?? "Option"
     })) : [],
     references: asStringArray2(question.references),
-    text: asNonEmptyString6(question.text) ?? "Clarification required."
+    text: asNonEmptyString8(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",
+  return payload.milestones.filter((milestone) => isRecord7(milestone)).map((milestone) => ({
+    description: asNonEmptyString8(milestone.description) ?? void 0,
+    name: asNonEmptyString8(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);
+  return isRecord7(value) && typeof value.taskDescription === "string" && Array.isArray(value.milestones) && Array.isArray(value.features) && Array.isArray(value.assertions);
 }
 function extractDraft(payload) {
   if (!payload) {
@@ -3161,7 +3718,7 @@ function countItems(payload, key) {
   return Array.isArray(value) ? value.length : 0;
 }
 function formatBudgetSummary(draft) {
-  if (!isRecord5(draft.config) || !isRecord5(draft.config.budget)) {
+  if (!isRecord7(draft.config) || !isRecord7(draft.config.budget)) {
     return "unknown";
   }
   const budget = draft.config.budget;
@@ -3175,13 +3732,13 @@ function formatBudgetSummary(draft) {
   }
 }
 function extractFailures(error) {
-  return error instanceof ApiError && isRecord5(error.payload) ? asStringArray2(error.payload.failures) : [];
+  return error instanceof ApiError && isRecord7(error.payload) ? asStringArray2(error.payload.failures) : [];
 }
 function extractErrorCode(error) {
-  if (!(error instanceof ApiError) || !isRecord5(error.payload)) {
+  if (!(error instanceof ApiError) || !isRecord7(error.payload)) {
     return null;
   }
-  return asNonEmptyString6(error.payload.error);
+  return asNonEmptyString8(error.payload.error);
 }
 function extractRound(payload) {
   return typeof payload?.round === "number" && Number.isFinite(payload.round) ? payload.round : 1;
@@ -3234,8 +3791,8 @@ async function defaultPromptInput2(options) {
     message: options.message
   });
 }
-async function defaultPromptConfirm(options) {
-  return defaultConfirmPrompt({
+async function defaultPromptConfirm2(options) {
+  return defaultConfirmPrompt2({
     default: options.default,
     message: options.message
   });
@@ -3265,20 +3822,20 @@ async function postDraftApproval(client, sessionId) {
     path: `/plan/${sessionId}/approve`
   });
 }
-function writeSection2(stdout, title) {
+function writeSection3(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc6.bold(title));
+  writeLine(stdout, pc8.bold(title));
 }
 function renderQuestion(stdout, question, index) {
   writeLine(stdout, `${index + 1}. ${question.text}`);
   if (question.references && question.references.length > 0) {
-    writeLine(stdout, `   ${pc6.dim(`References: ${question.references.join(", ")}`)}`);
+    writeLine(stdout, `   ${pc8.dim(`References: ${question.references.join(", ")}`)}`);
   }
 }
 function renderMilestones(stdout, milestones, reviewRound) {
-  writeSection2(stdout, `Milestone review round ${reviewRound}`);
+  writeSection3(stdout, `Milestone review round ${reviewRound}`);
   milestones.forEach((milestone, index) => {
-    writeLine(stdout, `${index + 1}. ${pc6.cyan(milestone.name)}`);
+    writeLine(stdout, `${index + 1}. ${pc8.cyan(milestone.name)}`);
     if (milestone.description) {
       writeLine(stdout, `   ${milestone.description}`);
     }
@@ -3289,14 +3846,14 @@ function renderMilestones(stdout, milestones, reviewRound) {
   });
 }
 function renderDraftSummary(stdout, payload, draft) {
-  writeSection2(stdout, "Draft summary");
+  writeSection3(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");
+  writeSection3(stdout, "Unresolved clarification items");
   failures.forEach((failure) => {
     writeLine(stdout, `- ${failure}`);
   });
@@ -3467,7 +4024,7 @@ async function resolveClarification(options, sessionId, initialPayload) {
     if (payload.state !== "clarifying") {
       break;
     }
-    writeSection2(options.stdout, `Clarification round ${round}`);
+    writeSection3(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);
@@ -3488,7 +4045,7 @@ async function resolveClarification(options, sessionId, initialPayload) {
       }
       writeLine(
         options.stdout,
-        pc6.yellow("Proceeding because --force is enabled.")
+        pc8.yellow("Proceeding because --force is enabled.")
       );
       payload = await postMilestoneConfirmation(options.client, sessionId, {});
       return {
@@ -3529,7 +4086,7 @@ async function resolveMilestones(options, sessionId, initialPayload) {
   while (true) {
     const milestones = extractMilestones(payload);
     renderMilestones(options.stdout, milestones, reviewRound);
-    const confirmed = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm)({
+    const confirmed = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm2)({
       default: true,
       message: "Do these milestones look correct?"
     });
@@ -3570,7 +4127,7 @@ async function runPlanningFlow(options) {
   if (options.existingMissionDraft) {
     writeLine(
       options.stdout,
-      pc6.cyan("Skipping planning because mission-draft.json already exists.")
+      pc8.cyan("Skipping planning because mission-draft.json already exists.")
     );
     return {
       cancelled: false,
@@ -3579,7 +4136,7 @@ async function runPlanningFlow(options) {
       skippedPlanning: true
     };
   }
-  const sessionId = asNonEmptyString6(options.existingSessionId) ?? asNonEmptyString6(
+  const sessionId = asNonEmptyString8(options.existingSessionId) ?? asNonEmptyString8(
     (await options.client.request({
       body: {
         repos: options.repoPaths,
@@ -3621,12 +4178,12 @@ async function runPlanningFlow(options) {
     payload
   );
   renderDraftSummary(options.stdout, summaryPayload, draft);
-  const approved = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm)({
+  const approved = options.autoApprove ? true : await (options.promptConfirm ?? defaultPromptConfirm2)({
     default: true,
     message: "Approve this draft and continue to upload?"
   });
   if (!approved) {
-    writeLine(options.stdout, pc6.yellow("Planning cancelled before upload."));
+    writeLine(options.stdout, pc8.yellow("Planning cancelled before upload."));
     return {
       cancelled: true,
       draft,
@@ -3635,7 +4192,7 @@ async function runPlanningFlow(options) {
     };
   }
   await options.persistMissionDraft(draft);
-  writeLine(options.stdout, pc6.green("Saved approved mission draft."));
+  writeLine(options.stdout, pc8.green("Saved approved mission draft."));
   return {
     cancelled: false,
     draft,
@@ -3650,7 +4207,7 @@ import { createReadStream as createReadStream2 } from "fs";
 import path6 from "path";
 import { Transform as Transform2 } from "stream";
 import ora3 from "ora";
-import pc7 from "picocolors";
+import pc9 from "picocolors";
 
 // src/snapshot.ts
 import { execFile } from "child_process";
@@ -4198,13 +4755,13 @@ function defaultCreateSpinner3(text) {
   spinner.start();
   return spinner;
 }
-async function defaultPromptConfirm2(options) {
+async function defaultPromptConfirm3(options) {
   return confirm({
     default: options.default,
     message: options.message
   });
 }
-function formatBytes(bytes) {
+function formatBytes2(bytes) {
   if (!Number.isFinite(bytes) || bytes < 1024) {
     return `${bytes} B`;
   }
@@ -4226,7 +4783,7 @@ function formatDuration(milliseconds) {
 function formatRate(bytesTransferred, elapsedMs) {
   const safeElapsedMs = Math.max(elapsedMs, 1);
   const bytesPerSecond = bytesTransferred * 1e3 / safeElapsedMs;
-  return `${formatBytes(Math.max(1, Math.round(bytesPerSecond)))}/s`;
+  return `${formatBytes2(Math.max(1, Math.round(bytesPerSecond)))}/s`;
 }
 function formatFinding(finding) {
   const location = finding.line === null ? finding.filePath : `${finding.filePath}:${finding.line}`;
@@ -4247,19 +4804,19 @@ function isTerminalUploadStatus2(status) {
   return status === "uploaded" || status === "blob_exists";
 }
 function renderSafetyGate(stdout, repos, existingBlobs) {
-  writeLine(stdout, pc7.bold("Upload safety check"));
+  writeLine(stdout, pc9.bold("Upload safety check"));
   writeLine(stdout, "Repos queued for upload:");
   for (const repo of repos) {
-    const cleanliness = repo.manifest.dirty ? pc7.yellow("dirty") : pc7.green("clean");
-    const secretSummary = repo.secretFindings.length > 0 ? pc7.red(`${repo.secretFindings.length} finding(s)`) : pc7.green("no findings");
-    const dedupSummary = existingBlobs.has(repo.manifest.archiveSha256) ? pc7.cyan("blob already exists remotely") : "new upload";
+    const cleanliness = repo.manifest.dirty ? pc9.yellow("dirty") : pc9.green("clean");
+    const secretSummary = repo.secretFindings.length > 0 ? pc9.red(`${repo.secretFindings.length} finding(s)`) : pc9.green("no findings");
+    const dedupSummary = existingBlobs.has(repo.manifest.archiveSha256) ? pc9.cyan("blob already exists remotely") : "new upload";
     writeLine(
       stdout,
-      `- ${pc7.cyan(repo.manifest.repoId)} \u2014 ${repo.manifest.localPath}`
+      `- ${pc9.cyan(repo.manifest.repoId)} \u2014 ${repo.manifest.localPath}`
     );
     writeLine(
       stdout,
-      `  Status: ${cleanliness}; archive ${formatBytes(repo.manifest.archiveBytes)}; ${dedupSummary}; secret scan ${secretSummary}`
+      `  Status: ${cleanliness}; archive ${formatBytes2(repo.manifest.archiveBytes)}; ${dedupSummary}; secret scan ${secretSummary}`
     );
     if (repo.warnings.length > 0) {
       for (const warning of repo.warnings) {
@@ -4316,7 +4873,7 @@ 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)`
+    `Uploading ${repo.manifest.repoId} 0 B / ${formatBytes2(repo.manifest.archiveBytes)} (0 B/s)`
   );
   spinner.start(spinner.text);
   const startedAt = Date.now();
@@ -4325,7 +4882,7 @@ async function uploadArchive(options, repo, uploadUrl) {
     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)})`;
+      spinner.text = `Uploading ${repo.manifest.repoId} ${formatBytes2(bytesTransferred)} / ${formatBytes2(repo.manifest.archiveBytes)} (${formatRate(bytesTransferred, elapsedMs2)})`;
       callback(null, chunk);
     }
   });
@@ -4356,7 +4913,7 @@ async function uploadArchive(options, repo, uploadUrl) {
   }
   const elapsedMs = Date.now() - startedAt;
   spinner.succeed(
-    `Uploaded ${repo.manifest.repoId} ${formatBytes(bytesTransferred)} in ${formatDuration(elapsedMs)} (${formatRate(bytesTransferred, elapsedMs)})`
+    `Uploaded ${repo.manifest.repoId} ${formatBytes2(bytesTransferred)} in ${formatDuration(elapsedMs)} (${formatRate(bytesTransferred, elapsedMs)})`
   );
 }
 async function processRepoUpload(options, repo, remoteLaunchId) {
@@ -4399,7 +4956,7 @@ async function processRepoUpload(options, repo, remoteLaunchId) {
     );
     writeLine(
       options.stdout,
-      pc7.cyan(`Skipping upload for ${repo.manifest.repoId}; blob already exists remotely.`)
+      pc9.cyan(`Skipping upload for ${repo.manifest.repoId}; blob already exists remotely.`)
     );
     return;
   }
@@ -4436,7 +4993,7 @@ async function processRepoUpload(options, repo, remoteLaunchId) {
   );
 }
 async function runUploadPipeline(options) {
-  const promptConfirm = options.promptConfirm ?? defaultPromptConfirm2;
+  const promptConfirm = options.promptConfirm ?? defaultPromptConfirm3;
   const launchSnapshot = await loadLaunchSnapshot(options.launchId, {
     cwd: options.cwd,
     homeDir: options.homeDir
@@ -4493,7 +5050,7 @@ async function runUploadPipeline(options) {
     })) {
       writeLine(
         options.stdout,
-        pc7.yellow("Upload cancelled before creating a remote launch.")
+        pc9.yellow("Upload cancelled before creating a remote launch.")
       );
       return {
         finalized: false,
@@ -4510,7 +5067,7 @@ async function runUploadPipeline(options) {
     if (existingBlobs.size > 0) {
       writeLine(
         options.stdout,
-        pc7.cyan(
+        pc9.cyan(
           `Remote dedup will reuse ${existingBlobs.size} existing blob${existingBlobs.size === 1 ? "" : "s"}.`
         )
       );
@@ -4537,7 +5094,7 @@ async function runUploadPipeline(options) {
     if (isTerminalUploadStatus2(uploadStates.get(repo.manifest.repoId))) {
       writeLine(
         options.stdout,
-        pc7.cyan(`Skipping ${repo.manifest.repoId}; already completed in upload-state.json.`)
+        pc9.cyan(`Skipping ${repo.manifest.repoId}; already completed in upload-state.json.`)
       );
       continue;
     }
@@ -4555,7 +5112,7 @@ async function runUploadPipeline(options) {
       failures.push(repo.manifest.repoId);
       writeLine(
         options.stdout,
-        pc7.red(
+        pc9.red(
           error instanceof Error ? error.message : `Upload failed for ${repo.manifest.repoId}.`
         )
       );
@@ -4577,7 +5134,7 @@ async function runUploadPipeline(options) {
   }
   writeLine(
     options.stdout,
-    pc7.green(`Upload complete. Remote launch ${remoteLaunchId} is finalized.`)
+    pc9.green(`Upload complete. Remote launch ${remoteLaunchId} is finalized.`)
   );
   return {
     finalized: true,
@@ -4752,10 +5309,10 @@ function registerMissionRunCommand(mission, context, dependencies = {}) {
 }
 
 // src/commands/mission-status.ts
-import pc8 from "picocolors";
-function writeSection3(stdout, title) {
+import pc10 from "picocolors";
+function writeSection4(stdout, title) {
   writeLine(stdout);
-  writeLine(stdout, pc8.bold(title));
+  writeLine(stdout, pc10.bold(title));
 }
 function normalizeMilestoneOrder(milestones, features, assertions) {
   const known = new Map(milestones.map((milestone) => [milestone.name, milestone]));
@@ -4828,7 +5385,7 @@ function renderMissionOverview(stdout, missionState) {
   );
 }
 function renderActiveWorker(stdout, missionState) {
-  writeSection3(stdout, "Active worker");
+  writeSection4(stdout, "Active worker");
   writeLine(stdout, `Feature: ${missionState.currentFeatureId ?? "none"}`);
   writeLine(
     stdout,
@@ -4839,7 +5396,7 @@ function renderBudget(stdout, missionState) {
   if (missionState.estimatedCostUsd === null && missionState.inferenceTokensUsed === null && missionState.sandboxMinutesUsed === null) {
     return;
   }
-  writeSection3(stdout, "Budget / usage");
+  writeSection4(stdout, "Budget / usage");
   writeLine(stdout, `Estimated cost: ${formatCurrency(missionState.estimatedCostUsd)}`);
   writeLine(
     stdout,
@@ -4851,11 +5408,11 @@ function renderBudget(stdout, missionState) {
   );
 }
 function renderMilestones2(stdout, milestones, features) {
-  writeSection3(stdout, "Milestones");
+  writeSection4(stdout, "Milestones");
   for (const milestone of milestones) {
     writeLine(
       stdout,
-      `- ${pc8.cyan(milestone.name)} (${milestone.state}) \xB7 ${milestone.completedFeatureCount}/${milestone.featureCount} features \xB7 ${milestone.passedAssertionCount}/${milestone.assertionCount} assertions`
+      `- ${pc10.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
@@ -4866,7 +5423,7 @@ function renderMilestones2(stdout, milestones, features) {
   }
 }
 function renderAssertionSummary(stdout, milestones, assertions) {
-  writeSection3(stdout, "Assertion pass rates");
+  writeSection4(stdout, "Assertion pass rates");
   const overall = summarizeAssertions2(assertions);
   writeLine(
     stdout,
@@ -4917,6 +5474,7 @@ function registerMissionCommands(program, context, dependencies = {}) {
   registerMissionStatusCommand(mission, context, dependencies);
   registerMissionInfoCommand(mission, context, dependencies);
   registerMissionListCommand(mission, context, dependencies);
+  registerMissionResourcesCommand(mission, context, dependencies);
   registerMissionLifecycleCommands(mission, context, dependencies);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coresource/hz",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "type": "module",
   "bin": {
     "hz": "dist/hz.mjs"
@@ -14,7 +14,7 @@
   "scripts": {
     "build": "tsup",
     "prepublishOnly": "npm run build",
-    "test": "vitest run",
+    "test": "vitest run --sequence.concurrent false",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {