@mytegroupinc/myte-core 0.0.24 → 0.0.26

package/README.md

@@ -15,6 +15,7 @@ This package exists so the public wrapper can stay small and versioned cleanly.
 - `MYTE_API_KEY` for project-scoped commands
 - `MYTEAI_API_KEY` for `myte ai`
 - `git` only when using `query --with-diff`
+- No runtime npm dependencies. The CLI uses Node 18+ built-ins for env loading, argument parsing, HTTP, and local context serialization.
 
 ## Behavior Summary
 
@@ -25,6 +26,110 @@ This package exists so the public wrapper can stay small and versioned cleanly.
 - `query --with-diff` requires project repos to be configured for diff collection and fails fast when no matching local project repo can be resolved.
 - Public package documentation is intentionally minimal. Internal rollout and design notes are not part of the npm package contract.
 
+## Agent Usage Contract
+
+Coding agents should treat `MYTE_API_KEY` as a project-scoped Project Assistant key:
+
+- Load it from the workspace `.env` or environment. `MYTE_PROJECT_API_KEY` is accepted as a compatibility fallback.
+- Call `myte config --json` first when project identity or local repo detection is uncertain.
+- Hydrate mission context with `bootstrap` first instead of scraping the web UI. `bootstrap` writes mission cards and mission suggestion thread state.
+- Use `suggestions sync` only when you need to refresh mission review-thread state without refreshing the full board.
+- Use `query --with-diff` for project-scoped code review, planning, and implementation questions.
+- Use `create-prd` only with reviewed markdown files. The markdown file body is the PRD document; `description` is only the short board/card summary.
+- Use `feedback status|edit|assign|archive` for reviewable local artifacts, `feedback submit` for owner review, and `feedback review` for owner/delegate decisions.
+- 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 `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.
+
+Do not use `MYTE_API_KEY` against account/JWT web endpoints. The direct project-key surface is `/api/project-assistant/*`.
+
+PRD document contract:
+
+- Always put the complete PRD in the markdown file passed to `myte create-prd`.
+- `title` maps to the feedback/board title.
+- `description` maps to the short feedback/card summary and must not contain the full PRD.
+- Raw markdown uploads send `{ title, description?, prd_markdown }`.
+- `myte-kanban` uploads send `{ ticket_markdown }`, where the leading JSON block contains metadata and the remaining markdown is the PRD body.
+- The backend stores the markdown as `prd_markdown`, mirrors it as PRD text for search/sync, generates a DOCX attachment from it, and marks `prd_format=markdown`.
+- The UI renders the PRD from stored PRD text/document content, not from `description`.
+
+Feedback comment support:
+
+- `feedback-sync` includes existing feedback comment turns in local context.
+- Feedback-specific comment creation exists in the web backend at `/api/feedbacks/<feedback_id>/comments`, protected by JWT/project assignment.
+- There is no project-key CLI command for `myte feedback comment` yet. That requires a Project Assistant feedback-comment route plus npm command before agents should rely on it.
+
+## Mission Action Map
+
+| Action | Command / Surface | Contract |
+| --- | --- | --- |
+| Sync mission cards and review threads | `myte bootstrap --json` | Refreshes `MyteCommandCenter/data/missions/*.yml`, project structure, and `MyteCommandCenter/data/mission-ops.yml`. |
+| Sync only mission review threads | `myte suggestions sync --json` | Refreshes `MyteCommandCenter/data/mission-ops.yml` while preserving local workspace drafts. |
+| Suggest edit to existing mission | `myte suggestions create` with `change_type: update` and `mission_id` | Creates or appends to an active review thread; live mission is unchanged until approval. |
+| 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. |
+
+Create payloads:
+
+```yaml
+items:
+  - change_type: update
+    mission_id: M001
+    change_description: Tighten acceptance criteria
+    change_set:
+      acceptance_criteria:
+        - The API returns a stable error code for invalid input.
+```
+
+```yaml
+items:
+  - change_type: create
+    change_description: Add observability mission
+    change_set:
+      title: Add mission observability
+      description: Track mission lifecycle actions with safe audit metadata.
+```
+
+Revise payload:
+
+```yaml
+items:
+  - suggestion_id: 507f1f77bcf86cd799439302
+    expected_revision: 1
+    change_description: Revise after review
+    change_set:
+      description: Updated proposed mission description.
+```
+
+YAML note: quote scalar values that contain `:` or other YAML-significant punctuation.
+
+## Finding Mission And Suggestion IDs
+
+Run this first:
+
+```powershell
+myte bootstrap --json
+```
+
+Then read:
+
+| Needed Value | Local Source |
+| --- | --- |
+| Existing mission business id | `MyteCommandCenter/data/missions/*.yml` -> `mission_id`, for example `M001`. |
+| Pending suggestion id | `MyteCommandCenter/data/mission-ops.yml` -> `queue[].suggestion_id` or `threads[].suggestion_id`. |
+| Existing suggestion latest revision | `MyteCommandCenter/data/mission-ops.yml` -> `threads[].latest_revision` or `threads[].latest_server_revision.revision`. |
+| Existing suggestion review revision | `MyteCommandCenter/data/mission-ops.yml` -> `threads[].review_revision`. |
+| Thread type | `MyteCommandCenter/data/mission-ops.yml` -> `threads[].change_type`, either `update` or `create`. |
+
+Agent rule: never guess `suggestion_id`. If `mission-ops.yml` is missing or stale, run `myte bootstrap --json` again. Use `myte suggestions sync --json` only for a narrow refresh after a mutation.
+
 ## Feedback Action Map
 
 | Command | What It Does | Governance |
@@ -72,6 +177,8 @@ Mutation routes:
 - `POST /api/project-assistant/query`
 - `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

@@ -46,25 +46,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 +75,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 +119,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() {
@@ -225,6 +186,8 @@ function printHelp() {
     "  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 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,22 @@ 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",
+    "",
+    "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",
     "",
     "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 +304,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",
@@ -395,6 +373,7 @@ function printHelp() {
     "  --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",
     "  --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",
@@ -414,6 +393,8 @@ 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 mission restore --mission-ids \"M001\" --status todo",
     "  myte bootstrap --output-dir ./MyteCommandCenter",
     "  myte sync-qaqc",
     "  myte update-team \"Backend deploy completed; QAQC rerun queued.\"",
@@ -636,8 +617,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 +2083,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 || ""))}`;
@@ -2437,6 +2445,109 @@ async function runMissionStatus(args) {
   }
 }
 
+async function runMissionArchiveCommand(args, { restore = false } = {}) {
+  const key = getProjectApiKey();
+  const commandLabel = restore ? "mission restore" : "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,
+  };
+  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 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 = restore ? "/project-assistant/mission-restore" : "/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 ${restore ? "restore" : "archive"} failed:`, err?.message || err);
+    }
+    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 || (restore ? "active" : "archived"),
+    new_status: data.new_status || (restore ? "Todo" : "Archived"),
+    missions: Array.isArray(data.missions) ? data.missions : [],
+  };
+
+  if (args.json) {
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+
+  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}`);
+  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(", ")})` : ""}`);
+  }
+}
+
 function formatTargetContacts(contacts) {
   const items = Array.isArray(contacts) ? contacts : [];
   const formatted = items
@@ -2722,9 +2833,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 +2850,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) {
@@ -3601,6 +3817,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 +4458,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 +4480,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 +4511,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 +4544,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 +5597,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,
@@ -5920,7 +6207,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`, `myte mission archive`, or `myte mission restore`.");
     process.exit(1);
   }
   const args = parseArgs(rest);
@@ -5954,6 +6241,16 @@ async function main() {
     return;
   }
 
+  if (command === "mission-archive") {
+    await runMissionArchiveCommand(args, { restore: false });
+    return;
+  }
+
+  if (command === "mission-restore") {
+    await runMissionArchiveCommand(args, { restore: true });
+    return;
+  }
+
   if (command === "sync-qaqc" || command === "qaqc-sync") {
     await runSyncQaqc(args);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",
@@ -20,10 +20,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "dotenv": "^16.5.0",
-    "minimist": "^1.2.8",
-    "node-fetch": "^3.3.2",
+  "dependencies": {},
+  "devDependencies": {
     "yaml": "^2.8.1"
   }
 }