codebyplan 1.13.57 → 1.13.58

package/dist/cli.js

@@ -5,11 +5,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -39,7 +48,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.57";
+    VERSION = "1.13.58";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -14526,8 +14535,8 @@ var require_RealtimeChannel = __commonJS({
       }
       /** @internal */
       _notThisChannelEvent(event, ref) {
-        const { close, error, leave, join: join56 } = constants_1.CHANNEL_EVENTS;
-        const events = [close, error, leave, join56];
+        const { close, error, leave, join: join57 } = constants_1.CHANNEL_EVENTS;
+        const events = [close, error, leave, join57];
         return ref && events.includes(event) && ref !== this.joinPush.ref;
       }
       /** @internal */
@@ -29578,6 +29587,1264 @@ var init_standalone_task = __esm({
   }
 });
 
+// src/lib/supabase.ts
+import * as fs5 from "node:fs";
+import * as path7 from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
+function defaultRun(cmd, args) {
+  const result = spawnSync6(cmd, args, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.error) throw result.error;
+  return (result.stdout ?? "").toString();
+}
+function readJsonFile2(filePath) {
+  try {
+    const raw = fs5.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getSupabaseSection(obj) {
+  const tryPath = (root) => {
+    const surfaces = root["surfaces"];
+    if (typeof surfaces !== "object" || surfaces === null || Array.isArray(surfaces))
+      return null;
+    const sb = surfaces["supabase"];
+    if (typeof sb === "object" && sb !== null && !Array.isArray(sb)) {
+      return sb;
+    }
+    return null;
+  };
+  const shipment = obj["shipment"];
+  if (typeof shipment === "object" && shipment !== null && !Array.isArray(shipment)) {
+    const found = tryPath(shipment);
+    if (found) return found;
+  }
+  return tryPath(obj);
+}
+function globToRegex(pattern) {
+  const special = ".+^${}()|[]\\";
+  let r = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i] ?? "";
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        r += ".*";
+        i++;
+      } else {
+        r += "[^/]*";
+      }
+    } else if (ch === "?") {
+      r += "[^/]";
+    } else if (special.includes(ch)) {
+      r += "\\" + ch;
+    } else {
+      r += ch;
+    }
+  }
+  return new RegExp(`^${r}$`);
+}
+function dateToStamp(d) {
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return String(d.getUTCFullYear()) + pad2(d.getUTCMonth() + 1) + pad2(d.getUTCDate()) + pad2(d.getUTCHours()) + pad2(d.getUTCMinutes()) + pad2(d.getUTCSeconds());
+}
+function extractStampToken(filename) {
+  if (!filename.endsWith(".sql")) return null;
+  const base = filename.slice(0, -4);
+  const parts = base.split("_");
+  const first = parts[0];
+  if (!first || !/^\d{14}$/.test(first)) return null;
+  const second = parts[1];
+  if (second && /^\d{2}$/.test(second)) {
+    return `${first}_${second}`;
+  }
+  return first;
+}
+function readShipmentConfig(cwd) {
+  const dir = cwd ?? process.cwd();
+  const obj = readJsonFile2(path7.join(dir, ".codebyplan", "shipment.json"));
+  if (!obj) return { parentRef: null, previewBranches: [] };
+  const section = getSupabaseSection(obj);
+  if (!section) return { parentRef: null, previewBranches: [] };
+  const parentRef = typeof section["project_ref"] === "string" ? section["project_ref"] : null;
+  const previewBranches = [];
+  const rawBranches = section["preview_branches"];
+  if (Array.isArray(rawBranches)) {
+    for (const b of rawBranches) {
+      if (typeof b !== "object" || b === null || Array.isArray(b)) continue;
+      const entry = b;
+      if (typeof entry["branch"] !== "string" || typeof entry["project_ref"] !== "string")
+        continue;
+      previewBranches.push({
+        branch: entry["branch"],
+        project_ref: entry["project_ref"],
+        created_at: typeof entry["created_at"] === "string" ? entry["created_at"] : void 0
+      });
+    }
+  }
+  return { parentRef, previewBranches };
+}
+function readGitConfig(cwd) {
+  const dir = cwd ?? process.cwd();
+  const obj = readJsonFile2(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)) {
+    return { ...GIT_DEFAULTS };
+  }
+  const bcObj = bc;
+  const production = typeof bcObj["production"] === "string" && bcObj["production"] ? bcObj["production"] : "main";
+  const protectedArr = [];
+  const rawProtected = bcObj["protected"];
+  if (Array.isArray(rawProtected)) {
+    for (const p of rawProtected) {
+      if (typeof p === "string" && p) protectedArr.push(p);
+    }
+  }
+  if (protectedArr.length === 0) protectedArr.push(production);
+  const integration = typeof bcObj["integration"] === "string" && bcObj["integration"] ? bcObj["integration"] : null;
+  return { production, protected: protectedArr, integration };
+}
+function readDbPaths(cwd) {
+  const dir = cwd ?? process.cwd();
+  const obj = readJsonFile2(path7.join(dir, ".codebyplan", "shipment.json"));
+  if (!obj) return [...DEFAULT_DB_PATHS];
+  const section = getSupabaseSection(obj);
+  if (!section) return [...DEFAULT_DB_PATHS];
+  const rawPaths = section["db_paths"];
+  if (!Array.isArray(rawPaths) || rawPaths.length === 0)
+    return [...DEFAULT_DB_PATHS];
+  const paths = [];
+  for (const p of rawPaths) {
+    if (typeof p === "string" && p) paths.push(p);
+  }
+  return paths.length > 0 ? paths : [...DEFAULT_DB_PATHS];
+}
+function detectDbChanged(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun;
+  const base = opts.base ?? readGitConfig(cwd).production;
+  const dbPaths = opts.dbPaths ?? readDbPaths(cwd);
+  if (dbPaths.length === 0) return false;
+  const regexes = dbPaths.map(globToRegex);
+  let output;
+  try {
+    output = run("git", ["diff", "--name-only", `origin/${base}...HEAD`]);
+  } catch {
+    return false;
+  }
+  const changedFiles = output.split("\n").map((l) => l.trim()).filter(Boolean);
+  return changedFiles.some((file) => regexes.some((re) => re.test(file)));
+}
+function defaultListDir(dir) {
+  try {
+    return fs5.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function generateMonotonicTimestamp(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const listDir = opts.listDir ?? defaultListDir;
+  const migrationsDir = path7.join(cwd, "supabase", "migrations");
+  const files = listDir(migrationsDir);
+  const existingStamps = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const token = extractStampToken(file);
+    if (token) existingStamps.add(token);
+  }
+  let maxStamp = "";
+  for (const s of existingStamps) {
+    if (s > maxStamp) maxStamp = s;
+  }
+  const computed = dateToStamp(now);
+  if (computed > maxStamp && !existingStamps.has(computed)) {
+    return computed;
+  }
+  const collisionBase14 = computed > maxStamp ? computed : maxStamp.slice(0, 14);
+  for (let i = 1; i <= 99; i++) {
+    const suffix = String(i).padStart(2, "0");
+    const candidate = `${collisionBase14}_${suffix}`;
+    if (!existingStamps.has(candidate) && candidate > maxStamp) {
+      return candidate;
+    }
+  }
+  return `${collisionBase14}_99`;
+}
+async function pollGhPreviewCheck(opts = {}) {
+  const run = opts.run ?? defaultRun;
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve16) => setTimeout(resolve16, ms)));
+  const maxPolls = opts.maxPolls ?? 20;
+  const intervalMs = opts.intervalMs ?? 15e3;
+  if (!opts.prNumber) {
+    return {
+      status: "pending_pr",
+      reason: "No PR number \u2014 branch has no open pull request yet."
+    };
+  }
+  try {
+    run("gh", ["--version"]);
+  } catch {
+    return {
+      status: "blocked",
+      reason: "gh CLI not available"
+    };
+  }
+  const prNumber = opts.prNumber;
+  for (let poll = 0; poll < maxPolls; poll++) {
+    if (poll > 0) {
+      await sleep3(intervalMs);
+    }
+    let checksOutput;
+    try {
+      try {
+        checksOutput = run("gh", [
+          "pr",
+          "checks",
+          prNumber,
+          "--json",
+          "name,bucket,state"
+        ]);
+      } catch {
+        checksOutput = run("gh", [
+          "pr",
+          "checks",
+          prNumber,
+          "--json",
+          "name,state"
+        ]);
+      }
+    } catch {
+      if (poll === maxPolls - 1) {
+        return {
+          status: "blocked",
+          reason: `gh pr checks failed after ${maxPolls} polls`
+        };
+      }
+      continue;
+    }
+    let checks;
+    try {
+      const parsed = JSON.parse(checksOutput);
+      checks = Array.isArray(parsed) ? parsed : [];
+    } catch {
+      checks = [];
+    }
+    const supabaseCheck = checks.find(
+      (c) => typeof c["name"] === "string" && c["name"].toLowerCase().includes("supabase preview")
+    );
+    if (!supabaseCheck) {
+      continue;
+    }
+    const bucket = typeof supabaseCheck["bucket"] === "string" ? supabaseCheck["bucket"].toLowerCase() : null;
+    const state = typeof supabaseCheck["state"] === "string" ? supabaseCheck["state"].toLowerCase() : null;
+    if (bucket === "pass") {
+      return { status: "passed", reason: "Supabase Preview check passed." };
+    }
+    if (bucket === "skipping") {
+      return {
+        status: "skipped",
+        reason: "Supabase Preview check skipped at CI."
+      };
+    }
+    if (bucket === "fail" || bucket === "cancel") {
+      return {
+        status: "blocked",
+        reason: `Supabase Preview check ${bucket}ed.`
+      };
+    }
+    if (state === "success") {
+      return { status: "passed", reason: "Supabase Preview check passed." };
+    }
+    if (state === "skipped" || state === "neutral") {
+      return {
+        status: "skipped",
+        reason: "Supabase Preview check skipped at CI."
+      };
+    }
+    if (state === "failure" || state === "cancelled" || state === "error" || state === "timed_out" || state === "stale" || state === "action_required") {
+      return {
+        status: "blocked",
+        reason: `Supabase Preview check ${state}.`
+      };
+    }
+  }
+  const minutesStr = Math.round(maxPolls * intervalMs / 6e4);
+  return {
+    status: "blocked",
+    reason: `Supabase Preview check still pending after ${minutesStr} min (${maxPolls} polls)`
+  };
+}
+var GIT_DEFAULTS, DEFAULT_DB_PATHS;
+var init_supabase = __esm({
+  "src/lib/supabase.ts"() {
+    "use strict";
+    GIT_DEFAULTS = {
+      production: "main",
+      protected: ["main"],
+      integration: null
+    };
+    DEFAULT_DB_PATHS = [
+      "supabase/**",
+      "apps/backend/**",
+      "packages/**/db/**"
+    ];
+  }
+});
+
+// src/lib/session.ts
+import { spawnSync as spawnSync7 } from "node:child_process";
+import { existsSync as nodeExistsSync } from "node:fs";
+import * as path8 from "node:path";
+function defaultRun2(cmd, args, cwd) {
+  const result = spawnSync7(cmd, args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = (result.stderr ?? "").toString().trim();
+    throw new Error(
+      `${cmd} ${args.join(" ")} exited ${result.status ?? "null"}${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+  return (result.stdout ?? "").toString();
+}
+function homeFf(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun2;
+  const gitCfg = readGitConfig(cwd);
+  const production = gitCfg.production;
+  let repoRoot;
+  try {
+    repoRoot = run("git", ["rev-parse", "--show-toplevel"], cwd).trim();
+  } catch {
+    return {
+      result: "skipped",
+      reason: "git rev-parse --show-toplevel failed"
+    };
+  }
+  const folder = path8.basename(repoRoot);
+  let current;
+  try {
+    current = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd).trim();
+  } catch {
+    return {
+      result: "skipped",
+      reason: "git rev-parse --abbrev-ref HEAD failed"
+    };
+  }
+  if (current !== folder) {
+    return { result: "skipped", reason: "not on home branch" };
+  }
+  try {
+    run("git", ["fetch", "origin", production], cwd);
+  } catch {
+    return {
+      result: "warn",
+      warn: `fetch failed \u2014 staying on local ${current}`
+    };
+  }
+  try {
+    run("git", ["merge", "--ff-only", `origin/${production}`], cwd);
+  } catch {
+    return {
+      result: "warn",
+      warn: `${current} not fast-forwardable (ahead/diverged) \u2014 left untouched`
+    };
+  }
+  return { result: "fast_forwarded" };
+}
+function spawnVersionStatus(cwd) {
+  try {
+    const result = spawnSync7("npx", ["codebyplan", "version-status"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.error) return null;
+    const raw = (result.stdout ?? "").toString().trim();
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return null;
+    }
+    const obj = parsed;
+    if (typeof obj["installed"] !== "string" || typeof obj["newer"] !== "boolean" || typeof obj["guarded"] !== "boolean" || typeof obj["installCommand"] !== "string") {
+      return null;
+    }
+    return {
+      installed: obj["installed"],
+      latest: typeof obj["latest"] === "string" ? obj["latest"] : null,
+      newer: obj["newer"],
+      packageManager: typeof obj["packageManager"] === "string" ? obj["packageManager"] : "npm",
+      installCommand: obj["installCommand"],
+      guarded: obj["guarded"],
+      guardReason: typeof obj["guardReason"] === "string" ? obj["guardReason"] : null
+    };
+  } catch {
+    return null;
+  }
+}
+function defaultRunInstall(installCommand, cwd) {
+  const parts = installCommand.trim().split(/\s+/);
+  const cmd = parts[0];
+  const args = parts.slice(1);
+  if (!cmd) throw new Error("empty installCommand");
+  const result = spawnSync7(cmd, args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = (result.stderr ?? "").toString().trim();
+    throw new Error(
+      `install exited ${result.status}${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+}
+function defaultRunClaudeUpdate(cwd) {
+  const result = spawnSync7("npx", ["codebyplan", "claude", "update", "--yes"], {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = (result.stderr ?? "").toString().trim();
+    throw new Error(
+      `claude update exited ${result.status}${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+}
+function defaultRunGitStatus(cwd) {
+  const result = spawnSync7(
+    "git",
+    ["status", "--porcelain", "--", ".claude/", ".codebyplan/"],
+    {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }
+  );
+  if (result.error) throw result.error;
+  return (result.stdout ?? "").toString();
+}
+async function freshnessGate(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const probeVersionStatus = opts.probeVersionStatus ?? ((c) => spawnVersionStatus(c));
+  const runInstall2 = opts.runInstall ?? defaultRunInstall;
+  const runClaudeUpdate = opts.runClaudeUpdate ?? defaultRunClaudeUpdate;
+  const runGitStatus = opts.runGitStatus ?? defaultRunGitStatus;
+  const haltOnUpdate = opts.haltOnUpdate ?? false;
+  let probe;
+  try {
+    probe = probeVersionStatus(cwd);
+  } catch {
+    probe = null;
+  }
+  if (!probe) {
+    return { result: "skipped", reason: "probe failed (fail-safe)" };
+  }
+  if (probe.guarded) {
+    return { result: "guarded" };
+  }
+  if (!probe.newer) {
+    return { result: "up_to_date" };
+  }
+  try {
+    runInstall2(probe.installCommand, cwd);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : "install failed (unknown error)";
+    return { result: "error", reason };
+  }
+  try {
+    runClaudeUpdate(cwd);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : "claude update failed (unknown error)";
+    return { result: "error", reason };
+  }
+  let gitStatusOutput = "";
+  try {
+    gitStatusOutput = runGitStatus(cwd);
+  } catch {
+    gitStatusOutput = "";
+  }
+  const changedFiles = gitStatusOutput.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const parts = line.split(/\s+/);
+    return parts.slice(1).join(" ");
+  }).filter(Boolean);
+  return {
+    result: "updated",
+    latest: probe.latest ?? probe.installed,
+    changed_files: changedFiles,
+    halt: haltOnUpdate
+  };
+}
+async function infraFiles(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun2;
+  const getTaskFiles = opts.getTaskFiles ?? (() => Promise.resolve([]));
+  let firstOutput;
+  try {
+    firstOutput = run("git", ["status", "--porcelain"], cwd);
+  } catch {
+    firstOutput = "";
+  }
+  const firstChanged = parseGitStatus2(firstOutput);
+  if (firstChanged.length === 0) {
+    return { infra_files: [], task_files: [], note: "clean tree" };
+  }
+  const taskFiles = await getTaskFiles();
+  const taskSet = new Set(taskFiles);
+  let secondOutput;
+  try {
+    secondOutput = run("git", ["status", "--porcelain"], cwd);
+  } catch {
+    secondOutput = "";
+  }
+  const freshChanged = parseGitStatus2(secondOutput);
+  const infraFilesList = freshChanged.filter((f) => !taskSet.has(f));
+  return {
+    infra_files: infraFilesList,
+    task_files: taskFiles
+  };
+}
+function resolveWorktreeJson(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun2;
+  try {
+    const stdout7 = run(
+      "npx",
+      ["codebyplan", "resolve-worktree", "--json"],
+      cwd
+    );
+    const raw = stdout7.trim();
+    if (!raw) {
+      return { worktree_id: null, error_kind: "tuple_miss" };
+    }
+    const parsed = JSON.parse(raw);
+    const worktree_id = typeof parsed["worktree_id"] === "string" ? parsed["worktree_id"] : null;
+    const error_kind = typeof parsed["error_kind"] === "string" ? parsed["error_kind"] : null;
+    return { worktree_id, error_kind };
+  } catch (err) {
+    process.stderr.write(
+      `session: resolveWorktreeJson failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return { worktree_id: null, error_kind: "unhandled" };
+  }
+}
+function infraDriftNudge(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun2;
+  const existsSync24 = opts.existsSync ?? ((p) => {
+    try {
+      return nodeExistsSync(p);
+    } catch {
+      return false;
+    }
+  });
+  try {
+    const driftScript = path8.join(cwd, "scripts", "infra-drift.mjs");
+    const templatesDir = path8.join(
+      cwd,
+      "packages",
+      "codebyplan-package",
+      "templates"
+    );
+    if (!existsSync24(driftScript) || !existsSync24(templatesDir)) {
+      return null;
+    }
+    try {
+      const production = readGitConfig(cwd).production || "main";
+      run("git", ["fetch", "origin", production], cwd);
+    } catch {
+    }
+    let output = "";
+    try {
+      output = run("node", [driftScript], cwd);
+    } catch {
+      return null;
+    }
+    const line = output.trim();
+    return line || null;
+  } catch (err) {
+    process.stderr.write(
+      `session: infraDriftNudge failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function archMapDriftNudge(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun2;
+  const existsSync24 = opts.existsSync ?? ((p) => {
+    try {
+      return nodeExistsSync(p);
+    } catch {
+      return false;
+    }
+  });
+  try {
+    const manifestPath2 = path8.join(cwd, ".codebyplan", "architecture.json");
+    if (!existsSync24(manifestPath2)) {
+      return null;
+    }
+    let output = "";
+    try {
+      output = run("npx", ["codebyplan", "arch-map", "drift"], cwd);
+    } catch {
+      return null;
+    }
+    const driftedCount = output.split("\n").filter((line) => /^\s*DRIFTED/.test(line)).length;
+    if (driftedCount > 0) {
+      return `\u26A0 .claude/architecture is ${driftedCount} module(s) stale \u2014 run /cbp-refresh-arch-map`;
+    }
+    return null;
+  } catch (err) {
+    process.stderr.write(
+      `session: archMapDriftNudge failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function lspNudge(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const run = opts.run ?? defaultRun2;
+  try {
+    let output = "";
+    try {
+      output = run("npx", ["codebyplan", "lsp", "--check"], cwd);
+    } catch {
+      return [];
+    }
+    return output.split("\n").map((l) => l.trim()).filter(Boolean);
+  } catch (err) {
+    process.stderr.write(
+      `session: lspNudge failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return [];
+  }
+}
+async function probeHandoff(opts) {
+  const stale = { fresh: false };
+  try {
+    const {
+      repoRoot,
+      worktreeId,
+      previousSessionRow,
+      freshnessWindowHours = 24,
+      readEntity
+    } = opts;
+    if (!previousSessionRow) return stale;
+    if (!previousSessionRow.closed_at) return stale;
+    if (previousSessionRow.content == null) return stale;
+    let handoff;
+    try {
+      const raw = typeof previousSessionRow.content === "string" ? JSON.parse(previousSessionRow.content) : previousSessionRow.content;
+      if (typeof raw !== "object" || raw === null) return stale;
+      const obj = raw;
+      if (!obj["command"] || typeof obj["command"] !== "string") return stale;
+      if (!obj["command"].trim()) return stale;
+      handoff = {
+        command: obj["command"],
+        captured_at: typeof obj["captured_at"] === "string" ? obj["captured_at"] : void 0,
+        context: typeof obj["context"] === "object" && obj["context"] !== null ? obj["context"] : {},
+        state: obj["state"]
+      };
+    } catch {
+      return stale;
+    }
+    const closedAt = new Date(previousSessionRow.closed_at).getTime();
+    const windowMs = freshnessWindowHours * 60 * 60 * 1e3;
+    if (Date.now() - closedAt > windowMs) return stale;
+    const capturedAt = handoff.captured_at ?? previousSessionRow.closed_at;
+    const ctx = handoff.context ?? {};
+    const resolveEntityPath = (entityType, id) => {
+      const stateDir2 = path8.join(repoRoot, ".codebyplan", "state");
+      if (entityType === "checkpoint") {
+        return path8.join(stateDir2, "checkpoints", `${id}.json`);
+      }
+      if (entityType === "task" && ctx.checkpoint_id) {
+        return path8.join(
+          stateDir2,
+          "checkpoints",
+          ctx.checkpoint_id,
+          "tasks",
+          `${id}.json`
+        );
+      }
+      if (entityType === "round" && ctx.checkpoint_id && ctx.task_id) {
+        return path8.join(
+          stateDir2,
+          "checkpoints",
+          ctx.checkpoint_id,
+          "tasks",
+          ctx.task_id,
+          "rounds",
+          `${id}.json`
+        );
+      }
+      return "";
+    };
+    const reader = readEntity ?? (async (filePath) => {
+      const { readEntityFile: ref } = await Promise.resolve().then(() => (init_state_store(), state_store_exports));
+      return ref(filePath);
+    });
+    if (ctx.checkpoint_id) {
+      const chkPath = resolveEntityPath("checkpoint", ctx.checkpoint_id);
+      if (!chkPath) return stale;
+      const chk = await reader(chkPath);
+      if (!chk) return stale;
+      if (chk.worktree_id != null && (worktreeId === null || worktreeId !== chk.worktree_id)) {
+        return stale;
+      }
+      if (chk.updated_at && capturedAt && chk.updated_at > capturedAt) {
+        return stale;
+      }
+    }
+    if (ctx.task_id) {
+      const taskPath2 = resolveEntityPath("task", ctx.task_id);
+      if (!taskPath2) return stale;
+      const task = await reader(taskPath2);
+      if (!task) return stale;
+      if (task.updated_at && capturedAt && task.updated_at > capturedAt) {
+        return stale;
+      }
+    }
+    if (ctx.round_id) {
+      const roundPath2 = resolveEntityPath("round", ctx.round_id);
+      if (!roundPath2) return stale;
+      const round = await reader(roundPath2);
+      if (!round) return stale;
+      if (round.updated_at && capturedAt && round.updated_at > capturedAt) {
+        return stale;
+      }
+    }
+    return {
+      fresh: true,
+      command: handoff.command,
+      context: ctx,
+      state: handoff.state
+    };
+  } catch (err) {
+    process.stderr.write(
+      `session: probeHandoff failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return stale;
+  }
+}
+function partitionOwnership(checkpoints, worktreeId) {
+  const owned = [];
+  const cross = [];
+  for (const chk of checkpoints) {
+    const id = chk.id ?? "";
+    const title = chk.title ?? (chk.number != null ? `CHK-${chk.number}` : id);
+    const chkWorktreeId = chk.worktree_id ?? null;
+    if (chkWorktreeId === null || chkWorktreeId === worktreeId) {
+      owned.push({ id, title });
+    } else {
+      cross.push({ id, title });
+    }
+  }
+  return { owned, cross };
+}
+function computeNextAction(input) {
+  const { status, owned_count, total_count, handoff_fresh, infra_files_count } = input;
+  if (status === "update_halt") return "mcp_update_halt";
+  if (handoff_fresh) return "resume_handoff";
+  if (infra_files_count > 0 && owned_count >= 1) return "commit_then_todo";
+  if (owned_count >= 1) return "trigger_todo";
+  if (total_count >= 1 && owned_count === 0) return "stop";
+  return "trigger_todo";
+}
+function renderBlock(envelope) {
+  const lines = [];
+  const worktreeDisplay = envelope.worktree_id ?? "unregistered";
+  lines.push(`Session active | Worktree: ${worktreeDisplay}`);
+  lines.push("");
+  if (envelope.worktree_error_kind !== null && envelope.worktree_error_kind !== "tuple_miss") {
+    lines.push(
+      `\u26A0 resolve-worktree: ${envelope.worktree_error_kind} \u2014 local state is broken; routing may be unreliable. Run \`npx codebyplan setup\` to repair.`
+    );
+    lines.push("");
+  }
+  if (envelope.infra_drift_nudge) {
+    lines.push(envelope.infra_drift_nudge);
+  }
+  if (envelope.arch_map_nudge) {
+    lines.push(envelope.arch_map_nudge);
+  }
+  if (envelope.infra_drift_nudge || envelope.arch_map_nudge) {
+    lines.push("");
+  }
+  const prevTitle = envelope.previous_session?.title ?? "none";
+  lines.push(`Previous session: ${prevTitle}`);
+  const pending = envelope.previous_session?.pending ?? "\u2014";
+  lines.push(`  Pending: ${pending}`);
+  lines.push("");
+  lines.push(
+    `Ownership: ${envelope.total_count} active CHK(s), ${envelope.owned_count} owned by this worktree`
+  );
+  if (envelope.owned_count > 0) {
+    const ownedStr = envelope.owned_checkpoints.map((c) => c.title).join(", ");
+    lines.push(`Owned: ${ownedStr}`);
+  }
+  if (envelope.cross_checkpoints.length > 0) {
+    const crossStr = envelope.cross_checkpoints.map((c) => c.title).join(", ");
+    lines.push(`Cross-worktree: ${crossStr}`);
+  }
+  if (envelope.lsp_nudges.length > 0) {
+    lines.push("");
+    for (const hint of envelope.lsp_nudges) {
+      lines.push(`LSP: ${hint}`);
+    }
+  }
+  if (envelope.worktree_id === null && (envelope.worktree_error_kind === null || envelope.worktree_error_kind === "tuple_miss")) {
+    lines.push("");
+    lines.push(
+      `\u26A0 Worktree unregistered \u2014 run \`npx codebyplan setup\` to register`
+    );
+  }
+  return lines.join("\n");
+}
+function parseGitStatus2(output) {
+  return output.split("\n").filter(Boolean).map((line) => {
+    if (line.length > 3) {
+      const rest = line.slice(3);
+      const arrow = rest.indexOf(" -> ");
+      if (arrow !== -1) {
+        return rest.slice(arrow + 4).trim();
+      }
+      return rest.trim();
+    }
+    return "";
+  }).filter(Boolean);
+}
+var init_session = __esm({
+  "src/lib/session.ts"() {
+    "use strict";
+    init_supabase();
+  }
+});
+
+// src/cli/session/start.ts
+var start_exports = {};
+__export(start_exports, {
+  buildCreateLogBody: () => buildCreateLogBody,
+  defaultGetCheckpoints: () => defaultGetCheckpoints,
+  runSessionStartCli: () => runSessionStartCli
+});
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { dirname as dirname9 } from "node:path";
+async function updateCursorHashLocal(repoRoot, entityId, row) {
+  const cursor = await readCursor(repoRoot);
+  if (!cursor) return;
+  const hash = hashEntity(row);
+  cursor.entity_hashes[entityId] = hash;
+  await writeCursor(repoRoot, cursor);
+}
+async function defaultUpdateStateActivate(repoId, repoRoot) {
+  const snakePatch = { action: "activate" };
+  const stateFilePath = sessionLogPath(repoRoot).replace(
+    "current.json",
+    "state.json"
+  );
+  const snapshot = await readEntityFile(stateFilePath);
+  const optimistic = { ...snapshot ?? {}, ...snakePatch, repo_id: repoId };
+  await writeEntityFile(stateFilePath, optimistic);
+  try {
+    const updated = await apiBackendPatch(
+      new URL(backendSessionStateEndpoint(repoId)).pathname,
+      snakePatch
+    );
+    await writeEntityFile(stateFilePath, updated);
+  } catch (err) {
+    if (err instanceof BackendError && err.status < 500) {
+      if (snapshot !== null) {
+        await writeEntityFile(stateFilePath, snapshot);
+      } else {
+        await deleteEntityFile(stateFilePath);
+      }
+    } else {
+      await writeEntityFile(
+        pendingMarkerPath(repoRoot, `session-state-${repoId}`),
+        {
+          entity: "session_state",
+          repo_id: repoId,
+          operation: "update-state",
+          attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+          error: err instanceof Error ? err.message : String(err)
+        }
+      );
+    }
+    process.stderr.write(
+      `session start: update-state activate failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function buildCreateLogBody(repoId, worktreeId, now = /* @__PURE__ */ new Date()) {
+  const session_date = now.toISOString().slice(0, 10);
+  const jan1 = Date.UTC(now.getUTCFullYear(), 0, 1);
+  const day_number = Math.floor((now.getTime() - jan1) / 864e5) + 1;
+  return {
+    repo_id: repoId,
+    session_date,
+    day_number,
+    started_at: now.toISOString(),
+    summary: "",
+    ...worktreeId != null ? { worktree_id: worktreeId } : {}
+  };
+}
+async function defaultCreateLog(repoId, repoRoot, worktreeId) {
+  const body = buildCreateLogBody(repoId, worktreeId);
+  try {
+    const created = await apiBackendPost(new URL(backendSessionLogsEndpoint()).pathname, body);
+    const sessionLog = created.session_log ?? created;
+    const filePath = sessionLogPath(repoRoot);
+    await writeEntityFile(filePath, sessionLog);
+    const sessionLogId = sessionLog.id;
+    if (sessionLogId) {
+      await updateCursorHashLocal(repoRoot, sessionLogId, sessionLog);
+    }
+    return sessionLogId ?? null;
+  } catch (err) {
+    process.stderr.write(
+      `session start: create-log failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+async function defaultGetCheckpoints(repoId) {
+  try {
+    const result = await apiGet("/checkpoints", {
+      repo_id: repoId,
+      status: "active"
+    });
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const res = result ?? {};
+    if (Array.isArray(res["data"])) {
+      return res["data"];
+    }
+    if (Array.isArray(res["checkpoints"])) {
+      return res["checkpoints"];
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function defaultRunSync(cwd) {
+  try {
+    spawnSync8("npx", ["codebyplan", "sync"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+async function resolveRepoInfo(cwd) {
+  const found = await findCodebyplanConfig(cwd);
+  if (!found?.contents.repo_id) return null;
+  const repoRoot = deriveRepoRoot(found.path);
+  return { repoRoot, repoId: found.contents.repo_id };
+}
+async function resolveTaskFilesFromState(repoRoot) {
+  try {
+    const todos = await readEntityFile(todosPath(repoRoot));
+    const rows = Array.isArray(todos) ? todos : [];
+    const active = rows.find((t) => t["status"] === "current");
+    if (!active) return [];
+    const checkpoint_id = active["checkpoint_id"];
+    const task_id = active["task_id"];
+    if (!checkpoint_id || !task_id) return [];
+    const roundsDir = dirname9(roundPath(repoRoot, checkpoint_id, task_id, "_"));
+    const roundFiles = await listEntityFiles(roundsDir);
+    const fileSet = /* @__PURE__ */ new Set();
+    for (const rPath of roundFiles) {
+      const round = await readEntityFile(rPath);
+      if (!round) continue;
+      const status = round.status ?? "";
+      if (status === "completed" || status === "cancelled") continue;
+      const files = round.files_changed ?? round.context?.files_changed ?? [];
+      for (const f of files) {
+        if (f.path) fileSet.add(f.path);
+      }
+    }
+    return [...fileSet];
+  } catch {
+    return [];
+  }
+}
+async function runSessionStartCli(_args, deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const repoInfo = await (deps.resolveRepo ?? resolveRepoInfo)(cwd);
+  if (!repoInfo) {
+    const envelope2 = {
+      status: "ok",
+      session_log_id: null,
+      worktree_id: null,
+      worktree_error_kind: "unhandled",
+      infra_drift_nudge: null,
+      arch_map_nudge: null,
+      lsp_nudges: [],
+      handoff: { fresh: false },
+      infra_files_to_commit: [],
+      owned_checkpoints: [],
+      cross_checkpoints: [],
+      owned_count: 0,
+      total_count: 0,
+      next_action: "trigger_todo",
+      rendered_block: "session start: no .codebyplan/repo.json found \u2014 run `codebyplan setup`",
+      previous_session: null
+    };
+    process.stdout.write(JSON.stringify(envelope2) + "\n");
+    return 0;
+  }
+  const { repoRoot, repoId } = repoInfo;
+  const { worktree_id: worktreeId, error_kind: worktreeErrorKind } = resolveWorktreeJson({ cwd, run: deps.resolveWorktreeRunner });
+  const freshnessGateFn = deps.freshnessGate ?? freshnessGate;
+  let freshnessResult;
+  try {
+    freshnessResult = await freshnessGateFn({
+      cwd,
+      haltOnUpdate: true
+    });
+  } catch {
+    freshnessResult = { result: "skipped", reason: "gate error (fail-safe)" };
+  }
+  if (freshnessResult.result === "updated" && "halt" in freshnessResult && freshnessResult.halt) {
+    const haltMsg = "codebyplan updated. Start a FRESH Claude Code session\n(run /clear or open a new window) so the updated .claude/ takes effect.";
+    const envelope2 = {
+      status: "update_halt",
+      session_log_id: null,
+      worktree_id: worktreeId,
+      worktree_error_kind: worktreeErrorKind,
+      infra_drift_nudge: null,
+      arch_map_nudge: null,
+      lsp_nudges: [],
+      handoff: { fresh: false },
+      infra_files_to_commit: "changed_files" in freshnessResult ? freshnessResult.changed_files ?? [] : [],
+      owned_checkpoints: [],
+      cross_checkpoints: [],
+      owned_count: 0,
+      total_count: 0,
+      next_action: "mcp_update_halt",
+      rendered_block: haltMsg,
+      previous_session: null
+    };
+    process.stdout.write(JSON.stringify(envelope2) + "\n");
+    return 0;
+  }
+  const infraDriftNudgeVal = infraDriftNudge({
+    cwd,
+    run: deps.infraDriftRunner,
+    existsSync: deps.infraDriftExistsSync
+  });
+  const archMapNudgeVal = archMapDriftNudge({
+    cwd,
+    run: deps.archMapDriftRunner,
+    existsSync: deps.archMapDriftExistsSync
+  });
+  const lspNudgesVal = lspNudge({ cwd, run: deps.lspRunner });
+  const runSync2 = deps.runSync ?? defaultRunSync;
+  const readPreviousSession = deps.readPreviousSession ?? ((rr) => readEntityFile(sessionLogPath(rr)));
+  let previousSessionRow = await readPreviousSession(repoRoot);
+  if (!previousSessionRow) {
+    runSync2(cwd);
+    previousSessionRow = await readPreviousSession(repoRoot);
+  }
+  const handoffResult = await probeHandoff({
+    repoRoot,
+    worktreeId,
+    previousSessionRow,
+    readEntity: deps.readEntity ?? (async (filePath) => {
+      return readEntityFile(filePath);
+    })
+  });
+  const updateStateActivateFn = deps.updateStateActivate ?? defaultUpdateStateActivate;
+  await updateStateActivateFn(repoId, repoRoot).catch((err) => {
+    process.stderr.write(
+      `session start: update-state activate threw (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  });
+  const createLogFn = deps.createLog ?? defaultCreateLog;
+  const sessionLogId = await createLogFn(repoId, repoRoot, worktreeId).catch(
+    (err) => {
+      process.stderr.write(
+        `session start: create-log threw (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      return null;
+    }
+  );
+  const resolveTaskFiles = deps.resolveTaskFiles ?? resolveTaskFilesFromState;
+  const taskFilesFromState = await resolveTaskFiles(repoRoot);
+  let infraFilesToCommit = [];
+  try {
+    const infraResult = await infraFiles({
+      cwd,
+      run: deps.infraFilesRunner,
+      getTaskFiles: () => Promise.resolve(taskFilesFromState)
+    });
+    infraFilesToCommit = infraResult.infra_files;
+  } catch {
+    infraFilesToCommit = [];
+  }
+  const getCheckpointsFn = deps.getCheckpoints ?? defaultGetCheckpoints;
+  let checkpoints = [];
+  try {
+    checkpoints = await getCheckpointsFn(repoId);
+  } catch {
+    checkpoints = [];
+  }
+  const { owned, cross } = partitionOwnership(checkpoints, worktreeId);
+  const ownedCount = owned.length;
+  const totalCount = owned.length + cross.length;
+  const nextAction = computeNextAction({
+    status: "ok",
+    owned_count: ownedCount,
+    total_count: totalCount,
+    handoff_fresh: handoffResult.fresh,
+    infra_files_count: infraFilesToCommit.length
+  });
+  let previousSession = null;
+  if (previousSessionRow) {
+    previousSession = {
+      title: typeof previousSessionRow["title"] === "string" ? previousSessionRow["title"] : void 0,
+      summary: typeof previousSessionRow["summary"] === "string" ? previousSessionRow["summary"] : void 0,
+      pending: typeof previousSessionRow["pending"] === "string" ? previousSessionRow["pending"] : void 0
+    };
+  }
+  const envelope = {
+    status: "ok",
+    session_log_id: sessionLogId,
+    worktree_id: worktreeId,
+    worktree_error_kind: worktreeErrorKind,
+    infra_drift_nudge: infraDriftNudgeVal,
+    arch_map_nudge: archMapNudgeVal,
+    lsp_nudges: lspNudgesVal,
+    handoff: handoffResult.fresh ? {
+      fresh: true,
+      command: handoffResult.command,
+      context: handoffResult.context,
+      state: handoffResult.state
+    } : { fresh: false },
+    infra_files_to_commit: infraFilesToCommit,
+    owned_checkpoints: owned,
+    cross_checkpoints: cross,
+    owned_count: ownedCount,
+    total_count: totalCount,
+    next_action: nextAction,
+    rendered_block: "",
+    // filled below
+    previous_session: previousSession
+  };
+  envelope.rendered_block = renderBlock(envelope);
+  process.stdout.write(JSON.stringify(envelope) + "\n");
+  return 0;
+}
+var init_start = __esm({
+  "src/cli/session/start.ts"() {
+    "use strict";
+    init_session();
+    init_flags();
+    init_state_store();
+    init_state_client();
+    init_urls();
+    init_api();
+  }
+});
+
+// src/cli/session/home-ff.ts
+var home_ff_exports = {};
+__export(home_ff_exports, {
+  homeFfCli: () => homeFfCli
+});
+function homeFfCli(_args, deps = {}) {
+  const result = homeFf(deps);
+  process.stdout.write(JSON.stringify(result) + "\n");
+  return 0;
+}
+var init_home_ff = __esm({
+  "src/cli/session/home-ff.ts"() {
+    "use strict";
+    init_session();
+  }
+});
+
+// src/cli/session/freshness-gate.ts
+var freshness_gate_exports = {};
+__export(freshness_gate_exports, {
+  freshnessGateCli: () => freshnessGateCli
+});
+async function freshnessGateCli(args, deps = {}) {
+  const haltOnUpdate = args.includes("--halt-on-update");
+  const result = await freshnessGate({
+    ...deps,
+    haltOnUpdate: deps.haltOnUpdate ?? haltOnUpdate
+  });
+  process.stdout.write(JSON.stringify(result) + "\n");
+  return 0;
+}
+var init_freshness_gate = __esm({
+  "src/cli/session/freshness-gate.ts"() {
+    "use strict";
+    init_session();
+  }
+});
+
+// src/cli/session/infra-files.ts
+var infra_files_exports = {};
+__export(infra_files_exports, {
+  infraFilesCli: () => infraFilesCli
+});
+async function infraFilesCli(args, deps = {}) {
+  let taskFilesFromFlag = [];
+  const tfIdx = args.indexOf("--task-files");
+  if (tfIdx !== -1 && tfIdx + 1 < args.length) {
+    const raw = args[tfIdx + 1];
+    if (raw && !raw.startsWith("--")) {
+      taskFilesFromFlag = raw.split(",").map((f) => f.trim()).filter(Boolean);
+    }
+  }
+  const result = await infraFiles({
+    ...deps,
+    // When the caller passes --task-files, use those as the task file list.
+    // The deps injection wins when explicitly provided (test path).
+    getTaskFiles: deps.getTaskFiles ?? (taskFilesFromFlag.length > 0 ? () => Promise.resolve(taskFilesFromFlag) : () => Promise.resolve([]))
+  });
+  process.stdout.write(JSON.stringify(result) + "\n");
+  return 0;
+}
+var init_infra_files = __esm({
+  "src/cli/session/infra-files.ts"() {
+    "use strict";
+    init_session();
+  }
+});
+
 // src/cli/session.ts
 var session_exports = {};
 __export(session_exports, {
@@ -29774,11 +31041,27 @@ async function runSessionUpdateState(args) {
 }
 function printSessionHelp() {
   process.stdout.write(
-    "\n  codebyplan session <subcommand>\n\n  Subcommands:\n    create-log     Create a session log (fields as --key value pairs)\n    update-log     Update a session log (--id <uuid> required, then --key value pairs)\n    update-state   Update session state for the current repo (--key value pairs)\n\n"
+    "\n  codebyplan session <subcommand>\n\n  Subcommands:\n    start          Run the session-start orchestrator; emits one JSON envelope on stdout\n    home-ff        Fast-forward the home branch to HEAD; emits { result, reason? } JSON\n    freshness-gate Check package version freshness [--halt-on-update]; emits { result, ... } JSON\n    infra-files    Compute the infra-file set for the active session [--task-files <csv>] [--json]\n    create-log     Create a session log (fields as --key value pairs)\n    update-log     Update a session log (--id <uuid> required, then --key value pairs)\n    update-state   Update session state for the current repo (--key value pairs)\n\n"
   );
 }
 async function runSessionCommand(args) {
   const subcommand = args[0];
+  if (subcommand === "start") {
+    const { runSessionStartCli: runSessionStartCli2 } = await Promise.resolve().then(() => (init_start(), start_exports));
+    process.exit(await runSessionStartCli2(args.slice(1)));
+  }
+  if (subcommand === "home-ff") {
+    const { homeFfCli: homeFfCli2 } = await Promise.resolve().then(() => (init_home_ff(), home_ff_exports));
+    process.exit(homeFfCli2(args.slice(1)));
+  }
+  if (subcommand === "freshness-gate") {
+    const { freshnessGateCli: freshnessGateCli2 } = await Promise.resolve().then(() => (init_freshness_gate(), freshness_gate_exports));
+    process.exit(await freshnessGateCli2(args.slice(1)));
+  }
+  if (subcommand === "infra-files") {
+    const { infraFilesCli: infraFilesCli2 } = await Promise.resolve().then(() => (init_infra_files(), infra_files_exports));
+    process.exit(await infraFilesCli2(args.slice(1)));
+  }
   if (subcommand === "create-log") {
     await runSessionCreateLog(args.slice(1));
     return;
@@ -29806,7 +31089,7 @@ Run 'codebyplan session help' for usage.
   }
   process.exit(1);
 }
-var init_session = __esm({
+var init_session2 = __esm({
   "src/cli/session.ts"() {
     "use strict";
     init_flags();
@@ -29818,7 +31101,7 @@ var init_session = __esm({
 
 // src/lib/migrate-branch-model.ts
 import { readFile as readFile18, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
 import { execSync as execSync4 } from "node:child_process";
 function assertValidBranchName(branch) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -29827,7 +31110,7 @@ function assertValidBranchName(branch) {
     );
   }
 }
-async function readJsonFile2(filePath) {
+async function readJsonFile3(filePath) {
   const raw = await readFile18(filePath, "utf-8");
   const parsed = JSON.parse(raw);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
@@ -29897,17 +31180,17 @@ async function runBranchMigration(opts) {
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      configPath = join22(dir, "git.json");
+      configPath = join24(dir, "git.json");
     } else {
       configPath = found.path;
     }
   } else {
-    configPath = join22(cwd, ".codebyplan", "git.json");
+    configPath = join24(cwd, ".codebyplan", "git.json");
   }
   let fileRaw;
   let fileParsed;
   try {
-    const result = await readJsonFile2(configPath);
+    const result = await readJsonFile3(configPath);
     fileRaw = result.raw;
     fileParsed = result.parsed;
   } catch (err) {
@@ -29995,323 +31278,10 @@ var init_migrate_branch_model = __esm({
   }
 });
 
-// src/lib/supabase.ts
-import * as fs5 from "node:fs";
-import * as path7 from "node:path";
-import { spawnSync as spawnSync6 } from "node:child_process";
-function defaultRun(cmd, args) {
-  const result = spawnSync6(cmd, args, {
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.error) throw result.error;
-  return (result.stdout ?? "").toString();
-}
-function readJsonFile3(filePath) {
-  try {
-    const raw = fs5.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function getSupabaseSection(obj) {
-  const tryPath = (root) => {
-    const surfaces = root["surfaces"];
-    if (typeof surfaces !== "object" || surfaces === null || Array.isArray(surfaces))
-      return null;
-    const sb = surfaces["supabase"];
-    if (typeof sb === "object" && sb !== null && !Array.isArray(sb)) {
-      return sb;
-    }
-    return null;
-  };
-  const shipment = obj["shipment"];
-  if (typeof shipment === "object" && shipment !== null && !Array.isArray(shipment)) {
-    const found = tryPath(shipment);
-    if (found) return found;
-  }
-  return tryPath(obj);
-}
-function globToRegex(pattern) {
-  const special = ".+^${}()|[]\\";
-  let r = "";
-  for (let i = 0; i < pattern.length; i++) {
-    const ch = pattern[i] ?? "";
-    if (ch === "*") {
-      if (pattern[i + 1] === "*") {
-        r += ".*";
-        i++;
-      } else {
-        r += "[^/]*";
-      }
-    } else if (ch === "?") {
-      r += "[^/]";
-    } else if (special.includes(ch)) {
-      r += "\\" + ch;
-    } else {
-      r += ch;
-    }
-  }
-  return new RegExp(`^${r}$`);
-}
-function dateToStamp(d) {
-  const pad2 = (n) => String(n).padStart(2, "0");
-  return String(d.getUTCFullYear()) + pad2(d.getUTCMonth() + 1) + pad2(d.getUTCDate()) + pad2(d.getUTCHours()) + pad2(d.getUTCMinutes()) + pad2(d.getUTCSeconds());
-}
-function extractStampToken(filename) {
-  if (!filename.endsWith(".sql")) return null;
-  const base = filename.slice(0, -4);
-  const parts = base.split("_");
-  const first = parts[0];
-  if (!first || !/^\d{14}$/.test(first)) return null;
-  const second = parts[1];
-  if (second && /^\d{2}$/.test(second)) {
-    return `${first}_${second}`;
-  }
-  return first;
-}
-function readShipmentConfig(cwd) {
-  const dir = cwd ?? process.cwd();
-  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: [] };
-  const parentRef = typeof section["project_ref"] === "string" ? section["project_ref"] : null;
-  const previewBranches = [];
-  const rawBranches = section["preview_branches"];
-  if (Array.isArray(rawBranches)) {
-    for (const b of rawBranches) {
-      if (typeof b !== "object" || b === null || Array.isArray(b)) continue;
-      const entry = b;
-      if (typeof entry["branch"] !== "string" || typeof entry["project_ref"] !== "string")
-        continue;
-      previewBranches.push({
-        branch: entry["branch"],
-        project_ref: entry["project_ref"],
-        created_at: typeof entry["created_at"] === "string" ? entry["created_at"] : void 0
-      });
-    }
-  }
-  return { parentRef, previewBranches };
-}
-function readGitConfig(cwd) {
-  const dir = cwd ?? process.cwd();
-  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)) {
-    return { ...GIT_DEFAULTS };
-  }
-  const bcObj = bc;
-  const production = typeof bcObj["production"] === "string" && bcObj["production"] ? bcObj["production"] : "main";
-  const protectedArr = [];
-  const rawProtected = bcObj["protected"];
-  if (Array.isArray(rawProtected)) {
-    for (const p of rawProtected) {
-      if (typeof p === "string" && p) protectedArr.push(p);
-    }
-  }
-  if (protectedArr.length === 0) protectedArr.push(production);
-  const integration = typeof bcObj["integration"] === "string" && bcObj["integration"] ? bcObj["integration"] : null;
-  return { production, protected: protectedArr, integration };
-}
-function readDbPaths(cwd) {
-  const dir = cwd ?? process.cwd();
-  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];
-  const rawPaths = section["db_paths"];
-  if (!Array.isArray(rawPaths) || rawPaths.length === 0)
-    return [...DEFAULT_DB_PATHS];
-  const paths = [];
-  for (const p of rawPaths) {
-    if (typeof p === "string" && p) paths.push(p);
-  }
-  return paths.length > 0 ? paths : [...DEFAULT_DB_PATHS];
-}
-function detectDbChanged(opts = {}) {
-  const cwd = opts.cwd ?? process.cwd();
-  const run = opts.run ?? defaultRun;
-  const base = opts.base ?? readGitConfig(cwd).production;
-  const dbPaths = opts.dbPaths ?? readDbPaths(cwd);
-  if (dbPaths.length === 0) return false;
-  const regexes = dbPaths.map(globToRegex);
-  let output;
-  try {
-    output = run("git", ["diff", "--name-only", `origin/${base}...HEAD`]);
-  } catch {
-    return false;
-  }
-  const changedFiles = output.split("\n").map((l) => l.trim()).filter(Boolean);
-  return changedFiles.some((file) => regexes.some((re) => re.test(file)));
-}
-function defaultListDir(dir) {
-  try {
-    return fs5.readdirSync(dir);
-  } catch {
-    return [];
-  }
-}
-function generateMonotonicTimestamp(opts = {}) {
-  const cwd = opts.cwd ?? process.cwd();
-  const now = opts.now ?? /* @__PURE__ */ new Date();
-  const listDir = opts.listDir ?? defaultListDir;
-  const migrationsDir = path7.join(cwd, "supabase", "migrations");
-  const files = listDir(migrationsDir);
-  const existingStamps = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const token = extractStampToken(file);
-    if (token) existingStamps.add(token);
-  }
-  let maxStamp = "";
-  for (const s of existingStamps) {
-    if (s > maxStamp) maxStamp = s;
-  }
-  const computed = dateToStamp(now);
-  if (computed > maxStamp && !existingStamps.has(computed)) {
-    return computed;
-  }
-  const collisionBase14 = computed > maxStamp ? computed : maxStamp.slice(0, 14);
-  for (let i = 1; i <= 99; i++) {
-    const suffix = String(i).padStart(2, "0");
-    const candidate = `${collisionBase14}_${suffix}`;
-    if (!existingStamps.has(candidate) && candidate > maxStamp) {
-      return candidate;
-    }
-  }
-  return `${collisionBase14}_99`;
-}
-async function pollGhPreviewCheck(opts = {}) {
-  const run = opts.run ?? defaultRun;
-  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve16) => setTimeout(resolve16, ms)));
-  const maxPolls = opts.maxPolls ?? 20;
-  const intervalMs = opts.intervalMs ?? 15e3;
-  if (!opts.prNumber) {
-    return {
-      status: "pending_pr",
-      reason: "No PR number \u2014 branch has no open pull request yet."
-    };
-  }
-  try {
-    run("gh", ["--version"]);
-  } catch {
-    return {
-      status: "blocked",
-      reason: "gh CLI not available"
-    };
-  }
-  const prNumber = opts.prNumber;
-  for (let poll = 0; poll < maxPolls; poll++) {
-    if (poll > 0) {
-      await sleep3(intervalMs);
-    }
-    let checksOutput;
-    try {
-      try {
-        checksOutput = run("gh", [
-          "pr",
-          "checks",
-          prNumber,
-          "--json",
-          "name,bucket,state"
-        ]);
-      } catch {
-        checksOutput = run("gh", [
-          "pr",
-          "checks",
-          prNumber,
-          "--json",
-          "name,state"
-        ]);
-      }
-    } catch {
-      if (poll === maxPolls - 1) {
-        return {
-          status: "blocked",
-          reason: `gh pr checks failed after ${maxPolls} polls`
-        };
-      }
-      continue;
-    }
-    let checks;
-    try {
-      const parsed = JSON.parse(checksOutput);
-      checks = Array.isArray(parsed) ? parsed : [];
-    } catch {
-      checks = [];
-    }
-    const supabaseCheck = checks.find(
-      (c) => typeof c["name"] === "string" && c["name"].toLowerCase().includes("supabase preview")
-    );
-    if (!supabaseCheck) {
-      continue;
-    }
-    const bucket = typeof supabaseCheck["bucket"] === "string" ? supabaseCheck["bucket"].toLowerCase() : null;
-    const state = typeof supabaseCheck["state"] === "string" ? supabaseCheck["state"].toLowerCase() : null;
-    if (bucket === "pass") {
-      return { status: "passed", reason: "Supabase Preview check passed." };
-    }
-    if (bucket === "skipping") {
-      return {
-        status: "skipped",
-        reason: "Supabase Preview check skipped at CI."
-      };
-    }
-    if (bucket === "fail" || bucket === "cancel") {
-      return {
-        status: "blocked",
-        reason: `Supabase Preview check ${bucket}ed.`
-      };
-    }
-    if (state === "success") {
-      return { status: "passed", reason: "Supabase Preview check passed." };
-    }
-    if (state === "skipped" || state === "neutral") {
-      return {
-        status: "skipped",
-        reason: "Supabase Preview check skipped at CI."
-      };
-    }
-    if (state === "failure" || state === "cancelled" || state === "error" || state === "timed_out" || state === "stale" || state === "action_required") {
-      return {
-        status: "blocked",
-        reason: `Supabase Preview check ${state}.`
-      };
-    }
-  }
-  const minutesStr = Math.round(maxPolls * intervalMs / 6e4);
-  return {
-    status: "blocked",
-    reason: `Supabase Preview check still pending after ${minutesStr} min (${maxPolls} polls)`
-  };
-}
-var GIT_DEFAULTS, DEFAULT_DB_PATHS;
-var init_supabase = __esm({
-  "src/lib/supabase.ts"() {
-    "use strict";
-    GIT_DEFAULTS = {
-      production: "main",
-      protected: ["main"],
-      integration: null
-    };
-    DEFAULT_DB_PATHS = [
-      "supabase/**",
-      "apps/backend/**",
-      "packages/**/db/**"
-    ];
-  }
-});
-
 // src/lib/branch-checkout.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-function defaultRun2(cmd, args, cwd) {
-  const result = spawnSync7(cmd, args, {
+import { spawnSync as spawnSync9 } from "node:child_process";
+function defaultRun3(cmd, args, cwd) {
+  const result = spawnSync9(cmd, args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -30325,7 +31295,7 @@ function defaultRun2(cmd, args, cwd) {
 function makeRun(cwd, userRun) {
   if (userRun) return userRun;
   return (cmd, args) => {
-    const r = defaultRun2(cmd, args, cwd);
+    const r = defaultRun3(cmd, args, cwd);
     if (r.status !== 0) {
       const msg = r.stderr.trim();
       throw new Error(
@@ -30346,7 +31316,7 @@ function makeRunRaw(cwd, userRun) {
       }
     };
   }
-  return (cmd, args) => defaultRun2(cmd, args, cwd);
+  return (cmd, args) => defaultRun3(cmd, args, cwd);
 }
 function checkoutBranch(opts) {
   const cwd = opts.cwd ?? process.cwd();
@@ -30562,8 +31532,8 @@ var init_branch = __esm({
 
 // src/lib/bump.ts
 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";
+import { join as join25, relative as relative5, resolve as resolve3 } from "node:path";
+import { spawnSync as spawnSync10 } from "node:child_process";
 function parsePnpmWorkspaceGlobs(raw) {
   const lines = raw.split("\n");
   const globs = [];
@@ -30592,18 +31562,18 @@ async function expandGlob(cwd, glob) {
   if (parts.length !== 2 || parts[1] !== "*") {
     return [];
   }
-  const parentDir = join24(cwd, parts[0]);
+  const parentDir = join25(cwd, parts[0]);
   let dirs;
   try {
     const entries = await readdir4(parentDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory()).map((e) => join24(parentDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory()).map((e) => join25(parentDir, e.name));
   } catch {
     return [];
   }
   const results = [];
   for (const dir of dirs) {
     try {
-      await access5(join24(dir, "package.json"));
+      await access5(join25(dir, "package.json"));
       results.push(dir);
     } catch {
     }
@@ -30614,7 +31584,7 @@ async function buildPackageMap(cwd) {
   const map = /* @__PURE__ */ new Map();
   let globs = [];
   try {
-    const raw = await readFile19(join24(cwd, "pnpm-workspace.yaml"), "utf-8");
+    const raw = await readFile19(join25(cwd, "pnpm-workspace.yaml"), "utf-8");
     globs = parsePnpmWorkspaceGlobs(raw);
   } catch {
   }
@@ -30622,7 +31592,7 @@ async function buildPackageMap(cwd) {
     const dirs = await expandGlob(cwd, glob);
     for (const dir of dirs) {
       try {
-        const pkgRaw = await readFile19(join24(dir, "package.json"), "utf-8");
+        const pkgRaw = await readFile19(join25(dir, "package.json"), "utf-8");
         const pkg = JSON.parse(pkgRaw);
         const name = pkg.name ?? relative5(cwd, dir);
         map.set(dir, { name, dir });
@@ -30700,7 +31670,7 @@ function compareSemver(a, b) {
   return 0;
 }
 function gitShowFile(cwd, ref, relPath) {
-  const result = spawnSync8("git", ["show", `${ref}:${relPath}`], {
+  const result = spawnSync10("git", ["show", `${ref}:${relPath}`], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -30765,7 +31735,7 @@ async function runBump(opts) {
   const prereleaseId = opts?.prereleaseId;
   const baseBranch = await readBaseBranch(cwd);
   const baseRef = resolveBaseRef(cwd, baseBranch);
-  const diffResult = spawnSync8(
+  const diffResult = spawnSync10(
     "git",
     ["diff", "--name-only", `${baseRef}...HEAD`],
     {
@@ -30781,7 +31751,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 = join24(cwd, "package.json");
+  const rootPkgPath = join25(cwd, "package.json");
   const changedPackageDirs = /* @__PURE__ */ new Set();
   for (const absFile of changedFiles) {
     const owner = findOwningPackage(absFile, packageDirs);
@@ -30792,19 +31762,19 @@ async function runBump(opts) {
   const entries = [];
   for (const pkgDir of changedPackageDirs) {
     const pkgInfo = packageMap.get(pkgDir);
-    const pkgJsonPath = join24(pkgDir, "package.json");
+    const pkgJsonPath = join25(pkgDir, "package.json");
     if (pkgJsonPath === rootPkgPath) continue;
     const versionFileCandidates = [
       { abs: pkgJsonPath, rel: relative5(cwd, pkgJsonPath).replace(/\\/g, "/") }
     ];
-    const tauriConfPath = join24(pkgDir, "src-tauri", "tauri.conf.json");
+    const tauriConfPath = join25(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 = join24(pkgDir, "app.json");
+    const appJsonPath = join25(pkgDir, "app.json");
     const appJsonRelPath = relative5(cwd, appJsonPath).replace(/\\/g, "/");
     try {
       await access5(appJsonPath);
@@ -30876,7 +31846,7 @@ async function runBump(opts) {
       }
       updatedVersionFiles.push(rel);
     }
-    const changelogPath = join24(pkgDir, "CHANGELOG.md");
+    const changelogPath = join25(pkgDir, "CHANGELOG.md");
     const changelogUpdated = await prependChangelog(
       changelogPath,
       pkgInfo.name,
@@ -30986,7 +31956,7 @@ var init_bump2 = __esm({
 });
 
 // src/lib/ship.ts
-import { execSync as execSync5, spawnSync as spawnSync9 } from "node:child_process";
+import { execSync as execSync5, spawnSync as spawnSync11 } from "node:child_process";
 import { relative as relative6 } from "node:path";
 function assertValidBranchName2(branch, label) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -31018,7 +31988,7 @@ async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Prom
   let totalGhErrors = 0;
   let iteration = 0;
   while (Date.now() < deadline) {
-    const ghResult = spawnSync9(
+    const ghResult = spawnSync11(
       "gh",
       ["pr", "checks", feat, "--json", "name,state,bucket"],
       {
@@ -31169,7 +32139,7 @@ ${statusOut.trim()}`
       ...e.changelogUpdated ? [relative6(cwd, e.packageDir).replace(/\\/g, "/") + "/CHANGELOG.md"] : []
     ]);
     if (toStage.length > 0) {
-      const addResult = spawnSync9("git", ["add", "--", ...toStage], {
+      const addResult = spawnSync11("git", ["add", "--", ...toStage], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -31179,13 +32149,13 @@ ${statusOut.trim()}`
           `Failed to stage bump files: ${addResult.stderr?.trim() ?? addResult.error?.message}`
         );
       }
-      const commitResult = spawnSync9(
+      const commitResult = spawnSync11(
         "git",
         ["commit", "-m", "chore(release): bump versions"],
         { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       );
       if (commitResult.status !== 0 || commitResult.error) {
-        spawnSync9(
+        spawnSync11(
           "git",
           ["restore", "--staged", "--worktree", "--", ...toStage],
           {
@@ -31230,7 +32200,7 @@ ${statusOut.trim()}`
     } else {
       createArgs.push("--body", defaultPrBody(feat, base));
     }
-    const createResult = spawnSync9("gh", createArgs, {
+    const createResult = spawnSync11("gh", createArgs, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -31261,7 +32231,7 @@ ${statusOut.trim()}`
   });
   let mergeCommit = null;
   try {
-    const prViewResult = spawnSync9(
+    const prViewResult = spawnSync11(
       "gh",
       ["pr", "view", feat, "--json", "state,mergeCommit"],
       {
@@ -31419,14 +32389,14 @@ var init_ship2 = __esm({
 
 // src/lib/scaffold-publish-workflow.ts
 import * as fs6 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 async function runScaffoldPublishWorkflow(opts) {
   await Promise.resolve();
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const projectDir = path8.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path9.resolve(opts?.projectDir ?? process.cwd());
   const templatesDir = opts?.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path8.join(
+  const templatePath = path9.join(
     templatesDir,
     "github-workflows",
     "publish.yml"
@@ -31437,7 +32407,7 @@ async function runScaffoldPublishWorkflow(opts) {
     );
   }
   const templateContent = fs6.readFileSync(templatePath, "utf-8");
-  const targetPath = path8.join(
+  const targetPath = path9.join(
     projectDir,
     ".github",
     "workflows",
@@ -31461,7 +32431,7 @@ async function runScaffoldPublishWorkflow(opts) {
       );
     }
   }
-  const targetDir = path8.dirname(targetPath);
+  const targetDir = path9.dirname(targetPath);
   fs6.mkdirSync(targetDir, { recursive: true });
   fs6.writeFileSync(targetPath, templateContent, "utf-8");
   return { status: "written", path: targetPath };
@@ -31558,7 +32528,7 @@ var init_atomic_write = __esm({
 
 // src/lib/ci-init.ts
 import * as fs8 from "node:fs";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 function tryReadJson(filePath) {
   try {
     return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
@@ -31580,27 +32550,27 @@ function hasDevDep(pkg, name) {
 function detectPlatforms(projectDir) {
   const detected = /* @__PURE__ */ new Set();
   const dirsToScan = [projectDir];
-  const appsDir = path9.join(projectDir, "apps");
+  const appsDir = path10.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(path9.join(appsDir, entry.name));
+          dirsToScan.push(path10.join(appsDir, entry.name));
         }
       }
     } catch {
     }
   }
   for (const dir of dirsToScan) {
-    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"))) {
+    const pkg = tryReadJson(path10.join(dir, "package.json"));
+    if (fs8.existsSync(path10.join(dir, "next.config.ts")) || fs8.existsSync(path10.join(dir, "next.config.js")) || fs8.existsSync(path10.join(dir, "next.config.mjs"))) {
       detected.add("next_js");
     }
     if (hasDep(pkg, "@nestjs/core")) {
       detected.add("nestjs");
     }
-    if (fs8.existsSync(path9.join(dir, "tauri.conf.json")) || fs8.existsSync(path9.join(dir, "src-tauri"))) {
+    if (fs8.existsSync(path10.join(dir, "tauri.conf.json")) || fs8.existsSync(path10.join(dir, "src-tauri"))) {
       detected.add("tauri");
     }
     if (hasDevDep(pkg, "@types/vscode")) {
@@ -31611,7 +32581,7 @@ function detectPlatforms(projectDir) {
       detected.add("expo");
     }
   }
-  const packagesDir = path9.join(projectDir, "packages");
+  const packagesDir = path10.join(projectDir, "packages");
   if (fs8.existsSync(packagesDir)) {
     try {
       const pkgEntries = fs8.readdirSync(packagesDir, { withFileTypes: true });
@@ -31648,10 +32618,10 @@ function buildDefaultCiConfig(platforms) {
 }
 async function runCiInit(opts) {
   await Promise.resolve();
-  const projectDir = path9.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path10.resolve(opts?.projectDir ?? process.cwd());
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const ciPath = path9.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path10.join(projectDir, ".codebyplan", "ci.json");
   const platforms = detectPlatforms(projectDir);
   if (dryRun) {
     return { status: "dry_run", path: ciPath, platforms };
@@ -31696,7 +32666,7 @@ async function runCiInit(opts) {
       platforms: newPlatforms.length > 0 ? newPlatforms : platforms
     };
   }
-  const codebyplanDir = path9.join(projectDir, ".codebyplan");
+  const codebyplanDir = path10.join(projectDir, ".codebyplan");
   fs8.mkdirSync(codebyplanDir, { recursive: true });
   writeJsonAtomic(ciPath, newConfig);
   return { status: "written", path: ciPath, platforms };
@@ -31905,7 +32875,7 @@ var init_ci_init = __esm({
 
 // src/lib/scaffold-ci-workflow.ts
 import * as fs9 from "node:fs";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 function substituteTokens(template, tokens) {
   let result = template;
   for (const [token, value] of Object.entries(tokens)) {
@@ -31915,7 +32885,7 @@ function substituteTokens(template, tokens) {
 }
 function detectPnpmVersionFromPackageJson(projectDir) {
   try {
-    const pkgPath = path10.join(projectDir, "package.json");
+    const pkgPath = path11.join(projectDir, "package.json");
     const raw = fs9.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(raw);
     const pm = pkg.packageManager;
@@ -31932,7 +32902,7 @@ function detectPnpmVersionFromPackageJson(projectDir) {
 }
 function detectStrictEnforcedFromCiJson(projectDir) {
   try {
-    const ciJsonPath = path10.join(projectDir, ".codebyplan", "ci.json");
+    const ciJsonPath = path11.join(projectDir, ".codebyplan", "ci.json");
     const raw = fs9.readFileSync(ciJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.workflow?.strict_check_enforced === true;
@@ -31944,12 +32914,12 @@ async function runScaffoldCiWorkflow(opts) {
   await Promise.resolve();
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const projectDir = path10.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path11.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 = path10.join(templatesDir, "github-workflows", "ci.yml");
+  const templatePath = path11.join(templatesDir, "github-workflows", "ci.yml");
   if (!fs9.existsSync(templatePath)) {
     throw new Error(
       `scaffold-ci-workflow: template not found at ${templatePath}`
@@ -31962,7 +32932,7 @@ async function runScaffoldCiWorkflow(opts) {
     STRICT_NAME_SUFFIX: strictEnforced ? "" : " (report-only)",
     STRICT_CONTINUE_ON_ERROR_LINE: strictEnforced ? "" : "\n    continue-on-error: true"
   });
-  const targetPath = path10.join(projectDir, ".github", "workflows", "ci.yml");
+  const targetPath = path11.join(projectDir, ".github", "workflows", "ci.yml");
   if (dryRun) {
     return { status: "dry_run", path: targetPath };
   }
@@ -31981,7 +32951,7 @@ async function runScaffoldCiWorkflow(opts) {
       );
     }
   }
-  const targetDir = path10.dirname(targetPath);
+  const targetDir = path11.dirname(targetPath);
   fs9.mkdirSync(targetDir, { recursive: true });
   const tmpPath = targetPath + ".tmp";
   try {
@@ -32005,10 +32975,10 @@ var init_scaffold_ci_workflow = __esm({
 
 // src/lib/gh-required-checks.ts
 import * as fs10 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { execSync as execSync6 } from "node:child_process";
 function readCiJson(projectDir) {
-  const ciPath = path11.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path12.join(projectDir, ".codebyplan", "ci.json");
   if (!fs10.existsSync(ciPath)) {
     return {
       platforms: {},
@@ -32027,15 +32997,15 @@ function readCiJson(projectDir) {
   }
 }
 function writeCiJsonAtomic(projectDir, config) {
-  const ciPath = path11.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path12.join(projectDir, ".codebyplan", "ci.json");
   writeJsonAtomic(ciPath, config);
 }
 function enforceRequiredCheck(opts) {
-  const projectDir = path11.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path12.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 = path11.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path12.join(projectDir, ".codebyplan", "ci.json");
   const config = readCiJson(projectDir);
   if (config.workflow?.required_check_enforced === true) {
     return { status: "already_enforced", path: ciPath };
@@ -32442,9 +33412,9 @@ var init_ci = __esm({
 
 // src/lib/cd-init.ts
 import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 function detectSurfaces(projectDir) {
-  const shipmentPath = path12.join(projectDir, ".codebyplan", "shipment.json");
+  const shipmentPath = path13.join(projectDir, ".codebyplan", "shipment.json");
   let shipment;
   try {
     shipment = JSON.parse(fs11.readFileSync(shipmentPath, "utf-8"));
@@ -32497,10 +33467,10 @@ function buildDefaultCdConfig(rawSurfaceKeys) {
 }
 async function runCdInit(opts) {
   await Promise.resolve();
-  const projectDir = path12.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path13.resolve(opts?.projectDir ?? process.cwd());
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const cdPath = path12.join(projectDir, ".codebyplan", "cd.json");
+  const cdPath = path13.join(projectDir, ".codebyplan", "cd.json");
   const rawSurfaceKeys = detectSurfaces(projectDir);
   const seen = /* @__PURE__ */ new Set();
   const surfaces = [];
@@ -32541,7 +33511,7 @@ async function runCdInit(opts) {
       surfaces: newSurfaces
     };
   }
-  const codebyplanDir = path12.join(projectDir, ".codebyplan");
+  const codebyplanDir = path13.join(projectDir, ".codebyplan");
   fs11.mkdirSync(codebyplanDir, { recursive: true });
   writeJsonAtomic(cdPath, newConfig);
   return { status: "written", path: cdPath, surfaces };
@@ -32631,14 +33601,14 @@ var init_cd_init = __esm({
 
 // src/lib/scaffold-cd-workflow.ts
 import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 async function scaffoldOneWorkflow(templateName, targetName, opts) {
   await Promise.resolve();
   const dryRun = opts.dryRun ?? false;
   const force = opts.force ?? false;
-  const projectDir = path13.resolve(opts.projectDir ?? process.cwd());
+  const projectDir = path14.resolve(opts.projectDir ?? process.cwd());
   const templatesDir = opts.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path13.join(
+  const templatePath = path14.join(
     templatesDir,
     "github-workflows",
     templateName
@@ -32649,7 +33619,7 @@ async function scaffoldOneWorkflow(templateName, targetName, opts) {
     );
   }
   const templateContent = fs12.readFileSync(templatePath, "utf-8");
-  const targetPath = path13.join(projectDir, ".github", "workflows", targetName);
+  const targetPath = path14.join(projectDir, ".github", "workflows", targetName);
   if (dryRun) {
     return { status: "dry_run", path: targetPath };
   }
@@ -32668,7 +33638,7 @@ async function scaffoldOneWorkflow(templateName, targetName, opts) {
       );
     }
   }
-  const targetDir = path13.dirname(targetPath);
+  const targetDir = path14.dirname(targetPath);
   fs12.mkdirSync(targetDir, { recursive: true });
   const tmpPath = targetPath + ".tmp";
   try {
@@ -33344,7 +34314,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 join31 } from "node:path";
+import { dirname as dirname13, join as join32 } from "node:path";
 function fetchLatestVersion() {
   try {
     return execFileSync("npm", ["view", "codebyplan", "version"], {
@@ -33368,11 +34338,11 @@ function detectPackageManager2(gitRoot) {
   let dir = process.cwd();
   const stopAt = gitRoot ?? null;
   while (true) {
-    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 (existsSync10(join32(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync10(join32(dir, "yarn.lock"))) return "yarn";
+    if (existsSync10(join32(dir, "package-lock.json"))) return "npm";
     if (stopAt !== null && dir === stopAt) break;
-    const parent = dirname12(dir);
+    const parent = dirname13(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -33390,7 +34360,7 @@ function buildInstallCommand2(pm) {
 }
 async function resolveGuard(gitRoot, currentBranch) {
   if (gitRoot !== null) {
-    const canonicalPkgPath = join31(
+    const canonicalPkgPath = join32(
       gitRoot,
       "packages",
       "codebyplan-package",
@@ -33414,10 +34384,10 @@ async function resolveGuard(gitRoot, currentBranch) {
       let gitJsonPath;
       if (found.path.endsWith("/repo.json")) {
         const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join31(dir, "git.json");
+        gitJsonPath = join32(dir, "git.json");
       } else {
         const legacyDir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join31(legacyDir, ".codebyplan", "git.json");
+        gitJsonPath = join32(legacyDir, ".codebyplan", "git.json");
       }
       const raw = readFileSync11(gitJsonPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -33502,7 +34472,7 @@ __export(upload_e2e_images_exports, {
   runUploadE2eImagesCommand: () => runUploadE2eImagesCommand
 });
 import { readFile as readFile20 } from "node:fs/promises";
-import { join as join32, basename, resolve as resolve10 } from "node:path";
+import { join as join33, basename as basename2, 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(/\/$/, "");
@@ -33537,7 +34507,7 @@ function parseArgs(args) {
 async function readE2eConfig(projectPath) {
   try {
     const raw = await readFile20(
-      join32(projectPath, ".codebyplan", "e2e.json"),
+      join33(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -33578,8 +34548,8 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
       continue;
     const isNew = status === "A";
     results.push({
-      absolutePath: join32(projectPath, filePath),
-      filename: basename(filePath),
+      absolutePath: join33(projectPath, filePath),
+      filename: basename2(filePath),
       framework: frameworkName,
       is_new: isNew
     });
@@ -33594,11 +34564,11 @@ function deriveTestName(absolutePath) {
       return seg.replace(".spec.ts-snapshots", "");
     }
   }
-  return basename(absolutePath, ".png");
+  return basename2(absolutePath, ".png");
 }
 function buildManifestItem(png) {
   const testName = deriveTestName(png.absolutePath);
-  const pageOrScreen = basename(png.absolutePath, ".png");
+  const pageOrScreen = basename2(png.absolutePath, ".png");
   return {
     filename: png.filename,
     test_name: testName,
@@ -33754,8 +34724,8 @@ __export(arch_map_exports, {
 });
 import { readFile as readFile21, writeFile as writeFile17 } from "node:fs/promises";
 import { existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
-import { join as join33 } from "node:path";
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { join as join34 } from "node:path";
+import { spawnSync as spawnSync12 } from "node:child_process";
 function normalizeModulePath(modulePath) {
   return modulePath.replace(/\/+$/, "");
 }
@@ -33779,7 +34749,7 @@ async function resolveCodebyplanDir(startDir) {
   }
 }
 async function readArchitectureConfig(codebyplanDir) {
-  const filePath = join33(codebyplanDir, "architecture.json");
+  const filePath = join34(codebyplanDir, "architecture.json");
   try {
     const raw = await readFile21(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -33792,12 +34762,12 @@ async function readArchitectureConfig(codebyplanDir) {
   }
 }
 async function writeArchitectureConfig(codebyplanDir, config) {
-  const filePath = join33(codebyplanDir, "architecture.json");
+  const filePath = join34(codebyplanDir, "architecture.json");
   await writeFile17(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function resolveGitSha(modulePath, cwd) {
   try {
-    const result = spawnSync10(
+    const result = spawnSync12(
       "git",
       ["log", "--format=%H", "-1", "--", modulePath],
       { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -33811,7 +34781,7 @@ function resolveGitSha(modulePath, cwd) {
 }
 async function discoverModulePaths(projectRoot) {
   const paths = [];
-  const workspacePath = join33(projectRoot, "pnpm-workspace.yaml");
+  const workspacePath = join34(projectRoot, "pnpm-workspace.yaml");
   let patterns = [];
   try {
     const raw = await readFile21(workspacePath, "utf-8");
@@ -33838,7 +34808,7 @@ async function discoverModulePaths(projectRoot) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join33(projectRoot, dir);
+      const absDir = join34(projectRoot, dir);
       try {
         if (existsSync11(absDir)) {
           const entries = readdirSync4(absDir, { withFileTypes: true });
@@ -33851,7 +34821,7 @@ async function discoverModulePaths(projectRoot) {
       } catch {
       }
     } else if (!pattern.includes("*")) {
-      const absPath = join33(projectRoot, pattern);
+      const absPath = join34(projectRoot, pattern);
       if (existsSync11(absPath)) {
         paths.push(pattern);
       }
@@ -33859,7 +34829,7 @@ async function discoverModulePaths(projectRoot) {
   }
   const crossCutting = ["supabase", ".github", "scripts"];
   for (const dir of crossCutting) {
-    const absPath = join33(projectRoot, dir);
+    const absPath = join34(projectRoot, dir);
     try {
       if (existsSync11(absPath)) {
         paths.push(dir);
@@ -34045,7 +35015,7 @@ 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 = join33(repoRoot, stampedEntry.map_file);
+  const mapAbsPath = join34(repoRoot, stampedEntry.map_file);
   let mapContent = null;
   try {
     mapContent = await readFile21(mapAbsPath, "utf-8");
@@ -34251,18 +35221,18 @@ var init_worktree_port_resolver = __esm({
 
 // src/lib/migrate-local-config.ts
 import { mkdir as mkdir9, readFile as readFile22, unlink as unlink5, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join34(projectPath, ".codebyplan.json");
+  return join35(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join34(projectPath, ".codebyplan.local.json");
+  return join35(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join34(projectPath, ".codebyplan");
+  return join35(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join34(projectPath, ".codebyplan", "repo.json");
+  return join35(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
   const { stat: stat3 } = await import("node:fs/promises");
@@ -34356,7 +35326,7 @@ async function runLocalMigration(projectPath) {
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
   await writeFile18(
-    join34(projectPath, ".codebyplan", "repo.json"),
+    join35(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -34369,7 +35339,7 @@ async function runLocalMigration(projectPath) {
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
   await writeFile18(
-    join34(projectPath, ".codebyplan", "server.json"),
+    join35(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -34378,7 +35348,7 @@ async function runLocalMigration(projectPath) {
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
   await writeFile18(
-    join34(projectPath, ".codebyplan", "git.json"),
+    join35(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
@@ -34386,35 +35356,35 @@ async function runLocalMigration(projectPath) {
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
   await writeFile18(
-    join34(projectPath, ".codebyplan", "shipment.json"),
+    join35(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
   await writeFile18(
-    join34(projectPath, ".codebyplan", "vendor.json"),
+    join35(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
   await writeFile18(
-    join34(projectPath, ".codebyplan", "e2e.json"),
+    join35(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
   await writeFile18(
-    join34(projectPath, ".codebyplan", "eslint.json"),
+    join35(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/eslint.json");
   if (!deviceWrittenByHelper) {
     await writeFile18(
-      join34(projectPath, ".codebyplan", "device.local.json"),
+      join35(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -34426,7 +35396,7 @@ async function runLocalMigration(projectPath) {
       "Migration write incomplete: .codebyplan/repo.json was not persisted. Re-run migration to retry from a clean state."
     );
   }
-  const gitignorePath = join34(projectPath, ".gitignore");
+  const gitignorePath = join35(projectPath, ".gitignore");
   try {
     const gitignoreContent = await readFile22(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
@@ -34490,7 +35460,7 @@ __export(config_exports, {
   runConfigMigrate: () => runConfigMigrate
 });
 import { mkdir as mkdir10, readFile as readFile23, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -34523,7 +35493,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join35(projectPath, ".codebyplan");
+  const codebyplanDir = join36(projectPath, ".codebyplan");
   const {
     resolvedWorktreeId,
     portAllocations,
@@ -34616,7 +35586,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   ];
   let anyUpdated = false;
   for (const { name, payload, createOnly } of files) {
-    const filePath = join35(codebyplanDir, name);
+    const filePath = join36(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
@@ -34636,7 +35606,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 async function readRepoConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "repo.json"),
+      join36(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34647,7 +35617,7 @@ async function readRepoConfig(projectPath) {
 async function readServerConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "server.json"),
+      join36(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34658,7 +35628,7 @@ async function readServerConfig(projectPath) {
 async function readGitConfig2(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "git.json"),
+      join36(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34669,7 +35639,7 @@ async function readGitConfig2(projectPath) {
 async function readShipmentConfig2(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "shipment.json"),
+      join36(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34680,7 +35650,7 @@ async function readShipmentConfig2(projectPath) {
 async function readVendorConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "vendor.json"),
+      join36(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34691,7 +35661,7 @@ async function readVendorConfig(projectPath) {
 async function readE2eConfig2(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "e2e.json"),
+      join36(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34702,7 +35672,7 @@ async function readE2eConfig2(projectPath) {
 async function readServerLocalConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join35(projectPath, ".codebyplan", "server.local.json"),
+      join36(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34775,7 +35745,7 @@ var init_config = __esm({
 
 // src/lib/server-detect.ts
 import { readFile as readFile24, readdir as readdir5, access as access6 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 async function fileExists4(filePath) {
   try {
     await access6(filePath);
@@ -34786,8 +35756,8 @@ async function fileExists4(filePath) {
 }
 function detectPackageManager3(dir) {
   return (async () => {
-    if (await fileExists4(join36(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists4(join36(dir, "yarn.lock"))) return "yarn";
+    if (await fileExists4(join37(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists4(join37(dir, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
@@ -34819,12 +35789,12 @@ function detectPortFromScripts(pkg) {
   return null;
 }
 async function isMonorepo(dir) {
-  return await fileExists4(join36(dir, "turbo.json")) || await fileExists4(join36(dir, "pnpm-workspace.yaml"));
+  return await fileExists4(join37(dir, "turbo.json")) || await fileExists4(join37(dir, "pnpm-workspace.yaml"));
 }
 async function detectServers(projectPath) {
   let pkg;
   try {
-    const raw = await readFile24(join36(projectPath, "package.json"), "utf-8");
+    const raw = await readFile24(join37(projectPath, "package.json"), "utf-8");
     pkg = JSON.parse(raw);
   } catch {
     return {
@@ -34840,13 +35810,13 @@ async function detectServers(projectPath) {
   const mono = await isMonorepo(projectPath);
   const servers = [];
   if (mono) {
-    const appsDir = join36(projectPath, "apps");
+    const appsDir = join37(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 = join36(appsDir, entry.name, "package.json");
+        const appPkgPath = join37(appsDir, entry.name, "package.json");
         try {
           const appRaw = await readFile24(appPkgPath, "utf-8");
           const appPkg = JSON.parse(appRaw);
@@ -35012,7 +35982,7 @@ __export(ports_exports, {
   runPorts: () => runPorts
 });
 import { mkdir as mkdir11, readFile as readFile26, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 function printDetectionResult(result, projectPath) {
   console.log(`
   CodeByPlan Ports - List`);
@@ -35168,8 +36138,8 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // and ServerLocalConfig.port_allocations is typed the same — honest end-to-end.
     port_allocations: portAllocations
   };
-  const codebyplanDir = join37(projectPath, ".codebyplan");
-  const filePath = join37(codebyplanDir, "server.local.json");
+  const codebyplanDir = join38(projectPath, ".codebyplan");
+  const filePath = join38(codebyplanDir, "server.local.json");
   const newJson = JSON.stringify(payload, null, 2) + "\n";
   let currentJson = "";
   try {
@@ -35191,8 +36161,8 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
   );
 }
 async function provisionE2eEnv(projectPath, dryRun) {
-  const relSource = join37("apps", "web", ".env.local");
-  const sourcePath = join37(projectPath, relSource);
+  const relSource = join38("apps", "web", ".env.local");
+  const sourcePath = join38(projectPath, relSource);
   let sourceRaw;
   try {
     sourceRaw = await readFile26(sourcePath, "utf-8");
@@ -35224,8 +36194,8 @@ async function provisionE2eEnv(projectPath, dryRun) {
     );
     return;
   }
-  const codebyplanDir = join37(projectPath, ".codebyplan");
-  const filePath = join37(codebyplanDir, "e2e.env");
+  const codebyplanDir = join38(projectPath, ".codebyplan");
+  const filePath = join38(codebyplanDir, "e2e.env");
   const newContent = lines.join("\n") + "\n";
   let currentContent = "";
   try {
@@ -35510,7 +36480,7 @@ __export(docs_exports, {
 });
 import { existsSync as existsSync13 } from "node:fs";
 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";
+import { dirname as dirname14, isAbsolute as isAbsolute2, join as join39, relative as relative7, sep as sep2 } from "node:path";
 function selectDependencies(deps) {
   const byName = /* @__PURE__ */ new Map();
   for (const dep of deps) {
@@ -35564,12 +36534,12 @@ async function mapWithConcurrency(items, limit, fn) {
 }
 async function resolveExactVersion(projectPath, dep) {
   const candidateDirs = [projectPath];
-  const sourceDir = join38(projectPath, dirname13(dep.sourcePath));
+  const sourceDir = join39(projectPath, dirname14(dep.sourcePath));
   if (sourceDir !== projectPath) candidateDirs.push(sourceDir);
   for (const base of candidateDirs) {
     try {
       const raw = await readFile27(
-        join38(base, "node_modules", dep.name, "package.json"),
+        join39(base, "node_modules", dep.name, "package.json"),
         "utf-8"
       );
       const pkg = JSON.parse(raw);
@@ -35584,7 +36554,7 @@ async function resolveExactVersion(projectPath, dep) {
 async function readVendorDocsPath(projectPath) {
   try {
     const raw = await readFile27(
-      join38(projectPath, ".codebyplan", "vendor.json"),
+      join39(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     const parsed = JSON.parse(raw);
@@ -35597,7 +36567,7 @@ async function readVendorDocsPath(projectPath) {
 }
 async function resolveDocsDir(projectPath, flags) {
   const configured = flags["dir"] ?? await readVendorDocsPath(projectPath) ?? DEFAULT_DOCS_DIR;
-  const absDir = isAbsolute2(configured) ? configured : join38(projectPath, configured);
+  const absDir = isAbsolute2(configured) ? configured : join39(projectPath, configured);
   const rel = relative7(projectPath, absDir);
   const relDir = rel === "" || rel.startsWith("..") ? null : rel.split(sep2).join("/");
   return { absDir, relDir };
@@ -35606,7 +36576,7 @@ async function readDocsLock(absDir) {
   const empty = { generated_at: "", libraries: {} };
   let raw;
   try {
-    raw = await readFile27(join38(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile27(join39(absDir, LOCK_FILE), "utf-8");
   } catch {
     return empty;
   }
@@ -35702,7 +36672,7 @@ function buildTopIndex(outcomes) {
 }
 async function ensureDocsGitignoreEntry(projectPath, relDir, dryRun) {
   const entry = `/${relDir}/`;
-  const gitignorePath = join38(projectPath, ".gitignore");
+  const gitignorePath = join39(projectPath, ".gitignore");
   let existing = "";
   try {
     existing = await readFile27(gitignorePath, "utf-8");
@@ -35725,7 +36695,7 @@ async function markUncovered(dep, exactVersion, ctx) {
   console.log(
     `  uncovered ${dep.name}@${exactVersion || "?"} \u2014 no docs in the library mirror`
   );
-  const libPath = join38(ctx.absDir, libDirName(dep.name));
+  const libPath = join39(ctx.absDir, libDirName(dep.name));
   if (existsSync13(libPath)) {
     if (ctx.dryRun) {
       console.log(`  would remove stale mirror dir ${libPath}`);
@@ -35778,14 +36748,14 @@ async function syncOneLibrary(dep, ctx) {
     }
   }
   const lockEntry = ctx.lock.libraries[dep.name];
-  const libPath = join38(ctx.absDir, libDirName(dep.name));
-  const versionPath = join38(libPath, manifest.resolved_version);
+  const libPath = join39(ctx.absDir, libDirName(dep.name));
+  const versionPath = join39(libPath, manifest.resolved_version);
   if (manifestMatchesLock(manifest, lockEntry)) {
     console.log(`  unchanged ${dep.name}@${manifest.resolved_version}`);
-    if (!ctx.dryRun && !existsSync13(join38(libPath, "INDEX.md"))) {
+    if (!ctx.dryRun && !existsSync13(join39(libPath, "INDEX.md"))) {
       await mkdir12(libPath, { recursive: true });
       await writeFile21(
-        join38(libPath, "INDEX.md"),
+        join39(libPath, "INDEX.md"),
         buildLibIndex(dep.name, manifest),
         "utf-8"
       );
@@ -35807,13 +36777,13 @@ async function syncOneLibrary(dep, ctx) {
       );
       continue;
     }
-    const target = join38(versionPath, rel);
+    const target = join39(versionPath, rel);
     if (sameVersionLockFiles[file.path] === file.content_hash && existsSync13(target)) {
       continue;
     }
     written++;
     if (!ctx.dryRun) {
-      await mkdir12(dirname13(target), { recursive: true });
+      await mkdir12(dirname14(target), { recursive: true });
       await writeFile21(target, file.content, "utf-8");
     }
   }
@@ -35825,7 +36795,7 @@ async function syncOneLibrary(dep, ctx) {
       const rel = sanitizeDocPath(lockedPath);
       if (rel === null) continue;
       removedFiles++;
-      if (!ctx.dryRun) await rm2(join38(versionPath, rel), { force: true });
+      if (!ctx.dryRun) await rm2(join39(versionPath, rel), { force: true });
     }
   }
   let removedVersionDirs = 0;
@@ -35840,13 +36810,13 @@ async function syncOneLibrary(dep, ctx) {
     }
     removedVersionDirs++;
     if (!ctx.dryRun) {
-      await rm2(join38(libPath, entry.name), { recursive: true, force: true });
+      await rm2(join39(libPath, entry.name), { recursive: true, force: true });
     }
   }
   if (!ctx.dryRun) {
     await mkdir12(libPath, { recursive: true });
     await writeFile21(
-      join38(libPath, "INDEX.md"),
+      join39(libPath, "INDEX.md"),
       buildLibIndex(dep.name, manifest),
       "utf-8"
     );
@@ -35900,7 +36870,7 @@ async function runDocsSync() {
   );
   if (!dryRun) {
     await mkdir12(absDir, { recursive: true });
-    await writeFile21(join38(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
+    await writeFile21(join39(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
     const libraries = {};
     for (const o of outcomes) {
       if (o.kind === "synced" || o.kind === "unchanged") {
@@ -35926,7 +36896,7 @@ async function runDocsSync() {
       libraries: sortedLibraries
     };
     await writeFile21(
-      join38(absDir, LOCK_FILE),
+      join39(absDir, LOCK_FILE),
       JSON.stringify(newLock, null, 2) + "\n",
       "utf-8"
     );
@@ -35968,7 +36938,7 @@ async function countFilesRecursively(dirPath) {
   let count = 0;
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      count += await countFilesRecursively(join38(dirPath, entry.name));
+      count += await countFilesRecursively(join39(dirPath, entry.name));
     } else if (entry.isFile()) {
       count++;
     }
@@ -35985,7 +36955,7 @@ async function runDocsStatus() {
 `);
   let raw;
   try {
-    raw = await readFile27(join38(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile27(join39(absDir, LOCK_FILE), "utf-8");
   } catch {
     console.log(
       `  No ${LOCK_FILE} found \u2014 run \`codebyplan docs sync\` first.
@@ -36014,7 +36984,7 @@ async function runDocsStatus() {
   let outOfSync = 0;
   for (const name of names) {
     const entry = lock.libraries[name];
-    const versionPath = join38(absDir, libDirName(name), entry.resolved_version);
+    const versionPath = join39(absDir, libDirName(name), entry.resolved_version);
     const expected = Object.keys(entry.files).length;
     if (!existsSync13(versionPath)) {
       outOfSync++;
@@ -36102,7 +37072,7 @@ var init_docs = __esm({
 
 // src/lib/check-baseline.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 function emptyBaseline() {
   return {
     lint: { known_failing: [] },
@@ -36112,7 +37082,7 @@ function emptyBaseline() {
   };
 }
 function loadBaseline(projectRoot) {
-  const filePath = join39(projectRoot, BASELINE_FILENAME);
+  const filePath = join40(projectRoot, BASELINE_FILENAME);
   try {
     const raw = readFileSync12(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -36136,7 +37106,7 @@ function loadBaseline(projectRoot) {
   }
 }
 function saveBaseline(projectRoot, baseline) {
-  const filePath = join39(projectRoot, BASELINE_FILENAME);
+  const filePath = join40(projectRoot, BASELINE_FILENAME);
   writeFileSync7(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
 }
 function diffBaseline(check, currentFailingPackages, baseline) {
@@ -36186,8 +37156,8 @@ var init_check_baseline = __esm({
 
 // src/lib/check.ts
 import { readFileSync as readFileSync13, existsSync as existsSync14 } from "node:fs";
-import { join as join40 } from "node:path";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { join as join41 } from "node:path";
+import { spawnSync as spawnSync13 } from "node:child_process";
 function hasSentinelValue(arrays) {
   const SENTINELS = /* @__PURE__ */ new Set([
     SUMMARY_UNREADABLE,
@@ -36202,7 +37172,7 @@ function resolveNewFailures(check, failingPackages, baseline, updateBaseline, no
   return diffBaseline(check, failingPackages, baseline);
 }
 function defaultSpawnFn(command, opts) {
-  const result = spawnSync11(command, {
+  const result = spawnSync13(command, {
     shell: true,
     cwd: opts.cwd,
     encoding: "utf-8",
@@ -36254,9 +37224,9 @@ function parseFailingPackagesFromSummary(summaryPath) {
   return Array.from(failing).sort();
 }
 function resolveTurboBin(projectRoot) {
-  const localBin = join40(projectRoot, "node_modules", ".bin", "turbo");
+  const localBin = join41(projectRoot, "node_modules", ".bin", "turbo");
   if (existsSync14(localBin)) return localBin;
-  const workspaceRootBin = join40(
+  const workspaceRootBin = join41(
     projectRoot,
     "..",
     "..",
@@ -36753,7 +37723,7 @@ var init_check2 = __esm({
 
 // src/lib/claude-plan.ts
 import * as fs13 from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 function buildDriftPlan(projectDir, templatesDir, manifest) {
   const packaged = walkTemplates(templatesDir);
   const packagedBySrc = new Map(packaged.map((f) => [f.src, f]));
@@ -36767,8 +37737,8 @@ function buildDriftPlan(projectDir, templatesDir, manifest) {
   };
   for (const pkg of packaged) {
     const inManifest = manifestBySrc.get(pkg.src);
-    const absDest = path14.join(projectDir, ".claude", pkg.dest);
-    const absSrc = path14.join(templatesDir, pkg.src);
+    const absDest = path15.join(projectDir, ".claude", pkg.dest);
+    const absSrc = path15.join(templatesDir, pkg.src);
     if (!inManifest) {
       plan.newOptIn.push({
         packaged: { src: pkg.src, dest: pkg.dest, hash: pkg.hash },
@@ -36817,7 +37787,7 @@ __export(status_exports, {
   runStatus: () => runStatus2
 });
 import * as fs14 from "node:fs";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 import { execSync as execSync9 } from "node:child_process";
 function makeFailSafe(checked_at) {
   return {
@@ -36926,12 +37896,12 @@ async function runStatus2(argv) {
     const latest = fetchLatestVersion();
     const newer = latest !== null && compareSemver(latest, installed) > 0;
     let settings_drift = false;
-    const settingsPath = path15.join(projectDir, ".claude", "settings.json");
-    const baseSettingsPath = path15.join(
+    const settingsPath = path16.join(projectDir, ".claude", "settings.json");
+    const baseSettingsPath = path16.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const hooksJsonPath = path15.join(templatesDir, "hooks", "hooks.json");
+    const hooksJsonPath = path16.join(templatesDir, "hooks", "hooks.json");
     if (fs14.existsSync(settingsPath)) {
       try {
         const settingsRaw = fs14.readFileSync(settingsPath, "utf8");
@@ -37001,10 +37971,10 @@ function emitResult(result, writeCache, quiet, projectDir) {
   const json = JSON.stringify(result, null, 2);
   if (writeCache) {
     try {
-      const cacheDir = path15.join(projectDir, ".codebyplan");
+      const cacheDir = path16.join(projectDir, ".codebyplan");
       fs14.mkdirSync(cacheDir, { recursive: true });
       fs14.writeFileSync(
-        path15.join(cacheDir, "claude-status.local.json"),
+        path16.join(cacheDir, "claude-status.local.json"),
         json + "\n",
         "utf8"
       );
@@ -37148,7 +38118,7 @@ __export(update_exports, {
 });
 import * as fs15 from "node:fs";
 import * as os3 from "node:os";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 async function runUpdate(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -37184,9 +38154,9 @@ async function runUpdate(opts, deps = {}) {
       finalManifestEntries.push(e);
     }
     for (const { packaged, absSrc } of plan.overwriteSafe) {
-      const absDest = path16.join(projectDir, ".claude", packaged.dest);
+      const absDest = path17.join(projectDir, ".claude", packaged.dest);
       if (!opts.dryRun) {
-        fs15.mkdirSync(path16.dirname(absDest), { recursive: true });
+        fs15.mkdirSync(path17.dirname(absDest), { recursive: true });
         fs15.copyFileSync(absSrc, absDest);
         if (opts.verbose) console.log(`updated ${packaged.dest}`);
       } else if (opts.verbose) {
@@ -37199,7 +38169,7 @@ async function runUpdate(opts, deps = {}) {
       absSrc,
       onDiskContent
     } of plan.overwriteHandEdited) {
-      const absDest = path16.join(projectDir, ".claude", packaged.dest);
+      const absDest = path17.join(projectDir, ".claude", packaged.dest);
       const newContent = fs15.readFileSync(absSrc);
       const showDiff = () => {
         console.log(
@@ -37212,7 +38182,7 @@ async function runUpdate(opts, deps = {}) {
       const answer = await promptOverwrite(packaged.dest, opts, showDiff);
       if (answer === "overwrite") {
         if (!opts.dryRun) {
-          fs15.mkdirSync(path16.dirname(absDest), { recursive: true });
+          fs15.mkdirSync(path17.dirname(absDest), { recursive: true });
           fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
@@ -37228,9 +38198,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 = path16.join(projectDir, ".claude", packaged.dest);
+        const absDest = path17.join(projectDir, ".claude", packaged.dest);
         if (!opts.dryRun) {
-          fs15.mkdirSync(path16.dirname(absDest), { recursive: true });
+          fs15.mkdirSync(path17.dirname(absDest), { recursive: true });
           fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
@@ -37242,25 +38212,25 @@ async function runUpdate(opts, deps = {}) {
     for (const e of plan.removedFromPackage) {
       const answer = await promptRemove(e.dest, opts);
       if (answer === "remove") {
-        const absDest = path16.join(projectDir, ".claude", e.dest);
+        const absDest = path17.join(projectDir, ".claude", e.dest);
         if (!opts.dryRun && fs15.existsSync(absDest)) {
           fs15.rmSync(absDest);
-          const claudeDir = path16.join(projectDir, ".claude");
-          let cur = path16.dirname(absDest);
-          while (cur !== claudeDir && cur !== path16.dirname(cur)) {
-            if (path16.dirname(cur) === claudeDir) break;
+          const claudeDir = path17.join(projectDir, ".claude");
+          let cur = path17.dirname(absDest);
+          while (cur !== claudeDir && cur !== path17.dirname(cur)) {
+            if (path17.dirname(cur) === claudeDir) break;
             try {
               fs15.rmdirSync(cur);
               if (opts.verbose)
                 console.log(
-                  `pruned empty dir ${path16.relative(claudeDir, cur)}`
+                  `pruned empty dir ${path17.relative(claudeDir, cur)}`
                 );
-              cur = path16.dirname(cur);
+              cur = path17.dirname(cur);
             } catch (err) {
               const code = err.code;
               if (code !== "ENOTEMPTY" && code !== "ENOENT") {
                 console.warn(
-                  `codebyplan claude: could not prune empty dir ${path16.relative(claudeDir, cur)}: ${err.message}`
+                  `codebyplan claude: could not prune empty dir ${path17.relative(claudeDir, cur)}: ${err.message}`
                 );
               }
               break;
@@ -37272,12 +38242,12 @@ async function runUpdate(opts, deps = {}) {
         if (opts.verbose) console.log(`kept (untracked) ${e.dest}`);
       }
     }
-    const hooksJsonPath = path16.join(templatesDir, "hooks", "hooks.json");
-    const baseSettingsPath = path16.join(
+    const hooksJsonPath = path17.join(templatesDir, "hooks", "hooks.json");
+    const baseSettingsPath = path17.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const settingsPath = path16.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path17.join(projectDir, ".claude", "settings.json");
     const existingSettings = fs15.existsSync(settingsPath) ? JSON.parse(fs15.readFileSync(settingsPath, "utf8")) : {};
     if (fs15.existsSync(baseSettingsPath)) {
       const base = JSON.parse(
@@ -37304,7 +38274,7 @@ async function runUpdate(opts, deps = {}) {
       deps.detectHealDeps
     );
     if (!opts.dryRun) {
-      fs15.mkdirSync(path16.dirname(settingsPath), { recursive: true });
+      fs15.mkdirSync(path17.dirname(settingsPath), { recursive: true });
       fs15.writeFileSync(
         settingsPath,
         JSON.stringify(existingSettings, null, 2) + "\n",
@@ -37320,7 +38290,7 @@ async function runUpdate(opts, deps = {}) {
     );
     if (opts.verbose && gitignoreAction !== "unchanged") {
       console.log(
-        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path16.relative(projectDir, path16.join(projectDir, ".gitignore"))}`
+        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path17.relative(projectDir, path17.join(projectDir, ".gitignore"))}`
       );
     }
     if (!opts.dryRun) {
@@ -37360,9 +38330,9 @@ function runUpdateUser(opts, deps) {
     return;
   }
   try {
-    const userDir = deps.userDir ?? path16.join(os3.homedir(), ".claude");
-    const settingsPath = path16.join(userDir, "settings.json");
-    const userBaseSettingsPath = path16.join(
+    const userDir = deps.userDir ?? path17.join(os3.homedir(), ".claude");
+    const settingsPath = path17.join(userDir, "settings.json");
+    const userBaseSettingsPath = path17.join(
       templatesDir,
       "settings.user.base.json"
     );
@@ -37434,7 +38404,7 @@ __export(uninstall_exports, {
 });
 import * as fs16 from "node:fs";
 import * as os4 from "node:os";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 async function runUninstall(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -37463,7 +38433,7 @@ async function runUninstall(opts, deps = {}) {
     let removed = 0;
     let warnings = 0;
     for (const entry of manifest.files) {
-      const abs = path17.join(projectDir, ".claude", entry.dest);
+      const abs = path18.join(projectDir, ".claude", entry.dest);
       if (!fs16.existsSync(abs)) {
         console.warn(
           `codebyplan claude uninstall: ${entry.dest} already absent (skipping).`
@@ -37487,12 +38457,12 @@ async function runUninstall(opts, deps = {}) {
     if (!opts.dryRun) {
       pruneEmptyManagedDirs(projectDir);
     }
-    const settingsPath = path17.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path18.join(projectDir, ".claude", "settings.json");
     if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
         fs16.readFileSync(settingsPath, "utf8")
       );
-      const baseSettingsPath = templatesDir ? path17.join(templatesDir, "settings.project.base.json") : null;
+      const baseSettingsPath = templatesDir ? path18.join(templatesDir, "settings.project.base.json") : null;
       if (baseSettingsPath && fs16.existsSync(baseSettingsPath)) {
         const base = JSON.parse(
           fs16.readFileSync(baseSettingsPath, "utf8")
@@ -37550,7 +38520,7 @@ function runUninstallUser(opts, deps) {
     }
   }
   try {
-    const userDir = deps.userDir ?? path17.join(os4.homedir(), ".claude");
+    const userDir = deps.userDir ?? path18.join(os4.homedir(), ".claude");
     const existingManifest = readManifestForScope("user", userDir);
     if (!existingManifest) {
       console.error(
@@ -37559,12 +38529,12 @@ function runUninstallUser(opts, deps) {
       process.exitCode = 1;
       return;
     }
-    const settingsPath = path17.join(userDir, "settings.json");
+    const settingsPath = path18.join(userDir, "settings.json");
     if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
         fs16.readFileSync(settingsPath, "utf8")
       );
-      const userBaseSettingsPath = templatesDir != null ? path17.join(templatesDir, "settings.user.base.json") : null;
+      const userBaseSettingsPath = templatesDir != null ? path18.join(templatesDir, "settings.user.base.json") : null;
       if (userBaseSettingsPath && fs16.existsSync(userBaseSettingsPath)) {
         const userBase = JSON.parse(
           fs16.readFileSync(userBaseSettingsPath, "utf8")
@@ -37605,7 +38575,7 @@ function runUninstallUser(opts, deps) {
 function pruneEmptyManagedDirs(projectDir) {
   const managedRoots = ["skills", "agents", "hooks", "rules"];
   for (const root of managedRoots) {
-    const abs = path17.join(projectDir, ".claude", root);
+    const abs = path18.join(projectDir, ".claude", root);
     if (!fs16.existsSync(abs)) continue;
     pruneLeafFirst(abs);
   }
@@ -37616,7 +38586,7 @@ function pruneLeafFirst(dir) {
   if (!stat3.isDirectory()) return;
   for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      pruneLeafFirst(path17.join(dir, entry.name));
+      pruneLeafFirst(path18.join(dir, entry.name));
     }
   }
   const remaining = fs16.readdirSync(dir);
@@ -37637,7 +38607,7 @@ var init_uninstall = __esm({
 
 // src/lib/verify-parity.ts
 import * as fs17 from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 function isValidScope(s) {
   return s === "org-shared" || s === "project-shared" || REPO_ONLY_RE.test(s);
 }
@@ -37654,25 +38624,25 @@ function checkSiblingParity(opts) {
     expectedOneSided = DEFAULT_EXPECTED_ONE_SIDED,
     ignoredSubtrees
   } = opts;
-  const defaultIgnored = [path18.join(claudeDir, "hooks", "__test-fixtures__")];
+  const defaultIgnored = [path19.join(claudeDir, "hooks", "__test-fixtures__")];
   const ignored = ignoredSubtrees ?? defaultIgnored;
   const violations = [];
   const claudeSideRels = /* @__PURE__ */ new Set();
   for (const scanDir of SCAN_DIRS) {
-    const baseDir = path18.join(claudeDir, scanDir);
+    const baseDir = path19.join(claudeDir, scanDir);
     if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path18.join(baseDir, entry);
+      const absPath = path19.join(baseDir, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (ignored.some(
-        (ig) => absPath.startsWith(ig + path18.sep) || absPath === ig
+        (ig) => absPath.startsWith(ig + path19.sep) || absPath === ig
       )) {
         continue;
       }
-      const relPath = path18.join(scanDir, entry).split(path18.sep).join("/");
+      const relPath = path19.join(scanDir, entry).split(path19.sep).join("/");
       claudeSideRels.add(relPath);
-      const templatePath = path18.join(templatesDir, relPath);
+      const templatePath = path19.join(templatesDir, relPath);
       if (!fs17.existsSync(templatePath)) {
         if (!expectedOneSided.has(relPath) && !isScaffoldFile(entry)) {
           violations.push({ type: "missing-twin", path: relPath });
@@ -37687,14 +38657,14 @@ function checkSiblingParity(opts) {
     }
   }
   for (const scanDir of SCAN_DIRS) {
-    const tplBase = path18.join(templatesDir, scanDir);
+    const tplBase = path19.join(templatesDir, scanDir);
     if (!fs17.existsSync(tplBase)) continue;
     const entries = readdirRecursive(tplBase);
     for (const entry of entries) {
-      const absPath = path18.join(tplBase, entry);
+      const absPath = path19.join(tplBase, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (isScaffoldFile(entry)) continue;
-      const relPath = path18.join(scanDir, entry).split(path18.sep).join("/");
+      const relPath = path19.join(scanDir, entry).split(path19.sep).join("/");
       if (!claudeSideRels.has(relPath) && !expectedOneSided.has(relPath)) {
         violations.push({ type: "extra-twin", path: relPath });
       }
@@ -37730,18 +38700,18 @@ function checkScopeMarkers(opts) {
   const twinDetectionActive = templatesDir != null && fs17.existsSync(templatesDir);
   const violations = [];
   for (const scanDir of scanDirs) {
-    const baseDir = path18.join(claudeDir, scanDir);
+    const baseDir = path19.join(claudeDir, scanDir);
     if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path18.join(baseDir, entry);
+      const absPath = path19.join(baseDir, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (!isStructuralEntry(scanDir, entry)) continue;
-      const ext = path18.extname(entry).toLowerCase();
+      const ext = path19.extname(entry).toLowerCase();
       const isMd = ext === ".md";
       const isSh = ext === ".sh";
       if (!isMd && !isSh) continue;
-      const relPath = path18.join(scanDir, entry).split(path18.sep).join("/");
+      const relPath = path19.join(scanDir, entry).split(path19.sep).join("/");
       if (allowlist.has(relPath)) continue;
       let content;
       try {
@@ -37755,7 +38725,7 @@ function checkScopeMarkers(opts) {
         continue;
       }
       const scopeValue = isMd ? extractFrontmatterScope(content) : extractShScope(content);
-      const managed = twinDetectionActive && fs17.existsSync(path18.join(templatesDir, relPath));
+      const managed = twinDetectionActive && fs17.existsSync(path19.join(templatesDir, relPath));
       if (managed) {
         if (scopeValue === null) {
         } else if (scopeValue === "org-shared") {
@@ -37809,7 +38779,7 @@ function readdirRecursive(dir, rel = "", visited = /* @__PURE__ */ new Set()) {
   visited.add(realDir);
   const results = [];
   for (const name of fs17.readdirSync(dir)) {
-    const full = path18.join(dir, name);
+    const full = path19.join(dir, name);
     const relName = rel ? `${rel}/${name}` : name;
     if (fs17.lstatSync(full).isDirectory()) {
       results.push(...readdirRecursive(full, relName, visited));
@@ -37882,12 +38852,12 @@ __export(verify_parity_exports, {
   verifyParity: () => verifyParity
 });
 import * as fs18 from "node:fs";
-import * as path19 from "node:path";
+import * as path20 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 = path19.join(projectDir, ".claude");
+  const claudeDir = path20.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);
@@ -38395,7 +39365,7 @@ __export(generate_exports, {
   runGenerate: () => runGenerate
 });
 import { readFile as readFile28, mkdir as mkdir13, writeFile as writeFile22 } from "node:fs/promises";
-import { join as join47, resolve as resolve11 } from "node:path";
+import { join as join48, resolve as resolve11 } from "node:path";
 async function readJsonFile4(filePath) {
   try {
     const raw = await readFile28(filePath, "utf-8");
@@ -38406,7 +39376,7 @@ async function readJsonFile4(filePath) {
 }
 async function readPkgName(absPath) {
   try {
-    const raw = await readFile28(join47(absPath, "package.json"), "utf-8");
+    const raw = await readFile28(join48(absPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
@@ -38420,7 +39390,7 @@ async function runGenerate(opts) {
   const rootDir = resolve11(projectDir);
   let packageManager;
   try {
-    const raw = await readFile28(join47(rootDir, "package.json"), "utf-8");
+    const raw = await readFile28(join48(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.packageManager === "string") {
       packageManager = pkg.packageManager;
@@ -38428,7 +39398,7 @@ async function runGenerate(opts) {
   } catch {
   }
   const serverJson = await readJsonFile4(
-    join47(rootDir, ".codebyplan", "server.json")
+    join48(rootDir, ".codebyplan", "server.json")
   );
   const ports = [];
   for (const alloc of serverJson?.port_allocations ?? []) {
@@ -38441,7 +39411,7 @@ async function runGenerate(opts) {
     }
   }
   const gitJson = await readJsonFile4(
-    join47(rootDir, ".codebyplan", "git.json")
+    join48(rootDir, ".codebyplan", "git.json")
   );
   const branchModel = gitJson?.branch_config?.production ? {
     production: gitJson.branch_config.production,
@@ -38450,7 +39420,7 @@ async function runGenerate(opts) {
     )
   } : void 0;
   const shipmentJson = await readJsonFile4(
-    join47(rootDir, ".codebyplan", "shipment.json")
+    join48(rootDir, ".codebyplan", "shipment.json")
   );
   const shipmentSurfaces = [];
   const rawSurfaces = shipmentJson?.shipment?.surfaces ?? shipmentJson?.surfaces ?? {};
@@ -38521,7 +39491,7 @@ async function runGenerate(opts) {
   const structureMdContent = generateStructureMd(config);
   const agentsContent = generateAgentsMd(structureMdContent);
   if (check) {
-    const agentsMdPath2 = join47(rootDir, "AGENTS.md");
+    const agentsMdPath2 = join48(rootDir, "AGENTS.md");
     let existingAgents = null;
     try {
       existingAgents = await readFile28(agentsMdPath2, "utf-8");
@@ -38560,13 +39530,13 @@ async function runGenerate(opts) {
     process.stdout.write(agentsContent);
     return;
   }
-  const outputDir = join47(rootDir, ".claude", "generated");
+  const outputDir = join48(rootDir, ".claude", "generated");
   await mkdir13(outputDir, { recursive: true });
-  const outputPath = join47(outputDir, "structure.md");
+  const outputPath = join48(outputDir, "structure.md");
   await writeFile22(outputPath, structureMdContent, "utf-8");
   process.stdout.write(`Wrote: .claude/generated/structure.md
 `);
-  const agentsMdPath = join47(rootDir, "AGENTS.md");
+  const agentsMdPath = join48(rootDir, "AGENTS.md");
   let existingAgentsContent = null;
   try {
     existingAgentsContent = await readFile28(agentsMdPath, "utf-8");
@@ -38598,7 +39568,7 @@ __export(readme_exports, {
   runReadmeCommand: () => runReadmeCommand
 });
 import { readFile as readFile29, writeFile as writeFile23 } from "node:fs/promises";
-import { join as join48, resolve as resolve12, relative as relative9 } from "node:path";
+import { join as join49, resolve as resolve12, relative as relative9 } from "node:path";
 async function readJsonFile5(filePath) {
   try {
     const raw = await readFile29(filePath, "utf-8");
@@ -38670,7 +39640,7 @@ async function discoverUnits(rootDir, rootPkgJson) {
   const discovered = await discoverMonorepoApps(rootDir);
   for (const app of discovered) {
     const pkgJson = await readJsonFile5(
-      join48(app.absPath, "package.json")
+      join49(app.absPath, "package.json")
     );
     pkgJsonByPath.set(app.absPath, pkgJson);
     allPackages.push({
@@ -38696,7 +39666,7 @@ async function runReadme(opts) {
   const init = opts.init ?? opts["init"] ?? false;
   const rootDir = resolve12(projectDir);
   const rootPkgJson = await readJsonFile5(
-    join48(rootDir, "package.json")
+    join49(rootDir, "package.json")
   );
   const { units, allPackages, pkgJsonByPath } = await discoverUnits(
     rootDir,
@@ -38705,8 +39675,8 @@ async function runReadme(opts) {
   const driftUnits = [];
   const missingUnits = [];
   for (const unit of units) {
-    const readmePath = join48(unit.absPath, "README.md");
-    const relPath = unit.isRoot ? "README.md" : join48(relative9(rootDir, unit.absPath), "README.md");
+    const readmePath = join49(unit.absPath, "README.md");
+    const relPath = unit.isRoot ? "README.md" : join49(relative9(rootDir, unit.absPath), "README.md");
     let existingContent = null;
     try {
       existingContent = await readFile29(readmePath, "utf-8");
@@ -38897,7 +39867,7 @@ import {
   readdir as readdir7
 } from "node:fs/promises";
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join49, resolve as resolve13, dirname as dirname15, sep as sep4 } from "node:path";
+import { join as join50, resolve as resolve13, dirname as dirname16, sep as sep4 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function encodeProjectPath(absPath) {
   return resolve13(absPath).replace(/[/\\]/g, "-");
@@ -38908,7 +39878,7 @@ function resolveAutoMemoryDir(opts) {
   }
   const projectDir = opts.projectDir ?? process.cwd();
   const encoded = encodeProjectPath(projectDir);
-  return join49(homedir8(), ".claude", "projects", encoded, "memory");
+  return join50(homedir8(), ".claude", "projects", encoded, "memory");
 }
 function parseFrontmatter(content) {
   content = content.replace(/\r\n/g, "\n");
@@ -38974,7 +39944,7 @@ async function inventoryFiles(dir) {
   }
   const results = [];
   for (const filename of filenames) {
-    const sourcePath = join49(dir, filename);
+    const sourcePath = join50(dir, filename);
     let raw;
     try {
       raw = await readFile30(sourcePath, "utf-8");
@@ -39063,8 +40033,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(join49(projectDir, relPath));
-    const targetFile = join49(targetDir, "CLAUDE.md");
+    const targetDir = resolve13(join50(projectDir, relPath));
+    const targetFile = join50(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
@@ -39114,7 +40084,7 @@ ${anchor}
       );
     }
   }
-  const rootClaudeMd = join49(projectDir, ".claude", "CLAUDE.md");
+  const rootClaudeMd = join50(projectDir, ".claude", "CLAUDE.md");
   if (dryRun) {
     process.stdout.write(
       `[dry-run] Would ensure ${rootClaudeMd} contains: ${IMPORT_LINE}
@@ -39125,7 +40095,7 @@ ${anchor}
     try {
       claudeMdContent = await readFile30(rootClaudeMd, "utf-8");
     } catch {
-      await mkdir14(dirname15(rootClaudeMd), { recursive: true });
+      await mkdir14(dirname16(rootClaudeMd), { recursive: true });
     }
     if (!claudeMdContent.includes(IMPORT_LINE)) {
       await writeFile24(
@@ -39158,8 +40128,8 @@ ${IMPORT_LINE}
     } catch {
     }
   }
-  const memoryMd = join49(plan.auto_memory_dir, "MEMORY.md");
-  const safeRmdirBase = join49(homedir8(), ".claude", "projects");
+  const memoryMd = join50(plan.auto_memory_dir, "MEMORY.md");
+  const safeRmdirBase = join50(homedir8(), ".claude", "projects");
   if (dryRun) {
     process.stdout.write(`[dry-run] Would delete MEMORY.md: ${memoryMd}
 `);
@@ -39283,7 +40253,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 join50, basename as basename2 } from "node:path";
+import { join as join51, basename as basename3 } from "node:path";
 function parseFrontmatter2(content) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
   if (!match) return {};
@@ -39303,7 +40273,7 @@ function parseFrontmatter2(content) {
 function auditAgent(filePath) {
   const content = readFileSync19(filePath, "utf-8");
   const fm = parseFrontmatter2(content);
-  const agentName = fm.name ?? basename2(filePath, ".md");
+  const agentName = fm.name ?? basename3(filePath, ".md");
   const expected = AGENT_EXCEPTIONS[agentName] ?? AGENT_DEFAULT;
   const expectedStr = `model:${expected.model}/effort:${expected.effort}`;
   const model = fm.model ?? null;
@@ -39360,19 +40330,19 @@ function auditSkill(filePath) {
 }
 function auditMode(templatesDir) {
   const entries = [];
-  const agentsDir = join50(templatesDir, "agents");
+  const agentsDir = join51(templatesDir, "agents");
   if (existsSync22(agentsDir)) {
     const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md")).sort();
     for (const f of agentFiles) {
-      entries.push(auditAgent(join50(agentsDir, f)));
+      entries.push(auditAgent(join51(agentsDir, f)));
     }
   }
-  const skillsDir = join50(templatesDir, "skills");
+  const skillsDir = join51(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(join50(skillsDir, dir, "PROVENANCE.md"))) continue;
-      const skillMd = join50(skillsDir, dir, "SKILL.md");
+      if (existsSync22(join51(skillsDir, dir, "PROVENANCE.md"))) continue;
+      const skillMd = join51(skillsDir, dir, "SKILL.md");
       if (existsSync22(skillMd)) {
         entries.push(auditSkill(skillMd));
       }
@@ -39477,9 +40447,9 @@ var resolve_preview_exports = {};
 __export(resolve_preview_exports, {
   resolvePreview: () => resolvePreview
 });
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync14 } from "node:child_process";
 function defaultGetCurrentBranch(cwd) {
-  const result = spawnSync12("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const result = spawnSync14("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -39631,7 +40601,7 @@ __export(new_migration_exports, {
   newMigration: () => newMigration
 });
 import * as fs19 from "node:fs";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 function slugify(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
@@ -39652,9 +40622,9 @@ function newMigration(args, deps = {}) {
   }
   const slug = slugify(rawName);
   const stamp = genTimestamp({ cwd });
-  const migrationsDir = path20.join(cwd, "supabase", "migrations");
+  const migrationsDir = path21.join(cwd, "supabase", "migrations");
   const filename = `${stamp}_${slug}.sql`;
-  const filePath = path20.join(migrationsDir, filename);
+  const filePath = path21.join(migrationsDir, filename);
   mkdirSync11(migrationsDir, { recursive: true });
   writeFileSync12(filePath, "");
   process.stdout.write(JSON.stringify({ path: filePath }) + "\n");
@@ -39672,9 +40642,9 @@ var preview_check_exports = {};
 __export(preview_check_exports, {
   previewCheck: () => previewCheck
 });
-import { spawnSync as spawnSync13 } from "node:child_process";
-function defaultRun3(cmd, args) {
-  const result = spawnSync13(cmd, args, {
+import { spawnSync as spawnSync15 } from "node:child_process";
+function defaultRun4(cmd, args) {
+  const result = spawnSync15(cmd, args, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -39699,7 +40669,7 @@ function defaultGetPrNumber(cwd, run) {
 }
 async function previewCheck(args, deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
-  const run = deps.run ?? defaultRun3;
+  const run = deps.run ?? defaultRun4;
   const sleep3 = deps.sleep ?? ((ms) => new Promise((resolve16) => setTimeout(resolve16, ms)));
   const getPrNumber = deps.getPrNumber ?? defaultGetPrNumber;
   const poll = deps.pollCheck ?? pollGhPreviewCheck;
@@ -39728,313 +40698,6 @@ var init_preview_check = __esm({
   }
 });
 
-// src/lib/session.ts
-import { spawnSync as spawnSync14 } from "node:child_process";
-import * as path21 from "node:path";
-function defaultRun4(cmd, args, cwd) {
-  const result = spawnSync14(cmd, args, {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    const stderr = (result.stderr ?? "").toString().trim();
-    throw new Error(
-      `${cmd} ${args.join(" ")} exited ${result.status ?? "null"}${stderr ? `: ${stderr}` : ""}`
-    );
-  }
-  return (result.stdout ?? "").toString();
-}
-function homeFf(opts = {}) {
-  const cwd = opts.cwd ?? process.cwd();
-  const run = opts.run ?? defaultRun4;
-  const gitCfg = readGitConfig(cwd);
-  const production = gitCfg.production;
-  let repoRoot;
-  try {
-    repoRoot = run("git", ["rev-parse", "--show-toplevel"], cwd).trim();
-  } catch {
-    return {
-      result: "skipped",
-      reason: "git rev-parse --show-toplevel failed"
-    };
-  }
-  const folder = path21.basename(repoRoot);
-  let current;
-  try {
-    current = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd).trim();
-  } catch {
-    return {
-      result: "skipped",
-      reason: "git rev-parse --abbrev-ref HEAD failed"
-    };
-  }
-  if (current !== folder) {
-    return { result: "skipped", reason: "not on home branch" };
-  }
-  try {
-    run("git", ["fetch", "origin", production], cwd);
-  } catch {
-    return {
-      result: "warn",
-      warn: `fetch failed \u2014 staying on local ${current}`
-    };
-  }
-  try {
-    run("git", ["merge", "--ff-only", `origin/${production}`], cwd);
-  } catch {
-    return {
-      result: "warn",
-      warn: `${current} not fast-forwardable (ahead/diverged) \u2014 left untouched`
-    };
-  }
-  return { result: "fast_forwarded" };
-}
-function spawnVersionStatus(cwd) {
-  try {
-    const result = spawnSync14("npx", ["codebyplan", "version-status"], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    if (result.error) return null;
-    const raw = (result.stdout ?? "").toString().trim();
-    if (!raw) return null;
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return null;
-    }
-    const obj = parsed;
-    if (typeof obj["installed"] !== "string" || typeof obj["newer"] !== "boolean" || typeof obj["guarded"] !== "boolean" || typeof obj["installCommand"] !== "string") {
-      return null;
-    }
-    return {
-      installed: obj["installed"],
-      latest: typeof obj["latest"] === "string" ? obj["latest"] : null,
-      newer: obj["newer"],
-      packageManager: typeof obj["packageManager"] === "string" ? obj["packageManager"] : "npm",
-      installCommand: obj["installCommand"],
-      guarded: obj["guarded"],
-      guardReason: typeof obj["guardReason"] === "string" ? obj["guardReason"] : null
-    };
-  } catch {
-    return null;
-  }
-}
-function defaultRunInstall(installCommand, cwd) {
-  const parts = installCommand.trim().split(/\s+/);
-  const cmd = parts[0];
-  const args = parts.slice(1);
-  if (!cmd) throw new Error("empty installCommand");
-  const result = spawnSync14(cmd, args, {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    const stderr = (result.stderr ?? "").toString().trim();
-    throw new Error(
-      `install exited ${result.status}${stderr ? `: ${stderr}` : ""}`
-    );
-  }
-}
-function defaultRunClaudeUpdate(cwd) {
-  const result = spawnSync14("npx", ["codebyplan", "claude", "update", "--yes"], {
-    cwd,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    const stderr = (result.stderr ?? "").toString().trim();
-    throw new Error(
-      `claude update exited ${result.status}${stderr ? `: ${stderr}` : ""}`
-    );
-  }
-}
-function defaultRunGitStatus(cwd) {
-  const result = spawnSync14(
-    "git",
-    ["status", "--porcelain", "--", ".claude/", ".codebyplan/"],
-    {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }
-  );
-  if (result.error) throw result.error;
-  return (result.stdout ?? "").toString();
-}
-async function freshnessGate(opts = {}) {
-  const cwd = opts.cwd ?? process.cwd();
-  const probeVersionStatus = opts.probeVersionStatus ?? ((c) => spawnVersionStatus(c));
-  const runInstall2 = opts.runInstall ?? defaultRunInstall;
-  const runClaudeUpdate = opts.runClaudeUpdate ?? defaultRunClaudeUpdate;
-  const runGitStatus = opts.runGitStatus ?? defaultRunGitStatus;
-  const haltOnUpdate = opts.haltOnUpdate ?? false;
-  let probe;
-  try {
-    probe = probeVersionStatus(cwd);
-  } catch {
-    probe = null;
-  }
-  if (!probe) {
-    return { result: "skipped", reason: "probe failed (fail-safe)" };
-  }
-  if (probe.guarded) {
-    return { result: "guarded" };
-  }
-  if (!probe.newer) {
-    return { result: "up_to_date" };
-  }
-  try {
-    runInstall2(probe.installCommand, cwd);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : "install failed (unknown error)";
-    return { result: "error", reason };
-  }
-  try {
-    runClaudeUpdate(cwd);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : "claude update failed (unknown error)";
-    return { result: "error", reason };
-  }
-  let gitStatusOutput = "";
-  try {
-    gitStatusOutput = runGitStatus(cwd);
-  } catch {
-    gitStatusOutput = "";
-  }
-  const changedFiles = gitStatusOutput.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
-    const parts = line.split(/\s+/);
-    return parts.slice(1).join(" ");
-  }).filter(Boolean);
-  return {
-    result: "updated",
-    latest: probe.latest ?? probe.installed,
-    changed_files: changedFiles,
-    halt: haltOnUpdate
-  };
-}
-async function infraFiles(opts = {}) {
-  const cwd = opts.cwd ?? process.cwd();
-  const run = opts.run ?? defaultRun4;
-  const getTaskFiles = opts.getTaskFiles ?? (() => Promise.resolve([]));
-  let firstOutput;
-  try {
-    firstOutput = run("git", ["status", "--porcelain"], cwd);
-  } catch {
-    firstOutput = "";
-  }
-  const firstChanged = parseGitStatus2(firstOutput);
-  if (firstChanged.length === 0) {
-    return { infra_files: [], task_files: [], note: "clean tree" };
-  }
-  const taskFiles = await getTaskFiles();
-  const taskSet = new Set(taskFiles);
-  let secondOutput;
-  try {
-    secondOutput = run("git", ["status", "--porcelain"], cwd);
-  } catch {
-    secondOutput = "";
-  }
-  const freshChanged = parseGitStatus2(secondOutput);
-  const infraFilesList = freshChanged.filter((f) => !taskSet.has(f));
-  return {
-    infra_files: infraFilesList,
-    task_files: taskFiles
-  };
-}
-function parseGitStatus2(output) {
-  return output.split("\n").filter(Boolean).map((line) => {
-    if (line.length > 3) {
-      const rest = line.slice(3);
-      const arrow = rest.indexOf(" -> ");
-      if (arrow !== -1) {
-        return rest.slice(arrow + 4).trim();
-      }
-      return rest.trim();
-    }
-    return "";
-  }).filter(Boolean);
-}
-var init_session2 = __esm({
-  "src/lib/session.ts"() {
-    "use strict";
-    init_supabase();
-  }
-});
-
-// src/cli/session/home-ff.ts
-var home_ff_exports = {};
-__export(home_ff_exports, {
-  homeFfCli: () => homeFfCli
-});
-function homeFfCli(_args, deps = {}) {
-  const result = homeFf(deps);
-  process.stdout.write(JSON.stringify(result) + "\n");
-  return 0;
-}
-var init_home_ff = __esm({
-  "src/cli/session/home-ff.ts"() {
-    "use strict";
-    init_session2();
-  }
-});
-
-// src/cli/session/freshness-gate.ts
-var freshness_gate_exports = {};
-__export(freshness_gate_exports, {
-  freshnessGateCli: () => freshnessGateCli
-});
-async function freshnessGateCli(args, deps = {}) {
-  const haltOnUpdate = args.includes("--halt-on-update");
-  const result = await freshnessGate({
-    ...deps,
-    haltOnUpdate: deps.haltOnUpdate ?? haltOnUpdate
-  });
-  process.stdout.write(JSON.stringify(result) + "\n");
-  return 0;
-}
-var init_freshness_gate = __esm({
-  "src/cli/session/freshness-gate.ts"() {
-    "use strict";
-    init_session2();
-  }
-});
-
-// src/cli/session/infra-files.ts
-var infra_files_exports = {};
-__export(infra_files_exports, {
-  infraFilesCli: () => infraFilesCli
-});
-async function infraFilesCli(args, deps = {}) {
-  let taskFilesFromFlag = [];
-  const tfIdx = args.indexOf("--task-files");
-  if (tfIdx !== -1 && tfIdx + 1 < args.length) {
-    const raw = args[tfIdx + 1];
-    if (raw && !raw.startsWith("--")) {
-      taskFilesFromFlag = raw.split(",").map((f) => f.trim()).filter(Boolean);
-    }
-  }
-  const result = await infraFiles({
-    ...deps,
-    // When the caller passes --task-files, use those as the task file list.
-    // The deps injection wins when explicitly provided (test path).
-    getTaskFiles: deps.getTaskFiles ?? (taskFilesFromFlag.length > 0 ? () => Promise.resolve(taskFilesFromFlag) : () => Promise.resolve([]))
-  });
-  process.stdout.write(JSON.stringify(result) + "\n");
-  return 0;
-}
-var init_infra_files = __esm({
-  "src/cli/session/infra-files.ts"() {
-    "use strict";
-    init_session2();
-  }
-});
-
 // src/lib/slug.ts
 function slugify2(title) {
   if (!title) return "";
@@ -40108,9 +40771,9 @@ var commit_exports = {};
 __export(commit_exports, {
   runCommitCommand: () => runCommitCommand
 });
-import { spawnSync as spawnSync15 } from "node:child_process";
+import { spawnSync as spawnSync16 } from "node:child_process";
 function defaultRun5(cmd, args) {
-  const result = spawnSync15(cmd, args, {
+  const result = spawnSync16(cmd, args, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -40158,7 +40821,7 @@ var init_commit = __esm({
 });
 
 // src/lib/migration-collisions.ts
-import { spawnSync as spawnSync16 } from "node:child_process";
+import { spawnSync as spawnSync17 } from "node:child_process";
 function extractPrefix(filename) {
   const base = filename.endsWith(".sql") ? filename.slice(0, -4) : filename;
   const underscoreIdx = base.indexOf("_");
@@ -40170,7 +40833,7 @@ function extractPrefix(filename) {
 }
 function makeDefaultRun(cwd) {
   return (cmd, args) => {
-    const result = spawnSync16(cmd, args, {
+    const result = spawnSync17(cmd, args, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -40526,12 +41189,12 @@ var init_validate_waves2 = __esm({
 });
 
 // src/cli/worktree/path.ts
-import { dirname as dirname16, basename as basename4, join as join52 } from "node:path";
+import { dirname as dirname17, basename as basename4, join as join53 } from "node:path";
 function computeWorktreePath(cwd, checkpointNumber) {
-  const parent = dirname16(cwd);
+  const parent = dirname17(cwd);
   const base = basename4(cwd);
   const nnn = String(checkpointNumber).padStart(3, "0");
-  return join52(parent, `${base}-CHK-${nnn}`);
+  return join53(parent, `${base}-CHK-${nnn}`);
 }
 var init_path = __esm({
   "src/cli/worktree/path.ts"() {
@@ -40540,9 +41203,9 @@ var init_path = __esm({
 });
 
 // src/cli/worktree/add.ts
-import { join as join53, basename as basename5 } from "node:path";
+import { join as join54, 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";
+import { spawnSync as spawnSync18 } from "node:child_process";
 async function defaultGetRepoId(cwd) {
   const found = await findCodebyplanConfig(cwd);
   return found?.contents.repo_id ?? null;
@@ -40571,7 +41234,7 @@ async function defaultLookupBranch(repoId, checkpointNumber) {
   return { found: true, branch_name: chk.branch_name };
 }
 function defaultGitRun(args, cwd) {
-  const result = spawnSync17("git", args, {
+  const result = spawnSync18("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -40590,11 +41253,11 @@ async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
     (fsp) => fsp.access(p).then(() => true).catch(() => false)
   ));
   const mkdirFn = deps.mkdirFn ?? ((p, opts) => mkdir15(p, opts));
-  await mkdirFn(join53(destPath, ".claude"), { recursive: true });
+  await mkdirFn(join54(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);
+    const srcFile = join54(srcCwd, ".claude", stub);
+    const destFile = join54(destPath, ".claude", stub);
     try {
       const destExists = await existsFn(destFile);
       if (destExists) continue;
@@ -40605,22 +41268,22 @@ async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
   }
 }
 async function defaultCopyConfigStubs(srcCwd, destPath) {
-  await mkdir15(join53(destPath, ".codebyplan"), { recursive: true });
+  await mkdir15(join54(destPath, ".codebyplan"), { recursive: true });
   const topLevelStubs = [".mcp.json", ".env.local"];
   for (const stub of topLevelStubs) {
     try {
-      const content = await readFile32(join53(srcCwd, stub), "utf-8");
-      await writeFile25(join53(destPath, stub), content, "utf-8");
+      const content = await readFile32(join54(srcCwd, stub), "utf-8");
+      await writeFile25(join54(destPath, stub), content, "utf-8");
     } catch {
     }
   }
   try {
     const content = await readFile32(
-      join53(srcCwd, ".codebyplan", "repo.json"),
+      join54(srcCwd, ".codebyplan", "repo.json"),
       "utf-8"
     );
     await writeFile25(
-      join53(destPath, ".codebyplan", "repo.json"),
+      join54(destPath, ".codebyplan", "repo.json"),
       content,
       "utf-8"
     );
@@ -40785,7 +41448,7 @@ var init_add = __esm({
 });
 
 // src/cli/worktree/create.ts
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 async function defaultGetRepoIdentity(cwd) {
   const found = await findCodebyplanConfig(cwd);
   const contents = found?.contents ?? null;
@@ -40841,7 +41504,7 @@ async function runWorktreeCreate(args, deps = {}) {
     );
     return 1;
   }
-  const worktreePath = explicitPath ?? join54(cwd, "..", name);
+  const worktreePath = explicitPath ?? join55(cwd, "..", name);
   const deviceId = await getDeviceId(cwd);
   let filesWritten = false;
   try {
@@ -40906,7 +41569,7 @@ var init_create = __esm({
 
 // src/cli/worktree/remove.ts
 import { basename as basename6 } from "node:path";
-import { spawnSync as spawnSync18 } from "node:child_process";
+import { spawnSync as spawnSync19 } from "node:child_process";
 async function defaultGetRepoId2(cwd) {
   const found = await findCodebyplanConfig(cwd);
   return found?.contents.repo_id ?? null;
@@ -40928,7 +41591,7 @@ async function defaultDeregisterWorktree(worktreeId) {
   await mcpCall("delete_worktree", { worktree_id: worktreeId });
 }
 function defaultGitRun2(args, cwd) {
-  const result = spawnSync18("git", args, {
+  const result = spawnSync19("git", args, {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -40941,7 +41604,7 @@ function defaultGitRun2(args, cwd) {
   };
 }
 function defaultGetWorktreeBranchName(worktreePath) {
-  const result = spawnSync18("git", ["symbolic-ref", "--short", "HEAD"], {
+  const result = spawnSync19("git", ["symbolic-ref", "--short", "HEAD"], {
     cwd: worktreePath,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -41486,7 +42149,7 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { existsSync as existsSync23 } from "node:fs";
-import { join as join55 } from "node:path";
+import { join as join56 } from "node:path";
 import { execSync as execSync10 } from "node:child_process";
 async function checkAuth() {
   try {
@@ -41610,7 +42273,7 @@ function checkSettings() {
         detail: "codebyplan not installed (no .cbp.manifest.json)"
       };
     }
-    if (!existsSync23(join55(projectDir, ".claude", "settings.json"))) {
+    if (!existsSync23(join56(projectDir, ".claude", "settings.json"))) {
       return {
         name: "settings",
         status: "warn",
@@ -41847,7 +42510,7 @@ void (async () => {
     process.exit(0);
   }
   if (arg === "session") {
-    const { runSessionCommand: runSessionCommand2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+    const { runSessionCommand: runSessionCommand2 } = await Promise.resolve().then(() => (init_session2(), session_exports));
     const rest = process.argv.slice(3);
     await runSessionCommand2(rest);
     process.exit(0);
@@ -42123,36 +42786,6 @@ void (async () => {
 
   The parent project ref is always read from .codebyplan/shipment.json
   (.shipment.surfaces.supabase.project_ref) \u2014 never hardcoded.
-`);
-    process.exit(0);
-  }
-  if (arg === "session") {
-    const subcommand = process.argv[3];
-    const rest = process.argv.slice(4);
-    if (subcommand === "home-ff") {
-      const { homeFfCli: homeFfCli2 } = await Promise.resolve().then(() => (init_home_ff(), home_ff_exports));
-      process.exit(homeFfCli2(rest));
-    }
-    if (subcommand === "freshness-gate") {
-      const { freshnessGateCli: freshnessGateCli2 } = await Promise.resolve().then(() => (init_freshness_gate(), freshness_gate_exports));
-      process.exit(await freshnessGateCli2(rest));
-    }
-    if (subcommand === "infra-files") {
-      const { infraFilesCli: infraFilesCli2 } = await Promise.resolve().then(() => (init_infra_files(), infra_files_exports));
-      process.exit(await infraFilesCli2(rest));
-    }
-    console.log(`
-  CodeByPlan session helpers v${VERSION}
-
-  Usage:
-    codebyplan session home-ff
-                                        Fast-forward the home branch to HEAD; outputs { result, reason?, warn? } JSON
-    codebyplan session freshness-gate [--halt-on-update]
-                                        Check package version freshness; outputs { result, ... } JSON
-    codebyplan session infra-files [--task-files <csv>] [--json]
-                                        Compute the infra-file set for the active session; outputs { infra_files, task_files } JSON
-
-  Output is always JSON on stdout. Exit 0 always \u2014 callers branch on the result field.
 `);
     process.exit(0);
   }