@mytegroupinc/myte-core 0.0.56 → 0.0.57

package/README.md

@@ -33,7 +33,10 @@ This package exists so the public wrapper can stay small and versioned cleanly.
   authorization, rate-limit, and server failures.
 - Safe transient reads and query polling use bounded retries. Query creation
   reuses one idempotency key across ambiguous retries.
-- Snapshot-style commands such as `bootstrap`, `sync-qaqc`, `feedback-sync`, and `suggestions sync` write local `MyteCommandCenter` data.
+- Snapshot-style commands such as `bootstrap`, `sync-qaqc`, `feedback-sync`, and `suggestions sync` write local `MyteCommandCenter` data.
+- `bootstrap` also writes `MyteCommandCenter/MyteBuildHarness.md` and `MyteCommandCenter/data/build-topology.yml`; these capture the project execution protocol and normalized topology without granting write permission.
+- `build verify --json` is a read-only local convergence check. It verifies the last bootstrap, active mission completion, actionable mission-operation state, per-mission terminal QA/QC coverage with no failed or pending cases, semantic/UI review evidence, and repository-gate evidence. It does not run QA/QC, repository tests, or semantic review itself.
+- Successful `myte` commands perform a cached, best-effort check for a newer package version and print any notice to `stderr`; `--json` output on `stdout` remains valid JSON. Disable it with `--no-update-check` or `MYTE_PACKAGE_UPDATE_CHECK=0`.
 - `feedback-sync` prefers stable ObjectId cursor pagination so concurrent
   inserts cannot shift later pages. It remains compatible with older
   offset-only API versions and rejects duplicate cross-page records instead of
@@ -106,7 +109,10 @@ Coding agents should treat `MYTE_API_KEY` as a project-scoped Project Assistant
 
 - Load it from the workspace `.env` or environment. `MYTE_PROJECT_API_KEY` is accepted as a compatibility fallback.
 - Call `myte config --json` first when project identity or local repo detection is uncertain.
-- Hydrate mission context with `bootstrap` first instead of scraping the web UI. `bootstrap` writes mission cards, mission suggestion thread state, and `MyteCommandCenter/AgentsMyteAPI.md`.
+- Hydrate mission context with `bootstrap` first instead of scraping the web UI. `bootstrap` writes mission cards, mission suggestion thread state, and `MyteCommandCenter/AgentsMyteAPI.md`.
+- Read `MyteCommandCenter/MyteBuildHarness.md` and `MyteCommandCenter/data/build-topology.yml` before implementing a new project. Organize work by workflow/domain topology and map frontend/backend ownership before changing code.
+- Run `myte build verify --json` only after the final bootstrap and preserve its QA/QC, semantic-review, and repository-gate evidence files for review.
+- The build verifier does not run QAQC, repository tests, or semantic review; run those steps first and preserve their evidence for verification.
 - Use `suggestions sync` only when you need to refresh mission review-thread state without refreshing the full board.
 - Use `query --with-diff` for project-scoped code review, planning, and implementation questions.
 - Use `create-prd` only with reviewed markdown files and `--confirm-write --approval-artifact <path>`. The markdown file body is the PRD document; `description` is only the short board/card summary.

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]",
@@ -261,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",
@@ -1009,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 =
@@ -4402,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");
@@ -4460,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,
@@ -4480,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);
@@ -6331,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");
@@ -6419,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;
@@ -6456,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");
@@ -8231,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 || {};
@@ -8740,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);
@@ -8855,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) => {