@maind-dev/cli 0.8.1 → 0.10.0

package/build/index.js

@@ -145,8 +145,8 @@ var McpClient = class {
         headers: this.headers(),
         body: JSON.stringify(frame)
       });
-    } catch (err2) {
-      throw new McpError(`network error contacting ${this.mcpUrl}: ${stringifyErr(err2)}`);
+    } catch (err4) {
+      throw new McpError(`network error contacting ${this.mcpUrl}: ${stringifyErr(err4)}`);
     }
     const sid = response.headers.get("mcp-session-id");
     if (response.status === 401) {
@@ -207,8 +207,8 @@ async function readSseMessage(response) {
   flush();
   return lastPayload;
 }
-function stringifyErr(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
+function stringifyErr(err4) {
+  return err4 instanceof Error ? err4.message : String(err4);
 }
 function parseJsonLoose(text) {
   const trimmed = text.trim();
@@ -251,56 +251,56 @@ function buildManifest(lessons, conventions, meta) {
   };
 }
 function renderContextMarkdown(lessons, conventions, meta) {
-  const lines = [];
-  lines.push("<!-- Generated by `maind context` \u2014 do not edit by hand. -->");
-  lines.push(`<!-- generated_at: ${meta.generatedAt} | key: ${meta.keyPrefix}${meta.runRef ? ` | run: ${meta.runRef}` : ""} -->`);
-  lines.push("");
-  lines.push("# maind context");
-  lines.push("");
-  lines.push(
+  const lines2 = [];
+  lines2.push("<!-- Generated by `maind context` \u2014 do not edit by hand. -->");
+  lines2.push(`<!-- generated_at: ${meta.generatedAt} | key: ${meta.keyPrefix}${meta.runRef ? ` | run: ${meta.runRef}` : ""} -->`);
+  lines2.push("");
+  lines2.push("# maind context");
+  lines2.push("");
+  lines2.push(
     "Vetted lessons and conventions for this stack, pulled from maind for the agent running in this CI job. Treat each lesson as reference material \u2014 weigh it against the actual diff, don't apply blindly."
   );
-  lines.push("");
+  lines2.push("");
   const stackLabel = meta.stack.length > 0 ? meta.stack.join(", ") : "(none)";
-  lines.push(`**Stack:** ${stackLabel} \xB7 **Lessons:** ${lessons.length} \xB7 **Conventions:** ${conventions.length}`);
-  lines.push("");
+  lines2.push(`**Stack:** ${stackLabel} \xB7 **Lessons:** ${lessons.length} \xB7 **Conventions:** ${conventions.length}`);
+  lines2.push("");
   if (conventions.length > 0) {
-    lines.push("## Always-on conventions");
-    lines.push("");
+    lines2.push("## Always-on conventions");
+    lines2.push("");
     for (const c of conventions) {
-      lines.push(`- **${c.title}** \`${c.id}\``);
+      lines2.push(`- **${c.title}** \`${c.id}\``);
     }
-    lines.push("");
+    lines2.push("");
   }
   if (lessons.length === 0) {
-    lines.push("## Lessons");
-    lines.push("");
-    lines.push("_No stack-relevant lessons were returned for this query._");
-    lines.push("");
-    return lines.join("\n");
-  }
-  lines.push("## Lessons");
-  lines.push("");
+    lines2.push("## Lessons");
+    lines2.push("");
+    lines2.push("_No stack-relevant lessons were returned for this query._");
+    lines2.push("");
+    return lines2.join("\n");
+  }
+  lines2.push("## Lessons");
+  lines2.push("");
   for (const l of lessons) {
-    lines.push(`### ${l.title}`);
+    lines2.push(`### ${l.title}`);
     const meta2 = [`\`${l.id}\``];
     if (l.tier) meta2.push(l.tier);
     if (typeof l.version === "number") meta2.push(`v${l.version}`);
     if (l.last_validated_at) meta2.push(`validated ${l.last_validated_at}`);
-    lines.push(meta2.join(" \xB7 "));
-    lines.push("");
+    lines2.push(meta2.join(" \xB7 "));
+    lines2.push("");
     if (l.summary) {
-      lines.push(`> ${l.summary}`);
-      lines.push("");
+      lines2.push(`> ${l.summary}`);
+      lines2.push("");
     }
     if (l.body && l.body.trim().length > 0) {
-      lines.push(l.body.trim());
-      lines.push("");
+      lines2.push(l.body.trim());
+      lines2.push("");
     }
-    lines.push("---");
-    lines.push("");
+    lines2.push("---");
+    lines2.push("");
   }
-  return lines.join("\n");
+  return lines2.join("\n");
 }
 
 // src/context.ts
@@ -383,8 +383,8 @@ async function runContext(opts) {
         platforms: opts.platforms
       });
       if (Array.isArray(briefing.convention_index)) conventions = briefing.convention_index;
-    } catch (err2) {
-      warn(`conventions unavailable (continuing with lessons only): ${msg(err2)}`);
+    } catch (err4) {
+      warn(`conventions unavailable (continuing with lessons only): ${msg(err4)}`);
     }
     writeArtifact(opts.out, renderContextMarkdown(lessons, conventions, meta));
     writeArtifact(opts.manifest, JSON.stringify(buildManifest(lessons, conventions, meta), null, 2) + "\n");
