@mytegroupinc/myte-core 0.0.24 → 0.0.27

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) {
@@ -46,25 +47,25 @@ function findEnvPath(startDir) {
 
 function loadEnv() {
   const envPath = findEnvPath(process.cwd());
-  try {
-    // eslint-disable-next-line global-require
-    const dotenv = require("dotenv");
-    dotenv.config(envPath ? { path: envPath } : undefined);
-    return;
-  } catch (err) {
-    if (!envPath || !fs.existsSync(envPath)) return;
-    const content = fs.readFileSync(envPath, "utf8");
-    content.split(/\r?\n/).forEach((line) => {
-      if (!line || line.trim().startsWith("#")) return;
-      const idx = line.indexOf("=");
-      if (idx === -1) return;
-      const key = line.slice(0, idx).trim();
-      const val = line.slice(idx + 1).trim();
-      if (key && !(key in process.env)) {
-        process.env[key] = val;
-      }
-    });
-  }
+  if (!envPath || !fs.existsSync(envPath)) return;
+  const content = fs.readFileSync(envPath, "utf8");
+  content.split(/\r?\n/).forEach((line) => {
+    const trimmed = String(line || "").trim();
+    if (!trimmed || trimmed.startsWith("#")) return;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) return;
+    const key = trimmed.slice(0, idx).trim();
+    let val = trimmed.slice(idx + 1).trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    if (key && !(key in process.env)) {
+      process.env[key] = val;
+    }
+  });
 }
 
 function splitCommand(argv) {
@@ -75,6 +76,12 @@ function splitCommand(argv) {
     if (argv[1] === "status") {
       return { command: "mission-status", rest: argv.slice(2) };
     }
+    if (argv[1] === "archive") {
+      return { command: "mission-archive", rest: argv.slice(2) };
+    }
+    if (argv[1] === "restore" || argv[1] === "unarchive") {
+      return { command: "mission-restore", rest: argv.slice(2) };
+    }
     return { command: "mission", rest: argv.slice(1) };
   }
 
@@ -113,105 +120,60 @@ function splitCommand(argv) {
 }
 
 function parseArgs(argv) {
-  try {
-    // eslint-disable-next-line global-require
-    const parsed = require("minimist")(argv, {
-      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin", "with-prd-text", "wait", "sync", "force", "json-response"],
-      string: [
-        "query",
-        "q",
-        "payload-file",
-        "context",
-        "ctx",
-        "file",
-        "actor-scope",
-        "base-url",
-        "timeout-ms",
-        "diff-limit",
-        "max-output-tokens",
-        "max-tokens",
-        "temperature",
-        "title",
-        "description",
-        "feedback-text",
-        "output-dir",
-        "content",
-        "subject",
-        "body-markdown",
-        "body-file",
-        "target-contact-id",
-        "target-contact-ids",
-        "status",
-        "source",
-        "feedback-id",
-        "request-id",
-        "event-id",
-        "version-id",
-        "compare-to",
-        "action",
-        "decision",
-        "to-state",
-        "from-state",
-        "reason",
-        "review-action",
-        "idempotency-key",
-        "user-id",
-        "assigned-user-id",
-        "due-date",
-        "priority",
-        "review-note",
-        "final-file",
-        "tags",
-        "tag",
-        "mission-ids",
-        "client-session-id",
-      ],
-      alias: {
-        q: "query",
-        d: "with-diff",
-        c: "context",
-        h: "help",
-      },
-      default: {
-        fetch: true,
-      },
-    });
-    parsed.__raw = Array.isArray(argv) ? [...argv] : [];
-    return parsed;
-  } catch (err) {
-    const parsed = { _: [] };
-    for (let i = 0; i < argv.length; i += 1) {
-      const token = argv[i];
-      if (token.startsWith("--no-")) {
-        const key = token.slice(5);
-        parsed[key] = false;
+  const parsed = { _: [], fetch: true };
+  const aliases = { q: "query", d: "with-diff", c: "context", h: "help" };
+  const setValue = (key, value) => {
+    const finalKey = aliases[key] || key;
+    if (parsed[finalKey] === undefined) {
+      parsed[finalKey] = value;
+    } else if (Array.isArray(parsed[finalKey])) {
+      parsed[finalKey].push(value);
+    } else {
+      parsed[finalKey] = [parsed[finalKey], value];
+    }
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--") {
+      parsed._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("--no-")) {
+      setValue(token.slice(5), false);
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const eqIdx = token.indexOf("=");
+      if (eqIdx !== -1) {
+        setValue(token.slice(2, eqIdx), token.slice(eqIdx + 1));
         continue;
       }
-      if (token.startsWith("--")) {
-        const key = token.slice(2);
-        const next = argv[i + 1];
-        if (next && !next.startsWith("-")) {
-          parsed[key] = next;
-          i += 1;
-        } else {
-          parsed[key] = true;
-        }
-      } else if (token.startsWith("-")) {
-        const key = token.slice(1);
-        const next = argv[i + 1];
-        if (next && !next.startsWith("-")) {
-          parsed[key] = next;
-          i += 1;
-        } else {
-          parsed[key] = true;
-        }
+      const key = token.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        setValue(key, next);
+        i += 1;
       } else {
-        parsed._.push(token);
+        setValue(key, true);
       }
+      continue;
     }
-    parsed.__raw = Array.isArray(argv) ? [...argv] : [];
-    return parsed;
+    if (token.startsWith("-") && token.length > 1) {
+      const key = token.slice(1);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        setValue(key, next);
+        i += 1;
+      } else {
+        setValue(key, true);
+      }
+      continue;
+    }
+    parsed._.push(token);
   }
+  parsed.__raw = Array.isArray(argv) ? [...argv] : [];
+  return parsed;
 }
 
 function printHelp() {
@@ -224,7 +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 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]",
@@ -272,8 +235,10 @@ function printHelp() {
     "bootstrap contract:",
     "  - Run from any workspace where you want local MyteCommandCenter data written",
     "  - Writes MyteCommandCenter/data/project.yml plus phases, epics, stories, and missions locally",
+    "  - Also refreshes mission review threads into MyteCommandCenter/data/mission-ops.yml by default",
     "  - Uses the project-scoped bootstrap snapshot from the Myte API",
     "  - Mission cards include richer execution context like complexity, estimated_hours, due_date, subtasks, technical_requirements, resources_needed, labels, and normalized test_cases",
+    "  - Use --no-suggestions only when you intentionally want mission cards without mission review-thread state",
     "",
     "sync-qaqc contract:",
     "  - Run from any workspace where you want local MyteCommandCenter data written",
@@ -284,7 +249,10 @@ function printHelp() {
     "  - suggestions sync pulls /api/project-assistant/suggestions and writes only MyteCommandCenter/data/mission-ops.yml",
     "  - sync preserves top-level workspace blocks and per-thread workspace.<actor_scope> drafts from the existing mission-ops file",
     "  - create reads --file YAML/JSON or MyteCommandCenter/data/mission-ops.yml workspace.<actor_scope>.draft_submissions[]",
+    "  - create change_type values are exactly: update, create",
+    "  - create update items require mission_id; create new-mission items require change_set.title and change_set.description",
     "  - revise reads --file YAML/JSON or threads[].workspace.<actor_scope> blocks marked with draft_status=submit|ready|pending_submit",
+    "  - revise does not accept a new change_type; it revises an existing suggestion_id and keeps that thread's change_type",
     "  - review reads --file YAML/JSON or threads[].workspace.<actor_scope> review_action / final_change_set local review blocks",
     "  - create/revise/review sync mission-ops by default after success unless --no-sync is set",
     "",
@@ -298,13 +266,25 @@ 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",
+    "  - 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 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",
     "  - Accepts one file or many files per command; multi-file uploads are sent in one deterministic batch request",
     "  - Title source: myte-kanban.title, first # heading, or --title",
-    "  - Description source: myte-kanban.description or --description",
-    "  - Each item carries the full PRD markdown blob that becomes the stored PRD document and generated DOCX source",
+    "  - Description source: myte-kanban.description or --description; this is a short feedback/card summary only",
+    "  - Never put the full PRD in description. The complete PRD must live in the markdown file body",
+    "  - Each item carries the full PRD markdown blob as prd_markdown/ticket_markdown",
+    "  - Backend stores that blob as the renderable PRD document source, mirrors it for PRD text search/sync, and generates a DOCX attachment",
     "  - PRD DOCX content: the markdown body is stored verbatim",
     "",
     "update-team contract:",
@@ -327,6 +307,7 @@ function printHelp() {
     "  - Syncs pending feedback by default so local Command Center data stays focused on active work",
     "  - Writes project feedback metadata and conversation turns into MyteCommandCenter/data/feedback.yml",
     "  - Stores full PRD context in MyteCommandCenter/PRD/feedback-sync/*.md and points to those files from feedback.yml",
+    "  - Reads existing feedback comments; direct project-key creation of feedback-specific comments is not exposed yet",
     "",
     "feedback review contract:",
     "  - Draft commands write review artifacts under MyteCommandCenter/reviews/feedback/*.yml for local IDE diff review",
@@ -394,12 +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)",
+    "  --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",
     "",
@@ -414,6 +396,7 @@ function printHelp() {
     "  myte suggestions review --file ./review.yml",
     "  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 bootstrap --output-dir ./MyteCommandCenter",
     "  myte sync-qaqc",
     "  myte update-team \"Backend deploy completed; QAQC rerun queued.\"",
@@ -636,8 +619,7 @@ function sleep(ms) {
 
 async function getFetch() {
   if (typeof fetch !== "undefined") return fetch;
-  const mod = await import("node-fetch");
-  return mod.default;
+  throw new Error("Global fetch is unavailable. myte requires Node 18+.");
 }
 
 function normalizeApiBase(baseRaw) {
@@ -2103,6 +2085,34 @@ async function createMissionStatusUpdate({ apiBase, key, timeoutMs, payload, ide
   return body.data || {};
 }
 
+async function createMissionArchiveUpdate({ apiBase, key, timeoutMs, endpoint, payload, idempotencyKey, clientSessionId }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}${endpoint}`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`,
+        "X-Idempotency-Key": String(idempotencyKey || "").trim(),
+        ...(String(clientSessionId || "").trim() ? { "X-Client-Session-Id": String(clientSessionId).trim() } : {}),
+      },
+      body: JSON.stringify(payload),
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Mission archive request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
 async function fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}/project-assistant/run-qaqc/${encodeURIComponent(String(batchId || ""))}`;
@@ -2404,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,
@@ -2413,6 +2435,116 @@ 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) {
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+
+  if (output.project_id) console.log(`Project ID: ${output.project_id}`);
+  console.log(`Target Status: ${output.new_status}`);
+  console.log(`Requested: ${output.requested_count}`);
+  console.log(`Matched: ${output.matched_count}`);
+  console.log(`Updated: ${output.updated_count}`);
+  console.log(`Unchanged: ${output.unchanged_count}`);
+  console.log(`Rejected: ${output.rejected_count}`);
+  for (const mission of output.missions) {
+    const missionId = String(mission?.mission_id || "").trim() || "(unknown)";
+    const status = String(mission?.status || "").trim() || "unknown";
+    const detailParts = [];
+    if (mission?.current_status) detailParts.push(`current=${mission.current_status}`);
+    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) {
+  const key = getProjectApiKey();
+  const commandLabel = "mission archive";
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+
+  const missionIds = parseMissionIdsArg(args);
+  if (!missionIds.length) {
+    console.error(`Missing --mission-ids for \`myte ${commandLabel}\`.`);
+    printHelp();
+    process.exit(1);
+  }
+
+  const payload = {
+    mission_ids: missionIds,
+  };
+  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 = "mission-archive";
+  const idempotencyKey = resolveProjectMutationIdempotencyKey({
+    args,
+    operation,
+    payload,
+  });
+
+  if (args["print-context"] || args.printContext || args["dry-run"] || args.dryRun) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  const timeoutMs = resolveTimeoutMs(args);
+  const apiBase = resolveApiBase(args);
+  const endpoint = "/project-assistant/mission-archive";
+
+  let data;
+  try {
+    data = await createMissionArchiveUpdate({
+      apiBase,
+      key,
+      timeoutMs,
+      endpoint,
+      payload,
+      idempotencyKey,
+      clientSessionId,
+    });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      console.error(`Request timed out after ${timeoutMs}ms`);
+    } else {
+      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,
+    matched_count: data.matched_count || 0,
+    updated_count: data.updated_count || 0,
+    unchanged_count: data.unchanged_count || 0,
+    rejected_count: data.rejected_count || 0,
+    archive_state: data.archive_state || "archived",
+    new_status: data.new_status || "Archived",
+    missions: Array.isArray(data.missions) ? data.missions : [],
+    sync: syncSummary,
   };
 
   if (args.json) {
@@ -2421,6 +2553,7 @@ async function runMissionStatus(args) {
   }
 
   if (output.project_id) console.log(`Project ID: ${output.project_id}`);
+  console.log(`Archive State: ${output.archive_state}`);
   console.log(`Target Status: ${output.new_status}`);
   console.log(`Requested: ${output.requested_count}`);
   console.log(`Matched: ${output.matched_count}`);
@@ -2435,6 +2568,9 @@ 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}`);
+  }
 }
 
 function formatTargetContacts(contacts) {
@@ -2722,9 +2858,7 @@ function bootstrapScopedPathId(item, preferredKeys, scopeKeys, fallbackKeys, fal
 }
 
 function stringifyYaml(value) {
-  // eslint-disable-next-line global-require
-  const YAML = require("yaml");
-  return YAML.stringify(value, { lineWidth: 0 });
+  return `${JSON.stringify(value, null, 2)}\n`;
 }
 
 function stableJsonStringify(value) {
@@ -2741,9 +2875,116 @@ function stableJsonStringify(value) {
 }
 
 function parseYaml(text) {
-  // eslint-disable-next-line global-require
-  const YAML = require("yaml");
-  return YAML.parse(String(text || ""));
+  const raw = String(text || "").trim();
+  if (!raw) return null;
+  if (raw.startsWith("{") || raw.startsWith("[")) {
+    return JSON.parse(raw);
+  }
+  return parseSimpleYaml(raw);
+}
+
+function parseScalarYaml(value) {
+  const raw = String(value || "").trim();
+  if (raw === "") return "";
+  if (raw === "null" || raw === "~") return null;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (/^-?\d+(?:\.\d+)?$/.test(raw)) return Number(raw);
+  if (
+    (raw.startsWith('"') && raw.endsWith('"')) ||
+    (raw.startsWith("'") && raw.endsWith("'"))
+  ) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+
+function parseSimpleYaml(text) {
+  const root = {};
+  const stack = [{ indent: -1, type: "object", value: root }];
+  const lines = String(text || "").split(/\r?\n/);
+  let lastScalar = null;
+
+  const nextContentLine = (startIndex) => {
+    for (let i = startIndex; i < lines.length; i += 1) {
+      const raw = lines[i];
+      if (!raw || !raw.trim() || raw.trim().startsWith("#")) continue;
+      return raw;
+    }
+    return "";
+  };
+
+  const containerForEmpty = (lineIndex) => {
+    const next = nextContentLine(lineIndex + 1);
+    return next.trim().startsWith("- ") ? [] : {};
+  };
+
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const rawLine = lines[lineIndex];
+    if (!rawLine || !rawLine.trim() || rawLine.trim().startsWith("#")) continue;
+    const indent = rawLine.match(/^ */)[0].length;
+    const line = rawLine.trim();
+
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1].value;
+
+    if (line.startsWith("- ")) {
+      if (!Array.isArray(parent)) {
+        throw new Error("Unsupported YAML list placement.");
+      }
+      const body = line.slice(2).trim();
+      if (!body) {
+        const child = containerForEmpty(lineIndex);
+        parent.push(child);
+        stack.push({ indent, type: Array.isArray(child) ? "array" : "object", value: child });
+      } else if (body.includes(":")) {
+        const [key, ...rest] = body.split(":");
+        const obj = {};
+        const keyName = key.trim();
+        const valueText = rest.join(":").trim();
+        const value = valueText ? parseScalarYaml(valueText) : containerForEmpty(lineIndex);
+        obj[keyName] = value;
+        parent.push(obj);
+        stack.push({ indent, type: "object", value: obj });
+        if (value && typeof value === "object") {
+          lastScalar = null;
+          stack.push({ indent: indent + 2, type: Array.isArray(value) ? "array" : "object", value });
+        } else {
+          lastScalar = { container: obj, key: keyName, indent };
+        }
+      } else {
+        parent.push(parseScalarYaml(body));
+        lastScalar = { container: parent, key: parent.length - 1, indent };
+      }
+      continue;
+    }
+
+    const sep = line.indexOf(":");
+    if (sep === -1) {
+      if (lastScalar && indent > lastScalar.indent && lastScalar.container) {
+        const previous = lastScalar.container[lastScalar.key];
+        if (typeof previous === "string") {
+          lastScalar.container[lastScalar.key] = `${previous} ${parseScalarYaml(line)}`;
+          continue;
+        }
+      }
+      throw new Error(`Unsupported YAML line: ${line}`);
+    }
+    const key = line.slice(0, sep).trim();
+    const valueText = line.slice(sep + 1).trim();
+    const value = valueText ? parseScalarYaml(valueText) : containerForEmpty(lineIndex);
+    parent[key] = value;
+    if (value && typeof value === "object") {
+      lastScalar = null;
+      stack.push({ indent, type: Array.isArray(value) ? "array" : "object", value });
+    } else {
+      lastScalar = { container: parent, key, indent };
+    }
+  }
+
+  return root;
 }
 
 function writeYamlFile(filePath, value) {
@@ -3437,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}`;
@@ -3601,6 +3847,34 @@ function normalizeItemsPayload(rawPayload, label) {
   throw new Error(`${label} payload must be an object, array, or { items: [...] } envelope.`);
 }
 
+function validateSuggestionsCreatePayload(payload) {
+  const items = Array.isArray(payload?.items) ? payload.items : [];
+  for (const [index, item] of items.entries()) {
+    if (!isPlainObject(item)) continue;
+    const changeType = String(item.change_type || "").trim().toLowerCase();
+    if (!["update", "create"].includes(changeType)) {
+      throw new Error(`Invalid suggestions create items[${index}].change_type: use update or create.`);
+    }
+    if (changeType === "update" && !String(item.mission_id || "").trim()) {
+      throw new Error(`Invalid suggestions create items[${index}].mission_id: update suggestions require mission_id.`);
+    }
+    if (changeType === "create") {
+      const changeSet = isPlainObject(item.change_set) ? item.change_set : item;
+      if (!String(changeSet.title || "").trim() || !String(changeSet.description || "").trim()) {
+        throw new Error(`Invalid suggestions create items[${index}].change_set: create suggestions require title and description.`);
+      }
+    }
+  }
+}
+
+function validateSuggestionsRevisePayload(payload) {
+  const items = Array.isArray(payload?.items) ? payload.items : [];
+  for (const [index, item] of items.entries()) {
+    if (!isPlainObject(item) || item.change_type === undefined) continue;
+    throw new Error(`Invalid suggestions revise items[${index}].change_type: revise keeps the existing thread change_type; provide suggestion_id, change_description/change_set, and expected_revision instead.`);
+  }
+}
+
 function filterWorkspaceDraftsByIndex(drafts, indexesToRemove) {
   const removal = new Set(Array.from(indexesToRemove || []).map((value) => Number(value)).filter((value) => Number.isInteger(value) && value > 0));
   if (!Array.isArray(drafts) || !removal.size) {
@@ -4214,6 +4488,8 @@ async function runBootstrap(args) {
   const wrapperRoot = resolved.root;
   const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
   const dryRun = Boolean(args["dry-run"] || args.dryRun);
+  const includeSuggestions = resolveBooleanFlag(args, "suggestions", true);
+  const actorScope = resolveActorScope(args, {});
   const summary = {
     api_base: apiBase,
     project_id: snapshot?.project?.id || null,
@@ -4234,6 +4510,16 @@ async function runBootstrap(args) {
     snapshot_hash: snapshot.snapshot_hash || null,
     generated_at: snapshot.generated_at || null,
     dry_run: dryRun,
+    mission_ops: includeSuggestions
+      ? {
+          included: true,
+          actor_scope: actorScope,
+          dry_run: dryRun,
+        }
+      : {
+          included: false,
+          skipped: true,
+        },
   };
 
   if (dryRun) {
@@ -4255,6 +4541,27 @@ async function runBootstrap(args) {
   const writeResult = writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir });
   summary.data_root = writeResult.dataRoot;
 
+  if (includeSuggestions) {
+    let missionOpsSnapshot;
+    try {
+      missionOpsSnapshot = await fetchSuggestionsSyncSnapshot({ apiBase, key, timeoutMs, actorScope });
+    } catch (err) {
+      console.error("Failed to fetch mission suggestions during bootstrap:", err?.message || err);
+      console.error("Run with --no-suggestions only if you intentionally want mission cards without mission review-thread state.");
+      process.exit(1);
+    }
+    const missionOpsWrite = writeMissionOpsSnapshot({ snapshot: missionOpsSnapshot, wrapperRoot, outputDir });
+    const missionOpsCounts = missionOpsWrite?.manifest?.sync?.counts || {};
+    summary.mission_ops = {
+      included: true,
+      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,
+    };
+  }
+
   if (args.json) {
     console.log(JSON.stringify(summary, null, 2));
     return;
@@ -4267,6 +4574,11 @@ async function runBootstrap(args) {
   console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
   if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
   console.log(`Wrote: phases=${summary.counts.phases}, epics=${summary.counts.epics}, stories=${summary.counts.stories}, missions=${summary.counts.missions}`);
+  if (summary.mission_ops?.included) {
+    console.log(`Wrote mission ops: total_threads=${summary.mission_ops.total_threads}, actionable_threads=${summary.mission_ops.actionable_threads}`);
+  } else {
+    console.log("Skipped mission ops sync.");
+  }
   console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
 }
 
@@ -5315,6 +5627,11 @@ async function buildSuggestionsMutationContext(args, mode) {
   if (clientSessionId && !payload.client_session_id) {
     payload.client_session_id = clientSessionId;
   }
+  if (mode === "create") {
+    validateSuggestionsCreatePayload(payload);
+  } else if (mode === "revise") {
+    validateSuggestionsRevisePayload(payload);
+  }
   const idempotencyKey = resolveSuggestionsIdempotencyKey({
     args,
     mode,
@@ -5353,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 {
@@ -5920,7 +6273,7 @@ async function main() {
     process.exit(1);
   }
   if (command === "mission") {
-    console.error("Unknown mission command. Use `myte mission status --mission-ids \"M001,M002\" --status todo|in_progress|done`.");
+    console.error("Unknown mission command. Use `myte mission status` or `myte mission archive`.");
     process.exit(1);
   }
   const args = parseArgs(rest);
@@ -5954,6 +6307,11 @@ async function main() {
     return;
   }
 
+  if (command === "mission-archive") {
+    await runMissionArchiveCommand(args);
+    return;
+  }
+
   if (command === "sync-qaqc" || command === "qaqc-sync") {
     await runSyncQaqc(args);
     return;