@mytegroupinc/myte-core 0.0.26 → 0.0.27

package/README.md

@@ -40,7 +40,7 @@ Coding agents should treat `MYTE_API_KEY` as a project-scoped Project Assistant
 - Use `suggestions create` for both existing-mission edits and new-mission proposals. The only valid `change_type` values are `update` and `create`.
 - Use `suggestions revise` only against an existing `suggestion_id`; do not send `change_type` on revisions because the backend keeps the thread's original type.
 - Use `suggestions review` for owner/elevated mission-review decisions: `approve`, `request_changes`, or `reject`.
-- Use `mission archive` and `mission restore` for lifecycle archive/restore. Do not send `Archived` through `mission status`.
+- Use `mission archive` for project-key lifecycle archival. Do not send `Archived` through `mission status`; restore archived missions from the web archived-board view.
 - Use `feedback move` only when a direct audited state move is intended and include a concrete `--reason`.
 - Use `update-team` when an agent needs to leave a project-level implementation note or verification comment.
 
@@ -72,9 +72,8 @@ Feedback comment support:
 | Suggest new mission | `myte suggestions create` with `change_type: create` | Requires `change_set.title` and `change_set.description`; creates a review thread only; the mission card is created only after approval. |
 | Revise a suggestion | `myte suggestions revise` with `suggestion_id` | Adds another revision to the same thread. Do not include `change_type`. |
 | Review a suggestion | `myte suggestions review` with `review_action: approve|request_changes|reject` | Project Owner or elevated mission-review delegate required. Approval mutates/creates the mission once; reject archives the thread only; request_changes keeps it actionable. |
-| Update mission status | `myte mission status --mission-ids "M001" --status todo|in_progress|done` | Project-key surface updates canonical mission status for active cards. |
-| Archive mission | `myte mission archive --mission-ids "M001[,M002]" --reason "..."` | Project Owner or elevated delegate required. Sets `Archived`, removes cards from normal bootstrap/board state, and writes mission activity. |
-| Restore mission | `myte mission restore --mission-ids "M001[,M002]" --status todo|in_progress|done --reason "..."` | Project Owner or elevated delegate required. Restores archived cards to an active status and writes mission activity. |
+| Update mission status | `myte mission status --mission-ids "M001" --status todo|in_progress|done` | Project-key surface updates canonical mission status for active cards and refreshes local bootstrap + mission-ops by default. |
+| Archive mission | `myte mission archive --mission-ids "M001[,M002]" --reason "..."` | Project Owner or elevated delegate required. Sets `Archived`, removes cards from normal bootstrap/board state, writes mission activity, and refreshes local bootstrap + mission-ops by default. |
 
 Create payloads:
 
@@ -178,7 +177,6 @@ Mutation routes:
 - `POST /api/project-assistant/run-qaqc`
 - `POST /api/project-assistant/mission-status-update`
 - `POST /api/project-assistant/mission-archive`
-- `POST /api/project-assistant/mission-restore`
 - `POST /api/project-assistant/project-comment`
 - `POST /api/project-assistant/update-owner`
 - `POST /api/project-assistant/client-update-drafts`

package/cli.js