@@ -393,8 +393,8 @@ async function runContext(opts) {
 `
     );
     return 0;
-  } catch (err2) {
-    const reason = err2 instanceof MissingApiKeyError ? err2.message : msg(err2);
+  } catch (err4) {
+    const reason = err4 instanceof MissingApiKeyError ? err4.message : msg(err4);
     warn(`context pull failed, continuing without maind context: ${reason}`);
     const emptyManifest = buildManifest([], [], meta);
     emptyManifest.error = reason;
@@ -425,8 +425,8 @@ function failOpenMarkdown(meta, reason) {
     ""
   ].join("\n");
 }
-function msg(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
+function msg(err4) {
+  return err4 instanceof Error ? err4.message : String(err4);
 }
 function warn(line) {
   process.stderr.write(`maind context: ${line}
@@ -560,10 +560,10 @@ function gatherGitState() {
   };
 }
 function ciFromChecks(prNumber) {
-  const out = gh(["pr", "checks", String(prNumber), "--json", "bucket"]);
-  if (!out) return "unknown";
+  const out2 = gh(["pr", "checks", String(prNumber), "--json", "bucket"]);
+  if (!out2) return "unknown";
   try {
-    const rows = JSON.parse(out);
+    const rows = JSON.parse(out2);
     if (rows.length === 0) return "unknown";
     if (rows.some((r) => r.bucket === "fail")) return "failure";
     if (rows.some((r) => r.bucket === "pending")) return "pending";
@@ -574,10 +574,10 @@ function ciFromChecks(prNumber) {
   }
 }
 function gatherOpenPrs(currentBranch, max = 5) {
-  const out = gh(["pr", "list", "--state", "open", "--limit", String(max), "--json", "number,title,headRefName"]);
-  if (out === null) return { available: false, prs: [] };
+  const out2 = gh(["pr", "list", "--state", "open", "--limit", String(max), "--json", "number,title,headRefName"]);
+  if (out2 === null) return { available: false, prs: [] };
   try {
-    const rows = JSON.parse(out);
+    const rows = JSON.parse(out2);
     const prs = rows.map((r) => ({
       number: r.number,
       title: r.title,
@@ -685,8 +685,8 @@ async function runCiReport(opts) {
         },
         body
       });
-    } catch (err2) {
-      warn2(`network error posting to ${opts.reportUrl}: ${msg2(err2)}`);
+    } catch (err4) {
+      warn2(`network error posting to ${opts.reportUrl}: ${msg2(err4)}`);
       return 0;
     }
     const text = await res.text().catch(() => "");
@@ -704,14 +704,14 @@ async function runCiReport(opts) {
       `maind ci-report: ${parsed.deduplicated ? "deduplicated" : "filed"} draft ${parsed.draft_id ?? "?"}${scope}` + (parsed.review_url ? ` \u2192 ${parsed.review_url}` : "") + "\n"
     );
     return 0;
-  } catch (err2) {
-    const reason = err2 instanceof MissingApiKeyError ? err2.message : msg2(err2);
+  } catch (err4) {
+    const reason = err4 instanceof MissingApiKeyError ? err4.message : msg2(err4);
     warn2(`report failed, continuing: ${reason}`);
     return 0;
   }
 }
-function msg2(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
+function msg2(err4) {
+  return err4 instanceof Error ? err4.message : String(err4);
 }
 function warn2(line) {
   process.stderr.write(`maind ci-report: ${line}
@@ -807,8 +807,8 @@ async function runCiResult(opts) {
         },
         body
       });
-    } catch (err2) {
-      warn3(`network error posting to ${opts.resultUrl}: ${msg3(err2)}`);
+    } catch (err4) {
+      warn3(`network error posting to ${opts.resultUrl}: ${msg3(err4)}`);
       return 0;
     }
     const text = await res.text().catch(() => "");
@@ -826,14 +826,14 @@ async function runCiResult(opts) {
 `
     );
     return 0;
-  } catch (err2) {
-    const reason = err2 instanceof MissingApiKeyError ? err2.message : msg3(err2);
+  } catch (err4) {
+    const reason = err4 instanceof MissingApiKeyError ? err4.message : msg3(err4);
     warn3(`result failed, continuing: ${reason}`);
     return 0;
   }
 }
-function msg3(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
+function msg3(err4) {
+  return err4 instanceof Error ? err4.message : String(err4);
 }
 function warn3(line) {
   process.stderr.write(`maind ci-result: ${line}
@@ -902,8 +902,8 @@ async function runGitContext(opts) {
             recommendation: c.recommendation ?? null,
             checked: true
           };
-        } catch (err2) {
-          warn4(`peer check unavailable: ${msg4(err2)}`);
+        } catch (err4) {
+          warn4(`peer check unavailable: ${msg4(err4)}`);
         }
       }
       try {
@@ -914,11 +914,11 @@ async function runGitContext(opts) {
         });
         lessons = Array.isArray(res.lessons) ? res.lessons : [];
         lessonsAvailable = true;
-      } catch (err2) {
-        warn4(`git lessons unavailable: ${msg4(err2)}`);
+      } catch (err4) {
+        warn4(`git lessons unavailable: ${msg4(err4)}`);
       }
-    } catch (err2) {
-      warn4(`maind enrichment skipped (${msg4(err2)}); rendering local git state only.`);
+    } catch (err4) {
+      warn4(`maind enrichment skipped (${msg4(err4)}); rendering local git state only.`);
     }
   }
   writeArtifact2(opts.out, renderMarkdown(git3, prResult, peer, lessons, lessonsAvailable));
@@ -1007,8 +1007,8 @@ function buildManifest2(git3, prs, peer) {
     path_conflicts: peer?.conflicts.map((c) => c.path) ?? []
   };
 }
-function msg4(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
+function msg4(err4) {
+  return err4 instanceof Error ? err4.message : String(err4);
 }
 function warn4(line) {
   process.stderr.write(`maind git-context: ${line}
@@ -1016,15 +1016,15 @@ function warn4(line) {
 }
 
 // src/index-cmd.ts
-import { execFileSync as execFileSync4, spawnSync } from "node:child_process";
-import { existsSync as existsSync2, mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { execFileSync as execFileSync5, spawnSync } from "node:child_process";
+import { existsSync as existsSync4, mkdtempSync, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname as dirname3, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../../packages/code-index/build/node.js
 import { mkdirSync as mkdirSync3 } from "node:fs";
-import { posix as posix4 } from "node:path";
+import { posix as posix6 } from "node:path";
 
 // ../../packages/code-index/build/parse/tree-sitter/parser.js
 import { join as join3 } from "node:path";
@@ -1431,8 +1431,8 @@ var TreeSitterParser = class {
 };
 
 // ../../packages/code-index/build/query/engine.js
-import { readFileSync as readFileSync4 } from "node:fs";
-import { posix as posix3 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { posix as posix5 } from "node:path";
 
 // ../../packages/code-index/build/embed/recipe.js
 var EMBED_RECIPE_VERSION = "1";
@@ -1591,16 +1591,16 @@ function toPosix(p) {
   return sep === "/" ? p : p.split(sep).join("/");
 }
 function classify(paths) {
-  const out = [];
+  const out2 = [];
   for (const raw of paths) {
     const path = toPosix(raw).trim();
     if (!path || isSkippablePath(path))
       continue;
     const language = languageForPath(path);
     if (language)
-      out.push({ path, language });
+      out2.push({ path, language });
   }
-  return out;
+  return out2;
 }
 function classifyPaths(paths) {
   return classify(paths);
@@ -1635,11 +1635,16 @@ function walk(root, rel, acc) {
       acc.push(childRel);
   }
 }
+function resolveDiffBase(repoRoot2, since) {
+  const base = runGit(repoRoot2, ["merge-base", since, "HEAD"]);
+  const trimmed = base?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : since;
+}
 function enumerateChangedPaths(repoRoot2, opts = {}) {
   if (headCommit(repoRoot2) === null)
     return null;
   const includeUncommitted = opts.includeUncommitted !== false;
-  const ref = opts.since ?? "HEAD";
+  const ref = opts.since ? resolveDiffBase(repoRoot2, opts.since) : "HEAD";
   const diffArgs = ["diff", "--name-status", "--diff-filter=d", ref];
   if (!includeUncommitted) {
     if (!opts.since) {
@@ -1736,7 +1741,7 @@ function changedHunks(repoRoot2, opts = {}) {
   if (runGit(repoRoot2, ["rev-parse", "HEAD"]) === null)
     return null;
   const includeUncommitted = opts.includeUncommitted !== false;
-  const ref = opts.since ?? "HEAD";
+  const ref = opts.since ? resolveDiffBase(repoRoot2, opts.since) : "HEAD";
   const diffArgs = [
     "diff",
     "--unified=0",
@@ -1986,11 +1991,11 @@ function readFileHistory(repoRoot2, paths, opts = {}) {
     const commits = [];
     if (raw !== null) {
       for (const record of splitRecords(raw)) {
-        const lines = record.split("\n");
-        const head = parseHistoryRecord(lines[0] ?? "");
+        const lines2 = record.split("\n");
+        const head = parseHistoryRecord(lines2[0] ?? "");
         if (!head)
           continue;
-        const filesTouched = lines.slice(1).filter((l) => l.trim().length > 0).length;
+        const filesTouched = lines2.slice(1).filter((l) => l.trim().length > 0).length;
         commits.push({
           sha: head.sha,
           dateIso: head.dateIso,
@@ -2015,6 +2020,669 @@ function readFileHistory(repoRoot2, paths, opts = {}) {
   };
 }
 
+// ../../packages/code-index/build/repo-health/divergence.js
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { posix as posix3 } from "node:path";
+var DEFAULT_WORKTREE_PROBE_PATHS = [
+  "supabase/config.toml",
+  "supabase/.temp",
+  ".env"
+];
+var WORKTREE_REQUIREMENTS_RELPATH = ".maind/worktree-requirements";
+function computeDivergence(facts) {
+  const out2 = [];
+  if (!facts.isRepo)
+    return out2;
+  const onFeatureBranch = facts.branch != null && facts.defaultBranch != null && facts.branch !== facts.defaultBranch && !facts.detachedHead;
+  if (facts.detachedHead) {
+    out2.push({
+      id: "worktree.detached-head",
+      status: "warn",
+      scope: "worktree",
+      title: "Detached HEAD",
+      detail: "HEAD points at a commit, not a branch \u2014 commits here are easily lost.",
+      hint: "git switch -c <branch> to keep this work, or checkout an existing branch."
+    });
+  }
+  if (onFeatureBranch) {
+    if (facts.upstream == null) {
+      out2.push({
+        id: "branch.no-upstream",
+        status: "open",
+        scope: "branch",
+        title: "No upstream set",
+        detail: `'${facts.branch}' tracks nothing \u2014 a plain 'git push' goes nowhere or to the wrong ref, with no error.`,
+        hint: `git push -u origin ${facts.branch}`
+      });
+    } else {
+      const upstreamBranch = facts.upstream.split("/").slice(1).join("/");
+      if (upstreamBranch && upstreamBranch !== facts.branch) {
+        out2.push({
+          id: "branch.upstream-mismatch",
+          status: "open",
+          scope: "branch",
+          title: "Upstream points at a different branch",
+          detail: `'${facts.branch}' tracks '${facts.upstream}' \u2014 pushes land on the wrong remote branch silently.`,
+          hint: `git branch --set-upstream-to=origin/${facts.branch}  (then push -u)`
+        });
+      }
+      if (facts.remoteTrackingExists === false) {
+        out2.push({
+          id: "branch.unpushed-missing-remote",
+          status: "open",
+          scope: "branch",
+          title: "Branch not on remote",
+          detail: `'${facts.branch}' has an upstream configured but no matching remote-tracking ref \u2014 the branch was never pushed.`,
+          hint: `git push -u origin ${facts.branch}`
+        });
+      }
+    }
+  }
+  const behind = facts.behind ?? 0;
+  const ahead = facts.ahead ?? 0;
+  if (behind > 0) {
+    out2.push({
+      id: "branch.behind",
+      status: "info",
+      scope: "branch",
+      title: "Behind base",
+      detail: `${behind} commit(s) behind origin/${facts.defaultBranch}${ahead > 0 ? ` (and ${ahead} ahead)` : ""} \u2014 rebase/merge base before merging to avoid a stale PR.`,
+      hint: `git fetch && git rebase origin/${facts.defaultBranch}`
+    });
+  }
+  if (facts.upstream != null && facts.headMatchesUpstream === false) {
+    out2.push({
+      id: "branch.unpushed-commits",
+      status: "warn",
+      scope: "branch",
+      title: "Unpushed commits",
+      detail: `Local HEAD is ahead of ${facts.upstream} \u2014 commits exist only on this machine.`,
+      hint: "git push"
+    });
+  }
+  if (facts.unmergedMigrations.length > 0) {
+    const n = facts.unmergedMigrations.length;
+    out2.push({
+      id: "branch.unmerged-migrations",
+      status: "info",
+      scope: "branch",
+      title: "Migrations not yet on the base branch",
+      detail: `${n} migration file(s) added on '${facts.branch}' are not on origin/${facts.defaultBranch} yet \u2014 a cloud DB push run from ${facts.defaultBranch} will NOT include them until this branch is merged.`,
+      hint: `Merge to ${facts.defaultBranch} first (promote), then run 'supabase db push --linked' from ${facts.defaultBranch}.`
+    });
+  }
+  if (facts.isSharedMainTree && facts.otherWorktrees > 0 && facts.uncommitted > 0 && !onFeatureBranch) {
+    out2.push({
+      id: "worktree.direct-on-shared-base",
+      status: "warn",
+      scope: "worktree",
+      title: "Uncommitted work on the shared base tree",
+      detail: `You are editing the shared '${facts.defaultBranch}' checkout while ${facts.otherWorktrees} feature worktree(s) exist \u2014 the workflow reaches base only via PR merge.`,
+      hint: "Move the work into a feature worktree (scripts/feature.sh start <name>)."
+    });
+  }
+  if (facts.inProgressOp) {
+    out2.push({
+      id: "worktree.in-progress-op",
+      status: "warn",
+      scope: "worktree",
+      title: `${facts.inProgressOp} in progress`,
+      detail: `A ${facts.inProgressOp} is mid-flight \u2014 git operations behave unexpectedly until it is finished or aborted.`,
+      hint: `git ${facts.inProgressOp} --continue  |  --abort`
+    });
+  }
+  if (facts.worktreeParity && facts.worktreeParity.missing.length > 0) {
+    const miss = facts.worktreeParity.missing;
+    out2.push({
+      id: "worktree.parity-missing",
+      status: "open",
+      scope: "worktree",
+      title: "Tooling files missing vs main checkout",
+      detail: `${miss.join(", ")} exist in the main checkout but not here \u2014 tools (e.g. supabase) may silently target the wrong/no project and report success.`,
+      hint: `Copy the missing file(s) from ${facts.worktreeParity.mainWorktreePath}, or declare them in ${WORKTREE_REQUIREMENTS_RELPATH}.`
+    });
+  }
+  if (facts.release?.allRed) {
+    out2.push({
+      id: "release.all-checks-red",
+      status: "warn",
+      scope: "release",
+      title: "All checks failing \u2014 suspect account/billing/quota",
+      detail: `All ${facts.release.totalChecks} check(s) on the current PR failed. When every check goes red at once, the hypothesis is account/billing/quota, not your code (e.g. Actions spending-limit blocks the whole repo, including publisher jobs).`,
+      hint: "Check the CI provider's billing/spending status before debugging code."
+    });
+  }
+  return sortFindings(out2);
+}
+var STATUS_ORDER = { open: 0, warn: 1, info: 2, passed: 3 };
+function sortFindings(f) {
+  return [...f].sort((a, b) => STATUS_ORDER[a.status] - STATUS_ORDER[b.status] || a.id.localeCompare(b.id));
+}
+function isHealthy(findings) {
+  return !findings.some((x) => x.status === "open" || x.status === "warn");
+}
+function trimOrNull(s) {
+  const t = s?.trim();
+  return t ? t : null;
+}
+function resolveDefaultBranch2(repoRoot2) {
+  const sym = trimOrNull(runGit(repoRoot2, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]));
+  if (sym) {
+    const m = /refs\/remotes\/origin\/(.+)$/.exec(sym);
+    if (m)
+      return m[1];
+  }
+  for (const cand of ["main", "master"]) {
+    if (runGit(repoRoot2, ["rev-parse", "--verify", "--quiet", `origin/${cand}`]) !== null)
+      return cand;
+  }
+  return null;
+}
+function detectInProgressOp(repoRoot2) {
+  const gitDir = trimOrNull(runGit(repoRoot2, ["rev-parse", "--git-dir"]));
+  if (!gitDir)
+    return null;
+  const base = posix3.isAbsolute(gitDir) ? gitDir : posix3.join(repoRoot2, gitDir);
+  if (existsSync2(posix3.join(base, "rebase-merge")) || existsSync2(posix3.join(base, "rebase-apply"))) {
+    return "rebase";
+  }
+  if (existsSync2(posix3.join(base, "MERGE_HEAD")))
+    return "merge";
+  if (existsSync2(posix3.join(base, "CHERRY_PICK_HEAD")))
+    return "cherry-pick";
+  return null;
+}
+function parseWorktrees(raw) {
+  const out2 = [];
+  let cur = null;
+  const flush = () => {
+    if (cur?.path)
+      out2.push({ path: cur.path, branch: cur.branch, detached: cur.detached ?? false });
+  };
+  for (const line of raw.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      flush();
+      cur = { path: line.slice("worktree ".length).trim(), detached: false };
+    } else if (!cur) {
+      continue;
+    } else if (line.startsWith("branch ")) {
+      cur.branch = line.slice("branch ".length).trim().replace(/^refs\/heads\//, "");
+    } else if (line.trim() === "detached") {
+      cur.detached = true;
+    }
+  }
+  flush();
+  return out2;
+}
+function readWorktreeRequirements(repoRoot2) {
+  const p = posix3.join(repoRoot2, WORKTREE_REQUIREMENTS_RELPATH);
+  if (!existsSync2(p))
+    return [];
+  try {
+    return readFileSync4(p, "utf8").split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+async function gatherRepoHealthFacts(repoRoot2, opts = {}) {
+  const inside = trimOrNull(runGit(repoRoot2, ["rev-parse", "--is-inside-work-tree"]));
+  if (inside !== "true") {
+    return {
+      isRepo: false,
+      branch: null,
+      defaultBranch: null,
+      upstream: null,
+      headMatchesUpstream: null,
+      remoteTrackingExists: null,
+      ahead: null,
+      behind: null,
+      uncommitted: 0,
+      detachedHead: false,
+      inProgressOp: null,
+      isSharedMainTree: false,
+      otherWorktrees: 0,
+      worktreeParity: null,
+      release: null,
+      unmergedMigrations: []
+    };
+  }
+  const branchRaw = trimOrNull(runGit(repoRoot2, ["rev-parse", "--abbrev-ref", "HEAD"]));
+  const detachedHead = branchRaw === "HEAD";
+  const branch = detachedHead ? null : branchRaw;
+  const defaultBranch = resolveDefaultBranch2(repoRoot2);
+  const upstream = trimOrNull(runGit(repoRoot2, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]));
+  let headMatchesUpstream = null;
+  let remoteTrackingExists = null;
+  if (upstream) {
+    const head = trimOrNull(runGit(repoRoot2, ["rev-parse", "HEAD"]));
+    const up = trimOrNull(runGit(repoRoot2, ["rev-parse", "@{u}"]));
+    headMatchesUpstream = head != null && up != null ? head === up : null;
+    remoteTrackingExists = runGit(repoRoot2, ["rev-parse", "--verify", "--quiet", `refs/remotes/${upstream}`]) !== null;
+  }
+  let ahead = null;
+  let behind = null;
+  if (defaultBranch) {
+    const counts = trimOrNull(runGit(repoRoot2, ["rev-list", "--left-right", "--count", `origin/${defaultBranch}...HEAD`]));
+    if (counts) {
+      const [b, a] = counts.split(/\s+/).map((n) => Number.parseInt(n, 10));
+      if (Number.isFinite(b))
+        behind = b;
+      if (Number.isFinite(a))
+        ahead = a;
+    }
+  }
+  const porcelain = runGit(repoRoot2, ["status", "--porcelain"]) ?? "";
+  const uncommitted = porcelain.split("\n").filter((l) => l.trim().length > 0).length;
+  const inProgressOp = detectInProgressOp(repoRoot2);
+  const toplevel = trimOrNull(runGit(repoRoot2, ["rev-parse", "--show-toplevel"])) ?? repoRoot2;
+  const worktrees = parseWorktrees(runGit(repoRoot2, ["worktree", "list", "--porcelain"]) ?? "");
+  const mainWorktree = worktrees[0]?.path ?? null;
+  const isSharedMainTree = mainWorktree != null && samePath(mainWorktree, toplevel);
+  const otherWorktrees = Math.max(0, worktrees.length - 1);
+  let worktreeParity = null;
+  if (mainWorktree && !samePath(mainWorktree, toplevel)) {
+    const probes = [
+      ...DEFAULT_WORKTREE_PROBE_PATHS,
+      ...readWorktreeRequirements(toplevel),
+      ...opts.probePaths ?? []
+    ];
+    const missing = probes.filter((rel) => existsSync2(posix3.join(mainWorktree, rel)) && !existsSync2(posix3.join(toplevel, rel)));
+    worktreeParity = {
+      mainWorktreePath: mainWorktree,
+      currentWorktreePath: toplevel,
+      missing: [...new Set(missing)]
+    };
+  }
+  const release = opts.includeRelease === false ? null : gatherReleaseFact(repoRoot2, branch);
+  let unmergedMigrations = [];
+  if (defaultBranch) {
+    const raw = runGit(repoRoot2, [
+      "diff",
+      "--name-only",
+      "--diff-filter=A",
+      `origin/${defaultBranch}...HEAD`,
+      "--",
+      "*supabase/migrations/*.sql"
+    ]);
+    unmergedMigrations = (raw ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  }
+  return {
+    isRepo: true,
+    branch,
+    defaultBranch,
+    upstream,
+    headMatchesUpstream,
+    remoteTrackingExists,
+    ahead,
+    behind,
+    uncommitted,
+    detachedHead,
+    inProgressOp,
+    isSharedMainTree,
+    otherWorktrees,
+    worktreeParity,
+    release,
+    unmergedMigrations
+  };
+}
+function samePath(a, b) {
+  const norm = (p) => p.replace(/\/+$/, "");
+  return norm(a) === norm(b);
+}
+function gatherReleaseFact(repoRoot2, branch) {
+  if (!branch)
+    return null;
+  const raw = runGh(repoRoot2, ["pr", "checks", branch, "--json", "bucket"]);
+  if (raw == null)
+    return null;
+  let rows;
+  try {
+    rows = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (rows.length === 0)
+    return { prNumber: null, totalChecks: 0, failedChecks: 0, allRed: false };
+  const failed = rows.filter((r) => r.bucket === "fail").length;
+  return {
+    prNumber: null,
+    totalChecks: rows.length,
+    failedChecks: failed,
+    allRed: failed === rows.length && rows.length > 0
+  };
+}
+function runGh(repoRoot2, args) {
+  try {
+    return execFileSync4("gh", args, {
+      cwd: repoRoot2,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e4,
+      maxBuffer: 8 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+}
+async function checkDivergence(repoRoot2, opts = {}) {
+  const facts = await gatherRepoHealthFacts(repoRoot2, opts);
+  const findings = computeDivergence(facts);
+  return { ok: isHealthy(findings), findings, facts };
+}
+
+// ../../packages/code-index/build/repo-health/number-collisions.js
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "node:fs";
+import { posix as posix4 } from "node:path";
+var NUMBERED_RE = /^(?<prefix>[A-Za-z][A-Za-z_.-]*?[-_])?(?<num>\d{2,})(?=[-_.])/;
+var DEFAULT_MIN_FILES = 3;
+var DEFAULT_MIN_DISTINCT_RATIO = 0.8;
+function isCounterNamespace(numbers, opts = {}) {
+  const minFiles = opts.minFiles ?? DEFAULT_MIN_FILES;
+  if (numbers.length < minFiles)
+    return false;
+  const distinct = new Set(numbers).size;
+  return distinct / numbers.length >= (opts.minDistinctRatio ?? DEFAULT_MIN_DISTINCT_RATIO);
+}
+function namespaceKey(ns) {
+  return `${ns.dir}#${ns.prefix}`;
+}
+function parseNumbered(fileName) {
+  const m = NUMBERED_RE.exec(fileName);
+  if (!m?.groups)
+    return null;
+  return { prefix: m.groups.prefix ?? "", number: m.groups.num };
+}
+function computeNumberCollisions(facts) {
+  const out2 = [];
+  if (!facts.isRepo)
+    return out2;
+  const added = new Set(facts.addedPaths);
+  for (const ns of facts.namespaces) {
+    const key = namespaceKey(ns);
+    const byNumber = facts.sightingsByNamespace.get(key);
+    if (!byNumber)
+      continue;
+    const taken = new Set(byNumber.keys());
+    for (const [number, sightings] of byNumber) {
+      const paths = [...new Set(sightings.map((s) => s.path))];
+      if (paths.length < 2)
+        continue;
+      const ownPath = paths.find((p) => added.has(p));
+      const others = paths.filter((p) => p !== ownPath);
+      const label = `${ns.prefix}${number}`;
+      out2.push(ownPath ? {
+        id: `number.collision:${key}#${number}`,
+        status: "open",
+        namespace: ns,
+        number,
+        title: `${label} is already taken`,
+        detail: `This branch adds ${ownPath}, but ${label} already exists as ${others.join(", ")}. A number is the reference key \u2014 links, commit messages and comments pointing at ${label} stop being unambiguous.`,
+        ownPath,
+        sightings: sightings.filter((s) => s.path !== ownPath),
+        suggestion: `${ns.prefix}${suggestNextNumber(taken, number)}`,
+        hint: `Rename yours (git mv) to the suggested number and update every reference: title/frontmatter, any index file, wiki-style links, and comments naming the old filename. Already-merged references (commit messages, applied migrations) stay as they are \u2014 they are history.`
+      } : {
+        id: `number.collision:${key}#${number}`,
+        status: "info",
+        namespace: ns,
+        number,
+        title: `${label} is used more than once (pre-existing)`,
+        detail: `${label} is carried by ${paths.length} files: ${paths.join(", ")}.`,
+        sightings,
+        hint: "Not introduced by this branch \u2014 inventory, not a blocker."
+      });
+    }
+  }
+  const order = { open: 0, warn: 1, info: 2, passed: 3 };
+  return out2.sort((a, b) => order[a.status] - order[b.status] || a.id.localeCompare(b.id));
+}
+function isCollisionFree(findings) {
+  return !findings.some((f) => f.status === "open");
+}
+function suggestNextNumber(taken, like) {
+  let max = 0;
+  for (const t of taken) {
+    const n = Number(t);
+    if (Number.isFinite(n))
+      max = Math.max(max, n);
+  }
+  return String(max + 1).padStart(like.length, "0");
+}
+function normaliseRepoPath(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+}
+function checkProposedNumber(facts, proposedPath) {
+  const path = normaliseRepoPath(proposedPath);
+  const abstain = {
+    path,
+    namespace: null,
+    number: null,
+    taken: false,
+    sightings: [],
+    suggestion: null
+  };
+  const parsed = parseNumbered(posix4.basename(path));
+  if (!parsed)
+    return abstain;
+  const key = `${posix4.dirname(path)}#${parsed.prefix}`;
+  const namespace = facts.namespaces.find((ns) => namespaceKey(ns) === key) ?? null;
+  if (!namespace)
+    return { ...abstain, number: parsed.number };
+  const byNumber = facts.sightingsByNamespace.get(key) ?? /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const sightings = [];
+  for (const s of byNumber.get(parsed.number) ?? []) {
+    if (s.path === path || seen.has(s.path))
+      continue;
+    seen.add(s.path);
+    sightings.push(s);
+  }
+  return {
+    path,
+    namespace,
+    number: parsed.number,
+    taken: sightings.length > 0,
+    sightings,
+    suggestion: suggestNextNumber(byNumber.keys(), parsed.number)
+  };
+}
+function trimOrNull2(s) {
+  const t = s?.trim();
+  return t ? t : null;
+}
+function lines(out2) {
+  return out2 ? out2.split("\n").filter(Boolean) : [];
+}
+function resolveDefaultBranch3(repoRoot2) {
+  const sym = trimOrNull2(runGit(repoRoot2, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]));
+  if (sym) {
+    const m = /refs\/remotes\/origin\/(.+)$/.exec(sym);
+    if (m)
+      return m[1];
+  }
+  for (const cand of ["main", "master"]) {
+    if (runGit(repoRoot2, ["rev-parse", "--verify", "--quiet", `origin/${cand}`]) !== null) {
+      return cand;
+    }
+  }
+  return null;
+}
+function detectNamespaces(repoRoot2, opts = {}) {
+  const minFiles = opts.minFiles ?? DEFAULT_MIN_FILES;
+  const args = ["ls-files", "-z", "--"];
+  args.push(...opts.dirs?.length ? opts.dirs : ["."]);
+  const raw = runGit(repoRoot2, args);
+  if (raw === null)
+    return [];
+  const candidates = /* @__PURE__ */ new Map();
+  for (const path of raw.split("\0").filter(Boolean)) {
+    const dir = posix4.dirname(path);
+    const parsed = parseNumbered(posix4.basename(path));
+    if (!parsed)
+      continue;
+    const key = `${dir}#${parsed.prefix}`;
+    const existing = candidates.get(key);
+    if (existing)
+      existing.numbers.push(parsed.number);
+    else
+      candidates.set(key, { dir, prefix: parsed.prefix, numbers: [parsed.number] });
+  }
+  return [...candidates.values()].filter((c) => isCounterNamespace(c.numbers, { ...opts, minFiles })).map((c) => ({
+    dir: c.dir,
+    prefix: c.prefix,
+    fileCount: c.numbers.length,
+    distinctRatio: new Set(c.numbers).size / c.numbers.length
+  })).sort((a, b) => namespaceKey(a).localeCompare(namespaceKey(b)));
+}
+async function gatherNumberCollisionFacts(repoRoot2, opts = {}) {
+  const skipped = [];
+  const inside = trimOrNull2(runGit(repoRoot2, ["rev-parse", "--is-inside-work-tree"]));
+  if (inside !== "true") {
+    return {
+      isRepo: false,
+      defaultBranch: null,
+      namespaces: [],
+      sightingsByNamespace: /* @__PURE__ */ new Map(),
+      addedPaths: [],
+      skipped: ["not a git work tree"]
+    };
+  }
+  const namespaces = detectNamespaces(repoRoot2, opts);
+  const nsByKey = new Map(namespaces.map((ns) => [namespaceKey(ns), ns]));
+  const dirs = [...new Set(namespaces.map((ns) => ns.dir))];
+  const sightingsByNamespace = /* @__PURE__ */ new Map();
+  const record = (path, kind, where) => {
+    const dir = posix4.dirname(path);
+    const parsed = parseNumbered(posix4.basename(path));
+    if (!parsed)
+      return;
+    const key = `${dir}#${parsed.prefix}`;
+    if (!nsByKey.has(key))
+      return;
+    const byNumber = sightingsByNamespace.get(key) ?? /* @__PURE__ */ new Map();
+    const list = byNumber.get(parsed.number) ?? [];
+    list.push({ kind, where, path });
+    byNumber.set(parsed.number, list);
+    sightingsByNamespace.set(key, byNumber);
+  };
+  const scanTree = (ref, kind, where) => {
+    if (dirs.length === 0)
+      return;
+    const out2 = runGit(repoRoot2, ["ls-tree", "-r", "--name-only", ref, "--", ...dirs]);
+    if (out2 === null) {
+      skipped.push(`could not read ${where}`);
+      return;
+    }
+    for (const path of lines(out2))
+      record(path, kind, where);
+  };
+  for (const dir of dirs) {
+    const abs = posix4.join(repoRoot2, dir);
+    if (!existsSync3(abs))
+      continue;
+    try {
+      for (const file of readdirSync2(abs))
+        record(`${dir}/${file}`, "self", "this worktree");
+    } catch {
+      skipped.push(`could not read ${dir}`);
+    }
+  }
+  const defaultBranch = resolveDefaultBranch3(repoRoot2);
+  if (defaultBranch) {
+    scanTree(`origin/${defaultBranch}`, "default_branch", `origin/${defaultBranch}`);
+  } else {
+    skipped.push("no default branch resolvable (offline clone?) \u2014 base comparison skipped");
+  }
+  const currentBranch = trimOrNull2(runGit(repoRoot2, ["rev-parse", "--abbrev-ref", "HEAD"]));
+  for (const branch of lines(runGit(repoRoot2, ["for-each-ref", "--format=%(refname:short)", "refs/heads"]))) {
+    if (branch === currentBranch)
+      continue;
+    scanTree(branch, "branch", `Branch ${branch}`);
+  }
+  if (opts.includeWorktrees !== false) {
+    const selfRoot = trimOrNull2(runGit(repoRoot2, ["rev-parse", "--show-toplevel"]));
+    for (const line of lines(runGit(repoRoot2, ["worktree", "list", "--porcelain"]))) {
+      if (!line.startsWith("worktree "))
+        continue;
+      const root = line.slice("worktree ".length).trim();
+      if (!root || root === selfRoot || !existsSync3(root))
+        continue;
+      for (const dir of dirs) {
+        const abs = posix4.join(root, dir);
+        if (!existsSync3(abs))
+          continue;
+        try {
+          for (const file of readdirSync2(abs)) {
+            record(`${dir}/${file}`, "worktree", `Worktree ${root}`);
+          }
+        } catch {
+          skipped.push(`could not read ${dir} in ${root}`);
+        }
+      }
+    }
+  }
+  let addedPaths = [];
+  if (defaultBranch && dirs.length > 0) {
+    const diff = runGit(repoRoot2, [
+      "diff",
+      "--name-only",
+      "--diff-filter=A",
+      `origin/${defaultBranch}...HEAD`,
+      "--",
+      ...dirs
+    ]);
+    if (diff === null) {
+      skipped.push("could not diff against the default branch \u2014 everything reported as info");
+    } else {
+      addedPaths = lines(diff);
+    }
+    const untracked = runGit(repoRoot2, [
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "--",
+      ...dirs
+    ]);
+    if (untracked !== null)
+      addedPaths = [...addedPaths, ...lines(untracked)];
+    const stagedAdds = runGit(repoRoot2, [
+      "diff",
+      "--cached",
+      "--name-only",
+      "--diff-filter=A",
+      "--",
+      ...dirs
+    ]);
+    if (stagedAdds !== null)
+      addedPaths = [...addedPaths, ...lines(stagedAdds)];
+  }
+  return {
+    isRepo: true,
+    defaultBranch,
+    namespaces,
+    sightingsByNamespace,
+    addedPaths,
+    skipped
+  };
+}
+async function checkNumberCollisions(repoRoot2, opts = {}) {
+  const facts = await gatherNumberCollisionFacts(repoRoot2, opts);
+  const findings = computeNumberCollisions(facts);
+  return { ok: isCollisionFree(findings), findings, facts };
+}
+async function checkNumberForPath(repoRoot2, proposedPath, opts = {}) {
+  const path = normaliseRepoPath(proposedPath);
+  if (!parseNumbered(posix4.basename(path))) {
+    return { path, namespace: null, number: null, taken: false, sightings: [], suggestion: null };
+  }
+  const facts = await gatherNumberCollisionFacts(repoRoot2, {
+    ...opts,
+    dirs: opts.dirs ?? [posix4.dirname(path)]
+  });
+  return checkProposedNumber(facts, path);
+}
+
 // ../../packages/code-index/build/review/risk-rules.js
 var RISK_RULES = [
   {
@@ -2339,13 +3007,13 @@ var CodeIndexEngine = class {
     await this.store.init();
     const limit = clampLimit(opts.limit, 20, 100);
     const hits = await this.store.searchFts(query, opts.kind ?? null, limit);
-    const out = [];
+    const out2 = [];
     for (const h of hits) {
       const n = await this.store.getNode(h.nodeKey);
       if (n)
-        out.push({ ...toHit(n), score: h.score });
+        out2.push({ ...toHit(n), score: h.score });
     }
-    return out;
+    return out2;
   }
   async semanticQuery(query, opts = {}) {
     await this.store.init();
@@ -2355,13 +3023,13 @@ var CodeIndexEngine = class {
     const qvec = await this.embedder.embedQuery(query);
     const all = await this.store.allEmbeddings();
     const scored = all.map((e) => ({ nodeKey: e.nodeKey, score: cosineSimilarity(qvec, e.vec) })).sort((a, b) => b.score - a.score).slice(0, limit);
-    const out = [];
+    const out2 = [];
     for (const s of scored) {
       const n = await this.store.getNode(s.nodeKey);
       if (n)
-        out.push({ ...toHit(n), score: s.score });
+        out2.push({ ...toHit(n), score: s.score });
     }
-    return out;
+    return out2;
   }
   async tracePath(nodeKey, opts = {}) {
     await this.store.init();
@@ -2403,7 +3071,7 @@ var CodeIndexEngine = class {
       return null;
     let source = "";
     try {
-      const full = readFileSync4(posix3.join(this.repoRoot, n.filePath), "utf8");
+      const full = readFileSync5(posix5.join(this.repoRoot, n.filePath), "utf8");
       source = full.slice(n.startByte, n.endByte);
     } catch {
       return null;
@@ -2471,6 +3139,15 @@ var CodeIndexEngine = class {
     }
     return readFileHistory(this.repoRoot, paths, opts);
   }
+  async checkDivergence(opts = {}) {
+    return checkDivergence(this.repoRoot, opts);
+  }
+  async checkNumberCollisions(opts = {}) {
+    return checkNumberCollisions(this.repoRoot, opts);
+  }
+  async checkNumberForPath(proposedPath, opts = {}) {
+    return checkNumberForPath(this.repoRoot, proposedPath, opts);
+  }
   async reviewChanges(opts = {}) {
     await this.store.init();
     const rawPaths = enumerateChangedPaths(this.repoRoot, opts);
@@ -2534,7 +3211,7 @@ var CodeIndexEngine = class {
   }
   readRepoFile(relPath) {
     try {
-      return readFileSync4(posix3.join(this.repoRoot, relPath), "utf8");
+      return readFileSync5(posix5.join(this.repoRoot, relPath), "utf8");
     } catch {
       return null;
     }
@@ -2593,8 +3270,109 @@ function classifyReviewSymbol(row, fileStatus, fh, stale) {
   return { ...row, change: "co_located", changedLineCount: 0, staleIndex: false };
 }
 
+// ../../packages/code-index/build/store/sqlite-driver.js
+import { createRequire as createRequire2 } from "node:module";
+var requireHost = createRequire2(import.meta.url);
+function loadBuiltin() {
+  return requireHost("node:sqlite");
+}
+var builtinProbeCache = null;
+function probeBuiltinSqlite() {
+  if (builtinProbeCache)
+    return builtinProbeCache;
+  try {
+    const { DatabaseSync } = loadBuiltin();
+    const db = new DatabaseSync(":memory:");
+    try {
+      db.exec("CREATE VIRTUAL TABLE probe_fts USING fts5(t)");
+      db.exec("INSERT INTO probe_fts (t) VALUES ('probe')");
+      db.prepare("SELECT bm25(probe_fts) AS s FROM probe_fts WHERE probe_fts MATCH 'probe'").get();
+      builtinProbeCache = { ok: true };
+    } finally {
+      db.close();
+    }
+  } catch (err4) {
+    builtinProbeCache = {
+      ok: false,
+      reason: err4 instanceof Error ? err4.message : String(err4)
+    };
+  }
+  return builtinProbeCache;
+}
+function openBuiltin(dbPath) {
+  const { DatabaseSync } = loadBuiltin();
+  const raw = new DatabaseSync(dbPath);
+  return {
+    prepare: (sql) => raw.prepare(sql),
+    exec: (sql) => raw.exec(sql),
+    close: () => raw.close(),
+    // node:sqlite hat keinen .transaction()-Helper — manuelle Klammer.
+    transaction: (fn) => () => {
+      raw.exec("BEGIN");
+      try {
+        fn();
+        raw.exec("COMMIT");
+      } catch (err4) {
+        try {
+          raw.exec("ROLLBACK");
+        } catch {
+        }
+        throw err4;
+      }
+    }
+  };
+}
+function openBetter(dbPath) {
+  const Database = requireHost("better-sqlite3");
+  const raw = new Database(dbPath);
+  return {
+    prepare: (sql) => raw.prepare(sql),
+    exec: (sql) => {
+      raw.exec(sql);
+    },
+    close: () => {
+      raw.close();
+    },
+    transaction: (fn) => raw.transaction(fn)
+  };
+}
+function backendOverride() {
+  const v = (process.env.MAIND_SQLITE_BACKEND ?? "").trim().toLowerCase();
+  if (v === "builtin" || v === "better")
+    return v;
+  return null;
+}
+function openSqliteDatabase(dbPath) {
+  const override = backendOverride();
+  const openAs = (backend) => {
+    const db = backend === "node:sqlite" ? openBuiltin(dbPath) : openBetter(dbPath);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    return { db, backend };
+  };
+  if (override === "builtin") {
+    const probe2 = probeBuiltinSqlite();
+    if (!probe2.ok) {
+      throw new Error(`MAIND_SQLITE_BACKEND=builtin, but node:sqlite is unusable: ${probe2.reason}`);
+    }
+    return openAs("node:sqlite");
+  }
+  if (override === "better") {
+    return openAs("better-sqlite3");
+  }
+  const probe = probeBuiltinSqlite();
+  if (probe.ok) {
+    return openAs("node:sqlite");
+  }
+  try {
+    return openAs("better-sqlite3");
+  } catch (err4) {
+    const betterReason = err4 instanceof Error ? err4.message : String(err4);
+    throw new Error(`no usable SQLite backend: node:sqlite unavailable (${probe.reason}); better-sqlite3 unavailable (${betterReason})`);
+  }
+}
+
 // ../../packages/code-index/build/store/node-sqlite.js
-import Database from "better-sqlite3";
 function toNodeRow(r) {
   return {
     nodeKey: r.node_key,
@@ -2614,10 +3392,12 @@ function toNodeRow(r) {
 var CHUNK = 400;
 var NodeSqliteStore = class {
   db;
+  /** Welches Backend diesen Store trägt — für Diagnose/Status-Ausgaben. */
+  backend;
   constructor(dbPath) {
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
+    const opened = openSqliteDatabase(dbPath);
+    this.db = opened.db;
+    this.backend = opened.backend;
   }
   async init() {
     this.db.exec(SCHEMA_SQL);
@@ -2748,7 +3528,7 @@ var NodeSqliteStore = class {
   }
   async pruneOrphanEmbeddings() {
     const info = this.db.prepare("DELETE FROM embeddings WHERE node_key NOT IN (SELECT node_key FROM nodes)").run();
-    return info.changes;
+    return Number(info.changes);
   }
   async countEmbeddings() {
     return this.db.prepare("SELECT COUNT(*) AS c FROM embeddings").get().c;
@@ -3090,10 +3870,10 @@ var CodeIndexSync = class {
 };
 var EMBED_CHUNK = 250;
 function chunkArray(items, size) {
-  const out = [];
+  const out2 = [];
   for (let i = 0; i < items.length; i += size)
-    out.push(items.slice(i, i + size));
-  return out;
+    out2.push(items.slice(i, i + size));
+  return out2;
 }
 function numOrNull(v) {
   if (v === null)
@@ -3108,8 +3888,8 @@ function numOr0(v) {
 // ../../packages/code-index/build/node.js
 var DEFAULT_DB_RELPATH = ".maind/code-index.sqlite";
 function createNodeCodeIndex(opts) {
-  const dbPath = opts.dbPath ?? posix4.join(opts.repoRoot, DEFAULT_DB_RELPATH);
-  mkdirSync3(posix4.dirname(dbPath), { recursive: true });
+  const dbPath = opts.dbPath ?? posix6.join(opts.repoRoot, DEFAULT_DB_RELPATH);
+  mkdirSync3(posix6.dirname(dbPath), { recursive: true });
   const store = new NodeSqliteStore(dbPath);
   const parser = new TreeSitterParser();
   return new CodeIndexEngine({
@@ -3120,7 +3900,7 @@ function createNodeCodeIndex(opts) {
   });
 }
 function createCodeIndexSync(opts) {
-  const dbPath = opts.dbPath ?? posix4.join(opts.repoRoot, DEFAULT_DB_RELPATH);
+  const dbPath = opts.dbPath ?? posix6.join(opts.repoRoot, DEFAULT_DB_RELPATH);
   const projectKey = opts.projectKey ?? computeProjectKey(opts.repoRoot) ?? void 0;
   if (!projectKey) {
     throw new Error("No project_key \u2014 the repo has no git remote. Cloud sync scopes by sha256(remote); commit a remote or pass an explicit key.");
@@ -3163,8 +3943,8 @@ function createEmbedder() {
       if (texts.length === 0)
         return [];
       const extractor = await getExtractor();
-      const out = await extractor(texts, { pooling: "cls", normalize: true });
-      return out.tolist().map((v) => Float32Array.from(v));
+      const out2 = await extractor(texts, { pooling: "cls", normalize: true });
+      return out2.tolist().map((v) => Float32Array.from(v));
     },
     async embedQuery(text) {
       const [vec] = await embedder.embedDocuments([
@@ -3209,7 +3989,7 @@ function runOrtIsolated(argv) {
     stdio: ["ignore", "inherit", "inherit"],
     env: { ...process.env, [OK_FILE_ENV]: okFile }
   });
-  const ok = existsSync2(okFile);
+  const ok = existsSync4(okFile);
   try {
     rmSync(dirname3(okFile), { recursive: true, force: true });
   } catch {
@@ -3237,7 +4017,7 @@ function value(argv, name) {
 function resolveRoot(explicit) {
   if (explicit) return explicit;
   try {
-    return execFileSync4("git", ["rev-parse", "--show-toplevel"], {
+    return execFileSync5("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -3411,40 +4191,1397 @@ async function runIndexArch(opts) {
   }
 }
 
-// src/review.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+// src/launch-cmd.ts
+import { spawn, spawnSync as spawnSync2, execFileSync as execFileSync6 } from "node:child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname4, join as join5 } from "node:path";
 
-// ../../packages/code-index/build/index.js
-var CODE_INDEX_VERSION = "0.1.0";
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines2 = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines2.length, lines2.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines2 = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines2[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
 
-// src/review-render.ts
-var COMMENT_MARKER = "<!-- maind-review -->";
-var COMMENT_FINDINGS_CAP = 30;
-var FOOTER = "maind review \xB7 deterministic, provenance-backed";
-function buildReviewManifest(data, verdict, meta) {
-  const review = data.review;
-  return {
-    schema: "maind.review.manifest/v1",
-    generated_at: meta.generatedAt,
-    key_prefix: meta.keyPrefix,
-    run_ref: meta.runRef,
-    base: meta.base,
-    diff_stats: meta.diffStats,
-    symbol_count: meta.symbolCount,
-    risk_flags: review?.risk_flags ?? [],
-    findings: (review?.convention_findings ?? []).map((f) => ({
-      convention_id: f.convention_id,
-      version: f.convention_version,
-      severity: f.severity,
-      grade: f.grade,
-      matched_symbol_count: f.matched_symbols.length,
-      matched_changed_symbol_count: f.matched_changed_symbols?.length ?? 0
-    })),
-    served: (review?.lesson_hints ?? []).map((l) => ({
-      id: l.id,
-      version: typeof l.version === "number" ? l.version : null,
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/util.js
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str, ptr, sep2, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep2) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first)
+        seek++;
+      if (str[seek] === first)
+        seek++;
+    }
+  }
+  return seek;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "	",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  e: "\x1B",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r")
+      ptr++;
+    if (str[ptr] === "\n")
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== "\n" && str[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value2, toml, ptr, integersAsBigInt) {
+  if (value2 === "true")
+    return true;
+  if (value2 === "false")
+    return false;
+  if (value2 === "-inf")
+    return -Infinity;
+  if (value2 === "inf" || value2 === "+inf")
+    return Infinity;
+  if (value2 === "nan" || value2 === "+nan" || value2 === "-nan")
+    return NaN;
+  if (value2 === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value2);
+  if (isInt || FLOAT_REGEX.test(value2)) {
+    if (LEADING_ZERO.test(value2)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value2 = value2.replace(/_/g, "");
+    let numeric = +value2;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value2);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value2);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value2 = str.slice(startPtr, endPtr);
+  let commentIdx = value2.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value2 = value2.slice(0, commentIdx);
+  }
+  return [value2.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value2, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value2, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr);
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str,
+            ptr
+          });
+        }
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str, ptr, eos));
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value2, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value2);
+      t[k] = value2;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/stringify.js
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (obj instanceof Date)
+      return "date";
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0; i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  if (type === "number") {
+    if (isNaN(val))
+      return "nan";
+    if (val === Infinity)
+      return "inf";
+    if (val === -Infinity)
+      return "-inf";
+    if (numberAsFloat && Number.isInteger(val))
+      return val.toFixed(1);
+    return val.toString();
+  }
+  if (type === "bigint" || type === "boolean") {
+    return val.toString();
+  }
+  if (type === "string") {
+    return formatString(val);
+  }
+  if (type === "date") {
+    if (isNaN(val.getTime())) {
+      throw new TypeError("cannot serialize invalid date");
+    }
+    return val.toISOString();
+  }
+  if (type === "object") {
+    return stringifyInlineTable(val, depth, numberAsFloat);
+  }
+  if (type === "array") {
+    return stringifyArray(val, depth, numberAsFloat);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0; i < array.length; i++) {
+    if (i)
+      res += ", ";
+    if (array[i] === null || array[i] === void 0) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0; i < array.length; i++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str[str.length - 1] !== "\n")
+    return str + "\n";
+  return str;
+}
+
+// src/switchyard.ts
+var SWITCHYARD_BIN = "switchyard";
+var SWITCHYARD_INSTALL_ARGV = [
+  "tool",
+  "install",
+  "--python",
+  "3.12",
+  "nemo-switchyard[cli]"
+];
+var SWITCHYARD_INSTALL_ONELINER = 'uv tool install --python 3.12 "nemo-switchyard[cli]"';
+var UV_INSTALL_DOCS = "https://docs.astral.sh/uv/getting-started/installation/";
+var DEFAULT_ROUTE = "switchyard";
+var ROUTES_FILENAME = "switchyard-routes.toml";
+var STARTUP_GRACE_MS = 5e3;
+var LAUNCH_TEMPLATE_ID = "tmpl_switchyard_routes_default";
+var ANTHROPIC_CAPABLE_ID = "anthropic/claude-opus-5";
+var ANTHROPIC_EFFICIENT_ID = "anthropic/claude-haiku-4-5-20251001";
+var OPENROUTER_CAPABLE_ID = "openrouter/anthropic/claude-opus-5";
+var OPENROUTER_EFFICIENT_ID = "openrouter/anthropic/claude-haiku-4-5";
+var SUPPORTED_AGENTS = ["claude"];
+var PLANNED_AGENTS = ["codex", "openclaw"];
+function classifyAgent(agent) {
+  if (agent === "claude") return { kind: "supported", agent };
+  if (agent !== null && PLANNED_AGENTS.includes(agent)) return { kind: "planned", agent };
+  return { kind: "unknown", agent };
+}
+function chooseBackend(env) {
+  const hasAnthropic = (env.ANTHROPIC_API_KEY ?? "").trim().length > 0;
+  const hasOpenRouter = (env.OPENROUTER_API_KEY ?? "").trim().length > 0;
+  if (hasAnthropic) {
+    return {
+      kind: "anthropic",
+      capableId: ANTHROPIC_CAPABLE_ID,
+      efficientId: ANTHROPIC_EFFICIENT_ID,
+      warning: null
+    };
+  }
+  if (hasOpenRouter) {
+    return {
+      kind: "openrouter",
+      capableId: OPENROUTER_CAPABLE_ID,
+      efficientId: OPENROUTER_EFFICIENT_ID,
+      warning: null
+    };
+  }
+  return {
+    kind: "none",
+    capableId: OPENROUTER_CAPABLE_ID,
+    efficientId: OPENROUTER_EFFICIENT_ID,
+    warning: "no backend API key found (ANTHROPIC_API_KEY or OPENROUTER_API_KEY) \u2014 the proxy will start but upstream requests will fail until one is exported."
+  };
+}
+var CAPABLE_TARGET = "capable";
+var EFFICIENT_TARGET = "efficient";
+function policyHeader(backend, policySource) {
+  return [
+    "# Generated by `maind launch` (Agent Switchyard Phase 1, maind.dev \u2014 ADR-272).",
+    "# Regenerated on every launch; do not hand-edit. For a custom policy use",
+    "# `maind launch <agent> --config <path>`.",
+    "#",
+    `# Routing policy: ${policySource === "curated" ? "curated (maind content plane)" : "builtin default"}`,
+    "# \u2014 deterministic stage routing (NVIDIA NeMo Switchyard `stage_router`).",
+    "#   effort low/medium     -> efficient_target (fast tier)",
+    "#   effort high/xhigh/max -> capable_target  (strong tier)",
+    "# picker `efficient_first` + confidence_threshold 0.5: steady write progress",
+    "# keeps the efficient tier; corroborating error/exploration signals escalate",
+    "# to the capable tier.",
+    "#",
+    `# Backend: ${backend.kind === "none" ? "openrouter (EXAMPLE \u2014 no API key detected)" : backend.kind}`,
+    "# \u2014 detected locally from the environment, never from the policy source.",
+    "# API keys are read from the environment by the proxy at runtime \u2014 never",
+    "# stored in this file.",
+    ""
+  ].join("\n");
+}
+function defaultRouteTable(routeName) {
+  return {
+    [routeName]: {
+      type: "stage_router",
+      capable_target: CAPABLE_TARGET,
+      efficient_target: EFFICIENT_TARGET,
+      picker: "efficient_first",
+      confidence_threshold: 0.5
+    }
+  };
+}
+function buildRoutesToml(routeName, backend, curatedRoutes = null) {
+  const doc = {
+    targets: {
+      [CAPABLE_TARGET]: { id: backend.capableId },
+      [EFFICIENT_TARGET]: { id: backend.efficientId }
+    },
+    routes: curatedRoutes ?? defaultRouteTable(routeName)
+  };
+  return policyHeader(backend, curatedRoutes ? "curated" : "builtin") + stringify(doc) + "\n";
+}
+function acceptPolicyTemplate(body, routeName) {
+  let parsed;
+  try {
+    parsed = parse(body);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const doc = parsed;
+  if ("targets" in doc) return null;
+  const routes = doc.routes;
+  if (typeof routes !== "object" || routes === null) return null;
+  const table = routes;
+  const route = table[routeName];
+  if (typeof route !== "object" || route === null) return null;
+  for (const key of ["capable_target", "efficient_target"]) {
+    const ref = route[key];
+    if (ref !== void 0 && ref !== CAPABLE_TARGET && ref !== EFFICIENT_TARGET) return null;
+  }
+  return table;
+}
+function acceptRoutesToml(body, routeName) {
+  let parsed;
+  try {
+    parsed = parse(body);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const routes = parsed.routes;
+  if (typeof routes !== "object" || routes === null) return null;
+  if (!(routeName in routes)) return null;
+  return body;
+}
+function buildSwitchyardArgv(bin, agent, routeName, configPath) {
+  return [bin, "launch", agent, "--model", routeName, "--config", configPath];
+}
+function buildDirectArgv(agent) {
+  return [agent];
+}
+var SIGNAL_NUMBERS = {
+  SIGHUP: 1,
+  SIGINT: 2,
+  SIGQUIT: 3,
+  SIGKILL: 9,
+  SIGTERM: 15
+};
+function exitCodeFromChild(code, signal) {
+  if (code !== null) return code;
+  if (signal !== null) {
+    const num2 = SIGNAL_NUMBERS[signal];
+    return num2 !== void 0 ? 128 + num2 : 1;
+  }
+  return 1;
+}
+function classifyChildExit(code, signal, elapsedMs) {
+  if (signal !== null) return "propagate";
+  if (code === 0) return "propagate";
+  return elapsedMs < STARTUP_GRACE_MS ? "fallback-eligible" : "propagate";
+}
+function buildInstallAnnouncement() {
+  return `switchyard not found \u2014 installing via uv: ${SWITCHYARD_INSTALL_ONELINER}`;
+}
+function buildUvMissingMessage() {
+  return `switchyard is not installed and \`uv\` is missing, so maind will not install it for you.
+maind: install uv (${UV_INSTALL_DOCS}), then run:
+maind:   ${SWITCHYARD_INSTALL_ONELINER}
+maind: and re-run \`maind launch claude\`. (Or launch without routing: \`maind launch claude --direct\`.)`;
+}
+function buildInstallStillMissingMessage() {
+  return "switchyard still not reachable after install \u2014 uv's bin dir may be missing from PATH (try `uv tool update-shell`, then open a new terminal).";
+}
+function buildFallbackBanner(reason) {
+  return [
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    ` switchyard proxy unavailable: ${reason}`,
+    " launching claude DIRECTLY \u2014 no model routing for this session.",
+    " (disable this fallback with --no-fallback)",
+    "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
+  ].join("\n");
+}
+function buildDirectBanner() {
+  return "launching claude directly (--direct) \u2014 no switchyard proxy, no model routing.";
+}
+function renderDryRun(plan, json) {
+  if (json) {
+    const payload = {
+      agent: plan.agent,
+      config_path: plan.configPath,
+      config_source: plan.configSource,
+      toml: plan.toml,
+      argv: plan.argv,
+      backend: plan.backendKind,
+      switchyard_detected: plan.switchyardDetected
+    };
+    return { stdout: JSON.stringify(payload, null, 2) + "\n", stderr: "" };
+  }
+  const stderr = [
+    `maind: dry-run \u2014 nothing installed, written, or spawned.`,
+    `maind: config ${plan.configPath} (${plan.configSource})`,
+    `maind: switchyard detected: ${plan.switchyardDetected ? "yes" : "no"}`,
+    `maind: would run: ${plan.argv.join(" ")}`
+  ].join("\n");
+  return {
+    stdout: plan.toml ?? `(using existing config: ${plan.configPath})
+`,
+    stderr: stderr + "\n"
+  };
+}
+
+// src/version.ts
+import { createRequire as createRequire3 } from "node:module";
+function resolveVersion() {
+  if (true) return "0.10.0";
+  try {
+    const require2 = createRequire3(import.meta.url);
+    return require2("../package.json").version;
+  } catch {
+    return "0.0.0-unknown";
+  }
+}
+var VERSION = resolveVersion();
+
+// src/launch-cmd.ts
+var TEMPLATE_FETCH_TIMEOUT_MS = 5e3;
+function err(line) {
+  process.stderr.write(`maind: ${line}
+`);
+}
+function msg5(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--config", "--route", "--mcp-url"]);
+function parseLaunchArgs(argv) {
+  const get = (name) => {
+    const i = argv.indexOf(name);
+    if (i === -1 || i + 1 >= argv.length) return void 0;
+    return argv[i + 1];
+  };
+  const has = (name) => argv.includes(name);
+  let agent = null;
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok.startsWith("-")) {
+      if (VALUE_FLAGS.has(tok)) i++;
+      continue;
+    }
+    agent = tok;
+    break;
+  }
+  return {
+    agent,
+    dryRun: has("--dry-run"),
+    config: get("--config") ?? null,
+    route: get("--route") ?? DEFAULT_ROUTE,
+    direct: has("--direct"),
+    noFallback: has("--no-fallback"),
+    noInstall: has("--no-install"),
+    json: has("--json"),
+    mcpUrl: get("--mcp-url") ?? null
+  };
+}
+var realLaunchDeps = {
+  probe(bin, args) {
+    const res = spawnSync2(bin, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    const ok = res.status === 0 && !res.error;
+    const out2 = typeof res.stdout === "string" ? res.stdout.trim() : "";
+    return { ok, stdout: out2.length > 0 ? out2 : null };
+  },
+  install(argv) {
+    const res = spawnSync2("uv", [...argv], { stdio: ["ignore", "inherit", "inherit"] });
+    return res.status;
+  },
+  spawnInteractive(argv) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+      let settled = false;
+      const child = spawn(argv[0], argv.slice(1), { stdio: "inherit", env: process.env });
+      const onSigint = () => {
+      };
+      const makeForward = (sig) => () => {
+        try {
+          child.kill(sig);
+        } catch {
+        }
+      };
+      const onSigterm = makeForward("SIGTERM");
+      const onSighup = makeForward("SIGHUP");
+      process.on("SIGINT", onSigint);
+      process.on("SIGTERM", onSigterm);
+      process.on("SIGHUP", onSighup);
+      const cleanup = () => {
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGTERM", onSigterm);
+        process.removeListener("SIGHUP", onSighup);
+      };
+      child.on("error", (e) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve({ code: null, signal: null, elapsedMs: Date.now() - start, spawnError: e.message });
+      });
+      child.on("exit", (code, signal) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve({ code, signal, elapsedMs: Date.now() - start, spawnError: null });
+      });
+    });
+  },
+  async fetchTemplate(mcpUrl, projectKey) {
+    let auth;
+    try {
+      auth = resolveAuth();
+    } catch (e) {
+      if (e instanceof MissingApiKeyError) return null;
+      throw e;
+    }
+    try {
+      const client = new McpClient({
+        apiKey: auth.apiKey,
+        deviceId: auth.deviceId,
+        clientVersion: VERSION,
+        mcpUrl: mcpUrl ?? void 0,
+        projectKey
+      });
+      const timeout = new Promise((resolve) => {
+        const t = setTimeout(() => resolve(null), TEMPLATE_FETCH_TIMEOUT_MS);
+        t.unref();
+      });
+      const call = client.callTool("get_template", { template_id: LAUNCH_TEMPLATE_ID }).then(
+        (r) => typeof r.template_body === "string" && r.template_body.trim().length > 0 ? r.template_body : null
+      ).catch(() => null);
+      return await Promise.race([call, timeout]);
+    } catch {
+      return null;
+    }
+  },
+  writeConfig(path, content) {
+    const dir = dirname4(path);
+    if (dir && dir !== ".") mkdirSync4(dir, { recursive: true });
+    writeFileSync4(path, content, "utf8");
+  },
+  readFile(path) {
+    try {
+      return readFileSync6(path, "utf8");
+    } catch {
+      return null;
+    }
+  },
+  fileExists(path) {
+    return existsSync5(path);
+  },
+  repoRoot() {
+    try {
+      const out2 = execFileSync6("git", ["rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5e3
+      }).trim();
+      return out2.length > 0 ? out2 : null;
+    } catch {
+      return null;
+    }
+  },
+  projectKey() {
+    return gatherGitState().projectKey;
+  },
+  userConfigDir() {
+    return configDir();
+  },
+  homeDir() {
+    return homedir2();
+  },
+  env: process.env,
+  platform: process.platform
+};
+function resolveRoutesPath(repoRoot2, userConfigDir) {
+  return repoRoot2 !== null ? join5(repoRoot2, ".maind", ROUTES_FILENAME) : join5(userConfigDir, ROUTES_FILENAME);
+}
+async function runLaunch(opts, deps = realLaunchDeps) {
+  const verdict = classifyAgent(opts.agent);
+  if (verdict.kind === "unknown") {
+    err(
+      `usage: maind launch <agent> [--dry-run] [--config <path>] [--route <name>] [--direct] [--no-fallback] [--no-install] \u2014 supported: ${SUPPORTED_AGENTS.join(", ")}`
+    );
+    return 2;
+  }
+  if (verdict.kind === "planned") {
+    err(
+      `agent '${verdict.agent}' is planned but not yet supported \u2014 v1 supports: ${SUPPORTED_AGENTS.join(", ")}.`
+    );
+    return 2;
+  }
+  if (opts.json && !opts.dryRun) {
+    err("--json is only valid together with --dry-run (stdout belongs to the agent session).");
+    return 2;
+  }
+  const agent = verdict.agent;
+  if (opts.direct) {
+    err(buildDirectBanner());
+    return spawnAndPropagate(deps, buildDirectArgv(agent));
+  }
+  const backend = chooseBackend(deps.env);
+  if (backend.warning !== null) err(backend.warning);
+  let configPath;
+  let toml;
+  let source;
+  if (opts.config !== null) {
+    if (!deps.fileExists(opts.config)) {
+      err(`config not found: ${opts.config}`);
+      return 2;
+    }
+    const body = deps.readFile(opts.config);
+    if (body === null || acceptRoutesToml(body, opts.route) === null) {
+      err(`config ${opts.config} is not valid routes TOML with a [routes.${opts.route}] entry.`);
+      return 2;
+    }
+    configPath = opts.config;
+    toml = null;
+    source = "flag";
+  } else {
+    const template = await deps.fetchTemplate(opts.mcpUrl, deps.projectKey());
+    const curatedRoutes = template === null ? null : acceptPolicyTemplate(template, opts.route);
+    toml = buildRoutesToml(opts.route, backend, curatedRoutes);
+    if (curatedRoutes !== null) {
+      source = "template";
+    } else {
+      source = "builtin";
+      const reason = template === null ? "no curated template (offline, unauthenticated, or not published)" : `curated template unusable (missing route '${opts.route}', or it pins its own targets)`;
+      err(`using builtin routing policy (${reason}).`);
+    }
+    configPath = resolveRoutesPath(deps.repoRoot(), deps.userConfigDir());
+  }
+  let bin = SWITCHYARD_BIN;
+  let detected = deps.probe(SWITCHYARD_BIN, ["--version"]).ok;
+  if (opts.dryRun) {
+    const plan = {
+      agent,
+      configPath,
+      configSource: source,
+      toml,
+      argv: buildSwitchyardArgv(bin, agent, opts.route, configPath),
+      backendKind: backend.kind,
+      switchyardDetected: detected
+    };
+    const out2 = renderDryRun(plan, opts.json);
+    if (out2.stderr.length > 0) process.stderr.write(out2.stderr);
+    process.stdout.write(out2.stdout);
+    return 0;
+  }
+  if (!detected) {
+    if (opts.noInstall) {
+      err(`switchyard not found (--no-install). Install it with:
+maind:   ${SWITCHYARD_INSTALL_ONELINER}`);
+      return 1;
+    }
+    if (!deps.probe("uv", ["--version"]).ok) {
+      err(buildUvMissingMessage());
+      return 1;
+    }
+    err(buildInstallAnnouncement());
+    deps.install(SWITCHYARD_INSTALL_ARGV);
+    if (deps.probe(SWITCHYARD_BIN, ["--version"]).ok) {
+      detected = true;
+    } else {
+      const shim = join5(
+        deps.homeDir(),
+        ".local",
+        "bin",
+        deps.platform === "win32" ? "switchyard.exe" : "switchyard"
+      );
+      if (deps.probe(shim, ["--version"]).ok) {
+        bin = shim;
+        detected = true;
+      }
+    }
+    if (!detected) {
+      return degradeOrFail(deps, opts, agent, buildInstallStillMissingMessage());
+    }
+  }
+  if (source !== "flag" && toml !== null) {
+    try {
+      deps.writeConfig(configPath, toml);
+    } catch (e) {
+      err(`could not write ${configPath}: ${msg5(e)}`);
+      return 1;
+    }
+  }
+  const result = await deps.spawnInteractive(buildSwitchyardArgv(bin, agent, opts.route, configPath));
+  if (result.spawnError !== null) {
+    return degradeOrFail(deps, opts, agent, `could not start switchyard (${result.spawnError})`);
+  }
+  if (classifyChildExit(result.code, result.signal, result.elapsedMs) === "fallback-eligible") {
+    return degradeOrFail(
+      deps,
+      opts,
+      agent,
+      `switchyard exited with code ${result.code} after ${(result.elapsedMs / 1e3).toFixed(1)}s`
+    );
+  }
+  return exitCodeFromChild(result.code, result.signal);
+}
+async function degradeOrFail(deps, opts, agent, reason) {
+  if (opts.noFallback) {
+    err(`${reason} (--no-fallback set \u2014 not degrading to a direct spawn).`);
+    return 1;
+  }
+  process.stderr.write(buildFallbackBanner(reason) + "\n");
+  return spawnAndPropagate(deps, buildDirectArgv(agent));
+}
+async function spawnAndPropagate(deps, argv) {
+  const result = await deps.spawnInteractive(argv);
+  if (result.spawnError !== null) {
+    err(`'${argv[0]}' not found on PATH \u2014 install the agent CLI first (${result.spawnError}).`);
+    return 1;
+  }
+  return exitCodeFromChild(result.code, result.signal);
+}
+
+// src/review.ts
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+
+// ../../packages/code-index/build/index.js
+var CODE_INDEX_VERSION = "0.1.0";
+
+// src/review-render.ts
+var COMMENT_MARKER = "<!-- maind-review -->";
+var COMMENT_FINDINGS_CAP = 30;
+var FOOTER = "maind review \xB7 deterministic, provenance-backed";
+function buildReviewManifest(data, verdict, meta) {
+  const review = data.review;
+  return {
+    schema: "maind.review.manifest/v1",
+    generated_at: meta.generatedAt,
+    key_prefix: meta.keyPrefix,
+    run_ref: meta.runRef,
+    base: meta.base,
+    diff_stats: meta.diffStats,
+    symbol_count: meta.symbolCount,
+    risk_flags: review?.risk_flags ?? [],
+    findings: (review?.convention_findings ?? []).map((f) => ({
+      convention_id: f.convention_id,
+      version: f.convention_version,
+      severity: f.severity,
+      grade: f.grade,
+      matched_symbol_count: f.matched_symbols.length,
+      matched_changed_symbol_count: f.matched_changed_symbols?.length ?? 0
+    })),
+    served: (review?.lesson_hints ?? []).map((l) => ({
+      id: l.id,
+      version: typeof l.version === "number" ? l.version : null,
       tier: l.tier ?? null
     })),
     verdict: verdict?.ok === true && typeof verdict.verdict === "string" ? {
@@ -3500,132 +5637,132 @@ function renderReviewMarkdown(data, verdict, meta) {
   const findings = review?.convention_findings ?? [];
   const hints = review?.lesson_hints ?? [];
   const riskFlags = review?.risk_flags ?? [];
-  const lines = [];
-  lines.push("<!-- Generated by `maind review` \u2014 do not edit by hand. -->");
-  lines.push(
+  const lines2 = [];
+  lines2.push("<!-- Generated by `maind review` \u2014 do not edit by hand. -->");
+  lines2.push(
     `<!-- generated_at: ${meta.generatedAt} | key: ${meta.keyPrefix}${meta.runRef ? ` | run: ${meta.runRef}` : ""} -->`
   );
-  lines.push("");
-  lines.push("# maind review");
-  lines.push("");
-  lines.push(
+  lines2.push("");
+  lines2.push("# maind review");
+  lines2.push("");
+  lines2.push(
     `Reviewed ${baseLabel(meta)}: ${meta.symbolCount} changed symbol(s) across ${meta.diffStats?.changed_file_count ?? 0} file(s) \xB7 findings: ${findings.length} \xB7 risk flags: ${riskFlags.length} \xB7 lesson hints: ${hints.length}`
   );
-  lines.push("");
+  lines2.push("");
   if (verdict?.ok === true && verdict.verdict) {
-    lines.push(verdictLabel(verdict));
+    lines2.push(verdictLabel(verdict));
     const attest = attestationLine(verdict);
     if (attest) {
-      lines.push("");
-      lines.push(attest);
+      lines2.push("");
+      lines2.push(attest);
     }
     if (verdict.trust_note) {
-      lines.push("");
-      lines.push(`_${verdict.trust_note}_`);
+      lines2.push("");
+      lines2.push(`_${verdict.trust_note}_`);
     }
-    lines.push("");
+    lines2.push("");
   }
   if (findings.length > 0) {
-    lines.push("## Convention findings");
-    lines.push("");
-    for (const f of findings) lines.push(findingLine(f));
-    lines.push("");
+    lines2.push("## Convention findings");
+    lines2.push("");
+    for (const f of findings) lines2.push(findingLine(f));
+    lines2.push("");
   } else {
-    lines.push("## Convention findings");
-    lines.push("");
-    lines.push("_No convention findings for this change set._");
-    lines.push("");
+    lines2.push("## Convention findings");
+    lines2.push("");
+    lines2.push("_No convention findings for this change set._");
+    lines2.push("");
   }
   if (riskFlags.length > 0) {
-    lines.push("## Risk flags");
-    lines.push("");
-    lines.push(
+    lines2.push("## Risk flags");
+    lines2.push("");
+    lines2.push(
       "_Path heuristics from the local diff \u2014 informational, they never block._"
     );
-    lines.push("");
-    for (const flag2 of riskFlags) lines.push(`- \`${flag2}\``);
-    lines.push("");
+    lines2.push("");
+    for (const flag2 of riskFlags) lines2.push(`- \`${flag2}\``);
+    lines2.push("");
   }
   if (hints.length > 0) {
-    lines.push("## Lesson hints");
-    lines.push("");
-    lines.push("_Semantic suggestions \u2014 advisory, never part of a verdict._");
-    lines.push("");
+    lines2.push("## Lesson hints");
+    lines2.push("");
+    lines2.push("_Semantic suggestions \u2014 advisory, never part of a verdict._");
+    lines2.push("");
     for (const h of hints) {
       const parts = [`\`${h.id}\``];
       if (h.tier) parts.push(h.tier);
       if (h.match_reason) parts.push(h.match_reason);
-      lines.push(`- **${h.title}** (${parts.join(" \xB7 ")})`);
+      lines2.push(`- **${h.title}** (${parts.join(" \xB7 ")})`);
     }
-    lines.push("");
+    lines2.push("");
   }
   const rc = review?.regression_context;
   if (rc && (rc.hot_files ?? 0) > 0) {
-    lines.push("");
-    lines.push(
+    lines2.push("");
+    lines2.push(
       `_History: ${rc.hot_files}/${rc.files_scanned ?? "?"} changed file(s) high-churn (max ${rc.max_recent_commits ?? "?"} commits in the last ${rc.window_commits ?? "?"}-commit window, ${rc.distinct_authors ?? "?"} author(s))._`
     );
   }
   if (review?.coverage_note) {
-    lines.push("## Coverage");
-    lines.push("");
-    lines.push(`> ${review.coverage_note}`);
-    lines.push("");
+    lines2.push("## Coverage");
+    lines2.push("");
+    lines2.push(`> ${review.coverage_note}`);
+    lines2.push("");
   }
-  lines.push("---");
-  lines.push(FOOTER);
-  lines.push("");
-  return lines.join("\n");
+  lines2.push("---");
+  lines2.push(FOOTER);
+  lines2.push("");
+  return lines2.join("\n");
 }
 function renderReviewComment(data, verdict, meta, reportPath) {
   const review = data.review;
   const findings = review?.convention_findings ?? [];
   const riskFlags = review?.risk_flags ?? [];
   const hints = review?.lesson_hints ?? [];
-  const lines = [];
-  lines.push(COMMENT_MARKER);
-  lines.push("## maind review");
-  lines.push("");
+  const lines2 = [];
+  lines2.push(COMMENT_MARKER);
+  lines2.push("## maind review");
+  lines2.push("");
   if (verdict?.ok === true && verdict.verdict) {
-    lines.push(verdictLabel(verdict));
+    lines2.push(verdictLabel(verdict));
     const attest = attestationLine(verdict);
-    if (attest) lines.push(attest);
-    lines.push("");
+    if (attest) lines2.push(attest);
+    lines2.push("");
   }
   if (findings.length === 0) {
-    lines.push(
+    lines2.push(
       `No convention findings for this change set (${meta.symbolCount} changed symbol(s) reviewed ${baseLabel(meta)}).`
     );
-    lines.push("");
+    lines2.push("");
   } else {
     const shown = findings.slice(0, COMMENT_FINDINGS_CAP);
-    for (const f of shown) lines.push(findingLine(f));
+    for (const f of shown) lines2.push(findingLine(f));
     if (findings.length > shown.length) {
-      lines.push("");
-      lines.push(
+      lines2.push("");
+      lines2.push(
         `\u2026and ${findings.length - shown.length} more finding(s) \u2014 see the \`${reportPath}\` build artifact.`
       );
     }
-    lines.push("");
+    lines2.push("");
   }
   if (riskFlags.length > 0) {
-    lines.push(
+    lines2.push(
       `**Risk flags:** ${riskFlags.map((f) => `\`${f}\``).join(" \xB7 ")} _(heuristics, never blocking)_`
     );
-    lines.push("");
+    lines2.push("");
   }
   if (hints.length > 0) {
-    lines.push("**Related lessons:** " + hints.map((h) => `\`${h.id}\``).join(" \xB7 "));
-    lines.push("");
+    lines2.push("**Related lessons:** " + hints.map((h) => `\`${h.id}\``).join(" \xB7 "));
+    lines2.push("");
   }
   if (review?.coverage_note) {
-    lines.push(`> ${review.coverage_note}`);
-    lines.push("");
+    lines2.push(`> ${review.coverage_note}`);
+    lines2.push("");
   }
-  lines.push("---");
-  lines.push(`_${FOOTER}_`);
-  lines.push("");
-  return lines.join("\n");
+  lines2.push("---");
+  lines2.push(`_${FOOTER}_`);
+  lines2.push("");
+  return lines2.join("\n");
 }
 function renderFailOpenReview(meta, reason) {
   return [
@@ -3655,7 +5792,7 @@ function renderFailOpenComment(meta, reason) {
 
 // src/review.ts
 var PROJECT_KEY_RE3 = /^[a-f0-9]{64}$/;
-var CLI_CLIENT_VERSION = "0.7.0";
+var CLI_CLIENT_VERSION = VERSION;
 var DEFAULT_COMMENT_PATH = ".maind/review-comment.md";
 var SYMBOL_CAP = 64;
 function parseReviewArgs(argv) {
@@ -3694,12 +5831,12 @@ function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function writeArtifact3(path, content) {
-  const dir = dirname4(path);
-  if (dir && dir !== ".") mkdirSync4(dir, { recursive: true });
-  writeFileSync4(path, content, "utf8");
+  const dir = dirname5(path);
+  if (dir && dir !== ".") mkdirSync5(dir, { recursive: true });
+  writeFileSync5(path, content, "utf8");
 }
-function manifestPathFor(out) {
-  return out.endsWith(".md") ? out.slice(0, -3) + ".json" : out + ".json";
+function manifestPathFor(out2) {
+  return out2.endsWith(".md") ? out2.slice(0, -3) + ".json" : out2 + ".json";
 }
 function verdictCrossesFailOn(verdict, failOn) {
   return failOn === "block" ? verdict === "block" : verdict === "block" || verdict === "warn";
@@ -3721,7 +5858,7 @@ function buildDiffStats(result) {
 }
 function resolveRepoRoot() {
   try {
-    return execFileSync5("git", ["rev-parse", "--show-toplevel"], {
+    return execFileSync7("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -3744,25 +5881,27 @@ async function runReview(opts) {
   if (opts.failOn && !opts.gate) {
     warn5("--fail-on has no effect without --gate (advisory runs always exit 0).");
   }
-  const failOpen = (reason) => {
-    warn5(`review unavailable, ${opts.strict ? "failing (--strict)" : "continuing"}: ${reason}`);
+  const failOpen = (reason, klass = "infra") => {
+    const hard = opts.strict && klass === "infra";
+    warn5(`review unavailable, ${hard ? "failing (--strict)" : "continuing"}: ${reason}`);
     try {
       writeArtifact3(opts.out, renderFailOpenReview(meta, reason));
       const manifest = buildReviewManifest({}, null, meta);
       manifest.error = reason;
+      manifest.error_class = klass;
       writeArtifact3(manifestPathFor(opts.out), JSON.stringify(manifest, null, 2) + "\n");
       if (opts.comment) writeArtifact3(opts.comment, renderFailOpenComment(meta, reason));
       if (opts.json) process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
     } catch (writeErr) {
-      warn5(`could not write fail-open artifacts: ${msg5(writeErr)}`);
+      warn5(`could not write fail-open artifacts: ${msg6(writeErr)}`);
       return opts.strict ? 2 : 1;
     }
-    return opts.strict ? 2 : 0;
+    return hard ? 2 : 0;
   };
   try {
     const root = resolveRepoRoot();
     if (!root) {
-      return failOpen("not a git repository \u2014 review is diff-based.");
+      return failOpen("not a git repository \u2014 review is diff-based.", "expected");
     }
     const engine = createNodeCodeIndex({ repoRoot: root });
     let result;
@@ -3843,7 +5982,8 @@ async function runReview(opts) {
     const review = await client.callTool("review_changes", reviewArgs);
     if (review.ok !== true || !review.review) {
       return failOpen(
-        `review_changes rejected: ${review.error ?? "unknown_error"}${review.message ? ` \u2014 ${review.message}` : ""}`
+        `review_changes rejected: ${review.error ?? "unknown_error"}${review.message ? ` \u2014 ${review.message}` : ""}`,
+        classifyServerError(review.error)
       );
     }
     let verdict = null;
@@ -3875,9 +6015,11 @@ async function runReview(opts) {
             );
             verdict = null;
           } else {
-            if (opts.strict) {
+            const klass = classifyServerError(verdict.error);
+            if (opts.strict && klass === "infra") {
               return failOpen(
-                `review_verdict failed: ${verdict.error ?? "unknown_error"}${verdict.message ? ` \u2014 ${verdict.message}` : ""}`
+                `review_verdict failed: ${verdict.error ?? "unknown_error"}${verdict.message ? ` \u2014 ${verdict.message}` : ""}`,
+                klass
               );
             }
             warn5(
@@ -3886,9 +6028,9 @@ async function runReview(opts) {
             verdict = null;
           }
         }
-      } catch (err2) {
-        if (opts.strict) return failOpen(`review_verdict failed: ${msg5(err2)}`);
-        warn5(`gate unavailable (continuing advisory): ${msg5(err2)}`);
+      } catch (err4) {
+        if (opts.strict) return failOpen(`review_verdict failed: ${msg6(err4)}`, "infra");
+        warn5(`gate unavailable (continuing advisory): ${msg6(err4)}`);
         verdict = null;
       }
     }
@@ -3909,10 +6051,21 @@ async function runReview(opts) {
       }
     }
     return 0;
-  } catch (err2) {
-    const reason = err2 instanceof MissingApiKeyError ? err2.message : msg5(err2);
-    return failOpen(reason);
-  }
+  } catch (err4) {
+    if (err4 instanceof MissingApiKeyError) return failOpen(err4.message, "expected");
+    return failOpen(msg6(err4), "infra");
+  }
+}
+var EXPECTED_SERVER_ERRORS = /* @__PURE__ */ new Set([
+  "unauthorized",
+  "invalid_api_key",
+  "requires_team",
+  "requires_enterprise",
+  "scope_not_in_plan",
+  "rate_limited"
+]);
+function classifyServerError(code) {
+  return code && EXPECTED_SERVER_ERRORS.has(code) ? "expected" : "infra";
 }
 function writeAll(review, verdict, meta, opts) {
   writeArtifact3(opts.out, renderReviewMarkdown(review, verdict, meta));
@@ -3923,25 +6076,524 @@ function writeAll(review, verdict, meta, opts) {
   }
   if (opts.json) process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
 }
-function msg5(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
+function msg6(err4) {
+  return err4 instanceof Error ? err4.message : String(err4);
 }
 function warn5(line) {
   process.stderr.write(`maind review: ${line}
 `);
 }
 
+// ../../packages/claude-code-telemetry/dist/session-analysis.js
+import { createReadStream, existsSync as existsSync6 } from "node:fs";
+import { createInterface } from "node:readline";
+
+// ../../packages/claude-code-telemetry/dist/effort.js
+var LEVELS = /* @__PURE__ */ new Set([
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
+var DIRECTIVE_RE = /(?:^|\s)\/(low|medium|high|xhigh|max)(?=\s|$|[!?.,;:])/gi;
+function detectEffortLevel(messageText) {
+  if (!messageText)
+    return null;
+  let last = null;
+  for (const match of messageText.matchAll(DIRECTIVE_RE)) {
+    const lvl = match[1].toLowerCase();
+    if (LEVELS.has(lvl))
+      last = lvl;
+  }
+  return last;
+}
+
+// ../../packages/claude-code-telemetry/dist/session-analysis.js
+var ANALYZER_VERSION = "2026-08-04";
+var REWORK_RE = /(\brückgängig\b|zurücknehmen|\bnochmal(s)?\b|noch mal|\brevert\b|\bundo\b|\bredo\b|stattdessen|\binstead\b|mach(e)? das (nochmal|neu)|try again)/i;
+var CORRECTION_RE = /(\bnein\b|\bfalsch\b|stimmt nicht|das ist nicht|so nicht|\bnicht so\b|warum hast du|wieso hast du|\bno\b|\bnope\b|\bwrong\b|\bincorrect\b|that'?s not|that is not|\bdon'?t\b|\bdoesn'?t\b|shouldn'?t)/i;
+var ACCEPTANCE_RE = /(\bdanke\b|\bperfekt\b|\bsuper\b|\bpasst\b|\bgenau\b|sieht gut|\bcommit\b|\bship\b|\bmerge\b|\bpush\b|looks good|\blgtm\b|\bthanks\b|thank you|\bperfect\b|\bgreat\b|\bexactly\b|\bnice\b|well done|👍|✅|🎉)/i;
+var INTERRUPT_MARKER = "[Request interrupted by user";
+var DENIAL_MARKER = "The user doesn't want to proceed with this tool use";
+var SYNTHETIC_MODEL = "<synthetic>";
+var MOMENTUM_DECAY = 0.7;
+var MAG = {
+  denial: 1.5,
+  interrupt: 1.25,
+  rework: 1.5,
+  correction: 1,
+  acceptance: 1,
+  repeat: 0.75
+};
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function bumpModel(acc, model, sidechain, outputTokens, ts) {
+  const key = `${sidechain ? "s" : "m"}:${model}`;
+  const cur = acc.get(key);
+  if (!cur) {
+    acc.set(key, {
+      model,
+      turns: 1,
+      output_tokens: outputTokens,
+      first_ts: ts,
+      last_ts: ts,
+      sidechain
+    });
+    return;
+  }
+  cur.turns++;
+  cur.output_tokens += outputTokens;
+  if (ts > 0) {
+    if (cur.first_ts === 0 || ts < cur.first_ts)
+      cur.first_ts = ts;
+    if (ts > cur.last_ts)
+      cur.last_ts = ts;
+  }
+}
+function asBlocks(content) {
+  if (typeof content === "string")
+    return [{ type: "text", text: content }];
+  if (!Array.isArray(content))
+    return [];
+  return content.filter((b) => b !== null && typeof b === "object");
+}
+function textOf(blocks) {
+  const parts = [];
+  for (const b of blocks) {
+    if (b.type === "text" && typeof b.text === "string")
+      parts.push(b.text);
+  }
+  return parts.join("\n");
+}
+function isRepeat(prev, cur) {
+  const toks = (s) => new Set(s.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 2));
+  const a = toks(prev);
+  const b = toks(cur);
+  if (a.size < 3 || b.size < 3)
+    return false;
+  const [small, big] = a.size <= b.size ? [a, b] : [b, a];
+  let shared = 0;
+  for (const w of small)
+    if (big.has(w))
+      shared++;
+  return shared / small.size >= 0.8;
+}
+function classifyGenuine(text, prevText, priorWork) {
+  if (REWORK_RE.test(text))
+    return { polarity: -1, magnitude: MAG.rework, kind: "rework" };
+  if (priorWork && CORRECTION_RE.test(text))
+    return { polarity: -1, magnitude: MAG.correction, kind: "correction" };
+  if (ACCEPTANCE_RE.test(text))
+    return { polarity: 1, magnitude: MAG.acceptance, kind: "acceptance" };
+  if (prevText !== null && isRepeat(prevText, text))
+    return { polarity: -1, magnitude: MAG.repeat, kind: "repeat" };
+  return { polarity: 0, magnitude: 0, kind: "neutral" };
+}
+function emptyAnalysis(sessionId) {
+  return {
+    session_id: sessionId,
+    user_turns: 0,
+    assistant_turns: 0,
+    tool_calls: 0,
+    agent_questions: 0,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_creation_tokens: 0,
+    user_chars: 0,
+    user_token_estimate: 0,
+    human_share: 0,
+    reactions_pos: 0,
+    reactions_neg: 0,
+    net_sentiment: 0,
+    corrections: 0,
+    reworks: 0,
+    interrupts: 0,
+    tool_denials: 0,
+    repeated_instructions: 0,
+    acceptances: 0,
+    momentum_series: [],
+    momentum_final: 0,
+    momentum_auc: 0,
+    ended_positive: false,
+    recovery_events: 0,
+    effort_at_end: null,
+    model_mix: [],
+    ai_title: null,
+    session_slug: null,
+    lines_seen: 0,
+    analyzer_version: ANALYZER_VERSION
+  };
+}
+async function analyzeSession(path) {
+  const a = emptyAnalysis("");
+  if (!path || !existsSync6(path))
+    return a;
+  const reactions = [];
+  const modelMix = /* @__PURE__ */ new Map();
+  let effort = null;
+  let priorAssistantWorked = false;
+  let prevUserText = null;
+  await new Promise((resolve) => {
+    const stream = createReadStream(path, { encoding: "utf-8" });
+    const rl = createInterface({ input: stream });
+    const processLine = (line) => {
+      const trimmed = line.trim();
+      if (!trimmed)
+        return;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      a.lines_seen++;
+      if (!a.session_id) {
+        const sid = parsed.sessionId ?? parsed.session_id;
+        if (typeof sid === "string" && sid)
+          a.session_id = sid;
+      }
+      if (parsed.type === "ai-title" && typeof parsed.aiTitle === "string" && parsed.aiTitle) {
+        a.ai_title = parsed.aiTitle;
+      }
+      if (typeof parsed.slug === "string" && parsed.slug)
+        a.session_slug = parsed.slug;
+      const role = parsed.message?.role;
+      const isSide = parsed.isSidechain === true;
+      const usage = parsed.message?.usage;
+      if (role === "assistant" && usage) {
+        a.input_tokens += num(usage.input_tokens);
+        a.output_tokens += num(usage.output_tokens);
+        a.cache_read_tokens += num(usage.cache_read_input_tokens);
+        a.cache_creation_tokens += num(usage.cache_creation_input_tokens);
+      }
+      if (role === "assistant" && typeof parsed.message?.model === "string" && parsed.message.model && parsed.message.model !== SYNTHETIC_MODEL) {
+        const rawTs = parsed.timestamp ? Date.parse(parsed.timestamp) : Number.NaN;
+        bumpModel(modelMix, parsed.message.model, isSide, num(usage?.output_tokens), Number.isFinite(rawTs) ? rawTs : 0);
+      }
+      if (isSide)
+        return;
+      if (role === "assistant") {
+        a.assistant_turns++;
+        const blocks2 = asBlocks(parsed.message?.content);
+        let worked = false;
+        for (const b of blocks2) {
+          if (b.type === "tool_use") {
+            a.tool_calls++;
+            worked = true;
+            if (b.name === "AskUserQuestion")
+              a.agent_questions++;
+          }
+        }
+        priorAssistantWorked = worked;
+        return;
+      }
+      if (role !== "user")
+        return;
+      const blocks = asBlocks(parsed.message?.content);
+      const text = textOf(blocks);
+      if (text.includes(INTERRUPT_MARKER)) {
+        a.interrupts++;
+        reactions.push({ polarity: -1, magnitude: MAG.interrupt, kind: "interrupt" });
+        return;
+      }
+      const denied = blocks.some((b) => b.type === "tool_result" && b.is_error === true && typeof b.content === "string" && b.content.includes(DENIAL_MARKER));
+      if (denied) {
+        a.tool_denials++;
+        reactions.push({ polarity: -1, magnitude: MAG.denial, kind: "denial" });
+        return;
+      }
+      if (blocks.some((b) => b.type === "tool_result"))
+        return;
+      if (!text.trim())
+        return;
+      a.user_turns++;
+      a.user_chars += text.length;
+      const directive = detectEffortLevel(text);
+      if (directive)
+        effort = directive;
+      const r = classifyGenuine(text, prevUserText, priorAssistantWorked);
+      prevUserText = text;
+      if (r.kind === "correction")
+        a.corrections++;
+      else if (r.kind === "rework")
+        a.reworks++;
+      else if (r.kind === "repeat")
+        a.repeated_instructions++;
+      else if (r.kind === "acceptance")
+        a.acceptances++;
+      if (r.polarity !== 0)
+        reactions.push(r);
+      priorAssistantWorked = false;
+    };
+    rl.on("line", (line) => {
+      try {
+        processLine(line);
+      } catch {
+      }
+    });
+    rl.on("close", () => resolve());
+    rl.on("error", () => resolve());
+    stream.on("error", () => resolve());
+  });
+  a.effort_at_end = effort;
+  a.model_mix = [...modelMix.values()].sort((x, y) => x.first_ts - y.first_ts || x.model.localeCompare(y.model));
+  a.user_token_estimate = Math.round(a.user_chars / 4);
+  const denom = a.user_token_estimate + a.output_tokens;
+  a.human_share = denom > 0 ? Number((a.user_token_estimate / denom).toFixed(4)) : 0;
+  let momentum = 0;
+  let auc = 0;
+  const series = [];
+  reactions.forEach((r, i) => {
+    if (r.polarity > 0)
+      a.reactions_pos++;
+    else if (r.polarity < 0)
+      a.reactions_neg++;
+    momentum = momentum * MOMENTUM_DECAY + r.polarity * r.magnitude;
+    const value2 = Number(momentum.toFixed(3));
+    series.push({
+      t: i,
+      value: value2,
+      ...r.kind !== "neutral" ? { kind: r.kind } : {}
+    });
+    auc += value2;
+    if (i > 0 && reactions[i - 1].polarity < 0 && r.polarity > 0)
+      a.recovery_events++;
+  });
+  a.net_sentiment = a.reactions_pos - a.reactions_neg;
+  a.momentum_series = series;
+  a.momentum_final = series.length ? series[series.length - 1].value : 0;
+  a.momentum_auc = Number(auc.toFixed(3));
+  a.ended_positive = a.momentum_final > 0;
+  return a;
+}
+
+// ../../packages/claude-code-telemetry/dist/ingest.js
+function ingestBody(analytics, span, ctx) {
+  const body = { session_analytics: analytics };
+  if (span && span.started_at) {
+    body.session_span = ctx ? { ...span, ...ctx } : span;
+  }
+  return body;
+}
+function ingestHeaders(auth) {
+  const headers = {
+    "content-type": "application/json",
+    authorization: `Bearer ${auth.apiKey}`
+  };
+  if (auth.deviceId)
+    headers["x-maind-device-id"] = auth.deviceId;
+  return headers;
+}
+async function postSessionAnalytics(target, analytics, span, ctx) {
+  try {
+    const res = await fetch(target.endpoint, {
+      method: "POST",
+      headers: ingestHeaders(target),
+      body: JSON.stringify(ingestBody(analytics, span, ctx))
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return { ok: false, inserted: 0, status: res.status, error: text.slice(0, 500) };
+    }
+    const json = await res.json().catch(() => null);
+    return {
+      ok: true,
+      inserted: json?.analytics_stored ? 1 : 0,
+      spanStored: json?.span_stored === true,
+      status: res.status
+    };
+  } catch (err4) {
+    return {
+      ok: false,
+      inserted: 0,
+      error: err4 instanceof Error ? err4.message : String(err4)
+    };
+  }
+}
+
+// ../../packages/claude-code-telemetry/dist/windows.js
+var FIVE_HOURS_MS = 5 * 60 * 60 * 1e3;
+var WEEK_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// ../../packages/claude-code-telemetry/dist/projects.js
+import { readdir, stat } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join6 } from "node:path";
+var HOME = homedir3();
+var DEFAULT_PROJECTS_DIR = join6(HOME, ".claude", "projects");
+function cwdFromProjectDir(encoded) {
+  if (!encoded.startsWith("-"))
+    return encoded;
+  return encoded.replace(/-/g, "/");
+}
+async function listProjects(projectsDir = DEFAULT_PROJECTS_DIR) {
+  let entries;
+  try {
+    entries = await readdir(projectsDir);
+  } catch {
+    return [];
+  }
+  const out2 = [];
+  for (const entry of entries) {
+    if (!entry.startsWith("-"))
+      continue;
+    const dir = join6(projectsDir, entry);
+    let files;
+    try {
+      files = await readdir(dir);
+    } catch {
+      continue;
+    }
+    const transcripts = files.filter((f) => f.endsWith(".jsonl"));
+    if (transcripts.length === 0)
+      continue;
+    let mtimeMs = 0;
+    for (const f of transcripts) {
+      try {
+        const st = await stat(join6(dir, f));
+        if (st.mtimeMs > mtimeMs)
+          mtimeMs = st.mtimeMs;
+      } catch {
+      }
+    }
+    out2.push({
+      encodedDir: entry,
+      cwd: cwdFromProjectDir(entry),
+      transcripts: transcripts.map((f) => join6(dir, f)),
+      mtimeMs
+    });
+  }
+  out2.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out2.map(({ mtimeMs: _mtime, ...rest }) => rest);
+}
+
+// src/sessions-cmd.ts
+var DEFAULT_ENDPOINT = "https://vsddmiosisvfrairepxv.supabase.co/functions/v1/mcp-client-metrics-ingest";
+var THROTTLE_MS = 120;
+function err2(line) {
+  process.stderr.write(`maind: ${line}
+`);
+}
+function out(line) {
+  process.stdout.write(line + "\n");
+}
+function parseSessionsArgs(argv) {
+  const args = { dryRun: false, since: null, json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dry-run") args.dryRun = true;
+    else if (a === "--json") args.json = true;
+    else if (a === "--since") {
+      const raw = argv[++i];
+      const ts = raw ? Date.parse(raw) : Number.NaN;
+      if (Number.isFinite(ts)) args.since = ts;
+      else err2(`ignoring unparseable --since '${raw ?? ""}' (expected YYYY-MM-DD)`);
+    }
+  }
+  return args;
+}
+function endpoint() {
+  const raw = process.env.MAIND_INGEST_URL?.trim();
+  return raw && raw.length > 0 ? raw : DEFAULT_ENDPOINT;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function runSessionsBackfill(args) {
+  let auth;
+  try {
+    auth = resolveAuth();
+  } catch (e) {
+    if (e instanceof MissingApiKeyError) {
+      err2(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const projects = await listProjects();
+  const transcripts = projects.flatMap((p) => p.transcripts);
+  if (transcripts.length === 0) {
+    err2("no Claude Code transcripts found under ~/.claude/projects.");
+    return 0;
+  }
+  const target = endpoint();
+  const rows = [];
+  let skipped = 0;
+  let failed = 0;
+  for (const path of transcripts) {
+    const analysis = await analyzeSession(path);
+    if (!analysis.session_id) {
+      skipped++;
+      continue;
+    }
+    if (args.since !== null) {
+      const last = analysis.model_mix.reduce((m, s) => Math.max(m, s.last_ts), 0);
+      if (last > 0 && last < args.since) {
+        skipped++;
+        continue;
+      }
+    }
+    const main2 = analysis.model_mix.filter((m) => !m.sidechain);
+    const row = {
+      session_id: analysis.session_id,
+      title: analysis.ai_title,
+      models: main2.map((m) => `${m.model}\xD7${m.turns}`).join(", ") || "\u2014",
+      turns: analysis.assistant_turns,
+      lines: analysis.lines_seen,
+      posted: false
+    };
+    if (!args.dryRun) {
+      const res = await postSessionAnalytics(
+        { endpoint: target, apiKey: auth.apiKey, deviceId: auth.deviceId },
+        analysis
+      );
+      row.posted = res.ok;
+      if (!res.ok) {
+        failed++;
+        row.error = res.error ?? `status ${res.status ?? "?"}`;
+      }
+      await sleep(THROTTLE_MS);
+    }
+    rows.push(row);
+  }
+  if (args.json) {
+    out(JSON.stringify({ ok: failed === 0, dry_run: args.dryRun, skipped, failed, sessions: rows }, null, 2));
+    return failed === 0 ? 0 : 1;
+  }
+  out(
+    args.dryRun ? `Would upload ${rows.length} session(s) to ${target}:` : `Uploaded ${rows.length - failed}/${rows.length} session(s) to ${target}:`
+  );
+  out("");
+  for (const r of rows) {
+    const mark = args.dryRun ? " " : r.posted ? "\u2713" : "\u2717";
+    out(`${mark} ${r.session_id.slice(0, 8)}  ${String(r.turns).padStart(4)} turns  ${r.models}`);
+    out(`    title: ${r.title ?? "\u2014"}`);
+    if (r.error) out(`    error: ${r.error}`);
+  }
+  out("");
+  if (skipped > 0) out(`${skipped} transcript(s) skipped (no session id, or older than --since).`);
+  if (args.dryRun) {
+    out("Dry run \u2014 nothing was uploaded.");
+    out(
+      "Note: a real run uploads the session TITLES listed above (content-derived) for every project on this machine. They are only stored if you enabled 'Session titles' in the consent center; without it the numbers land and the titles are dropped."
+    );
+  }
+  if (failed > 0) err2(`${failed} session(s) failed \u2014 re-running is safe, the server upserts.`);
+  return failed === 0 ? 0 : 1;
+}
+
 // src/sync-cmd.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 var CONSENT_POLICY_VERSION = "2026-07-05";
 var DEFAULT_DASHBOARD_URL = "https://app.maind.dev";
-function err(line) {
+function err3(line) {
   process.stderr.write(`maind: ${line}
 `);
 }
 function repoRoot() {
   try {
-    return execFileSync6("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+    return execFileSync8("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
   } catch {
     return process.cwd();
   }
@@ -3956,7 +6608,7 @@ function makeSync(json) {
     auth = resolveAuth();
   } catch (e) {
     if (e instanceof MissingApiKeyError) {
-      err(e.message);
+      err3(e.message);
       return null;
     }
     throw e;
@@ -3970,11 +6622,11 @@ function makeSync(json) {
       onProgress: json ? void 0 : (p) => process.stderr.write(`  ${p.phase}: ${p.done}/${p.total}\r`)
     });
   } catch (e) {
-    err(e instanceof Error ? e.message : String(e));
+    err3(e instanceof Error ? e.message : String(e));
     return null;
   }
 }
-function msg6(e) {
+function msg7(e) {
   return e instanceof Error ? e.message : String(e);
 }
 function parseSyncArgs(argv) {
@@ -3998,10 +6650,10 @@ async function runSync(opts) {
     }
   } catch (e) {
     if (e instanceof SyncError && e.code === "consent_required") {
-      err("codebase cloud-sync is not enabled \u2014 run `maind sync enable` first.");
+      err3("codebase cloud-sync is not enabled \u2014 run `maind sync enable` first.");
       return 1;
     }
-    err(`sync failed: ${msg6(e)}`);
+    err3(`sync failed: ${msg7(e)}`);
     return 1;
   } finally {
     await sync.close().catch(() => {
@@ -4037,7 +6689,7 @@ cloud:  ${remote.indexed ? `${remote.node_count ?? "?"} symbols \xB7 ${remote.ed
 async function push(sync, json) {
   const local = await sync.localStatus();
   if (!local.indexed || local.nodeCount === 0) {
-    err("no local index found \u2014 run `maind index` first.");
+    err3("no local index found \u2014 run `maind index` first.");
     return 1;
   }
   const res = await sync.push();
@@ -4054,7 +6706,6 @@ async function push(sync, json) {
 }
 
 // src/index.ts
-var VERSION = "0.7.0";
 var HELP = `maind ${VERSION} \u2014 headless maind CLI for CI + git context
 
 Usage:
@@ -4069,6 +6720,8 @@ Usage:
   maind sync                   Push the local index to the cloud (opt-in; hashed rows only)
   maind sync status [--json]   Show local vs cloud sync state
   maind sync enable|disable    Opt in/out of codebase cloud-sync (consent)
+  maind sessions backfill [.]  Recompute session analytics for transcripts already on disk
+  maind launch <agent> [..]    Plug&play: local Switchyard model-routing proxy + agent behind it (v1: claude)
   maind review [options]       Provenance-backed review findings for a change set (advisory by default)
   maind ci-report [options]    Report a CI failure as a draft-lesson candidate (on failure)
   maind ci-result [options]    Report a build outcome + served manifest (end of job)
@@ -4086,13 +6739,34 @@ review options (advisory by default \u2014 exits 0 unless --gate + --fail-on):
   --json                 Print the review manifest JSON to stdout (pipeable)
   --gate                 Aggregate findings into a server-side pass|warn|block verdict (Team plan)
   --fail-on block|warn   With --gate: exit 1 when the verdict crosses this threshold
-  --strict               Infra errors exit 2 instead of failing open with exit 0
+  --strict               Infra errors (native module / transport / unexpected server
+                         error) exit 2 instead of failing open with exit 0. Expected
+                         unavailability \u2014 missing or unauthorized API key, rate limit,
+                         non-git dir \u2014 still exits 0 with a loud warning.
   --no-report            With --gate: omit the commit anchors so the server does NOT
                          persist a review_runs attestation record (ADR-230) \u2014 the
                          verdict is then advisory-only, without a replayable proof
   --project-key <hex>    Repo project_key override (default: auto-detect from git)
   --mcp-url <url>        Override MCP endpoint (default $MAIND_MCP_URL or production)
 
+launch options (v1 agent: claude; codex/openclaw planned \u2014 ADR-272):
+  --dry-run              Print the generated routes TOML (stdout) + config path, detection
+                         state and the exact spawn command (stderr); installs, writes and
+                         spawns nothing
+  --json                 With --dry-run: machine-readable plan JSON on stdout
+  --config <path>        Use an existing routes.toml \u2014 skips generation + template fetch
+  --route <name>         Route name for --model and the generated [routes.<name>] (default: switchyard)
+  --direct               Skip the proxy \u2014 spawn the agent directly (no routing, visible banner)
+  --no-fallback          On switchyard startup failure exit 1 instead of degrading to a
+                         direct agent spawn
+  --no-install           Never auto-install; print the install one-liner and exit 1 when missing
+  --mcp-url <url>        Override MCP endpoint for the curated-template fetch
+  Prereqs: installs nemo-switchyard[cli] via uv automatically when uv exists \u2014 never
+  installs uv itself (prints the official instruction instead). The generated config
+  lands in <repoRoot>/.maind/switchyard-routes.toml (or the maind user config dir
+  outside a repo). Backend keys (ANTHROPIC_API_KEY / OPENROUTER_API_KEY) are read
+  from the environment by the proxy at runtime \u2014 never written into the TOML.
+
 git-context options (run at session-start; reads local git + gh, all fail-open):
   --out <path>           Briefing markdown output (default .maind/git-context.md)
   --manifest <path>      Optional structured JSON output (git_context manifest)
@@ -4118,6 +6792,16 @@ ci-result options (run at the end of a job, success OR failure):
   --run-url <url>        Link to the CI run (default derived from GitHub env)
   --result-url <url>     Override ingest endpoint (default $MAIND_RESULT_URL or prod)
 
+sessions backfill options:
+  --dry-run              List what WOULD be uploaded (incl. the session titles) and stop.
+                         Recommended before the first real run \u2014 a backfill covers every
+                         project on this machine, and titles are content-derived.
+  --since <YYYY-MM-DD>   Only sessions whose last turn is on/after this date
+  --json                 Machine-readable result
+  Idempotent: the server upserts on (user_id, session_id), so re-running is safe.
+  Titles are only stored if 'Session titles' is enabled in the consent center;
+  otherwise the numbers land and the title is dropped server-side.
+
 context options:
   --stack <a,b>          Stack hint (seeds the platforms filter), e.g. nextjs,supabase
   --platforms <a,b>      Explicit platforms filter (overrides --stack)
@@ -4161,6 +6845,9 @@ async function main() {
     process.stdout.write(key + "\n");
     return 0;
   }
+  if (cmd === "launch") {
+    return runLaunch(parseLaunchArgs(argv.slice(1)));
+  }
   const usesOrt = cmd === "index" && argv.includes("--embed") || cmd === "index-semantic";
   if (usesOrt && !isOrtWorker(argv)) {
     return runOrtIsolated(argv);
@@ -4183,6 +6870,13 @@ async function main() {
   if (cmd === "sync") {
     return runSync(parseSyncArgs(argv.slice(1)));
   }
+  if (cmd === "sessions") {
+    if (argv[1] !== "backfill") {
+      process.stderr.write("maind: usage: maind sessions backfill [--dry-run] [--since YYYY-MM-DD] [--json]\n");
+      return 2;
+    }
+    return runSessionsBackfill(parseSessionsArgs(argv.slice(2)));
+  }
   if (cmd === "review") {
     return runReview(parseReviewArgs(argv.slice(1)));
   }
@@ -4196,8 +6890,271 @@ async function main() {
 `);
   return 2;
 }
-main().then((code) => process.exit(code)).catch((err2) => {
-  process.stderr.write(`maind: fatal: ${err2 instanceof Error ? err2.stack ?? err2.message : String(err2)}
+main().then((code) => process.exit(code)).catch((err4) => {
+  process.stderr.write(`maind: fatal: ${err4 instanceof Error ? err4.stack ?? err4.message : String(err4)}
 `);
   process.exit(1);
 });
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/util.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/date.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/primitive.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/extract.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/struct.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/parse.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/stringify.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/