codebyplan 1.13.56 → 1.13.57

package/dist/cli.js

@@ -39,7 +39,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.56";
+    VERSION = "1.13.57";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -113,8 +113,8 @@ async function readLocalConfig(projectPath, onMigrationNotice) {
 }
 async function writeLocalConfig(projectPath, config) {
   const content = { device_id: config.device_id };
-  const path21 = localConfigPath(projectPath);
-  const dirPath = dirname(path21);
+  const path22 = localConfigPath(projectPath);
+  const dirPath = dirname(path22);
   let phase = "stat config directory";
   try {
     try {
@@ -134,7 +134,7 @@ async function writeLocalConfig(projectPath, config) {
     phase = "create config directory";
     await mkdir(dirPath, { recursive: true });
     phase = "write local config";
-    await writeFile(path21, JSON.stringify(content, null, 2) + "\n", "utf-8");
+    await writeFile(path22, JSON.stringify(content, null, 2) + "\n", "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "LEGACY_FILE_BLOCKS_DIR") {
@@ -652,8 +652,8 @@ var init_gitignore_block = __esm({
 // src/lib/worktree.ts
 import { mkdir as mkdir3, writeFile as writeFile4, readFile as readFile6 } from "node:fs/promises";
 import { join as join6 } from "node:path";
-function defaultExists(path21) {
-  return readFile6(path21, "utf-8").then(() => true).catch(() => false);
+function defaultExists(path22) {
+  return readFile6(path22, "utf-8").then(() => true).catch(() => false);
 }
 async function writeRepoJson(codebyplanDir, selectedRepo, deps) {
   const repoJson = {
@@ -774,9 +774,9 @@ var init_worktree = __esm({
     init_local_config();
     init_gitignore_block();
     defaultFsDeps = {
-      mkdir: (path21, opts) => mkdir3(path21, opts).then(() => void 0),
-      writeFile: (path21, data, encoding) => writeFile4(path21, data, encoding),
-      readFile: (path21, encoding) => readFile6(path21, encoding),
+      mkdir: (path22, opts) => mkdir3(path22, opts).then(() => void 0),
+      writeFile: (path22, data, encoding) => writeFile4(path22, data, encoding),
+      readFile: (path22, encoding) => readFile6(path22, encoding),
       exists: defaultExists
     };
   }
@@ -844,12 +844,12 @@ async function readFallback(filename) {
   }
 }
 async function writeFallback(filename, data) {
-  const path21 = fallbackFile(filename);
-  await mkdir4(dirname2(path21), { recursive: true });
-  await writeFile5(path21, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const path22 = fallbackFile(filename);
+  await mkdir4(dirname2(path22), { recursive: true });
+  await writeFile5(path22, JSON.stringify(data, null, 2) + "\n", "utf-8");
   if (platform() !== "win32") {
     try {
-      await chmod(path21, 384);
+      await chmod(path22, 384);
     } catch {
     }
   }
@@ -1143,8 +1143,8 @@ async function validateConnectivity() {
     );
   }
 }
-function buildUrl(path21, params) {
-  const url = new URL(`${baseUrl()}/api${path21}`);
+function buildUrl(path22, params) {
+  const url = new URL(`${baseUrl()}/api${path22}`);
   if (params) {
     for (const [key, value] of Object.entries(params)) {
       if (value !== void 0) {
@@ -1163,8 +1163,8 @@ function isRetryable(err) {
 function delay(ms) {
   return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
-async function request(method, path21, options) {
-  const url = buildUrl(path21, options?.params);
+async function request(method, path22, options) {
+  const url = buildUrl(path22, options?.params);
   const auth = await getAuthHeaders();
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -1184,7 +1184,7 @@ async function request(method, path21, options) {
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
       });
       if (!res.ok) {
-        let message = `API ${method} ${path21} failed with status ${res.status}`;
+        let message = `API ${method} ${path22} failed with status ${res.status}`;
         let code;
         try {
           const body = await res.json();
@@ -1218,20 +1218,20 @@ async function request(method, path21, options) {
   }
   throw lastError;
 }
-async function apiGet(path21, params) {
-  return request("GET", path21, { params });
+async function apiGet(path22, params) {
+  return request("GET", path22, { params });
 }
-async function apiPost(path21, body) {
-  return request("POST", path21, { body });
+async function apiPost(path22, body) {
+  return request("POST", path22, { body });
 }
-async function apiPut(path21, body) {
-  return request("PUT", path21, { body });
+async function apiPut(path22, body) {
+  return request("PUT", path22, { body });
 }
-async function apiPatch(path21, body) {
-  return request("PATCH", path21, { body });
+async function apiPatch(path22, body) {
+  return request("PATCH", path22, { body });
 }
-async function apiDelete(path21, params) {
-  await request("DELETE", path21, { params });
+async function apiDelete(path22, params) {
+  await request("DELETE", path22, { params });
 }
 async function callMcpTool(toolName, params) {
   const url = mcpEndpoint();
@@ -2229,9 +2229,229 @@ var init_templates_dir = __esm({
   }
 });
 
+// src/lib/gitignore-detect.ts
+import * as path5 from "node:path";
+import { readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
+import { spawnSync as spawnSync3 } from "node:child_process";
+function defaultGitCheckIgnore(projectDir) {
+  const result = spawnSync3(
+    "git",
+    ["check-ignore", "-v", "--", ".claude/settings.json"],
+    {
+      cwd: projectDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }
+  );
+  if (result.error) {
+    return { exitCode: 128, stdout: "", stderr: "" };
+  }
+  return {
+    exitCode: result.status,
+    stdout: (result.stdout ?? "").toString(),
+    stderr: (result.stderr ?? "").toString()
+  };
+}
+function defaultGitLsFiles(projectDir) {
+  const result = spawnSync3(
+    "git",
+    ["ls-files", "--error-unmatch", "--", ".claude/settings.json"],
+    {
+      cwd: projectDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }
+  );
+  if (result.error) {
+    return 128;
+  }
+  return result.status ?? 1;
+}
+async function defaultPromptRemoveIgnore(displayLine, opts) {
+  if (opts.yes) {
+    return true;
+  }
+  const readline2 = await import("node:readline");
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      "@codebyplan/claude: interactive prompts require a TTY. Re-run with --yes to accept defaults."
+    );
+  }
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    while (true) {
+      const answer = await new Promise((resolve16) => {
+        rl.question(
+          `The following gitignore rule matches .claude/settings.json:
+  ${displayLine}
+Remove this line?
+  [r] remove  [k] keep
+> `,
+          (input) => {
+            resolve16(input.trim().toLowerCase());
+          }
+        );
+      });
+      if (answer === "r" || answer === "remove") return true;
+      if (answer === "k" || answer === "keep") return false;
+      console.error(`Unknown answer: ${answer || "(empty)"} \u2014 try again.`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+function patternTargetsSettingsJson(pattern) {
+  const trimmed = pattern.trim();
+  if (trimmed === "" || trimmed.startsWith("!")) return false;
+  const lastSegment = trimmed.split("/").filter(Boolean).pop() ?? "";
+  return lastSegment === "settings.json" && !trimmed.endsWith("/");
+}
+function parseCheckIgnoreLine(line) {
+  const tabIdx = line.indexOf("	");
+  if (tabIdx === -1) return null;
+  const meta = line.slice(0, tabIdx);
+  const matchedPath = line.slice(tabIdx + 1);
+  const m = /^(.*):(\d+):(.*)$/.exec(meta);
+  if (!m) return null;
+  return {
+    sourceFile: m[1] ?? "",
+    lineNum: parseInt(m[2] ?? "0", 10),
+    pattern: m[3] ?? "",
+    matchedPath
+  };
+}
+async function detectAndHealSettingsGitignore(projectDir, opts, deps = {}) {
+  const gitCheckIgnore = deps.gitCheckIgnore ?? defaultGitCheckIgnore;
+  const readFileFn = deps.readFileFn ?? ((p) => readFile9(p, "utf-8"));
+  const writeFileFn = deps.writeFileFn ?? ((p, content) => writeFile7(p, content, "utf-8"));
+  const promptFn = deps.promptRemoveIgnore ?? defaultPromptRemoveIgnore;
+  const printWarning = deps.printWarning ?? ((msg) => console.warn(msg));
+  const printInfo = deps.printInfo ?? ((msg) => console.log(msg));
+  let ciResult;
+  try {
+    ciResult = gitCheckIgnore(projectDir);
+  } catch {
+    return { healed: false, skipped: "non-git" };
+  }
+  if (ciResult.exitCode === 128 || ciResult.exitCode === null) {
+    return { healed: false, skipped: "non-git" };
+  }
+  if (ciResult.exitCode !== 0) {
+    return { healed: false, skipped: "not-ignored" };
+  }
+  const rawLine = ciResult.stdout.trim().split(/\r?\n/)[0] ?? "";
+  const parsed = parseCheckIgnoreLine(rawLine);
+  if (!parsed) {
+    return { healed: false, skipped: "not-ignored" };
+  }
+  const gitignorePath = path5.isAbsolute(parsed.sourceFile) ? parsed.sourceFile : path5.join(projectDir, parsed.sourceFile);
+  let gitignoreContent;
+  try {
+    gitignoreContent = await readFileFn(gitignorePath);
+  } catch {
+    return { healed: false, skipped: "not-ignored" };
+  }
+  const nl = gitignoreContent.includes("\r\n") ? "\r\n" : "\n";
+  const lines = gitignoreContent.split(/\r?\n/);
+  const startIdx = lines.findIndex((l) => l === GITIGNORE_BLOCK_START);
+  const endIdx = lines.findIndex((l) => l === GITIGNORE_BLOCK_END);
+  const lineIdx = parsed.lineNum - 1;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx && lineIdx > startIdx && lineIdx < endIdx) {
+    return { healed: false, skipped: "managed-block" };
+  }
+  const offendingLine = lines[lineIdx] ?? parsed.pattern;
+  const displayLine = `${parsed.sourceFile}:${parsed.lineNum}: ${offendingLine}`;
+  if (patternTargetsSettingsJson(parsed.pattern)) {
+    printInfo(
+      `codebyplan: ${opts.dryRun ? "(dry-run) would remove" : "removing"} gitignore rule "${offendingLine}" (${parsed.sourceFile}:${parsed.lineNum}) \u2014 .claude/settings.json must be committed.`
+    );
+  } else {
+    let accepted;
+    try {
+      accepted = await promptFn(displayLine, opts);
+    } catch (err) {
+      printWarning(
+        `codebyplan: could not prompt to remove gitignore line (${err instanceof Error ? err.message : String(err)}). Manual fix: remove "${offendingLine}" from ${parsed.sourceFile}, then git add .claude/settings.json.`
+      );
+      return { healed: false, skipped: "user-declined" };
+    }
+    if (!accepted) {
+      printWarning(
+        `codebyplan: .claude/settings.json is gitignored by "${offendingLine}" in ${parsed.sourceFile}:${parsed.lineNum}. To fix manually: remove that line and run \`git add .claude/settings.json\`.`
+      );
+      return { healed: false, skipped: "user-declined" };
+    }
+  }
+  if (!opts.dryRun) {
+    const newLines = lines.filter((_l, idx) => idx !== lineIdx);
+    const newContent = newLines.join(nl);
+    try {
+      await writeFileFn(gitignorePath, newContent);
+    } catch (err) {
+      printWarning(
+        `codebyplan: failed to write ${parsed.sourceFile}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return { healed: false, skipped: "user-declined" };
+    }
+  }
+  return { healed: true };
+}
+function detectSettingsIgnored(projectDir, deps) {
+  const gitCheckIgnoreFn = deps?.gitCheckIgnore ?? defaultGitCheckIgnore;
+  let ciResult;
+  try {
+    ciResult = gitCheckIgnoreFn(projectDir);
+  } catch {
+    return { status: "non-git" };
+  }
+  if (ciResult.exitCode === 128 || ciResult.exitCode === null) {
+    return { status: "non-git" };
+  }
+  if (ciResult.exitCode !== 0) {
+    return { status: "not-ignored" };
+  }
+  const rawLine = ciResult.stdout.trim().split(/\r?\n/)[0] ?? "";
+  const parsed = parseCheckIgnoreLine(rawLine);
+  if (!parsed) {
+    return { status: "not-ignored" };
+  }
+  return {
+    status: "ignored",
+    info: {
+      sourceFile: parsed.sourceFile,
+      lineNum: parsed.lineNum,
+      pattern: parsed.pattern
+    }
+  };
+}
+function checkSettingsUntracked(projectDir, deps = {}) {
+  const lsFn = deps.gitLsFiles ?? defaultGitLsFiles;
+  const code = lsFn(projectDir);
+  if (code === 0) return "tracked";
+  if (code === 128) return "non-git";
+  return "untracked";
+}
+function warnIfSettingsUntracked(projectDir, deps = {}) {
+  const status = checkSettingsUntracked(projectDir, deps);
+  if (status === "untracked") {
+    console.warn(
+      "codebyplan: .claude/settings.json is untracked \u2014 run `git add .claude/settings.json` and commit it."
+    );
+  }
+}
+var init_gitignore_detect = __esm({
+  "src/lib/gitignore-detect.ts"() {
+    "use strict";
+    init_gitignore_block();
+  }
+});
+
 // src/lib/tech-detect.ts
-import { readFile as readFile9, access, readdir } from "node:fs/promises";
-import { join as join11, relative as relative2 } from "node:path";
+import { readFile as readFile10, access, readdir } from "node:fs/promises";
+import { join as join12, relative as relative2 } from "node:path";
 async function fileExists(filePath) {
   try {
     await access(filePath);
@@ -2244,8 +2464,8 @@ async function discoverMonorepoApps(projectPath) {
   const apps = [];
   const patterns = [];
   try {
-    const raw = await readFile9(
-      join11(projectPath, "pnpm-workspace.yaml"),
+    const raw = await readFile10(
+      join12(projectPath, "pnpm-workspace.yaml"),
       "utf-8"
     );
     const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
@@ -2259,7 +2479,7 @@ async function discoverMonorepoApps(projectPath) {
   }
   if (patterns.length === 0) {
     try {
-      const raw = await readFile9(join11(projectPath, "package.json"), "utf-8");
+      const raw = await readFile10(join12(projectPath, "package.json"), "utf-8");
       const pkg = JSON.parse(raw);
       const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
       if (ws) patterns.push(...ws);
@@ -2269,14 +2489,14 @@ async function discoverMonorepoApps(projectPath) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join11(projectPath, dir);
+      const absDir = join12(projectPath, dir);
       try {
         const entries = await readdir(absDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const relPath = join11(dir, entry.name);
-            const absPath = join11(absDir, entry.name);
-            if (await fileExists(join11(absPath, "package.json"))) {
+            const relPath = join12(dir, entry.name);
+            const absPath = join12(absDir, entry.name);
+            if (await fileExists(join12(absPath, "package.json"))) {
               apps.push({ name: entry.name, path: relPath, absPath });
             }
           }
@@ -2295,7 +2515,7 @@ async function hasJsxFile(dir, depth = 0) {
       const name = entry.name;
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
-        if (await hasJsxFile(join11(dir, name), depth + 1)) return true;
+        if (await hasJsxFile(join12(dir, name), depth + 1)) return true;
       } else if (entry.isFile()) {
         if (JSX_TEST_PATTERN.test(name)) continue;
         if (name.endsWith(".tsx") || name.endsWith(".jsx")) return true;
@@ -2314,7 +2534,7 @@ async function hasJsxFile(dir, depth = 0) {
 async function detectCapabilities(dirPath, pkgJson) {
   const caps = /* @__PURE__ */ new Set();
   for (const sub of JSX_SCAN_DIRS) {
-    if (await hasJsxFile(join11(dirPath, sub))) {
+    if (await hasJsxFile(join12(dirPath, sub))) {
       caps.add("jsx");
       break;
     }
@@ -2336,7 +2556,7 @@ async function detectCapabilities(dirPath, pkgJson) {
       }
     }
   }
-  if (!caps.has("node-server") && await fileExists(join11(dirPath, "src", "main.ts"))) {
+  if (!caps.has("node-server") && await fileExists(join12(dirPath, "src", "main.ts"))) {
     caps.add("node-server");
   }
   if (pkgJson && pkgJson.bin) {
@@ -2352,7 +2572,7 @@ async function detectFromDirectory(dirPath) {
   const seen = /* @__PURE__ */ new Map();
   let pkgJson = null;
   try {
-    const raw = await readFile9(join11(dirPath, "package.json"), "utf-8");
+    const raw = await readFile10(join12(dirPath, "package.json"), "utf-8");
     pkgJson = JSON.parse(raw);
     const allDeps = {
       ...pkgJson.dependencies ?? {},
@@ -2384,7 +2604,7 @@ async function detectFromDirectory(dirPath) {
   }
   for (const { file, rule } of CONFIG_FILE_MAP) {
     const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join11(dirPath, file))) {
+    if (!seen.has(key) && await fileExists(join12(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
@@ -2562,7 +2782,7 @@ function categorizeDependency(depName) {
 async function findPackageJsonFiles(dir, projectPath, depth = 0) {
   if (depth > 4) return [];
   const results = [];
-  const pkgPath = join11(dir, "package.json");
+  const pkgPath = join12(dir, "package.json");
   if (await fileExists(pkgPath)) {
     results.push(pkgPath);
   }
@@ -2571,7 +2791,7 @@ async function findPackageJsonFiles(dir, projectPath, depth = 0) {
     for (const entry of entries) {
       if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
       const subResults = await findPackageJsonFiles(
-        join11(dir, entry.name),
+        join12(dir, entry.name),
         projectPath,
         depth + 1
       );
@@ -2586,7 +2806,7 @@ async function scanAllDependencies(projectPath) {
   const dependencies = [];
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile9(pkgPath, "utf-8");
+      const raw = await readFile10(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const sourcePath = relative2(projectPath, pkgPath);
       const depSections = [
@@ -2825,7 +3045,7 @@ var init_tech_detect = __esm({
 });
 
 // src/lib/lsp-detect.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 function mapTechStackToLsp(detectedNames) {
   const pluginIndex = new Map(
     LSP_TABLE.map((s) => [s.plugin, s])
@@ -2847,7 +3067,7 @@ function binaryOnPath(binary) {
 }
 function probeWith(probe, binary) {
   try {
-    const result = spawnSync3(probe, [binary], {
+    const result = spawnSync4(probe, [binary], {
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -2988,9 +3208,9 @@ __export(lsp_exports, {
   runLsp: () => runLsp,
   runLspFull: () => runLspFull
 });
-import { readFile as readFile10, writeFile as writeFile7, mkdir as mkdir5, unlink as unlink2, access as access2 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { readFile as readFile11, writeFile as writeFile8, mkdir as mkdir5, unlink as unlink2, access as access2 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+import { spawnSync as spawnSync5 } from "node:child_process";
 async function fileExists2(filePath) {
   try {
     await access2(filePath);
@@ -3001,7 +3221,7 @@ async function fileExists2(filePath) {
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await readFile10(filePath, "utf-8");
+    const raw = await readFile11(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3009,7 +3229,7 @@ async function readJsonFile(filePath) {
 }
 function tryNpmInstallGlobal(pkg) {
   try {
-    const result = spawnSync4("npm", ["i", "-g", pkg], {
+    const result = spawnSync5("npm", ["i", "-g", pkg], {
       encoding: "utf-8",
       timeout: 6e4,
       // "pipe" (not "inherit"): inheriting the parent's fds can surface EPIPE/EIO
@@ -3042,7 +3262,7 @@ async function runLspFull(projectPath, opts = {}) {
     `  Detected LSP servers: ${servers.map((s) => s.plugin).join(", ")}
 `
   );
-  const settingsLocalPath = join12(projectPath, ".claude", "settings.local.json");
+  const settingsLocalPath = join13(projectPath, ".claude", "settings.local.json");
   let settings = {};
   const existingSettingsRaw = await readJsonFile(settingsLocalPath);
   if (existingSettingsRaw) {
@@ -3055,15 +3275,15 @@ async function runLspFull(projectPath, opts = {}) {
   if (dryRun) {
     console.log(`  [dry-run] would update ${settingsLocalPath}`);
   } else {
-    await mkdir5(join12(projectPath, ".claude"), { recursive: true });
-    await writeFile7(
+    await mkdir5(join13(projectPath, ".claude"), { recursive: true });
+    await writeFile8(
       settingsLocalPath,
       JSON.stringify(settings, null, 2) + "\n",
       "utf-8"
     );
     console.log(`  Updated ${settingsLocalPath}`);
   }
-  const lspJsonPath = join12(projectPath, ".codebyplan", "lsp.json");
+  const lspJsonPath = join13(projectPath, ".codebyplan", "lsp.json");
   const lspJsonContent = {
     servers: servers.map((s) => ({
       plugin: s.plugin,
@@ -3074,15 +3294,15 @@ async function runLspFull(projectPath, opts = {}) {
   if (dryRun) {
     console.log(`  [dry-run] would write ${lspJsonPath}`);
   } else {
-    await mkdir5(join12(projectPath, ".codebyplan"), { recursive: true });
-    await writeFile7(
+    await mkdir5(join13(projectPath, ".codebyplan"), { recursive: true });
+    await writeFile8(
       lspJsonPath,
       JSON.stringify(lspJsonContent, null, 2) + "\n",
       "utf-8"
     );
     console.log(`  Wrote ${lspJsonPath}`);
   }
-  const todoDir = join12(projectPath, ".codebyplan", "todo", "session-start");
+  const todoDir = join13(projectPath, ".codebyplan", "todo", "session-start");
   const autoInstalled = [];
   const nudged = [];
   for (const server of servers) {
@@ -3105,10 +3325,10 @@ async function runLspFull(projectPath, opts = {}) {
           `    npm install failed for ${server.npmPackage}. Writing nudge file.`
         );
         await mkdir5(todoDir, { recursive: true });
-        const nudgeFile = join12(todoDir, `install-${server.binary}.md`);
+        const nudgeFile = join13(todoDir, `install-${server.binary}.md`);
         const nudgeContent = `Run \`${server.installHint}\` to enable ${server.language} LSP support in Claude Code.
 `;
-        await writeFile7(nudgeFile, nudgeContent, "utf-8");
+        await writeFile8(nudgeFile, nudgeContent, "utf-8");
         nudged.push(server.binary);
       }
     } else {
@@ -3117,10 +3337,10 @@ async function runLspFull(projectPath, opts = {}) {
         nudged.push(server.binary);
       } else {
         await mkdir5(todoDir, { recursive: true });
-        const nudgeFile = join12(todoDir, `install-${server.binary}.md`);
+        const nudgeFile = join13(todoDir, `install-${server.binary}.md`);
         const nudgeContent = `Run \`${server.installHint}\` to enable ${server.language} LSP support in Claude Code.
 `;
-        await writeFile7(nudgeFile, nudgeContent, "utf-8");
+        await writeFile8(nudgeFile, nudgeContent, "utf-8");
         nudged.push(server.binary);
       }
     }
@@ -3154,19 +3374,19 @@ async function runLspFull(projectPath, opts = {}) {
 `);
 }
 async function runLspCheck(projectPath) {
-  const lspJsonPath = join12(projectPath, ".codebyplan", "lsp.json");
+  const lspJsonPath = join13(projectPath, ".codebyplan", "lsp.json");
   const lspJson = await readJsonFile(lspJsonPath);
   if (!lspJson || !Array.isArray(lspJson.servers)) {
     return;
   }
-  const todoDir = join12(projectPath, ".codebyplan", "todo", "session-start");
+  const todoDir = join13(projectPath, ".codebyplan", "todo", "session-start");
   const stillMissing = [];
   for (const entry of lspJson.servers) {
     const { binary, plugin } = entry;
     const found = binaryOnPath(binary);
     const fullServer = LSP_TABLE.find((s) => s.plugin === plugin);
     if (found) {
-      const nudgeFile = join12(todoDir, `install-${binary}.md`);
+      const nudgeFile = join13(todoDir, `install-${binary}.md`);
       if (await fileExists2(nudgeFile)) {
         try {
           await unlink2(nudgeFile);
@@ -3212,7 +3432,7 @@ __export(install_exports, {
 });
 import * as fs4 from "node:fs";
 import * as os2 from "node:os";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 async function runInstall(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -3240,14 +3460,14 @@ async function runInstall(opts, deps = {}) {
     const files = walkTemplates(templatesDir);
     const manifestEntries = [];
     for (const f of files) {
-      const absDest = path5.join(projectDir, ".claude", f.dest);
-      const absSrc = path5.join(templatesDir, f.src);
+      const absDest = path6.join(projectDir, ".claude", f.dest);
+      const absSrc = path6.join(templatesDir, f.src);
       if (opts.dryRun) {
         if (opts.verbose) {
           console.log(`[dry-run] would copy ${f.src} \u2192 .claude/${f.dest}`);
         }
       } else {
-        fs4.mkdirSync(path5.dirname(absDest), { recursive: true });
+        fs4.mkdirSync(path6.dirname(absDest), { recursive: true });
         fs4.copyFileSync(absSrc, absDest);
         if (opts.verbose) {
           console.log(`copied ${f.src} \u2192 .claude/${f.dest}`);
@@ -3255,14 +3475,14 @@ async function runInstall(opts, deps = {}) {
       }
       manifestEntries.push({ src: f.src, dest: f.dest, hash: f.hash });
     }
-    const hooksJsonPath = path5.join(templatesDir, "hooks", "hooks.json");
-    const baseSettingsPath = path5.join(
+    const hooksJsonPath = path6.join(templatesDir, "hooks", "hooks.json");
+    const baseSettingsPath = path6.join(
       templatesDir,
       "settings.project.base.json"
     );
     const hasHooks = fs4.existsSync(hooksJsonPath);
     const hasBase = fs4.existsSync(baseSettingsPath);
-    const settingsPath = path5.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path6.join(projectDir, ".claude", "settings.json");
     const existingSettings = fs4.existsSync(settingsPath) ? JSON.parse(fs4.readFileSync(settingsPath, "utf8")) : {};
     if (hasBase) {
       const base = JSON.parse(
@@ -3283,8 +3503,13 @@ async function runInstall(opts, deps = {}) {
         ) : void 0
       );
     }
+    await detectAndHealSettingsGitignore(
+      projectDir,
+      { yes: opts.yes, dryRun: opts.dryRun },
+      deps.detectHealDeps
+    );
     if (!opts.dryRun) {
-      fs4.mkdirSync(path5.dirname(settingsPath), { recursive: true });
+      fs4.mkdirSync(path6.dirname(settingsPath), { recursive: true });
       fs4.writeFileSync(
         settingsPath,
         JSON.stringify(existingSettings, null, 2) + "\n",
@@ -3292,16 +3517,19 @@ async function runInstall(opts, deps = {}) {
       );
     } else if (opts.verbose) {
       console.log(
-        `[dry-run] would merge settings into ${path5.relative(projectDir, settingsPath)}`
+        `[dry-run] would merge settings into ${path6.relative(projectDir, settingsPath)}`
       );
     }
+    if (!opts.dryRun) {
+      warnIfSettingsUntracked(projectDir, deps.lsFilesDep);
+    }
     const gitignoreAction = await ensureManagedGitignoreBlock(
       projectDir,
       opts.dryRun
     );
     if (opts.verbose && gitignoreAction !== "unchanged") {
       console.log(
-        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path5.relative(projectDir, path5.join(projectDir, ".gitignore"))}`
+        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path6.relative(projectDir, path6.join(projectDir, ".gitignore"))}`
       );
     }
     if (!opts.dryRun) {
@@ -3339,9 +3567,9 @@ function runInstallUser(opts, deps) {
     return;
   }
   try {
-    const userDir = deps.userDir ?? path5.join(os2.homedir(), ".claude");
-    const settingsPath = path5.join(userDir, "settings.json");
-    const userBaseSettingsPath = path5.join(
+    const userDir = deps.userDir ?? path6.join(os2.homedir(), ".claude");
+    const settingsPath = path6.join(userDir, "settings.json");
+    const userBaseSettingsPath = path6.join(
       templatesDir,
       "settings.user.base.json"
     );
@@ -3383,7 +3611,7 @@ function runInstallUser(opts, deps) {
   }
 }
 function countHookEntries(templatesDir) {
-  const p = path5.join(templatesDir, "hooks", "hooks.json");
+  const p = path6.join(templatesDir, "hooks", "hooks.json");
   if (!fs4.existsSync(p)) return 0;
   try {
     const j = JSON.parse(fs4.readFileSync(p, "utf8"));
@@ -3408,6 +3636,7 @@ var init_install = __esm({
     init_settings_merge();
     init_statusline_config();
     init_templates_dir();
+    init_gitignore_detect();
   }
 });
 
@@ -3416,17 +3645,17 @@ var setup_exports = {};
 __export(setup_exports, {
   runSetup: () => runSetup
 });
-import { readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
+import { readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { stdin, stdout as stdout2 } from "node:process";
 import { createInterface } from "node:readline/promises";
 function getConfigPath(scope) {
-  return scope === "user" ? join14(homedir4(), ".claude.json") : join14(process.cwd(), ".mcp.json");
+  return scope === "user" ? join15(homedir4(), ".claude.json") : join15(process.cwd(), ".mcp.json");
 }
-async function readConfig(path21) {
+async function readConfig(path22) {
   try {
-    const raw = await readFile11(path21, "utf-8");
+    const raw = await readFile12(path22, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -3446,7 +3675,7 @@ async function writeMcpConfig(scope) {
     config.mcpServers = {};
   }
   config.mcpServers.codebyplan = buildMcpEntry();
-  await writeFile8(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile9(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return configPath;
 }
 async function fetchRepos(auth) {
@@ -3851,15 +4080,15 @@ var upgrade_auth_exports = {};
 __export(upgrade_auth_exports, {
   runUpgradeAuth: () => runUpgradeAuth
 });
-import { readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function configPaths() {
-  return [join15(homedir5(), ".claude.json"), join15(process.cwd(), ".mcp.json")];
+  return [join16(homedir5(), ".claude.json"), join16(process.cwd(), ".mcp.json")];
 }
-async function readConfig2(path21) {
+async function readConfig2(path22) {
   try {
-    const raw = await readFile12(path21, "utf-8");
+    const raw = await readFile13(path22, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -3873,7 +4102,7 @@ function entryHasLegacyApiKey(entry) {
   if (!entry || !entry.headers) return false;
   return "x-api-key" in entry.headers;
 }
-async function rewriteConfig(path21, config, newUrl) {
+async function rewriteConfig(path22, config, newUrl) {
   const servers = config.mcpServers;
   if (!servers) return false;
   const entry = servers.codebyplan;
@@ -3881,7 +4110,7 @@ async function rewriteConfig(path21, config, newUrl) {
   if (!entryHasLegacyApiKey(entry) && entry.url === newUrl && entry.type === "http")
     return false;
   servers.codebyplan = { type: "http", url: newUrl };
-  await writeFile9(path21, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile10(path22, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return true;
 }
 async function runUpgradeAuth() {
@@ -3889,12 +4118,12 @@ async function runUpgradeAuth() {
   await runLogin();
   const newUrl = mcpEndpoint();
   let migrated = 0;
-  for (const path21 of configPaths()) {
-    const config = await readConfig2(path21);
+  for (const path22 of configPaths()) {
+    const config = await readConfig2(path22);
     if (!config) continue;
-    const changed = await rewriteConfig(path21, config, newUrl);
+    const changed = await rewriteConfig(path22, config, newUrl);
     if (changed) {
-      console.log(`  Updated ${path21}`);
+      console.log(`  Updated ${path22}`);
       migrated++;
     }
   }
@@ -4347,8 +4576,8 @@ __export(eslint_exports, {
   eslintInit: () => eslintInit,
   runEslint: () => runEslint
 });
-import { readFile as readFile13, writeFile as writeFile10, access as access3, readdir as readdir2 } from "node:fs/promises";
-import { join as join16, relative as relative4 } from "node:path";
+import { readFile as readFile14, writeFile as writeFile11, access as access3, readdir as readdir2 } from "node:fs/promises";
+import { join as join17, relative as relative4 } from "node:path";
 async function fileExists3(filePath) {
   try {
     await access3(filePath);
@@ -4359,7 +4588,7 @@ async function fileExists3(filePath) {
 }
 async function autoDetectIgnorePatterns(absPath) {
   const patterns = [];
-  if (await fileExists3(join16(absPath, "esbuild.js"))) {
+  if (await fileExists3(join17(absPath, "esbuild.js"))) {
     patterns.push("esbuild.js");
   }
   let entries = [];
@@ -4379,19 +4608,19 @@ async function autoDetectIgnorePatterns(absPath) {
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vitest.config.${ext}`;
-    if (await fileExists3(join16(absPath, candidate))) {
+    if (await fileExists3(join17(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vite.config.${ext}`;
-    if (await fileExists3(join16(absPath, candidate))) {
+    if (await fileExists3(join17(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
-  if (await fileExists3(join16(absPath, "tauri.conf.json"))) {
+  if (await fileExists3(join17(absPath, "tauri.conf.json"))) {
     patterns.push("src-tauri/**");
     patterns.push("**/*.d.ts");
   }
@@ -4399,14 +4628,14 @@ async function autoDetectIgnorePatterns(absPath) {
 }
 function detectPackageManager(projectPath) {
   return (async () => {
-    if (await fileExists3(join16(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists3(join16(projectPath, "yarn.lock"))) return "yarn";
+    if (await fileExists3(join17(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists3(join17(projectPath, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
 async function getInstalledDeps(pkgJsonPath) {
   try {
-    const raw = await readFile13(pkgJsonPath, "utf-8");
+    const raw = await readFile14(pkgJsonPath, "utf-8");
     const pkg = JSON.parse(raw);
     const all = /* @__PURE__ */ new Set();
     for (const name of Object.keys(pkg.dependencies ?? {})) all.add(name);
@@ -4519,7 +4748,7 @@ async function eslintInit(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
-    const configPath = join16(target.absPath, "eslint.config.mjs");
+    const configPath = join17(target.absPath, "eslint.config.mjs");
     configsToWrite.push({
       target,
       presets,
@@ -4541,11 +4770,11 @@ async function eslintInit(repoId, projectPath) {
     return;
   }
   const pm = await detectPackageManager(projectPath);
-  const rootPkgJsonPath = join16(projectPath, "package.json");
+  const rootPkgJsonPath = join17(projectPath, "package.json");
   const installed = await getInstalledDeps(rootPkgJsonPath);
   if (isMonorepo2) {
     for (const { target } of configsToWrite) {
-      const appPkgJson = join16(target.absPath, "package.json");
+      const appPkgJson = join17(target.absPath, "package.json");
       const appDeps = await getInstalledDeps(appPkgJson);
       for (const dep of appDeps) {
         installed.add(dep);
@@ -4597,7 +4826,7 @@ async function eslintInit(repoId, projectPath) {
   } of configsToWrite) {
     if (await fileExists3(configPath)) {
       try {
-        const existing = await readFile13(configPath, "utf-8");
+        const existing = await readFile14(configPath, "utf-8");
         const existingHash = hashConfig(existing);
         if (existingHash === hash) {
           console.log(
@@ -4617,7 +4846,7 @@ async function eslintInit(repoId, projectPath) {
       }
     }
     try {
-      await writeFile10(configPath, content, "utf-8");
+      await writeFile11(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${target.name}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -4670,16 +4899,16 @@ var init_eslint = __esm({
 });
 
 // src/lib/worktree-cache.ts
-import { mkdir as mkdir6, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname7, join as join17 } from "node:path";
+import { mkdir as mkdir6, readFile as readFile15, writeFile as writeFile12 } from "node:fs/promises";
+import { dirname as dirname7, join as join18 } from "node:path";
 function worktreeCachePath(repoRoot) {
-  return join17(repoRoot, ".codebyplan", "worktree.local.json");
+  return join18(repoRoot, ".codebyplan", "worktree.local.json");
 }
 async function readCachedWorktreeId(repoRoot, currentBranch) {
   const cachePath = worktreeCachePath(repoRoot);
   let raw;
   try {
-    raw = await readFile14(cachePath, "utf-8");
+    raw = await readFile15(cachePath, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -4725,7 +4954,7 @@ async function writeWorktreeCache(repoRoot, data) {
   };
   try {
     await mkdir6(dirPath, { recursive: true });
-    await writeFile11(
+    await writeFile12(
       cachePath,
       JSON.stringify(payload, null, 2) + "\n",
       "utf-8"
@@ -4767,25 +4996,25 @@ __export(state_store_exports, {
 import { createHash as createHash4 } from "node:crypto";
 import {
   mkdir as mkdir7,
-  readFile as readFile15,
-  writeFile as writeFile12,
+  readFile as readFile16,
+  writeFile as writeFile13,
   unlink as unlink3,
   readdir as readdir3,
   stat as stat2,
   rm
 } from "node:fs/promises";
-import { join as join18, dirname as dirname8 } from "node:path";
+import { join as join19, dirname as dirname8 } from "node:path";
 function stateDir(repoRoot) {
-  return join18(repoRoot, ".codebyplan", "state");
+  return join19(repoRoot, ".codebyplan", "state");
 }
 function cursorPath(repoRoot) {
-  return join18(stateDir(repoRoot), "_cursor.json");
+  return join19(stateDir(repoRoot), "_cursor.json");
 }
 function checkpointPath(repoRoot, checkpointId) {
-  return join18(stateDir(repoRoot), "checkpoints", `${checkpointId}.json`);
+  return join19(stateDir(repoRoot), "checkpoints", `${checkpointId}.json`);
 }
 function taskPath(repoRoot, checkpointId, taskId) {
-  return join18(
+  return join19(
     stateDir(repoRoot),
     "checkpoints",
     checkpointId,
@@ -4794,7 +5023,7 @@ function taskPath(repoRoot, checkpointId, taskId) {
   );
 }
 function roundPath(repoRoot, checkpointId, taskId, roundId) {
-  return join18(
+  return join19(
     stateDir(repoRoot),
     "checkpoints",
     checkpointId,
@@ -4805,19 +5034,19 @@ function roundPath(repoRoot, checkpointId, taskId, roundId) {
   );
 }
 function standaloneTaskPath(repoRoot, taskId) {
-  return join18(stateDir(repoRoot), "standalone_tasks", `${taskId}.json`);
+  return join19(stateDir(repoRoot), "standalone_tasks", `${taskId}.json`);
 }
 function sessionLogPath(repoRoot) {
-  return join18(stateDir(repoRoot), "session", "current.json");
+  return join19(stateDir(repoRoot), "session", "current.json");
 }
 function todosPath(repoRoot) {
-  return join18(stateDir(repoRoot), "todos.json");
+  return join19(stateDir(repoRoot), "todos.json");
 }
 function worktreesPath(repoRoot) {
-  return join18(stateDir(repoRoot), "worktrees.json");
+  return join19(stateDir(repoRoot), "worktrees.json");
 }
 function pendingMarkerPath(repoRoot, entityId) {
-  return join18(stateDir(repoRoot), "_pending", `${entityId}.json`);
+  return join19(stateDir(repoRoot), "_pending", `${entityId}.json`);
 }
 function serializeEntity(row) {
   return JSON.stringify(row, null, 2) + "\n";
@@ -4828,7 +5057,7 @@ function hashEntity(row) {
 async function readCursor(repoRoot) {
   const p = cursorPath(repoRoot);
   try {
-    const raw = await readFile15(p, "utf-8");
+    const raw = await readFile16(p, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     const code = err.code;
@@ -4845,7 +5074,7 @@ async function writeCursor(repoRoot, cursor) {
   const p = cursorPath(repoRoot);
   try {
     await mkdir7(dirname8(p), { recursive: true });
-    await writeFile12(p, JSON.stringify(cursor, null, 2) + "\n", "utf-8");
+    await writeFile13(p, JSON.stringify(cursor, null, 2) + "\n", "utf-8");
   } catch (err) {
     process.stderr.write(
       `state-store: writeCursor failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
@@ -4855,7 +5084,7 @@ async function writeCursor(repoRoot, cursor) {
 }
 async function readEntityFile(filePath) {
   try {
-    const raw = await readFile15(filePath, "utf-8");
+    const raw = await readFile16(filePath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     const code = err.code;
@@ -4873,7 +5102,7 @@ async function writeEntityFile(filePath, row) {
   const hash = createHash4("sha256").update(serialized).digest("hex");
   try {
     await mkdir7(dirname8(filePath), { recursive: true });
-    await writeFile12(filePath, serialized, "utf-8");
+    await writeFile13(filePath, serialized, "utf-8");
   } catch (err) {
     process.stderr.write(
       `state-store: writeEntityFile failed for ${filePath} (non-fatal): ${err instanceof Error ? err.message : String(err)}
@@ -4920,7 +5149,7 @@ async function collectJsonFiles(dir, out) {
     throw err;
   }
   for (const entry of entries) {
-    const full = join18(dir, entry);
+    const full = join19(dir, entry);
     try {
       const s = await stat2(full);
       if (s.isDirectory()) {
@@ -4938,7 +5167,7 @@ async function pruneEntityTree(repoRoot, knownIdsByTable) {
   const taskIds = knownIdsByTable.tasks ?? /* @__PURE__ */ new Set();
   const roundIds = knownIdsByTable.rounds ?? /* @__PURE__ */ new Set();
   const base = stateDir(repoRoot);
-  const checkpointsDir = join18(base, "checkpoints");
+  const checkpointsDir = join19(base, "checkpoints");
   const prunedCheckpointIds = /* @__PURE__ */ new Set();
   const beforePrune = pruned.length;
   await pruneJsonDir(checkpointsDir, checkpointIds, pruned);
@@ -4948,7 +5177,7 @@ async function pruneEntityTree(repoRoot, knownIdsByTable) {
   }
   for (const id of prunedCheckpointIds) {
     try {
-      await rm(join18(checkpointsDir, id), { recursive: true, force: true });
+      await rm(join19(checkpointsDir, id), { recursive: true, force: true });
     } catch (err) {
       process.stderr.write(
         `state-store: pruneEntityTree could not remove subtree for checkpoint ${id} (non-fatal): ${String(err)}
@@ -4956,7 +5185,7 @@ async function pruneEntityTree(repoRoot, knownIdsByTable) {
       );
     }
   }
-  const taskFiles = await listEntityFiles(join18(checkpointsDir));
+  const taskFiles = await listEntityFiles(join19(checkpointsDir));
   for (const f of taskFiles) {
     const chkMatch = f.match(/[/\\]checkpoints[/\\]([^/\\]+)[/\\]/);
     if (chkMatch?.[1] && prunedCheckpointIds.has(chkMatch[1])) continue;
@@ -4996,7 +5225,7 @@ async function pruneJsonDir(dir, knownIds, pruned) {
     if (!entry.endsWith(".json")) continue;
     const id = entry.slice(0, -5);
     if (!knownIds.has(id)) {
-      const full = join18(dir, entry);
+      const full = join19(dir, entry);
       await deleteEntityFile(full);
       pruned.push(full);
     }
@@ -5653,13 +5882,13 @@ function __disposeResources(env) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path21, preserveJsx) {
-  if (typeof path21 === "string" && /^\.\.?\//.test(path21)) {
-    return path21.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+function __rewriteRelativeImportExtension(path22, preserveJsx) {
+  if (typeof path22 === "string" && /^\.\.?\//.test(path22)) {
+    return path22.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
       return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
     });
   }
-  return path21;
+  return path22;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -14297,8 +14526,8 @@ var require_RealtimeChannel = __commonJS({
       }
       /** @internal */
       _notThisChannelEvent(event, ref) {
-        const { close, error, leave, join: join54 } = constants_1.CHANNEL_EVENTS;
-        const events = [close, error, leave, join54];
+        const { close, error, leave, join: join56 } = constants_1.CHANNEL_EVENTS;
+        const events = [close, error, leave, join56];
         return ref && events.includes(event) && ref !== this.joinPush.ref;
       }
       /** @internal */
@@ -15181,8 +15410,8 @@ var require_main2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/iceberg-js@0.8.1/node_modules/iceberg-js/dist/index.mjs
-function buildUrl2(baseUrl3, path21, query) {
-  const url = new URL(path21, baseUrl3);
+function buildUrl2(baseUrl3, path22, query) {
+  const url = new URL(path22, baseUrl3);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -15212,12 +15441,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path21,
+      path: path22,
       query,
       body,
       headers
     }) {
-      const url = buildUrl2(options.baseUrl, path21, query);
+      const url = buildUrl2(options.baseUrl, path22, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -16115,7 +16344,7 @@ var init_dist3 = __esm({
       * @param path The relative file path. Should be of the format `folder/subfolder/filename.png`. The bucket must already exist before attempting to upload.
       * @param fileBody The body of the file to be stored in the bucket.
       */
-      async uploadOrUpdate(method, path21, fileBody, fileOptions) {
+      async uploadOrUpdate(method, path22, fileBody, fileOptions) {
         var _this = this;
         return _this.handleOperation(async () => {
           let body;
@@ -16139,7 +16368,7 @@ var init_dist3 = __esm({
             if ((typeof ReadableStream !== "undefined" && body instanceof ReadableStream || body && typeof body === "object" && "pipe" in body && typeof body.pipe === "function") && !options.duplex) options.duplex = "half";
           }
           if (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.headers) for (const [key, value] of Object.entries(fileOptions.headers)) headers = setHeader(headers, key, value);
-          const cleanPath = _this._removeEmptyFolders(path21);
+          const cleanPath = _this._removeEmptyFolders(path22);
           const _path = _this._getFinalPath(cleanPath);
           const data = await (method == "PUT" ? put : post)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread22({ headers }, (options === null || options === void 0 ? void 0 : options.duplex) ? { duplex: options.duplex } : {}));
           return {
@@ -16201,8 +16430,8 @@ var init_dist3 = __esm({
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Upload file using `ArrayBuffer` from base64 file data instead, see example below.
       */
-      async upload(path21, fileBody, fileOptions) {
-        return this.uploadOrUpdate("POST", path21, fileBody, fileOptions);
+      async upload(path22, fileBody, fileOptions) {
+        return this.uploadOrUpdate("POST", path22, fileBody, fileOptions);
       }
       /**
       * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -16242,9 +16471,9 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: none
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async uploadToSignedUrl(path21, token, fileBody, fileOptions) {
+      async uploadToSignedUrl(path22, token, fileBody, fileOptions) {
         var _this3 = this;
-        const cleanPath = _this3._removeEmptyFolders(path21);
+        const cleanPath = _this3._removeEmptyFolders(path22);
         const _path = _this3._getFinalPath(cleanPath);
         const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
         url.searchParams.set("token", token);
@@ -16313,10 +16542,10 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `insert`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async createSignedUploadUrl(path21, options) {
+      async createSignedUploadUrl(path22, options) {
         var _this4 = this;
         return _this4.handleOperation(async () => {
-          let _path = _this4._getFinalPath(path21);
+          let _path = _this4._getFinalPath(path22);
           const headers = _objectSpread22({}, _this4.headers);
           if (options === null || options === void 0 ? void 0 : options.upsert) headers["x-upsert"] = "true";
           const data = await post(_this4.fetch, `${_this4.url}/object/upload/sign/${_path}`, {}, { headers });
@@ -16325,7 +16554,7 @@ var init_dist3 = __esm({
           if (!token) throw new StorageError("No token returned by API");
           return {
             signedUrl: url.toString(),
-            path: path21,
+            path: path22,
             token
           };
         });
@@ -16385,8 +16614,8 @@ var init_dist3 = __esm({
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Update file using `ArrayBuffer` from base64 file data instead, see example below.
       */
-      async update(path21, fileBody, fileOptions) {
-        return this.uploadOrUpdate("PUT", path21, fileBody, fileOptions);
+      async update(path22, fileBody, fileOptions) {
+        return this.uploadOrUpdate("PUT", path22, fileBody, fileOptions);
       }
       /**
       * Moves an existing file to a new path in the same bucket.
@@ -16537,10 +16766,10 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `select`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async createSignedUrl(path21, expiresIn, options) {
+      async createSignedUrl(path22, expiresIn, options) {
         var _this8 = this;
         return _this8.handleOperation(async () => {
-          let _path = _this8._getFinalPath(path21);
+          let _path = _this8._getFinalPath(path22);
           const hasTransform = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0;
           let data = await post(_this8.fetch, `${_this8.url}/object/sign/${_path}`, _objectSpread22({ expiresIn }, hasTransform ? { transform: options.transform } : {}), { headers: _this8.headers });
           const query = new URLSearchParams();
@@ -16676,13 +16905,13 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `select`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      download(path21, options, parameters) {
+      download(path22, options, parameters) {
         const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0 ? "render/image/authenticated" : "object";
         const query = new URLSearchParams();
         if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
         if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
         const queryString = query.toString();
-        const _path = this._getFinalPath(path21);
+        const _path = this._getFinalPath(path22);
         const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString ? `?${queryString}` : ""}`, {
           headers: this.headers,
           noResolveJson: true
@@ -16713,9 +16942,9 @@ var init_dist3 = __esm({
       * }
       * ```
       */
-      async info(path21) {
+      async info(path22) {
         var _this10 = this;
-        const _path = _this10._getFinalPath(path21);
+        const _path = _this10._getFinalPath(path22);
         return _this10.handleOperation(async () => {
           return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
         });
@@ -16736,9 +16965,9 @@ var init_dist3 = __esm({
       *   .exists('folder/avatar1.png')
       * ```
       */
-      async exists(path21) {
+      async exists(path22) {
         var _this11 = this;
-        const _path = _this11._getFinalPath(path21);
+        const _path = _this11._getFinalPath(path22);
         try {
           await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
           return {
@@ -16817,8 +17046,8 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: none
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      getPublicUrl(path21, options) {
-        const _path = this._getFinalPath(path21);
+      getPublicUrl(path22, options) {
+        const _path = this._getFinalPath(path22);
         const query = new URLSearchParams();
         if (options === null || options === void 0 ? void 0 : options.download) query.set("download", options.download === true ? "" : options.download);
         if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
@@ -16957,10 +17186,10 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `select`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async list(path21, options, parameters) {
+      async list(path22, options, parameters) {
         var _this13 = this;
         return _this13.handleOperation(async () => {
-          const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path21 || "" });
+          const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path22 || "" });
           return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
         });
       }
@@ -17025,11 +17254,11 @@ var init_dist3 = __esm({
         if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
         return btoa(data);
       }
-      _getFinalPath(path21) {
-        return `${this.bucketId}/${path21.replace(/^\/+/, "")}`;
+      _getFinalPath(path22) {
+        return `${this.bucketId}/${path22.replace(/^\/+/, "")}`;
       }
-      _removeEmptyFolders(path21) {
-        return path21.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+      _removeEmptyFolders(path22) {
+        return path22.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
       }
       /** Modifies the `query`, appending values the from `transform` */
       applyTransformOptsToQuery(query, transform) {
@@ -27446,8 +27675,8 @@ __export(watch_exports, {
   runWatchCommand: () => runWatchCommand
 });
 import { spawn as spawn2 } from "node:child_process";
-import { mkdir as mkdir8, readFile as readFile16, unlink as unlink4, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile17, unlink as unlink4, writeFile as writeFile14 } from "node:fs/promises";
+import { join as join20 } from "node:path";
 async function resolveIdentity() {
   const found = await findCodebyplanConfig(process.cwd());
   const repoId = found?.contents.repo_id;
@@ -27467,18 +27696,18 @@ async function resolveIdentity() {
   return { repoRoot, repoId, worktreeId };
 }
 function watchDir(repoRoot) {
-  return join19(repoRoot, ".codebyplan", "state", "_watch");
+  return join20(repoRoot, ".codebyplan", "state", "_watch");
 }
 function pidFilePath(repoRoot, worktreeId) {
-  return join19(watchDir(repoRoot), `${worktreeId ?? "default"}.pid`);
+  return join20(watchDir(repoRoot), `${worktreeId ?? "default"}.pid`);
 }
 function healthFilePath(repoRoot, worktreeId) {
-  return join19(watchDir(repoRoot), `${worktreeId ?? "default"}.health.json`);
+  return join20(watchDir(repoRoot), `${worktreeId ?? "default"}.health.json`);
 }
 async function handleStart(repoRoot, repoId, worktreeId, forwardArgs) {
   const pidFile = pidFilePath(repoRoot, worktreeId);
   try {
-    const pidStr = await readFile16(pidFile, "utf-8");
+    const pidStr = await readFile17(pidFile, "utf-8");
     const pid = parseInt(pidStr.trim(), 10);
     if (!isNaN(pid)) {
       try {
@@ -27498,7 +27727,7 @@ async function handleStart(repoRoot, repoId, worktreeId, forwardArgs) {
   }
   const lockFile = `${pidFile}.lock`;
   try {
-    await writeFile13(lockFile, String(process.pid), { flag: "wx" });
+    await writeFile14(lockFile, String(process.pid), { flag: "wx" });
   } catch {
     process.stdout.write("watch: start already in progress\n");
     process.exit(0);
@@ -27515,7 +27744,7 @@ async function handleStart(repoRoot, repoId, worktreeId, forwardArgs) {
     child.unref();
     if (child.pid !== void 0) {
       try {
-        await writeFile13(pidFile, String(child.pid), "utf-8");
+        await writeFile14(pidFile, String(child.pid), "utf-8");
       } catch {
       }
       process.stdout.write(`watch: daemon started (pid ${child.pid})
@@ -27535,7 +27764,7 @@ async function handleStop(repoRoot, worktreeId) {
   const healthFile = healthFilePath(repoRoot, worktreeId);
   let pid;
   try {
-    const pidStr = await readFile16(pidFile, "utf-8");
+    const pidStr = await readFile17(pidFile, "utf-8");
     pid = parseInt(pidStr.trim(), 10);
     if (isNaN(pid)) throw new Error("invalid pid in pidfile");
   } catch (err) {
@@ -27571,7 +27800,7 @@ async function handleStatus(repoRoot, worktreeId, subArgs) {
   let pid = null;
   let alive = false;
   try {
-    const pidStr = await readFile16(pidFile, "utf-8");
+    const pidStr = await readFile17(pidFile, "utf-8");
     const parsed = parseInt(pidStr.trim(), 10);
     if (!isNaN(parsed)) {
       pid = parsed;
@@ -27586,7 +27815,7 @@ async function handleStatus(repoRoot, worktreeId, subArgs) {
   }
   let health = null;
   try {
-    const raw = await readFile16(healthFile, "utf-8");
+    const raw = await readFile17(healthFile, "utf-8");
     health = JSON.parse(raw);
   } catch {
   }
@@ -27610,7 +27839,7 @@ async function handleRun(repoRoot, repoId, worktreeId) {
   const healthFile = healthFilePath(repoRoot, worktreeId);
   try {
     await mkdir8(watchDir(repoRoot), { recursive: true });
-    await writeFile13(pidFile, String(process.pid), "utf-8");
+    await writeFile14(pidFile, String(process.pid), "utf-8");
   } catch (err) {
     process.stderr.write(
       `watch: could not write pidfile: ${err instanceof Error ? err.message : String(err)}
@@ -27659,7 +27888,7 @@ async function handleRun(repoRoot, repoId, worktreeId) {
       worktree_id: worktreeId ?? null,
       repo_id: repoId
     };
-    void writeFile13(
+    void writeFile14(
       healthFile,
       JSON.stringify(data, null, 2) + "\n",
       "utf-8"
@@ -27748,8 +27977,8 @@ var init_watch = __esm({
 });
 
 // src/lib/state-client.ts
-async function backendRequest(method, path21, body) {
-  const url = `${getBackendBase()}${path21}`;
+async function backendRequest(method, path22, body) {
+  const url = `${getBackendBase()}${path22}`;
   const auth = await getAuthHeaders();
   const res = await fetch(url, {
     method,
@@ -27761,7 +27990,7 @@ async function backendRequest(method, path21, body) {
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
   });
   if (!res.ok) {
-    let message = `Backend ${method} ${path21} failed with status ${res.status}`;
+    let message = `Backend ${method} ${path22} failed with status ${res.status}`;
     try {
       const errBody = await res.json();
       const msg = typeof errBody.message === "string" ? errBody.message : typeof errBody.error === "string" ? errBody.error : void 0;
@@ -27775,11 +28004,11 @@ async function backendRequest(method, path21, body) {
   }
   return res.json();
 }
-async function apiBackendPost(path21, body) {
-  return backendRequest("POST", path21, body);
+async function apiBackendPost(path22, body) {
+  return backendRequest("POST", path22, body);
 }
-async function apiBackendPatch(path21, body) {
-  return backendRequest("PATCH", path21, body);
+async function apiBackendPatch(path22, body) {
+  return backendRequest("PATCH", path22, body);
 }
 var REQUEST_TIMEOUT_MS2, BackendError;
 var init_state_client = __esm({
@@ -28539,7 +28768,7 @@ __export(round_exports, {
   setRetryDelayMs: () => setRetryDelayMs
 });
 import { access as access4 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 function setRetryDelayMs(ms) {
   RETRY_DELAY_MS = ms;
@@ -28919,7 +29148,7 @@ async function runRoundSyncApprovals(args) {
           "sync-approvals: git status failed; proceeding with empty diff\n"
         );
       }
-      const hookPath = join20(
+      const hookPath = join21(
         repoRoot,
         ".claude",
         "hooks",
@@ -29588,8 +29817,8 @@ var init_session = __esm({
 });
 
 // src/lib/migrate-branch-model.ts
-import { readFile as readFile17, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { readFile as readFile18, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 import { execSync as execSync4 } from "node:child_process";
 function assertValidBranchName(branch) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -29599,7 +29828,7 @@ function assertValidBranchName(branch) {
   }
 }
 async function readJsonFile2(filePath) {
-  const raw = await readFile17(filePath, "utf-8");
+  const raw = await readFile18(filePath, "utf-8");
   const parsed = JSON.parse(raw);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error(`${filePath} does not contain a JSON object`);
@@ -29668,12 +29897,12 @@ async function runBranchMigration(opts) {
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      configPath = join21(dir, "git.json");
+      configPath = join22(dir, "git.json");
     } else {
       configPath = found.path;
     }
   } else {
-    configPath = join21(cwd, ".codebyplan", "git.json");
+    configPath = join22(cwd, ".codebyplan", "git.json");
   }
   let fileRaw;
   let fileParsed;
@@ -29747,7 +29976,7 @@ async function runBranchMigration(opts) {
     const updatedParsed = { ...fileParsed, branch_config: after };
     const newJson = JSON.stringify(updatedParsed, null, 2) + "\n";
     if (newJson !== fileRaw) {
-      await writeFile14(configPath, newJson, "utf-8");
+      await writeFile15(configPath, newJson, "utf-8");
     }
   }
   return {
@@ -29768,10 +29997,10 @@ var init_migrate_branch_model = __esm({
 
 // src/lib/supabase.ts
 import * as fs5 from "node:fs";
-import * as path6 from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import * as path7 from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function defaultRun(cmd, args) {
-  const result = spawnSync5(cmd, args, {
+  const result = spawnSync6(cmd, args, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -29848,7 +30077,7 @@ function extractStampToken(filename) {
 }
 function readShipmentConfig(cwd) {
   const dir = cwd ?? process.cwd();
-  const obj = readJsonFile3(path6.join(dir, ".codebyplan", "shipment.json"));
+  const obj = readJsonFile3(path7.join(dir, ".codebyplan", "shipment.json"));
   if (!obj) return { parentRef: null, previewBranches: [] };
   const section = getSupabaseSection(obj);
   if (!section) return { parentRef: null, previewBranches: [] };
@@ -29872,7 +30101,7 @@ function readShipmentConfig(cwd) {
 }
 function readGitConfig(cwd) {
   const dir = cwd ?? process.cwd();
-  const obj = readJsonFile3(path6.join(dir, ".codebyplan", "git.json"));
+  const obj = readJsonFile3(path7.join(dir, ".codebyplan", "git.json"));
   if (!obj) return { ...GIT_DEFAULTS };
   const bc = obj["branch_config"];
   if (typeof bc !== "object" || bc === null || Array.isArray(bc)) {
@@ -29893,7 +30122,7 @@ function readGitConfig(cwd) {
 }
 function readDbPaths(cwd) {
   const dir = cwd ?? process.cwd();
-  const obj = readJsonFile3(path6.join(dir, ".codebyplan", "shipment.json"));
+  const obj = readJsonFile3(path7.join(dir, ".codebyplan", "shipment.json"));
   if (!obj) return [...DEFAULT_DB_PATHS];
   const section = getSupabaseSection(obj);
   if (!section) return [...DEFAULT_DB_PATHS];
@@ -29933,7 +30162,7 @@ function generateMonotonicTimestamp(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const listDir = opts.listDir ?? defaultListDir;
-  const migrationsDir = path6.join(cwd, "supabase", "migrations");
+  const migrationsDir = path7.join(cwd, "supabase", "migrations");
   const files = listDir(migrationsDir);
   const existingStamps = /* @__PURE__ */ new Set();
   for (const file of files) {
@@ -30080,9 +30309,9 @@ var init_supabase = __esm({
 });
 
 // src/lib/branch-checkout.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 function defaultRun2(cmd, args, cwd) {
-  const result = spawnSync6(cmd, args, {
+  const result = spawnSync7(cmd, args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -30332,9 +30561,9 @@ var init_branch = __esm({
 });
 
 // src/lib/bump.ts
-import { readFile as readFile18, writeFile as writeFile15, access as access5, readdir as readdir4 } from "node:fs/promises";
-import { join as join23, relative as relative5, resolve as resolve3 } from "node:path";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { readFile as readFile19, writeFile as writeFile16, access as access5, readdir as readdir4 } from "node:fs/promises";
+import { join as join24, relative as relative5, resolve as resolve3 } from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
 function parsePnpmWorkspaceGlobs(raw) {
   const lines = raw.split("\n");
   const globs = [];
@@ -30363,18 +30592,18 @@ async function expandGlob(cwd, glob) {
   if (parts.length !== 2 || parts[1] !== "*") {
     return [];
   }
-  const parentDir = join23(cwd, parts[0]);
+  const parentDir = join24(cwd, parts[0]);
   let dirs;
   try {
     const entries = await readdir4(parentDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory()).map((e) => join23(parentDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory()).map((e) => join24(parentDir, e.name));
   } catch {
     return [];
   }
   const results = [];
   for (const dir of dirs) {
     try {
-      await access5(join23(dir, "package.json"));
+      await access5(join24(dir, "package.json"));
       results.push(dir);
     } catch {
     }
@@ -30385,7 +30614,7 @@ async function buildPackageMap(cwd) {
   const map = /* @__PURE__ */ new Map();
   let globs = [];
   try {
-    const raw = await readFile18(join23(cwd, "pnpm-workspace.yaml"), "utf-8");
+    const raw = await readFile19(join24(cwd, "pnpm-workspace.yaml"), "utf-8");
     globs = parsePnpmWorkspaceGlobs(raw);
   } catch {
   }
@@ -30393,7 +30622,7 @@ async function buildPackageMap(cwd) {
     const dirs = await expandGlob(cwd, glob);
     for (const dir of dirs) {
       try {
-        const pkgRaw = await readFile18(join23(dir, "package.json"), "utf-8");
+        const pkgRaw = await readFile19(join24(dir, "package.json"), "utf-8");
         const pkg = JSON.parse(pkgRaw);
         const name = pkg.name ?? relative5(cwd, dir);
         map.set(dir, { name, dir });
@@ -30471,7 +30700,7 @@ function compareSemver(a, b) {
   return 0;
 }
 function gitShowFile(cwd, ref, relPath) {
-  const result = spawnSync7("git", ["show", `${ref}:${relPath}`], {
+  const result = spawnSync8("git", ["show", `${ref}:${relPath}`], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -30512,7 +30741,7 @@ function injectVersion(raw, nextVersion, filePath) {
 async function prependChangelog(changelogPath, packageName, nextVersion, now, dryRun) {
   let existing;
   try {
-    existing = await readFile18(changelogPath, "utf-8");
+    existing = await readFile19(changelogPath, "utf-8");
   } catch {
     return false;
   }
@@ -30525,7 +30754,7 @@ async function prependChangelog(changelogPath, packageName, nextVersion, now, dr
 `;
   const updated = entry + existing;
   if (!dryRun) {
-    await writeFile15(changelogPath, updated, "utf-8");
+    await writeFile16(changelogPath, updated, "utf-8");
   }
   return true;
 }
@@ -30536,7 +30765,7 @@ async function runBump(opts) {
   const prereleaseId = opts?.prereleaseId;
   const baseBranch = await readBaseBranch(cwd);
   const baseRef = resolveBaseRef(cwd, baseBranch);
-  const diffResult = spawnSync7(
+  const diffResult = spawnSync8(
     "git",
     ["diff", "--name-only", `${baseRef}...HEAD`],
     {
@@ -30552,7 +30781,7 @@ async function runBump(opts) {
   const changedFiles = (diffResult.stdout ?? "").trim().split("\n").filter(Boolean).map((f) => resolve3(cwd, f));
   const packageMap = await buildPackageMap(cwd);
   const packageDirs = Array.from(packageMap.keys());
-  const rootPkgPath = join23(cwd, "package.json");
+  const rootPkgPath = join24(cwd, "package.json");
   const changedPackageDirs = /* @__PURE__ */ new Set();
   for (const absFile of changedFiles) {
     const owner = findOwningPackage(absFile, packageDirs);
@@ -30563,19 +30792,19 @@ async function runBump(opts) {
   const entries = [];
   for (const pkgDir of changedPackageDirs) {
     const pkgInfo = packageMap.get(pkgDir);
-    const pkgJsonPath = join23(pkgDir, "package.json");
+    const pkgJsonPath = join24(pkgDir, "package.json");
     if (pkgJsonPath === rootPkgPath) continue;
     const versionFileCandidates = [
       { abs: pkgJsonPath, rel: relative5(cwd, pkgJsonPath).replace(/\\/g, "/") }
     ];
-    const tauriConfPath = join23(pkgDir, "src-tauri", "tauri.conf.json");
+    const tauriConfPath = join24(pkgDir, "src-tauri", "tauri.conf.json");
     const tauriRelPath = relative5(cwd, tauriConfPath).replace(/\\/g, "/");
     try {
       await access5(tauriConfPath);
       versionFileCandidates.push({ abs: tauriConfPath, rel: tauriRelPath });
     } catch {
     }
-    const appJsonPath = join23(pkgDir, "app.json");
+    const appJsonPath = join24(pkgDir, "app.json");
     const appJsonRelPath = relative5(cwd, appJsonPath).replace(/\\/g, "/");
     try {
       await access5(appJsonPath);
@@ -30584,7 +30813,7 @@ async function runBump(opts) {
     }
     let currentPkgJsonRaw;
     try {
-      currentPkgJsonRaw = await readFile18(pkgJsonPath, "utf-8");
+      currentPkgJsonRaw = await readFile19(pkgJsonPath, "utf-8");
     } catch (err) {
       console.warn(
         `runBump: could not read ${pkgJsonPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -30629,7 +30858,7 @@ async function runBump(opts) {
     for (const { abs, rel } of versionFileCandidates) {
       let raw;
       try {
-        raw = await readFile18(abs, "utf-8");
+        raw = await readFile19(abs, "utf-8");
       } catch {
         continue;
       }
@@ -30643,11 +30872,11 @@ async function runBump(opts) {
       }
       const updated = injectVersion(raw, nextVersion, abs);
       if (!dryRun) {
-        await writeFile15(abs, updated, "utf-8");
+        await writeFile16(abs, updated, "utf-8");
       }
       updatedVersionFiles.push(rel);
     }
-    const changelogPath = join23(pkgDir, "CHANGELOG.md");
+    const changelogPath = join24(pkgDir, "CHANGELOG.md");
     const changelogUpdated = await prependChangelog(
       changelogPath,
       pkgInfo.name,
@@ -30757,7 +30986,7 @@ var init_bump2 = __esm({
 });
 
 // src/lib/ship.ts
-import { execSync as execSync5, spawnSync as spawnSync8 } from "node:child_process";
+import { execSync as execSync5, spawnSync as spawnSync9 } from "node:child_process";
 import { relative as relative6 } from "node:path";
 function assertValidBranchName2(branch, label) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -30789,7 +31018,7 @@ async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Prom
   let totalGhErrors = 0;
   let iteration = 0;
   while (Date.now() < deadline) {
-    const ghResult = spawnSync8(
+    const ghResult = spawnSync9(
       "gh",
       ["pr", "checks", feat, "--json", "name,state,bucket"],
       {
@@ -30940,7 +31169,7 @@ ${statusOut.trim()}`
       ...e.changelogUpdated ? [relative6(cwd, e.packageDir).replace(/\\/g, "/") + "/CHANGELOG.md"] : []
     ]);
     if (toStage.length > 0) {
-      const addResult = spawnSync8("git", ["add", "--", ...toStage], {
+      const addResult = spawnSync9("git", ["add", "--", ...toStage], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -30950,13 +31179,13 @@ ${statusOut.trim()}`
           `Failed to stage bump files: ${addResult.stderr?.trim() ?? addResult.error?.message}`
         );
       }
-      const commitResult = spawnSync8(
+      const commitResult = spawnSync9(
         "git",
         ["commit", "-m", "chore(release): bump versions"],
         { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       );
       if (commitResult.status !== 0 || commitResult.error) {
-        spawnSync8(
+        spawnSync9(
           "git",
           ["restore", "--staged", "--worktree", "--", ...toStage],
           {
@@ -31001,7 +31230,7 @@ ${statusOut.trim()}`
     } else {
       createArgs.push("--body", defaultPrBody(feat, base));
     }
-    const createResult = spawnSync8("gh", createArgs, {
+    const createResult = spawnSync9("gh", createArgs, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -31032,7 +31261,7 @@ ${statusOut.trim()}`
   });
   let mergeCommit = null;
   try {
-    const prViewResult = spawnSync8(
+    const prViewResult = spawnSync9(
       "gh",
       ["pr", "view", feat, "--json", "state,mergeCommit"],
       {
@@ -31190,14 +31419,14 @@ var init_ship2 = __esm({
 
 // src/lib/scaffold-publish-workflow.ts
 import * as fs6 from "node:fs";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 async function runScaffoldPublishWorkflow(opts) {
   await Promise.resolve();
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const projectDir = path7.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path8.resolve(opts?.projectDir ?? process.cwd());
   const templatesDir = opts?.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path7.join(
+  const templatePath = path8.join(
     templatesDir,
     "github-workflows",
     "publish.yml"
@@ -31208,7 +31437,7 @@ async function runScaffoldPublishWorkflow(opts) {
     );
   }
   const templateContent = fs6.readFileSync(templatePath, "utf-8");
-  const targetPath = path7.join(
+  const targetPath = path8.join(
     projectDir,
     ".github",
     "workflows",
@@ -31232,7 +31461,7 @@ async function runScaffoldPublishWorkflow(opts) {
       );
     }
   }
-  const targetDir = path7.dirname(targetPath);
+  const targetDir = path8.dirname(targetPath);
   fs6.mkdirSync(targetDir, { recursive: true });
   fs6.writeFileSync(targetPath, templateContent, "utf-8");
   return { status: "written", path: targetPath };
@@ -31329,7 +31558,7 @@ var init_atomic_write = __esm({
 
 // src/lib/ci-init.ts
 import * as fs8 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 function tryReadJson(filePath) {
   try {
     return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
@@ -31351,27 +31580,27 @@ function hasDevDep(pkg, name) {
 function detectPlatforms(projectDir) {
   const detected = /* @__PURE__ */ new Set();
   const dirsToScan = [projectDir];
-  const appsDir = path8.join(projectDir, "apps");
+  const appsDir = path9.join(projectDir, "apps");
   if (fs8.existsSync(appsDir)) {
     try {
       const appsEntries = fs8.readdirSync(appsDir, { withFileTypes: true });
       for (const entry of appsEntries) {
         if (entry.isDirectory()) {
-          dirsToScan.push(path8.join(appsDir, entry.name));
+          dirsToScan.push(path9.join(appsDir, entry.name));
         }
       }
     } catch {
     }
   }
   for (const dir of dirsToScan) {
-    const pkg = tryReadJson(path8.join(dir, "package.json"));
-    if (fs8.existsSync(path8.join(dir, "next.config.ts")) || fs8.existsSync(path8.join(dir, "next.config.js")) || fs8.existsSync(path8.join(dir, "next.config.mjs"))) {
+    const pkg = tryReadJson(path9.join(dir, "package.json"));
+    if (fs8.existsSync(path9.join(dir, "next.config.ts")) || fs8.existsSync(path9.join(dir, "next.config.js")) || fs8.existsSync(path9.join(dir, "next.config.mjs"))) {
       detected.add("next_js");
     }
     if (hasDep(pkg, "@nestjs/core")) {
       detected.add("nestjs");
     }
-    if (fs8.existsSync(path8.join(dir, "tauri.conf.json")) || fs8.existsSync(path8.join(dir, "src-tauri"))) {
+    if (fs8.existsSync(path9.join(dir, "tauri.conf.json")) || fs8.existsSync(path9.join(dir, "src-tauri"))) {
       detected.add("tauri");
     }
     if (hasDevDep(pkg, "@types/vscode")) {
@@ -31382,7 +31611,7 @@ function detectPlatforms(projectDir) {
       detected.add("expo");
     }
   }
-  const packagesDir = path8.join(projectDir, "packages");
+  const packagesDir = path9.join(projectDir, "packages");
   if (fs8.existsSync(packagesDir)) {
     try {
       const pkgEntries = fs8.readdirSync(packagesDir, { withFileTypes: true });
@@ -31419,10 +31648,10 @@ function buildDefaultCiConfig(platforms) {
 }
 async function runCiInit(opts) {
   await Promise.resolve();
-  const projectDir = path8.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path9.resolve(opts?.projectDir ?? process.cwd());
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const ciPath = path8.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path9.join(projectDir, ".codebyplan", "ci.json");
   const platforms = detectPlatforms(projectDir);
   if (dryRun) {
     return { status: "dry_run", path: ciPath, platforms };
@@ -31467,7 +31696,7 @@ async function runCiInit(opts) {
       platforms: newPlatforms.length > 0 ? newPlatforms : platforms
     };
   }
-  const codebyplanDir = path8.join(projectDir, ".codebyplan");
+  const codebyplanDir = path9.join(projectDir, ".codebyplan");
   fs8.mkdirSync(codebyplanDir, { recursive: true });
   writeJsonAtomic(ciPath, newConfig);
   return { status: "written", path: ciPath, platforms };
@@ -31676,7 +31905,7 @@ var init_ci_init = __esm({
 
 // src/lib/scaffold-ci-workflow.ts
 import * as fs9 from "node:fs";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 function substituteTokens(template, tokens) {
   let result = template;
   for (const [token, value] of Object.entries(tokens)) {
@@ -31686,7 +31915,7 @@ function substituteTokens(template, tokens) {
 }
 function detectPnpmVersionFromPackageJson(projectDir) {
   try {
-    const pkgPath = path9.join(projectDir, "package.json");
+    const pkgPath = path10.join(projectDir, "package.json");
     const raw = fs9.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     const pm = pkg.packageManager;
@@ -31703,7 +31932,7 @@ function detectPnpmVersionFromPackageJson(projectDir) {
 }
 function detectStrictEnforcedFromCiJson(projectDir) {
   try {
-    const ciJsonPath = path9.join(projectDir, ".codebyplan", "ci.json");
+    const ciJsonPath = path10.join(projectDir, ".codebyplan", "ci.json");
     const raw = fs9.readFileSync(ciJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.workflow?.strict_check_enforced === true;
@@ -31715,12 +31944,12 @@ async function runScaffoldCiWorkflow(opts) {
   await Promise.resolve();
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const projectDir = path9.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path10.resolve(opts?.projectDir ?? process.cwd());
   const pnpmVersion = opts?.pnpmVersion ?? detectPnpmVersionFromPackageJson(projectDir);
   const nodeVersion = opts?.nodeVersion ?? "22";
   const strictEnforced = opts?.strictEnforced ?? detectStrictEnforcedFromCiJson(projectDir);
   const templatesDir = opts?.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path9.join(templatesDir, "github-workflows", "ci.yml");
+  const templatePath = path10.join(templatesDir, "github-workflows", "ci.yml");
   if (!fs9.existsSync(templatePath)) {
     throw new Error(
       `scaffold-ci-workflow: template not found at ${templatePath}`
@@ -31733,7 +31962,7 @@ async function runScaffoldCiWorkflow(opts) {
     STRICT_NAME_SUFFIX: strictEnforced ? "" : " (report-only)",
     STRICT_CONTINUE_ON_ERROR_LINE: strictEnforced ? "" : "\n    continue-on-error: true"
   });
-  const targetPath = path9.join(projectDir, ".github", "workflows", "ci.yml");
+  const targetPath = path10.join(projectDir, ".github", "workflows", "ci.yml");
   if (dryRun) {
     return { status: "dry_run", path: targetPath };
   }
@@ -31752,7 +31981,7 @@ async function runScaffoldCiWorkflow(opts) {
       );
     }
   }
-  const targetDir = path9.dirname(targetPath);
+  const targetDir = path10.dirname(targetPath);
   fs9.mkdirSync(targetDir, { recursive: true });
   const tmpPath = targetPath + ".tmp";
   try {
@@ -31776,10 +32005,10 @@ var init_scaffold_ci_workflow = __esm({
 
 // src/lib/gh-required-checks.ts
 import * as fs10 from "node:fs";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import { execSync as execSync6 } from "node:child_process";
 function readCiJson(projectDir) {
-  const ciPath = path10.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path11.join(projectDir, ".codebyplan", "ci.json");
   if (!fs10.existsSync(ciPath)) {
     return {
       platforms: {},
@@ -31798,15 +32027,15 @@ function readCiJson(projectDir) {
   }
 }
 function writeCiJsonAtomic(projectDir, config) {
-  const ciPath = path10.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path11.join(projectDir, ".codebyplan", "ci.json");
   writeJsonAtomic(ciPath, config);
 }
 function enforceRequiredCheck(opts) {
-  const projectDir = path10.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path11.resolve(opts?.projectDir ?? process.cwd());
   const branch = opts?.branch ?? "main";
   const checkName = opts?.checkName ?? "Lint + typecheck + test + build";
   const dryRun = opts?.dryRun ?? false;
-  const ciPath = path10.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path11.join(projectDir, ".codebyplan", "ci.json");
   const config = readCiJson(projectDir);
   if (config.workflow?.required_check_enforced === true) {
     return { status: "already_enforced", path: ciPath };
@@ -32213,9 +32442,9 @@ var init_ci = __esm({
 
 // src/lib/cd-init.ts
 import * as fs11 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 function detectSurfaces(projectDir) {
-  const shipmentPath = path11.join(projectDir, ".codebyplan", "shipment.json");
+  const shipmentPath = path12.join(projectDir, ".codebyplan", "shipment.json");
   let shipment;
   try {
     shipment = JSON.parse(fs11.readFileSync(shipmentPath, "utf-8"));
@@ -32268,10 +32497,10 @@ function buildDefaultCdConfig(rawSurfaceKeys) {
 }
 async function runCdInit(opts) {
   await Promise.resolve();
-  const projectDir = path11.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path12.resolve(opts?.projectDir ?? process.cwd());
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const cdPath = path11.join(projectDir, ".codebyplan", "cd.json");
+  const cdPath = path12.join(projectDir, ".codebyplan", "cd.json");
   const rawSurfaceKeys = detectSurfaces(projectDir);
   const seen = /* @__PURE__ */ new Set();
   const surfaces = [];
@@ -32312,7 +32541,7 @@ async function runCdInit(opts) {
       surfaces: newSurfaces
     };
   }
-  const codebyplanDir = path11.join(projectDir, ".codebyplan");
+  const codebyplanDir = path12.join(projectDir, ".codebyplan");
   fs11.mkdirSync(codebyplanDir, { recursive: true });
   writeJsonAtomic(cdPath, newConfig);
   return { status: "written", path: cdPath, surfaces };
@@ -32402,14 +32631,14 @@ var init_cd_init = __esm({
 
 // src/lib/scaffold-cd-workflow.ts
 import * as fs12 from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 async function scaffoldOneWorkflow(templateName, targetName, opts) {
   await Promise.resolve();
   const dryRun = opts.dryRun ?? false;
   const force = opts.force ?? false;
-  const projectDir = path12.resolve(opts.projectDir ?? process.cwd());
+  const projectDir = path13.resolve(opts.projectDir ?? process.cwd());
   const templatesDir = opts.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path12.join(
+  const templatePath = path13.join(
     templatesDir,
     "github-workflows",
     templateName
@@ -32420,7 +32649,7 @@ async function scaffoldOneWorkflow(templateName, targetName, opts) {
     );
   }
   const templateContent = fs12.readFileSync(templatePath, "utf-8");
-  const targetPath = path12.join(projectDir, ".github", "workflows", targetName);
+  const targetPath = path13.join(projectDir, ".github", "workflows", targetName);
   if (dryRun) {
     return { status: "dry_run", path: targetPath };
   }
@@ -32439,7 +32668,7 @@ async function scaffoldOneWorkflow(templateName, targetName, opts) {
       );
     }
   }
-  const targetDir = path12.dirname(targetPath);
+  const targetDir = path13.dirname(targetPath);
   fs12.mkdirSync(targetDir, { recursive: true });
   const tmpPath = targetPath + ".tmp";
   try {
@@ -33115,7 +33344,7 @@ __export(version_status_exports, {
 });
 import { execFileSync, execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname12, join as join30 } from "node:path";
+import { dirname as dirname12, join as join31 } from "node:path";
 function fetchLatestVersion() {
   try {
     return execFileSync("npm", ["view", "codebyplan", "version"], {
@@ -33139,9 +33368,9 @@ function detectPackageManager2(gitRoot) {
   let dir = process.cwd();
   const stopAt = gitRoot ?? null;
   while (true) {
-    if (existsSync10(join30(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync10(join30(dir, "yarn.lock"))) return "yarn";
-    if (existsSync10(join30(dir, "package-lock.json"))) return "npm";
+    if (existsSync10(join31(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync10(join31(dir, "yarn.lock"))) return "yarn";
+    if (existsSync10(join31(dir, "package-lock.json"))) return "npm";
     if (stopAt !== null && dir === stopAt) break;
     const parent = dirname12(dir);
     if (parent === dir) break;
@@ -33161,7 +33390,7 @@ function buildInstallCommand2(pm) {
 }
 async function resolveGuard(gitRoot, currentBranch) {
   if (gitRoot !== null) {
-    const canonicalPkgPath = join30(
+    const canonicalPkgPath = join31(
       gitRoot,
       "packages",
       "codebyplan-package",
@@ -33185,10 +33414,10 @@ async function resolveGuard(gitRoot, currentBranch) {
       let gitJsonPath;
       if (found.path.endsWith("/repo.json")) {
         const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join30(dir, "git.json");
+        gitJsonPath = join31(dir, "git.json");
       } else {
         const legacyDir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join30(legacyDir, ".codebyplan", "git.json");
+        gitJsonPath = join31(legacyDir, ".codebyplan", "git.json");
       }
       const raw = readFileSync11(gitJsonPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -33272,8 +33501,8 @@ var upload_e2e_images_exports = {};
 __export(upload_e2e_images_exports, {
   runUploadE2eImagesCommand: () => runUploadE2eImagesCommand
 });
-import { readFile as readFile19 } from "node:fs/promises";
-import { join as join31, basename, resolve as resolve10 } from "node:path";
+import { readFile as readFile20 } from "node:fs/promises";
+import { join as join32, basename, resolve as resolve10 } from "node:path";
 import { execSync as execSync8 } from "node:child_process";
 function baseUrl2() {
   return (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
@@ -33307,8 +33536,8 @@ function parseArgs(args) {
 }
 async function readE2eConfig(projectPath) {
   try {
-    const raw = await readFile19(
-      join31(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile20(
+      join32(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -33349,7 +33578,7 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
       continue;
     const isNew = status === "A";
     results.push({
-      absolutePath: join31(projectPath, filePath),
+      absolutePath: join32(projectPath, filePath),
       filename: basename(filePath),
       framework: frameworkName,
       is_new: isNew
@@ -33446,7 +33675,7 @@ async function runUploadE2eImagesCommand(args) {
   for (const png of allPngs) {
     let bytes;
     try {
-      bytes = await readFile19(png.absolutePath);
+      bytes = await readFile20(png.absolutePath);
     } catch {
       process.stderr.write(
         `upload-e2e-images: could not read file: ${png.absolutePath}
@@ -33523,10 +33752,10 @@ __export(arch_map_exports, {
   runArchMapCommand: () => runArchMapCommand,
   updateFrontmatterFields: () => updateFrontmatterFields
 });
-import { readFile as readFile20, writeFile as writeFile16 } from "node:fs/promises";
+import { readFile as readFile21, writeFile as writeFile17 } from "node:fs/promises";
 import { existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
-import { join as join32 } from "node:path";
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { join as join33 } from "node:path";
+import { spawnSync as spawnSync10 } from "node:child_process";
 function normalizeModulePath(modulePath) {
   return modulePath.replace(/\/+$/, "");
 }
@@ -33550,9 +33779,9 @@ async function resolveCodebyplanDir(startDir) {
   }
 }
 async function readArchitectureConfig(codebyplanDir) {
-  const filePath = join32(codebyplanDir, "architecture.json");
+  const filePath = join33(codebyplanDir, "architecture.json");
   try {
-    const raw = await readFile20(filePath, "utf-8");
+    const raw = await readFile21(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.modules)) {
       return { version: 1, modules: [] };
@@ -33563,12 +33792,12 @@ async function readArchitectureConfig(codebyplanDir) {
   }
 }
 async function writeArchitectureConfig(codebyplanDir, config) {
-  const filePath = join32(codebyplanDir, "architecture.json");
-  await writeFile16(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const filePath = join33(codebyplanDir, "architecture.json");
+  await writeFile17(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function resolveGitSha(modulePath, cwd) {
   try {
-    const result = spawnSync9(
+    const result = spawnSync10(
       "git",
       ["log", "--format=%H", "-1", "--", modulePath],
       { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -33582,10 +33811,10 @@ function resolveGitSha(modulePath, cwd) {
 }
 async function discoverModulePaths(projectRoot) {
   const paths = [];
-  const workspacePath = join32(projectRoot, "pnpm-workspace.yaml");
+  const workspacePath = join33(projectRoot, "pnpm-workspace.yaml");
   let patterns = [];
   try {
-    const raw = await readFile20(workspacePath, "utf-8");
+    const raw = await readFile21(workspacePath, "utf-8");
     const lines = raw.split("\n");
     let inPackages = false;
     for (const line of lines) {
@@ -33609,7 +33838,7 @@ async function discoverModulePaths(projectRoot) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join32(projectRoot, dir);
+      const absDir = join33(projectRoot, dir);
       try {
         if (existsSync11(absDir)) {
           const entries = readdirSync4(absDir, { withFileTypes: true });
@@ -33622,7 +33851,7 @@ async function discoverModulePaths(projectRoot) {
       } catch {
       }
     } else if (!pattern.includes("*")) {
-      const absPath = join32(projectRoot, pattern);
+      const absPath = join33(projectRoot, pattern);
       if (existsSync11(absPath)) {
         paths.push(pattern);
       }
@@ -33630,7 +33859,7 @@ async function discoverModulePaths(projectRoot) {
   }
   const crossCutting = ["supabase", ".github", "scripts"];
   for (const dir of crossCutting) {
-    const absPath = join32(projectRoot, dir);
+    const absPath = join33(projectRoot, dir);
     try {
       if (existsSync11(absPath)) {
         paths.push(dir);
@@ -33816,10 +34045,10 @@ async function runStamp(modulePath, sha, depthArg, projectRoot) {
   }
   await writeArchitectureConfig(codebyplanDir, config);
   const stampedEntry = existingIndex >= 0 ? config.modules[existingIndex] : config.modules[config.modules.length - 1];
-  const mapAbsPath = join32(repoRoot, stampedEntry.map_file);
+  const mapAbsPath = join33(repoRoot, stampedEntry.map_file);
   let mapContent = null;
   try {
-    mapContent = await readFile20(mapAbsPath, "utf-8");
+    mapContent = await readFile21(mapAbsPath, "utf-8");
   } catch {
     console.warn(
       "  Warning: map file " + stampedEntry.map_file + " not found \u2014 stamped manifest only"
@@ -33841,7 +34070,7 @@ async function runStamp(modulePath, sha, depthArg, projectRoot) {
       );
     } else {
       try {
-        await writeFile16(mapAbsPath, updated, "utf-8");
+        await writeFile17(mapAbsPath, updated, "utf-8");
       } catch (writeErr) {
         console.warn(
           "  Warning: could not write map file " + stampedEntry.map_file + " \u2014 " + (writeErr instanceof Error ? writeErr.message : String(writeErr)) + " \u2014 stamped manifest only"
@@ -34021,19 +34250,19 @@ var init_worktree_port_resolver = __esm({
 });
 
 // src/lib/migrate-local-config.ts
-import { mkdir as mkdir9, readFile as readFile21, unlink as unlink5, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join33 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile22, unlink as unlink5, writeFile as writeFile18 } from "node:fs/promises";
+import { join as join34 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join33(projectPath, ".codebyplan.json");
+  return join34(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join33(projectPath, ".codebyplan.local.json");
+  return join34(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join33(projectPath, ".codebyplan");
+  return join34(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join33(projectPath, ".codebyplan", "repo.json");
+  return join34(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
   const { stat: stat3 } = await import("node:fs/promises");
@@ -34072,7 +34301,7 @@ async function runLocalMigration(projectPath) {
   }
   let legacyRaw;
   try {
-    legacyRaw = await readFile21(legacySharedPath(projectPath), "utf-8");
+    legacyRaw = await readFile22(legacySharedPath(projectPath), "utf-8");
   } catch {
     return {
       migrated: true,
@@ -34099,7 +34328,7 @@ async function runLocalMigration(projectPath) {
   let deviceId;
   let deviceWrittenByHelper = false;
   try {
-    const localRaw = await readFile21(legacyLocalPath(projectPath), "utf-8");
+    const localRaw = await readFile22(legacyLocalPath(projectPath), "utf-8");
     const localParsed = JSON.parse(localRaw);
     if (typeof localParsed.device_id === "string") {
       deviceId = localParsed.device_id;
@@ -34126,8 +34355,8 @@ async function runLocalMigration(projectPath) {
   if ("repo_id" in cfg) repoJson.repo_id = cfg.repo_id;
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "repo.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -34139,8 +34368,8 @@ async function runLocalMigration(projectPath) {
     serverJson.auto_push_enabled = cfg.auto_push_enabled;
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "server.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -34148,44 +34377,44 @@ async function runLocalMigration(projectPath) {
   const gitJson = {};
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "git.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/git.json");
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "shipment.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "vendor.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "e2e.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
-  await writeFile17(
-    join33(projectPath, ".codebyplan", "eslint.json"),
+  await writeFile18(
+    join34(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/eslint.json");
   if (!deviceWrittenByHelper) {
-    await writeFile17(
-      join33(projectPath, ".codebyplan", "device.local.json"),
+    await writeFile18(
+      join34(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -34197,9 +34426,9 @@ async function runLocalMigration(projectPath) {
       "Migration write incomplete: .codebyplan/repo.json was not persisted. Re-run migration to retry from a clean state."
     );
   }
-  const gitignorePath = join33(projectPath, ".gitignore");
+  const gitignorePath = join34(projectPath, ".gitignore");
   try {
-    const gitignoreContent = await readFile21(gitignorePath, "utf-8");
+    const gitignoreContent = await readFile22(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
     const newLine = ".codebyplan/device.local.json";
     const hasLegacy = gitignoreContent.split("\n").some((l) => l.trimEnd() === legacyLine);
@@ -34218,7 +34447,7 @@ async function runLocalMigration(projectPath) {
       updated = gitignoreContent;
     }
     if (updated !== gitignoreContent) {
-      await writeFile17(gitignorePath, updated, "utf-8");
+      await writeFile18(gitignorePath, updated, "utf-8");
       filesChanged.push(".gitignore");
     }
   } catch {
@@ -34260,8 +34489,8 @@ __export(config_exports, {
   runConfig: () => runConfig,
   runConfigMigrate: () => runConfigMigrate
 });
-import { mkdir as mkdir10, readFile as readFile22, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join34 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile23, writeFile as writeFile19 } from "node:fs/promises";
+import { join as join35 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -34294,7 +34523,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join34(projectPath, ".codebyplan");
+  const codebyplanDir = join35(projectPath, ".codebyplan");
   const {
     resolvedWorktreeId,
     portAllocations,
@@ -34387,16 +34616,16 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   ];
   let anyUpdated = false;
   for (const { name, payload, createOnly } of files) {
-    const filePath = join34(codebyplanDir, name);
+    const filePath = join35(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
-      currentJson = await readFile22(filePath, "utf-8");
+      currentJson = await readFile23(filePath, "utf-8");
     } catch {
     }
     if (createOnly && currentJson !== "") continue;
     if (currentJson === newJson) continue;
-    await writeFile18(filePath, newJson, "utf-8");
+    await writeFile19(filePath, newJson, "utf-8");
     console.log(`  Updated .codebyplan/${name}`);
     anyUpdated = true;
   }
@@ -34406,8 +34635,8 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 }
 async function readRepoConfig(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "repo.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34417,8 +34646,8 @@ async function readRepoConfig(projectPath) {
 }
 async function readServerConfig(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "server.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34428,8 +34657,8 @@ async function readServerConfig(projectPath) {
 }
 async function readGitConfig2(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "git.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34439,8 +34668,8 @@ async function readGitConfig2(projectPath) {
 }
 async function readShipmentConfig2(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "shipment.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34450,8 +34679,8 @@ async function readShipmentConfig2(projectPath) {
 }
 async function readVendorConfig(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34461,8 +34690,8 @@ async function readVendorConfig(projectPath) {
 }
 async function readE2eConfig2(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34472,8 +34701,8 @@ async function readE2eConfig2(projectPath) {
 }
 async function readServerLocalConfig(projectPath) {
   try {
-    const raw = await readFile22(
-      join34(projectPath, ".codebyplan", "server.local.json"),
+    const raw = await readFile23(
+      join35(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34545,8 +34774,8 @@ var init_config = __esm({
 });
 
 // src/lib/server-detect.ts
-import { readFile as readFile23, readdir as readdir5, access as access6 } from "node:fs/promises";
-import { join as join35 } from "node:path";
+import { readFile as readFile24, readdir as readdir5, access as access6 } from "node:fs/promises";
+import { join as join36 } from "node:path";
 async function fileExists4(filePath) {
   try {
     await access6(filePath);
@@ -34557,8 +34786,8 @@ async function fileExists4(filePath) {
 }
 function detectPackageManager3(dir) {
   return (async () => {
-    if (await fileExists4(join35(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists4(join35(dir, "yarn.lock"))) return "yarn";
+    if (await fileExists4(join36(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists4(join36(dir, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
@@ -34590,12 +34819,12 @@ function detectPortFromScripts(pkg) {
   return null;
 }
 async function isMonorepo(dir) {
-  return await fileExists4(join35(dir, "turbo.json")) || await fileExists4(join35(dir, "pnpm-workspace.yaml"));
+  return await fileExists4(join36(dir, "turbo.json")) || await fileExists4(join36(dir, "pnpm-workspace.yaml"));
 }
 async function detectServers(projectPath) {
   let pkg;
   try {
-    const raw = await readFile23(join35(projectPath, "package.json"), "utf-8");
+    const raw = await readFile24(join36(projectPath, "package.json"), "utf-8");
     pkg = JSON.parse(raw);
   } catch {
     return {
@@ -34611,15 +34840,15 @@ async function detectServers(projectPath) {
   const mono = await isMonorepo(projectPath);
   const servers = [];
   if (mono) {
-    const appsDir = join35(projectPath, "apps");
+    const appsDir = join36(projectPath, "apps");
     try {
       const entries = await readdir5(appsDir, { withFileTypes: true });
       const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
       for (const entry of sorted) {
         if (!entry.isDirectory()) continue;
-        const appPkgPath = join35(appsDir, entry.name, "package.json");
+        const appPkgPath = join36(appsDir, entry.name, "package.json");
         try {
-          const appRaw = await readFile23(appPkgPath, "utf-8");
+          const appRaw = await readFile24(appPkgPath, "utf-8");
           const appPkg = JSON.parse(appRaw);
           const appName = entry.name;
           const framework = detectFramework(appPkg);
@@ -34662,14 +34891,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile24 } from "node:fs/promises";
+import { readFile as readFile25 } from "node:fs/promises";
 async function verifyPorts(projectPath, portAllocations) {
   const mismatches = [];
   const allocatedPorts = new Set(portAllocations.map((a) => a.port));
   const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile24(pkgPath, "utf-8");
+      const raw = await readFile25(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -34732,7 +34961,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile24(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile25(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -34782,8 +35011,8 @@ __export(ports_exports, {
   parseEnvFile: () => parseEnvFile,
   runPorts: () => runPorts
 });
-import { mkdir as mkdir11, readFile as readFile25, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { mkdir as mkdir11, readFile as readFile26, writeFile as writeFile20 } from "node:fs/promises";
+import { join as join37 } from "node:path";
 function printDetectionResult(result, projectPath) {
   console.log(`
   CodeByPlan Ports - List`);
@@ -34939,12 +35168,12 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // and ServerLocalConfig.port_allocations is typed the same — honest end-to-end.
     port_allocations: portAllocations
   };
-  const codebyplanDir = join36(projectPath, ".codebyplan");
-  const filePath = join36(codebyplanDir, "server.local.json");
+  const codebyplanDir = join37(projectPath, ".codebyplan");
+  const filePath = join37(codebyplanDir, "server.local.json");
   const newJson = JSON.stringify(payload, null, 2) + "\n";
   let currentJson = "";
   try {
-    currentJson = await readFile25(filePath, "utf-8");
+    currentJson = await readFile26(filePath, "utf-8");
   } catch {
   }
   if (currentJson === newJson) {
@@ -34956,17 +35185,17 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     return;
   }
   await mkdir11(codebyplanDir, { recursive: true });
-  await writeFile19(filePath, newJson, "utf-8");
+  await writeFile20(filePath, newJson, "utf-8");
   console.log(
     `  Updated .codebyplan/server.local.json (worktree ${resolvedWorktreeId ?? "\u2014"}, ${portAllocations.length} allocation${portAllocations.length === 1 ? "" : "s"}).`
   );
 }
 async function provisionE2eEnv(projectPath, dryRun) {
-  const relSource = join36("apps", "web", ".env.local");
-  const sourcePath = join36(projectPath, relSource);
+  const relSource = join37("apps", "web", ".env.local");
+  const sourcePath = join37(projectPath, relSource);
   let sourceRaw;
   try {
-    sourceRaw = await readFile25(sourcePath, "utf-8");
+    sourceRaw = await readFile26(sourcePath, "utf-8");
   } catch {
     console.warn(
       `  Skipped .codebyplan/e2e.env \u2014 source ${relSource} not found.`
@@ -34995,12 +35224,12 @@ async function provisionE2eEnv(projectPath, dryRun) {
     );
     return;
   }
-  const codebyplanDir = join36(projectPath, ".codebyplan");
-  const filePath = join36(codebyplanDir, "e2e.env");
+  const codebyplanDir = join37(projectPath, ".codebyplan");
+  const filePath = join37(codebyplanDir, "e2e.env");
   const newContent = lines.join("\n") + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile25(filePath, "utf-8");
+    currentContent = await readFile26(filePath, "utf-8");
   } catch {
   }
   if (currentContent === newContent) {
@@ -35012,7 +35241,7 @@ async function provisionE2eEnv(projectPath, dryRun) {
     return;
   }
   await mkdir11(codebyplanDir, { recursive: true });
-  await writeFile19(filePath, newContent, "utf-8");
+  await writeFile20(filePath, newContent, "utf-8");
   console.log(
     `  Provisioned .codebyplan/e2e.env (${lines.length} var${lines.length === 1 ? "" : "s"}).`
   );
@@ -35280,8 +35509,8 @@ __export(docs_exports, {
   stripRangePrefix: () => stripRangePrefix
 });
 import { existsSync as existsSync13 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile26, readdir as readdir6, rm as rm2, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname13, isAbsolute, join as join37, relative as relative7, sep as sep2 } from "node:path";
+import { mkdir as mkdir12, readFile as readFile27, readdir as readdir6, rm as rm2, writeFile as writeFile21 } from "node:fs/promises";
+import { dirname as dirname13, isAbsolute as isAbsolute2, join as join38, relative as relative7, sep as sep2 } from "node:path";
 function selectDependencies(deps) {
   const byName = /* @__PURE__ */ new Map();
   for (const dep of deps) {
@@ -35335,12 +35564,12 @@ async function mapWithConcurrency(items, limit, fn) {
 }
 async function resolveExactVersion(projectPath, dep) {
   const candidateDirs = [projectPath];
-  const sourceDir = join37(projectPath, dirname13(dep.sourcePath));
+  const sourceDir = join38(projectPath, dirname13(dep.sourcePath));
   if (sourceDir !== projectPath) candidateDirs.push(sourceDir);
   for (const base of candidateDirs) {
     try {
-      const raw = await readFile26(
-        join37(base, "node_modules", dep.name, "package.json"),
+      const raw = await readFile27(
+        join38(base, "node_modules", dep.name, "package.json"),
         "utf-8"
       );
       const pkg = JSON.parse(raw);
@@ -35354,8 +35583,8 @@ async function resolveExactVersion(projectPath, dep) {
 }
 async function readVendorDocsPath(projectPath) {
   try {
-    const raw = await readFile26(
-      join37(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile27(
+      join38(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     const parsed = JSON.parse(raw);
@@ -35368,7 +35597,7 @@ async function readVendorDocsPath(projectPath) {
 }
 async function resolveDocsDir(projectPath, flags) {
   const configured = flags["dir"] ?? await readVendorDocsPath(projectPath) ?? DEFAULT_DOCS_DIR;
-  const absDir = isAbsolute(configured) ? configured : join37(projectPath, configured);
+  const absDir = isAbsolute2(configured) ? configured : join38(projectPath, configured);
   const rel = relative7(projectPath, absDir);
   const relDir = rel === "" || rel.startsWith("..") ? null : rel.split(sep2).join("/");
   return { absDir, relDir };
@@ -35377,7 +35606,7 @@ async function readDocsLock(absDir) {
   const empty = { generated_at: "", libraries: {} };
   let raw;
   try {
-    raw = await readFile26(join37(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile27(join38(absDir, LOCK_FILE), "utf-8");
   } catch {
     return empty;
   }
@@ -35473,10 +35702,10 @@ function buildTopIndex(outcomes) {
 }
 async function ensureDocsGitignoreEntry(projectPath, relDir, dryRun) {
   const entry = `/${relDir}/`;
-  const gitignorePath = join37(projectPath, ".gitignore");
+  const gitignorePath = join38(projectPath, ".gitignore");
   let existing = "";
   try {
-    existing = await readFile26(gitignorePath, "utf-8");
+    existing = await readFile27(gitignorePath, "utf-8");
   } catch {
   }
   const lines = existing.split(/\r?\n/).map((l) => l.trim());
@@ -35488,7 +35717,7 @@ async function ensureDocsGitignoreEntry(projectPath, relDir, dryRun) {
     content += `${GITIGNORE_COMMENT}
 ${entry}
 `;
-    await writeFile20(gitignorePath, content, "utf-8");
+    await writeFile21(gitignorePath, content, "utf-8");
   }
   return "added";
 }
@@ -35496,7 +35725,7 @@ async function markUncovered(dep, exactVersion, ctx) {
   console.log(
     `  uncovered ${dep.name}@${exactVersion || "?"} \u2014 no docs in the library mirror`
   );
-  const libPath = join37(ctx.absDir, libDirName(dep.name));
+  const libPath = join38(ctx.absDir, libDirName(dep.name));
   if (existsSync13(libPath)) {
     if (ctx.dryRun) {
       console.log(`  would remove stale mirror dir ${libPath}`);
@@ -35549,14 +35778,14 @@ async function syncOneLibrary(dep, ctx) {
     }
   }
   const lockEntry = ctx.lock.libraries[dep.name];
-  const libPath = join37(ctx.absDir, libDirName(dep.name));
-  const versionPath = join37(libPath, manifest.resolved_version);
+  const libPath = join38(ctx.absDir, libDirName(dep.name));
+  const versionPath = join38(libPath, manifest.resolved_version);
   if (manifestMatchesLock(manifest, lockEntry)) {
     console.log(`  unchanged ${dep.name}@${manifest.resolved_version}`);
-    if (!ctx.dryRun && !existsSync13(join37(libPath, "INDEX.md"))) {
+    if (!ctx.dryRun && !existsSync13(join38(libPath, "INDEX.md"))) {
       await mkdir12(libPath, { recursive: true });
-      await writeFile20(
-        join37(libPath, "INDEX.md"),
+      await writeFile21(
+        join38(libPath, "INDEX.md"),
         buildLibIndex(dep.name, manifest),
         "utf-8"
       );
@@ -35578,14 +35807,14 @@ async function syncOneLibrary(dep, ctx) {
       );
       continue;
     }
-    const target = join37(versionPath, rel);
+    const target = join38(versionPath, rel);
     if (sameVersionLockFiles[file.path] === file.content_hash && existsSync13(target)) {
       continue;
     }
     written++;
     if (!ctx.dryRun) {
       await mkdir12(dirname13(target), { recursive: true });
-      await writeFile20(target, file.content, "utf-8");
+      await writeFile21(target, file.content, "utf-8");
     }
   }
   let removedFiles = 0;
@@ -35596,7 +35825,7 @@ async function syncOneLibrary(dep, ctx) {
       const rel = sanitizeDocPath(lockedPath);
       if (rel === null) continue;
       removedFiles++;
-      if (!ctx.dryRun) await rm2(join37(versionPath, rel), { force: true });
+      if (!ctx.dryRun) await rm2(join38(versionPath, rel), { force: true });
     }
   }
   let removedVersionDirs = 0;
@@ -35611,13 +35840,13 @@ async function syncOneLibrary(dep, ctx) {
     }
     removedVersionDirs++;
     if (!ctx.dryRun) {
-      await rm2(join37(libPath, entry.name), { recursive: true, force: true });
+      await rm2(join38(libPath, entry.name), { recursive: true, force: true });
     }
   }
   if (!ctx.dryRun) {
     await mkdir12(libPath, { recursive: true });
-    await writeFile20(
-      join37(libPath, "INDEX.md"),
+    await writeFile21(
+      join38(libPath, "INDEX.md"),
       buildLibIndex(dep.name, manifest),
       "utf-8"
     );
@@ -35671,7 +35900,7 @@ async function runDocsSync() {
   );
   if (!dryRun) {
     await mkdir12(absDir, { recursive: true });
-    await writeFile20(join37(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
+    await writeFile21(join38(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
     const libraries = {};
     for (const o of outcomes) {
       if (o.kind === "synced" || o.kind === "unchanged") {
@@ -35696,8 +35925,8 @@ async function runDocsSync() {
       generated_at: (/* @__PURE__ */ new Date()).toISOString(),
       libraries: sortedLibraries
     };
-    await writeFile20(
-      join37(absDir, LOCK_FILE),
+    await writeFile21(
+      join38(absDir, LOCK_FILE),
       JSON.stringify(newLock, null, 2) + "\n",
       "utf-8"
     );
@@ -35739,7 +35968,7 @@ async function countFilesRecursively(dirPath) {
   let count = 0;
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      count += await countFilesRecursively(join37(dirPath, entry.name));
+      count += await countFilesRecursively(join38(dirPath, entry.name));
     } else if (entry.isFile()) {
       count++;
     }
@@ -35756,7 +35985,7 @@ async function runDocsStatus() {
 `);
   let raw;
   try {
-    raw = await readFile26(join37(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile27(join38(absDir, LOCK_FILE), "utf-8");
   } catch {
     console.log(
       `  No ${LOCK_FILE} found \u2014 run \`codebyplan docs sync\` first.
@@ -35785,7 +36014,7 @@ async function runDocsStatus() {
   let outOfSync = 0;
   for (const name of names) {
     const entry = lock.libraries[name];
-    const versionPath = join37(absDir, libDirName(name), entry.resolved_version);
+    const versionPath = join38(absDir, libDirName(name), entry.resolved_version);
     const expected = Object.keys(entry.files).length;
     if (!existsSync13(versionPath)) {
       outOfSync++;
@@ -35873,7 +36102,7 @@ var init_docs = __esm({
 
 // src/lib/check-baseline.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 function emptyBaseline() {
   return {
     lint: { known_failing: [] },
@@ -35883,7 +36112,7 @@ function emptyBaseline() {
   };
 }
 function loadBaseline(projectRoot) {
-  const filePath = join38(projectRoot, BASELINE_FILENAME);
+  const filePath = join39(projectRoot, BASELINE_FILENAME);
   try {
     const raw = readFileSync12(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -35907,7 +36136,7 @@ function loadBaseline(projectRoot) {
   }
 }
 function saveBaseline(projectRoot, baseline) {
-  const filePath = join38(projectRoot, BASELINE_FILENAME);
+  const filePath = join39(projectRoot, BASELINE_FILENAME);
   writeFileSync7(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
 }
 function diffBaseline(check, currentFailingPackages, baseline) {
@@ -35957,8 +36186,8 @@ var init_check_baseline = __esm({
 
 // src/lib/check.ts
 import { readFileSync as readFileSync13, existsSync as existsSync14 } from "node:fs";
-import { join as join39 } from "node:path";
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { join as join40 } from "node:path";
+import { spawnSync as spawnSync11 } from "node:child_process";
 function hasSentinelValue(arrays) {
   const SENTINELS = /* @__PURE__ */ new Set([
     SUMMARY_UNREADABLE,
@@ -35973,7 +36202,7 @@ function resolveNewFailures(check, failingPackages, baseline, updateBaseline, no
   return diffBaseline(check, failingPackages, baseline);
 }
 function defaultSpawnFn(command, opts) {
-  const result = spawnSync10(command, {
+  const result = spawnSync11(command, {
     shell: true,
     cwd: opts.cwd,
     encoding: "utf-8",
@@ -36025,9 +36254,9 @@ function parseFailingPackagesFromSummary(summaryPath) {
   return Array.from(failing).sort();
 }
 function resolveTurboBin(projectRoot) {
-  const localBin = join39(projectRoot, "node_modules", ".bin", "turbo");
+  const localBin = join40(projectRoot, "node_modules", ".bin", "turbo");
   if (existsSync14(localBin)) return localBin;
-  const workspaceRootBin = join39(
+  const workspaceRootBin = join40(
     projectRoot,
     "..",
     "..",
@@ -36524,7 +36753,7 @@ var init_check2 = __esm({
 
 // src/lib/claude-plan.ts
 import * as fs13 from "node:fs";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 function buildDriftPlan(projectDir, templatesDir, manifest) {
   const packaged = walkTemplates(templatesDir);
   const packagedBySrc = new Map(packaged.map((f) => [f.src, f]));
@@ -36538,8 +36767,8 @@ function buildDriftPlan(projectDir, templatesDir, manifest) {
   };
   for (const pkg of packaged) {
     const inManifest = manifestBySrc.get(pkg.src);
-    const absDest = path13.join(projectDir, ".claude", pkg.dest);
-    const absSrc = path13.join(templatesDir, pkg.src);
+    const absDest = path14.join(projectDir, ".claude", pkg.dest);
+    const absSrc = path14.join(templatesDir, pkg.src);
     if (!inManifest) {
       plan.newOptIn.push({
         packaged: { src: pkg.src, dest: pkg.dest, hash: pkg.hash },
@@ -36588,7 +36817,7 @@ __export(status_exports, {
   runStatus: () => runStatus2
 });
 import * as fs14 from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import { execSync as execSync9 } from "node:child_process";
 function makeFailSafe(checked_at) {
   return {
@@ -36601,6 +36830,8 @@ function makeFailSafe(checked_at) {
     new_in_package: [],
     removed_from_package: [],
     settings_drift: false,
+    settings_missing: false,
+    settings_ignored: false,
     guarded: true,
     guard_reason: "unknown",
     in_sync: true,
@@ -36666,6 +36897,8 @@ async function runStatus2(argv) {
         new_in_package: [],
         removed_from_package: [],
         settings_drift: false,
+        settings_missing: false,
+        settings_ignored: false,
         guarded: true,
         // guarded:true must always pair with a non-null reason. canonical_source
         // keeps its reason; the bare no-manifest case (never-installed consumer)
@@ -36693,12 +36926,12 @@ async function runStatus2(argv) {
     const latest = fetchLatestVersion();
     const newer = latest !== null && compareSemver(latest, installed) > 0;
     let settings_drift = false;
-    const settingsPath = path14.join(projectDir, ".claude", "settings.json");
-    const baseSettingsPath = path14.join(
+    const settingsPath = path15.join(projectDir, ".claude", "settings.json");
+    const baseSettingsPath = path15.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const hooksJsonPath = path14.join(templatesDir, "hooks", "hooks.json");
+    const hooksJsonPath = path15.join(templatesDir, "hooks", "hooks.json");
     if (fs14.existsSync(settingsPath)) {
       try {
         const settingsRaw = fs14.readFileSync(settingsPath, "utf8");
@@ -36722,6 +36955,8 @@ async function runStatus2(argv) {
         settings_drift = false;
       }
     }
+    const settings_missing = !fs14.existsSync(settingsPath);
+    const settings_ignored = detectSettingsIgnored(projectDir).status === "ignored";
     const in_sync = !version_skip && drifted_files.length === 0 && new_in_package.length === 0 && removed_from_package.length === 0 && !settings_drift;
     let action = null;
     if (guardReason !== "protected_branch") {
@@ -36737,6 +36972,8 @@ async function runStatus2(argv) {
       new_in_package,
       removed_from_package,
       settings_drift,
+      settings_missing,
+      settings_ignored,
       // Always false in the full-detection path: a protected_branch consumer
       // (the only guarded case that reaches here) must still SEE the segment;
       // only canonical_source / no-manifest (Branch A) report guarded:true.
@@ -36764,10 +37001,10 @@ function emitResult(result, writeCache, quiet, projectDir) {
   const json = JSON.stringify(result, null, 2);
   if (writeCache) {
     try {
-      const cacheDir = path14.join(projectDir, ".codebyplan");
+      const cacheDir = path15.join(projectDir, ".codebyplan");
       fs14.mkdirSync(cacheDir, { recursive: true });
       fs14.writeFileSync(
-        path14.join(cacheDir, "claude-status.local.json"),
+        path15.join(cacheDir, "claude-status.local.json"),
         json + "\n",
         "utf8"
       );
@@ -36789,6 +37026,7 @@ var init_status = __esm({
     init_claude_plan();
     init_settings_merge();
     init_version_status();
+    init_gitignore_detect();
   }
 });
 
@@ -36910,7 +37148,7 @@ __export(update_exports, {
 });
 import * as fs15 from "node:fs";
 import * as os3 from "node:os";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 async function runUpdate(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -36946,9 +37184,9 @@ async function runUpdate(opts, deps = {}) {
       finalManifestEntries.push(e);
     }
     for (const { packaged, absSrc } of plan.overwriteSafe) {
-      const absDest = path15.join(projectDir, ".claude", packaged.dest);
+      const absDest = path16.join(projectDir, ".claude", packaged.dest);
       if (!opts.dryRun) {
-        fs15.mkdirSync(path15.dirname(absDest), { recursive: true });
+        fs15.mkdirSync(path16.dirname(absDest), { recursive: true });
         fs15.copyFileSync(absSrc, absDest);
         if (opts.verbose) console.log(`updated ${packaged.dest}`);
       } else if (opts.verbose) {
@@ -36961,7 +37199,7 @@ async function runUpdate(opts, deps = {}) {
       absSrc,
       onDiskContent
     } of plan.overwriteHandEdited) {
-      const absDest = path15.join(projectDir, ".claude", packaged.dest);
+      const absDest = path16.join(projectDir, ".claude", packaged.dest);
       const newContent = fs15.readFileSync(absSrc);
       const showDiff = () => {
         console.log(
@@ -36974,7 +37212,7 @@ async function runUpdate(opts, deps = {}) {
       const answer = await promptOverwrite(packaged.dest, opts, showDiff);
       if (answer === "overwrite") {
         if (!opts.dryRun) {
-          fs15.mkdirSync(path15.dirname(absDest), { recursive: true });
+          fs15.mkdirSync(path16.dirname(absDest), { recursive: true });
           fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
@@ -36990,9 +37228,9 @@ async function runUpdate(opts, deps = {}) {
     for (const { packaged, absSrc } of plan.newOptIn) {
       const answer = await promptOptIn(packaged.dest, opts);
       if (answer === "opt-in") {
-        const absDest = path15.join(projectDir, ".claude", packaged.dest);
+        const absDest = path16.join(projectDir, ".claude", packaged.dest);
         if (!opts.dryRun) {
-          fs15.mkdirSync(path15.dirname(absDest), { recursive: true });
+          fs15.mkdirSync(path16.dirname(absDest), { recursive: true });
           fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
@@ -37004,25 +37242,25 @@ async function runUpdate(opts, deps = {}) {
     for (const e of plan.removedFromPackage) {
       const answer = await promptRemove(e.dest, opts);
       if (answer === "remove") {
-        const absDest = path15.join(projectDir, ".claude", e.dest);
+        const absDest = path16.join(projectDir, ".claude", e.dest);
         if (!opts.dryRun && fs15.existsSync(absDest)) {
           fs15.rmSync(absDest);
-          const claudeDir = path15.join(projectDir, ".claude");
-          let cur = path15.dirname(absDest);
-          while (cur !== claudeDir && cur !== path15.dirname(cur)) {
-            if (path15.dirname(cur) === claudeDir) break;
+          const claudeDir = path16.join(projectDir, ".claude");
+          let cur = path16.dirname(absDest);
+          while (cur !== claudeDir && cur !== path16.dirname(cur)) {
+            if (path16.dirname(cur) === claudeDir) break;
             try {
               fs15.rmdirSync(cur);
               if (opts.verbose)
                 console.log(
-                  `pruned empty dir ${path15.relative(claudeDir, cur)}`
+                  `pruned empty dir ${path16.relative(claudeDir, cur)}`
                 );
-              cur = path15.dirname(cur);
+              cur = path16.dirname(cur);
             } catch (err) {
               const code = err.code;
               if (code !== "ENOTEMPTY" && code !== "ENOENT") {
                 console.warn(
-                  `codebyplan claude: could not prune empty dir ${path15.relative(claudeDir, cur)}: ${err.message}`
+                  `codebyplan claude: could not prune empty dir ${path16.relative(claudeDir, cur)}: ${err.message}`
                 );
               }
               break;
@@ -37034,12 +37272,12 @@ async function runUpdate(opts, deps = {}) {
         if (opts.verbose) console.log(`kept (untracked) ${e.dest}`);
       }
     }
-    const hooksJsonPath = path15.join(templatesDir, "hooks", "hooks.json");
-    const baseSettingsPath = path15.join(
+    const hooksJsonPath = path16.join(templatesDir, "hooks", "hooks.json");
+    const baseSettingsPath = path16.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const settingsPath = path15.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path16.join(projectDir, ".claude", "settings.json");
     const existingSettings = fs15.existsSync(settingsPath) ? JSON.parse(fs15.readFileSync(settingsPath, "utf8")) : {};
     if (fs15.existsSync(baseSettingsPath)) {
       const base = JSON.parse(
@@ -37060,21 +37298,29 @@ async function runUpdate(opts, deps = {}) {
         ) : void 0
       );
     }
+    await detectAndHealSettingsGitignore(
+      projectDir,
+      { yes: opts.yes, dryRun: opts.dryRun },
+      deps.detectHealDeps
+    );
     if (!opts.dryRun) {
-      fs15.mkdirSync(path15.dirname(settingsPath), { recursive: true });
+      fs15.mkdirSync(path16.dirname(settingsPath), { recursive: true });
       fs15.writeFileSync(
         settingsPath,
         JSON.stringify(existingSettings, null, 2) + "\n",
         "utf8"
       );
     }
+    if (!opts.dryRun) {
+      warnIfSettingsUntracked(projectDir, deps.lsFilesDep);
+    }
     const gitignoreAction = await ensureManagedGitignoreBlock(
       projectDir,
       opts.dryRun
     );
     if (opts.verbose && gitignoreAction !== "unchanged") {
       console.log(
-        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path15.relative(projectDir, path15.join(projectDir, ".gitignore"))}`
+        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path16.relative(projectDir, path16.join(projectDir, ".gitignore"))}`
       );
     }
     if (!opts.dryRun) {
@@ -37114,9 +37360,9 @@ function runUpdateUser(opts, deps) {
     return;
   }
   try {
-    const userDir = deps.userDir ?? path15.join(os3.homedir(), ".claude");
-    const settingsPath = path15.join(userDir, "settings.json");
-    const userBaseSettingsPath = path15.join(
+    const userDir = deps.userDir ?? path16.join(os3.homedir(), ".claude");
+    const settingsPath = path16.join(userDir, "settings.json");
+    const userBaseSettingsPath = path16.join(
       templatesDir,
       "settings.user.base.json"
     );
@@ -37169,6 +37415,7 @@ var init_update = __esm({
   "src/cli/claude/update.ts"() {
     "use strict";
     init_gitignore_block();
+    init_gitignore_detect();
     init_templates_dir();
     init_manifest();
     init_settings_merge();
@@ -37187,7 +37434,7 @@ __export(uninstall_exports, {
 });
 import * as fs16 from "node:fs";
 import * as os4 from "node:os";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 async function runUninstall(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -37216,7 +37463,7 @@ async function runUninstall(opts, deps = {}) {
     let removed = 0;
     let warnings = 0;
     for (const entry of manifest.files) {
-      const abs = path16.join(projectDir, ".claude", entry.dest);
+      const abs = path17.join(projectDir, ".claude", entry.dest);
       if (!fs16.existsSync(abs)) {
         console.warn(
           `codebyplan claude uninstall: ${entry.dest} already absent (skipping).`
@@ -37240,12 +37487,12 @@ async function runUninstall(opts, deps = {}) {
     if (!opts.dryRun) {
       pruneEmptyManagedDirs(projectDir);
     }
-    const settingsPath = path16.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path17.join(projectDir, ".claude", "settings.json");
     if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
         fs16.readFileSync(settingsPath, "utf8")
       );
-      const baseSettingsPath = templatesDir ? path16.join(templatesDir, "settings.project.base.json") : null;
+      const baseSettingsPath = templatesDir ? path17.join(templatesDir, "settings.project.base.json") : null;
       if (baseSettingsPath && fs16.existsSync(baseSettingsPath)) {
         const base = JSON.parse(
           fs16.readFileSync(baseSettingsPath, "utf8")
@@ -37303,7 +37550,7 @@ function runUninstallUser(opts, deps) {
     }
   }
   try {
-    const userDir = deps.userDir ?? path16.join(os4.homedir(), ".claude");
+    const userDir = deps.userDir ?? path17.join(os4.homedir(), ".claude");
     const existingManifest = readManifestForScope("user", userDir);
     if (!existingManifest) {
       console.error(
@@ -37312,12 +37559,12 @@ function runUninstallUser(opts, deps) {
       process.exitCode = 1;
       return;
     }
-    const settingsPath = path16.join(userDir, "settings.json");
+    const settingsPath = path17.join(userDir, "settings.json");
     if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
         fs16.readFileSync(settingsPath, "utf8")
       );
-      const userBaseSettingsPath = templatesDir != null ? path16.join(templatesDir, "settings.user.base.json") : null;
+      const userBaseSettingsPath = templatesDir != null ? path17.join(templatesDir, "settings.user.base.json") : null;
       if (userBaseSettingsPath && fs16.existsSync(userBaseSettingsPath)) {
         const userBase = JSON.parse(
           fs16.readFileSync(userBaseSettingsPath, "utf8")
@@ -37358,7 +37605,7 @@ function runUninstallUser(opts, deps) {
 function pruneEmptyManagedDirs(projectDir) {
   const managedRoots = ["skills", "agents", "hooks", "rules"];
   for (const root of managedRoots) {
-    const abs = path16.join(projectDir, ".claude", root);
+    const abs = path17.join(projectDir, ".claude", root);
     if (!fs16.existsSync(abs)) continue;
     pruneLeafFirst(abs);
   }
@@ -37369,7 +37616,7 @@ function pruneLeafFirst(dir) {
   if (!stat3.isDirectory()) return;
   for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      pruneLeafFirst(path16.join(dir, entry.name));
+      pruneLeafFirst(path17.join(dir, entry.name));
     }
   }
   const remaining = fs16.readdirSync(dir);
@@ -37390,7 +37637,7 @@ var init_uninstall = __esm({
 
 // src/lib/verify-parity.ts
 import * as fs17 from "node:fs";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 function isValidScope(s) {
   return s === "org-shared" || s === "project-shared" || REPO_ONLY_RE.test(s);
 }
@@ -37407,25 +37654,25 @@ function checkSiblingParity(opts) {
     expectedOneSided = DEFAULT_EXPECTED_ONE_SIDED,
     ignoredSubtrees
   } = opts;
-  const defaultIgnored = [path17.join(claudeDir, "hooks", "__test-fixtures__")];
+  const defaultIgnored = [path18.join(claudeDir, "hooks", "__test-fixtures__")];
   const ignored = ignoredSubtrees ?? defaultIgnored;
   const violations = [];
   const claudeSideRels = /* @__PURE__ */ new Set();
   for (const scanDir of SCAN_DIRS) {
-    const baseDir = path17.join(claudeDir, scanDir);
+    const baseDir = path18.join(claudeDir, scanDir);
     if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path17.join(baseDir, entry);
+      const absPath = path18.join(baseDir, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (ignored.some(
-        (ig) => absPath.startsWith(ig + path17.sep) || absPath === ig
+        (ig) => absPath.startsWith(ig + path18.sep) || absPath === ig
       )) {
         continue;
       }
-      const relPath = path17.join(scanDir, entry).split(path17.sep).join("/");
+      const relPath = path18.join(scanDir, entry).split(path18.sep).join("/");
       claudeSideRels.add(relPath);
-      const templatePath = path17.join(templatesDir, relPath);
+      const templatePath = path18.join(templatesDir, relPath);
       if (!fs17.existsSync(templatePath)) {
         if (!expectedOneSided.has(relPath) && !isScaffoldFile(entry)) {
           violations.push({ type: "missing-twin", path: relPath });
@@ -37440,14 +37687,14 @@ function checkSiblingParity(opts) {
     }
   }
   for (const scanDir of SCAN_DIRS) {
-    const tplBase = path17.join(templatesDir, scanDir);
+    const tplBase = path18.join(templatesDir, scanDir);
     if (!fs17.existsSync(tplBase)) continue;
     const entries = readdirRecursive(tplBase);
     for (const entry of entries) {
-      const absPath = path17.join(tplBase, entry);
+      const absPath = path18.join(tplBase, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (isScaffoldFile(entry)) continue;
-      const relPath = path17.join(scanDir, entry).split(path17.sep).join("/");
+      const relPath = path18.join(scanDir, entry).split(path18.sep).join("/");
       if (!claudeSideRels.has(relPath) && !expectedOneSided.has(relPath)) {
         violations.push({ type: "extra-twin", path: relPath });
       }
@@ -37483,18 +37730,18 @@ function checkScopeMarkers(opts) {
   const twinDetectionActive = templatesDir != null && fs17.existsSync(templatesDir);
   const violations = [];
   for (const scanDir of scanDirs) {
-    const baseDir = path17.join(claudeDir, scanDir);
+    const baseDir = path18.join(claudeDir, scanDir);
     if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path17.join(baseDir, entry);
+      const absPath = path18.join(baseDir, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (!isStructuralEntry(scanDir, entry)) continue;
-      const ext = path17.extname(entry).toLowerCase();
+      const ext = path18.extname(entry).toLowerCase();
       const isMd = ext === ".md";
       const isSh = ext === ".sh";
       if (!isMd && !isSh) continue;
-      const relPath = path17.join(scanDir, entry).split(path17.sep).join("/");
+      const relPath = path18.join(scanDir, entry).split(path18.sep).join("/");
       if (allowlist.has(relPath)) continue;
       let content;
       try {
@@ -37508,7 +37755,7 @@ function checkScopeMarkers(opts) {
         continue;
       }
       const scopeValue = isMd ? extractFrontmatterScope(content) : extractShScope(content);
-      const managed = twinDetectionActive && fs17.existsSync(path17.join(templatesDir, relPath));
+      const managed = twinDetectionActive && fs17.existsSync(path18.join(templatesDir, relPath));
       if (managed) {
         if (scopeValue === null) {
         } else if (scopeValue === "org-shared") {
@@ -37562,7 +37809,7 @@ function readdirRecursive(dir, rel = "", visited = /* @__PURE__ */ new Set()) {
   visited.add(realDir);
   const results = [];
   for (const name of fs17.readdirSync(dir)) {
-    const full = path17.join(dir, name);
+    const full = path18.join(dir, name);
     const relName = rel ? `${rel}/${name}` : name;
     if (fs17.lstatSync(full).isDirectory()) {
       results.push(...readdirRecursive(full, relName, visited));
@@ -37635,12 +37882,12 @@ __export(verify_parity_exports, {
   verifyParity: () => verifyParity
 });
 import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 function verifyParity(args, deps = {}) {
   const warnOnly = args.includes("--warn-only");
   const jsonMode = args.includes("--json");
   const projectDir = deps.cwd ?? process.cwd();
-  const claudeDir = path18.join(projectDir, ".claude");
+  const claudeDir = path19.join(projectDir, ".claude");
   if (!fs18.existsSync(claudeDir)) {
     const msg = "codebyplan claude verify-parity: .claude/ not found in cwd \u2014 run from the project root.\n";
     process.stderr.write(msg);
@@ -38147,11 +38394,11 @@ var generate_exports = {};
 __export(generate_exports, {
   runGenerate: () => runGenerate
 });
-import { readFile as readFile27, mkdir as mkdir13, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join46, resolve as resolve11 } from "node:path";
+import { readFile as readFile28, mkdir as mkdir13, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join47, resolve as resolve11 } from "node:path";
 async function readJsonFile4(filePath) {
   try {
-    const raw = await readFile27(filePath, "utf-8");
+    const raw = await readFile28(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -38159,7 +38406,7 @@ async function readJsonFile4(filePath) {
 }
 async function readPkgName(absPath) {
   try {
-    const raw = await readFile27(join46(absPath, "package.json"), "utf-8");
+    const raw = await readFile28(join47(absPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
@@ -38173,7 +38420,7 @@ async function runGenerate(opts) {
   const rootDir = resolve11(projectDir);
   let packageManager;
   try {
-    const raw = await readFile27(join46(rootDir, "package.json"), "utf-8");
+    const raw = await readFile28(join47(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.packageManager === "string") {
       packageManager = pkg.packageManager;
@@ -38181,7 +38428,7 @@ async function runGenerate(opts) {
   } catch {
   }
   const serverJson = await readJsonFile4(
-    join46(rootDir, ".codebyplan", "server.json")
+    join47(rootDir, ".codebyplan", "server.json")
   );
   const ports = [];
   for (const alloc of serverJson?.port_allocations ?? []) {
@@ -38194,7 +38441,7 @@ async function runGenerate(opts) {
     }
   }
   const gitJson = await readJsonFile4(
-    join46(rootDir, ".codebyplan", "git.json")
+    join47(rootDir, ".codebyplan", "git.json")
   );
   const branchModel = gitJson?.branch_config?.production ? {
     production: gitJson.branch_config.production,
@@ -38203,7 +38450,7 @@ async function runGenerate(opts) {
     )
   } : void 0;
   const shipmentJson = await readJsonFile4(
-    join46(rootDir, ".codebyplan", "shipment.json")
+    join47(rootDir, ".codebyplan", "shipment.json")
   );
   const shipmentSurfaces = [];
   const rawSurfaces = shipmentJson?.shipment?.surfaces ?? shipmentJson?.surfaces ?? {};
@@ -38274,10 +38521,10 @@ async function runGenerate(opts) {
   const structureMdContent = generateStructureMd(config);
   const agentsContent = generateAgentsMd(structureMdContent);
   if (check) {
-    const agentsMdPath2 = join46(rootDir, "AGENTS.md");
+    const agentsMdPath2 = join47(rootDir, "AGENTS.md");
     let existingAgents = null;
     try {
-      existingAgents = await readFile27(agentsMdPath2, "utf-8");
+      existingAgents = await readFile28(agentsMdPath2, "utf-8");
     } catch {
       existingAgents = null;
     }
@@ -38313,16 +38560,16 @@ async function runGenerate(opts) {
     process.stdout.write(agentsContent);
     return;
   }
-  const outputDir = join46(rootDir, ".claude", "generated");
+  const outputDir = join47(rootDir, ".claude", "generated");
   await mkdir13(outputDir, { recursive: true });
-  const outputPath = join46(outputDir, "structure.md");
-  await writeFile21(outputPath, structureMdContent, "utf-8");
+  const outputPath = join47(outputDir, "structure.md");
+  await writeFile22(outputPath, structureMdContent, "utf-8");
   process.stdout.write(`Wrote: .claude/generated/structure.md
 `);
-  const agentsMdPath = join46(rootDir, "AGENTS.md");
+  const agentsMdPath = join47(rootDir, "AGENTS.md");
   let existingAgentsContent = null;
   try {
-    existingAgentsContent = await readFile27(agentsMdPath, "utf-8");
+    existingAgentsContent = await readFile28(agentsMdPath, "utf-8");
   } catch {
     existingAgentsContent = null;
   }
@@ -38330,7 +38577,7 @@ async function runGenerate(opts) {
     process.stdout.write(`Up to date: AGENTS.md
 `);
   } else {
-    await writeFile21(agentsMdPath, agentsContent, "utf-8");
+    await writeFile22(agentsMdPath, agentsContent, "utf-8");
     process.stdout.write(`Wrote: AGENTS.md
 `);
   }
@@ -38350,11 +38597,11 @@ __export(readme_exports, {
   runReadme: () => runReadme,
   runReadmeCommand: () => runReadmeCommand
 });
-import { readFile as readFile28, writeFile as writeFile22 } from "node:fs/promises";
-import { join as join47, resolve as resolve12, relative as relative9 } from "node:path";
+import { readFile as readFile29, writeFile as writeFile23 } from "node:fs/promises";
+import { join as join48, resolve as resolve12, relative as relative9 } from "node:path";
 async function readJsonFile5(filePath) {
   try {
-    const raw = await readFile28(filePath, "utf-8");
+    const raw = await readFile29(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -38423,7 +38670,7 @@ async function discoverUnits(rootDir, rootPkgJson) {
   const discovered = await discoverMonorepoApps(rootDir);
   for (const app of discovered) {
     const pkgJson = await readJsonFile5(
-      join47(app.absPath, "package.json")
+      join48(app.absPath, "package.json")
     );
     pkgJsonByPath.set(app.absPath, pkgJson);
     allPackages.push({
@@ -38449,7 +38696,7 @@ async function runReadme(opts) {
   const init = opts.init ?? opts["init"] ?? false;
   const rootDir = resolve12(projectDir);
   const rootPkgJson = await readJsonFile5(
-    join47(rootDir, "package.json")
+    join48(rootDir, "package.json")
   );
   const { units, allPackages, pkgJsonByPath } = await discoverUnits(
     rootDir,
@@ -38458,11 +38705,11 @@ async function runReadme(opts) {
   const driftUnits = [];
   const missingUnits = [];
   for (const unit of units) {
-    const readmePath = join47(unit.absPath, "README.md");
-    const relPath = unit.isRoot ? "README.md" : join47(relative9(rootDir, unit.absPath), "README.md");
+    const readmePath = join48(unit.absPath, "README.md");
+    const relPath = unit.isRoot ? "README.md" : join48(relative9(rootDir, unit.absPath), "README.md");
     let existingContent = null;
     try {
-      existingContent = await readFile28(readmePath, "utf-8");
+      existingContent = await readFile29(readmePath, "utf-8");
     } catch {
       existingContent = null;
     }
@@ -38497,7 +38744,7 @@ ${newContent}
 `
         );
       } else {
-        await writeFile22(readmePath, newContent, "utf-8");
+        await writeFile23(readmePath, newContent, "utf-8");
         process.stdout.write(`Wrote (scaffold): ${relPath}
 `);
       }
@@ -38535,7 +38782,7 @@ ${newContent}
 `
         );
       } else {
-        await writeFile22(readmePath, newContent, "utf-8");
+        await writeFile23(readmePath, newContent, "utf-8");
         process.stdout.write(`Wrote (refresh): ${relPath}
 `);
       }
@@ -38554,7 +38801,7 @@ ${newContent}
 `
           );
         } else {
-          await writeFile22(readmePath, newContent, "utf-8");
+          await writeFile23(readmePath, newContent, "utf-8");
           process.stdout.write(`Wrote (init): ${relPath}
 `);
         }
@@ -38642,15 +38889,15 @@ __export(migrate_memory_exports, {
   runMigrateMemory: () => runMigrateMemory
 });
 import {
-  readFile as readFile29,
-  writeFile as writeFile23,
+  readFile as readFile30,
+  writeFile as writeFile24,
   mkdir as mkdir14,
   unlink as unlink6,
   rmdir,
   readdir as readdir7
 } from "node:fs/promises";
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join48, resolve as resolve13, dirname as dirname15, sep as sep4 } from "node:path";
+import { join as join49, resolve as resolve13, dirname as dirname15, sep as sep4 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function encodeProjectPath(absPath) {
   return resolve13(absPath).replace(/[/\\]/g, "-");
@@ -38661,7 +38908,7 @@ function resolveAutoMemoryDir(opts) {
   }
   const projectDir = opts.projectDir ?? process.cwd();
   const encoded = encodeProjectPath(projectDir);
-  return join48(homedir8(), ".claude", "projects", encoded, "memory");
+  return join49(homedir8(), ".claude", "projects", encoded, "memory");
 }
 function parseFrontmatter(content) {
   content = content.replace(/\r\n/g, "\n");
@@ -38727,10 +38974,10 @@ async function inventoryFiles(dir) {
   }
   const results = [];
   for (const filename of filenames) {
-    const sourcePath = join48(dir, filename);
+    const sourcePath = join49(dir, filename);
     let raw;
     try {
-      raw = await readFile29(sourcePath, "utf-8");
+      raw = await readFile30(sourcePath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       results.push({
@@ -38816,8 +39063,8 @@ async function applyPlan(plan, opts) {
     if (entry.suggested_action !== "keep") continue;
     if (!entry.suggested_target?.startsWith("nested:")) continue;
     const relPath = entry.suggested_target.slice("nested:".length);
-    const targetDir = resolve13(join48(projectDir, relPath));
-    const targetFile = join48(targetDir, "CLAUDE.md");
+    const targetDir = resolve13(join49(projectDir, relPath));
+    const targetFile = join49(targetDir, "CLAUDE.md");
     if (!targetDir.startsWith(resolve13(projectDir) + sep4)) {
       process.stderr.write(
         `migrate-memory: skipping unsafe suggested_target "${entry.suggested_target}" \u2014 resolves outside projectDir
@@ -38849,11 +39096,11 @@ ${anchor}
     await mkdir14(targetDir, { recursive: true });
     let existing = "";
     try {
-      existing = await readFile29(targetFile, "utf-8");
+      existing = await readFile30(targetFile, "utf-8");
     } catch {
     }
     if (!existing.includes(anchor)) {
-      await writeFile23(targetFile, existing + appendContent, "utf-8");
+      await writeFile24(targetFile, existing + appendContent, "utf-8");
     }
     if (resolve13(entry.source_path).startsWith(resolve13(plan.auto_memory_dir) + sep4)) {
       try {
@@ -38867,7 +39114,7 @@ ${anchor}
       );
     }
   }
-  const rootClaudeMd = join48(projectDir, ".claude", "CLAUDE.md");
+  const rootClaudeMd = join49(projectDir, ".claude", "CLAUDE.md");
   if (dryRun) {
     process.stdout.write(
       `[dry-run] Would ensure ${rootClaudeMd} contains: ${IMPORT_LINE}
@@ -38876,12 +39123,12 @@ ${anchor}
   } else {
     let claudeMdContent = "";
     try {
-      claudeMdContent = await readFile29(rootClaudeMd, "utf-8");
+      claudeMdContent = await readFile30(rootClaudeMd, "utf-8");
     } catch {
       await mkdir14(dirname15(rootClaudeMd), { recursive: true });
     }
     if (!claudeMdContent.includes(IMPORT_LINE)) {
-      await writeFile23(
+      await writeFile24(
         rootClaudeMd,
         claudeMdContent + `
 ${IMPORT_LINE}
@@ -38911,8 +39158,8 @@ ${IMPORT_LINE}
     } catch {
     }
   }
-  const memoryMd = join48(plan.auto_memory_dir, "MEMORY.md");
-  const safeRmdirBase = join48(homedir8(), ".claude", "projects");
+  const memoryMd = join49(plan.auto_memory_dir, "MEMORY.md");
+  const safeRmdirBase = join49(homedir8(), ".claude", "projects");
   if (dryRun) {
     process.stdout.write(`[dry-run] Would delete MEMORY.md: ${memoryMd}
 `);
@@ -38965,7 +39212,7 @@ async function runMigrateMemory(opts) {
   if (applyFile) {
     let planJson;
     try {
-      planJson = await readFile29(resolve13(applyFile), "utf-8");
+      planJson = await readFile30(resolve13(applyFile), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(
@@ -39036,7 +39283,7 @@ var init_migrate_memory = __esm({
 
 // src/lib/claude-mode-audit.ts
 import { readdirSync as readdirSync7, readFileSync as readFileSync19, existsSync as existsSync22 } from "node:fs";
-import { join as join49, basename as basename2 } from "node:path";
+import { join as join50, basename as basename2 } from "node:path";
 function parseFrontmatter2(content) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
   if (!match) return {};
@@ -39113,19 +39360,19 @@ function auditSkill(filePath) {
 }
 function auditMode(templatesDir) {
   const entries = [];
-  const agentsDir = join49(templatesDir, "agents");
+  const agentsDir = join50(templatesDir, "agents");
   if (existsSync22(agentsDir)) {
     const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md")).sort();
     for (const f of agentFiles) {
-      entries.push(auditAgent(join49(agentsDir, f)));
+      entries.push(auditAgent(join50(agentsDir, f)));
     }
   }
-  const skillsDir = join49(templatesDir, "skills");
+  const skillsDir = join50(templatesDir, "skills");
   if (existsSync22(skillsDir)) {
     const skillDirs = readdirSync7(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
     for (const dir of skillDirs) {
-      if (existsSync22(join49(skillsDir, dir, "PROVENANCE.md"))) continue;
-      const skillMd = join49(skillsDir, dir, "SKILL.md");
+      if (existsSync22(join50(skillsDir, dir, "PROVENANCE.md"))) continue;
+      const skillMd = join50(skillsDir, dir, "SKILL.md");
       if (existsSync22(skillMd)) {
         entries.push(auditSkill(skillMd));
       }
@@ -39230,9 +39477,9 @@ var resolve_preview_exports = {};
 __export(resolve_preview_exports, {
   resolvePreview: () => resolvePreview
 });
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 function defaultGetCurrentBranch(cwd) {
-  const result = spawnSync11("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const result = spawnSync12("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -39384,7 +39631,7 @@ __export(new_migration_exports, {
   newMigration: () => newMigration
 });
 import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function slugify(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
@@ -39405,9 +39652,9 @@ function newMigration(args, deps = {}) {
   }
   const slug = slugify(rawName);
   const stamp = genTimestamp({ cwd });
-  const migrationsDir = path19.join(cwd, "supabase", "migrations");
+  const migrationsDir = path20.join(cwd, "supabase", "migrations");
   const filename = `${stamp}_${slug}.sql`;
-  const filePath = path19.join(migrationsDir, filename);
+  const filePath = path20.join(migrationsDir, filename);
   mkdirSync11(migrationsDir, { recursive: true });
   writeFileSync12(filePath, "");
   process.stdout.write(JSON.stringify({ path: filePath }) + "\n");
@@ -39425,9 +39672,9 @@ var preview_check_exports = {};
 __export(preview_check_exports, {
   previewCheck: () => previewCheck
 });
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync13 } from "node:child_process";
 function defaultRun3(cmd, args) {
-  const result = spawnSync12(cmd, args, {
+  const result = spawnSync13(cmd, args, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -39482,10 +39729,10 @@ var init_preview_check = __esm({
 });
 
 // src/lib/session.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
-import * as path20 from "node:path";
+import { spawnSync as spawnSync14 } from "node:child_process";
+import * as path21 from "node:path";
 function defaultRun4(cmd, args, cwd) {
-  const result = spawnSync13(cmd, args, {
+  const result = spawnSync14(cmd, args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -39513,7 +39760,7 @@ function homeFf(opts = {}) {
       reason: "git rev-parse --show-toplevel failed"
     };
   }
-  const folder = path20.basename(repoRoot);
+  const folder = path21.basename(repoRoot);
   let current;
   try {
     current = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd).trim();
@@ -39546,7 +39793,7 @@ function homeFf(opts = {}) {
 }
 function spawnVersionStatus(cwd) {
   try {
-    const result = spawnSync13("npx", ["codebyplan", "version-status"], {
+    const result = spawnSync14("npx", ["codebyplan", "version-status"], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -39580,7 +39827,7 @@ function defaultRunInstall(installCommand, cwd) {
   const cmd = parts[0];
   const args = parts.slice(1);
   if (!cmd) throw new Error("empty installCommand");
-  const result = spawnSync13(cmd, args, {
+  const result = spawnSync14(cmd, args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -39594,7 +39841,7 @@ function defaultRunInstall(installCommand, cwd) {
   }
 }
 function defaultRunClaudeUpdate(cwd) {
-  const result = spawnSync13("npx", ["codebyplan", "claude", "update", "--yes"], {
+  const result = spawnSync14("npx", ["codebyplan", "claude", "update", "--yes"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -39608,7 +39855,7 @@ function defaultRunClaudeUpdate(cwd) {
   }
 }
 function defaultRunGitStatus(cwd) {
-  const result = spawnSync13(
+  const result = spawnSync14(
     "git",
     ["status", "--porcelain", "--", ".claude/", ".codebyplan/"],
     {
@@ -39861,9 +40108,9 @@ var commit_exports = {};
 __export(commit_exports, {
   runCommitCommand: () => runCommitCommand
 });
-import { spawnSync as spawnSync14 } from "node:child_process";
+import { spawnSync as spawnSync15 } from "node:child_process";
 function defaultRun5(cmd, args) {
-  const result = spawnSync14(cmd, args, {
+  const result = spawnSync15(cmd, args, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -39911,7 +40158,7 @@ var init_commit = __esm({
 });
 
 // src/lib/migration-collisions.ts
-import { spawnSync as spawnSync15 } from "node:child_process";
+import { spawnSync as spawnSync16 } from "node:child_process";
 function extractPrefix(filename) {
   const base = filename.endsWith(".sql") ? filename.slice(0, -4) : filename;
   const underscoreIdx = base.indexOf("_");
@@ -39923,7 +40170,7 @@ function extractPrefix(filename) {
 }
 function makeDefaultRun(cwd) {
   return (cmd, args) => {
-    const result = spawnSync15(cmd, args, {
+    const result = spawnSync16(cmd, args, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -40080,13 +40327,13 @@ function validateWaves(waves) {
       pathOwners.set(file, owners);
     }
   }
-  for (const [path21, owners] of pathOwners) {
+  for (const [path22, owners] of pathOwners) {
     if (owners.length > 1) {
       violations.push({
         invariant: "I",
         code: "DUPLICATE_FILE",
-        message: `File "${path21}" appears in multiple waves: ${owners.join(", ")}.`,
-        detail: { path: path21, waves: owners }
+        message: `File "${path22}" appears in multiple waves: ${owners.join(", ")}.`,
+        detail: { path: path22, waves: owners }
       });
     }
   }
@@ -40180,7 +40427,7 @@ var validate_waves_exports = {};
 __export(validate_waves_exports, {
   runValidateWavesCommand: () => runValidateWavesCommand
 });
-import { readFile as readFile30 } from "node:fs/promises";
+import { readFile as readFile31 } from "node:fs/promises";
 async function readStdin() {
   return new Promise((resolve16, reject) => {
     const chunks = [];
@@ -40199,7 +40446,7 @@ async function runValidateWavesCommand(args) {
   let raw;
   if (filePath) {
     try {
-      raw = await readFile30(filePath, "utf-8");
+      raw = await readFile31(filePath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(
@@ -40279,12 +40526,12 @@ var init_validate_waves2 = __esm({
 });
 
 // src/cli/worktree/path.ts
-import { dirname as dirname16, basename as basename4, join as join51 } from "node:path";
+import { dirname as dirname16, basename as basename4, join as join52 } from "node:path";
 function computeWorktreePath(cwd, checkpointNumber) {
   const parent = dirname16(cwd);
   const base = basename4(cwd);
   const nnn = String(checkpointNumber).padStart(3, "0");
-  return join51(parent, `${base}-CHK-${nnn}`);
+  return join52(parent, `${base}-CHK-${nnn}`);
 }
 var init_path = __esm({
   "src/cli/worktree/path.ts"() {
@@ -40293,9 +40540,9 @@ var init_path = __esm({
 });
 
 // src/cli/worktree/add.ts
-import { join as join52, basename as basename5 } from "node:path";
-import { mkdir as mkdir15, readFile as readFile31, writeFile as writeFile24 } from "node:fs/promises";
-import { spawnSync as spawnSync16 } from "node:child_process";
+import { join as join53, basename as basename5 } from "node:path";
+import { mkdir as mkdir15, readFile as readFile32, writeFile as writeFile25 } from "node:fs/promises";
+import { spawnSync as spawnSync17 } from "node:child_process";
 async function defaultGetRepoId(cwd) {
   const found = await findCodebyplanConfig(cwd);
   return found?.contents.repo_id ?? null;
@@ -40324,7 +40571,7 @@ async function defaultLookupBranch(repoId, checkpointNumber) {
   return { found: true, branch_name: chk.branch_name };
 }
 function defaultGitRun(args, cwd) {
-  const result = spawnSync16("git", args, {
+  const result = spawnSync17("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -40336,34 +40583,56 @@ function defaultGitRun(args, cwd) {
     error: result.error
   };
 }
+async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
+  const readFileFn = deps.readFileFn ?? ((p) => readFile32(p, "utf-8"));
+  const writeFileFn = deps.writeFileFn ?? ((p, content) => writeFile25(p, content, "utf-8"));
+  const existsFn = deps.existsFn ?? ((p) => import("node:fs/promises").then(
+    (fsp) => fsp.access(p).then(() => true).catch(() => false)
+  ));
+  const mkdirFn = deps.mkdirFn ?? ((p, opts) => mkdir15(p, opts));
+  await mkdirFn(join53(destPath, ".claude"), { recursive: true });
+  const claudeStubs = ["settings.json", "settings.local.json"];
+  for (const stub of claudeStubs) {
+    const srcFile = join53(srcCwd, ".claude", stub);
+    const destFile = join53(destPath, ".claude", stub);
+    try {
+      const destExists = await existsFn(destFile);
+      if (destExists) continue;
+      const content = await readFileFn(srcFile);
+      await writeFileFn(destFile, content);
+    } catch {
+    }
+  }
+}
 async function defaultCopyConfigStubs(srcCwd, destPath) {
-  await mkdir15(join52(destPath, ".codebyplan"), { recursive: true });
+  await mkdir15(join53(destPath, ".codebyplan"), { recursive: true });
   const topLevelStubs = [".mcp.json", ".env.local"];
   for (const stub of topLevelStubs) {
     try {
-      const content = await readFile31(join52(srcCwd, stub), "utf-8");
-      await writeFile24(join52(destPath, stub), content, "utf-8");
+      const content = await readFile32(join53(srcCwd, stub), "utf-8");
+      await writeFile25(join53(destPath, stub), content, "utf-8");
     } catch {
     }
   }
   try {
-    const content = await readFile31(
-      join52(srcCwd, ".codebyplan", "repo.json"),
+    const content = await readFile32(
+      join53(srcCwd, ".codebyplan", "repo.json"),
       "utf-8"
     );
-    await writeFile24(
-      join52(destPath, ".codebyplan", "repo.json"),
+    await writeFile25(
+      join53(destPath, ".codebyplan", "repo.json"),
       content,
       "utf-8"
     );
   } catch {
   }
+  await copyClaudeSettings(srcCwd, destPath);
 }
-async function defaultRegisterWorktree(repoId, name, path21) {
+async function defaultRegisterWorktree(repoId, name, path22) {
   const res = await apiPost("/worktrees", {
     repo_id: repoId,
     name,
-    path: path21,
+    path: path22,
     status: "active"
   });
   return { worktree_id: res.data.id };
@@ -40461,10 +40730,12 @@ async function runWorktreeAdd(args, deps = {}) {
       );
       return 1;
     }
+    let copyStubsWarn;
     try {
       await copyConfigStubs(cwd, worktreePath);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      copyStubsWarn = `Failed to copy config stubs: ${msg}`;
       process.stderr.write(`Warning: failed to copy config stubs: ${msg}
 `);
     }
@@ -40478,7 +40749,8 @@ async function runWorktreeAdd(args, deps = {}) {
         status: "added",
         worktree_path: worktreePath,
         branch_name: branchName,
-        worktree_id
+        worktree_id,
+        ...copyStubsWarn ? { warn: copyStubsWarn } : {}
       };
       process.stdout.write(JSON.stringify(result) + "\n");
       return 0;
@@ -40513,7 +40785,7 @@ var init_add = __esm({
 });
 
 // src/cli/worktree/create.ts
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 async function defaultGetRepoIdentity(cwd) {
   const found = await findCodebyplanConfig(cwd);
   const contents = found?.contents ?? null;
@@ -40525,11 +40797,11 @@ async function defaultGetRepoIdentity(cwd) {
     project_id: typeof contents?.["project_id"] === "string" ? contents["project_id"] : void 0
   };
 }
-async function defaultRegisterWorktree2(repoId, name, path21) {
+async function defaultRegisterWorktree2(repoId, name, path22) {
   const res = await apiPost("/worktrees", {
     repo_id: repoId,
     name,
-    path: path21,
+    path: path22,
     status: "active"
   });
   return { worktree_id: res.data.id };
@@ -40558,6 +40830,7 @@ async function runWorktreeCreate(args, deps = {}) {
   const getRepoIdentity = deps.getRepoIdentity ?? defaultGetRepoIdentity;
   const getDeviceId = deps.getDeviceId ?? getOrCreateDeviceId;
   const registerWorktree = deps.registerWorktree ?? defaultRegisterWorktree2;
+  const copyClaudeSettingsFn = deps.copyClaudeSettingsFn ?? ((srcCwd, destPath) => copyClaudeSettings(srcCwd, destPath));
   const identity = await getRepoIdentity(cwd);
   const repoId = identity?.repo_id ?? null;
   if (!identity || !repoId) {
@@ -40568,7 +40841,7 @@ async function runWorktreeCreate(args, deps = {}) {
     );
     return 1;
   }
-  const worktreePath = explicitPath ?? join53(cwd, "..", name);
+  const worktreePath = explicitPath ?? join54(cwd, "..", name);
   const deviceId = await getDeviceId(cwd);
   let filesWritten = false;
   try {
@@ -40593,12 +40866,19 @@ async function runWorktreeCreate(args, deps = {}) {
     process.stdout.write(JSON.stringify(result) + "\n");
     return 0;
   }
+  let copyWarn;
+  try {
+    await copyClaudeSettingsFn(cwd, worktreePath);
+  } catch (err) {
+    copyWarn = err instanceof Error ? err.message : String(err);
+  }
   try {
     const { worktree_id } = await registerWorktree(repoId, name, worktreePath);
     const result = {
       worktree_files_written: true,
       mcp_registered: true,
-      worktree_id
+      worktree_id,
+      ...copyWarn ? { warn: `Settings copy failed (non-fatal): ${copyWarn}` } : {}
     };
     process.stdout.write(JSON.stringify(result) + "\n");
     return 0;
@@ -40620,12 +40900,13 @@ var init_create = __esm({
     init_local_config();
     init_api();
     init_worktree();
+    init_add();
   }
 });
 
 // src/cli/worktree/remove.ts
 import { basename as basename6 } from "node:path";
-import { spawnSync as spawnSync17 } from "node:child_process";
+import { spawnSync as spawnSync18 } from "node:child_process";
 async function defaultGetRepoId2(cwd) {
   const found = await findCodebyplanConfig(cwd);
   return found?.contents.repo_id ?? null;
@@ -40647,7 +40928,7 @@ async function defaultDeregisterWorktree(worktreeId) {
   await mcpCall("delete_worktree", { worktree_id: worktreeId });
 }
 function defaultGitRun2(args, cwd) {
-  const result = spawnSync17("git", args, {
+  const result = spawnSync18("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -40660,7 +40941,7 @@ function defaultGitRun2(args, cwd) {
   };
 }
 function defaultGetWorktreeBranchName(worktreePath) {
-  const result = spawnSync17("git", ["symbolic-ref", "--short", "HEAD"], {
+  const result = spawnSync18("git", ["symbolic-ref", "--short", "HEAD"], {
     cwd: worktreePath,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -41071,7 +41352,7 @@ var init_e2e = __esm({
 });
 
 // src/cli/e2e/verify-round.ts
-import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile33 } from "node:fs/promises";
 import { resolve as resolve14 } from "node:path";
 async function defaultFetchRounds(taskId) {
   return mcpCall("get_rounds", { task_id: taskId });
@@ -41079,7 +41360,7 @@ async function defaultFetchRounds(taskId) {
 async function defaultReadE2eConfig(cwd) {
   try {
     const p = resolve14(cwd, ".codebyplan", "e2e.json");
-    const raw = await readFile32(p, "utf-8");
+    const raw = await readFile33(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -41204,6 +41485,8 @@ var doctor_exports = {};
 __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join55 } from "node:path";
 import { execSync as execSync10 } from "node:child_process";
 async function checkAuth() {
   try {
@@ -41310,6 +41593,75 @@ async function checkWorktree() {
     };
   }
 }
+function checkSettings() {
+  try {
+    let projectDir;
+    try {
+      projectDir = execSync10("git rev-parse --show-toplevel", {
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+      projectDir = process.cwd();
+    }
+    if (readManifest(projectDir) === null) {
+      return {
+        name: "settings",
+        status: "skip",
+        detail: "codebyplan not installed (no .cbp.manifest.json)"
+      };
+    }
+    if (!existsSync23(join55(projectDir, ".claude", "settings.json"))) {
+      return {
+        name: "settings",
+        status: "warn",
+        detail: ".claude/settings.json missing \u2014 run `codebyplan claude update` to recreate, then git add + commit"
+      };
+    }
+    const ignoreResult = detectSettingsIgnored(projectDir);
+    if (ignoreResult.status === "non-git") {
+      return {
+        name: "settings",
+        status: "skip",
+        detail: "not in a git repo"
+      };
+    }
+    if (ignoreResult.status === "ignored") {
+      const { sourceFile, lineNum, pattern } = ignoreResult.info;
+      return {
+        name: "settings",
+        status: "warn",
+        detail: `.claude/settings.json is gitignored by "${pattern}" (${sourceFile}:${lineNum}) \u2014 remove the rule or run \`codebyplan claude update\` to auto-heal specific rules, then git add + commit`
+      };
+    }
+    const trackedStatus = checkSettingsUntracked(projectDir);
+    if (trackedStatus === "untracked") {
+      return {
+        name: "settings",
+        status: "warn",
+        detail: ".claude/settings.json is untracked \u2014 run `git add .claude/settings.json` and commit it"
+      };
+    }
+    if (trackedStatus === "non-git") {
+      return {
+        name: "settings",
+        status: "skip",
+        detail: "not in a git repo"
+      };
+    }
+    return {
+      name: "settings",
+      status: "ok",
+      detail: ".claude/settings.json present and tracked"
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      name: "settings",
+      status: "warn",
+      detail: `settings check failed: ${msg}`
+    };
+  }
+}
 function overallStatus(checks) {
   if (checks.some((c) => c.status === "fail")) return "fail";
   if (checks.some((c) => c.status === "warn")) return "warn";
@@ -41334,7 +41686,7 @@ function printHuman(result) {
 }
 function printHelp6() {
   process.stdout.write(
-    "\n  codebyplan doctor [--json]\n\n  Run diagnostics: auth, version, worktree.\n  Always exits 0 \u2014 safe for scripted use.\n\n  Flags:\n    --json   Emit structured JSON instead of the human table\n\n"
+    "\n  codebyplan doctor [--json]\n\n  Run diagnostics: auth, version, worktree, settings.\n  Always exits 0 \u2014 safe for scripted use.\n\n  Flags:\n    --json   Emit structured JSON instead of the human table\n\n"
   );
 }
 async function runDoctor(args) {
@@ -41348,7 +41700,8 @@ async function runDoctor(args) {
   const checks = await Promise.all([
     checkAuth(),
     checkVersion(),
-    checkWorktree()
+    checkWorktree(),
+    Promise.resolve(checkSettings())
   ]);
   const result = {
     checks,
@@ -41372,6 +41725,8 @@ var init_doctor = __esm({
     init_flags();
     init_local_config();
     init_resolve_worktree();
+    init_manifest();
+    init_gitignore_detect();
   }
 });