@mytegroupinc/myte-core 0.0.16 → 0.0.18

package/README.md

@@ -7,6 +7,7 @@ Most users should install the unscoped wrapper instead:
 - `npm install myte` then `npx myte ai "Return a JSON object with risks and next_steps" --json-response`
 - `npm install myte` then `npx myte bootstrap`
 - `npm install myte` then `npx myte run-qaqc --mission-ids M001 --wait --sync`
+- `npm install myte` then `npx myte mission status --mission-ids M001 --status done`
 - `npm install myte` then `npx myte sync-qaqc`
 - `npm install myte` then `npx myte feedback-sync`
 - `npm install myte` then `npx myte suggestions sync`
@@ -20,6 +21,7 @@ Most users should install the unscoped wrapper instead:
 - `npm install myte` then `npx myte update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 - `npm i -g myte` then `myte bootstrap`
 - `npm i -g myte` then `myte run-qaqc --mission-ids M001 --wait --sync`
+- `npm i -g myte` then `myte mission status --mission-ids M001 --status done`
 - `npm i -g myte` then `myte sync-qaqc`
 - `npm i -g myte` then `myte feedback-sync`
 - `npm i -g myte` then `myte suggestions sync`
@@ -32,6 +34,7 @@ Most users should install the unscoped wrapper instead:
 - `npm i -g myte` then `myte update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 - `npx myte@latest bootstrap`
 - `npx myte@latest run-qaqc --mission-ids M001 --wait --sync`
+- `npx myte@latest mission status --mission-ids M001 --status done`
 - `npx myte@latest sync-qaqc`
 - `npx myte@latest feedback-sync`
 - `npx myte@latest suggestions sync`
@@ -68,6 +71,9 @@ Notes:
 - On PowerShell, quote comma-separated multi-id values: `--mission-ids "M001,M002"`.
 - `run-qaqc --wait` polls `/api/project-assistant/run-qaqc/<batch_id>` until the batch is terminal.
 - `run-qaqc --sync` refreshes `MyteCommandCenter/data/qaqc.yml` after a completed batch.
+- `mission status` updates one or many mission business ids through `/api/project-assistant/mission-status-update`.
+- `mission status` normalizes status aliases like `todo`, `in_progress`, and `done`, then sends the canonical mission status values `Todo`, `In Progress`, or `Done`.
+- `mission status` updates only the mission `status` field used by the app. It does not run QAQC and it does not rewrite `MyteCommandCenter/data/qaqc.yml`.
 - project-key QAQC runs through the dedicated `project_api_qaqc` queue inside the existing Celery service, with a global budget of `20` dispatch starts/minute and `20` live jobs.
 - a saturated `run-qaqc --wait` batch can take roughly `5-10` minutes before `--sync` has final data to write.
 - `sync-qaqc` works without `bootstrap`; it creates `MyteCommandCenter/data/qaqc.yml` automatically if missing.
@@ -76,6 +82,7 @@ Notes:
 - `sync-qaqc` keeps QAQC state in one deterministic file so the working set grows and shrinks with current active-mission reality.
 - `sync-qaqc` fully rewrites `MyteCommandCenter/data/qaqc.yml` on every sync and does not delete `MyteCommandCenter/data/missions/*.yml`.
 - `feedback-sync` writes one deterministic feedback snapshot under `MyteCommandCenter/data/feedback.yml`.
+- `feedback-sync` defaults to all non-archived feedback unless `--status` is provided.
 - `feedback-sync` keeps feedback metadata plus comment turns in `MyteCommandCenter/data/feedback.yml`.
 - `feedback-sync` writes full PRD context into `MyteCommandCenter/PRD/feedback-sync/*.md` and points to those files from `feedback.yml`.
 - `feedback-sync` fully replaces the feedback-owned sync file to avoid stale local feedback noise.
@@ -122,6 +129,7 @@ Examples:
 - `npx myte ai "Return a JSON object with risks and next_steps" --json-response`
 - `npx myte bootstrap`
 - `npx myte run-qaqc --mission-ids "M001,M002" --wait --sync`
+- `npx myte mission status --mission-ids "M001,M002" --status done`
 - `npx myte sync-qaqc`
 - `npx myte feedback-sync`
 - `npx myte suggestions sync`