@@ -30,6 +30,7 @@ const REMOVED_COMMAND_MESSAGES = {
   "add-prd": "The `add-prd` alias has been removed. Use `myte create-prd <file.md> [more.md ...]`.",
   prd: "The `prd` alias has been removed. Use `myte create-prd <file.md> [more.md ...]`.",
   "qaqc-status-update": "The `qaqc-status-update` command has been removed. Use `myte mission status --mission-ids \"M001,M002\" --status todo|in_progress|done`.",
+  "mission-restore": "The project-key `myte mission restore` command has been removed. Restore archived missions from the Myte web archived missions board.",
 };
 
 function findEnvPath(startDir) {
@@ -185,9 +186,8 @@ function printHelp() {
     "  myte config [--json]",
     "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
     "  myte run-qaqc --mission-ids \"M001[,M002...]\" [--wait] [--sync] [--force] [--json]",
-    "  myte mission status --mission-ids \"M001[,M002...]\" --status todo|in_progress|done [--json]",
-    "  myte mission archive --mission-ids \"M001[,M002...]\" [--reason \"...\"] [--json]",
-    "  myte mission restore --mission-ids \"M001[,M002...]\" [--status todo|in_progress|done] [--reason \"...\"] [--json]",
+    "  myte mission status --mission-ids \"M001[,M002...]\" --status todo|in_progress|done [--no-sync] [--json]",
+    "  myte mission archive --mission-ids \"M001[,M002...]\" [--reason \"...\"] [--no-sync] [--json]",
     "  myte sync-qaqc [--output-dir ./MyteCommandCenter] [--json]",
     "  myte suggestions sync [--output-dir ./MyteCommandCenter] [--json]",
     "  myte suggestions create [--file ./payload.yml] [--no-sync] [--json]",
@@ -266,13 +266,16 @@ function printHelp() {
     "  - Accepts mission business ids and normalizes status aliases like todo, in_progress, and done",
     "  - Canonical mission statuses are exactly: Todo, In Progress, Done",
     "  - This only changes mission state. It does not queue QAQC and it does not sync MyteCommandCenter/data/qaqc.yml",
-    "  - Use mission archive/restore for lifecycle archival; do not send Archived through mission status",
+    "  - Status updates refresh bootstrap + mission-ops locally by default after success unless --no-sync is set",
+    "  - Use mission archive for lifecycle archival; do not send Archived through mission status",
     "",
-    "mission archive/restore contract:",
-    "  - Archive calls /api/project-assistant/mission-archive and restore calls /api/project-assistant/mission-restore",
-    "  - Both require Project Owner or elevated owner_delegate authority on the authenticated project key",
-    "  - Archive hides cards from normal bootstrap/board state; restore brings them back to Todo by default",
-    "  - Missions are recoverable. The project-key surface does not hard-delete mission cards",
+    "mission archive contract:",
+    "  - Archive calls /api/project-assistant/mission-archive",
+    "  - Project Owner or elevated owner_delegate authority is required on the authenticated project key",
+    "  - Archive hides cards from normal bootstrap/board state and keeps the mission record immutable",
+    "  - Archive refreshes bootstrap + mission-ops locally by default after success unless --no-sync is set",
+    "  - Restore is intentionally web-only from the archived missions board",
+    "  - The project-key surface does not hard-delete mission cards",
     "",
     "create-prd contract:",
     "  - Required: valid MYTE_API_KEY, PRD markdown body, title",
@@ -372,13 +375,13 @@ function printHelp() {
     "  --review-note <text>  Review note stored in feedback refinement history",
     "  --with-prd-text       Include extracted PRD text so local PRD files are materialized during feedback-sync (default: on)",
     "  --no-with-prd-text    Skip PRD text download and write only feedback metadata/comment turns",
-    "  --mission-ids <ids>   Comma-separated mission business ids for run-qaqc or mission status (quote multi-id values on PowerShell)",
-    "  --reason <text>       Optional reason for governed mission archive/restore or feedback changes",
+    "  --mission-ids <ids>   Comma-separated mission business ids for run-qaqc, mission status, or mission archive (quote multi-id values on PowerShell)",
+    "  --reason <text>       Optional reason for governed mission archive or feedback changes",
     "  --actor-scope <id>    Actor workspace key inside mission-ops.yml (defaults to machine-cwd slug)",
     "  --wait                Poll batch status until terminal completion for run-qaqc",
     "  --sync                After run-qaqc completes, refresh local QAQC file",
     "  --force               Allow run-qaqc to bypass stale-state protection when supported",
-    "  --no-sync             Skip automatic mission-ops resync after suggestions create/revise/review",
+    "  --no-sync             Skip automatic post-mutation sync for suggestions or mission status/archive",
     "  --print-context       Print JSON payload and exit (no query call)",
     "  --no-fetch            Don't git fetch origin main/master before diff",
     "",
@@ -394,7 +397,6 @@ function printHelp() {
     "  myte run-qaqc --mission-ids \"M001,M002\" --wait --sync",
     "  myte mission status --mission-ids \"M001,M002\" --status done",
     "  myte mission archive --mission-ids \"M001\" --reason \"Duplicate disposable test mission\"",
-    "  myte mission restore --mission-ids \"M001\" --status todo",
     "  myte bootstrap --output-dir ./MyteCommandCenter",
     "  myte sync-qaqc",
     "  myte update-team \"Backend deploy completed; QAQC rerun queued.\"",
@@ -2412,6 +2414,18 @@ async function runMissionStatus(args) {
     process.exit(1);
   }
 
+  const shouldSync = shouldSyncMissionStateAfterMutation(args);
+  let syncSummary = null;
+  if (shouldSync) {
+    try {
+      syncSummary = await resyncBootstrapAfterMissionMutation({ args, apiBase, key, timeoutMs });
+    } catch (err) {
+      console.error("Mission status update succeeded, but bootstrap sync failed:", err?.message || err);
+      console.error("Run `myte bootstrap` to refresh local Command Center state.");
+      process.exit(1);
+    }
+  }
+
   const output = {
     project_id: data.project_id || null,
     requested_count: data.requested_count || missionIds.length,
@@ -2421,6 +2435,7 @@ async function runMissionStatus(args) {
     rejected_count: data.rejected_count || 0,
     new_status: data.new_status || newStatus,
     missions: Array.isArray(data.missions) ? data.missions : [],
+    sync: syncSummary,
   };
 
   if (args.json) {
@@ -2443,11 +2458,14 @@ async function runMissionStatus(args) {
     if (mission?.new_status) detailParts.push(`target=${mission.new_status}`);
     console.log(`- ${missionId}: ${status}${detailParts.length ? ` (${detailParts.join(", ")})` : ""}`);
   }
+  if (syncSummary?.output_root) {
+    console.log(`Synced Command Center: ${syncSummary.output_root}`);
+  }
 }
 
-async function runMissionArchiveCommand(args, { restore = false } = {}) {
+async function runMissionArchiveCommand(args) {
   const key = getProjectApiKey();
-  const commandLabel = restore ? "mission restore" : "mission archive";
+  const commandLabel = "mission archive";
   if (!key) {
     console.error("Missing MYTE_API_KEY (project key) in environment/.env");
     process.exit(1);
@@ -2463,21 +2481,12 @@ async function runMissionArchiveCommand(args, { restore = false } = {}) {
   const payload = {
     mission_ids: missionIds,
   };
-  if (restore) {
-    const restoreStatus = normalizeMissionStatusInput(firstNonEmptyString(args.status, args["restore-status"], args.restoreStatus, args.restore_status) || "todo");
-    if (!restoreStatus) {
-      console.error("Missing or invalid --status for `myte mission restore`. Use todo, in_progress, or done.");
-      printHelp();
-      process.exit(1);
-    }
-    payload.restore_status = restoreStatus;
-  }
   const reason = firstNonEmptyString(args.reason);
   if (reason) payload.reason = reason;
   const clientSessionId = firstNonEmptyString(args["client-session-id"], args.clientSessionId, args.client_session_id);
   if (clientSessionId) payload.client_session_id = clientSessionId;
 
-  const operation = restore ? "mission-restore" : "mission-archive";
+  const operation = "mission-archive";
   const idempotencyKey = resolveProjectMutationIdempotencyKey({
     args,
     operation,
@@ -2491,7 +2500,7 @@ async function runMissionArchiveCommand(args, { restore = false } = {}) {
 
   const timeoutMs = resolveTimeoutMs(args);
   const apiBase = resolveApiBase(args);
-  const endpoint = restore ? "/project-assistant/mission-restore" : "/project-assistant/mission-archive";
+  const endpoint = "/project-assistant/mission-archive";
 
   let data;
   try {
@@ -2508,11 +2517,23 @@ async function runMissionArchiveCommand(args, { restore = false } = {}) {
     if (err?.name === "AbortError") {
       console.error(`Request timed out after ${timeoutMs}ms`);
     } else {
-      console.error(`Mission ${restore ? "restore" : "archive"} failed:`, err?.message || err);
+      console.error("Mission archive failed:", err?.message || err);
     }
     process.exit(1);
   }
 
+  const shouldSync = shouldSyncMissionStateAfterMutation(args);
+  let syncSummary = null;
+  if (shouldSync) {
+    try {
+      syncSummary = await resyncBootstrapAfterMissionMutation({ args, apiBase, key, timeoutMs });
+    } catch (err) {
+      console.error("Mission archive succeeded, but bootstrap sync failed:", err?.message || err);
+      console.error("Run `myte bootstrap` to refresh local Command Center state.");
+      process.exit(1);
+    }
+  }
+
   const output = {
     project_id: data.project_id || null,
     requested_count: data.requested_count || missionIds.length,
@@ -2520,9 +2541,10 @@ async function runMissionArchiveCommand(args, { restore = false } = {}) {
     updated_count: data.updated_count || 0,
     unchanged_count: data.unchanged_count || 0,
     rejected_count: data.rejected_count || 0,
-    archive_state: data.archive_state || (restore ? "active" : "archived"),
-    new_status: data.new_status || (restore ? "Todo" : "Archived"),
+    archive_state: data.archive_state || "archived",
+    new_status: data.new_status || "Archived",
     missions: Array.isArray(data.missions) ? data.missions : [],
+    sync: syncSummary,
   };
 
   if (args.json) {
@@ -2546,6 +2568,9 @@ async function runMissionArchiveCommand(args, { restore = false } = {}) {
     if (mission?.new_status) detailParts.push(`target=${mission.new_status}`);
     console.log(`- ${missionId}: ${status}${detailParts.length ? ` (${detailParts.join(", ")})` : ""}`);
   }
+  if (syncSummary?.output_root) {
+    console.log(`Synced Command Center: ${syncSummary.output_root}`);
+  }
 }
 
 function formatTargetContacts(contacts) {
@@ -3653,6 +3678,11 @@ function shouldSyncSuggestionsAfterMutation(args) {
   return !rawArgs.includes("--no-sync");
 }
 
+function shouldSyncMissionStateAfterMutation(args) {
+  const rawArgs = Array.isArray(args?.__raw) ? args.__raw : [];
+  return !rawArgs.includes("--no-sync");
+}
+
 function resolveBooleanFlag(args, dashedName, defaultValue) {
   const rawArgs = Array.isArray(args?.__raw) ? args.__raw : [];
   const enabledToken = `--${dashedName}`;
@@ -5640,6 +5670,42 @@ async function resyncMissionOpsAfterMutation({ apiBase, key, timeoutMs, actorSco
   };
 }
 
+async function resyncBootstrapAfterMissionMutation({ args, apiBase, key, timeoutMs }) {
+  const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
+  const existingPaths = resolveMissionOpsPaths(args, { requireExisting: false });
+  const existingPayload = existingPaths && fs.existsSync(existingPaths.missionOpsPath)
+    ? (readYamlFile(existingPaths.missionOpsPath) || {})
+    : {};
+  const actorScope = resolveActorScope(args, existingPayload);
+  const snapshot = await fetchBootstrapSnapshot({ apiBase, key, timeoutMs });
+  const resolved = resolvePortableWorkspace(snapshot.repo_names || []);
+  const wrapperRoot = !outputDir && existingPaths?.wrapperRoot ? existingPaths.wrapperRoot : resolved.root;
+  const writeResult = writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir });
+  const missionOpsSnapshot = await fetchSuggestionsSyncSnapshot({ apiBase, key, timeoutMs, actorScope });
+  const missionOpsWrite = writeMissionOpsSnapshot({ snapshot: missionOpsSnapshot, wrapperRoot, outputDir });
+  const missionOpsCounts = missionOpsWrite?.manifest?.sync?.counts || {};
+  const outputRoot = outputDir ? path.resolve(process.cwd(), String(outputDir)) : path.join(wrapperRoot, "MyteCommandCenter");
+  return {
+    wrapper_root: wrapperRoot,
+    output_root: outputRoot,
+    data_root: writeResult.dataRoot,
+    snapshot_hash: snapshot.snapshot_hash || null,
+    counts: {
+      phases: Array.isArray(snapshot.phases) ? snapshot.phases.length : 0,
+      epics: Array.isArray(snapshot.epics) ? snapshot.epics.length : 0,
+      stories: Array.isArray(snapshot.stories) ? snapshot.stories.length : 0,
+      missions: Array.isArray(snapshot.missions) ? snapshot.missions.length : 0,
+    },
+    mission_ops: {
+      actor_scope: missionOpsWrite?.manifest?.sync?.actor_scope || actorScope,
+      total_threads: Number(missionOpsCounts.total_threads || 0),
+      actionable_threads: Number(missionOpsCounts.actionable_threads || 0),
+      snapshot_hash: missionOpsWrite?.manifest?.snapshot_hash || null,
+      data_root: missionOpsWrite?.dataRoot || writeResult.dataRoot,
+    },
+  };
+}
+
 async function runSuggestionsCreate(args) {
   let context;
   try {
@@ -6207,7 +6273,7 @@ async function main() {
     process.exit(1);
   }
   if (command === "mission") {
-    console.error("Unknown mission command. Use `myte mission status`, `myte mission archive`, or `myte mission restore`.");
+    console.error("Unknown mission command. Use `myte mission status` or `myte mission archive`.");
     process.exit(1);
   }
   const args = parseArgs(rest);
@@ -6242,12 +6308,7 @@ async function main() {
   }
 
   if (command === "mission-archive") {
-    await runMissionArchiveCommand(args, { restore: false });
-    return;
-  }
-
-  if (command === "mission-restore") {
-    await runMissionArchiveCommand(args, { restore: true });
+    await runMissionArchiveCommand(args);
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",
@@ -8,6 +8,7 @@
     "README.md",
     "cli.js",
     "lib",
+    "scripts",
     "package.json"
   ],
   "scripts": {

package/scripts/mission-live-disposable-harness.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const CLI_PATH = path.resolve(__dirname, "..", "cli.js");
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      args._.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    index += 1;
+  }
+  return args;
+}
+
+function requireConfirm(args) {
+  if (!args["confirm-live"]) {
+    throw new Error("Refusing to run live mission mutations. Re-run with --confirm-live after backend/frontend deploy.");
+  }
+  if (!process.env.MYTE_API_KEY && !process.env.MYTE_PROJECT_API_KEY) {
+    throw new Error("Missing MYTE_API_KEY or MYTE_PROJECT_API_KEY.");
+  }
+}
+
+function runCli(cliArgs, cwd, envPatch = {}) {
+  const result = spawnSync(process.execPath, [CLI_PATH, ...cliArgs], {
+    cwd,
+    env: { ...process.env, ...envPatch },
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) {
+    throw new Error([
+      `Command failed: myte ${cliArgs.join(" ")}`,
+      result.stderr || result.stdout || "(no output)",
+    ].join("\n"));
+  }
+  const stdout = String(result.stdout || "").trim();
+  if (!stdout) return {};
+  try {
+    return JSON.parse(stdout);
+  } catch (err) {
+    throw new Error(`Expected JSON from myte ${cliArgs.join(" ")}:\n${stdout}`);
+  }
+}
+
+function writeJson(workspace, name, payload) {
+  const filePath = path.join(workspace, name);
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+  return filePath;
+}
+
+function collectMissionFileText(workspace) {
+  const missionsDir = path.join(workspace, "MyteCommandCenter", "data", "missions");
+  if (!fs.existsSync(missionsDir)) return "";
+  return fs.readdirSync(missionsDir)
+    .filter((name) => name.endsWith(".yml") || name.endsWith(".yaml") || name.endsWith(".json"))
+    .map((name) => fs.readFileSync(path.join(missionsDir, name), "utf8"))
+    .join("\n");
+}
+
+function assertMissionPresence(workspace, missionId, expectedPresent, label) {
+  const text = collectMissionFileText(workspace);
+  const present = text.includes(`mission_id: ${missionId}`) || text.includes(`"mission_id": "${missionId}"`);
+  if (present !== expectedPresent) {
+    throw new Error(`${label}: expected mission ${missionId} ${expectedPresent ? "in" : "absent from"} bootstrap mission state.`);
+  }
+}
+
+function pickSuggestionId(createOutput) {
+  for (const item of createOutput.items || []) {
+    const suggestionId = item?.suggestion?.suggestion_id || item?.suggestion_id;
+    if (suggestionId) return String(suggestionId);
+  }
+  return "";
+}
+
+function pickAppliedMissionId(reviewOutput) {
+  for (const item of reviewOutput.items || []) {
+    const missionId = item?.applied_mission?.mission_id || item?.mission_id || item?.suggestion?.mission_id;
+    if (missionId) return String(missionId);
+  }
+  return "";
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  requireConfirm(args);
+
+  const workspace = path.resolve(
+    args.workspace || fs.mkdtempSync(path.join(os.tmpdir(), "myte-live-mission-harness-")),
+  );
+  fs.mkdirSync(workspace, { recursive: true });
+
+  const actorScope = String(args["actor-scope"] || `live-disposable-harness-${Date.now()}`);
+  const baseArgs = [];
+  if (args["base-url"]) {
+    baseArgs.push("--base-url", String(args["base-url"]));
+  }
+
+  const title = String(args.title || `Disposable mission harness ${new Date().toISOString()}`);
+  const description = String(args.description || "Disposable mission used to verify Myte mission create, approve, archive, and cleanup flows.");
+  const reason = String(args.reason || "Disposable live mission harness verification");
+
+  console.log(`Workspace: ${workspace}`);
+  console.log(`Actor scope: ${actorScope}`);
+
+  runCli(["bootstrap", "--json", "--actor-scope", actorScope, ...baseArgs], workspace);
+
+  const createFile = writeJson(workspace, "mission-create.json", {
+    items: [
+      {
+        change_type: "create",
+        change_description: "Create disposable mission for live harness verification",
+        change_set: {
+          title,
+          description,
+          acceptance_criteria: [
+            "Mission can be approved from the suggestion review loop.",
+            "Mission can be archived without hard delete.",
+            "Archived missions disappear from normal bootstrap state.",
+          ],
+          labels: ["harness", "disposable"],
+        },
+      },
+    ],
+  });
+  const createOutput = runCli([
+    "suggestions",
+    "create",
+    "--file",
+    createFile,
+    "--actor-scope",
+    actorScope,
+    "--no-sync",
+    "--json",
+    ...baseArgs,
+  ], workspace);
+  const suggestionId = pickSuggestionId(createOutput);
+  if (!suggestionId) {
+    throw new Error(`Suggestion create did not return a suggestion id: ${JSON.stringify(createOutput, null, 2)}`);
+  }
+
+  const reviewFile = writeJson(workspace, "mission-review.json", {
+    items: [
+      {
+        suggestion_id: suggestionId,
+        action: "approve",
+        review_action: "approve",
+        final_change_set: {
+          title,
+          description,
+          acceptance_criteria: [
+            "Mission can be approved from the suggestion review loop.",
+            "Mission can be archived without hard delete.",
+            "Archived missions disappear from normal bootstrap state.",
+          ],
+          labels: ["harness", "disposable"],
+        },
+      },
+    ],
+  });
+  const reviewOutput = runCli([
+    "suggestions",
+    "review",
+    "--file",
+    reviewFile,
+    "--actor-scope",
+    actorScope,
+    "--no-sync",
+    "--json",
+    ...baseArgs,
+  ], workspace);
+  const missionId = pickAppliedMissionId(reviewOutput);
+  if (!missionId) {
+    throw new Error(`Suggestion approval did not return an applied mission id: ${JSON.stringify(reviewOutput, null, 2)}`);
+  }
+
+  const archiveOutput = runCli([
+    "mission",
+    "archive",
+    "--mission-ids",
+    missionId,
+    "--reason",
+    reason,
+    "--json",
+    ...baseArgs,
+  ], workspace);
+  if (!Number(archiveOutput.updated_count || 0) && !Number(archiveOutput.unchanged_count || 0)) {
+    throw new Error(`Archive did not update or confirm mission state: ${JSON.stringify(archiveOutput, null, 2)}`);
+  }
+  runCli(["bootstrap", "--json", "--actor-scope", actorScope, ...baseArgs], workspace);
+  assertMissionPresence(workspace, missionId, false, "Archived bootstrap check");
+
+  const finalState = "archived";
+
+  console.log(JSON.stringify({
+    status: "success",
+    workspace,
+    suggestion_id: suggestionId,
+    mission_id: missionId,
+    final_state: finalState,
+  }, null, 2));
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(err?.message || err);
+  process.exit(1);
+}

package/scripts/mission-live-full-harness.js

@@ -0,0 +1,824 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const CLI_PATH = path.resolve(__dirname, "..", "cli.js");
+const DEFAULT_BASE_URL = "https://api.myte.dev/api";
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) {
+      args._.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    index += 1;
+  }
+  return args;
+}
+
+function loadEnvFromNearest(startDir) {
+  let cur = startDir;
+  for (let index = 0; index < 8; index += 1) {
+    const filePath = path.join(cur, ".env");
+    if (fs.existsSync(filePath)) {
+      for (const line of fs.readFileSync(filePath, "utf8").split(/\r?\n/)) {
+        const trimmed = String(line || "").trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const splitAt = trimmed.indexOf("=");
+        if (splitAt <= 0) continue;
+        const key = trimmed.slice(0, splitAt).trim();
+        let value = trimmed.slice(splitAt + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+        if (key && process.env[key] === undefined) process.env[key] = value;
+      }
+      return filePath;
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+
+function nowId() {
+  return new Date().toISOString().replace(/[^0-9A-Za-z]+/g, "-").replace(/^-|-$/g, "");
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function writeJson(dirPath, name, payload) {
+  ensureDir(dirPath);
+  const filePath = path.join(dirPath, name);
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+  return filePath;
+}
+
+function normalizeBaseUrl(value) {
+  const raw = String(value || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  return raw.endsWith("/api") ? raw : `${raw}/api`;
+}
+
+function getProjectKey() {
+  return process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "";
+}
+
+function stableScenarioList(raw, confirmLive) {
+  if (raw) {
+    return String(raw)
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+  if (!confirmLive) return ["preflight", "contracts"];
+  return [
+    "preflight",
+    "contracts",
+    "suggestion_update_loop",
+    "create_reject_loop",
+    "archive_route_probe",
+    "approved_lifecycle",
+    "batch_limits",
+    "batch_mutation",
+    "qaqc",
+  ];
+}
+
+function cliInvocation(args, cliMode, packageVersion) {
+  if (cliMode === "global") return { command: "myte", args };
+  if (cliMode === "npx") return { command: "npx", args: ["--yes", `myte@${packageVersion}`, ...args] };
+  return { command: process.execPath, args: [CLI_PATH, ...args] };
+}
+
+function commandText(invocation) {
+  return [invocation.command, ...invocation.args].join(" ");
+}
+
+function runCli(cliArgs, options = {}) {
+  const {
+    workspace,
+    baseUrl,
+    actorScope,
+    expectFailure = false,
+    parseJson = true,
+    cliMode = "local",
+    packageVersion = "latest",
+    timeoutMs = 120000,
+  } = options;
+  const finalArgs = [...cliArgs];
+  if (actorScope) finalArgs.push("--actor-scope", actorScope);
+  if (baseUrl) finalArgs.push("--base-url", baseUrl);
+  const invocation = cliInvocation(finalArgs, cliMode, packageVersion);
+  const result = spawnSync(invocation.command, invocation.args, {
+    cwd: workspace || process.cwd(),
+    env: process.env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs,
+  });
+  const stdout = String(result.stdout || "").trim();
+  const stderr = String(result.stderr || "").trim();
+  const ok = result.status === 0;
+  if (expectFailure) {
+    if (ok) {
+      throw new Error(`Expected command to fail but it succeeded: ${commandText(invocation)}`);
+    }
+    return { ok: false, status: result.status, stdout, stderr };
+  }
+  if (!ok) {
+    throw new Error([`Command failed: ${commandText(invocation)}`, stderr || stdout || "(no output)"].join("\n"));
+  }
+  if (!parseJson) return { ok: true, stdout, stderr };
+  try {
+    return stdout ? JSON.parse(stdout) : {};
+  } catch (error) {
+    throw new Error(`Expected JSON from ${commandText(invocation)}:\n${stdout}`);
+  }
+}
+
+async function apiJson({ method = "GET", baseUrl, route, key, body, query, idempotencyKey }) {
+  const url = new URL(`${baseUrl}${route}`);
+  for (const [queryKey, queryValue] of Object.entries(query || {})) {
+    if (queryValue !== undefined && queryValue !== null && String(queryValue).trim() !== "") {
+      url.searchParams.set(queryKey, String(queryValue));
+    }
+  }
+  const headers = { Authorization: `Bearer ${key}` };
+  if (body !== undefined) headers["Content-Type"] = "application/json";
+  if (idempotencyKey) headers["X-Idempotency-Key"] = String(idempotencyKey);
+  const response = await fetch(url.toString(), {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  let payload = {};
+  try {
+    payload = await response.json();
+  } catch (_) {
+    payload = {};
+  }
+  return {
+    ok: response.ok && payload.status === "success",
+    statusCode: response.status,
+    message: payload.message || "",
+    data: payload.data || {},
+  };
+}
+
+function missionPublicId(mission) {
+  return String(mission?.mission_id || mission?.public_id || mission?.id || "").trim();
+}
+
+function missionTitle(mission) {
+  return String(mission?.title || "").trim();
+}
+
+function activeMissions(bootstrap) {
+  return (Array.isArray(bootstrap?.missions) ? bootstrap.missions : [])
+    .filter((mission) => missionPublicId(mission))
+    .filter((mission) => String(mission.status || "").toLowerCase() !== "archived")
+    .filter((mission) => mission.is_archived !== true);
+}
+
+function chooseStableMission(bootstrap) {
+  const missions = activeMissions(bootstrap);
+  return missions.find((mission) => !/^Disposable mission harness/i.test(missionTitle(mission))) || missions[0] || null;
+}
+
+function hasRunnableQaqcCases(mission) {
+  if (String(mission?.status || "").toLowerCase() === "done") return false;
+  const testCases = mission?.test_cases || {};
+  const success = Array.isArray(testCases.success) ? testCases.success : [];
+  const failure = Array.isArray(testCases.failure) ? testCases.failure : [];
+  return success.length > 0 || failure.length > 0;
+}
+
+function chooseQaqcMission(bootstrap) {
+  const missions = activeMissions(bootstrap).filter(hasRunnableQaqcCases);
+  return missions.find((mission) => !/^Disposable mission harness/i.test(missionTitle(mission))) || missions[0] || null;
+}
+
+function pickSuggestionId(output) {
+  for (const item of output.items || []) {
+    const suggestionId = item?.suggestion?.suggestion_id || item?.suggestion_id;
+    if (suggestionId) return String(suggestionId);
+  }
+  return "";
+}
+
+function pickAppliedMissionId(output) {
+  for (const item of output.items || []) {
+    const missionId = item?.applied_mission?.mission_id || item?.mission_id || item?.suggestion?.mission_id;
+    if (missionId) return String(missionId);
+  }
+  return "";
+}
+
+function threadRefs(snapshot) {
+  const refs = [];
+  for (const source of [snapshot?.queue, snapshot?.threads, snapshot?.suggestions]) {
+    if (!Array.isArray(source)) continue;
+    for (const item of source) {
+      refs.push({
+        suggestion_id: String(item?.suggestion_id || item?.id || "").trim(),
+        mission_id: String(item?.mission_id || "").trim(),
+        change_type: String(item?.change_type || "").trim(),
+        status: String(item?.status || item?.thread_status || "").trim(),
+      });
+    }
+  }
+  return refs.filter((item) => item.suggestion_id || item.mission_id);
+}
+
+function queueRefs(snapshot) {
+  return threadRefs({ queue: snapshot?.queue || [] });
+}
+
+function hasMissionInBootstrap(bootstrap, missionId) {
+  const target = String(missionId || "").toUpperCase();
+  return activeMissions(bootstrap).some((mission) => missionPublicId(mission).toUpperCase() === target);
+}
+
+function assertCondition(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function safeResult(details = {}) {
+  return JSON.parse(JSON.stringify(details, (_key, value) => {
+    if (typeof value !== "string") return value;
+    if (value.includes("@")) return "[redacted]";
+    return value.length > 180 ? `${value.slice(0, 180)}...` : value;
+  }));
+}
+
+class Harness {
+  constructor(args) {
+    loadEnvFromNearest(process.cwd());
+    this.args = args;
+    this.confirmLive = args["confirm-live"] === true;
+    this.keepGoing = args["keep-going"] === true;
+    this.baseUrl = normalizeBaseUrl(args["base-url"] || process.env.MYTE_API_BASE_URL || DEFAULT_BASE_URL);
+    this.key = getProjectKey();
+    this.actorBase = String(args["actor-scope"] || `mission-live-full-${nowId()}`);
+    this.cliMode = String(args.cli || "local").toLowerCase();
+    this.packageVersion = String(args["package-version"] || "0.0.27");
+    this.batchSize = Math.max(1, Math.min(10, Number(args["batch-size"] || 10)));
+    this.includeQaqcRun = args["include-qaqc-run"] === true;
+    this.workspace = path.resolve(
+      args.workspace || fs.mkdtempSync(path.join(os.tmpdir(), "myte-mission-full-harness-")),
+    );
+    this.payloadDir = path.join(this.workspace, "payloads");
+    this.reportPath = path.resolve(args["report-file"] || path.join(this.workspace, "mission-live-full-report.json"));
+    this.scenarios = stableScenarioList(args.scenarios, this.confirmLive);
+    this.createdMissions = new Set();
+    this.openSuggestions = new Set();
+    this.archiveRouteAvailable = null;
+    this.report = {
+      status: "running",
+      generated_at: new Date().toISOString(),
+      base_url: this.baseUrl,
+      cli_mode: this.cliMode,
+      package_version: this.packageVersion,
+      workspace: this.workspace,
+      scenarios: [],
+      created_mission_ids: [],
+      open_suggestion_ids: [],
+      notes: [],
+    };
+  }
+
+  requireKey() {
+    if (!this.key) throw new Error("Missing MYTE_API_KEY or MYTE_PROJECT_API_KEY.");
+  }
+
+  requireLive(name) {
+    if (!this.confirmLive) {
+      throw new Error(`${name} requires --confirm-live because it mutates live project data.`);
+    }
+  }
+
+  cli(args, options = {}) {
+    return runCli(args, {
+      workspace: this.workspace,
+      baseUrl: this.baseUrl,
+      cliMode: this.cliMode,
+      packageVersion: this.packageVersion,
+      ...options,
+    });
+  }
+
+  cliWithActor(args, suffix, options = {}) {
+    return this.cli(args, {
+      actorScope: `${this.actorBase}-${suffix}`,
+      ...options,
+    });
+  }
+
+  async api(route, options = {}) {
+    return apiJson({
+      baseUrl: this.baseUrl,
+      key: this.key,
+      route,
+      ...options,
+    });
+  }
+
+  async bootstrap() {
+    const response = await this.api("/project-assistant/bootstrap");
+    if (!response.ok) throw new Error(`Bootstrap API failed (${response.statusCode}): ${response.message}`);
+    return response.data;
+  }
+
+  async suggestions(actorScope) {
+    const response = await this.api("/project-assistant/suggestions", {
+      query: actorScope ? { actor_scope: actorScope } : {},
+    });
+    if (!response.ok) throw new Error(`Suggestions API failed (${response.statusCode}): ${response.message}`);
+    return response.data;
+  }
+
+  async probeArchiveRoute() {
+    const response = await this.api("/project-assistant/mission-archive", {
+      method: "POST",
+      idempotencyKey: `mission-live-full-route-probe-${nowId()}`,
+      body: {
+        mission_ids: ["__NOT_A_REAL_MISSION__"],
+        reason: "mission live full harness route probe",
+      },
+    });
+    this.archiveRouteAvailable = response.statusCode === 200;
+    if (!this.archiveRouteAvailable) {
+      throw new Error(`Archive route is not live (${response.statusCode}): ${response.message || "no message"}`);
+    }
+    return {
+      status_code: response.statusCode,
+      rejected_count: response.data?.rejected_count,
+      updated_count: response.data?.updated_count,
+    };
+  }
+
+  async scenarioPreflight() {
+    this.requireKey();
+    const config = this.cli(["config", "--json"]);
+    const bootstrap = this.cli(["bootstrap", "--json"]);
+    const sync = this.cliWithActor(["suggestions", "sync", "--json"], "preflight");
+    return {
+      project_id: config.project_id || bootstrap.project_id || null,
+      repo_count: Array.isArray(config.repo_names) ? config.repo_names.length : 0,
+      active_mission_count: bootstrap.counts?.missions || 0,
+      suggestion_threads: sync.thread_count || 0,
+      actionable_threads: sync.actionable_count || 0,
+    };
+  }
+
+  async scenarioContracts() {
+    const invalidCreate = writeJson(this.payloadDir, "invalid-create-change-type.json", {
+      items: [{ change_type: "add-mission", change_description: "invalid", change_set: { title: "Invalid" } }],
+    });
+    const invalidRevise = writeJson(this.payloadDir, "invalid-revise-change-type.json", {
+      items: [{ suggestion_id: "000000000000000000000000", change_type: "create", change_set: { title: "Invalid" } }],
+    });
+    const badMissionIds = Array.from({ length: 101 }, (_, index) => `ZZ${String(index).padStart(3, "0")}`).join(",");
+    const tooManyQaqcIds = Array.from({ length: 11 }, (_, index) => `ZZ${String(index).padStart(3, "0")}`).join(",");
+
+    const checks = [];
+    checks.push(this.cli(["suggestions", "create", "--file", invalidCreate, "--json"], { expectFailure: true, parseJson: false }));
+    checks.push(this.cli(["suggestions", "revise", "--file", invalidRevise, "--json"], { expectFailure: true, parseJson: false }));
+    checks.push(this.cli(["mission", "status", "--mission-ids", "M001", "--status", "archived", "--json"], { expectFailure: true, parseJson: false }));
+    checks.push(this.cli(["mission", "restore", "--mission-ids", "M001", "--status", "todo", "--json"], { expectFailure: true, parseJson: false }));
+    checks.push(this.cli(["mission", "delete", "--mission-ids", "M001", "--json"], { expectFailure: true, parseJson: false }));
+    checks.push(this.cli(["mission", "archive", "--mission-ids", "M001", "--reason", "dry run", "--dry-run", "--json"]));
+    checks.push(this.cli(["mission", "status", "--mission-ids", badMissionIds, "--status", "todo", "--json"], { expectFailure: true, parseJson: false, timeoutMs: 180000 }));
+    checks.push(this.cli(["run-qaqc", "--mission-ids", tooManyQaqcIds, "--json"], { expectFailure: true, parseJson: false, timeoutMs: 180000 }));
+    return { checks: checks.length };
+  }
+
+  async scenarioSuggestionUpdateLoop() {
+    this.requireLive("suggestion_update_loop");
+    const actor = `${this.actorBase}-update-loop`;
+    const bootstrap = await this.bootstrap();
+    const mission = chooseStableMission(bootstrap);
+    assertCondition(mission, "No active mission available for update suggestion loop.");
+    const missionId = missionPublicId(mission);
+
+    const createOne = writeJson(this.payloadDir, "update-loop-create-1.json", {
+      items: [{
+        change_type: "update",
+        mission_id: missionId,
+        change_description: "Harness proposed non-applied update",
+        change_set: { description: "Harness proposed description. This should be rejected during cleanup." },
+      }],
+    });
+    const first = this.cli(["suggestions", "create", "--file", createOne, "--no-sync", "--json"], { actorScope: actor });
+    const suggestionId = pickSuggestionId(first);
+    assertCondition(suggestionId, "Update suggestion create did not return suggestion_id.");
+    this.openSuggestions.add(suggestionId);
+
+    const createTwo = writeJson(this.payloadDir, "update-loop-create-2.json", {
+      items: [{
+        change_type: "update",
+        mission_id: missionId,
+        change_description: "Harness append to existing pending update thread",
+        change_set: { acceptance_criteria: ["Harness proposed acceptance criterion. This should be rejected."] },
+      }],
+    });
+    const second = this.cli(["suggestions", "create", "--file", createTwo, "--no-sync", "--json"], { actorScope: actor });
+    const appendedId = pickSuggestionId(second);
+    assertCondition(appendedId === suggestionId, `Expected append to same suggestion ${suggestionId}, got ${appendedId || "(none)"}.`);
+
+    const revise = writeJson(this.payloadDir, "update-loop-revise.json", {
+      items: [{
+        suggestion_id: suggestionId,
+        change_description: "Harness revision after append",
+        change_set: { technical_requirements: ["Harness proposed requirement. This should be rejected."] },
+      }],
+    });
+    const revised = this.cli(["suggestions", "revise", "--file", revise, "--no-sync", "--json"], { actorScope: actor });
+    assertCondition((revised.revised_count || 0) >= 1, "Update suggestion revise did not revise the thread.");
+
+    const requestChanges = writeJson(this.payloadDir, "update-loop-request-changes.json", {
+      items: [{ suggestion_id: suggestionId, action: "request_changes", review_action: "request_changes", review_note: "Harness request changes check." }],
+    });
+    const requested = this.cli(["suggestions", "review", "--file", requestChanges, "--no-sync", "--json"], { actorScope: actor });
+    assertCondition((requested.processed_count || 0) >= 1, "Update suggestion request_changes did not process.");
+
+    const reviseAfterRequest = writeJson(this.payloadDir, "update-loop-revise-after-request.json", {
+      items: [{
+        suggestion_id: suggestionId,
+        change_description: "Harness revision after request_changes",
+        change_set: { labels: ["harness-proposed-update"] },
+      }],
+    });
+    const revisedAgain = this.cli(["suggestions", "revise", "--file", reviseAfterRequest, "--no-sync", "--json"], { actorScope: actor });
+    assertCondition((revisedAgain.revised_count || 0) >= 1, "Update suggestion revise after request_changes did not process.");
+
+    const reject = writeJson(this.payloadDir, "update-loop-reject.json", {
+      items: [{ suggestion_id: suggestionId, action: "reject", review_action: "reject", review_note: "Harness cleanup reject." }],
+    });
+    const rejected = this.cli(["suggestions", "review", "--file", reject, "--json"], { actorScope: actor });
+    assertCondition((rejected.processed_count || 0) >= 1, "Update suggestion reject cleanup did not process.");
+    this.openSuggestions.delete(suggestionId);
+
+    return { mission_id: missionId, suggestion_id: suggestionId, append_verified: true };
+  }
+
+  async scenarioCreateRejectLoop() {
+    this.requireLive("create_reject_loop");
+    const actor = `${this.actorBase}-create-reject`;
+    const title = `Harness rejected mission ${nowId()}`;
+    const before = await this.bootstrap();
+
+    const createFile = writeJson(this.payloadDir, "create-reject-create.json", {
+      items: [{
+        change_type: "create",
+        change_description: "Harness new mission proposal that will be rejected",
+        change_set: {
+          title,
+          description: "Harness proposal that should never become an active mission.",
+          acceptance_criteria: ["The rejected proposal does not create a mission card."],
+          labels: ["harness", "reject-path"],
+        },
+      }],
+    });
+    const created = this.cli(["suggestions", "create", "--file", createFile, "--no-sync", "--json"], { actorScope: actor });
+    const suggestionId = pickSuggestionId(created);
+    assertCondition(suggestionId, "Create suggestion did not return suggestion_id.");
+    this.openSuggestions.add(suggestionId);
+
+    const afterCreate = await this.bootstrap();
+    assertCondition(
+      activeMissions(afterCreate).length === activeMissions(before).length,
+      "New mission proposal created an active mission before approval.",
+    );
+
+    const reviseFile = writeJson(this.payloadDir, "create-reject-revise.json", {
+      items: [{
+        suggestion_id: suggestionId,
+        change_description: "Harness revision for rejected create thread",
+        change_set: { description: "Harness revised proposal. This should still be rejected." },
+      }],
+    });
+    const revised = this.cli(["suggestions", "revise", "--file", reviseFile, "--no-sync", "--json"], { actorScope: actor });
+    assertCondition((revised.revised_count || 0) >= 1, "Create suggestion revise did not process.");
+
+    const requestChanges = writeJson(this.payloadDir, "create-reject-request-changes.json", {
+      items: [{ suggestion_id: suggestionId, action: "request_changes", review_action: "request_changes", review_note: "Harness request changes check." }],
+    });
+    const requested = this.cli(["suggestions", "review", "--file", requestChanges, "--no-sync", "--json"], { actorScope: actor });
+    assertCondition((requested.processed_count || 0) >= 1, "Create suggestion request_changes did not process.");
+
+    const reject = writeJson(this.payloadDir, "create-reject-reject.json", {
+      items: [{ suggestion_id: suggestionId, action: "reject", review_action: "reject", review_note: "Harness cleanup reject." }],
+    });
+    const rejected = this.cli(["suggestions", "review", "--file", reject, "--json"], { actorScope: actor });
+    assertCondition((rejected.processed_count || 0) >= 1, "Create suggestion reject cleanup did not process.");
+    this.openSuggestions.delete(suggestionId);
+
+    const afterReject = await this.bootstrap();
+    assertCondition(
+      activeMissions(afterReject).every((mission) => missionTitle(mission) !== title),
+      "Rejected create suggestion appeared as an active mission.",
+    );
+    return { suggestion_id: suggestionId, active_mission_created: false };
+  }
+
+  async archiveMissions(missionIds, reason) {
+    if (!missionIds.length) return null;
+    return this.cli(["mission", "archive", "--mission-ids", missionIds.join(","), "--reason", reason, "--json"], {
+      timeoutMs: 180000,
+    });
+  }
+
+  async rejectSuggestion(suggestionId, actor, note) {
+    const rejectFile = writeJson(this.payloadDir, `reject-${suggestionId}.json`, {
+      items: [{ suggestion_id: suggestionId, action: "reject", review_action: "reject", review_note: note || "Harness cleanup reject." }],
+    });
+    return this.cli(["suggestions", "review", "--file", rejectFile, "--json"], { actorScope: actor, timeoutMs: 180000 });
+  }
+
+  async createApprovedMission(actor, index = 1) {
+    const title = `Harness approved mission ${nowId()} ${index}`;
+    const description = "Disposable mission created by the reusable live mission harness.";
+    const createFile = writeJson(this.payloadDir, `approved-create-${index}.json`, {
+      items: [{
+        change_type: "create",
+        change_description: "Harness approved disposable mission creation",
+        change_set: {
+          title,
+          description,
+          acceptance_criteria: [
+            "Mission can be created through suggestion approval.",
+            "Mission can be mutated through project-key mission commands.",
+            "Mission can be archived without hard delete.",
+          ],
+          labels: ["harness", "approved-disposable"],
+        },
+      }],
+    });
+    const created = this.cli(["suggestions", "create", "--file", createFile, "--no-sync", "--json"], { actorScope: actor, timeoutMs: 180000 });
+    const suggestionId = pickSuggestionId(created);
+    assertCondition(suggestionId, "Approved mission create did not return suggestion_id.");
+    this.openSuggestions.add(suggestionId);
+    const reviewFile = writeJson(this.payloadDir, `approved-review-${index}.json`, {
+      items: [{
+        suggestion_id: suggestionId,
+        action: "approve",
+        review_action: "approve",
+        final_change_set: {
+          title,
+          description,
+          acceptance_criteria: [
+            "Mission can be created through suggestion approval.",
+            "Mission can be mutated through project-key mission commands.",
+            "Mission can be archived without hard delete.",
+          ],
+          labels: ["harness", "approved-disposable"],
+        },
+      }],
+    });
+    const reviewed = this.cli(["suggestions", "review", "--file", reviewFile, "--json"], { actorScope: actor, timeoutMs: 180000 });
+    const missionId = pickAppliedMissionId(reviewed);
+    assertCondition(missionId, "Approved mission review did not return applied mission id.");
+    this.createdMissions.add(missionId);
+    this.openSuggestions.delete(suggestionId);
+    return { mission_id: missionId, suggestion_id: suggestionId, title };
+  }
+
+  async scenarioApprovedLifecycle() {
+    this.requireLive("approved_lifecycle");
+    if (this.archiveRouteAvailable !== true) await this.probeArchiveRoute();
+    const actor = `${this.actorBase}-approved-lifecycle`;
+    const created = await this.createApprovedMission(actor, 1);
+    let pendingSuggestionId = "";
+    try {
+      const activeAfterCreate = await this.bootstrap();
+      assertCondition(hasMissionInBootstrap(activeAfterCreate, created.mission_id), "Approved mission is missing from active bootstrap state.");
+
+      for (const status of ["in_progress", "done", "todo"]) {
+        const result = this.cli(["mission", "status", "--mission-ids", created.mission_id, "--status", status, "--json"], { timeoutMs: 180000 });
+        assertCondition((result.matched_count || 0) >= 1, `Mission status ${status} did not match the disposable mission.`);
+      }
+      const noop = this.cli(["mission", "status", "--mission-ids", created.mission_id, "--status", "todo", "--json"], { timeoutMs: 180000 });
+      assertCondition((noop.unchanged_count || 0) >= 1 || (noop.matched_count || 0) >= 1, "Idempotent mission status no-op did not report a stable match.");
+
+      const pendingFile = writeJson(this.payloadDir, "approved-lifecycle-pending-update.json", {
+        items: [{
+          change_type: "update",
+          mission_id: created.mission_id,
+          change_description: "Harness pending suggestion across archive",
+          change_set: { description: "Harness pending suggestion should be hidden from actionable queue while archived." },
+        }],
+      });
+      const pending = this.cli(["suggestions", "create", "--file", pendingFile, "--no-sync", "--json"], { actorScope: actor, timeoutMs: 180000 });
+      pendingSuggestionId = pickSuggestionId(pending);
+      assertCondition(pendingSuggestionId, "Pending update suggestion for approved mission was not created.");
+      this.openSuggestions.add(pendingSuggestionId);
+
+      const archived = await this.archiveMissions([created.mission_id], "Harness archive active mission with pending suggestion");
+      assertCondition((archived.updated_count || 0) + (archived.unchanged_count || 0) >= 1, "Archive did not update or confirm the disposable mission.");
+
+      const afterArchive = await this.bootstrap();
+      assertCondition(!hasMissionInBootstrap(afterArchive, created.mission_id), "Archived mission is still present in active bootstrap state.");
+      const archivedSuggestions = await this.suggestions(actor);
+      const archivedQueueRefs = queueRefs(archivedSuggestions).filter((item) => item.mission_id.toUpperCase() === created.mission_id.toUpperCase());
+      assertCondition(archivedQueueRefs.length === 0, "Archived mission still appears in actionable suggestion queue.");
+      const archivedThreadRefs = threadRefs(archivedSuggestions).filter((item) => item.suggestion_id === pendingSuggestionId);
+      assertCondition(archivedThreadRefs.length >= 1, "Archived mission pending suggestion was not preserved in thread history.");
+
+      await this.rejectSuggestion(pendingSuggestionId, actor, "Harness cleanup reject after archived-thread preservation check.");
+      this.openSuggestions.delete(pendingSuggestionId);
+      return {
+        mission_id: created.mission_id,
+        create_suggestion_id: created.suggestion_id,
+        pending_suggestion_id: pendingSuggestionId,
+        archive_hides_active: true,
+        archive_preserves_thread_history: true,
+      };
+    } catch (error) {
+      if (pendingSuggestionId) {
+        try {
+          await this.rejectSuggestion(pendingSuggestionId, actor, "Harness failure cleanup reject.");
+          this.openSuggestions.delete(pendingSuggestionId);
+        } catch (_) {}
+      }
+      try {
+        await this.archiveMissions([created.mission_id], "Harness failure cleanup archive.");
+      } catch (_) {}
+      throw error;
+    }
+  }
+
+  async scenarioBatchLimits() {
+    const statusIds = Array.from({ length: 101 }, (_, index) => `ZZ${String(index).padStart(3, "0")}`).join(",");
+    const qaqcIds = Array.from({ length: 11 }, (_, index) => `ZZ${String(index).padStart(3, "0")}`).join(",");
+    const archiveProbe = await this.api("/project-assistant/mission-archive", {
+      method: "POST",
+      idempotencyKey: `mission-live-full-archive-limit-${nowId()}`,
+      body: {
+        mission_ids: Array.from({ length: 101 }, (_, index) => `ZZ${String(index).padStart(3, "0")}`),
+        reason: "Harness limit check",
+      },
+    });
+    const checks = [
+      this.cli(["mission", "status", "--mission-ids", statusIds, "--status", "todo", "--json"], { expectFailure: true, parseJson: false, timeoutMs: 180000 }),
+      this.cli(["run-qaqc", "--mission-ids", qaqcIds, "--json"], { expectFailure: true, parseJson: false, timeoutMs: 180000 }),
+    ];
+    assertCondition(
+      archiveProbe.statusCode === 400 || archiveProbe.statusCode === 404,
+      `Expected archive limit check to return 400 when route is live or 404 when route is absent, got ${archiveProbe.statusCode}.`,
+    );
+    return {
+      checks: checks.length + 1,
+      mission_status_limit: 100,
+      run_qaqc_limit: 10,
+      archive_limit: archiveProbe.statusCode === 400 ? 100 : "route_not_live",
+    };
+  }
+
+  async scenarioBatchMutation() {
+    this.requireLive("batch_mutation");
+    if (this.archiveRouteAvailable !== true) await this.probeArchiveRoute();
+    const actor = `${this.actorBase}-batch`;
+    const created = [];
+    try {
+      for (let index = 1; index <= this.batchSize; index += 1) {
+        created.push(await this.createApprovedMission(actor, index));
+      }
+      const missionIds = created.map((item) => item.mission_id);
+      for (const status of ["in_progress", "done", "todo"]) {
+        const result = this.cli(["mission", "status", "--mission-ids", missionIds.join(","), "--status", status, "--json"], { timeoutMs: 240000 });
+        assertCondition((result.matched_count || 0) === missionIds.length, `Batch status ${status} matched ${result.matched_count || 0}/${missionIds.length}.`);
+      }
+      const archived = await this.archiveMissions(missionIds, "Harness batch cleanup archive");
+      assertCondition((archived.updated_count || 0) + (archived.unchanged_count || 0) === missionIds.length, "Batch archive did not cover every disposable mission.");
+      return { mission_count: missionIds.length, mission_ids: missionIds };
+    } catch (error) {
+      try {
+        await this.archiveMissions(created.map((item) => item.mission_id), "Harness batch failure cleanup archive");
+      } catch (_) {}
+      throw error;
+    }
+  }
+
+  async scenarioQaqc() {
+    const sync = this.cli(["sync-qaqc", "--json"], { timeoutMs: 180000 });
+    const result = {
+      sync_mission_count: sync.counts?.missions || sync.missions_count || 0,
+      run_executed: false,
+    };
+    if (!this.includeQaqcRun) {
+      result.skipped_run_reason = "Pass --include-qaqc-run to queue a live QAQC batch.";
+      return result;
+    }
+    this.requireLive("qaqc run");
+    const bootstrap = await this.bootstrap();
+    const mission = chooseQaqcMission(bootstrap);
+    assertCondition(mission, "No active non-Done mission with test cases is available for QAQC run.");
+    const missionId = missionPublicId(mission);
+    const run = this.cli(["run-qaqc", "--mission-ids", missionId, "--wait", "--sync", "--json"], { timeoutMs: 600000 });
+    result.run_executed = true;
+    result.mission_id = missionId;
+    result.batch_id = run.batch_id || null;
+    result.status = run.status || null;
+    result.accepted_count = run.accepted_count || 0;
+    assertCondition(result.accepted_count > 0, `QAQC run did not accept ${missionId}; status=${result.status || "unknown"}.`);
+    return result;
+  }
+
+  scenarioMap() {
+    return {
+      preflight: () => this.scenarioPreflight(),
+      contracts: () => this.scenarioContracts(),
+      suggestion_update_loop: () => this.scenarioSuggestionUpdateLoop(),
+      create_reject_loop: () => this.scenarioCreateRejectLoop(),
+      archive_route_probe: () => this.probeArchiveRoute(),
+      approved_lifecycle: () => this.scenarioApprovedLifecycle(),
+      batch_limits: () => this.scenarioBatchLimits(),
+      batch_mutation: () => this.scenarioBatchMutation(),
+      qaqc: () => this.scenarioQaqc(),
+    };
+  }
+
+  async runScenario(name) {
+    const startedAt = new Date().toISOString();
+    const entry = { name, status: "running", started_at: startedAt };
+    this.report.scenarios.push(entry);
+    const map = this.scenarioMap();
+    if (!map[name]) throw new Error(`Unknown scenario: ${name}`);
+    try {
+      const details = await map[name]();
+      entry.status = "passed";
+      entry.completed_at = new Date().toISOString();
+      entry.details = safeResult(details || {});
+      console.log(`[pass] ${name}`);
+    } catch (error) {
+      entry.status = "failed";
+      entry.completed_at = new Date().toISOString();
+      entry.error = String(error?.message || error);
+      console.error(`[fail] ${name}: ${entry.error}`);
+      if (!this.keepGoing) throw error;
+    } finally {
+      this.writeReport();
+    }
+  }
+
+  writeReport() {
+    this.report.created_mission_ids = Array.from(this.createdMissions).sort();
+    this.report.open_suggestion_ids = Array.from(this.openSuggestions).sort();
+    if (!this.report.completed_at) {
+      this.report.status = this.report.scenarios.some((item) => item.status === "failed") ? "failed" : "running";
+    }
+    ensureDir(path.dirname(this.reportPath));
+    fs.writeFileSync(this.reportPath, JSON.stringify(this.report, null, 2), "utf8");
+  }
+
+  async run() {
+    this.requireKey();
+    ensureDir(this.workspace);
+    ensureDir(this.payloadDir);
+    console.log(`Workspace: ${this.workspace}`);
+    console.log(`Report: ${this.reportPath}`);
+    console.log(`Scenarios: ${this.scenarios.join(", ")}`);
+    if (!this.confirmLive) {
+      console.log("Live mutations disabled. Pass --confirm-live to run mutating scenarios.");
+    }
+    for (const scenario of this.scenarios) {
+      await this.runScenario(scenario);
+    }
+    const failed = this.report.scenarios.filter((item) => item.status === "failed");
+    this.report.status = failed.length ? "failed" : "passed";
+    this.report.completed_at = new Date().toISOString();
+    this.writeReport();
+    console.log(JSON.stringify({
+      status: this.report.status,
+      report_file: this.reportPath,
+      passed: this.report.scenarios.filter((item) => item.status === "passed").length,
+      failed: failed.length,
+      created_mission_ids: this.report.created_mission_ids,
+      open_suggestion_ids: this.report.open_suggestion_ids,
+    }, null, 2));
+    if (failed.length && this.args["no-fail-exit"] !== true) process.exitCode = 1;
+  }
+}
+
+const args = parseArgs(process.argv.slice(2));
+new Harness(args).run().catch((error) => {
+  console.error(error?.message || error);
+  process.exit(1);
+});