@mytegroupinc/myte-core 0.0.4 → 0.0.6

package/README.md

@@ -3,9 +3,15 @@
 Internal implementation package for the `myte` CLI.
 
 Most users should install the unscoped wrapper instead:
+- `npm install myte` then `npx myte bootstrap`
+- `npm install myte` then `npx myte sync-qaqc`
 - `npm install myte` then `npx myte query "..." --with-diff`
 - `npm install myte` then `npm exec myte -- query "..." --with-diff`
+- `npm i -g myte` then `myte bootstrap`
+- `npm i -g myte` then `myte sync-qaqc`
 - `npm i -g myte` then `myte query "..." --with-diff`
+- `npx myte@latest bootstrap`
+- `npx myte@latest sync-qaqc`
 - `npx myte@latest query "..." --with-diff`
 - `npm install myte` then `npx myte create-prd ./drafts/auth-prd.md`
 - `cat ./drafts/auth-prd.md | npx myte create-prd --stdin`
@@ -20,6 +26,15 @@ Requirements:
 Notes:
 - `npm install myte` installs the wrapper locally; use `npx myte` or `npm exec myte -- ...` to run it.
 - `npm install myte` means the CLI is available locally; bare `myte ...` still requires a global install.
+- `bootstrap` is a local file materialization path, not a hosted file download.
+- `bootstrap` expects to run from a wrapper root that contains the project's configured repo folders.
+- `bootstrap` writes `MyteCommandCenter/data/phases`, `epics`, `stories`, `missions`, `project.yml`, and `bootstrap-manifest.json`.
+- `bootstrap` materializes a public Command Center DTO, not raw backend documents.
+- `bootstrap` excludes internal keys like `_id`, `org_id`, `project_id`, `created_by`, `assigned_to`, and raw `qa_qc_results`.
+- `sync-qaqc` works without `bootstrap`; it creates `MyteCommandCenter/data/qaqc` automatically if missing.
+- `sync-qaqc` writes active mission QAQC cards to `MyteCommandCenter/data/qaqc/active-missions` and refreshes matching `MyteCommandCenter/data/missions` cards.
+- `sync-qaqc` only exports active `Todo` / `In Progress` missions plus a public QAQC summary and sanitized latest batch metadata.
+- `sync-qaqc` removes previously QAQC-managed mission files from `MyteCommandCenter/data/missions` once they leave the active set.
 - `create-prd` is a deterministic PRD upload path, not an LLM generation command.
 - `--with-diff` only searches repo folders whose names match the project repo names configured in Myte.
 - `--with-diff` includes per-repo diagnostics in `print-context` payload:
@@ -28,4 +43,20 @@ Notes:
   - clean/no-change repo summaries
 - `--with-diff` query payload includes `diff_diagnostics` so backend/UI can report exactly why context may be missing.
 
+Deterministic `create-prd` contract:
+- Required: `MYTE_API_KEY`, a PRD markdown body, and a title.
+- Title source: `myte-kanban.title`, the first markdown `# Heading`, or `--title`.
+- Description source: `myte-kanban.description` or `--description`.
+- The markdown body is stored verbatim as PRD content and is what the backend uses to build the PRD DOCX.
+- Legacy `feedback_text` is still accepted for older payloads, but new callers should use `description`.
+- Optional structured fields: `priority`, `status`, `tags`, `assigned_user_email`, `assigned_user_id`, `due_date`, `repo_name`, `repo_id`, `preview_url`, `source`.
+
+Examples:
+- `npx myte bootstrap`
+- `npx myte sync-qaqc`
+- `npx myte bootstrap --dry-run --json`
+- `npx myte sync-qaqc --dry-run --json`
+- `npx myte create-prd ./drafts/auth-prd.md --description "Short card summary"`
+- `npx myte create-prd ./drafts/auth-prd.md --print-context`
+
 This package is published under the org scope for governance; the public `myte` wrapper delegates here.

package/cli.js

