@m8t-stack/cli 0.2.14 → 0.2.15

package/dist/cli.js

@@ -1198,7 +1198,7 @@ var init_enable_hosted_brain = __esm({
 import { Builtins, Cli } from "clipanion";
 
 // src/lib/package-version.ts
-var CLI_VERSION = "0.2.14";
+var CLI_VERSION = "0.2.15";
 
 // src/lib/render-error.ts
 init_errors();
@@ -13197,6 +13197,18 @@ async function ghAuthLoginDevice(exec = defaultGhExec) {
     });
   }
 }
+async function getGhToken(exec = defaultGhExec) {
+  const r = await exec("gh", ["auth", "token"]);
+  const tok = r.stdout.trim();
+  if (r.exitCode !== 0 || !tok) {
+    throw new LocalCliError({
+      code: "GH_TOKEN_FAILED",
+      message: `gh auth token failed (exit ${r.exitCode.toString()}): ${(r.stderr || r.stdout).slice(0, 200)}`,
+      hint: "Run `gh auth login` to authenticate the GitHub CLI."
+    });
+  }
+  return tok;
+}
 async function getRepoId(owner, repo, exec = defaultGhExec) {
   const r = await exec("gh", ["api", `/repos/${owner}/${repo}`, "--jq", ".id"]);
   if (r.exitCode !== 0) {
@@ -13300,6 +13312,34 @@ async function tryOpenUrl(url, exec = defaultGhExec) {
   } catch {
   }
 }
+function ghRepoProbe(args) {
+  const exec = args.exec ?? defaultGhExec;
+  const slug = `${args.owner}/${args.repo}`;
+  return {
+    repoStatus: async () => {
+      const r = await exec("gh", ["api", "-i", `/repos/${slug}`]);
+      const combined = `${r.stdout}
+${r.stderr}`;
+      const header = /^HTTP\/[\d.]+\s+(\d{3})/m.exec(combined);
+      if (header) return Number(header[1]);
+      const ghErr = /\(HTTP (\d{3})\)/.exec(combined);
+      if (ghErr) return Number(ghErr[1]);
+      if (r.exitCode === 0) return 200;
+      throw new LocalCliError({
+        code: "GH_REPO_PROBE_FAILED",
+        message: `gh api /repos/${slug} failed (exit ${r.exitCode.toString()}): ${(r.stderr || r.stdout).slice(0, 200)}`
+      });
+    },
+    getFile: async (path29) => {
+      const r = await exec("gh", ["api", "-H", "Accept: application/vnd.github.raw+json", `/repos/${slug}/contents/${path29}`]);
+      return r.exitCode === 0 ? r.stdout : null;
+    },
+    isEmpty: async () => {
+      const r = await exec("gh", ["api", `/repos/${slug}/contents`]);
+      return r.exitCode !== 0;
+    }
+  };
+}
 
 // src/commands/brain/app-create.ts
 init_errors();
@@ -13534,6 +13574,7 @@ import { readFileSync as readFileSync6 } from "fs";
 import * as fs10 from "fs";
 import * as os4 from "os";
 import * as path9 from "path";
+import * as readline2 from "readline/promises";
 import { DefaultAzureCredential as DefaultAzureCredential4 } from "@azure/identity";
 init_errors();
 
@@ -14065,6 +14106,20 @@ function materializeBrainTree(opts) {
 init_errors();
 init_esm2();
 import { spawn as spawn3 } from "child_process";
+import { parse as parseYaml5 } from "yaml";
+function isM8tBrainMarker(yamlText) {
+  if (!yamlText.trim()) return false;
+  let parsed;
+  try {
+    parsed = parseYaml5(yamlText);
+  } catch {
+    return false;
+  }
+  if (!parsed || typeof parsed !== "object") return false;
+  const root = parsed;
+  const isObj2 = (v) => typeof v === "object" && v !== null;
+  return isObj2(root.engine) || isObj2(root.processes) || isObj2(root.link);
+}
 async function createBlankRepo(args) {
   const res = await fetch(`https://api.github.com/orgs/${args.org}/repos`, {
     method: "POST",
@@ -14195,8 +14250,119 @@ async function commitFilesViaApp(args) {
   });
   await api(`/git/refs/heads/${args.branch}`, { method: "PATCH", body: JSON.stringify({ sha: commit.sha }) });
 }
+async function probeRepoState(probe) {
+  const status = await probe.repoStatus();
+  if (status === 404) return "absent";
+  if (status !== 200) {
+    throw new LocalCliError({
+      code: "GH_REPO_PROBE_FAILED",
+      message: `GET repo returned HTTP ${status.toString()} (expected 200 or 404)`
+    });
+  }
+  const marker = await probe.getFile(".m8t/brain.yaml");
+  if (marker !== null && isM8tBrainMarker(marker)) return "m8t-brain";
+  if (await probe.isEmpty()) return "empty";
+  return "foreign";
+}
+function appRepoProbe(args) {
+  const doFetch = args.fetchImpl ?? fetch;
+  const H = ghHeaders(args.token);
+  return {
+    repoStatus: async () => {
+      const res = await doFetch(`${GH_API}/repos/${args.repo}`, { headers: H, signal: AbortSignal.timeout(GH_REQUEST_TIMEOUT_MS) });
+      return res.status;
+    },
+    getFile: (path29) => readRepoFileViaApp({ token: args.token, repo: args.repo, path: path29, fetchImpl: args.fetchImpl }),
+    isEmpty: async () => {
+      const res = await doFetch(`${GH_API}/repos/${args.repo}/contents`, { headers: H, signal: AbortSignal.timeout(GH_REQUEST_TIMEOUT_MS) });
+      return res.status === 404;
+    }
+  };
+}
+
+// src/lib/brain-repo-collision.ts
+init_errors();
+var DEFAULT_MAX_ATTEMPTS = 20;
+function actionForState(state) {
+  switch (state) {
+    case "absent":
+      return "create";
+    case "m8t-brain":
+      return "reuse";
+    case "empty":
+      return "adopt";
+    case "foreign":
+      throw new LocalCliError({
+        code: "FOREIGN_REPO_COLLISION",
+        message: `A repo already exists but isn't an m8t brain.`
+      });
+  }
+}
+function candidate(base, n) {
+  return n === 1 ? base : `${base}-${n.toString()}`;
+}
+async function scan(base, classify, accept, startAt, maxAttempts) {
+  for (let n = startAt; n <= maxAttempts; n++) {
+    const name = candidate(base, n);
+    const state = await classify(name);
+    if (accept(state)) return { repoName: name, state };
+  }
+  throw new LocalCliError({
+    code: "REPO_NAME_SCAN_EXHAUSTED",
+    message: `Could not find a free repo name for "${base}" after ${maxAttempts.toString()} attempts.`
+  });
+}
+async function resolveRepoCollision(args) {
+  const max = args.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const state = await args.classify(args.repoName);
+  if (args.force === "new") {
+    const found = await scan(args.repoName, args.classify, (s) => s === "absent", 1, max);
+    return { repoName: found.repoName, action: "create" };
+  }
+  if (args.force === "reuse") {
+    return { repoName: args.repoName, action: actionForState(state) };
+  }
+  if (state === "absent") return { repoName: args.repoName, action: "create" };
+  if (args.interactive && args.prompt) {
+    const choice = await args.prompt({ repoName: args.repoName, state });
+    if (choice === "abort") {
+      throw new LocalCliError({ code: "BRAIN_CREATE_ABORTED", message: "Aborted by the operator." });
+    }
+    if (choice === "new") {
+      const found = await scan(args.repoName, args.classify, (s) => s !== "foreign", 2, max);
+      return { repoName: found.repoName, action: actionForState(found.state) };
+    }
+    return { repoName: args.repoName, action: actionForState(state) };
+  }
+  if (state === "foreign") {
+    throw new LocalCliError({
+      code: "FOREIGN_REPO_COLLISION",
+      message: `A repo with this name already exists but isn't an m8t brain, so it won't be touched. Rename that repo or install into a different org, then re-run.`
+    });
+  }
+  return { repoName: args.repoName, action: actionForState(state) };
+}
 
 // src/commands/brain/create.ts
+async function promptCollision(ctx, info) {
+  const rl = readline2.createInterface({ input: ctx.stdin, output: ctx.stdout });
+  try {
+    if (info.state === "foreign") {
+      const ans2 = (await rl.question(
+        `A repo "${info.repoName}" already exists but isn't an m8t brain. Create a new "${info.repoName}-2" instead? [Y/n] (n aborts) `
+      )).trim().toLowerCase();
+      return ans2 === "" || ans2 === "y" || ans2 === "yes" ? "new" : "abort";
+    }
+    const ans = (await rl.question(
+      `An m8t brain "${info.repoName}" already exists. Reuse it? [Y/n] (n creates "${info.repoName}-2", or "a" aborts) `
+    )).trim().toLowerCase();
+    if (ans === "" || ans === "y" || ans === "yes") return "reuse";
+    if (ans === "a" || ans === "abort") return "abort";
+    return "new";
+  } finally {
+    rl.close();
+  }
+}
 function stageAsGitRepo(dir) {
   const steps = [
     { args: ["init", "-b", "main"], label: "git init" },
@@ -14239,6 +14405,8 @@ var BrainCreateCommand = class extends M8tCommand {
   appId = Option17.String("--app-id", { description: "GitHub App id (no-gh path); with --app-pem/--installation-id, create the repo via the App instead of gh." });
   appPem = Option17.String("--app-pem", { description: "Path to the App private-key PEM (no-gh path)." });
   installationId = Option17.String("--installation-id", { description: "Org installation id for the App (no-gh path)." });
+  reuse = Option17.Boolean("--reuse", false, { description: "If the brain repo already exists, reuse it (non-interactive). Errors if the repo isn't a valid m8t brain." });
+  newName = Option17.Boolean("--new", false, { description: "If the brain repo name is taken, create a fresh suffixed repo (e.g. <name>-2) instead of reusing." });
   async executeCommand() {
     const owner = typeof this.owner === "string" ? this.owner : void 0;
     const worker = typeof this.worker === "string" ? this.worker : void 0;
@@ -14303,59 +14471,95 @@ var BrainCreateCommand = class extends M8tCommand {
     const tmpDir = fs10.mkdtempSync(path9.join(os4.tmpdir(), `m8t-brain-create-${worker}-`));
     let result;
     let resolvedInstallationId = null;
+    const force = this.reuse === true ? "reuse" : this.newName === true ? "new" : void 0;
+    const interactive = !useAppPath && this.context.stdout.isTTY === true;
+    let token;
+    let classify;
+    if (useAppPath) {
+      token = await mintInstallationTokenFromPem({
+        appId: appIdOpt,
+        privateKeyPem: readFileSync6(appPemOpt, "utf8"),
+        installationId: installationIdOpt
+      });
+      const tok = token;
+      classify = (name) => probeRepoState(appRepoProbe({ token: tok, repo: `${owner}/${name}` }));
+    } else {
+      classify = (name) => probeRepoState(ghRepoProbe({ owner, repo: name }));
+    }
+    const decision = await resolveRepoCollision({
+      repoName,
+      classify,
+      interactive,
+      force,
+      prompt: interactive ? (info) => promptCollision(
+        { stdin: this.context.stdin, stdout: this.context.stdout },
+        info
+      ) : void 0
+    });
+    const finalName = decision.repoName;
+    const needsPush = decision.action === "create" || decision.action === "adopt";
+    if (finalName !== repoName) {
+      this.context.stdout.write(`${colors.hint("note:")} using repo name ${colors.field(finalName)} (${decision.action}).
+`);
+    }
     try {
-      materializeBrainTree({ templateSrc, destDir: tmpDir, seedDir });
-      this.context.stdout.write(
-        seedName ? `${colors.dim("\u2192")} copied brain-template/ + overlaid seed ${colors.field(seedName)} to ${tmpDir}
+      if (needsPush) {
+        materializeBrainTree({ templateSrc, destDir: tmpDir, seedDir });
+        this.context.stdout.write(
+          seedName ? `${colors.dim("\u2192")} copied brain-template/ + overlaid seed ${colors.field(seedName)} to ${tmpDir}
 ` : `${colors.dim("\u2192")} copied brain-template/ to ${tmpDir}
 `
-      );
+        );
+      }
       if (useAppPath) {
-        this.context.stdout.write(`${colors.dim("\u2192")} creating ${owner}/${repoName} via the GitHub App (no gh)\u2026
+        const appToken = token ?? "";
+        if (decision.action === "create") {
+          this.context.stdout.write(`${colors.dim("\u2192")} creating ${owner}/${finalName} via the GitHub App (no gh)\u2026
+`);
+          await createBlankRepo({ token: appToken, org: owner, name: finalName, private: !this.public_ });
+          await pushSeed({ token: appToken, org: owner, name: finalName, branch, sourceDir: tmpDir });
+          this.context.stdout.write(`${colors.success("\u2713")} repo created + seeded via the App
+`);
+        } else if (decision.action === "adopt") {
+          this.context.stdout.write(`${colors.dim("\u2192")} seeding the existing empty repo ${owner}/${finalName} via the GitHub App\u2026
+`);
+          await pushSeed({ token: appToken, org: owner, name: finalName, branch, sourceDir: tmpDir });
+          this.context.stdout.write(`${colors.success("\u2713")} empty repo seeded via the App
+`);
+        } else {
+          this.context.stdout.write(`${colors.success("\u2713")} reusing the existing brain ${owner}/${finalName}
 `);
-        const pem = readFileSync6(appPemOpt, "utf8");
-        const appJwt = signAppJwt({ appId: appIdOpt, privateKeyPem: pem });
-        const tokRes = await fetch(
-          `https://api.github.com/app/installations/${installationIdOpt}/access_tokens`,
-          {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${appJwt}`,
-              Accept: "application/vnd.github+json",
-              "X-GitHub-Api-Version": "2022-11-28",
-              "User-Agent": "m8t"
-            }
-          }
-        );
-        if (!tokRes.ok) {
-          throw new LocalCliError({
-            code: "GH_APP_TOKEN_FAILED",
-            message: `mint installation token HTTP ${tokRes.status.toString()}: ${(await tokRes.text()).slice(0, 300)}`
-          });
         }
-        const token = (await tokRes.json()).token;
-        await createBlankRepo({ token, org: owner, name: repoName, private: !this.public_ });
-        await pushSeed({ token, org: owner, name: repoName, branch, sourceDir: tmpDir });
         resolvedInstallationId = installationIdOpt;
-        this.context.stdout.write(`${colors.success("\u2713")} repo created + seeded via the App
-`);
       } else {
-        stageAsGitRepo(tmpDir);
-        this.context.stdout.write(`${colors.dim("\u2192")} creating repo ${owner}/${repoName} (${this.public_ ? "public" : "private"})\u2026
+        if (decision.action === "create") {
+          stageAsGitRepo(tmpDir);
+          this.context.stdout.write(`${colors.dim("\u2192")} creating repo ${owner}/${finalName} (${this.public_ ? "public" : "private"})\u2026
+`);
+          await createRepo({ owner, name: finalName, private: !this.public_, source: tmpDir });
+          this.context.stdout.write(`${colors.success("\u2713")} repo created
+`);
+        } else if (decision.action === "adopt") {
+          this.context.stdout.write(`${colors.dim("\u2192")} seeding the existing empty repo ${owner}/${finalName}\u2026
 `);
-        await createRepo({ owner, name: repoName, private: !this.public_, source: tmpDir });
-        this.context.stdout.write(`${colors.success("\u2713")} repo created
+          const ghToken = await getGhToken();
+          await pushSeed({ token: ghToken, org: owner, name: finalName, branch, sourceDir: tmpDir });
+          this.context.stdout.write(`${colors.success("\u2713")} empty repo seeded
 `);
-        const repoId = await getRepoId(owner, repoName);
+        } else {
+          this.context.stdout.write(`${colors.success("\u2713")} reusing the existing brain ${owner}/${finalName}
+`);
+        }
+        const repoId = await getRepoId(owner, finalName);
         const { slug, appId: secretAppId, privateKeyPem } = await readAppSecrets({ credential: credential2, kvUri });
         const initialJwt = signAppJwt({ appId: secretAppId, privateKeyPem });
-        resolvedInstallationId = await probeAppInstallation({ owner, repo: repoName, jwt: initialJwt });
+        resolvedInstallationId = await probeAppInstallation({ owner, repo: finalName, jwt: initialJwt });
         if (resolvedInstallationId) {
-          this.context.stdout.write(`  ${colors.success("\u2713")} App already installed on ${colors.field(`${owner}/${repoName}`)} (installation ${resolvedInstallationId}); skipping browser open.
+          this.context.stdout.write(`  ${colors.success("\u2713")} App already installed on ${colors.field(`${owner}/${finalName}`)} (installation ${resolvedInstallationId}); skipping browser open.
 `);
         } else {
           const url = installUrl(slug, repoId);
-          this.context.stdout.write(`${colors.field("\u2192")} Install the m8t-brain App on ${owner}/${repoName}:
+          this.context.stdout.write(`${colors.field("\u2192")} Install the m8t-brain App on ${owner}/${finalName}:
   ${url}
 `);
           await tryOpenUrl(url);
@@ -14363,10 +14567,10 @@ var BrainCreateCommand = class extends M8tCommand {
 `);
           resolvedInstallationId = await pollForInstallation({
             owner,
-            repo: repoName,
+            repo: finalName,
             // Mint fresh JWT each tick — App JWTs are 10-min TTL, poll defaults to 5 min
             // but the timeout is a soft default, so don't depend on the inequality.
-            probe: () => probeAppInstallation({ owner, repo: repoName, jwt: signAppJwt({ appId: secretAppId, privateKeyPem }) }),
+            probe: () => probeAppInstallation({ owner, repo: finalName, jwt: signAppJwt({ appId: secretAppId, privateKeyPem }) }),
             onTick: (n) => {
               if (n % 5 === 0) this.context.stderr.write(`  ${colors.dim(`\u2026still waiting (${(n * 2).toString()}s)`)}
 `);
@@ -14382,7 +14586,7 @@ var BrainCreateCommand = class extends M8tCommand {
         projectEndpoint: project.endpoint,
         projectArmId: `${project.accountScope}/projects/${project.projectName}`,
         agentName: worker,
-        repo: `${owner}/${repoName}`,
+        repo: `${owner}/${finalName}`,
         branch,
         repoRoot,
         installationId: resolvedInstallationId,
@@ -14396,7 +14600,7 @@ var BrainCreateCommand = class extends M8tCommand {
       this.context.stdout.write(
         renderJson({
           worker,
-          repo: `${owner}/${repoName}`,
+          repo: `${owner}/${finalName}`,
           branch,
           installationId: resolvedInstallationId,
           connectionName: result.connectionName,
@@ -14406,10 +14610,10 @@ var BrainCreateCommand = class extends M8tCommand {
       return 0;
     }
     this.context.stdout.write(
-      `${colors.success("\u2713")} created + linked ${colors.field(worker)} \u2194 ${colors.field(`${owner}/${repoName}`)} (agent version ${result.foundryVersion ?? ""}).
+      `${colors.success("\u2713")} created + linked ${colors.field(worker)} \u2194 ${colors.field(`${owner}/${finalName}`)} (agent version ${result.foundryVersion ?? ""}).
 `
     );
-    this.context.stdout.write(`  ${colors.hint("brain repo:")} https://github.com/${owner}/${repoName}
+    this.context.stdout.write(`  ${colors.hint("brain repo:")} https://github.com/${owner}/${finalName}
 `);
     this.context.stdout.write(`  ${colors.hint("token:")} rotates lazily on every invoke (60min TTL, 10min safety margin).
 `);
@@ -15010,7 +15214,7 @@ init_errors();
 // src/lib/deploy-prompt-advisor.ts
 import * as fs12 from "fs";
 import * as path11 from "path";
-import { parse as parseYaml5 } from "yaml";
+import { parse as parseYaml6 } from "yaml";
 init_foundry_agents();
 init_errors();
 function findPersonasRoot(hint) {
@@ -15038,7 +15242,7 @@ async function deployPromptAdvisor(args) {
     });
   }
   const fmMatch = /^---\n([\s\S]*?)\n---/.exec(raw);
-  const fm = fmMatch ? parseYaml5(fmMatch[1]) : {};
+  const fm = fmMatch ? parseYaml6(fmMatch[1]) : {};
   const model = args.model ?? fm.targets?.foundry?.model;
   if (!model) {
     throw new LocalCliError({
@@ -15305,7 +15509,7 @@ async function awaitAgentQueryable(args) {
 init_errors();
 init_esm();
 import * as fs13 from "fs";
-import { parse as parseYaml6 } from "yaml";
+import { parse as parseYaml7 } from "yaml";
 function readPersonaA2aCard(personaPath) {
   let raw;
   try {
@@ -15315,7 +15519,7 @@ function readPersonaA2aCard(personaPath) {
   }
   const fm = /^---\n([\s\S]*?)\n---/.exec(raw);
   if (!fm) throw new LocalCliError({ code: "PERSONA_NO_FRONTMATTER", message: `Persona '${personaPath}' has no frontmatter.` });
-  const front = parseYaml6(fm[1]);
+  const front = parseYaml7(fm[1]);
   const role = typeof front.role === "string" ? front.role : "";
   const cardYaml = front.targets?.foundry?.["a2a-card"];
   if (!cardYaml || typeof cardYaml !== "object") {
@@ -15801,7 +16005,7 @@ init_errors();
 import * as fs15 from "fs";
 import * as os6 from "os";
 import * as path12 from "path";
-import { parse as parseYaml7 } from "yaml";
+import { parse as parseYaml8 } from "yaml";
 var A2A_PATH = "/api/a2a/mcp";
 function resolveBridgeUrl(opts) {
   const env = opts.env ?? process.env;
@@ -15825,7 +16029,7 @@ function readConfigGatewayUrl(home) {
   const cfg = path12.join(home ?? os6.homedir(), ".m8t-stack", "config.yaml");
   if (!fs15.existsSync(cfg)) return void 0;
   try {
-    const o = parseYaml7(fs15.readFileSync(cfg, "utf8"));
+    const o = parseYaml8(fs15.readFileSync(cfg, "utf8"));
     return typeof o.gatewayUrl === "string" ? o.gatewayUrl : void 0;
   } catch {
     return void 0;
@@ -16327,7 +16531,7 @@ async function deployHostedWorker(args) {
 // src/lib/persona.ts
 import * as fs17 from "fs";
 import * as path15 from "path";
-import { parse as parseYaml8 } from "yaml";
+import { parse as parseYaml9 } from "yaml";
 function findRepoRoot(startDir) {
   let dir = path15.resolve(startDir);
   for (; ; ) {
@@ -16351,7 +16555,7 @@ function resolvePersona(persona, cwd = process.cwd()) {
   if (!match) return { persona, personaVersion: null };
   let fm = null;
   try {
-    fm = parseYaml8(match[1]);
+    fm = parseYaml9(match[1]);
   } catch {
     return { persona, personaVersion: null };
   }
@@ -18256,9 +18460,9 @@ var EvalSkillCommand = class extends M8tCommand {
     return Promise.resolve(this._runCommand());
   }
   _runCommand() {
-    const candidate = typeof this.candidate === "string" ? this.candidate : void 0;
+    const candidate2 = typeof this.candidate === "string" ? this.candidate : void 0;
     const skillsDir = typeof this.skillsDir === "string" ? this.skillsDir : void 0;
-    if (!candidate) {
+    if (!candidate2) {
       throw new LocalCliError({ code: "USAGE", message: "<path> positional argument is required" });
     }
     if (!skillsDir) {
@@ -18267,7 +18471,7 @@ var EvalSkillCommand = class extends M8tCommand {
     const outputFlag = this.output === "json" || this.output === "auto" || this.output === "pretty" ? this.output : "pretty";
     const mode = resolveOutputMode(outputFlag, this.context.stdout);
     const bin = process.env.BRAIN_EVAL_BIN ?? "brain-eval";
-    const args = ["skill", candidate, "--skills-dir", skillsDir, "--json"];
+    const args = ["skill", candidate2, "--skills-dir", skillsDir, "--json"];
     if (this.noJudge === true) args.push("--no-judge");
     if (typeof this.deployment === "string") args.push("--deployment", this.deployment);
     const res = spawnSync3(bin, args, { encoding: "utf-8" });
@@ -19256,7 +19460,7 @@ import { Command as Command41, Option as Option39 } from "clipanion";
 // src/lib/profiles.ts
 import * as fs20 from "fs/promises";
 import * as path21 from "path";
-import { parse as parseYaml9, stringify as stringifyYaml4 } from "yaml";
+import { parse as parseYaml10, stringify as stringifyYaml4 } from "yaml";
 function profilesDir() {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
   return path21.join(home, ".m8t-stack", "profiles");
@@ -19281,7 +19485,7 @@ async function listProfiles() {
 async function readProfile(name) {
   try {
     const raw = await fs20.readFile(getProfilePath(name), "utf8");
-    const parsed = parseYaml9(raw);
+    const parsed = parseYaml10(raw);
     if (!parsed || typeof parsed !== "object") return null;
     return parsed;
   } catch (e) {
@@ -20451,16 +20655,16 @@ function buildAdvancePlan(worker, cursor, physicalPks, consumedRowsByPk, failedT
   for (const pk of physicalPks) {
     const rowsForPk = consumedRowsByPk[pk] ?? [];
     const { ts, consumedRowKeys } = computeWatermark(rowsForPk, now.toISOString(), safetyLagSeconds);
-    let candidate = ts;
+    let candidate2 = ts;
     const prior = Object.hasOwn(cursor.watermarks, pk) ? cursor.watermarks[pk].ts : void 0;
     if (prior)
       priorTsByPk[pk] = prior;
-    if (prior && candidate < prior)
-      candidate = prior;
+    if (prior && candidate2 < prior)
+      candidate2 = prior;
     const failed = failedTsByPk[pk];
-    if (failed && candidate >= failed)
-      candidate = justBefore(failed);
-    watermarks[pk] = { ts: candidate, consumedRowKeys };
+    if (failed && candidate2 >= failed)
+      candidate2 = justBefore(failed);
+    watermarks[pk] = { ts: candidate2, consumedRowKeys };
     consumedKeysByPk[pk] = consumedRowKeys;
   }
   return {
@@ -20854,12 +21058,12 @@ function validateDelta(d) {
 }
 function extractJson(text) {
   const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
-  const candidate = (fenced ? fenced[1] : text).trim();
-  const start = candidate.indexOf("{");
-  const end = candidate.lastIndexOf("}");
+  const candidate2 = (fenced ? fenced[1] : text).trim();
+  const start = candidate2.indexOf("{");
+  const end = candidate2.lastIndexOf("}");
   if (start === -1 || end === -1 || end < start)
     throw new Error("no JSON object found");
-  return JSON.parse(candidate.slice(start, end + 1));
+  return JSON.parse(candidate2.slice(start, end + 1));
 }
 async function propose(model, system, user, opts = {}) {
   const sleep2 = opts.sleep ?? defaultSleep2;
@@ -21439,14 +21643,14 @@ function narrowAdvance(src, kept) {
   for (const pk of Object.keys(src.watermarks)) {
     const rows = keptRowsByPk[pk] ?? [];
     const { ts, consumedRowKeys } = computeWatermark(rows, now, safetyLagSeconds);
-    let candidate = ts;
+    let candidate2 = ts;
     const prior = priorTsByPk[pk];
-    if (prior && candidate < prior)
-      candidate = prior;
+    if (prior && candidate2 < prior)
+      candidate2 = prior;
     const failed = src.failedTsByPk[pk];
-    if (failed && candidate >= failed)
-      candidate = justBefore(failed);
-    watermarks[pk] = { ts: candidate, consumedRowKeys };
+    if (failed && candidate2 >= failed)
+      candidate2 = justBefore(failed);
+    watermarks[pk] = { ts: candidate2, consumedRowKeys };
     consumedRowsByPk[pk] = consumedRowKeys;
   }
   return {
@@ -21548,7 +21752,7 @@ async function emitDigest(input, deps, digest) {
 }
 
 // ../../packages/brain/engine/dist/esm/dream/config.js
-import { parse as parseYaml10 } from "yaml";
+import { parse as parseYaml11 } from "yaml";
 var DEFAULT_DREAM_MODEL = "gpt-5.4";
 function asCadence(v) {
   return v === "nightly" ? "nightly" : "off";
@@ -21556,7 +21760,7 @@ function asCadence(v) {
 function parseDreamerConfig(rawYaml, env) {
   let parsed;
   try {
-    parsed = parseYaml10(rawYaml);
+    parsed = parseYaml11(rawYaml);
   } catch {
     return { enabled: false, cadence: "off", model: env.M8T_DREAM_MODEL ?? DEFAULT_DREAM_MODEL };
   }
@@ -21570,16 +21774,16 @@ function parseDreamerConfig(rawYaml, env) {
 }
 
 // ../../packages/brain/engine/dist/esm/cost-report/config.js
-import { parse as parseYaml11 } from "yaml";
+import { parse as parseYaml12 } from "yaml";
 
 // ../../packages/brain/engine/dist/esm/librarian/codify/persistence-guard.js
 var ZERO_WIDTH_RE = new RegExp("\u200B|\u200C|\u200D|\uFEFF", "g");
 
 // ../../packages/brain/engine/dist/esm/librarian/janitor/frontmatter.js
-import { parse as parseYaml12, stringify as stringifyYaml5 } from "yaml";
+import { parse as parseYaml13, stringify as stringifyYaml5 } from "yaml";
 
 // ../../packages/brain/engine/dist/esm/librarian/config.js
-import { parse as parseYaml13 } from "yaml";
+import { parse as parseYaml14 } from "yaml";
 
 // src/lib/dream-discovery.ts
 init_http();