@@ -139,3 +147,5 @@ Examples:
 - `npx myte update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 
 This package is published under the org scope for governance; the public `myte` wrapper delegates here.
+
+`--json-response` sends both the Myte convenience flag (`myte_json_response: true`) and the OpenAI-compatible chat-completions shape (`response_format: { type: "json_object" }`). On the public developer API, that strict-JSON path also defaults to `medium` reasoning unless the caller explicitly overrides reasoning.

package/cli.js

@@ -28,6 +28,7 @@ const REMOVED_COMMAND_MESSAGES = {
   "create-prds": "The `create-prds` alias has been removed. Use `myte create-prd <file.md> [more.md ...]`.",
   "add-prd": "The `add-prd` alias has been removed. Use `myte create-prd <file.md> [more.md ...]`.",
   prd: "The `prd` alias has been removed. Use `myte create-prd <file.md> [more.md ...]`.",
+  "qaqc-status-update": "The `qaqc-status-update` command has been removed. Use `myte mission status --mission-ids \"M001,M002\" --status todo|in_progress|done`.",
 };
 
 function findEnvPath(startDir) {
@@ -66,6 +67,16 @@ function loadEnv() {
 }
 
 function splitCommand(argv) {
+  if (argv[0] === "mission") {
+    if (argv[1] === "status" && argv[2] === "update") {
+      return { command: "mission-status", rest: argv.slice(3) };
+    }
+    if (argv[1] === "status") {
+      return { command: "mission-status", rest: argv.slice(2) };
+    }
+    return { command: "mission", rest: argv.slice(1) };
+  }
+
   const known = new Set([
     "query",
     "ai",
@@ -75,6 +86,8 @@ function splitCommand(argv) {
     "bootstrap",
     "suggestions",
     "run-qaqc",
+    "qaqc-status-update",
+    "mission",
     "sync-qaqc",
     "qaqc-sync",
     "create-prd",
@@ -189,6 +202,7 @@ function printHelp() {
     "  myte config [--json]",
     "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
     "  myte run-qaqc --mission-ids \"M001[,M002...]\" [--wait] [--sync] [--force] [--json]",
+    "  myte mission status --mission-ids \"M001[,M002...]\" --status todo|in_progress|done [--json]",
     "  myte sync-qaqc [--output-dir ./MyteCommandCenter] [--json]",
     "  myte suggestions sync [--output-dir ./MyteCommandCenter] [--json]",
     "  myte suggestions create [--file ./payload.yml] [--no-sync] [--json]",
@@ -197,7 +211,7 @@ function printHelp() {
     "  myte update-team \"<content>\" [--json]",
     "  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 Pending] [--source User] [--output-dir ./MyteCommandCenter] [--json]",
+    "  myte feedback-sync [--status <value>] [--source <value>] [--with-prd-text|--no-with-prd-text] [--output-dir ./MyteCommandCenter] [--json]",
     "  myte create-prd <file.md> [more.md ...] [--json] [--title \"...\"] [--description \"...\"]",
     "  cat file.md | myte create-prd --stdin [--title \"...\"] [--description \"...\"]",
     "  cat update.md | myte update-owner --stdin --subject \"Owner update\"",
@@ -241,6 +255,12 @@ function printHelp() {
     "  - Use --wait to poll batch status and --sync to refresh MyteCommandCenter/data/qaqc.yml after completion",
     "  - On PowerShell, quote comma-separated mission ids: --mission-ids \"M001,M002\"",
     "",
+    "mission status contract:",
+    "  - Updates the same mission `status` field used by the product board through /api/project-assistant/mission-status-update",
+    "  - 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",
+    "",
     "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",
@@ -266,7 +286,8 @@ function printHelp() {
     "",
     "feedback-sync contract:",
     "  - Runs from the wrapper root that contains the project's configured repo folders",
-    "  - Writes open project feedback metadata and conversation turns into MyteCommandCenter/data/feedback.yml",
+    "  - Syncs all non-archived feedback by default; use --status only when you want a narrower slice",
+    "  - 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",
     "",
     "Options:",
@@ -275,7 +296,7 @@ function printHelp() {
     "  --timeout-ms <ms>     Request timeout (default: 300000)",
     "  --base-url <url>      API base (default: https://api.myte.dev)",
     "  --payload-file <path> Raw OpenAI-style chat-completions payload for `myte ai`",
-    "  --json-response       Ask the Myte AI gateway to return clean JSON only",
+    "  --json-response       Ask the Myte AI gateway to return clean JSON only and send OpenAI-compatible response_format",
     "  --max-output-tokens   Output token cap for `myte ai` simple queries",
     "  --temperature <num>   Temperature for `myte ai` simple queries",
     "  --output-dir <path>   Command Center output directory (default: <wrapper-root>/MyteCommandCenter)",
@@ -289,10 +310,11 @@ function printHelp() {
     "  --body-file <path>    Read update-owner or update-client markdown body from a file",
     "  --target-contact-id   Add one client contact ObjectId (repeatable)",
     "  --target-contact-ids  Comma-separated client contact ObjectIds",
-    "  --status <value>      Feedback status filter for feedback-sync (default: Pending)",
+    "  --status <value>      For mission status: required target status (todo|in_progress|done). For feedback-sync: optional filter.",
     "  --source <value>      Feedback source filter for feedback-sync",
-    "  --with-prd-text       Include extracted PRD text so local PRD files can be materialized during feedback-sync (default: on)",
-    "  --mission-ids <ids>   Comma-separated mission business ids for run-qaqc (quote multi-id values on PowerShell)",
+    "  --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)",
     "  --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",
@@ -311,12 +333,13 @@ function printHelp() {
     "  myte suggestions revise --no-sync",
     "  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 bootstrap --output-dir ./MyteCommandCenter",
     "  myte sync-qaqc",
     "  myte update-team \"Backend deploy completed; QAQC rerun queued.\"",
     "  myte update-owner --subject \"QAQC progress\" --body-file ./updates/owner.md",
     "  myte update-client --subject \"Weekly client update\" --body-file ./updates/week-12.md",
-    "  myte feedback-sync --status Pending --source User",
+    "  myte feedback-sync --json",
     "  myte suggestions create --file ./suggestions/create.yml",
     "  myte suggestions revise",
     "  myte suggestions review",
@@ -397,6 +420,16 @@ function dedupeStrings(values) {
   return unique;
 }
 
+function normalizeMissionStatusInput(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  const compact = raw.replace(/[\s_-]+/g, "").toLowerCase();
+  if (compact === "todo" || compact === "pending") return "Todo";
+  if (compact === "inprogress" || compact === "doing") return "In Progress";
+  if (compact === "done" || compact === "complete" || compact === "completed") return "Done";
+  return "";
+}
+
 function resolveTimeoutMs(args) {
   const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
   const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
@@ -1067,9 +1100,15 @@ async function fetchQaqcSyncSnapshot({ apiBase, key, timeoutMs }) {
   );
 
   if (!resp.ok || body.status !== "success") {
+    const retryAfter = resp.headers?.get?.("retry-after");
     const msg = body?.message || `QAQC sync request failed (${resp.status})`;
-    const err = new Error(msg);
+    const err = new Error(
+      retryAfter
+        ? `${msg} Retry after ${retryAfter}s.`
+        : msg
+    );
     err.status = resp.status;
+    if (retryAfter) err.retryAfter = retryAfter;
     throw err;
   }
   return body.data || {};
@@ -1213,6 +1252,34 @@ async function createRunQaqcBatch({ apiBase, key, timeoutMs, payload, idempotenc
   return body.data || {};
 }
 
+async function createMissionStatusUpdate({ apiBase, key, timeoutMs, payload, idempotencyKey, clientSessionId }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/mission-status-update`;
+  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 status update 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 || ""))}`;
@@ -1227,15 +1294,30 @@ async function fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId }) {
   );
 
   if (!resp.ok || body.status !== "success") {
+    const retryAfter = resp.headers?.get?.("retry-after");
     const msg = body?.message || `Run QAQC status request failed (${resp.status})`;
-    const err = new Error(msg);
+    const err = new Error(
+      retryAfter
+        ? `${msg} Retry after ${retryAfter}s.`
+        : msg
+    );
     err.status = resp.status;
+    if (retryAfter) err.retryAfter = retryAfter;
     throw err;
   }
   return body.data || {};
 }
 
-async function callAssistantQuery({ apiBase, key, payload, timeoutMs, endpoint = "/project-assistant/query" }) {
+function resolveRetryAfterMs(err, fallbackMs = 5_000) {
+  const retryAfterRaw = firstNonEmptyString(err?.retryAfter);
+  const retryAfterSeconds = Number.parseInt(String(retryAfterRaw || ""), 10);
+  if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) {
+    return Math.min(retryAfterSeconds * 1_000, 60_000);
+  }
+  return fallbackMs;
+}
+
+async function createAssistantQueryJob({ apiBase, key, payload, timeoutMs, endpoint = "/project-assistant/query" }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}${endpoint}`;
   const { resp, body } = await fetchJsonWithTimeout(
@@ -1253,9 +1335,35 @@ async function callAssistantQuery({ apiBase, key, payload, timeoutMs, endpoint =
   );
 
   if (!resp.ok || body.status !== "success") {
+    const retryAfter = resp.headers?.get?.("retry-after");
     const msg = body?.message || `Query failed (${resp.status})`;
-    const err = new Error(msg);
+    const err = new Error(retryAfter ? `${msg} Retry after ${retryAfter}s.` : msg);
+    err.status = resp.status;
+    if (retryAfter) err.retryAfter = retryAfter;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function fetchAssistantQueryJobStatus({ apiBase, key, timeoutMs, jobId }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/query/${encodeURIComponent(String(jobId || ""))}`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const retryAfter = resp.headers?.get?.("retry-after");
+    const msg = body?.message || `Query status request failed (${resp.status})`;
+    const err = new Error(retryAfter ? `${msg} Retry after ${retryAfter}s.` : msg);
     err.status = resp.status;
+    if (retryAfter) err.retryAfter = retryAfter;
     throw err;
   }
   return body.data || {};
@@ -1326,6 +1434,10 @@ async function runRunQaqc(args) {
       try {
         finalStatus = await fetchRunQaqcBatchStatus({ apiBase, key, timeoutMs, batchId: data.batch_id });
       } catch (err) {
+        if (Number(err?.status) === 429) {
+          await sleep(resolveRetryAfterMs(err));
+          continue;
+        }
         console.error("Failed to fetch QAQC batch status:", err?.message || err);
         process.exit(1);
       }
@@ -1341,11 +1453,18 @@ async function runRunQaqc(args) {
 
     if (shouldSync && ["completed", "completed_with_errors"].includes(String(finalStatus.status || "").trim())) {
       let snapshot;
-      try {
-        snapshot = await fetchQaqcSyncSnapshot({ apiBase, key, timeoutMs });
-      } catch (err) {
-        console.error("Failed to fetch QAQC sync snapshot after batch completion:", err?.message || err);
-        process.exit(1);
+      for (let attempt = 0; attempt < 5; attempt += 1) {
+        try {
+          snapshot = await fetchQaqcSyncSnapshot({ apiBase, key, timeoutMs });
+          break;
+        } catch (err) {
+          if (Number(err?.status) === 429 && attempt < 4) {
+            await sleep(resolveRetryAfterMs(err));
+            continue;
+          }
+          console.error("Failed to fetch QAQC sync snapshot after batch completion:", err?.message || err);
+          process.exit(1);
+        }
       }
 
       let resolved;
@@ -1398,6 +1517,99 @@ async function runRunQaqc(args) {
   }
 }
 
+async function runMissionStatus(args) {
+  const key = getProjectApiKey();
+  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 mission status`.");
+    printHelp();
+    process.exit(1);
+  }
+
+  const newStatus = normalizeMissionStatusInput(firstNonEmptyString(args.status));
+  if (!newStatus) {
+    console.error("Missing or invalid --status for `myte mission status`. Use todo, in_progress, or done.");
+    printHelp();
+    process.exit(1);
+  }
+
+  const payload = {
+    mission_ids: missionIds,
+    new_status: newStatus,
+  };
+  const clientSessionId = firstNonEmptyString(args["client-session-id"], args.clientSessionId, args.client_session_id);
+  if (clientSessionId) payload.client_session_id = clientSessionId;
+  const idempotencyKey = resolveProjectMutationIdempotencyKey({
+    args,
+    operation: "mission-status-update",
+    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);
+
+  let data;
+  try {
+    data = await createMissionStatusUpdate({
+      apiBase,
+      key,
+      timeoutMs,
+      payload,
+      idempotencyKey,
+      clientSessionId,
+    });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      console.error(`Request timed out after ${timeoutMs}ms`);
+    } else {
+      console.error("Mission status update 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,
+    new_status: data.new_status || newStatus,
+    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(`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
@@ -1668,6 +1880,20 @@ function stableItemId(item, keys, fallback) {
   return fallback;
 }
 
+function bootstrapPathId(item, preferredKeys, fallbackKeys, fallback) {
+  return stableItemId(item, preferredKeys, stableItemId(item, fallbackKeys, fallback));
+}
+
+function bootstrapScopedPathId(item, preferredKeys, scopeKeys, fallbackKeys, fallback) {
+  const preferred = stableItemId(item, preferredKeys, "");
+  if (preferred) return preferred;
+  const fallbackId = stableItemId(item, fallbackKeys, fallback);
+  const scopeParts = (Array.isArray(scopeKeys) ? scopeKeys : [])
+    .map((key) => String(item?.[key] || "").trim())
+    .filter(Boolean);
+  return [...scopeParts, fallbackId].filter(Boolean).join("__") || fallbackId;
+}
+
 function stringifyYaml(value) {
   // eslint-disable-next-line global-require
   const YAML = require("yaml");
@@ -1889,20 +2115,42 @@ function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir }) {
   const missions = Array.isArray(snapshot.missions) ? snapshot.missions.map((item) => scrubBootstrapValue(item)) : [];
 
   phases.forEach((phase, index) => {
-    const phaseId = stableItemId(phase, ["phase_id", "id"], `P${String(index + 1).padStart(3, "0")}`);
-    writeYamlFile(path.join(phasesDir, `${phaseId}.yml`), phase);
+    const phasePathId = bootstrapPathId(
+      phase,
+      ["phase_key", "id"],
+      ["phase_id"],
+      `phase-${String(index + 1).padStart(3, "0")}`
+    );
+    writeYamlFile(path.join(phasesDir, `${phasePathId}.yml`), phase);
   });
   epics.forEach((epic, index) => {
-    const epicId = stableItemId(epic, ["epic_id", "id"], `E${String(index + 1).padStart(3, "0")}`);
-    writeYamlFile(path.join(epicsDir, `${epicId}.yml`), epic);
+    const epicPathId = bootstrapScopedPathId(
+      epic,
+      ["epic_key", "id"],
+      ["phase_key", "phase_id"],
+      ["epic_id"],
+      `epic-${String(index + 1).padStart(3, "0")}`
+    );
+    writeYamlFile(path.join(epicsDir, `${epicPathId}.yml`), epic);
   });
   stories.forEach((story, index) => {
-    const storyId = stableItemId(story, ["story_id", "id"], `S${String(index + 1).padStart(3, "0")}`);
-    writeYamlFile(path.join(storiesDir, `${storyId}.yml`), story);
+    const storyPathId = bootstrapScopedPathId(
+      story,
+      ["story_key", "id"],
+      ["phase_key", "phase_id", "epic_key", "epic_id"],
+      ["story_id"],
+      `story-${String(index + 1).padStart(3, "0")}`
+    );
+    writeYamlFile(path.join(storiesDir, `${storyPathId}.yml`), story);
   });
   missions.forEach((mission, index) => {
-    const missionId = stableItemId(mission, ["mission_id", "id"], `M${String(index + 1).padStart(3, "0")}`);
-    writeYamlFile(path.join(missionsDir, `${missionId}.yml`), mission);
+    const missionPathId = bootstrapPathId(
+      mission,
+      ["mission_key", "id"],
+      ["mission_id"],
+      `mission-${String(index + 1).padStart(3, "0")}`
+    );
+    writeYamlFile(path.join(missionsDir, `${missionPathId}.yml`), mission);
   });
 
   if (snapshot.project && typeof snapshot.project === "object") {
@@ -2204,6 +2452,24 @@ function shouldSyncSuggestionsAfterMutation(args) {
   return !rawArgs.includes("--no-sync");
 }
 
+function resolveBooleanFlag(args, dashedName, defaultValue) {
+  const rawArgs = Array.isArray(args?.__raw) ? args.__raw : [];
+  const enabledToken = `--${dashedName}`;
+  const disabledToken = `--no-${dashedName}`;
+
+  for (const token of rawArgs) {
+    if (token === disabledToken) return false;
+    if (token === enabledToken) return true;
+    if (token.startsWith(`${enabledToken}=`)) {
+      const rawValue = token.slice(enabledToken.length + 1).trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(rawValue)) return true;
+      if (["0", "false", "no", "off"].includes(rawValue)) return false;
+    }
+  }
+
+  return defaultValue;
+}
+
 function readMissionOpsWorkspace({ wrapperRoot, outputDir }) {
   const { targetRoot, dataRoot } = resolveCommandCenterRoots(wrapperRoot, outputDir);
   const missionOpsPath = path.join(dataRoot, "mission-ops.yml");
@@ -3108,13 +3374,9 @@ async function runFeedbackSync(args) {
 
   const timeoutMs = resolveTimeoutMs(args);
   const apiBase = resolveApiBase(args);
-  const includePrdText = args["with-prd-text"] !== undefined
-    ? Boolean(args["with-prd-text"])
-    : args.withPrdText !== undefined
-      ? Boolean(args.withPrdText)
-      : true;
+  const includePrdText = resolveBooleanFlag(args, "with-prd-text", true);
   const filters = {
-    status: firstNonEmptyString(args.status) || "Pending",
+    status: firstNonEmptyString(args.status) || "",
     source: firstNonEmptyString(args.source) || "",
     includePrdText,
     includeCommentTurns: true,
@@ -3815,7 +4077,46 @@ async function runQuery(args) {
 
   let data;
   try {
-    data = await callAssistantQuery({ apiBase, key, payload, timeoutMs });
+    const queued = await createAssistantQueryJob({ apiBase, key, payload, timeoutMs });
+    if (queued.answer) {
+      data = queued;
+    } else {
+      const jobId = firstNonEmptyString(queued.job_id, queued.id);
+      if (!jobId) {
+        throw new Error("Query job was accepted without a job_id.");
+      }
+      const pollTimeoutMs = Math.max(timeoutMs, 900_000);
+      const startedAt = Date.now();
+      let finalStatus = null;
+      do {
+        await sleep(2_000);
+        try {
+          finalStatus = await fetchAssistantQueryJobStatus({ apiBase, key, timeoutMs, jobId });
+        } catch (err) {
+          if (Number(err?.status) === 429) {
+            await sleep(resolveRetryAfterMs(err));
+            continue;
+          }
+          throw err;
+        }
+        if (["completed", "failed"].includes(String(finalStatus.status || "").trim())) {
+          break;
+        }
+      } while (Date.now() - startedAt < pollTimeoutMs);
+
+      if (!finalStatus || !["completed", "failed"].includes(String(finalStatus.status || "").trim())) {
+        throw new Error(`Timed out waiting for query job ${jobId}`);
+      }
+      if (String(finalStatus.status || "").trim() === "failed") {
+        const detail = firstNonEmptyString(finalStatus?.error?.message, finalStatus?.error?.code);
+        throw new Error(detail || `Query job ${jobId} failed`);
+      }
+      data = {
+        answer: finalStatus.answer,
+        context_blocks: finalStatus.context_blocks,
+        telemetry: finalStatus.telemetry,
+      };
+    }
   } catch (err) {
     if (err?.name === "AbortError") {
       console.error(`Request timed out after ${timeoutMs}ms`);
@@ -3847,6 +4148,10 @@ async function main() {
     console.error(REMOVED_COMMAND_MESSAGES[command]);
     process.exit(1);
   }
+  if (command === "mission") {
+    console.error("Unknown mission command. Use `myte mission status --mission-ids \"M001,M002\" --status todo|in_progress|done`.");
+    process.exit(1);
+  }
   const args = parseArgs(rest);
   if (args.help || command === "help") {
     printHelp();
@@ -3873,6 +4178,11 @@ async function main() {
     return;
   }
 
+  if (command === "mission-status") {
+    await runMissionStatus(args);
+    return;
+  }
+
   if (command === "sync-qaqc" || command === "qaqc-sync") {
     await runSyncQaqc(args);
     return;

package/lib/ai-gateway.js

@@ -16,7 +16,10 @@ function buildSimpleAiPayload({ query, jsonResponse = false, maxOutputTokens, te
   const payload = {
     messages: [{ role: "user", content: String(query || "").trim() }],
   };
-  if (jsonResponse) payload.myte_json_response = true;
+  if (jsonResponse) {
+    payload.myte_json_response = true;
+    payload.response_format = { type: "json_object" };
+  }
   if (Number.isFinite(Number(maxOutputTokens)) && Number(maxOutputTokens) > 0) {
     payload.max_tokens = Number(maxOutputTokens);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Myte CLI core implementation (Project Assistant + Myte AI gateway).",
   "type": "commonjs",
   "main": "cli.js",