@mytegroupinc/myte-core 0.0.23 → 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
 
@@ -24,3 +25,174 @@ This package exists so the public wrapper can stay small and versioned cleanly.
 - `feedback validate|apply` remains available for validation and owner-direct apply paths; live authorization, stale checks, and history stay server-side.
 - `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 |
+| --- | --- | --- |
+| `feedback-sync` | Pulls feedback metadata, comments, and PRD context into `MyteCommandCenter`. | Read-only project-key API call. |
+| `feedback get` | Reads one feedback item's current server snapshot and `snapshot_hash`. | Read-only; backend checks project access. |
+| `feedback status` | Creates a local YAML proposal to change canonical lifecycle state. | No live mutation until `submit` and owner/delegate review, except owner-direct `apply`. |
+| `feedback edit` / `feedback refine` | Creates a local YAML proposal for title, description/body, priority, due date, tags, or notes. | Content changes go through owner-review membrane. |
+| `feedback assign` | Creates a local YAML proposal to change assignee. | Goes through review unless applied through owner-direct path. |
+| `feedback archive` | Creates a local YAML proposal to archive. | Archive is governed by backend owner/delegate capability. |
+| `feedback submit` | Sends a local proposal artifact to the backend as a review request. | Does not mutate live feedback before approval. |
+| `feedback revise` | Resubmits the original submitter's request after `request_changes`. | Only valid for the original submitter and `needs_changes` requests. |
+| `feedback reviews` | Lists review requests or fetches one request by `--request-id`. | Read-only; response includes backend permissions. |
+| `feedback review` | Approves, rejects, requests changes, or cancels a review request. | Backend restricts approval/review decisions to Project Owner or elevated delegate for Feedback scope. |
+| `feedback move` | Moves a card across allowed board states directly with an audit event. | Safe states are direct; governed states such as archive/reject/deploy remain backend-authorized. |
+| `feedback undo` | Reverses an audited board event when there is no conflict. | Backend validates event ownership/project scope and conflict state. |
+| `feedback prd-versions` | Lists retained PRD baselines/revisions for a feedback item. | Read-only; old S3 objects are retained by reference. |
+| `feedback prd-diff` | Fetches backend-generated text diff for PRD versions. | Read-only; backend controls version access. |
+| `feedback history` | Lists audited feedback board/refinement events. | Read-only; backend checks project access. |
+| `feedback validate` | Sends an artifact to backend validation without mutation. | Useful before submit or owner-direct apply. |
+| `feedback apply` | Applies an artifact through the owner-direct/emergency path. | Not the normal collaborator flow; normal flow is `submit` -> `review`. |
+
+## Direct Project API Surface
+
+All routes use `Authorization: Bearer <MYTE_API_KEY>`. The CLI adds idempotency and client-session headers on mutation routes.
+
+Read/sync routes:
+
+- `GET /api/project-assistant/config`
+- `GET /api/project-assistant/bootstrap`
+- `GET /api/project-assistant/qaqc-sync`
+- `GET /api/project-assistant/feedback-sync`
+- `GET /api/project-assistant/feedback/<feedback_id>`
+- `GET /api/project-assistant/feedback/<feedback_id>/refinement/history`
+- `GET /api/project-assistant/feedback-review-requests`
+- `GET /api/project-assistant/feedback-review-requests/<request_id>`
+- `GET /api/project-assistant/feedback/<feedback_id>/events`
+- `GET /api/project-assistant/feedback/<feedback_id>/prd/versions`
+- `GET /api/project-assistant/feedback/<feedback_id>/prd/versions/<version_id>/diff`
+- `GET /api/project-assistant/suggestions`
+- `GET /api/project-assistant/run-qaqc/<batch_id>`
+
+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`
+- `POST /api/project-assistant/create-prd`
+- `POST /api/project-assistant/create-prds`
+- `POST /api/project-assistant/feedback/<feedback_id>/refinement/validate`
+- `POST /api/project-assistant/feedback/<feedback_id>/refinement/requests`
+- `POST /api/project-assistant/feedback-review-requests/<request_id>/revise`
+- `POST /api/project-assistant/feedback/<feedback_id>/refinement/apply`
+- `POST /api/project-assistant/feedback-review-requests/<request_id>/review`
+- `POST /api/project-assistant/feedback-review-requests/<request_id>/request-changes`
+- `POST /api/project-assistant/feedback-review-requests/<request_id>/cancel`
+- `POST /api/project-assistant/feedback/<feedback_id>/board-move`
+- `POST /api/project-assistant/feedback/<feedback_id>/events/<event_id>/undo`
+- `POST /api/project-assistant/suggestions`
+- `POST /api/project-assistant/suggestions/revise`
+- `POST /api/project-assistant/suggestions/review`

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]",
@@ -234,8 +197,12 @@ function printHelp() {
     "  myte update-owner --subject \"<text>\" [--body-markdown \"...\"] [--body-file ./update.md] [--json]",
     "  myte update-client --subject \"<text>\" [--body-markdown \"...\"] [--body-file ./update.md] [--target-contact-ids <id1,id2>] [--json]",
     "  myte feedback-sync [--status <value>] [--source <value>] [--with-prd-text|--no-with-prd-text] [--output-dir ./MyteCommandCenter] [--json]",
+    "  myte feedback get --feedback-id <id> [--json]",
+    "  myte feedback history --feedback-id <id> [--limit 50] [--json]",
     "  myte feedback status --feedback-id <id> --status todo|in_progress|in_review|completed|deployed|rejected|archived --reason \"...\"",
     "  myte feedback edit --feedback-id <id> [--title \"...\"] [--feedback-text \"...\"] [--priority High] [--reason \"...\"]",
+    "  myte feedback assign --feedback-id <id> --user-id <id> [--reason \"...\"]",
+    "  myte feedback archive --feedback-id <id> --reason \"...\"",
     "  myte feedback submit --file ./MyteCommandCenter/reviews/feedback/<id>-edit.yml [--json]",
     "  myte feedback revise --request-id <id> --file ./MyteCommandCenter/reviews/feedback/<id>-edit.yml [--json]",
     "  myte feedback reviews [--status open|terminal|all] [--request-id <id>] [--json]",
@@ -268,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",
@@ -280,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",
     "",
@@ -294,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:",
@@ -323,17 +304,36 @@ 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",
+    "  - status/edit/assign/archive/refine create local proposals only; they do not mutate live feedback by themselves",
     "  - submit/revise route artifacts through the owner-review membrane before live feedback mutation",
     "  - reviews/review expose owner/delegate approval, rejection, request-changes, and cancel decisions",
     "  - move/undo operate safe board states directly; governed states remain backend-authorized",
+    "  - get/history read current feedback snapshots and audited event history through the project-key API",
     "  - prd-versions/prd-diff expose retained PRD versions and backend-generated text diffs",
     "  - validate/apply send artifacts to /api/project-assistant/feedback/<id>/refinement/* for validation or owner-direct apply",
     "  - The backend owns authorization, stale snapshot checks, allowed field/transition rules, and history",
     "  - apply is idempotent and does not rewrite local feedback.yml; run feedback-sync after apply to refresh local state",
     "",
+    "feedback action map:",
+    "  - feedback-sync: pull board/PRD context into MyteCommandCenter for IDE work",
+    "  - get: read one feedback item's current server snapshot and snapshot_hash",
+    "  - status/edit/assign/archive/refine: create reviewable local YAML artifacts; no live mutation",
+    "  - submit: submit a local artifact as a pending owner-review request",
+    "  - revise: resubmit the original submitter's request after request_changes",
+    "  - reviews: list open/terminal/all requests or inspect one request",
+    "  - review: approve, reject, request_changes, or cancel; backend restricts this to owner/delegate capability",
+    "  - move: direct audited board movement for allowed states; governed transitions remain backend-authorized",
+    "  - undo: reverse an audited board event when conflict checks allow it",
+    "  - prd-versions: list retained PRD baselines/revisions for a feedback item",
+    "  - prd-diff: fetch backend-generated text diff between PRD versions",
+    "  - history: list board/refinement events for audit review",
+    "  - validate: server-side validation of an artifact without mutation",
+    "  - apply: owner-direct/emergency apply path; normal collaborative flow is submit -> review",
+    "",
     "Options:",
     "  --with-diff           Include deterministic git diffs (project-scoped; fails fast if no project repos are configured or resolved)",
     "  --diff-limit <chars>  Truncate diff context to N chars (default: 500000)",
@@ -373,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",
@@ -392,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.\"",
@@ -614,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) {
@@ -2081,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 || ""))}`;
@@ -2415,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
@@ -2700,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) {
@@ -2719,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) {
@@ -3579,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) {
@@ -4192,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,
@@ -4212,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) {
@@ -4233,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;
@@ -4245,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"}`);
 }
 
@@ -5293,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,
@@ -5898,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);
@@ -5932,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.23",
+  "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"
   }
 }