@mytegroupinc/myte-core 0.0.55 → 0.0.57

package/cli.js

@@ -14,7 +14,7 @@ const net = require("net");
 const tls = require("tls");
 const { createHash, randomUUID } = require("crypto");
 const { spawnSync } = require("child_process");
-const {
+const {
   DEFAULT_MYTEAI_BASE,
   buildSimpleAiPayload,
   callMyteAiChat,
@@ -22,10 +22,23 @@ const {
   getMyteAiKey,
   normalizeJsonAssistantText,
   normalizeMyteAiBase,
-} = require("./lib/ai-gateway");
-
-const DEFAULT_API_BASE = "https://api.myte.dev";
-const DEFAULT_DIFF_LIMIT_CHARS = 500_000;
+} = require("./lib/ai-gateway");
+const {
+  buildBuildHarnessMarkdown,
+  buildTopology,
+  qaqcMissionCoverage,
+  verifyTopology,
+} = require("./lib/build-harness");
+const {
+  checkPackageUpdate,
+  packageUpdateNotice,
+} = require("./lib/package-update-check");
+
+const DEFAULT_API_BASE = "https://api.myte.dev";
+const PACKAGE_NAME = "myte";
+const PACKAGE_VERSION = require("./package.json").version;
+const DEFAULT_PACKAGE_LATEST_URL = "https://registry.npmjs.org/myte/latest";
+const DEFAULT_DIFF_LIMIT_CHARS = 500_000;
 const DEFAULT_FEEDBACK_SYNC_PAGE_SIZE = 50;
 const MAX_PRD_DOCUMENT_MARKDOWN_CHARS = 250_000;
 const REMOVED_COMMAND_MESSAGES = {
@@ -74,7 +87,10 @@ function loadEnv() {
   return envPath;
 }
 
-function splitCommand(argv) {
+function splitCommand(argv) {
+  if (argv[0] === "build" && argv[1] === "verify") {
+    return { command: "build-verify", rest: argv.slice(2) };
+  }
   if (argv[0] === "mission") {
     if (argv[1] === "status" && argv[2] === "update") {
       return { command: "mission-status", rest: argv.slice(3) };
@@ -203,7 +219,8 @@ function printHelp() {
     "  myte doctor [--json] [--timeout-ms <ms>] [--base-url <url>]",
     "  myte info [--json]",
     "  myte --version [--verbose] [--json]",
-    "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
+    "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
+    "  myte build verify [--output-dir ./MyteCommandCenter] [--semantic-review-file <path>] [--repository-gates-file <path>] [--qaqc-file <path>] [--json]",
     "  myte run-qaqc --mission-ids \"M001[,M002...]\" [--wait] [--sync] [--force] [--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]",
@@ -231,6 +248,12 @@ function printHelp() {
     "  myte feedback move --feedback-id <id> --to-state in_progress --from-state todo --reason \"...\" [--json]",
     "  myte feedback move --feedback-ids \"<id1,id2>\" --to-state in_progress --reason \"...\" [--json]",
     "  myte feedback comment --feedback-id <id> --body \"...\" [--body-file ./comment.md] --confirm-write --approval-artifact <path> [--json]",
+    "  myte feedback tickets list --feedback-id <id> [--json]",
+    "  myte feedback tickets create --feedback-id <id> --file ./ticket.yml --confirm-write --approval-artifact <path> [--json]",
+    "  myte feedback tickets create --feedback-id <id> --file ./ticket-batch.yml --dry-run [--json]",
+    "  myte feedback tickets update --feedback-id <id> --ticket-ids \"<id1,id2>\" --status in_progress --confirm-write --approval-artifact <path> [--json]",
+    "  myte feedback tickets update --feedback-id <id> --file ./ticket-updates.yml --dry-run [--json]",
+    "  myte feedback tickets coverage --feedback-id <id> --ticket-id <id> --version-id <id> --document-id <id> --coverage-status covered --confirm-write --approval-artifact <path> [--json]",
     "  myte feedback undo --feedback-id <id> --event-id <id> --reason \"...\" [--json]",
     "  myte feedback prd-versions --feedback-id <id> [--json]",
     "  myte feedback prd-diff --feedback-id <id> --version-id <id> [--compare-to <id>] [--document-id <id>] [--json]",
@@ -255,13 +278,26 @@ function printHelp() {
     "  - Set MYTE_API_KEY in a workspace .env (or env var)",
     "  - Set MYTEAI_API_KEY in a workspace .env (or env var) for `myte ai`",
     "",
-    "bootstrap contract:",
+    "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",
+    "  - Use --no-suggestions only when you intentionally want mission cards without mission review-thread state",
+    "  - Also writes MyteBuildHarness.md and data/build-topology.yml with the project execution protocol and convergence checks",
+    "",
+    "build verify contract:",
+    "  - Verifies the local bootstrap topology and evidence without mutating Myte state",
+    "  - Requires explicit semantic/UI review and repository-gate evidence files for a passing result",
+    "  - Reports missing acceptance criteria, test cases, orphan missions, and missing intent topology",
+    "  - Requires readable terminal QAQC coverage for every active mission, with no failed or pending cases",
+    "  - Does not run QAQC, repository tests, or semantic review; it verifies the evidence those steps produced",
+    "",
+    "package update notices:",
+    "  - Successful commands perform a cached, best-effort check for a newer myte package",
+    "  - Notices go to stderr so --json stdout remains machine-readable",
+    "  - Disable with --no-update-check or MYTE_PACKAGE_UPDATE_CHECK=0",
     "",
     "sync-qaqc contract:",
     "  - Run from any workspace where you want local MyteCommandCenter data written",
@@ -311,7 +347,8 @@ function printHelp() {
     "  - Explicit assignees must be the project owner or an active assigned project collaborator",
     "  - 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",
+    "  - Backend stores that blob as the renderable PRD document source, mirrors it for PRD text search/sync, and generates a DOCX attachment",
+    "  - Successful creation returns active_prd_version_id, active_prd_version_number, and primary_document_id for immediate sub-ticket linking",
     "  - Renderer-friendly PRDs use one # title, ## sections, bullets, GitHub tables/checklists where useful, and code fences only for real code/config",
     "  - Do not wrap the whole PRD in a ```markdown fence; generic .md/.docx/.pdf/.txt uploads are normal attachments unless created as PRDs",
     "  - PRD DOCX content: the markdown body is stored verbatim",
@@ -320,10 +357,10 @@ function printHelp() {
     "  - Creates a project team comment through /api/project-assistant/project-comment",
     "  - Required: content (inline, --content, or --stdin)",
     "",
-    "update-owner contract:",
-    "  - Queues a durable owner email delivery through /api/project-assistant/update-owner",
+    "update-owner contract:",
+    "  - Queues a durable owner email delivery through /api/project-assistant/update-owner",
     "  - Required: --subject and body markdown (via --body-markdown, --body-file, positional file/text, or --stdin)",
-    "  - Resolves the owner synchronously; the existing notification worker delivers with a deterministic delivery id",
+    "  - Resolves the owner synchronously; the existing notification worker delivers with a deterministic delivery id",
     "",
     "update-client contract:",
     "  - Creates a client update draft through /api/project-assistant/client-update-drafts",
@@ -352,6 +389,9 @@ function printHelp() {
     "  - move with --feedback-ids sends one batch board move request; it supports active-state moves and authorized archive",
     "  - comment creates text-only feedback-specific comments; attachments remain web UI only for this endpoint",
     "  - project-key API/CLI cannot unarchive archived Feedback; use the web archived Feedback view",
+    "  - tickets list/create/update/coverage govern multiple engineering subtickets linked to the same PRD; create/update files accept JSON or YAML and batches are capped at 100",
+    "  - Each ticket may link at most 25 PRD documents; the backend rejects version/document links outside that exact PRD before mutation",
+    "  - tickets create/update --dry-run uses the server validation routes without mutating; live writes require revisions, idempotency and a structured approval artifact",
     "  - 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 per-document text diffs",
     "  - edit/refine with --prd-file updates a review artifact only; --document-id targets one document in a PRD document set",
@@ -361,7 +401,7 @@ function printHelp() {
     "  - apply is idempotent and does not rewrite local feedback.yml; run feedback-sync after apply to refresh local state",
     "",
     "approval artifact requirements:",
-    "  - Required: create-prd, update-team, update-owner, update-client, feedback submit/revise/comment, suggestions create/revise",
+    "  - Required: create-prd, update-team, update-owner, update-client, feedback submit/revise/comment, feedback tickets create/update/coverage, suggestions create/revise",
     "  - Not required: run-qaqc, mission status/archive, suggestions review, feedback review/move/undo/apply",
     "  - Never required: read/sync/query/validate commands, --print-context, --dry-run, and feedback local draft commands",
     "  - For required actions, prepare a .md/.markdown/.yml/.yaml/.json artifact, show it to the user, then rerun with --confirm-write --approval-artifact <path>",
@@ -383,6 +423,7 @@ function printHelp() {
     "  - move: direct audited board movement for allowed states; governed transitions remain backend-authorized",
     "  - document-add: create a governed proposal to append one linked PRD document to an existing Feedback item",
     "  - comment: create a text-only comment on one Feedback item",
+    "  - tickets: list, validate, create and revision-fence single or batch PRD subticket lifecycle changes",
     "  - 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",
@@ -418,6 +459,10 @@ function printHelp() {
     "  --target-contact-ids  Comma-separated client contact ObjectIds",
     "  --feedback-id <id>    Feedback ObjectId for feedback review commands",
     "  --feedback-ids <ids>  Comma-separated Feedback ObjectIds for batch feedback move",
+    "  --ticket-id <id>       Feedback PRD subticket ObjectId for single update or coverage",
+    "  --ticket-ids <ids>     Comma-separated subticket ObjectIds for one batch update",
+    "  --severity <value>     Ticket severity target: Critical, High, Medium, Low, or Info",
+    "  --coverage-status <value> Ticket PRD coverage: not_covered, partially_covered, covered, or not_applicable",
     "  --request-id <id>     Feedback review request ObjectId for submit/revise/review flows",
     "  --request-ids <ids>   Comma-separated Feedback review request ObjectIds for batch review",
     "  --event-id <id>       Feedback board event ObjectId for undo",
@@ -477,6 +522,9 @@ function printHelp() {
     "  myte feedback review --request-id 507f1f77bcf86cd799439022 --action approve --reason \"Looks correct\" --json",
     "  myte feedback move --feedback-id 507f1f77bcf86cd799439011 --to-state in_progress --reason \"Started\" --json",
     "  myte feedback comment --feedback-id 507f1f77bcf86cd799439011 --body-file ./comments/implementation.md --confirm-write --approval-artifact ./comments/implementation.md --json",
+    "  myte feedback tickets list --feedback-id 507f1f77bcf86cd799439011 --json",
+    "  myte feedback tickets create --feedback-id 507f1f77bcf86cd799439011 --file ./tickets/auth.yml --dry-run --json",
+    "  myte feedback tickets update --feedback-id 507f1f77bcf86cd799439011 --ticket-ids \"507f1f77bcf86cd799439021,507f1f77bcf86cd799439022\" --status in_progress --confirm-write --approval-artifact ./tickets/update.yml --json",
     "  myte feedback document-add --feedback-id 507f1f77bcf86cd799439011 --prd-file ./drafts/sidebar-branding.md --title \"Individual Use Sidebar Branding\" --reason \"Link governed UX addendum to the Feedback context.\"",
     "  myte feedback validate --file ./MyteCommandCenter/reviews/feedback/507f1f77bcf86cd799439011-status.yml --json",
     "  myte feedback apply --file ./MyteCommandCenter/reviews/feedback/507f1f77bcf86cd799439011-status.yml --json",
@@ -991,7 +1039,7 @@ function normalizeApiBase(baseRaw) {
   return base.endsWith("/api") ? base : `${base}/api`;
 }
 
-async function fetchJsonWithTimeout(fetchFn, url, options, timeoutMs) {
+async function fetchJsonWithTimeout(fetchFn, url, options, timeoutMs) {
   const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
   let timedOut = false;
   const timeoutId =
@@ -2589,6 +2637,59 @@ async function postFeedbackComment({ apiBase, key, timeoutMs, feedbackId, payloa
   return body.data || {};
 }
 
+function parseFeedbackTicketIdsArg(args) {
+  return dedupeStrings(
+    parseCsvValues(
+      args["ticket-ids"],
+      args.ticketIds,
+      args.ticket_ids,
+      args["ticket-id"],
+      args.ticketId,
+      args.ticket_id
+    )
+  );
+}
+
+async function requestFeedbackTickets({
+  apiBase,
+  key,
+  timeoutMs,
+  feedbackId,
+  endpoint = "",
+  method = "GET",
+  payload,
+  idempotencyKey,
+  clientSessionId,
+}) {
+  const fetchFn = await getFetch();
+  const suffix = endpoint ? `/${String(endpoint).replace(/^\/+/, "")}` : "";
+  const url = `${apiBase}/project-assistant/feedback/${encodeURIComponent(String(feedbackId || ""))}/tickets${suffix}`;
+  const headers = {
+    Authorization: `Bearer ${key}`,
+    ...(String(clientSessionId || "").trim() ? { "X-Client-Session-Id": String(clientSessionId).trim() } : {}),
+  };
+  if (payload !== undefined) headers["Content-Type"] = "application/json";
+  if (idempotencyKey) headers["X-Idempotency-Key"] = String(idempotencyKey).trim();
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method,
+      headers,
+      ...(payload !== undefined ? { body: JSON.stringify(payload || {}) } : {}),
+    },
+    timeoutMs
+  );
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Feedback ticket request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    err.data = body?.data;
+    throw err;
+  }
+  return body.data || {};
+}
+
 async function fetchFeedbackPrdVersions({ apiBase, key, timeoutMs, feedbackId }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}/project-assistant/feedback/${encodeURIComponent(String(feedbackId || ""))}/prd/versions`;
@@ -2807,7 +2908,7 @@ async function createMissionArchiveUpdate({ apiBase, key, timeoutMs, endpoint, p
   return body.data || {};
 }
 
-async function fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId }) {
+async function fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}/project-assistant/run-qaqc/${encodeURIComponent(String(batchId || ""))}`;
   const { resp, body } = await fetchJsonWithTimeout(
@@ -2832,15 +2933,15 @@ async function fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId }) {
     if (retryAfter) err.retryAfter = retryAfter;
     throw err;
   }
-  const data = body.data || {};
-  Object.defineProperty(data, "_nextPollAfterMs", {
-    value: successfulPollDelayMs(data, resp),
-    enumerable: false,
-  });
-  return data;
+  const data = body.data || {};
+  Object.defineProperty(data, "_nextPollAfterMs", {
+    value: successfulPollDelayMs(data, resp),
+    enumerable: false,
+  });
+  return data;
 }
 
-function resolveRetryAfterMs(err, fallbackMs = 5_000) {
+function resolveRetryAfterMs(err, fallbackMs = 5_000) {
   const retryAfterRaw = firstNonEmptyString(err?.retryAfter);
   const retryAfterSeconds = Number.parseInt(String(retryAfterRaw || ""), 10);
   if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) {
@@ -2850,21 +2951,21 @@ function resolveRetryAfterMs(err, fallbackMs = 5_000) {
   if (Number.isFinite(retryAfterDate)) {
     return Math.min(Math.max(0, retryAfterDate - Date.now()), 60_000);
   }
-  return fallbackMs;
-}
-
-function successfulPollDelayMs(data, response, fallbackMs = 2_000) {
-  const payloadDelay = Number(data?.next_poll_after_ms);
-  const retryAfter = response?.headers?.get?.("retry-after");
-  const headerDelay = retryAfter ? resolveRetryAfterMs({ retryAfter }, 0) : 0;
-  const advertised = Math.max(
-    Number.isFinite(payloadDelay) && payloadDelay > 0 ? payloadDelay : 0,
-    headerDelay,
-  );
-  const base = Math.min(60_000, Math.max(250, advertised || fallbackMs));
-  const jitterLimit = Math.max(0, Math.min(1_000, Number(process.env.MYTE_POLL_JITTER_MS ?? 250) || 0));
-  return Math.min(60_000, base + (jitterLimit ? Math.floor(Math.random() * (jitterLimit + 1)) : 0));
-}
+  return fallbackMs;
+}
+
+function successfulPollDelayMs(data, response, fallbackMs = 2_000) {
+  const payloadDelay = Number(data?.next_poll_after_ms);
+  const retryAfter = response?.headers?.get?.("retry-after");
+  const headerDelay = retryAfter ? resolveRetryAfterMs({ retryAfter }, 0) : 0;
+  const advertised = Math.max(
+    Number.isFinite(payloadDelay) && payloadDelay > 0 ? payloadDelay : 0,
+    headerDelay,
+  );
+  const base = Math.min(60_000, Math.max(250, advertised || fallbackMs));
+  const jitterLimit = Math.max(0, Math.min(1_000, Number(process.env.MYTE_POLL_JITTER_MS ?? 250) || 0));
+  return Math.min(60_000, base + (jitterLimit ? Math.floor(Math.random() * (jitterLimit + 1)) : 0));
+}
 
 function isTransientQueryStatusError(err) {
   return Boolean(
@@ -2883,9 +2984,22 @@ function createHttpResponseError(resp, body, url, fallbackMessage) {
   if (status === 401) {
     kind = "authentication";
     detail = "The API rejected the project key.";
-  } else if (status === 403) {
-    kind = "authorization";
-    detail = "The authenticated project identity is not allowed to perform this action.";
+  } else if (status === 403) {
+    kind = "authorization";
+    const responseCode = firstNonEmptyString(body?.data?.code, body?.code);
+    if (responseCode === "policy_consent_required") {
+      const consentPath = firstNonEmptyString(body?.data?.consent_url, body?.data?.mission_board_deeplink);
+      const requiredVersion = firstNonEmptyString(body?.data?.required_policy_version);
+      detail = [
+        firstNonEmptyString(body?.message) || "Myte Policy acceptance is required for this project.",
+        requiredVersion ? `Required policy version: ${requiredVersion}.` : "",
+        consentPath ? `Open the Myte mission board to review and accept: ${consentPath}` : "",
+      ]
+        .filter(Boolean)
+        .join(" ");
+    } else {
+      detail = "The authenticated project identity is not allowed to perform this action.";
+    }
   } else if (status === 429) {
     kind = "rate_limit";
     detail = "The API rate limit is temporarily exhausted.";
@@ -3008,7 +3122,7 @@ async function createAssistantQueryJob({
   return body.data || {};
 }
 
-async function fetchAssistantQueryJobStatus({ apiBase, key, timeoutMs, jobId, requestId }) {
+async function fetchAssistantQueryJobStatus({ apiBase, key, timeoutMs, jobId, requestId }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}/project-assistant/query/${encodeURIComponent(String(jobId || ""))}`;
   const { resp, body } = await fetchJsonWithTimeout(
@@ -3027,12 +3141,12 @@ async function fetchAssistantQueryJobStatus({ apiBase, key, timeoutMs, jobId, re
   if (!resp.ok || body.status !== "success") {
     throw createHttpResponseError(resp, body, url, "The query status could not be loaded.");
   }
-  const data = body.data || {};
-  Object.defineProperty(data, "_nextPollAfterMs", {
-    value: successfulPollDelayMs(data, resp),
-    enumerable: false,
-  });
-  return data;
+  const data = body.data || {};
+  Object.defineProperty(data, "_nextPollAfterMs", {
+    value: successfulPollDelayMs(data, resp),
+    enumerable: false,
+  });
+  return data;
 }
 
 async function runRunQaqc(args) {
@@ -3092,15 +3206,15 @@ async function runRunQaqc(args) {
 
   let finalStatus = null;
   let syncSummary = null;
-  if (shouldWait && data.batch_id) {
-    const pollTimeoutMs = Math.max(timeoutMs, 900_000);
-    const startedAt = Date.now();
-    let pollDelayMs = 2_000;
-    do {
-      await sleep(pollDelayMs);
-      try {
-        finalStatus = await fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId: data.batch_id });
-        pollDelayMs = Number(finalStatus?._nextPollAfterMs) || Math.min(10_000, Math.ceil(pollDelayMs * 1.25));
+  if (shouldWait && data.batch_id) {
+    const pollTimeoutMs = Math.max(timeoutMs, 900_000);
+    const startedAt = Date.now();
+    let pollDelayMs = 2_000;
+    do {
+      await sleep(pollDelayMs);
+      try {
+        finalStatus = await fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId: data.batch_id });
+        pollDelayMs = Number(finalStatus?._nextPollAfterMs) || Math.min(10_000, Math.ceil(pollDelayMs * 1.25));
       } catch (err) {
         if (Number(err?.status) === 429) {
           await sleep(resolveRetryAfterMs(err));
@@ -4221,6 +4335,7 @@ function buildAgentsMyteApiMarkdown() {
     "- Mission edit/create batches use `myte suggestions create` or `myte suggestions revise`; the artifact must list each item. For mission edits include `change_type: update`, the existing `mission_id`, and the changed fields. For new missions include `change_type: create`, the proposed title, description, and acceptance details. For revisions include each `suggestion_id` and expected revision.",
     "- PRD batches use one `myte create-prd fileA.md fileB.md ...`; the artifact must list each PRD file/title/client ref. `batch_count` must match the number of PRD items.",
     "- Feedback submit/revise/comment artifacts are usually the same YAML or markdown file being submitted. If the command uses inline text or stdin, create a separate approval memo that includes the feedback id or request id and the exact content.",
+    "- Feedback ticket create/update/coverage artifacts must enumerate every ticket key/id, expected revision, PRD document link, and changed lifecycle field. Use --dry-run before the approved live batch.",
     "- Team, owner, and client update artifacts should name the audience and include the exact message body or a complete summary; client updates should include target contact ids when used.",
     "- `feedback review --request-ids`, `feedback move --feedback-ids`, `mission status --mission-ids`, `mission archive --mission-ids`, and `run-qaqc --mission-ids` are batched governed writes, but they are marked `no` below and should not receive approval artifact flags.",
     "",
@@ -4265,6 +4380,10 @@ function buildAgentsMyteApiMarkdown() {
     "| Feedback move | `myte feedback move --feedback-id <id> --to-state in_progress --reason \"...\" --json` | `POST /project-assistant/feedback/<id>/board-move` | governed write | no |",
     "| Feedback batch move | `myte feedback move --feedback-ids \"<id1,id2>\" --to-state in_progress --json` | `POST /project-assistant/feedback/batch-board-move` | governed write | no |",
     "| Feedback comment | `myte feedback comment --feedback-id <id> --body-file ./comment.md --confirm-write --approval-artifact ./comment.md --json` | `POST /project-assistant/feedback/<id>/comments` | comment write | required |",
+    "| Feedback tickets list | `myte feedback tickets list --feedback-id <id> --json` | `GET /project-assistant/feedback/<id>/tickets` | read | no |",
+    "| Feedback tickets create | `myte feedback tickets create --feedback-id <id> --file ./tickets.yml --confirm-write --approval-artifact ./tickets.yml --json` | `POST /project-assistant/feedback/<id>/tickets` or `/tickets/batch`; `--dry-run` uses `/tickets/batch/validate` | synchronous ticket write | required |",
+    "| Feedback tickets update | `myte feedback tickets update --feedback-id <id> --ticket-ids \"<id1,id2>\" --status in_progress --confirm-write --approval-artifact ./update.yml --json` | `PATCH /project-assistant/feedback/<id>/tickets/batch`; `--dry-run` uses `/tickets/batch-update/validate` | revision-fenced ticket write | required |",
+    "| Feedback ticket coverage | `myte feedback tickets coverage --feedback-id <id> --ticket-id <id> ... --confirm-write --approval-artifact ./coverage.yml --json` | `PATCH /project-assistant/feedback/<id>/tickets/<ticket_id>/prd-coverage` | revision-fenced ticket write | required |",
     "| Feedback undo | `myte feedback undo --feedback-id <id> --event-id <id> --reason \"...\" --json` | `POST /project-assistant/feedback/<id>/events/<event_id>/undo` | governed write | no |",
     "| Feedback PRD versions | `myte feedback prd-versions --feedback-id <id> --json` | `GET /project-assistant/feedback/<id>/prd/versions` | read | no |",
     "| Feedback PRD diff | `myte feedback prd-diff --feedback-id <id> --version-id <id>` | `GET /project-assistant/feedback/<id>/prd/versions/<version_id>/diff` | read | no |",
@@ -4313,7 +4432,7 @@ function pruneLegacyCommandCenterArtifacts(dataRoot, options = {}) {
   }
 }
 
-function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir }) {
+function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir, local }) {
   const { targetRoot, dataRoot } = resolveCommandCenterRoots(wrapperRoot, outputDir);
   const phasesDir = path.join(dataRoot, "phases");
   const epicsDir = path.join(dataRoot, "epics");
@@ -4371,10 +4490,19 @@ function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir }) {
     writeYamlFile(path.join(missionsDir, `${missionPathId}.yml`), mission);
   });
 
-  if (snapshot.project && typeof snapshot.project === "object") {
-    writeYamlFile(path.join(dataRoot, "project.yml"), scrubBootstrapValue(snapshot.project));
-  }
-  const agentsMyteApiPath = writeAgentsMyteApiGuide({ wrapperRoot, outputDir });
+  if (snapshot.project && typeof snapshot.project === "object") {
+    writeYamlFile(path.join(dataRoot, "project.yml"), scrubBootstrapValue(snapshot.project));
+  }
+  const agentsMyteApiPath = writeAgentsMyteApiGuide({ wrapperRoot, outputDir });
+  const topology = buildTopology(snapshot, {
+    mode: local?.mode,
+    found: local?.found,
+    missing: local?.missing,
+  });
+  const buildTopologyPath = path.join(dataRoot, "build-topology.yml");
+  const buildHarnessPath = path.join(targetRoot, "MyteBuildHarness.md");
+  writeYamlFile(buildTopologyPath, topology);
+  writeTextFile(buildHarnessPath, buildBuildHarnessMarkdown(topology));
 
   const manifest = {
     schema_version: snapshot.schema_version || 1,
@@ -4391,11 +4519,73 @@ function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir }) {
   };
   return {
     targetRoot,
-    dataRoot,
-    agentsMyteApiPath,
-    manifest,
-  };
-}
+    dataRoot,
+    agentsMyteApiPath,
+    buildTopologyPath,
+    buildHarnessPath,
+    topology,
+    manifest,
+  };
+}
+
+function packageUpdateCheckEnabled(args = {}) {
+  if (args["update-check"] === false) return false;
+  return process.env.MYTE_PACKAGE_UPDATE_CHECK !== "0";
+}
+
+function packageLatestUrl(args = {}) {
+  return String(
+    args["package-latest-url"] ||
+      process.env.MYTE_PACKAGE_LATEST_URL ||
+      DEFAULT_PACKAGE_LATEST_URL,
+  );
+}
+
+function packageUpdateTimeoutMs(args = {}) {
+  const value = Number(
+    args["package-update-timeout-ms"] ||
+      process.env.MYTE_PACKAGE_UPDATE_TIMEOUT_MS ||
+      1500,
+  );
+  return Number.isFinite(value) && value > 0 ? value : 1500;
+}
+
+async function checkMytePackageUpdate(args = {}) {
+  const fetchFn = await getFetch();
+  return checkPackageUpdate({
+    packageName: PACKAGE_NAME,
+    installedVersion: PACKAGE_VERSION,
+    latestUrl: packageLatestUrl(args),
+    enabled: packageUpdateCheckEnabled(args),
+    timeoutMs: packageUpdateTimeoutMs(args),
+    cacheDir: process.env.MYTE_PACKAGE_UPDATE_CACHE_DIR || undefined,
+    fetchJson: async (url, { timeoutMs } = {}) => {
+      const { resp, body } = await fetchJsonWithTimeout(
+        fetchFn,
+        url,
+        { method: "GET", headers: { Accept: "application/json" } },
+        timeoutMs,
+      );
+      return { ok: Boolean(resp.ok), status: resp.status, body };
+    },
+  });
+}
+
+async function runWithPackageUpdateNotice(args, run) {
+  const updatePromise = checkMytePackageUpdate(args).catch(() => null);
+  let completed = false;
+  try {
+    const result = await run();
+    completed = true;
+    return result;
+  } finally {
+    if (completed && !process.exitCode) {
+      const status = await updatePromise;
+      const notice = packageUpdateNotice(status);
+      if (notice) console.error(`[myte] ${notice}`);
+    }
+  }
+}
 
 function writeQaqcSnapshot({ snapshot, wrapperRoot, outputDir }) {
   const { targetRoot, dataRoot } = resolveCommandCenterRoots(wrapperRoot, outputDir);
@@ -5541,14 +5731,14 @@ async function runCreatePrd(args) {
     console.error("--document-set requires one to three markdown file paths; --stdin is not supported.");
     process.exit(1);
   }
-  if (documentSetMode && (providedPaths.length < 1 || providedPaths.length > 3)) {
+  if (documentSetMode && (providedPaths.length < 1 || providedPaths.length > 3)) {
     console.error("--document-set requires between one and three markdown file paths.");
     process.exit(1);
-  }
-  if (!documentSetMode && providedPaths.length > 20) {
-    console.error("create-prd accepts at most 20 files per batch.");
-    process.exit(1);
-  }
+  }
+  if (!documentSetMode && providedPaths.length > 20) {
+    console.error("create-prd accepts at most 20 files per batch.");
+    process.exit(1);
+  }
 
   const buildCreatePrdPayload = ({ sourceText, filePath, includeClientRef = false }) => {
     const trimmedSource = String(sourceText || "").trim();
@@ -6195,12 +6385,15 @@ async function runConfig(args) {
   const apiBase = normalizeApiBase(baseRaw);
 
   let cfg;
-  try {
-    cfg = await fetchProjectConfig({ apiBase, key, timeoutMs });
-  } catch (err) {
-    console.error("Failed to fetch config:", err?.message || err);
-    process.exit(1);
-  }
+  try {
+    cfg = await fetchProjectConfig({ apiBase, key, timeoutMs });
+  } catch (err) {
+    console.error("Failed to fetch config:", err?.message || err);
+    // Let Node drain its native fetch handles instead of forcing libuv closed.
+    // Immediate process.exit() can abort on Windows after an HTTP error.
+    process.exitCode = 1;
+    return;
+  }
 
   const repoNames = Array.isArray(cfg.repo_names) ? cfg.repo_names : [];
   const repoBindings = Array.isArray(cfg.repo_bindings) ? cfg.repo_bindings : [];
@@ -6239,7 +6432,7 @@ async function runConfig(args) {
   }
 }
 
-async function runBootstrap(args) {
+async function runBootstrap(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
     console.error("Missing MYTE_API_KEY (project key) in environment/.env");
@@ -6327,9 +6520,38 @@ async function runBootstrap(args) {
     return;
   }
 
-  const writeResult = writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir });
-  summary.data_root = writeResult.dataRoot;
-  summary.agents_myte_api_path = writeResult.agentsMyteApiPath;
+  const writeResult = writeBootstrapSnapshot({
+    snapshot,
+    wrapperRoot,
+    outputDir,
+    local: {
+      mode: resolved.mode,
+      found: (resolved.repos || []).map((repo) => repo.name),
+      missing: resolved.missing || [],
+    },
+  });
+  summary.data_root = writeResult.dataRoot;
+  summary.agents_myte_api_path = writeResult.agentsMyteApiPath;
+  summary.build_harness_path = writeResult.buildHarnessPath;
+  summary.build_topology_path = writeResult.buildTopologyPath;
+  const topologyWarnings = [];
+  if (writeResult.topology.intent.source === "mission_snapshot_only") {
+    topologyWarnings.push("API intent topology was not returned; workflow grouping is fallback-only");
+  }
+  if (!writeResult.topology.intent.workflows.length) {
+    topologyWarnings.push("No explicit workflows were returned; validate workflow boundaries from features and entities");
+  }
+  if (writeResult.topology.mission_groups.some((group) => group.source === "fallback")) {
+    topologyWarnings.push("One or more mission groups use fallback metadata and require semantic review");
+  }
+  summary.topology = {
+    intent_source: writeResult.topology.intent.source,
+    workflow_count: writeResult.topology.intent.workflows.length,
+    feature_count: writeResult.topology.intent.features.length,
+    entity_count: writeResult.topology.intent.entity_graph.entities.length,
+    relationship_count: writeResult.topology.intent.entity_graph.relationships.length,
+    warnings: topologyWarnings,
+  };
 
   if (includeSuggestions) {
     let missionOpsSnapshot;
@@ -6364,16 +6586,103 @@ 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.agents_myte_api_path) console.log(`Wrote AgentsMyteAPI: ${summary.agents_myte_api_path}`);
+  if (summary.agents_myte_api_path) console.log(`Wrote AgentsMyteAPI: ${summary.agents_myte_api_path}`);
+  if (summary.build_harness_path) console.log(`Wrote MyteBuildHarness: ${summary.build_harness_path}`);
+  if (summary.build_topology_path) console.log(`Wrote build topology: ${summary.build_topology_path}`);
   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"}`);
-}
-
-async function runSyncQaqc(args) {
+  console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
+}
+
+function resolveLocalEvidencePath(candidate, fallback, outputRoot) {
+  const value = candidate ? path.resolve(process.cwd(), String(candidate)) : path.join(outputRoot, fallback);
+  return value;
+}
+
+function readEvidenceFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const text = fs.readFileSync(filePath, "utf8").trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch (_) {
+    try {
+      return parseYaml(text);
+    } catch (_) {
+      return { raw: text };
+    }
+  }
+}
+
+async function runBuildVerify(args) {
+  const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
+  const outputRoot = path.resolve(process.cwd(), String(outputDir || "MyteCommandCenter"));
+  const dataRoot = path.join(outputRoot, "data");
+  const topologyPath = path.join(dataRoot, "build-topology.yml");
+  const harnessPath = path.join(outputRoot, "MyteBuildHarness.md");
+  const topology = readEvidenceFile(topologyPath);
+  const missionOps = readEvidenceFile(path.join(dataRoot, "mission-ops.yml"));
+  const qaqc = readEvidenceFile(resolveLocalEvidencePath(args["qaqc-file"] || args.qaqcFile, path.join("data", "qaqc.yml"), outputRoot));
+  const semanticReviewPath = resolveLocalEvidencePath(args["semantic-review-file"] || args.semanticReviewFile, "build-evidence/semantic-review.md", outputRoot);
+  const repositoryGatesPath = resolveLocalEvidencePath(args["repository-gates-file"] || args.repositoryGatesFile, "build-evidence/repository-gates.yml", outputRoot);
+  const semanticReview = Boolean(readEvidenceFile(semanticReviewPath));
+  const repositoryGates = Boolean(readEvidenceFile(repositoryGatesPath));
+  const qaqcEvidence = Boolean(qaqc);
+  const qaqcCoverage = topology ? qaqcMissionCoverage(topology, qaqc) : null;
+
+  const result = {
+    ok: false,
+    output_root: outputRoot,
+    topology_path: topologyPath,
+    harness_path: harnessPath,
+    evidence: {
+      semantic_review: { path: semanticReviewPath, present: semanticReview },
+      repository_gates: { path: repositoryGatesPath, present: repositoryGates },
+      qaqc: {
+        path: resolveLocalEvidencePath(args["qaqc-file"] || args.qaqcFile, path.join("data", "qaqc.yml"), outputRoot),
+        present: qaqcEvidence,
+        coverage: qaqcCoverage,
+      },
+    },
+    errors: [],
+    warnings: [],
+  };
+  if (!topology) result.errors.push(`missing ${topologyPath}`);
+  if (!fs.existsSync(harnessPath)) result.errors.push(`missing ${harnessPath}`);
+  if (topology) {
+    const topologyResult = verifyTopology(topology, { semanticReview, repositoryGates, qaqcEvidence, qaqcCoverage });
+    result.errors.push(...topologyResult.errors);
+    result.warnings.push(...topologyResult.warnings);
+    const statusCounts = topology.mission_coverage?.status_counts || {};
+    const totalMissions = Number(topology.mission_coverage?.active_missions || 0);
+    const done = Object.entries(statusCounts)
+      .filter(([status]) => status.trim().toLowerCase() === "done")
+      .reduce((sum, [, count]) => sum + Number(count || 0), 0);
+    const incomplete = Math.max(0, totalMissions - done);
+    result.completion = {
+      active_missions: totalMissions,
+      incomplete_missions: incomplete,
+      all_active_missions_done: incomplete === 0,
+    };
+    if (incomplete > 0) result.errors.push(`${incomplete} active mission(s) are not Done in the last bootstrap`);
+  }
+  const actionable = Number(missionOps?.sync?.counts?.actionable_threads || missionOps?.counts?.actionable_threads || 0);
+  result.mission_ops = { actionable_threads: actionable };
+  if (actionable > 0) result.errors.push(`${actionable} actionable mission-operation thread(s) remain`);
+  result.ok = result.errors.length === 0;
+  if (args.json) console.log(JSON.stringify(result, null, 2));
+  else {
+    console.log(`Build verification: ${result.ok ? "passed" : "failed"}`);
+    if (result.errors.length) console.log(`Errors: ${result.errors.join("; ")}`);
+    if (result.warnings.length) console.log(`Warnings: ${result.warnings.join("; ")}`);
+  }
+  if (!result.ok) process.exitCode = 1;
+}
+
+async function runSyncQaqc(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
     console.error("Missing MYTE_API_KEY (project key) in environment/.env");
@@ -7710,6 +8019,213 @@ async function runFeedbackGetOrHistory(args, mode) {
   console.log(`Snapshot: ${feedback.snapshot_hash || "n/a"}`);
 }
 
+async function runFeedbackTickets(args) {
+  const key = getProjectApiKey();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+  const action = String(firstNonEmptyString(args._?.[1], "list")).trim().toLowerCase().replace(/_/g, "-");
+  const feedbackId = resolveFeedbackIdArg(args);
+  if (!feedbackId) {
+    console.error("Missing --feedback-id.");
+    process.exit(1);
+  }
+  const apiBase = resolveApiBase(args);
+  const timeoutMs = resolveTimeoutMs(args);
+  const clientSessionId = firstNonEmptyString(args["client-session-id"], args.clientSessionId, args.client_session_id);
+  const dryRun = Boolean(args["dry-run"] || args.dryRun || action.startsWith("validate-"));
+
+  const call = async (requestOptions) => requestFeedbackTickets({
+    apiBase,
+    key,
+    timeoutMs,
+    feedbackId,
+    clientSessionId,
+    ...requestOptions,
+  });
+  const print = (data) => {
+    if (args.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    const tickets = Array.isArray(data?.tickets) ? data.tickets : [];
+    if (tickets.length) {
+      console.log(`Tickets: ${tickets.length}`);
+      for (const ticket of tickets) {
+        console.log(`- ${ticket.ticket_id || ticket._id || "(unknown)"} r${ticket.revision ?? "?"} ${ticket.status || "unknown"} ${ticket.severity || ""} ${ticket.title || ""}`.trim());
+      }
+      return;
+    }
+    console.log(JSON.stringify(data, null, 2));
+  };
+
+  try {
+    if (action === "list") {
+      print(await call({ method: "GET" }));
+      return;
+    }
+
+    const filePath = firstNonEmptyString(args.file);
+    let rawPayload = filePath ? readStructuredPayloadFile(filePath, "Feedback ticket") : null;
+
+    if (["create", "validate-create"].includes(action)) {
+      if (!rawPayload) {
+        console.error("Missing --file with a JSON/YAML ticket payload.");
+        process.exit(1);
+      }
+      const isBatch = Array.isArray(rawPayload) || (isPlainObject(rawPayload) && Array.isArray(rawPayload.items));
+      let payload = isBatch ? normalizeItemsPayload(rawPayload, "Feedback ticket create") : { ...rawPayload };
+      if (dryRun) {
+        const validationPayload = isBatch ? payload : {
+          items: [{
+            ...payload,
+            ticket_key: firstNonEmptyString(payload.ticket_key, args["ticket-key"], `validate-${projectWritePayloadHash(payload).slice(0, 24)}`),
+          }],
+        };
+        print(await call({ endpoint: "batch/validate", method: "POST", payload: validationPayload }));
+        return;
+      }
+      const itemCount = isBatch ? payload.items.length : 1;
+      const targets = isBatch
+        ? [feedbackId, ...payload.items.map((item) => firstNonEmptyString(item?.ticket_key)).filter(Boolean)]
+        : [feedbackId];
+      payload = withWriteApproval(args, payload, {
+        artifactKind: "yaml",
+        targets,
+        batchCount: isBatch ? itemCount : null,
+      });
+      const idempotencyKey = resolveProjectMutationIdempotencyKey({
+        args,
+        operation: `feedback_ticket_${isBatch ? "batch_" : ""}create:${feedbackId}`,
+        payload,
+      });
+      print(await call({
+        endpoint: isBatch ? "batch" : "",
+        method: "POST",
+        payload,
+        idempotencyKey,
+      }));
+      return;
+    }
+
+    if (["update", "validate-update"].includes(action)) {
+      const ticketIds = parseFeedbackTicketIdsArg(args);
+      let payload;
+      if (rawPayload) {
+        payload = Array.isArray(rawPayload) ? { items: rawPayload } : { ...rawPayload };
+      } else {
+        if (!ticketIds.length) {
+          console.error("Missing --file or --ticket-ids for ticket update.");
+          process.exit(1);
+        }
+        const updates = {};
+        for (const field of ["status", "severity"]) {
+          const value = firstNonEmptyString(args[field]);
+          if (value) updates[field] = value;
+        }
+        const assignedUserId = firstNonEmptyString(args["assigned-user-id"], args.assignedUserId, args.assigned_user_id);
+        if (assignedUserId) updates.assigned_user_id = assignedUserId;
+        if (!Object.keys(updates).length) {
+          console.error("Missing ticket update fields. Use --status, --severity, --assigned-user-id, or --file.");
+          process.exit(1);
+        }
+        const current = await call({ method: "GET" });
+        const currentById = new Map((current.tickets || []).map((ticket) => [String(ticket.ticket_id || ticket._id), ticket]));
+        const missing = ticketIds.filter((ticketId) => !currentById.has(String(ticketId)));
+        if (missing.length) throw new Error(`Feedback ticket ids were not found: ${missing.join(", ")}`);
+        payload = {
+          items: ticketIds.map((ticketId) => ({
+            ticket_id: ticketId,
+            expected_revision: Number(currentById.get(String(ticketId)).revision),
+            updates,
+          })),
+        };
+      }
+      const isBatch = Array.isArray(payload.items) || Array.isArray(payload.ticket_ids);
+      if (dryRun) {
+        const validationPayload = isBatch ? payload : {
+          items: [{
+            ticket_id: firstNonEmptyString(args["ticket-id"], args.ticketId, args.ticket_id, payload.ticket_id),
+            expected_revision: payload.expected_revision,
+            updates: payload.updates || Object.fromEntries(Object.entries(payload).filter(([key]) => ["title", "summary", "severity", "status", "assigned_user_id"].includes(key))),
+          }],
+        };
+        print(await call({ endpoint: "batch-update/validate", method: "POST", payload: validationPayload }));
+        return;
+      }
+      const itemCount = isBatch ? (payload.items || payload.ticket_ids || []).length : 1;
+      const targetTicketId = firstNonEmptyString(args["ticket-id"], args.ticketId, args.ticket_id, payload.ticket_id);
+      if (!isBatch && !targetTicketId) {
+        console.error("Missing --ticket-id for a single ticket update.");
+        process.exit(1);
+      }
+      const targetIds = isBatch
+        ? (payload.items || []).map((item) => item?.ticket_id).filter(Boolean).concat(payload.ticket_ids || [])
+        : [targetTicketId];
+      payload = withWriteApproval(args, payload, {
+        artifactKind: "yaml",
+        targets: [feedbackId, ...targetIds],
+        batchCount: isBatch ? itemCount : null,
+      });
+      const idempotencyKey = resolveProjectMutationIdempotencyKey({
+        args,
+        operation: `feedback_ticket_${isBatch ? "batch_" : ""}update:${feedbackId}:${targetIds.join(",")}`,
+        payload,
+      });
+      print(await call({
+        endpoint: isBatch ? "batch" : encodeURIComponent(targetTicketId),
+        method: "PATCH",
+        payload,
+        idempotencyKey,
+      }));
+      return;
+    }
+
+    if (action === "coverage") {
+      const ticketId = firstNonEmptyString(args["ticket-id"], args.ticketId, args.ticket_id);
+      if (!ticketId) {
+        console.error("Missing --ticket-id.");
+        process.exit(1);
+      }
+      let payload = rawPayload && isPlainObject(rawPayload) ? { ...rawPayload } : {
+        version_id: firstNonEmptyString(args["version-id"], args.versionId, args.version_id),
+        document_id: firstNonEmptyString(args["document-id"], args.documentId, args.document_id),
+        coverage_status: firstNonEmptyString(args["coverage-status"], args.coverageStatus, args.coverage_status),
+      };
+      if (payload.expected_revision === undefined) {
+        const current = await call({ method: "GET" });
+        const ticket = (current.tickets || []).find((item) => String(item.ticket_id || item._id) === String(ticketId));
+        if (!ticket) throw new Error(`Feedback ticket id was not found: ${ticketId}`);
+        payload.expected_revision = Number(ticket.revision);
+      }
+      if (dryRun) {
+        console.log(JSON.stringify({ valid: true, validate_only: true, ticket_id: ticketId, payload }, null, 2));
+        return;
+      }
+      payload = withWriteApproval(args, payload, { artifactKind: "yaml", targets: [feedbackId, ticketId] });
+      const idempotencyKey = resolveProjectMutationIdempotencyKey({
+        args,
+        operation: `feedback_ticket_coverage:${feedbackId}:${ticketId}`,
+        payload,
+      });
+      print(await call({ endpoint: `${encodeURIComponent(ticketId)}/prd-coverage`, method: "PATCH", payload, idempotencyKey }));
+      return;
+    }
+
+    console.error("Unknown feedback tickets command. Use list, create, validate-create, update, validate-update, or coverage.");
+    process.exit(1);
+  } catch (err) {
+    if (args.json) {
+      console.log(JSON.stringify({ ok: false, status: err?.status || null, message: err?.message || String(err), data: err?.data || null }, null, 2));
+    } else {
+      console.error("Feedback tickets failed:", err?.message || err);
+      if (err?.data) console.error(JSON.stringify(err.data, null, 2));
+    }
+    process.exit(1);
+  }
+}
+
 async function runFeedback(args) {
   const subcommand = firstNonEmptyString(args._?.[0]) || "help";
   if (subcommand === "help") {
@@ -7764,7 +8280,11 @@ async function runFeedback(args) {
     await runFeedbackGetOrHistory(args, subcommand);
     return;
   }
-  console.error("Unknown feedback command. Use status, edit, document-add, assign, archive, submit, revise, reviews, review, move, comment, undo, prd-versions, prd-diff, get, history, validate, or apply.");
+  if (subcommand === "tickets") {
+    await runFeedbackTickets(args);
+    return;
+  }
+  console.error("Unknown feedback command. Use status, edit, document-add, assign, archive, submit, revise, reviews, review, move, comment, tickets, undo, prd-versions, prd-diff, get, history, validate, or apply.");
   process.exit(1);
 }
 
@@ -7928,7 +8448,16 @@ async function resyncBootstrapAfterMissionMutation({ args, apiBase, key, timeout
   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 writeResult = writeBootstrapSnapshot({
+    snapshot,
+    wrapperRoot,
+    outputDir,
+    local: {
+      mode: resolved.mode,
+      found: (resolved.repos || []).map((repo) => repo.name),
+      missing: resolved.missing || [],
+    },
+  });
   const missionOpsSnapshot = await fetchSuggestionsSyncSnapshot({ apiBase, key, timeoutMs, actorScope });
   const missionOpsWrite = writeMissionOpsSnapshot({ snapshot: missionOpsSnapshot, wrapperRoot, outputDir });
   const missionOpsCounts = missionOpsWrite?.manifest?.sync?.counts || {};
@@ -8437,10 +8966,10 @@ async function runQuery(args) {
   };
   if (diffDiagnostics) payload.diff_diagnostics = diffDiagnostics;
 
-  if (printContext) {
-    console.log(JSON.stringify(payload, null, 2));
-    process.exit(0);
-  }
+  if (printContext) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
 
   let data;
   const requestId = queryRequestId(args);
@@ -8495,7 +9024,7 @@ async function runQuery(args) {
             initialDelayMs: Math.min(2_000, pollDelayMs),
           },
         );
-        pollDelayMs = Number(finalStatus?._nextPollAfterMs) || Math.min(10_000, Math.ceil(pollDelayMs * 1.25));
+        pollDelayMs = Number(finalStatus?._nextPollAfterMs) || Math.min(10_000, Math.ceil(pollDelayMs * 1.25));
         if (["completed", "failed"].includes(String(finalStatus.status || "").trim())) {
           break;
         }
@@ -8552,112 +9081,120 @@ async function runChat(args) {
   process.exit(1);
 }
 
-async function main() {
-  const envPath = loadEnv();
-
-  const { command, rest } = splitCommand(process.argv.slice(2));
-  if (REMOVED_COMMAND_MESSAGES[command]) {
-    console.error(REMOVED_COMMAND_MESSAGES[command]);
-    process.exit(1);
-  }
-  if (command === "mission") {
-    console.error("Unknown mission command. Use `myte mission status` or `myte mission archive`.");
-    process.exit(1);
-  }
-  const args = parseArgs(rest);
-  if (args.help || command === "help") {
-    printHelp();
-    return;
-  }
-
-  if (command === "version") {
-    await runVersion(args);
-    return;
-  }
-
-  if (command === "info") {
-    await runInfo(args, envPath);
-    return;
-  }
-
-  if (command === "doctor") {
-    await runDoctor(args, envPath);
-    return;
-  }
-
-  if (command === "config") {
-    await runConfig(args);
-    return;
-  }
-
-  if (command === "ai") {
-    await runAi(args);
-    return;
-  }
-
-  if (command === "bootstrap") {
-    await runBootstrap(args);
-    return;
-  }
-
-  if (command === "run-qaqc") {
-    await runRunQaqc(args);
-    return;
-  }
-
-  if (command === "mission-status") {
-    await runMissionStatus(args);
-    return;
-  }
-
-  if (command === "mission-archive") {
-    await runMissionArchiveCommand(args);
-    return;
-  }
-
-  if (command === "sync-qaqc" || command === "qaqc-sync") {
-    await runSyncQaqc(args);
-    return;
-  }
-
-  if (command === "feedback-sync") {
-    await runFeedbackSync(args);
-    return;
-  }
-
-  if (command === "feedback") {
-    await runFeedback(args);
-    return;
-  }
-
-  if (command === "suggestions") {
-    await runSuggestions(args);
-    return;
-  }
-
-  if (command === "create-prd") {
-    await runCreatePrd(args);
-    return;
-  }
-
-  if (command === "update-team") {
-    await runUpdateTeam(args);
-    return;
-  }
-
-  if (command === "update-owner") {
-    await runUpdateOwner(args);
-    return;
-  }
-
-  if (command === "update-client") {
-    await runUpdateClient(args);
-    return;
-  }
-
-  // query default
-  await runQuery(args);
-}
+async function dispatchCommand(command, args, envPath) {
+  if (command === "version") {
+    await runVersion(args);
+    return;
+  }
+
+  if (command === "info") {
+    await runInfo(args, envPath);
+    return;
+  }
+
+  if (command === "doctor") {
+    await runDoctor(args, envPath);
+    return;
+  }
+
+  if (command === "config") {
+    await runConfig(args);
+    return;
+  }
+
+  if (command === "ai") {
+    await runAi(args);
+    return;
+  }
+
+  if (command === "bootstrap") {
+    await runBootstrap(args);
+    return;
+  }
+  if (command === "build-verify") {
+    await runBuildVerify(args);
+    return;
+  }
+
+  if (command === "run-qaqc") {
+    await runRunQaqc(args);
+    return;
+  }
+
+  if (command === "mission-status") {
+    await runMissionStatus(args);
+    return;
+  }
+
+  if (command === "mission-archive") {
+    await runMissionArchiveCommand(args);
+    return;
+  }
+
+  if (command === "sync-qaqc" || command === "qaqc-sync") {
+    await runSyncQaqc(args);
+    return;
+  }
+
+  if (command === "feedback-sync") {
+    await runFeedbackSync(args);
+    return;
+  }
+
+  if (command === "feedback") {
+    await runFeedback(args);
+    return;
+  }
+
+  if (command === "suggestions") {
+    await runSuggestions(args);
+    return;
+  }
+
+  if (command === "create-prd") {
+    await runCreatePrd(args);
+    return;
+  }
+
+  if (command === "update-team") {
+    await runUpdateTeam(args);
+    return;
+  }
+
+  if (command === "update-owner") {
+    await runUpdateOwner(args);
+    return;
+  }
+
+  if (command === "update-client") {
+    await runUpdateClient(args);
+    return;
+  }
+
+  // query default
+  await runQuery(args);
+}
+
+async function main() {
+  const envPath = loadEnv();
+
+  const { command, rest } = splitCommand(process.argv.slice(2));
+  if (REMOVED_COMMAND_MESSAGES[command]) {
+    console.error(REMOVED_COMMAND_MESSAGES[command]);
+    process.exit(1);
+  }
+  if (command === "mission") {
+    console.error("Unknown mission command. Use `myte mission status` or `myte mission archive`.");
+    process.exit(1);
+  }
+  const args = parseArgs(rest);
+  if (args.help || command === "help") {
+    printHelp();
+    return;
+  }
+
+  await runWithPackageUpdateNotice(args, () => dispatchCommand(command, args, envPath));
+}
 
 if (require.main === module) {
   main().catch((err) => {
@@ -8684,8 +9221,8 @@ if (require.main === module) {
     resolveActorScope,
     main,
     scrubBootstrapValue,
-    scrubMissionOpsValue,
-    successfulPollDelayMs,
+    scrubMissionOpsValue,
+    successfulPollDelayMs,
     writeBootstrapSnapshot,
     writeFeedbackSnapshot,
     writeApprovedMissionCards,