@@ -49,7 +49,7 @@ function loadEnv() {
 }
 
 function splitCommand(argv) {
-  const known = new Set(["query", "ask", "chat", "config", "create-prd", "add-prd", "prd", "help", "--help", "-h"]);
+  const known = new Set(["query", "ask", "chat", "config", "bootstrap", "sync-qaqc", "qaqc-sync", "create-prd", "add-prd", "prd", "help", "--help", "-h"]);
   const first = argv[0];
   if (first && known.has(first)) {
     const cmd = first === "--help" || first === "-h" ? "help" : first;
@@ -63,7 +63,7 @@ function parseArgs(argv) {
     // eslint-disable-next-line global-require
     return require("minimist")(argv, {
       boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin"],
-      string: ["query", "q", "context", "ctx", "base-url", "timeout-ms", "diff-limit", "title"],
+      string: ["query", "q", "context", "ctx", "base-url", "timeout-ms", "diff-limit", "title", "description", "feedback-text", "output-dir"],
       alias: {
         q: "query",
         d: "with-diff",
@@ -116,10 +116,12 @@ function printHelp() {
     "Usage:",
     "  myte query \"<text>\" [--with-diff] [--context \"...\"]",
     "  myte config [--json]",
+    "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
+    "  myte sync-qaqc [--output-dir ./MyteCommandCenter] [--json]",
     "  myte chat",
-    "  myte create-prd <file.md> [--json]",
+    "  myte create-prd <file.md> [--json] [--title \"...\"] [--description \"...\"]",
     "  myte add-prd <file.md> [--json]",
-    "  cat file.md | myte create-prd --stdin [--title \"...\"]",
+    "  cat file.md | myte create-prd --stdin [--title \"...\"] [--description \"...\"]",
     "",
     "Run forms:",
     "  npm install myte   then npx myte query \"...\" --with-diff",
@@ -130,19 +132,41 @@ function printHelp() {
     "Auth:",
     "  - Set MYTE_API_KEY in a workspace .env (or env var)",
     "",
+    "bootstrap contract:",
+    "  - Run from the wrapper root that contains the project's configured repo folders",
+    "  - Writes MyteCommandCenter/data/phases, epics, stories, and missions locally",
+    "  - Uses the project-scoped bootstrap snapshot from the Myte API",
+    "",
+    "sync-qaqc contract:",
+    "  - Run from the wrapper root that contains the project's configured repo folders",
+    "  - Works even if bootstrap has not been run yet; it creates MyteCommandCenter/data/qaqc automatically",
+    "  - Writes active mission QAQC context under MyteCommandCenter/data/qaqc/active-missions",
+    "  - Refreshes matching MyteCommandCenter/data/missions cards for active missions only",
+    "",
+    "create-prd contract:",
+    "  - Required: valid MYTE_API_KEY, PRD markdown body, title",
+    "  - Title source: myte-kanban.title, first # heading, or --title",
+    "  - Description source: myte-kanban.description or --description",
+    "  - PRD DOCX content: the markdown body is stored verbatim",
+    "",
     "Options:",
     "  --with-diff           Include deterministic git diffs (project-scoped)",
     "  --diff-limit <chars>  Truncate diff context to N chars (default: 200000)",
     "  --timeout-ms <ms>     Request timeout (default: 300000)",
     "  --base-url <url>      API base (default: https://api.myte.dev)",
+    "  --output-dir <path>   Bootstrap output directory (default: <wrapper-root>/MyteCommandCenter)",
     "  --stdin               Read PRD content from stdin instead of a file path",
-    "  --title <text>        Required only when stdin/raw markdown has no H1 title",
+    "  --title <text>        Override PRD title for raw markdown uploads",
+    "  --description <text>  Set feedback description/card summary for raw markdown uploads",
     "  --print-context       Print JSON payload and exit (no query call)",
     "  --no-fetch            Don't git fetch origin main/master before diff",
     "",
     "Examples:",
     "  myte query \"What changed in logging?\" --with-diff",
-    "  myte create-prd ./drafts/auth-prd.md",
+    "  myte bootstrap",
+    "  myte bootstrap --output-dir ./MyteCommandCenter",
+    "  myte sync-qaqc",
+    "  myte create-prd ./drafts/auth-prd.md --description \"Short card summary\"",
     "  cat ./drafts/auth-prd.md | myte create-prd --stdin",
     "  myte config",
   ].join("\n");
@@ -695,6 +719,50 @@ async function fetchProjectConfig({ apiBase, key, timeoutMs }) {
   return body.data || {};
 }
 
+async function fetchBootstrapSnapshot({ apiBase, key, timeoutMs }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/bootstrap`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Bootstrap request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function fetchQaqcSyncSnapshot({ apiBase, key, timeoutMs }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/qaqc-sync`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `QAQC sync request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
 async function callAssistantQuery({ apiBase, key, payload, timeoutMs, endpoint = "/project-assistant/query" }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}${endpoint}`;
@@ -721,6 +789,221 @@ async function callAssistantQuery({ apiBase, key, payload, timeoutMs, endpoint =
   return body.data || {};
 }
 
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function clearYamlDirectory(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    return;
+  }
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.toLowerCase().endsWith(".yml")) continue;
+    fs.rmSync(path.join(dirPath, entry.name), { force: true });
+  }
+}
+
+function stableItemId(item, keys, fallback) {
+  for (const key of keys) {
+    const value = String(item?.[key] || "").trim();
+    if (value) return value;
+  }
+  return fallback;
+}
+
+function stringifyYaml(value) {
+  // eslint-disable-next-line global-require
+  const YAML = require("yaml");
+  return YAML.stringify(value, { lineWidth: 0 });
+}
+
+function writeYamlFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, stringifyYaml(value), "utf8");
+}
+
+function writeJsonFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+const BOOTSTRAP_FORBIDDEN_KEYS = new Set([
+  "_id",
+  "org_id",
+  "project_id",
+  "created_by",
+  "assigned_to",
+  "user_id",
+  "qa_qc_results",
+  "job_id",
+  "job_ids",
+  "celery_task_id",
+  "conversation_id",
+  "error",
+]);
+
+function scrubBootstrapValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => scrubBootstrapValue(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+
+  const cleaned = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (BOOTSTRAP_FORBIDDEN_KEYS.has(key)) continue;
+    cleaned[key] = scrubBootstrapValue(child);
+  }
+  return cleaned;
+}
+
+function resolveBootstrapWorkspace(repoNames) {
+  const resolved = resolveConfiguredRepos(repoNames);
+  if (!resolved.root || !Array.isArray(resolved.repos) || !resolved.repos.length) {
+    const names = Array.isArray(repoNames) ? repoNames.join(", ") : "";
+    throw new Error(
+      `No configured project repos were found from the current workspace. Expected child folders matching: ${names || "(none)"}`
+    );
+  }
+  return resolved;
+}
+
+function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir }) {
+  const targetRoot = outputDir
+    ? path.resolve(process.cwd(), String(outputDir))
+    : path.join(wrapperRoot, "MyteCommandCenter");
+  const dataRoot = path.join(targetRoot, "data");
+  const phasesDir = path.join(dataRoot, "phases");
+  const epicsDir = path.join(dataRoot, "epics");
+  const storiesDir = path.join(dataRoot, "stories");
+  const missionsDir = path.join(dataRoot, "missions");
+
+  ensureDir(dataRoot);
+  clearYamlDirectory(phasesDir);
+  clearYamlDirectory(epicsDir);
+  clearYamlDirectory(storiesDir);
+  clearYamlDirectory(missionsDir);
+
+  const phases = Array.isArray(snapshot.phases) ? snapshot.phases.map((item) => scrubBootstrapValue(item)) : [];
+  const epics = Array.isArray(snapshot.epics) ? snapshot.epics.map((item) => scrubBootstrapValue(item)) : [];
+  const stories = Array.isArray(snapshot.stories) ? snapshot.stories.map((item) => scrubBootstrapValue(item)) : [];
+  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);
+  });
+  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);
+  });
+  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);
+  });
+  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);
+  });
+
+  if (snapshot.project && typeof snapshot.project === "object") {
+    writeYamlFile(path.join(dataRoot, "project.yml"), scrubBootstrapValue(snapshot.project));
+  }
+
+  const manifest = {
+    schema_version: snapshot.schema_version || 1,
+    generated_at: snapshot.generated_at || null,
+    snapshot_hash: snapshot.snapshot_hash || null,
+    project: snapshot.project ? scrubBootstrapValue(snapshot.project) : null,
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    counts: {
+      phases: phases.length,
+      epics: epics.length,
+      stories: stories.length,
+      missions: missions.length,
+    },
+  };
+  writeJsonFile(path.join(dataRoot, "bootstrap-manifest.json"), manifest);
+
+  return {
+    targetRoot,
+    dataRoot,
+    manifest,
+  };
+}
+
+function writeQaqcSnapshot({ snapshot, wrapperRoot, outputDir }) {
+  const targetRoot = outputDir
+    ? path.resolve(process.cwd(), String(outputDir))
+    : path.join(wrapperRoot, "MyteCommandCenter");
+  const dataRoot = path.join(targetRoot, "data");
+  const missionsDir = path.join(dataRoot, "missions");
+  const qaqcRoot = path.join(dataRoot, "qaqc");
+  const activeMissionsDir = path.join(qaqcRoot, "active-missions");
+  const manifestPath = path.join(qaqcRoot, "manifest.json");
+
+  ensureDir(dataRoot);
+  ensureDir(missionsDir);
+  ensureDir(qaqcRoot);
+  const previousManifest = readJsonFile(manifestPath);
+  const previousMissionIds = Array.isArray(previousManifest?.active_mission_ids)
+    ? previousManifest.active_mission_ids.map((item) => String(item).trim()).filter(Boolean)
+    : [];
+  clearYamlDirectory(activeMissionsDir);
+
+  const missions = Array.isArray(snapshot.missions) ? snapshot.missions.map((item) => scrubBootstrapValue(item)) : [];
+  const currentMissionIds = [];
+
+  if (snapshot.project && typeof snapshot.project === "object") {
+    writeYamlFile(path.join(dataRoot, "project.yml"), scrubBootstrapValue(snapshot.project));
+  }
+
+  missions.forEach((mission, index) => {
+    const missionId = stableItemId(mission, ["mission_id", "id"], `M${String(index + 1).padStart(3, "0")}`);
+    currentMissionIds.push(missionId);
+    writeYamlFile(path.join(missionsDir, `${missionId}.yml`), mission);
+    writeYamlFile(path.join(activeMissionsDir, `${missionId}.yml`), mission);
+  });
+
+  const currentMissionIdSet = new Set(currentMissionIds);
+  previousMissionIds.forEach((missionId) => {
+    if (!missionId || currentMissionIdSet.has(missionId)) return;
+    fs.rmSync(path.join(missionsDir, `${missionId}.yml`), { force: true });
+  });
+
+  const manifest = {
+    schema_version: snapshot.schema_version || 1,
+    generated_at: snapshot.generated_at || null,
+    snapshot_hash: snapshot.snapshot_hash || null,
+    project: snapshot.project ? scrubBootstrapValue(snapshot.project) : null,
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    active_mission_ids: currentMissionIds,
+    counts: snapshot.counts && typeof snapshot.counts === "object" ? scrubBootstrapValue(snapshot.counts) : {
+      active_missions: missions.length,
+    },
+  };
+  writeJsonFile(manifestPath, manifest);
+  writeJsonFile(path.join(qaqcRoot, "latest-batch.json"), snapshot.latest_batch ? scrubBootstrapValue(snapshot.latest_batch) : null);
+
+  return {
+    targetRoot,
+    dataRoot,
+    manifest,
+  };
+}
+
 async function runCreatePrd(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
@@ -766,6 +1049,7 @@ async function runCreatePrd(args) {
   }
 
   const inferredTitle = String(args.title || extractMarkdownTitle(trimmedSource) || (!useStdin && filePath ? path.parse(filePath).name : "")).trim();
+  const description = String(args.description || args["feedback-text"] || args.feedbackText || "").trim();
   const payload = isMyteKanbanTicket(trimmedSource)
     ? {
         ticket_markdown: trimmedSource,
@@ -775,6 +1059,10 @@ async function runCreatePrd(args) {
         title: inferredTitle,
       };
 
+  if (!payload.ticket_markdown && description) {
+    payload.description = description;
+  }
+
   if (!payload.ticket_markdown && !payload.title) {
     console.error("A title is required when uploading raw markdown without a myte-kanban metadata block. Use --title or add a top-level # heading.");
     process.exit(1);
@@ -874,6 +1162,191 @@ async function runConfig(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");
+    process.exit(1);
+  }
+
+  const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
+  const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
+  const timeoutMs = Number.isFinite(timeoutParsed) ? timeoutParsed : 300_000;
+
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTE_API_BASE || DEFAULT_API_BASE;
+  const apiBase = normalizeApiBase(baseRaw);
+
+  let snapshot;
+  try {
+    snapshot = await fetchBootstrapSnapshot({ apiBase, key, timeoutMs });
+  } catch (err) {
+    console.error("Failed to fetch bootstrap snapshot:", err?.message || err);
+    process.exit(1);
+  }
+
+  if (args["print-context"] || args.printContext) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+
+  let resolved;
+  try {
+    resolved = resolveBootstrapWorkspace(snapshot.repo_names || []);
+  } catch (err) {
+    console.error(err?.message || err);
+    process.exit(1);
+  }
+
+  const wrapperRoot = resolved.root;
+  const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
+  const dryRun = Boolean(args["dry-run"] || args.dryRun);
+  const summary = {
+    api_base: apiBase,
+    project_id: snapshot?.project?.id || null,
+    wrapper_root: wrapperRoot,
+    output_root: outputDir ? path.resolve(process.cwd(), String(outputDir)) : path.join(wrapperRoot, "MyteCommandCenter"),
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    local: {
+      mode: resolved.mode,
+      found: (resolved.repos || []).map((repo) => repo.name),
+      missing: resolved.missing || [],
+    },
+    counts: {
+      phases: Array.isArray(snapshot.phases) ? snapshot.phases.length : 0,
+      epics: Array.isArray(snapshot.epics) ? snapshot.epics.length : 0,
+      stories: Array.isArray(snapshot.stories) ? snapshot.stories.length : 0,
+      missions: Array.isArray(snapshot.missions) ? snapshot.missions.length : 0,
+    },
+    snapshot_hash: snapshot.snapshot_hash || null,
+    generated_at: snapshot.generated_at || null,
+    dry_run: dryRun,
+  };
+
+  if (dryRun) {
+    if (args.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log(`Project: ${summary.project_id || "(unknown)"}`);
+      console.log(`Wrapper root: ${summary.wrapper_root}`);
+      console.log(`Output root: ${summary.output_root}`);
+      console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
+      console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
+      if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
+      console.log(`Counts: phases=${summary.counts.phases}, epics=${summary.counts.epics}, stories=${summary.counts.stories}, missions=${summary.counts.missions}`);
+      console.log("Dry run only - no files written.");
+    }
+    return;
+  }
+
+  const writeResult = writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir });
+  summary.data_root = writeResult.dataRoot;
+
+  if (args.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  console.log(`Project: ${summary.project_id || "(unknown)"}`);
+  console.log(`Wrapper root: ${summary.wrapper_root}`);
+  console.log(`Output root: ${summary.output_root}`);
+  console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
+  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}`);
+  console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
+}
+
+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");
+    process.exit(1);
+  }
+
+  const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
+  const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
+  const timeoutMs = Number.isFinite(timeoutParsed) ? timeoutParsed : 300_000;
+
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTE_API_BASE || DEFAULT_API_BASE;
+  const apiBase = normalizeApiBase(baseRaw);
+
+  let snapshot;
+  try {
+    snapshot = await fetchQaqcSyncSnapshot({ apiBase, key, timeoutMs });
+  } catch (err) {
+    console.error("Failed to fetch QAQC sync snapshot:", err?.message || err);
+    process.exit(1);
+  }
+
+  if (args["print-context"] || args.printContext) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+
+  let resolved;
+  try {
+    resolved = resolveBootstrapWorkspace(snapshot.repo_names || []);
+  } catch (err) {
+    console.error(err?.message || err);
+    process.exit(1);
+  }
+
+  const wrapperRoot = resolved.root;
+  const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
+  const dryRun = Boolean(args["dry-run"] || args.dryRun);
+  const summary = {
+    api_base: apiBase,
+    project_id: snapshot?.project?.id || null,
+    wrapper_root: wrapperRoot,
+    output_root: outputDir ? path.resolve(process.cwd(), String(outputDir)) : path.join(wrapperRoot, "MyteCommandCenter"),
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    local: {
+      mode: resolved.mode,
+      found: (resolved.repos || []).map((repo) => repo.name),
+      missing: resolved.missing || [],
+    },
+    counts: snapshot.counts && typeof snapshot.counts === "object" ? snapshot.counts : {
+      active_missions: Array.isArray(snapshot.missions) ? snapshot.missions.length : 0,
+    },
+    snapshot_hash: snapshot.snapshot_hash || null,
+    generated_at: snapshot.generated_at || null,
+    dry_run: dryRun,
+  };
+
+  if (dryRun) {
+    if (args.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log(`Project: ${summary.project_id || "(unknown)"}`);
+      console.log(`Wrapper root: ${summary.wrapper_root}`);
+      console.log(`Output root: ${summary.output_root}`);
+      console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
+      console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
+      if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
+      console.log(`Counts: active_missions=${summary.counts.active_missions || 0}, todo=${summary.counts.todo || 0}, in_progress=${summary.counts.in_progress || 0}, with_failures=${summary.counts.with_failures || 0}`);
+      console.log("Dry run only - no files written.");
+    }
+    return;
+  }
+
+  const writeResult = writeQaqcSnapshot({ snapshot, wrapperRoot, outputDir });
+  summary.data_root = writeResult.dataRoot;
+
+  if (args.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  console.log(`Project: ${summary.project_id || "(unknown)"}`);
+  console.log(`Wrapper root: ${summary.wrapper_root}`);
+  console.log(`Output root: ${summary.output_root}`);
+  console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
+  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 QAQC: active_missions=${summary.counts.active_missions || 0}, todo=${summary.counts.todo || 0}, in_progress=${summary.counts.in_progress || 0}, with_failures=${summary.counts.with_failures || 0}`);
+  console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
+}
+
 async function runQuery(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
@@ -1007,6 +1480,16 @@ async function main() {
     return;
   }
 
+  if (command === "bootstrap") {
+    await runBootstrap(args);
+    return;
+  }
+
+  if (command === "sync-qaqc" || command === "qaqc-sync") {
+    await runSyncQaqc(args);
+    return;
+  }
+
   if (command === "chat") {
     await runChat(args);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Myte CLI core implementation (Project Assistant + deterministic diffs).",
   "type": "commonjs",
   "main": "cli.js",
@@ -22,6 +22,7 @@
   "dependencies": {
     "dotenv": "^16.5.0",
     "minimist": "^1.2.8",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "yaml": "^2.8.1"
   }
 }