codebyplan 1.13.24 → 1.13.26

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.24";
+    VERSION = "1.13.26";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -149,6 +149,7 @@ var init_gitignore_block = __esm({
       ".codebyplan/device.local.json",
       ".codebyplan/statusline.local.json",
       ".codebyplan/worktree.local.json",
+      ".codebyplan/todo/",
       ".codebyplan/claude-status.local.json",
       ".codebyplan.local.json"
     ];
@@ -1568,6 +1569,18 @@ function stripBaseSettingsFromSettings(settings, base) {
   }
   return settings;
 }
+function mergeEnabledPluginsIntoSettings(settings, plugins) {
+  if (!settings.enabledPlugins) {
+    settings.enabledPlugins = {};
+  }
+  for (const plugin of plugins) {
+    const key = `${plugin}@claude-plugins-official`;
+    if (!(key in settings.enabledPlugins)) {
+      settings.enabledPlugins[key] = true;
+    }
+  }
+  return settings;
+}
 function stripOwnedHooksFromSettings(settings) {
   if (!settings.hooks) {
     return settings;
@@ -1636,1518 +1649,1903 @@ var init_settings_merge = __esm({
   }
 });
 
-// src/cli/claude/install.ts
-var install_exports = {};
-__export(install_exports, {
-  resolveTemplatesDir: () => resolveTemplatesDir,
-  runInstall: () => runInstall
-});
-import * as fs3 from "node:fs";
-import * as os2 from "node:os";
-import * as path4 from "node:path";
-import { fileURLToPath } from "node:url";
-function resolveTemplatesDir() {
-  const here = path4.dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    path4.resolve(here, "..", "templates"),
-    path4.resolve(here, "..", "..", "templates"),
-    path4.resolve(here, "..", "..", "..", "templates")
-  ];
-  for (const c of candidates) {
-    if (fs3.existsSync(c) && fs3.statSync(c).isDirectory()) {
-      return c;
+// src/lib/flags.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join8, resolve } from "node:path";
+async function findCodebyplanConfig(startDir, maxDepth = 20) {
+  let cursor = resolve(startDir);
+  for (let depth = 0; depth < maxDepth; depth++) {
+    const sentinelPath2 = join8(cursor, ".codebyplan", "repo.json");
+    try {
+      const raw = await readFile6(sentinelPath2, "utf-8");
+      const parsed = JSON.parse(raw);
+      return { path: sentinelPath2, contents: parsed };
+    } catch {
     }
+    const legacyPath = join8(cursor, ".codebyplan.json");
+    try {
+      const raw = await readFile6(legacyPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return { path: legacyPath, contents: parsed };
+    } catch {
+    }
+    const parent = resolve(cursor, "..");
+    if (parent === cursor) return null;
+    cursor = parent;
   }
-  throw new Error(
-    `codebyplan: could not locate templates/ directory. Probed:
-  ${candidates.join(
-      "\n  "
-    )}`
-  );
+  return null;
 }
-async function runInstall(opts, deps = {}) {
-  await Promise.resolve();
-  const scope = opts.scope ?? "project";
-  if (scope === "user") {
-    if (opts.renderer) {
-      console.warn(
-        "codebyplan claude install: --bash/--node/--python is ignored for --scope user (no project root for statusline.local.json)."
-      );
+function parseFlags(startIndex) {
+  const flags = {};
+  const args = process.argv.slice(startIndex);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--") && i + 1 < args.length) {
+      const key = arg.slice(2);
+      flags[key] = args[++i];
     }
-    runInstallUser(opts, deps);
-    return;
   }
-  const projectDir = deps.projectDir ?? process.cwd();
-  let templatesDir;
-  try {
-    templatesDir = deps.templatesDir ?? resolveTemplatesDir();
-  } catch (err) {
-    console.error(
-      err instanceof Error ? err.message : `codebyplan claude install: ${String(err)}`
+  return flags;
+}
+function hasFlag(name, startIndex) {
+  return process.argv.slice(startIndex).includes(`--${name}`);
+}
+async function resolveConfig(flags) {
+  const projectPath = flags["path"] ?? process.cwd();
+  let repoId = flags["repo-id"] ?? process.env.CODEBYPLAN_REPO_ID;
+  let worktreeId = flags["worktree-id"] ?? process.env.CODEBYPLAN_WORKTREE_ID;
+  if (!repoId) {
+    const found = await findCodebyplanConfig(projectPath);
+    if (found) {
+      repoId = found.contents.repo_id;
+      if (!worktreeId) worktreeId = found.contents.worktree_id;
+    }
+  }
+  if (!repoId) {
+    throw new Error(
+      `Could not determine repo_id.
+
+Provide it via one of:
+  --repo-id <uuid>              CLI flag
+  CODEBYPLAN_REPO_ID=<uuid>     environment variable
+  .codebyplan/repo.json         { "repo_id": "<uuid>" } in project root
+  Run 'codebyplan setup' to initialize this project`
     );
-    process.exitCode = 1;
-    return;
   }
+  return { repoId, worktreeId, projectPath };
+}
+var init_flags = __esm({
+  "src/lib/flags.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/tech-detect.ts
+import { readFile as readFile7, access, readdir } from "node:fs/promises";
+import { join as join9, relative as relative2 } from "node:path";
+async function fileExists(filePath) {
   try {
-    const files = walkTemplates(templatesDir);
-    const manifestEntries = [];
-    for (const f of files) {
-      const absDest = path4.join(projectDir, ".claude", f.dest);
-      const absSrc = path4.join(templatesDir, f.src);
-      if (opts.dryRun) {
-        if (opts.verbose) {
-          console.log(`[dry-run] would copy ${f.src} \u2192 .claude/${f.dest}`);
-        }
-      } else {
-        fs3.mkdirSync(path4.dirname(absDest), { recursive: true });
-        fs3.copyFileSync(absSrc, absDest);
-        if (opts.verbose) {
-          console.log(`copied ${f.src} \u2192 .claude/${f.dest}`);
-        }
-      }
-      manifestEntries.push({ src: f.src, dest: f.dest, hash: f.hash });
-    }
-    const hooksJsonPath = path4.join(templatesDir, "hooks", "hooks.json");
-    const baseSettingsPath = path4.join(
-      templatesDir,
-      "settings.project.base.json"
-    );
-    const hasHooks = fs3.existsSync(hooksJsonPath);
-    const hasBase = fs3.existsSync(baseSettingsPath);
-    const settingsPath = path4.join(projectDir, ".claude", "settings.json");
-    const existingSettings = fs3.existsSync(settingsPath) ? JSON.parse(fs3.readFileSync(settingsPath, "utf8")) : {};
-    if (hasBase) {
-      const base = JSON.parse(
-        fs3.readFileSync(baseSettingsPath, "utf8")
-      );
-      mergeBaseSettingsIntoSettings(existingSettings, base);
-    }
-    if (hasHooks) {
-      const hooksJson = JSON.parse(
-        fs3.readFileSync(hooksJsonPath, "utf8")
-      );
-      mergeHooksIntoSettings(existingSettings, hooksJson);
-    }
-    if (!opts.dryRun) {
-      fs3.mkdirSync(path4.dirname(settingsPath), { recursive: true });
-      fs3.writeFileSync(
-        settingsPath,
-        JSON.stringify(existingSettings, null, 2) + "\n",
-        "utf8"
-      );
-    } else if (opts.verbose) {
-      console.log(
-        `[dry-run] would merge settings into ${path4.relative(projectDir, settingsPath)}`
-      );
-    }
-    const gitignoreAction = await ensureManagedGitignoreBlock(
-      projectDir,
-      opts.dryRun
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function discoverMonorepoApps(projectPath) {
+  const apps = [];
+  const patterns = [];
+  try {
+    const raw = await readFile7(
+      join9(projectPath, "pnpm-workspace.yaml"),
+      "utf-8"
     );
-    if (opts.verbose && gitignoreAction !== "unchanged") {
-      console.log(
-        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path4.relative(projectDir, path4.join(projectDir, ".gitignore"))}`
-      );
+    const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
+    if (matches) {
+      for (const m of matches) {
+        const pattern = m.replace(/^\s*-\s*['"]?/, "").replace(/['"]?\s*$/, "").trim();
+        if (pattern) patterns.push(pattern);
+      }
     }
-    if (!opts.dryRun) {
-      const manifest = defaultManifest();
-      manifest.files = manifestEntries;
-      writeManifest(projectDir, manifest);
+  } catch {
+  }
+  if (patterns.length === 0) {
+    try {
+      const raw = await readFile7(join9(projectPath, "package.json"), "utf-8");
+      const pkg = JSON.parse(raw);
+      const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
+      if (ws) patterns.push(...ws);
+    } catch {
     }
-    console.log(
-      `codebyplan claude install${opts.dryRun ? " (dry-run)" : ""}: ${manifestEntries.length} files, ${countHookEntries(templatesDir)} hook entries.`
-    );
-    if (opts.renderer && !opts.dryRun) {
-      await writeStatuslineLocalConfig(projectDir, { renderer: opts.renderer });
+  }
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const dir = pattern.slice(0, -2);
+      const absDir = join9(projectPath, dir);
+      try {
+        const entries = await readdir(absDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const relPath = join9(dir, entry.name);
+            const absPath = join9(absDir, entry.name);
+            if (await fileExists(join9(absPath, "package.json"))) {
+              apps.push({ name: entry.name, path: relPath, absPath });
+            }
+          }
+        }
+      } catch {
+      }
     }
-  } catch (err) {
-    console.error(
-      `codebyplan claude install failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-    process.exitCode = 1;
   }
+  return apps;
 }
-function runInstallUser(opts, deps) {
-  let templatesDir;
+async function hasJsxFile(dir, depth = 0) {
+  if (depth > 6) return false;
   try {
-    templatesDir = deps.templatesDir ?? resolveTemplatesDir();
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const name = entry.name;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
+        if (await hasJsxFile(join9(dir, name), depth + 1)) return true;
+      } else if (entry.isFile()) {
+        if (JSX_TEST_PATTERN.test(name)) continue;
+        if (name.endsWith(".tsx") || name.endsWith(".jsx")) return true;
+      }
+    }
   } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return false;
+    }
     console.error(
-      err instanceof Error ? err.message : `codebyplan claude install: ${String(err)}`
+      `detectCapabilities: readdir failed for ${dir}: ${err instanceof Error ? err.message : String(err)}`
     );
-    process.exitCode = 1;
-    return;
   }
-  try {
-    const userDir = deps.userDir ?? path4.join(os2.homedir(), ".claude");
-    const settingsPath = path4.join(userDir, "settings.json");
-    const userBaseSettingsPath = path4.join(
-      templatesDir,
-      "settings.user.base.json"
-    );
-    if (!fs3.existsSync(userBaseSettingsPath)) {
-      console.error(
-        "codebyplan claude install: settings.user.base.json not found in templates."
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const userBase = JSON.parse(
-      fs3.readFileSync(userBaseSettingsPath, "utf8")
-    );
-    const existingSettings = fs3.existsSync(settingsPath) ? JSON.parse(fs3.readFileSync(settingsPath, "utf8")) : {};
-    mergeBaseSettingsIntoSettings(existingSettings, userBase);
-    if (!opts.dryRun) {
-      fs3.mkdirSync(userDir, { recursive: true });
-      fs3.writeFileSync(
-        settingsPath,
-        JSON.stringify(existingSettings, null, 2) + "\n",
-        "utf8"
-      );
-      const manifest = defaultManifest();
-      manifest.files = [];
-      writeManifestForScope("user", manifest, userDir);
-    } else if (opts.verbose) {
-      console.log(
-        `[dry-run] would merge user base settings into ${settingsPath}`
-      );
+  return false;
+}
+async function detectCapabilities(dirPath, pkgJson) {
+  const caps = /* @__PURE__ */ new Set();
+  for (const sub of JSX_SCAN_DIRS) {
+    if (await hasJsxFile(join9(dirPath, sub))) {
+      caps.add("jsx");
+      break;
     }
-    console.log(
-      `codebyplan claude install --scope user${opts.dryRun ? " (dry-run)" : ""}: settings.json updated, 0 template files copied.`
-    );
-  } catch (err) {
-    console.error(
-      `codebyplan claude install failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-    process.exitCode = 1;
   }
-}
-function countHookEntries(templatesDir) {
-  const p = path4.join(templatesDir, "hooks", "hooks.json");
-  if (!fs3.existsSync(p)) return 0;
-  try {
-    const j = JSON.parse(fs3.readFileSync(p, "utf8"));
-    let n = 0;
-    for (const blocks of Object.values(j.hooks)) {
-      for (const b of blocks) n += b.hooks.length;
+  if (pkgJson) {
+    const allDeps = {
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    };
+    for (const dep of Object.keys(allDeps)) {
+      if (SERVER_FRAMEWORK_DEPS.has(dep)) {
+        caps.add("node-server");
+        break;
+      }
+    }
+    if (!caps.has("node-server") && typeof pkgJson.main === "string") {
+      if (SERVER_MAIN_ENTRIES.has(pkgJson.main.trim())) {
+        caps.add("node-server");
+      }
     }
-    return n;
-  } catch (err) {
-    console.error(
-      `codebyplan: could not count hook entries in hooks.json: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return 0;
   }
-}
-var init_install = __esm({
-  "src/cli/claude/install.ts"() {
-    "use strict";
-    init_template_walker();
-    init_gitignore_block();
-    init_manifest();
-    init_settings_merge();
-    init_statusline_config();
+  if (!caps.has("node-server") && await fileExists(join9(dirPath, "src", "main.ts"))) {
+    caps.add("node-server");
   }
-});
-
-// src/cli/setup.ts
-var setup_exports = {};
-__export(setup_exports, {
-  runSetup: () => runSetup
-});
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { join as join9 } from "node:path";
-import { stdin, stdout as stdout2 } from "node:process";
-import { createInterface } from "node:readline/promises";
-function getConfigPath(scope) {
-  return scope === "user" ? join9(homedir4(), ".claude.json") : join9(process.cwd(), ".mcp.json");
+  if (pkgJson && pkgJson.bin) {
+    if (typeof pkgJson.bin === "string" && pkgJson.bin.trim().length > 0) {
+      caps.add("cli-bin");
+    } else if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && Object.keys(pkgJson.bin).length > 0) {
+      caps.add("cli-bin");
+    }
+  }
+  return caps;
 }
-async function readConfig(path10) {
+async function detectFromDirectory(dirPath) {
+  const seen = /* @__PURE__ */ new Map();
+  let pkgJson = null;
   try {
-    const raw = await readFile6(path10, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      return parsed;
+    const raw = await readFile7(join9(dirPath, "package.json"), "utf-8");
+    pkgJson = JSON.parse(raw);
+    const allDeps = {
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    };
+    for (const depName of Object.keys(allDeps)) {
+      const rule = PACKAGE_MAP[depName];
+      if (rule) {
+        const key = rule.name.toLowerCase();
+        if (!seen.has(key)) {
+          seen.set(key, { name: rule.name, category: rule.category });
+        }
+        continue;
+      }
+      for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
+        if (depName.startsWith(prefix)) {
+          const key = prefixRule.name.toLowerCase();
+          if (!seen.has(key)) {
+            seen.set(key, {
+              name: prefixRule.name,
+              category: prefixRule.category
+            });
+          }
+          break;
+        }
+      }
     }
-    return {};
   } catch {
-    return {};
   }
-}
-function buildMcpEntry() {
-  return { type: "http", url: mcpEndpoint() };
-}
-async function writeMcpConfig(scope) {
-  const configPath = getConfigPath(scope);
-  const config = await readConfig(configPath);
-  if (typeof config.mcpServers !== "object" || config.mcpServers === null || Array.isArray(config.mcpServers)) {
-    config.mcpServers = {};
-  }
-  config.mcpServers.codebyplan = buildMcpEntry();
-  await writeFile6(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  return configPath;
-}
-async function fetchRepos(auth) {
-  const baseUrl3 = (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
-  const headers = auth.kind === "oauth" ? { Authorization: `Bearer ${await getAccessToken()}` } : { "x-api-key": auth.apiKey };
-  const res = await fetch(`${baseUrl3}/api/repos`, {
-    headers,
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (res.status === 401) {
-    if (auth.kind === "oauth") {
-      throw new Error(
-        "Session rejected. Run `codebyplan logout && codebyplan login`."
-      );
+  for (const { file, rule } of CONFIG_FILE_MAP) {
+    const key = rule.name.toLowerCase();
+    if (!seen.has(key) && await fileExists(join9(dirPath, file))) {
+      seen.set(key, { name: rule.name, category: rule.category });
     }
-    throw new Error("Invalid API key. Please check and try again.");
   }
-  if (!res.ok) {
-    console.log(
-      `  Warning: API returned status ${res.status}, but continuing.
-`
+  const capabilities = await detectCapabilities(dirPath, pkgJson);
+  const capsArray = Array.from(capabilities).sort();
+  const entries = Array.from(seen.values()).map((entry) => {
+    const isBearer = CAPABILITY_BEARER_NAMES.has(entry.name.toLowerCase());
+    return {
+      ...entry,
+      capabilities: isBearer ? capsArray : []
+    };
+  });
+  if (capsArray.length > 0) {
+    const hasBearerWithCaps = entries.some(
+      (e) => CAPABILITY_BEARER_NAMES.has(e.name.toLowerCase()) && (e.capabilities?.some((c) => c.length > 0) ?? false)
     );
-    return [];
+    if (!hasBearerWithCaps) {
+      entries.push({
+        name: SYNTHETIC_CARRIER_NAME,
+        category: "tool",
+        capabilities: capsArray
+      });
+    }
   }
-  const body = await res.json();
-  return body.data ?? [];
+  return entries.sort(compareByCategoryThenName);
 }
-async function chooseAuthMode(rl) {
-  console.log("  How would you like to authenticate?\n");
-  console.log("    1. OAuth \u2014 open browser to sign in (recommended)");
-  console.log(
-    "    2. Legacy API key \u2014 for the 30-day shim (deprecated 2026-06-30)\n"
-  );
-  const choice = (await rl.question("  Select (1/2, default: 1): ")).trim();
-  if (choice === "" || choice === "1") {
-    try {
-      await runLogin();
-      return { kind: "oauth" };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.log(`
-  OAuth login failed: ${msg}
-`);
-      return null;
+function collectCapabilities(entries) {
+  const set = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.capabilities) continue;
+    for (const cap of entry.capabilities) {
+      if (typeof cap === "string" && cap.length > 0) {
+        set.add(cap.toLowerCase());
+      }
     }
   }
-  const apiKey = (await rl.question("  Enter your API key: ")).trim();
-  if (!apiKey) {
-    console.log("\n  No API key provided. Aborting setup.\n");
-    return null;
-  }
-  return { kind: "legacy", apiKey };
+  return Array.from(set).sort();
 }
-async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
-  const codebyplanDir = join9(projectPath, ".codebyplan");
-  await mkdir4(codebyplanDir, { recursive: true });
-  const repoJson = {
-    repo_id: selectedRepo.id
-  };
-  const repoAny = selectedRepo;
-  if (typeof repoAny.organization_id === "string") {
-    repoJson.organization_id = repoAny.organization_id;
+async function detectTechStack(projectPath) {
+  const repo = await detectFromDirectory(projectPath);
+  const discoveredApps = await discoverMonorepoApps(projectPath);
+  const apps = [];
+  for (const app of discoveredApps) {
+    const stack = await detectFromDirectory(app.absPath);
+    if (stack.length > 0) {
+      apps.push({ name: app.name, path: app.path, stack });
+    }
   }
-  if (typeof repoAny.project_id === "string") {
-    repoJson.project_id = repoAny.project_id;
+  const flatMap = /* @__PURE__ */ new Map();
+  for (const entry of repo) {
+    flatMap.set(entry.name.toLowerCase(), entry);
   }
-  await writeFile6(
-    join9(codebyplanDir, "repo.json"),
-    JSON.stringify(repoJson, null, 2) + "\n",
-    "utf-8"
+  for (const app of apps) {
+    for (const entry of app.stack) {
+      const key = entry.name.toLowerCase();
+      const existing = flatMap.get(key);
+      if (!existing) {
+        flatMap.set(key, entry);
+      } else if (entry.capabilities?.length) {
+        const merged = Array.from(
+          /* @__PURE__ */ new Set([...existing.capabilities ?? [], ...entry.capabilities])
+        ).sort();
+        flatMap.set(key, { ...existing, capabilities: merged });
+      }
+    }
+  }
+  const repoCleaned = stripSyntheticIfCovered(repo).sort(
+    compareByCategoryThenName
   );
-  await writeFile6(
-    join9(codebyplanDir, "server.json"),
-    JSON.stringify(
-      {
-        server_port: null,
-        server_type: null,
-        auto_push_enabled: false,
-        port_allocations: []
-      },
-      null,
-      2
-    ) + "\n",
-    "utf-8"
-  );
-  await writeFile6(
-    join9(codebyplanDir, "git.json"),
-    JSON.stringify({ git_branch: null, branch_config: null }, null, 2) + "\n",
-    "utf-8"
-  );
-  await writeFile6(
-    join9(codebyplanDir, "shipment.json"),
-    JSON.stringify({ shipment: null }, null, 2) + "\n",
-    "utf-8"
-  );
-  await writeFile6(
-    join9(codebyplanDir, "vendor.json"),
-    JSON.stringify({}, null, 2) + "\n",
-    "utf-8"
-  );
-  await writeFile6(
-    join9(codebyplanDir, "e2e.json"),
-    JSON.stringify({}, null, 2) + "\n",
-    "utf-8"
-  );
-  await writeFile6(
-    join9(codebyplanDir, "eslint.json"),
-    JSON.stringify({}, null, 2) + "\n",
-    "utf-8"
+  const appsCleaned = apps.map((a) => ({
+    ...a,
+    stack: stripSyntheticIfCovered(a.stack).sort(compareByCategoryThenName)
+  }));
+  const flat = stripSyntheticIfCovered(Array.from(flatMap.values())).sort(
+    compareByCategoryThenName
   );
-  const statuslinePath = join9(codebyplanDir, "statusline.json");
-  let statuslineExists = false;
-  try {
-    await readFile6(statuslinePath, "utf-8");
-    statuslineExists = true;
-  } catch {
+  return { repo: repoCleaned, apps: appsCleaned, flat };
+}
+function stripSyntheticIfCovered(entries) {
+  const synth = entries.find((e) => e.name === SYNTHETIC_CARRIER_NAME);
+  if (!synth?.capabilities?.length) return entries;
+  const realBearerCaps = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.name === SYNTHETIC_CARRIER_NAME) continue;
+    for (const c of e.capabilities ?? []) realBearerCaps.add(c);
   }
-  if (!statuslineExists) {
-    await writeFile6(
-      statuslinePath,
-      JSON.stringify(STATUSLINE_DEFAULTS, null, 2) + "\n",
-      "utf-8"
+  if (synth.capabilities.every((c) => realBearerCaps.has(c))) {
+    return entries.filter((e) => e.name !== SYNTHETIC_CARRIER_NAME);
+  }
+  return entries;
+}
+function mergeTechStack(remote, detected) {
+  const stripCarrier = (e) => e.name !== SYNTHETIC_CARRIER_NAME;
+  const cleanDetected = {
+    repo: detected.repo.filter(stripCarrier),
+    apps: detected.apps.map((a) => ({
+      ...a,
+      stack: a.stack.filter(stripCarrier)
+    })),
+    flat: detected.flat.filter(stripCarrier)
+  };
+  const remoteResult = Array.isArray(remote) ? {
+    repo: remote.filter(stripCarrier),
+    apps: [],
+    flat: remote.filter(stripCarrier)
+  } : {
+    repo: remote.repo.filter(stripCarrier),
+    apps: remote.apps.map((a) => ({
+      ...a,
+      stack: a.stack.filter(stripCarrier)
+    })),
+    flat: remote.flat.filter(stripCarrier)
+  };
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of remoteResult.flat) {
+    seen.set(entry.name.toLowerCase(), entry);
+  }
+  const added = [];
+  for (const entry of cleanDetected.flat) {
+    const key = entry.name.toLowerCase();
+    if (!seen.has(key)) {
+      seen.set(key, entry);
+      added.push(entry);
+    }
+  }
+  const flat = Array.from(seen.values()).sort(compareByCategoryThenName);
+  const merged = {
+    repo: cleanDetected.repo,
+    apps: cleanDetected.apps,
+    flat
+  };
+  return { merged, added };
+}
+function parseTechStack(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter(
+      (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.category === "string"
     );
   }
-  await writeLocalConfig(projectPath, { device_id: deviceId });
-  console.log(`  Created ${codebyplanDir}/`);
-  console.log(
-    `    repo.json, server.json, git.json, shipment.json, vendor.json, e2e.json, eslint.json, statusline.json`
-  );
-  console.log(`    device.local.json (gitignored)`);
-  const gitignoreAction = await ensureManagedGitignoreBlock(projectPath);
-  if (gitignoreAction !== "unchanged") {
-    console.log("  Updated .gitignore (codebyplan managed block)");
+  if (typeof raw === "object" && raw !== null && "flat" in raw) {
+    return parseTechStack(raw.flat);
   }
+  return [];
 }
-async function runSetup() {
-  const rl = createInterface({ input: stdin, output: stdout2 });
-  console.log("\n  CodeByPlan Setup\n");
-  console.log("  This will configure Claude Code to use CodeByPlan.\n");
+function parseAppTechStacks(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.path === "string" && Array.isArray(item.stack)
+  ).map((item) => ({
+    name: item.name,
+    path: item.path,
+    stack: parseTechStack(item.stack)
+  }));
+}
+function parseTechStackResult(raw) {
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && "flat" in raw) {
+    const obj = raw;
+    return {
+      repo: parseTechStack(obj.repo),
+      apps: parseAppTechStacks(obj.apps),
+      flat: parseTechStack(obj.flat)
+    };
+  }
+  const flat = parseTechStack(raw);
+  return { repo: flat, apps: [], flat };
+}
+function categorizeDependency(depName) {
+  const rule = PACKAGE_MAP[depName];
+  if (rule) return rule.category;
+  for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
+    if (depName.startsWith(prefix)) return prefixRule.category;
+  }
+  return "other";
+}
+async function findPackageJsonFiles(dir, projectPath, depth = 0) {
+  if (depth > 4) return [];
+  const results = [];
+  const pkgPath = join9(dir, "package.json");
+  if (await fileExists(pkgPath)) {
+    results.push(pkgPath);
+  }
   try {
-    const auth = await chooseAuthMode(rl);
-    if (!auth) return;
-    console.log("\n  Where should the MCP server be configured?\n");
-    console.log("    1. Global \u2014 available in all projects (~/.claude.json)");
-    console.log("    2. Project \u2014 only this project (.mcp.json)\n");
-    const scopeInput = (await rl.question("  Select (1/2, default: 1): ")).trim();
-    const scope = scopeInput === "2" ? "project" : "user";
-    console.log("\n  Configuring MCP server...");
-    const configPath = await writeMcpConfig(scope);
-    console.log(`  Done! Config written to ${configPath}
-`);
-    let repos = [];
-    try {
-      repos = await fetchRepos(auth);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.log(`  ${msg}
-`);
-      return;
-    }
-    if (repos.length === 0) {
-      console.log(
-        "  No repositories found. Create one at https://codebyplan.com after setup.\n"
-      );
-      console.log(
-        "  Setup complete! Start a new Claude Code session to begin.\n"
-      );
-      return;
-    }
-    console.log("  Initialize this project?\n");
-    const initAnswer = (await rl.question("  Link to a repository? (Y/n): ")).trim().toLowerCase();
-    if (initAnswer !== "" && initAnswer !== "y" && initAnswer !== "yes") {
-      console.log(
-        "  Setup complete! Start a new Claude Code session to begin.\n"
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+      const subResults = await findPackageJsonFiles(
+        join9(dir, entry.name),
+        projectPath,
+        depth + 1
       );
-      return;
-    }
-    if (auth.kind === "legacy") {
-      process.env.CODEBYPLAN_API_KEY = auth.apiKey;
-    }
-    console.log("\n  Your repositories:\n");
-    for (let i = 0; i < repos.length; i++) {
-      console.log(`    ${i + 1}. ${repos[i].name}`);
-    }
-    console.log();
-    const choice = (await rl.question("  Select a repository (number): ")).trim();
-    const index = parseInt(choice, 10) - 1;
-    if (isNaN(index) || index < 0 || index >= repos.length) {
-      console.log("  Invalid selection. Skipping project init.\n");
-      return;
-    }
-    const selectedRepo = repos[index];
-    console.log(`
-  Selected: ${selectedRepo.name}
-`);
-    const projectPath = process.cwd();
-    const pathBasedId = await resolveAndCacheWorktreeId(
-      selectedRepo.id,
-      projectPath,
-      { skipWrite: true }
-    );
-    const deviceId = await getOrCreateDeviceId(projectPath);
-    let branch = "main";
-    try {
-      const { execSync: execSync9 } = await import("node:child_process");
-      branch = execSync9("git symbolic-ref --short HEAD", {
-        cwd: projectPath,
-        encoding: "utf-8"
-      }).trim();
-    } catch {
+      results.push(...subResults);
     }
-    const tupleId = await resolveWorktreeId({
-      repoId: selectedRepo.id,
-      repoPath: projectPath,
-      branch,
-      deviceId
-    });
-    const _worktreeId = tupleId ?? pathBasedId;
-    void _worktreeId;
-    await writeCodebyplanDirectory(projectPath, selectedRepo, deviceId);
-    const priorExitCode = process.exitCode;
-    let installFailed = false;
+  } catch {
+  }
+  return results;
+}
+async function scanAllDependencies(projectPath) {
+  const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
+  const dependencies = [];
+  for (const pkgPath of packageJsonPaths) {
     try {
-      const { runInstall: runInstall2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-      await runInstall2(
-        { yes: true, dryRun: false, verbose: false, scope: "project" },
-        { projectDir: projectPath }
-      );
-      installFailed = process.exitCode !== priorExitCode;
+      const raw = await readFile7(pkgPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const sourcePath = relative2(projectPath, pkgPath);
+      const depSections = [
+        { deps: pkg.dependencies, depType: "production", isDev: false },
+        { deps: pkg.devDependencies, depType: "dev", isDev: true },
+        { deps: pkg.peerDependencies, depType: "peer", isDev: false },
+        { deps: pkg.optionalDependencies, depType: "optional", isDev: false }
+      ];
+      for (const { deps, depType, isDev } of depSections) {
+        if (!deps) continue;
+        for (const [name, version] of Object.entries(deps)) {
+          dependencies.push({
+            name,
+            version,
+            category: categorizeDependency(name),
+            source_path: sourcePath,
+            is_dev: isDev,
+            dep_type: depType
+          });
+        }
+      }
     } catch {
-      installFailed = true;
     }
-    if (installFailed) {
-      process.exitCode = priorExitCode;
-      console.log(
-        "  Warning: .claude/ install step failed. Run `codebyplan claude install` manually."
-      );
-    }
-    const existingRenderer = await readStatuslineLocalConfig(projectPath);
-    const isInteractive = process.stdin.isTTY === true;
-    if (!existingRenderer && isInteractive) {
-      const availability = detectAvailableRenderers();
-      const available = Object.entries(availability).filter(([, v]) => v).map(([k]) => k).join(", ");
-      console.log(
-        `
-  Which statusline renderer would you like to use? (available: ${available})`
-      );
-      console.log("    bash   \u2014 shell script, zero dependencies (default)");
-      console.log("    node   \u2014 Node.js renderer");
-      console.log("    python \u2014 Python 3 renderer");
-      const rendererInput = (await rl.question(
-        "  Select renderer (bash/node/python, default: bash): "
-      )).trim().toLowerCase();
-      const chosen = rendererInput === "node" ? "node" : rendererInput === "python" ? "python" : "bash";
-      await writeStatuslineLocalConfig(projectPath, { renderer: chosen });
-      if (!availability[chosen]) {
-        console.log(
-          `  Warning: '${chosen}' was not detected on this machine. You can change it later with \`codebyplan statusline\`.`
-        );
-      } else {
-        console.log(`  Renderer set to '${chosen}'.`);
+  }
+  return { dependencies };
+}
+var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SYNTHETIC_CARRIER_NAME, CAPABILITY_BEARER_NAMES, JSX_TEST_PATTERN, JSX_SKIP_DIRS, JSX_SCAN_DIRS, SERVER_MAIN_ENTRIES, SERVER_FRAMEWORK_DEPS, compareByCategoryThenName, SKIP_DIRS;
+var init_tech_detect = __esm({
+  "src/lib/tech-detect.ts"() {
+    "use strict";
+    PACKAGE_MAP = {
+      // Frameworks
+      next: { name: "Next.js", category: "framework" },
+      nuxt: { name: "Nuxt", category: "framework" },
+      gatsby: { name: "Gatsby", category: "framework" },
+      express: { name: "Express", category: "framework" },
+      fastify: { name: "Fastify", category: "framework" },
+      hono: { name: "Hono", category: "framework" },
+      "@remix-run/node": { name: "Remix", category: "framework" },
+      svelte: { name: "Svelte", category: "framework" },
+      astro: { name: "Astro", category: "framework" },
+      "@angular/core": { name: "Angular", category: "framework" },
+      "@nestjs/core": { name: "NestJS", category: "framework" },
+      // Libraries (UI)
+      react: { name: "React", category: "framework" },
+      vue: { name: "Vue", category: "framework" },
+      "solid-js": { name: "Solid", category: "framework" },
+      preact: { name: "Preact", category: "framework" },
+      // Languages (detected via devDeps)
+      typescript: { name: "TypeScript", category: "language" },
+      // Styling
+      tailwindcss: { name: "Tailwind CSS", category: "styling" },
+      sass: { name: "SCSS", category: "styling" },
+      "styled-components": { name: "styled-components", category: "styling" },
+      "@emotion/react": { name: "Emotion", category: "styling" },
+      // Database
+      prisma: { name: "Prisma", category: "database" },
+      "@prisma/client": { name: "Prisma", category: "database" },
+      "drizzle-orm": { name: "Drizzle", category: "database" },
+      "@supabase/supabase-js": { name: "Supabase", category: "database" },
+      mongoose: { name: "MongoDB", category: "database" },
+      typeorm: { name: "TypeORM", category: "database" },
+      knex: { name: "Knex", category: "database" },
+      // Testing
+      jest: { name: "Jest", category: "testing" },
+      vitest: { name: "Vitest", category: "testing" },
+      mocha: { name: "Mocha", category: "testing" },
+      playwright: { name: "Playwright", category: "testing" },
+      "@playwright/test": { name: "Playwright", category: "testing" },
+      cypress: { name: "Cypress", category: "testing" },
+      supertest: { name: "Supertest", category: "testing" },
+      webdriverio: { name: "WebdriverIO", category: "testing" },
+      "@wdio/cli": { name: "WebdriverIO", category: "testing" },
+      "@vscode/test-cli": { name: "VS Code Test CLI", category: "testing" },
+      // Build tools
+      turbo: { name: "Turborepo", category: "build" },
+      vite: { name: "Vite", category: "build" },
+      webpack: { name: "Webpack", category: "build" },
+      esbuild: { name: "esbuild", category: "build" },
+      rollup: { name: "Rollup", category: "build" },
+      nx: { name: "Nx", category: "build" },
+      lerna: { name: "Lerna", category: "build" },
+      tsup: { name: "tsup", category: "build" },
+      "@swc/core": { name: "SWC", category: "build" },
+      parcel: { name: "Parcel", category: "build" },
+      // Tools
+      eslint: { name: "ESLint", category: "tool" },
+      prettier: { name: "Prettier", category: "tool" },
+      "@biomejs/biome": { name: "Biome", category: "tool" },
+      storybook: { name: "Storybook", category: "tool" },
+      // Component libs
+      "@mui/material": { name: "MUI", category: "component-lib" },
+      "@chakra-ui/react": { name: "Chakra UI", category: "component-lib" },
+      "@mantine/core": { name: "Mantine", category: "component-lib" },
+      // GraphQL
+      graphql: { name: "GraphQL", category: "graphql" },
+      "@apollo/client": { name: "Apollo Client", category: "graphql" },
+      urql: { name: "urql", category: "graphql" },
+      "graphql-request": { name: "graphql-request", category: "graphql" },
+      // Documentation
+      typedoc: { name: "TypeDoc", category: "documentation" },
+      "@docusaurus/core": { name: "Docusaurus", category: "documentation" },
+      vitepress: { name: "VitePress", category: "documentation" },
+      // Code quality
+      husky: { name: "Husky", category: "quality" },
+      "lint-staged": { name: "lint-staged", category: "quality" },
+      commitlint: { name: "commitlint", category: "quality" },
+      "@commitlint/cli": { name: "commitlint", category: "quality" },
+      // Mobile
+      "react-native": { name: "React Native", category: "mobile" },
+      expo: { name: "Expo", category: "mobile" }
+    };
+    PACKAGE_PREFIX_MAP = [
+      {
+        prefix: "@radix-ui/",
+        rule: { name: "Radix UI", category: "component-lib" }
+      },
+      { prefix: "@storybook/", rule: { name: "Storybook", category: "tool" } },
+      {
+        prefix: "@testing-library/",
+        rule: { name: "Testing Library", category: "testing" }
+      }
+    ];
+    CONFIG_FILE_MAP = [
+      { file: "tsconfig.json", rule: { name: "TypeScript", category: "language" } },
+      { file: "next.config.js", rule: { name: "Next.js", category: "framework" } },
+      { file: "next.config.mjs", rule: { name: "Next.js", category: "framework" } },
+      { file: "next.config.ts", rule: { name: "Next.js", category: "framework" } },
+      {
+        file: "tailwind.config.js",
+        rule: { name: "Tailwind CSS", category: "styling" }
+      },
+      {
+        file: "tailwind.config.ts",
+        rule: { name: "Tailwind CSS", category: "styling" }
+      },
+      { file: "turbo.json", rule: { name: "Turborepo", category: "build" } },
+      {
+        file: "docker-compose.yml",
+        rule: { name: "Docker", category: "deployment" }
+      },
+      {
+        file: "docker-compose.yaml",
+        rule: { name: "Docker", category: "deployment" }
+      },
+      { file: "Dockerfile", rule: { name: "Docker", category: "deployment" } },
+      { file: "vercel.json", rule: { name: "Vercel", category: "deployment" } },
+      { file: ".storybook/main.js", rule: { name: "Storybook", category: "tool" } },
+      { file: ".storybook/main.ts", rule: { name: "Storybook", category: "tool" } },
+      {
+        file: ".storybook/main.mjs",
+        rule: { name: "Storybook", category: "tool" }
+      },
+      {
+        file: "components.json",
+        rule: { name: "shadcn/ui", category: "component-lib" }
+      },
+      { file: "nx.json", rule: { name: "Nx", category: "build" } },
+      { file: "lerna.json", rule: { name: "Lerna", category: "build" } },
+      {
+        file: "playwright.config.ts",
+        rule: { name: "Playwright", category: "testing" }
+      },
+      {
+        file: "playwright.config.js",
+        rule: { name: "Playwright", category: "testing" }
+      },
+      {
+        file: "playwright.config.mjs",
+        rule: { name: "Playwright", category: "testing" }
+      },
+      { file: "wdio.conf.ts", rule: { name: "WebdriverIO", category: "testing" } },
+      {
+        file: "wdio.conf.js",
+        rule: { name: "WebdriverIO", category: "testing" }
+      },
+      {
+        file: "maestro/config.yaml",
+        rule: { name: "Maestro", category: "testing" }
       }
-    }
-    console.log(
-      "\n  Run `npx codebyplan config` to sync repo config from the DB."
-    );
-    console.log(
-      "  Setup complete! Start a new Claude Code session to begin.\n"
-    );
-  } finally {
-    rl.close();
-  }
-}
-var init_setup = __esm({
-  "src/cli/setup.ts"() {
-    "use strict";
-    init_gitignore_block();
-    init_local_config();
-    init_statusline_config();
-    init_resolve_worktree();
-    init_token_refresh();
-    init_urls();
-    init_login();
+    ];
+    SYNTHETIC_CARRIER_NAME = "__capabilities__";
+    CAPABILITY_BEARER_NAMES = /* @__PURE__ */ new Set([
+      "react",
+      "next.js",
+      "vue",
+      "svelte",
+      "solid",
+      "preact",
+      "remix",
+      "astro",
+      "angular",
+      "nestjs",
+      "nuxt",
+      "gatsby",
+      "express",
+      "fastify",
+      "hono",
+      "react native",
+      "expo"
+    ]);
+    JSX_TEST_PATTERN = /\.(test|spec)\.(tsx|jsx)$/;
+    JSX_SKIP_DIRS = /* @__PURE__ */ new Set(["__tests__", "test", "tests"]);
+    JSX_SCAN_DIRS = ["src", "app", "pages"];
+    SERVER_MAIN_ENTRIES = /* @__PURE__ */ new Set([
+      "dist/main.js",
+      "dist/server.js",
+      "dist/index.js",
+      "main.js",
+      "server.js"
+    ]);
+    SERVER_FRAMEWORK_DEPS = /* @__PURE__ */ new Set([
+      "@nestjs/core",
+      "express",
+      "fastify",
+      "hono"
+    ]);
+    compareByCategoryThenName = (a, b) => {
+      const catCmp = a.category.localeCompare(b.category);
+      if (catCmp !== 0) return catCmp;
+      return a.name.localeCompare(b.name);
+    };
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".next",
+      "dist",
+      ".turbo",
+      ".git",
+      "coverage",
+      "build",
+      "out",
+      ".vercel",
+      ".expo"
+    ]);
   }
 });
 
-// src/lib/flags.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join10, resolve as resolve2 } from "node:path";
-async function findCodebyplanConfig(startDir, maxDepth = 20) {
-  let cursor = resolve2(startDir);
-  for (let depth = 0; depth < maxDepth; depth++) {
-    const sentinelPath2 = join10(cursor, ".codebyplan", "repo.json");
-    try {
-      const raw = await readFile7(sentinelPath2, "utf-8");
-      const parsed = JSON.parse(raw);
-      return { path: sentinelPath2, contents: parsed };
-    } catch {
-    }
-    const legacyPath = join10(cursor, ".codebyplan.json");
-    try {
-      const raw = await readFile7(legacyPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      return { path: legacyPath, contents: parsed };
-    } catch {
-    }
-    const parent = resolve2(cursor, "..");
-    if (parent === cursor) return null;
-    cursor = parent;
-  }
-  return null;
-}
-function parseFlags(startIndex) {
-  const flags = {};
-  const args = process.argv.slice(startIndex);
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--") && i + 1 < args.length) {
-      const key = arg.slice(2);
-      flags[key] = args[++i];
-    }
+// src/lib/lsp-detect.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+function mapTechStackToLsp(detectedNames) {
+  const pluginIndex = new Map(
+    LSP_TABLE.map((s) => [s.plugin, s])
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const name of detectedNames) {
+    const pluginId = ALIAS_MAP[name.toLowerCase()];
+    if (!pluginId) continue;
+    if (seen.has(pluginId)) continue;
+    seen.add(pluginId);
+    const server = pluginIndex.get(pluginId);
+    if (server) result.push(server);
   }
-  return flags;
+  return result;
 }
-function hasFlag(name, startIndex) {
-  return process.argv.slice(startIndex).includes(`--${name}`);
+function binaryOnPath(binary) {
+  return probeWith("which", binary) || probeWith("where", binary);
 }
-async function resolveConfig(flags) {
-  const projectPath = flags["path"] ?? process.cwd();
-  let repoId = flags["repo-id"] ?? process.env.CODEBYPLAN_REPO_ID;
-  let worktreeId = flags["worktree-id"] ?? process.env.CODEBYPLAN_WORKTREE_ID;
-  if (!repoId) {
-    const found = await findCodebyplanConfig(projectPath);
-    if (found) {
-      repoId = found.contents.repo_id;
-      if (!worktreeId) worktreeId = found.contents.worktree_id;
-    }
-  }
-  if (!repoId) {
-    throw new Error(
-      `Could not determine repo_id.
-
-Provide it via one of:
-  --repo-id <uuid>              CLI flag
-  CODEBYPLAN_REPO_ID=<uuid>     environment variable
-  .codebyplan/repo.json         { "repo_id": "<uuid>" } in project root
-  Run 'codebyplan setup' to initialize this project`
-    );
+function probeWith(probe, binary) {
+  try {
+    const result = spawnSync2(probe, [binary], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    if (result.error) return false;
+    return result.status === 0;
+  } catch {
+    return false;
   }
-  return { repoId, worktreeId, projectPath };
 }
-var init_flags = __esm({
-  "src/lib/flags.ts"() {
+var LSP_TABLE, ALIAS_MAP;
+var init_lsp_detect = __esm({
+  "src/lib/lsp-detect.ts"() {
     "use strict";
+    LSP_TABLE = [
+      {
+        language: "TypeScript",
+        plugin: "typescript-lsp",
+        binary: "typescript-language-server",
+        npmPackage: "typescript-language-server",
+        installHint: "npm install -g typescript-language-server"
+      },
+      {
+        language: "Python",
+        plugin: "pyright-lsp",
+        binary: "pyright-langserver",
+        npmPackage: "pyright",
+        installHint: "npm install -g pyright"
+      },
+      {
+        language: "PHP",
+        plugin: "php-lsp",
+        binary: "intelephense",
+        npmPackage: "intelephense",
+        installHint: "npm install -g intelephense"
+      },
+      {
+        language: "Rust",
+        plugin: "rust-analyzer-lsp",
+        binary: "rust-analyzer",
+        npmPackage: null,
+        installHint: "rustup component add rust-analyzer"
+      },
+      {
+        language: "Go",
+        plugin: "gopls-lsp",
+        binary: "gopls",
+        npmPackage: null,
+        installHint: "go install golang.org/x/tools/gopls@latest"
+      },
+      {
+        language: "Swift",
+        plugin: "swift-lsp",
+        binary: "sourcekit-lsp",
+        npmPackage: null,
+        installHint: "Install Xcode and the Swift toolchain; sourcekit-lsp is included in the toolchain"
+      },
+      {
+        language: "C/C++",
+        plugin: "clangd-lsp",
+        binary: "clangd",
+        npmPackage: null,
+        installHint: "brew install llvm  # macOS\napt install clangd  # Debian/Ubuntu"
+      },
+      {
+        language: "C#",
+        plugin: "csharp-lsp",
+        binary: "csharp-ls",
+        npmPackage: null,
+        installHint: "dotnet tool install -g csharp-ls"
+      },
+      {
+        language: "Java",
+        plugin: "jdtls-lsp",
+        binary: "jdtls",
+        npmPackage: null,
+        installHint: "Download Eclipse JDT LS from https://github.com/eclipse-jdtls/eclipse.jdt.ls/releases"
+      },
+      {
+        language: "Kotlin",
+        plugin: "kotlin-lsp",
+        binary: "kotlin-language-server",
+        npmPackage: null,
+        installHint: "Download from https://github.com/fwcd/kotlin-language-server/releases"
+      },
+      {
+        language: "Lua",
+        plugin: "lua-lsp",
+        binary: "lua-language-server",
+        npmPackage: null,
+        installHint: "brew install lua-language-server  # macOS"
+      }
+    ];
+    ALIAS_MAP = {
+      // TypeScript / JavaScript
+      typescript: "typescript-lsp",
+      javascript: "typescript-lsp",
+      "next.js": "typescript-lsp",
+      react: "typescript-lsp",
+      vue: "typescript-lsp",
+      svelte: "typescript-lsp",
+      angular: "typescript-lsp",
+      nestjs: "typescript-lsp",
+      // Python
+      python: "pyright-lsp",
+      // PHP
+      php: "php-lsp",
+      // Rust
+      rust: "rust-analyzer-lsp",
+      // Go
+      go: "gopls-lsp",
+      golang: "gopls-lsp",
+      // Swift
+      swift: "swift-lsp",
+      // C/C++
+      "c++": "clangd-lsp",
+      "c/c++": "clangd-lsp",
+      c: "clangd-lsp",
+      clang: "clangd-lsp",
+      cpp: "clangd-lsp",
+      // C#
+      "c#": "csharp-lsp",
+      csharp: "csharp-lsp",
+      ".net": "csharp-lsp",
+      dotnet: "csharp-lsp",
+      // Java
+      java: "jdtls-lsp",
+      // Kotlin
+      kotlin: "kotlin-lsp",
+      // Lua
+      lua: "lua-lsp"
+    };
   }
 });
 
-// src/cli/statusline.ts
-var statusline_exports = {};
-__export(statusline_exports, {
-  runStatusline: () => runStatusline
+// src/cli/lsp.ts
+var lsp_exports = {};
+__export(lsp_exports, {
+  runLsp: () => runLsp,
+  runLspFull: () => runLspFull
 });
-import { dirname as dirname5 } from "node:path";
-async function resolveProjectPath() {
-  const found = await findCodebyplanConfig(process.cwd());
-  if (found) {
-    return dirname5(dirname5(found.path));
+import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir4, unlink as unlink2, access as access2 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+async function fileExists2(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  return process.cwd();
 }
-function parseRendererArg(arg) {
-  const normalised = arg.startsWith("--") ? arg.slice(2) : arg;
-  if (VALID_RENDERERS2.has(normalised)) {
-    return normalised;
+async function readJsonFile(filePath) {
+  try {
+    const raw = await readFile8(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
   }
-  return null;
 }
-async function runStatusline(args) {
-  const positional = args.filter((a) => !a.startsWith("-"));
-  const flagArgs = args.filter((a) => a.startsWith("--"));
-  const rendererTokens = [...positional, ...flagArgs].filter(
-    (a) => parseRendererArg(a) !== null
+function tryNpmInstallGlobal(pkg) {
+  try {
+    const result = spawnSync3("npm", ["i", "-g", pkg], {
+      encoding: "utf-8",
+      timeout: 6e4,
+      // "pipe" (not "inherit"): inheriting the parent's fds can surface EPIPE/EIO
+      // in piped/CI contexts as result.error even when npm itself succeeded, and
+      // interleaves npm output with our own console.log lines unpredictably.
+      stdio: "pipe"
+    });
+    if (result.error) return false;
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+async function runLspFull(projectPath, opts = {}) {
+  const dryRun = opts.dryRun ?? false;
+  console.log("\n  CodeByPlan LSP");
+  console.log(`  Path: ${projectPath}
+`);
+  const rootDetected = await detectTechStack(projectPath);
+  const allTechNames = /* @__PURE__ */ new Set();
+  for (const entry of rootDetected.flat) {
+    allTechNames.add(entry.name);
+  }
+  const servers = mapTechStackToLsp(Array.from(allTechNames));
+  if (servers.length === 0) {
+    console.log("  No LSP-relevant tech detected. Nothing to enable.\n");
+    return;
+  }
+  console.log(
+    `  Detected LSP servers: ${servers.map((s) => s.plugin).join(", ")}
+`
   );
-  if (rendererTokens.length > 1) {
-    process.stderr.write(
-      "codebyplan statusline: bash, node, and python are mutually exclusive; pass only one.\n"
+  const settingsPath = join10(projectPath, ".claude", "settings.json");
+  let settings = {};
+  const existingSettingsRaw = await readJsonFile(settingsPath);
+  if (existingSettingsRaw) {
+    settings = existingSettingsRaw;
+  }
+  mergeEnabledPluginsIntoSettings(
+    settings,
+    servers.map((s) => s.plugin)
+  );
+  if (dryRun) {
+    console.log(`  [dry-run] would update ${settingsPath}`);
+  } else {
+    await mkdir4(join10(projectPath, ".claude"), { recursive: true });
+    await writeFile6(
+      settingsPath,
+      JSON.stringify(settings, null, 2) + "\n",
+      "utf-8"
     );
-    process.exitCode = 1;
-    return;
+    console.log(`  Updated ${settingsPath}`);
   }
-  let rendererArg;
-  for (const a of [...positional, ...flagArgs]) {
-    const parsed = parseRendererArg(a);
-    if (parsed !== null) {
-      rendererArg = a;
-      break;
+  const lspJsonPath = join10(projectPath, ".codebyplan", "lsp.json");
+  const lspJsonContent = {
+    servers: servers.map((s) => ({
+      plugin: s.plugin,
+      binary: s.binary,
+      install: s.npmPackage ? `npm i -g ${s.npmPackage}` : s.installHint
+    }))
+  };
+  if (dryRun) {
+    console.log(`  [dry-run] would write ${lspJsonPath}`);
+  } else {
+    await mkdir4(join10(projectPath, ".codebyplan"), { recursive: true });
+    await writeFile6(
+      lspJsonPath,
+      JSON.stringify(lspJsonContent, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(`  Wrote ${lspJsonPath}`);
+  }
+  const todoDir = join10(projectPath, ".codebyplan", "todo", "session-start");
+  const autoInstalled = [];
+  const nudged = [];
+  for (const server of servers) {
+    if (binaryOnPath(server.binary)) {
+      continue;
+    }
+    if (server.npmPackage !== null) {
+      if (dryRun) {
+        console.log(`  [dry-run] would install ${server.npmPackage}`);
+        autoInstalled.push(server.plugin);
+      } else {
+        console.log(`  Installing ${server.npmPackage} globally...`);
+        const success = tryNpmInstallGlobal(server.npmPackage);
+        if (success && binaryOnPath(server.binary)) {
+          autoInstalled.push(server.plugin);
+          console.log(`    Installed ${server.npmPackage}.`);
+          continue;
+        }
+        console.log(
+          `    npm install failed for ${server.npmPackage}. Writing nudge file.`
+        );
+        await mkdir4(todoDir, { recursive: true });
+        const nudgeFile = join10(todoDir, `install-${server.binary}.md`);
+        const nudgeContent = `Run \`${server.installHint}\` to enable ${server.language} LSP support in Claude Code.
+`;
+        await writeFile6(nudgeFile, nudgeContent, "utf-8");
+        nudged.push(server.binary);
+      }
+    } else {
+      if (dryRun) {
+        console.log(`  [dry-run] would write nudge for ${server.binary}`);
+        nudged.push(server.binary);
+      } else {
+        await mkdir4(todoDir, { recursive: true });
+        const nudgeFile = join10(todoDir, `install-${server.binary}.md`);
+        const nudgeContent = `Run \`${server.installHint}\` to enable ${server.language} LSP support in Claude Code.
+`;
+        await writeFile6(nudgeFile, nudgeContent, "utf-8");
+        nudged.push(server.binary);
+      }
     }
   }
-  const unknownPositional = args.filter(
-    (a) => !a.startsWith("-") && !VALID_RENDERERS2.has(a)
+  const pluginNames = servers.map((s) => s.plugin);
+  console.log(`
+  Summary:`);
+  console.log(
+    `    Enabled plugins: ${pluginNames.length > 0 ? pluginNames.join(", ") : "none"}`
   );
-  if (unknownPositional.length > 0) {
-    process.stderr.write(
-      `codebyplan statusline: unknown argument '${unknownPositional[0]}'.
-
-Usage:
-  codebyplan statusline                     Show current renderer and line toggles
-  codebyplan statusline bash|node|python    Set the renderer
-  codebyplan statusline --bash|--node|--python  Set the renderer (flag form)
-`
+  console.log(
+    `    (settings.json key format: <plugin>@claude-plugins-official)`
+  );
+  if (autoInstalled.length > 0) {
+    console.log(
+      `    ${dryRun ? "Would auto-install:" : "Auto-installed:  "} ${autoInstalled.join(", ")}`
     );
-    process.exitCode = 1;
-    return;
   }
-  const unknownFlags = flagArgs.filter((a) => parseRendererArg(a) === null);
-  if (unknownFlags.length > 0) {
-    process.stderr.write(
-      `codebyplan statusline: unknown flag '${unknownFlags[0]}'.
-
-Usage:
-  codebyplan statusline                     Show current renderer and line toggles
-  codebyplan statusline bash|node|python    Set the renderer
-  codebyplan statusline --bash|--node|--python  Set the renderer (flag form)
-`
+  if (nudged.length > 0) {
+    console.log(
+      `    ${dryRun ? "Would write nudge for:" : "Manual install required for:"} ${nudged.join(", ")}`
     );
-    process.exitCode = 1;
-    return;
-  }
-  const projectPath = await resolveProjectPath();
-  if (rendererArg !== void 0) {
-    const chosen = parseRendererArg(rendererArg);
-    await writeStatuslineLocalConfig(projectPath, { renderer: chosen });
-    const availability2 = detectAvailableRenderers();
-    if (!availability2[chosen]) {
-      process.stderr.write(
-        `Warning: '${chosen}' was not detected on this machine. The renderer is saved but may not run.
-`
+    if (!dryRun) {
+      console.log(
+        `    See .codebyplan/todo/session-start/ for install instructions.`
       );
     }
-    console.log(`Statusline renderer set to '${chosen}'.`);
-    return;
   }
-  const availability = detectAvailableRenderers();
-  const [renderer, config] = await Promise.all([
-    resolveRenderer(projectPath),
-    readStatuslineConfig(projectPath)
-  ]);
-  const availStr = Object.entries(availability).map(([k, v]) => `${k}: ${v ? "yes" : "no"}`).join(", ");
-  console.log(`
-Statusline configuration`);
-  console.log(`  Renderer:     ${renderer}`);
-  console.log(`  Available:    ${availStr}`);
-  console.log(`  no_color:     ${config.no_color}`);
   console.log(`
-  Line toggles:`);
-  for (const [key, val] of Object.entries(config.lines)) {
-    console.log(`    ${key.padEnd(14)} ${val ? "on" : "off"}`);
+  LSP setup complete.
+`);
+}
+async function runLspCheck(projectPath) {
+  const lspJsonPath = join10(projectPath, ".codebyplan", "lsp.json");
+  const lspJson = await readJsonFile(lspJsonPath);
+  if (!lspJson || !Array.isArray(lspJson.servers)) {
+    return;
+  }
+  const todoDir = join10(projectPath, ".codebyplan", "todo", "session-start");
+  const stillMissing = [];
+  for (const entry of lspJson.servers) {
+    const { binary, plugin } = entry;
+    const found = binaryOnPath(binary);
+    const fullServer = LSP_TABLE.find((s) => s.plugin === plugin);
+    if (found) {
+      const nudgeFile = join10(todoDir, `install-${binary}.md`);
+      if (await fileExists2(nudgeFile)) {
+        try {
+          await unlink2(nudgeFile);
+        } catch {
+        }
+      }
+    } else {
+      const hint = fullServer?.installHint ?? entry.install;
+      stillMissing.push(hint);
+    }
+  }
+  for (const hint of stillMissing) {
+    console.log(hint);
   }
-  console.log();
 }
-var VALID_RENDERERS2;
-var init_statusline = __esm({
-  "src/cli/statusline.ts"() {
+async function runLsp() {
+  const checkMode = hasFlag("check", 3);
+  const dryRun = hasFlag("dry-run", 3);
+  const pathIdx = process.argv.indexOf("--path");
+  const pathVal = pathIdx !== -1 ? process.argv[pathIdx + 1] : void 0;
+  const projectPath = pathVal != null && !pathVal.startsWith("--") ? pathVal : process.cwd();
+  if (checkMode) {
+    await runLspCheck(projectPath);
+  } else {
+    await runLspFull(projectPath, { dryRun });
+  }
+}
+var init_lsp = __esm({
+  "src/cli/lsp.ts"() {
     "use strict";
     init_flags();
-    init_statusline_config();
-    VALID_RENDERERS2 = /* @__PURE__ */ new Set(["bash", "node", "python"]);
+    init_tech_detect();
+    init_lsp_detect();
+    init_settings_merge();
   }
 });
 
-// src/cli/logout.ts
-var logout_exports = {};
-__export(logout_exports, {
-  runLogout: () => runLogout
+// src/cli/claude/install.ts
+var install_exports = {};
+__export(install_exports, {
+  resolveTemplatesDir: () => resolveTemplatesDir,
+  runInstall: () => runInstall
 });
-async function runLogout() {
-  await clearTokens();
-  await clearClient();
-  console.log("\n  Logged out.\n");
+import * as fs3 from "node:fs";
+import * as os2 from "node:os";
+import * as path4 from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveTemplatesDir() {
+  const here = path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path4.resolve(here, "..", "templates"),
+    path4.resolve(here, "..", "..", "templates"),
+    path4.resolve(here, "..", "..", "..", "templates")
+  ];
+  for (const c of candidates) {
+    if (fs3.existsSync(c) && fs3.statSync(c).isDirectory()) {
+      return c;
+    }
+  }
+  throw new Error(
+    `codebyplan: could not locate templates/ directory. Probed:
+  ${candidates.join(
+      "\n  "
+    )}`
+  );
 }
-var init_logout = __esm({
-  "src/cli/logout.ts"() {
-    "use strict";
-    init_client_registration();
-    init_keychain();
+async function runInstall(opts, deps = {}) {
+  await Promise.resolve();
+  const scope = opts.scope ?? "project";
+  if (scope === "user") {
+    if (opts.renderer) {
+      console.warn(
+        "codebyplan claude install: --bash/--node/--python is ignored for --scope user (no project root for statusline.local.json)."
+      );
+    }
+    runInstallUser(opts, deps);
+    return;
   }
-});
-
-// src/cli/whoami.ts
-var whoami_exports = {};
-__export(whoami_exports, {
-  runWhoami: () => runWhoami
-});
-async function fetchMe(accessToken) {
+  const projectDir = deps.projectDir ?? process.cwd();
+  let templatesDir;
   try {
-    const res = await fetch(meEndpoint(), {
-      headers: { Authorization: `Bearer ${accessToken}` },
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!res.ok) return null;
-    const body = await res.json();
-    return {
-      email: body.email ?? null,
-      username: body.username ?? null
-    };
-  } catch {
-    return null;
+    templatesDir = deps.templatesDir ?? resolveTemplatesDir();
+  } catch (err) {
+    console.error(
+      err instanceof Error ? err.message : `codebyplan claude install: ${String(err)}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const files = walkTemplates(templatesDir);
+    const manifestEntries = [];
+    for (const f of files) {
+      const absDest = path4.join(projectDir, ".claude", f.dest);
+      const absSrc = path4.join(templatesDir, f.src);
+      if (opts.dryRun) {
+        if (opts.verbose) {
+          console.log(`[dry-run] would copy ${f.src} \u2192 .claude/${f.dest}`);
+        }
+      } else {
+        fs3.mkdirSync(path4.dirname(absDest), { recursive: true });
+        fs3.copyFileSync(absSrc, absDest);
+        if (opts.verbose) {
+          console.log(`copied ${f.src} \u2192 .claude/${f.dest}`);
+        }
+      }
+      manifestEntries.push({ src: f.src, dest: f.dest, hash: f.hash });
+    }
+    const hooksJsonPath = path4.join(templatesDir, "hooks", "hooks.json");
+    const baseSettingsPath = path4.join(
+      templatesDir,
+      "settings.project.base.json"
+    );
+    const hasHooks = fs3.existsSync(hooksJsonPath);
+    const hasBase = fs3.existsSync(baseSettingsPath);
+    const settingsPath = path4.join(projectDir, ".claude", "settings.json");
+    const existingSettings = fs3.existsSync(settingsPath) ? JSON.parse(fs3.readFileSync(settingsPath, "utf8")) : {};
+    if (hasBase) {
+      const base = JSON.parse(
+        fs3.readFileSync(baseSettingsPath, "utf8")
+      );
+      mergeBaseSettingsIntoSettings(existingSettings, base);
+    }
+    if (hasHooks) {
+      const hooksJson = JSON.parse(
+        fs3.readFileSync(hooksJsonPath, "utf8")
+      );
+      mergeHooksIntoSettings(existingSettings, hooksJson);
+    }
+    if (!opts.dryRun) {
+      fs3.mkdirSync(path4.dirname(settingsPath), { recursive: true });
+      fs3.writeFileSync(
+        settingsPath,
+        JSON.stringify(existingSettings, null, 2) + "\n",
+        "utf8"
+      );
+    } else if (opts.verbose) {
+      console.log(
+        `[dry-run] would merge settings into ${path4.relative(projectDir, settingsPath)}`
+      );
+    }
+    const gitignoreAction = await ensureManagedGitignoreBlock(
+      projectDir,
+      opts.dryRun
+    );
+    if (opts.verbose && gitignoreAction !== "unchanged") {
+      console.log(
+        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path4.relative(projectDir, path4.join(projectDir, ".gitignore"))}`
+      );
+    }
+    if (!opts.dryRun) {
+      const manifest = defaultManifest();
+      manifest.files = manifestEntries;
+      writeManifest(projectDir, manifest);
+    }
+    console.log(
+      `codebyplan claude install${opts.dryRun ? " (dry-run)" : ""}: ${manifestEntries.length} files, ${countHookEntries(templatesDir)} hook entries.`
+    );
+    if (opts.renderer && !opts.dryRun) {
+      await writeStatuslineLocalConfig(projectDir, { renderer: opts.renderer });
+    }
+    try {
+      const { runLspFull: runLspFull2 } = await Promise.resolve().then(() => (init_lsp(), lsp_exports));
+      await runLspFull2(projectDir, { dryRun: opts.dryRun });
+    } catch {
+    }
+  } catch (err) {
+    console.error(
+      `codebyplan claude install failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exitCode = 1;
   }
 }
-async function runWhoami(opts = {}) {
-  const tokens = await loadTokens();
-  if (opts.json) {
-    if (!tokens) {
-      console.log("null");
+function runInstallUser(opts, deps) {
+  let templatesDir;
+  try {
+    templatesDir = deps.templatesDir ?? resolveTemplatesDir();
+  } catch (err) {
+    console.error(
+      err instanceof Error ? err.message : `codebyplan claude install: ${String(err)}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const userDir = deps.userDir ?? path4.join(os2.homedir(), ".claude");
+    const settingsPath = path4.join(userDir, "settings.json");
+    const userBaseSettingsPath = path4.join(
+      templatesDir,
+      "settings.user.base.json"
+    );
+    if (!fs3.existsSync(userBaseSettingsPath)) {
+      console.error(
+        "codebyplan claude install: settings.user.base.json not found in templates."
+      );
       process.exitCode = 1;
       return;
     }
-    const me2 = await fetchMe(tokens.access_token);
+    const userBase = JSON.parse(
+      fs3.readFileSync(userBaseSettingsPath, "utf8")
+    );
+    const existingSettings = fs3.existsSync(settingsPath) ? JSON.parse(fs3.readFileSync(settingsPath, "utf8")) : {};
+    mergeBaseSettingsIntoSettings(existingSettings, userBase);
+    if (!opts.dryRun) {
+      fs3.mkdirSync(userDir, { recursive: true });
+      fs3.writeFileSync(
+        settingsPath,
+        JSON.stringify(existingSettings, null, 2) + "\n",
+        "utf8"
+      );
+      const manifest = defaultManifest();
+      manifest.files = [];
+      writeManifestForScope("user", manifest, userDir);
+    } else if (opts.verbose) {
+      console.log(
+        `[dry-run] would merge user base settings into ${settingsPath}`
+      );
+    }
     console.log(
-      JSON.stringify({
-        user_id: tokens.user_id,
-        email: me2?.email ?? tokens.email,
-        username: me2?.username ?? null
-      })
+      `codebyplan claude install --scope user${opts.dryRun ? " (dry-run)" : ""}: settings.json updated, 0 template files copied.`
+    );
+  } catch (err) {
+    console.error(
+      `codebyplan claude install failed: ${err instanceof Error ? err.message : String(err)}`
     );
-    return;
-  }
-  if (!tokens) {
-    console.log("\n  Not logged in. Run `codebyplan login` to authenticate.\n");
     process.exitCode = 1;
-    return;
   }
-  const me = await fetchMe(tokens.access_token);
-  const degraded = me === null;
-  const email = me?.email ?? tokens.email;
-  const username = me?.username ?? null;
-  console.log(`
-  user_id:  ${tokens.user_id}`);
-  console.log(`  email:    ${email ?? "(unknown)"}`);
-  console.log(`  username: ${username ?? "(not set)"}`);
-  if (degraded) {
-    console.log(`  (profile fetch failed \u2014 showing stored credentials)
-`);
-  } else {
-    console.log();
+}
+function countHookEntries(templatesDir) {
+  const p = path4.join(templatesDir, "hooks", "hooks.json");
+  if (!fs3.existsSync(p)) return 0;
+  try {
+    const j = JSON.parse(fs3.readFileSync(p, "utf8"));
+    let n = 0;
+    for (const blocks of Object.values(j.hooks)) {
+      for (const b of blocks) n += b.hooks.length;
+    }
+    return n;
+  } catch (err) {
+    console.error(
+      `codebyplan: could not count hook entries in hooks.json: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 0;
   }
 }
-var init_whoami = __esm({
-  "src/cli/whoami.ts"() {
+var init_install = __esm({
+  "src/cli/claude/install.ts"() {
     "use strict";
-    init_keychain();
-    init_urls();
+    init_template_walker();
+    init_gitignore_block();
+    init_manifest();
+    init_settings_merge();
+    init_statusline_config();
   }
 });
 
-// src/cli/upgrade-auth.ts
-var upgrade_auth_exports = {};
-__export(upgrade_auth_exports, {
-  runUpgradeAuth: () => runUpgradeAuth
+// src/cli/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  runSetup: () => runSetup
 });
-import { readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { join as join11 } from "node:path";
-function configPaths() {
-  return [join11(homedir5(), ".claude.json"), join11(process.cwd(), ".mcp.json")];
+import { mkdir as mkdir5, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join12 } from "node:path";
+import { stdin, stdout as stdout2 } from "node:process";
+import { createInterface } from "node:readline/promises";
+function getConfigPath(scope) {
+  return scope === "user" ? join12(homedir4(), ".claude.json") : join12(process.cwd(), ".mcp.json");
 }
-async function readConfig2(path10) {
+async function readConfig(path10) {
   try {
-    const raw = await readFile8(path10, "utf-8");
+    const raw = await readFile9(path10, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
     }
-    return null;
+    return {};
   } catch {
-    return null;
+    return {};
   }
 }
-function entryHasLegacyApiKey(entry) {
-  if (!entry || !entry.headers) return false;
-  return "x-api-key" in entry.headers;
+function buildMcpEntry() {
+  return { type: "http", url: mcpEndpoint() };
 }
-async function rewriteConfig(path10, config, newUrl) {
-  const servers = config.mcpServers;
-  if (!servers) return false;
-  const entry = servers.codebyplan;
-  if (!entry) return false;
-  if (!entryHasLegacyApiKey(entry) && entry.url === newUrl && entry.type === "http")
-    return false;
-  servers.codebyplan = { type: "http", url: newUrl };
-  await writeFile7(path10, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  return true;
+async function writeMcpConfig(scope) {
+  const configPath = getConfigPath(scope);
+  const config = await readConfig(configPath);
+  if (typeof config.mcpServers !== "object" || config.mcpServers === null || Array.isArray(config.mcpServers)) {
+    config.mcpServers = {};
+  }
+  config.mcpServers.codebyplan = buildMcpEntry();
+  await writeFile7(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return configPath;
 }
-async function runUpgradeAuth() {
-  console.log("\n  Upgrading codebyplan auth to OAuth...\n");
-  await runLogin();
-  const newUrl = mcpEndpoint();
-  let migrated = 0;
-  for (const path10 of configPaths()) {
-    const config = await readConfig2(path10);
-    if (!config) continue;
-    const changed = await rewriteConfig(path10, config, newUrl);
-    if (changed) {
-      console.log(`  Updated ${path10}`);
-      migrated++;
+async function fetchRepos(auth) {
+  const baseUrl3 = (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
+  const headers = auth.kind === "oauth" ? { Authorization: `Bearer ${await getAccessToken()}` } : { "x-api-key": auth.apiKey };
+  const res = await fetch(`${baseUrl3}/api/repos`, {
+    headers,
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (res.status === 401) {
+    if (auth.kind === "oauth") {
+      throw new Error(
+        "Session rejected. Run `codebyplan logout && codebyplan login`."
+      );
     }
+    throw new Error("Invalid API key. Please check and try again.");
   }
-  if (migrated === 0) {
-    console.log(
-      "  All codebyplan MCP entries are already up to date \u2014 nothing to change."
-    );
-  } else {
+  if (!res.ok) {
     console.log(
-      `
-  Done. Restart Claude Code to use the new endpoint: ${newUrl}
+      `  Warning: API returned status ${res.status}, but continuing.
 `
     );
+    return [];
   }
+  const body = await res.json();
+  return body.data ?? [];
 }
-var init_upgrade_auth = __esm({
-  "src/cli/upgrade-auth.ts"() {
-    "use strict";
-    init_urls();
-    init_login();
-  }
-});
-
-// src/cli/confirm.ts
-var confirm_exports = {};
-__export(confirm_exports, {
-  SyncCancelledError: () => SyncCancelledError,
-  confirmProceed: () => confirmProceed
-});
-import { createInterface as createInterface2 } from "node:readline/promises";
-import { stdin as stdin2, stdout as stdout3 } from "node:process";
-function isAbortError(err) {
-  return err instanceof Error && err.code === "ABORT_ERR";
-}
-async function confirmProceed(message) {
-  const rl = createInterface2({ input: stdin2, output: stdout3 });
-  try {
-    while (true) {
-      const answer = await rl.question(message ?? "  Proceed? [Y/n] ");
-      const a = answer.trim().toLowerCase();
-      if (a === "" || a === "y" || a === "yes") return true;
-      if (a === "n" || a === "no") return false;
-      console.log(
-        `    Unknown option "${answer.trim()}". Valid: y/yes, n/no, or Enter for yes.`
-      );
+async function chooseAuthMode(rl) {
+  console.log("  How would you like to authenticate?\n");
+  console.log("    1. OAuth \u2014 open browser to sign in (recommended)");
+  console.log(
+    "    2. Legacy API key \u2014 for the 30-day shim (deprecated 2026-06-30)\n"
+  );
+  const choice = (await rl.question("  Select (1/2, default: 1): ")).trim();
+  if (choice === "" || choice === "1") {
+    try {
+      await runLogin();
+      return { kind: "oauth" };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(`
+  OAuth login failed: ${msg}
+`);
+      return null;
     }
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
   }
+  const apiKey = (await rl.question("  Enter your API key: ")).trim();
+  if (!apiKey) {
+    console.log("\n  No API key provided. Aborting setup.\n");
+    return null;
+  }
+  return { kind: "legacy", apiKey };
 }
-var SyncCancelledError;
-var init_confirm = __esm({
-  "src/cli/confirm.ts"() {
-    "use strict";
-    SyncCancelledError = class extends Error {
-      constructor() {
-        super("Sync cancelled");
-        this.name = "SyncCancelledError";
-      }
-    };
+async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
+  const codebyplanDir = join12(projectPath, ".codebyplan");
+  await mkdir5(codebyplanDir, { recursive: true });
+  const repoJson = {
+    repo_id: selectedRepo.id
+  };
+  const repoAny = selectedRepo;
+  if (typeof repoAny.organization_id === "string") {
+    repoJson.organization_id = repoAny.organization_id;
   }
-});
-
-// src/lib/tech-detect.ts
-import { readFile as readFile9, access, readdir } from "node:fs/promises";
-import { join as join12, relative as relative3 } from "node:path";
-async function fileExists(filePath) {
+  if (typeof repoAny.project_id === "string") {
+    repoJson.project_id = repoAny.project_id;
+  }
+  await writeFile7(
+    join12(codebyplanDir, "repo.json"),
+    JSON.stringify(repoJson, null, 2) + "\n",
+    "utf-8"
+  );
+  await writeFile7(
+    join12(codebyplanDir, "server.json"),
+    JSON.stringify(
+      {
+        server_port: null,
+        server_type: null,
+        auto_push_enabled: false,
+        port_allocations: []
+      },
+      null,
+      2
+    ) + "\n",
+    "utf-8"
+  );
+  await writeFile7(
+    join12(codebyplanDir, "git.json"),
+    JSON.stringify({ git_branch: null, branch_config: null }, null, 2) + "\n",
+    "utf-8"
+  );
+  await writeFile7(
+    join12(codebyplanDir, "shipment.json"),
+    JSON.stringify({ shipment: null }, null, 2) + "\n",
+    "utf-8"
+  );
+  await writeFile7(
+    join12(codebyplanDir, "vendor.json"),
+    JSON.stringify({}, null, 2) + "\n",
+    "utf-8"
+  );
+  await writeFile7(
+    join12(codebyplanDir, "e2e.json"),
+    JSON.stringify({}, null, 2) + "\n",
+    "utf-8"
+  );
+  await writeFile7(
+    join12(codebyplanDir, "eslint.json"),
+    JSON.stringify({}, null, 2) + "\n",
+    "utf-8"
+  );
+  const statuslinePath = join12(codebyplanDir, "statusline.json");
+  let statuslineExists = false;
   try {
-    await access(filePath);
-    return true;
+    await readFile9(statuslinePath, "utf-8");
+    statuslineExists = true;
   } catch {
-    return false;
   }
-}
-async function discoverMonorepoApps(projectPath) {
-  const apps = [];
-  const patterns = [];
-  try {
-    const raw = await readFile9(
-      join12(projectPath, "pnpm-workspace.yaml"),
+  if (!statuslineExists) {
+    await writeFile7(
+      statuslinePath,
+      JSON.stringify(STATUSLINE_DEFAULTS, null, 2) + "\n",
       "utf-8"
     );
-    const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
-    if (matches) {
-      for (const m of matches) {
-        const pattern = m.replace(/^\s*-\s*['"]?/, "").replace(/['"]?\s*$/, "").trim();
-        if (pattern) patterns.push(pattern);
-      }
-    }
-  } catch {
-  }
-  if (patterns.length === 0) {
-    try {
-      const raw = await readFile9(join12(projectPath, "package.json"), "utf-8");
-      const pkg = JSON.parse(raw);
-      const ws = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
-      if (ws) patterns.push(...ws);
-    } catch {
-    }
   }
-  for (const pattern of patterns) {
-    if (pattern.endsWith("/*")) {
-      const dir = pattern.slice(0, -2);
-      const absDir = join12(projectPath, dir);
-      try {
-        const entries = await readdir(absDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            const relPath = join12(dir, entry.name);
-            const absPath = join12(absDir, entry.name);
-            if (await fileExists(join12(absPath, "package.json"))) {
-              apps.push({ name: entry.name, path: relPath, absPath });
-            }
-          }
-        }
-      } catch {
-      }
-    }
+  await writeLocalConfig(projectPath, { device_id: deviceId });
+  console.log(`  Created ${codebyplanDir}/`);
+  console.log(
+    `    repo.json, server.json, git.json, shipment.json, vendor.json, e2e.json, eslint.json, statusline.json`
+  );
+  console.log(`    device.local.json (gitignored)`);
+  const gitignoreAction = await ensureManagedGitignoreBlock(projectPath);
+  if (gitignoreAction !== "unchanged") {
+    console.log("  Updated .gitignore (codebyplan managed block)");
   }
-  return apps;
 }
-async function hasJsxFile(dir, depth = 0) {
-  if (depth > 6) return false;
+async function runSetup() {
+  const rl = createInterface({ input: stdin, output: stdout2 });
+  console.log("\n  CodeByPlan Setup\n");
+  console.log("  This will configure Claude Code to use CodeByPlan.\n");
   try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const name = entry.name;
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
-        if (await hasJsxFile(join12(dir, name), depth + 1)) return true;
-      } else if (entry.isFile()) {
-        if (JSX_TEST_PATTERN.test(name)) continue;
-        if (name.endsWith(".tsx") || name.endsWith(".jsx")) return true;
-      }
+    const auth = await chooseAuthMode(rl);
+    if (!auth) return;
+    console.log("\n  Where should the MCP server be configured?\n");
+    console.log("    1. Global \u2014 available in all projects (~/.claude.json)");
+    console.log("    2. Project \u2014 only this project (.mcp.json)\n");
+    const scopeInput = (await rl.question("  Select (1/2, default: 1): ")).trim();
+    const scope = scopeInput === "2" ? "project" : "user";
+    console.log("\n  Configuring MCP server...");
+    const configPath = await writeMcpConfig(scope);
+    console.log(`  Done! Config written to ${configPath}
+`);
+    let repos = [];
+    try {
+      repos = await fetchRepos(auth);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(`  ${msg}
+`);
+      return;
     }
-  } catch (err) {
-    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      return false;
+    if (repos.length === 0) {
+      console.log(
+        "  No repositories found. Create one at https://codebyplan.com after setup.\n"
+      );
+      console.log(
+        "  Setup complete! Start a new Claude Code session to begin.\n"
+      );
+      return;
     }
-    console.error(
-      `detectCapabilities: readdir failed for ${dir}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  return false;
-}
-async function detectCapabilities(dirPath, pkgJson) {
-  const caps = /* @__PURE__ */ new Set();
-  for (const sub of JSX_SCAN_DIRS) {
-    if (await hasJsxFile(join12(dirPath, sub))) {
-      caps.add("jsx");
-      break;
+    console.log("  Initialize this project?\n");
+    const initAnswer = (await rl.question("  Link to a repository? (Y/n): ")).trim().toLowerCase();
+    if (initAnswer !== "" && initAnswer !== "y" && initAnswer !== "yes") {
+      console.log(
+        "  Setup complete! Start a new Claude Code session to begin.\n"
+      );
+      return;
     }
-  }
-  if (pkgJson) {
-    const allDeps = {
-      ...pkgJson.dependencies ?? {},
-      ...pkgJson.devDependencies ?? {}
-    };
-    for (const dep of Object.keys(allDeps)) {
-      if (SERVER_FRAMEWORK_DEPS.has(dep)) {
-        caps.add("node-server");
-        break;
-      }
+    if (auth.kind === "legacy") {
+      process.env.CODEBYPLAN_API_KEY = auth.apiKey;
     }
-    if (!caps.has("node-server") && typeof pkgJson.main === "string") {
-      if (SERVER_MAIN_ENTRIES.has(pkgJson.main.trim())) {
-        caps.add("node-server");
-      }
+    console.log("\n  Your repositories:\n");
+    for (let i = 0; i < repos.length; i++) {
+      console.log(`    ${i + 1}. ${repos[i].name}`);
     }
-  }
-  if (!caps.has("node-server") && await fileExists(join12(dirPath, "src", "main.ts"))) {
-    caps.add("node-server");
-  }
-  if (pkgJson && pkgJson.bin) {
-    if (typeof pkgJson.bin === "string" && pkgJson.bin.trim().length > 0) {
-      caps.add("cli-bin");
-    } else if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && Object.keys(pkgJson.bin).length > 0) {
-      caps.add("cli-bin");
+    console.log();
+    const choice = (await rl.question("  Select a repository (number): ")).trim();
+    const index = parseInt(choice, 10) - 1;
+    if (isNaN(index) || index < 0 || index >= repos.length) {
+      console.log("  Invalid selection. Skipping project init.\n");
+      return;
     }
-  }
-  return caps;
-}
-async function detectFromDirectory(dirPath) {
-  const seen = /* @__PURE__ */ new Map();
-  let pkgJson = null;
-  try {
-    const raw = await readFile9(join12(dirPath, "package.json"), "utf-8");
-    pkgJson = JSON.parse(raw);
-    const allDeps = {
-      ...pkgJson.dependencies ?? {},
-      ...pkgJson.devDependencies ?? {}
-    };
-    for (const depName of Object.keys(allDeps)) {
-      const rule = PACKAGE_MAP[depName];
-      if (rule) {
-        const key = rule.name.toLowerCase();
-        if (!seen.has(key)) {
-          seen.set(key, { name: rule.name, category: rule.category });
-        }
-        continue;
-      }
-      for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
-        if (depName.startsWith(prefix)) {
-          const key = prefixRule.name.toLowerCase();
-          if (!seen.has(key)) {
-            seen.set(key, {
-              name: prefixRule.name,
-              category: prefixRule.category
-            });
-          }
-          break;
-        }
-      }
+    const selectedRepo = repos[index];
+    console.log(`
+  Selected: ${selectedRepo.name}
+`);
+    const projectPath = process.cwd();
+    const pathBasedId = await resolveAndCacheWorktreeId(
+      selectedRepo.id,
+      projectPath,
+      { skipWrite: true }
+    );
+    const deviceId = await getOrCreateDeviceId(projectPath);
+    let branch = "main";
+    try {
+      const { execSync: execSync9 } = await import("node:child_process");
+      branch = execSync9("git symbolic-ref --short HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+    } catch {
     }
-  } catch {
-  }
-  for (const { file, rule } of CONFIG_FILE_MAP) {
-    const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join12(dirPath, file))) {
-      seen.set(key, { name: rule.name, category: rule.category });
+    const tupleId = await resolveWorktreeId({
+      repoId: selectedRepo.id,
+      repoPath: projectPath,
+      branch,
+      deviceId
+    });
+    const _worktreeId = tupleId ?? pathBasedId;
+    void _worktreeId;
+    await writeCodebyplanDirectory(projectPath, selectedRepo, deviceId);
+    const priorExitCode = process.exitCode;
+    let installFailed = false;
+    try {
+      const { runInstall: runInstall2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+      await runInstall2(
+        { yes: true, dryRun: false, verbose: false, scope: "project" },
+        { projectDir: projectPath }
+      );
+      installFailed = process.exitCode !== priorExitCode;
+    } catch {
+      installFailed = true;
     }
-  }
-  const capabilities = await detectCapabilities(dirPath, pkgJson);
-  const capsArray = Array.from(capabilities).sort();
-  const entries = Array.from(seen.values()).map((entry) => {
-    const isBearer = CAPABILITY_BEARER_NAMES.has(entry.name.toLowerCase());
-    return {
-      ...entry,
-      capabilities: isBearer ? capsArray : []
-    };
-  });
-  if (capsArray.length > 0) {
-    const hasBearerWithCaps = entries.some(
-      (e) => CAPABILITY_BEARER_NAMES.has(e.name.toLowerCase()) && (e.capabilities?.some((c) => c.length > 0) ?? false)
-    );
-    if (!hasBearerWithCaps) {
-      entries.push({
-        name: SYNTHETIC_CARRIER_NAME,
-        category: "tool",
-        capabilities: capsArray
-      });
+    if (installFailed) {
+      process.exitCode = priorExitCode;
+      console.log(
+        "  Warning: .claude/ install step failed. Run `codebyplan claude install` manually."
+      );
     }
-  }
-  return entries.sort(compareByCategoryThenName);
-}
-function collectCapabilities(entries) {
-  const set = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    if (!entry.capabilities) continue;
-    for (const cap of entry.capabilities) {
-      if (typeof cap === "string" && cap.length > 0) {
-        set.add(cap.toLowerCase());
+    const existingRenderer = await readStatuslineLocalConfig(projectPath);
+    const isInteractive = process.stdin.isTTY === true;
+    if (!existingRenderer && isInteractive) {
+      const availability = detectAvailableRenderers();
+      const available = Object.entries(availability).filter(([, v]) => v).map(([k]) => k).join(", ");
+      console.log(
+        `
+  Which statusline renderer would you like to use? (available: ${available})`
+      );
+      console.log("    bash   \u2014 shell script, zero dependencies (default)");
+      console.log("    node   \u2014 Node.js renderer");
+      console.log("    python \u2014 Python 3 renderer");
+      const rendererInput = (await rl.question(
+        "  Select renderer (bash/node/python, default: bash): "
+      )).trim().toLowerCase();
+      const chosen = rendererInput === "node" ? "node" : rendererInput === "python" ? "python" : "bash";
+      await writeStatuslineLocalConfig(projectPath, { renderer: chosen });
+      if (!availability[chosen]) {
+        console.log(
+          `  Warning: '${chosen}' was not detected on this machine. You can change it later with \`codebyplan statusline\`.`
+        );
+      } else {
+        console.log(`  Renderer set to '${chosen}'.`);
       }
     }
+    console.log(
+      "\n  Run `npx codebyplan config` to sync repo config from the DB."
+    );
+    console.log(
+      "  Setup complete! Start a new Claude Code session to begin.\n"
+    );
+  } finally {
+    rl.close();
   }
-  return Array.from(set).sort();
 }
-async function detectTechStack(projectPath) {
-  const repo = await detectFromDirectory(projectPath);
-  const discoveredApps = await discoverMonorepoApps(projectPath);
-  const apps = [];
-  for (const app of discoveredApps) {
-    const stack = await detectFromDirectory(app.absPath);
-    if (stack.length > 0) {
-      apps.push({ name: app.name, path: app.path, stack });
-    }
-  }
-  const flatMap = /* @__PURE__ */ new Map();
-  for (const entry of repo) {
-    flatMap.set(entry.name.toLowerCase(), entry);
+var init_setup = __esm({
+  "src/cli/setup.ts"() {
+    "use strict";
+    init_gitignore_block();
+    init_local_config();
+    init_statusline_config();
+    init_resolve_worktree();
+    init_token_refresh();
+    init_urls();
+    init_login();
   }
-  for (const app of apps) {
-    for (const entry of app.stack) {
-      const key = entry.name.toLowerCase();
-      const existing = flatMap.get(key);
-      if (!existing) {
-        flatMap.set(key, entry);
-      } else if (entry.capabilities?.length) {
-        const merged = Array.from(
-          /* @__PURE__ */ new Set([...existing.capabilities ?? [], ...entry.capabilities])
-        ).sort();
-        flatMap.set(key, { ...existing, capabilities: merged });
-      }
-    }
+});
+
+// src/cli/statusline.ts
+var statusline_exports = {};
+__export(statusline_exports, {
+  runStatusline: () => runStatusline
+});
+import { dirname as dirname5 } from "node:path";
+async function resolveProjectPath() {
+  const found = await findCodebyplanConfig(process.cwd());
+  if (found) {
+    return dirname5(dirname5(found.path));
   }
-  const repoCleaned = stripSyntheticIfCovered(repo).sort(
-    compareByCategoryThenName
-  );
-  const appsCleaned = apps.map((a) => ({
-    ...a,
-    stack: stripSyntheticIfCovered(a.stack).sort(compareByCategoryThenName)
-  }));
-  const flat = stripSyntheticIfCovered(Array.from(flatMap.values())).sort(
-    compareByCategoryThenName
-  );
-  return { repo: repoCleaned, apps: appsCleaned, flat };
+  return process.cwd();
 }
-function stripSyntheticIfCovered(entries) {
-  const synth = entries.find((e) => e.name === SYNTHETIC_CARRIER_NAME);
-  if (!synth?.capabilities?.length) return entries;
-  const realBearerCaps = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    if (e.name === SYNTHETIC_CARRIER_NAME) continue;
-    for (const c of e.capabilities ?? []) realBearerCaps.add(c);
-  }
-  if (synth.capabilities.every((c) => realBearerCaps.has(c))) {
-    return entries.filter((e) => e.name !== SYNTHETIC_CARRIER_NAME);
+function parseRendererArg(arg) {
+  const normalised = arg.startsWith("--") ? arg.slice(2) : arg;
+  if (VALID_RENDERERS2.has(normalised)) {
+    return normalised;
   }
-  return entries;
+  return null;
 }
-function mergeTechStack(remote, detected) {
-  const stripCarrier = (e) => e.name !== SYNTHETIC_CARRIER_NAME;
-  const cleanDetected = {
-    repo: detected.repo.filter(stripCarrier),
-    apps: detected.apps.map((a) => ({
-      ...a,
-      stack: a.stack.filter(stripCarrier)
-    })),
-    flat: detected.flat.filter(stripCarrier)
-  };
-  const remoteResult = Array.isArray(remote) ? {
-    repo: remote.filter(stripCarrier),
-    apps: [],
-    flat: remote.filter(stripCarrier)
-  } : {
-    repo: remote.repo.filter(stripCarrier),
-    apps: remote.apps.map((a) => ({
-      ...a,
-      stack: a.stack.filter(stripCarrier)
-    })),
-    flat: remote.flat.filter(stripCarrier)
-  };
-  const seen = /* @__PURE__ */ new Map();
-  for (const entry of remoteResult.flat) {
-    seen.set(entry.name.toLowerCase(), entry);
+async function runStatusline(args) {
+  const positional = args.filter((a) => !a.startsWith("-"));
+  const flagArgs = args.filter((a) => a.startsWith("--"));
+  const rendererTokens = [...positional, ...flagArgs].filter(
+    (a) => parseRendererArg(a) !== null
+  );
+  if (rendererTokens.length > 1) {
+    process.stderr.write(
+      "codebyplan statusline: bash, node, and python are mutually exclusive; pass only one.\n"
+    );
+    process.exitCode = 1;
+    return;
   }
-  const added = [];
-  for (const entry of cleanDetected.flat) {
-    const key = entry.name.toLowerCase();
-    if (!seen.has(key)) {
-      seen.set(key, entry);
-      added.push(entry);
+  let rendererArg;
+  for (const a of [...positional, ...flagArgs]) {
+    const parsed = parseRendererArg(a);
+    if (parsed !== null) {
+      rendererArg = a;
+      break;
     }
   }
-  const flat = Array.from(seen.values()).sort(compareByCategoryThenName);
-  const merged = {
-    repo: cleanDetected.repo,
-    apps: cleanDetected.apps,
-    flat
-  };
-  return { merged, added };
-}
-function parseTechStack(raw) {
-  if (Array.isArray(raw)) {
-    return raw.filter(
-      (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.category === "string"
+  const unknownPositional = args.filter(
+    (a) => !a.startsWith("-") && !VALID_RENDERERS2.has(a)
+  );
+  if (unknownPositional.length > 0) {
+    process.stderr.write(
+      `codebyplan statusline: unknown argument '${unknownPositional[0]}'.
+
+Usage:
+  codebyplan statusline                     Show current renderer and line toggles
+  codebyplan statusline bash|node|python    Set the renderer
+  codebyplan statusline --bash|--node|--python  Set the renderer (flag form)
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const unknownFlags = flagArgs.filter((a) => parseRendererArg(a) === null);
+  if (unknownFlags.length > 0) {
+    process.stderr.write(
+      `codebyplan statusline: unknown flag '${unknownFlags[0]}'.
+
+Usage:
+  codebyplan statusline                     Show current renderer and line toggles
+  codebyplan statusline bash|node|python    Set the renderer
+  codebyplan statusline --bash|--node|--python  Set the renderer (flag form)
+`
     );
+    process.exitCode = 1;
+    return;
   }
-  if (typeof raw === "object" && raw !== null && "flat" in raw) {
-    return parseTechStack(raw.flat);
+  const projectPath = await resolveProjectPath();
+  if (rendererArg !== void 0) {
+    const chosen = parseRendererArg(rendererArg);
+    await writeStatuslineLocalConfig(projectPath, { renderer: chosen });
+    const availability2 = detectAvailableRenderers();
+    if (!availability2[chosen]) {
+      process.stderr.write(
+        `Warning: '${chosen}' was not detected on this machine. The renderer is saved but may not run.
+`
+      );
+    }
+    console.log(`Statusline renderer set to '${chosen}'.`);
+    return;
   }
-  return [];
+  const availability = detectAvailableRenderers();
+  const [renderer, config] = await Promise.all([
+    resolveRenderer(projectPath),
+    readStatuslineConfig(projectPath)
+  ]);
+  const availStr = Object.entries(availability).map(([k, v]) => `${k}: ${v ? "yes" : "no"}`).join(", ");
+  console.log(`
+Statusline configuration`);
+  console.log(`  Renderer:     ${renderer}`);
+  console.log(`  Available:    ${availStr}`);
+  console.log(`  no_color:     ${config.no_color}`);
+  console.log(`
+  Line toggles:`);
+  for (const [key, val] of Object.entries(config.lines)) {
+    console.log(`    ${key.padEnd(14)} ${val ? "on" : "off"}`);
+  }
+  console.log();
 }
-function parseAppTechStacks(raw) {
-  if (!Array.isArray(raw)) return [];
-  return raw.filter(
-    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.path === "string" && Array.isArray(item.stack)
-  ).map((item) => ({
-    name: item.name,
-    path: item.path,
-    stack: parseTechStack(item.stack)
-  }));
+var VALID_RENDERERS2;
+var init_statusline = __esm({
+  "src/cli/statusline.ts"() {
+    "use strict";
+    init_flags();
+    init_statusline_config();
+    VALID_RENDERERS2 = /* @__PURE__ */ new Set(["bash", "node", "python"]);
+  }
+});
+
+// src/cli/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  runLogout: () => runLogout
+});
+async function runLogout() {
+  await clearTokens();
+  await clearClient();
+  console.log("\n  Logged out.\n");
 }
-function parseTechStackResult(raw) {
-  if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && "flat" in raw) {
-    const obj = raw;
+var init_logout = __esm({
+  "src/cli/logout.ts"() {
+    "use strict";
+    init_client_registration();
+    init_keychain();
+  }
+});
+
+// src/cli/whoami.ts
+var whoami_exports = {};
+__export(whoami_exports, {
+  runWhoami: () => runWhoami
+});
+async function fetchMe(accessToken) {
+  try {
+    const res = await fetch(meEndpoint(), {
+      headers: { Authorization: `Bearer ${accessToken}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
     return {
-      repo: parseTechStack(obj.repo),
-      apps: parseAppTechStacks(obj.apps),
-      flat: parseTechStack(obj.flat)
+      email: body.email ?? null,
+      username: body.username ?? null
     };
+  } catch {
+    return null;
   }
-  const flat = parseTechStack(raw);
-  return { repo: flat, apps: [], flat };
 }
-function categorizeDependency(depName) {
-  const rule = PACKAGE_MAP[depName];
-  if (rule) return rule.category;
-  for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
-    if (depName.startsWith(prefix)) return prefixRule.category;
+async function runWhoami(opts = {}) {
+  const tokens = await loadTokens();
+  if (opts.json) {
+    if (!tokens) {
+      console.log("null");
+      process.exitCode = 1;
+      return;
+    }
+    const me2 = await fetchMe(tokens.access_token);
+    console.log(
+      JSON.stringify({
+        user_id: tokens.user_id,
+        email: me2?.email ?? tokens.email,
+        username: me2?.username ?? null
+      })
+    );
+    return;
+  }
+  if (!tokens) {
+    console.log("\n  Not logged in. Run `codebyplan login` to authenticate.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const me = await fetchMe(tokens.access_token);
+  const degraded = me === null;
+  const email = me?.email ?? tokens.email;
+  const username = me?.username ?? null;
+  console.log(`
+  user_id:  ${tokens.user_id}`);
+  console.log(`  email:    ${email ?? "(unknown)"}`);
+  console.log(`  username: ${username ?? "(not set)"}`);
+  if (degraded) {
+    console.log(`  (profile fetch failed \u2014 showing stored credentials)
+`);
+  } else {
+    console.log();
   }
-  return "other";
 }
-async function findPackageJsonFiles(dir, projectPath, depth = 0) {
-  if (depth > 4) return [];
-  const results = [];
-  const pkgPath = join12(dir, "package.json");
-  if (await fileExists(pkgPath)) {
-    results.push(pkgPath);
+var init_whoami = __esm({
+  "src/cli/whoami.ts"() {
+    "use strict";
+    init_keychain();
+    init_urls();
   }
+});
+
+// src/cli/upgrade-auth.ts
+var upgrade_auth_exports = {};
+__export(upgrade_auth_exports, {
+  runUpgradeAuth: () => runUpgradeAuth
+});
+import { readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join13 } from "node:path";
+function configPaths() {
+  return [join13(homedir5(), ".claude.json"), join13(process.cwd(), ".mcp.json")];
+}
+async function readConfig2(path10) {
   try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
-      const subResults = await findPackageJsonFiles(
-        join12(dir, entry.name),
-        projectPath,
-        depth + 1
-      );
-      results.push(...subResults);
+    const raw = await readFile10(path10, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
     }
+    return null;
   } catch {
+    return null;
   }
-  return results;
 }
-async function scanAllDependencies(projectPath) {
-  const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
-  const dependencies = [];
-  for (const pkgPath of packageJsonPaths) {
-    try {
-      const raw = await readFile9(pkgPath, "utf-8");
-      const pkg = JSON.parse(raw);
-      const sourcePath = relative3(projectPath, pkgPath);
-      const depSections = [
-        { deps: pkg.dependencies, depType: "production", isDev: false },
-        { deps: pkg.devDependencies, depType: "dev", isDev: true },
-        { deps: pkg.peerDependencies, depType: "peer", isDev: false },
-        { deps: pkg.optionalDependencies, depType: "optional", isDev: false }
-      ];
-      for (const { deps, depType, isDev } of depSections) {
-        if (!deps) continue;
-        for (const [name, version] of Object.entries(deps)) {
-          dependencies.push({
-            name,
-            version,
-            category: categorizeDependency(name),
-            source_path: sourcePath,
-            is_dev: isDev,
-            dep_type: depType
-          });
-        }
-      }
-    } catch {
+function entryHasLegacyApiKey(entry) {
+  if (!entry || !entry.headers) return false;
+  return "x-api-key" in entry.headers;
+}
+async function rewriteConfig(path10, config, newUrl) {
+  const servers = config.mcpServers;
+  if (!servers) return false;
+  const entry = servers.codebyplan;
+  if (!entry) return false;
+  if (!entryHasLegacyApiKey(entry) && entry.url === newUrl && entry.type === "http")
+    return false;
+  servers.codebyplan = { type: "http", url: newUrl };
+  await writeFile8(path10, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return true;
+}
+async function runUpgradeAuth() {
+  console.log("\n  Upgrading codebyplan auth to OAuth...\n");
+  await runLogin();
+  const newUrl = mcpEndpoint();
+  let migrated = 0;
+  for (const path10 of configPaths()) {
+    const config = await readConfig2(path10);
+    if (!config) continue;
+    const changed = await rewriteConfig(path10, config, newUrl);
+    if (changed) {
+      console.log(`  Updated ${path10}`);
+      migrated++;
+    }
+  }
+  if (migrated === 0) {
+    console.log(
+      "  All codebyplan MCP entries are already up to date \u2014 nothing to change."
+    );
+  } else {
+    console.log(
+      `
+  Done. Restart Claude Code to use the new endpoint: ${newUrl}
+`
+    );
+  }
+}
+var init_upgrade_auth = __esm({
+  "src/cli/upgrade-auth.ts"() {
+    "use strict";
+    init_urls();
+    init_login();
+  }
+});
+
+// src/cli/confirm.ts
+var confirm_exports = {};
+__export(confirm_exports, {
+  SyncCancelledError: () => SyncCancelledError,
+  confirmProceed: () => confirmProceed
+});
+import { createInterface as createInterface2 } from "node:readline/promises";
+import { stdin as stdin2, stdout as stdout3 } from "node:process";
+function isAbortError(err) {
+  return err instanceof Error && err.code === "ABORT_ERR";
+}
+async function confirmProceed(message) {
+  const rl = createInterface2({ input: stdin2, output: stdout3 });
+  try {
+    while (true) {
+      const answer = await rl.question(message ?? "  Proceed? [Y/n] ");
+      const a = answer.trim().toLowerCase();
+      if (a === "" || a === "y" || a === "yes") return true;
+      if (a === "n" || a === "no") return false;
+      console.log(
+        `    Unknown option "${answer.trim()}". Valid: y/yes, n/no, or Enter for yes.`
+      );
     }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    rl.close();
   }
-  return { dependencies };
 }
-var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SYNTHETIC_CARRIER_NAME, CAPABILITY_BEARER_NAMES, JSX_TEST_PATTERN, JSX_SKIP_DIRS, JSX_SCAN_DIRS, SERVER_MAIN_ENTRIES, SERVER_FRAMEWORK_DEPS, compareByCategoryThenName, SKIP_DIRS;
-var init_tech_detect = __esm({
-  "src/lib/tech-detect.ts"() {
+var SyncCancelledError;
+var init_confirm = __esm({
+  "src/cli/confirm.ts"() {
     "use strict";
-    PACKAGE_MAP = {
-      // Frameworks
-      next: { name: "Next.js", category: "framework" },
-      nuxt: { name: "Nuxt", category: "framework" },
-      gatsby: { name: "Gatsby", category: "framework" },
-      express: { name: "Express", category: "framework" },
-      fastify: { name: "Fastify", category: "framework" },
-      hono: { name: "Hono", category: "framework" },
-      "@remix-run/node": { name: "Remix", category: "framework" },
-      svelte: { name: "Svelte", category: "framework" },
-      astro: { name: "Astro", category: "framework" },
-      "@angular/core": { name: "Angular", category: "framework" },
-      "@nestjs/core": { name: "NestJS", category: "framework" },
-      // Libraries (UI)
-      react: { name: "React", category: "framework" },
-      vue: { name: "Vue", category: "framework" },
-      "solid-js": { name: "Solid", category: "framework" },
-      preact: { name: "Preact", category: "framework" },
-      // Languages (detected via devDeps)
-      typescript: { name: "TypeScript", category: "language" },
-      // Styling
-      tailwindcss: { name: "Tailwind CSS", category: "styling" },
-      sass: { name: "SCSS", category: "styling" },
-      "styled-components": { name: "styled-components", category: "styling" },
-      "@emotion/react": { name: "Emotion", category: "styling" },
-      // Database
-      prisma: { name: "Prisma", category: "database" },
-      "@prisma/client": { name: "Prisma", category: "database" },
-      "drizzle-orm": { name: "Drizzle", category: "database" },
-      "@supabase/supabase-js": { name: "Supabase", category: "database" },
-      mongoose: { name: "MongoDB", category: "database" },
-      typeorm: { name: "TypeORM", category: "database" },
-      knex: { name: "Knex", category: "database" },
-      // Testing
-      jest: { name: "Jest", category: "testing" },
-      vitest: { name: "Vitest", category: "testing" },
-      mocha: { name: "Mocha", category: "testing" },
-      playwright: { name: "Playwright", category: "testing" },
-      "@playwright/test": { name: "Playwright", category: "testing" },
-      cypress: { name: "Cypress", category: "testing" },
-      supertest: { name: "Supertest", category: "testing" },
-      webdriverio: { name: "WebdriverIO", category: "testing" },
-      "@wdio/cli": { name: "WebdriverIO", category: "testing" },
-      "@vscode/test-cli": { name: "VS Code Test CLI", category: "testing" },
-      // Build tools
-      turbo: { name: "Turborepo", category: "build" },
-      vite: { name: "Vite", category: "build" },
-      webpack: { name: "Webpack", category: "build" },
-      esbuild: { name: "esbuild", category: "build" },
-      rollup: { name: "Rollup", category: "build" },
-      nx: { name: "Nx", category: "build" },
-      lerna: { name: "Lerna", category: "build" },
-      tsup: { name: "tsup", category: "build" },
-      "@swc/core": { name: "SWC", category: "build" },
-      parcel: { name: "Parcel", category: "build" },
-      // Tools
-      eslint: { name: "ESLint", category: "tool" },
-      prettier: { name: "Prettier", category: "tool" },
-      "@biomejs/biome": { name: "Biome", category: "tool" },
-      storybook: { name: "Storybook", category: "tool" },
-      // Component libs
-      "@mui/material": { name: "MUI", category: "component-lib" },
-      "@chakra-ui/react": { name: "Chakra UI", category: "component-lib" },
-      "@mantine/core": { name: "Mantine", category: "component-lib" },
-      // GraphQL
-      graphql: { name: "GraphQL", category: "graphql" },
-      "@apollo/client": { name: "Apollo Client", category: "graphql" },
-      urql: { name: "urql", category: "graphql" },
-      "graphql-request": { name: "graphql-request", category: "graphql" },
-      // Documentation
-      typedoc: { name: "TypeDoc", category: "documentation" },
-      "@docusaurus/core": { name: "Docusaurus", category: "documentation" },
-      vitepress: { name: "VitePress", category: "documentation" },
-      // Code quality
-      husky: { name: "Husky", category: "quality" },
-      "lint-staged": { name: "lint-staged", category: "quality" },
-      commitlint: { name: "commitlint", category: "quality" },
-      "@commitlint/cli": { name: "commitlint", category: "quality" },
-      // Mobile
-      "react-native": { name: "React Native", category: "mobile" },
-      expo: { name: "Expo", category: "mobile" }
-    };
-    PACKAGE_PREFIX_MAP = [
-      {
-        prefix: "@radix-ui/",
-        rule: { name: "Radix UI", category: "component-lib" }
-      },
-      { prefix: "@storybook/", rule: { name: "Storybook", category: "tool" } },
-      {
-        prefix: "@testing-library/",
-        rule: { name: "Testing Library", category: "testing" }
-      }
-    ];
-    CONFIG_FILE_MAP = [
-      { file: "tsconfig.json", rule: { name: "TypeScript", category: "language" } },
-      { file: "next.config.js", rule: { name: "Next.js", category: "framework" } },
-      { file: "next.config.mjs", rule: { name: "Next.js", category: "framework" } },
-      { file: "next.config.ts", rule: { name: "Next.js", category: "framework" } },
-      {
-        file: "tailwind.config.js",
-        rule: { name: "Tailwind CSS", category: "styling" }
-      },
-      {
-        file: "tailwind.config.ts",
-        rule: { name: "Tailwind CSS", category: "styling" }
-      },
-      { file: "turbo.json", rule: { name: "Turborepo", category: "build" } },
-      {
-        file: "docker-compose.yml",
-        rule: { name: "Docker", category: "deployment" }
-      },
-      {
-        file: "docker-compose.yaml",
-        rule: { name: "Docker", category: "deployment" }
-      },
-      { file: "Dockerfile", rule: { name: "Docker", category: "deployment" } },
-      { file: "vercel.json", rule: { name: "Vercel", category: "deployment" } },
-      { file: ".storybook/main.js", rule: { name: "Storybook", category: "tool" } },
-      { file: ".storybook/main.ts", rule: { name: "Storybook", category: "tool" } },
-      {
-        file: ".storybook/main.mjs",
-        rule: { name: "Storybook", category: "tool" }
-      },
-      {
-        file: "components.json",
-        rule: { name: "shadcn/ui", category: "component-lib" }
-      },
-      { file: "nx.json", rule: { name: "Nx", category: "build" } },
-      { file: "lerna.json", rule: { name: "Lerna", category: "build" } },
-      {
-        file: "playwright.config.ts",
-        rule: { name: "Playwright", category: "testing" }
-      },
-      {
-        file: "playwright.config.js",
-        rule: { name: "Playwright", category: "testing" }
-      },
-      {
-        file: "playwright.config.mjs",
-        rule: { name: "Playwright", category: "testing" }
-      },
-      { file: "wdio.conf.ts", rule: { name: "WebdriverIO", category: "testing" } },
-      {
-        file: "wdio.conf.js",
-        rule: { name: "WebdriverIO", category: "testing" }
-      },
-      {
-        file: "maestro/config.yaml",
-        rule: { name: "Maestro", category: "testing" }
+    SyncCancelledError = class extends Error {
+      constructor() {
+        super("Sync cancelled");
+        this.name = "SyncCancelledError";
       }
-    ];
-    SYNTHETIC_CARRIER_NAME = "__capabilities__";
-    CAPABILITY_BEARER_NAMES = /* @__PURE__ */ new Set([
-      "react",
-      "next.js",
-      "vue",
-      "svelte",
-      "solid",
-      "preact",
-      "remix",
-      "astro",
-      "angular",
-      "nestjs",
-      "nuxt",
-      "gatsby",
-      "express",
-      "fastify",
-      "hono",
-      "react native",
-      "expo"
-    ]);
-    JSX_TEST_PATTERN = /\.(test|spec)\.(tsx|jsx)$/;
-    JSX_SKIP_DIRS = /* @__PURE__ */ new Set(["__tests__", "test", "tests"]);
-    JSX_SCAN_DIRS = ["src", "app", "pages"];
-    SERVER_MAIN_ENTRIES = /* @__PURE__ */ new Set([
-      "dist/main.js",
-      "dist/server.js",
-      "dist/index.js",
-      "main.js",
-      "server.js"
-    ]);
-    SERVER_FRAMEWORK_DEPS = /* @__PURE__ */ new Set([
-      "@nestjs/core",
-      "express",
-      "fastify",
-      "hono"
-    ]);
-    compareByCategoryThenName = (a, b) => {
-      const catCmp = a.category.localeCompare(b.category);
-      if (catCmp !== 0) return catCmp;
-      return a.name.localeCompare(b.name);
     };
-    SKIP_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      ".next",
-      "dist",
-      ".turbo",
-      ".git",
-      "coverage",
-      "build",
-      "out",
-      ".vercel",
-      ".expo"
-    ]);
   }
 });
 
@@ -3537,11 +3935,11 @@ __export(eslint_exports, {
   eslintInit: () => eslintInit,
   runEslint: () => runEslint
 });
-import { readFile as readFile10, writeFile as writeFile8, access as access2, readdir as readdir2 } from "node:fs/promises";
-import { join as join13, relative as relative4 } from "node:path";
-async function fileExists2(filePath) {
+import { readFile as readFile11, writeFile as writeFile9, access as access3, readdir as readdir2 } from "node:fs/promises";
+import { join as join14, relative as relative4 } from "node:path";
+async function fileExists3(filePath) {
   try {
-    await access2(filePath);
+    await access3(filePath);
     return true;
   } catch {
     return false;
@@ -3549,7 +3947,7 @@ async function fileExists2(filePath) {
 }
 async function autoDetectIgnorePatterns(absPath) {
   const patterns = [];
-  if (await fileExists2(join13(absPath, "esbuild.js"))) {
+  if (await fileExists3(join14(absPath, "esbuild.js"))) {
     patterns.push("esbuild.js");
   }
   let entries = [];
@@ -3569,19 +3967,19 @@ async function autoDetectIgnorePatterns(absPath) {
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vitest.config.${ext}`;
-    if (await fileExists2(join13(absPath, candidate))) {
+    if (await fileExists3(join14(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vite.config.${ext}`;
-    if (await fileExists2(join13(absPath, candidate))) {
+    if (await fileExists3(join14(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
-  if (await fileExists2(join13(absPath, "tauri.conf.json"))) {
+  if (await fileExists3(join14(absPath, "tauri.conf.json"))) {
     patterns.push("src-tauri/**");
     patterns.push("**/*.d.ts");
   }
@@ -3589,14 +3987,14 @@ async function autoDetectIgnorePatterns(absPath) {
 }
 function detectPackageManager(projectPath) {
   return (async () => {
-    if (await fileExists2(join13(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(join13(projectPath, "yarn.lock"))) return "yarn";
+    if (await fileExists3(join14(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists3(join14(projectPath, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
 async function getInstalledDeps(pkgJsonPath) {
   try {
-    const raw = await readFile10(pkgJsonPath, "utf-8");
+    const raw = await readFile11(pkgJsonPath, "utf-8");
     const pkg = JSON.parse(raw);
     const all = /* @__PURE__ */ new Set();
     for (const name of Object.keys(pkg.dependencies ?? {})) all.add(name);
@@ -3709,7 +4107,7 @@ async function eslintInit(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
-    const configPath = join13(target.absPath, "eslint.config.mjs");
+    const configPath = join14(target.absPath, "eslint.config.mjs");
     configsToWrite.push({
       target,
       presets,
@@ -3731,11 +4129,11 @@ async function eslintInit(repoId, projectPath) {
     return;
   }
   const pm = await detectPackageManager(projectPath);
-  const rootPkgJsonPath = join13(projectPath, "package.json");
+  const rootPkgJsonPath = join14(projectPath, "package.json");
   const installed = await getInstalledDeps(rootPkgJsonPath);
   if (isMonorepo) {
     for (const { target } of configsToWrite) {
-      const appPkgJson = join13(target.absPath, "package.json");
+      const appPkgJson = join14(target.absPath, "package.json");
       const appDeps = await getInstalledDeps(appPkgJson);
       for (const dep of appDeps) {
         installed.add(dep);
@@ -3785,9 +4183,9 @@ async function eslintInit(repoId, projectPath) {
     configPath,
     userOverrides
   } of configsToWrite) {
-    if (await fileExists2(configPath)) {
+    if (await fileExists3(configPath)) {
       try {
-        const existing = await readFile10(configPath, "utf-8");
+        const existing = await readFile11(configPath, "utf-8");
         const existingHash = hashConfig(existing);
         if (existingHash === hash) {
           console.log(
@@ -3807,7 +4205,7 @@ async function eslintInit(repoId, projectPath) {
       }
     }
     try {
-      await writeFile8(configPath, content, "utf-8");
+      await writeFile9(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${target.name}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -4107,16 +4505,16 @@ var init_sync_approvals = __esm({
 });
 
 // src/lib/worktree-cache.ts
-import { mkdir as mkdir5, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname6, join as join14 } from "node:path";
+import { mkdir as mkdir6, readFile as readFile12, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname6, join as join15 } from "node:path";
 function worktreeCachePath(repoRoot) {
-  return join14(repoRoot, ".codebyplan", "worktree.local.json");
+  return join15(repoRoot, ".codebyplan", "worktree.local.json");
 }
 async function readCachedWorktreeId(repoRoot, currentBranch) {
   const cachePath = worktreeCachePath(repoRoot);
   let raw;
   try {
-    raw = await readFile11(cachePath, "utf-8");
+    raw = await readFile12(cachePath, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -4161,8 +4559,8 @@ async function writeWorktreeCache(repoRoot, data) {
     resolved_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    await mkdir5(dirPath, { recursive: true });
-    await writeFile9(
+    await mkdir6(dirPath, { recursive: true });
+    await writeFile10(
       cachePath,
       JSON.stringify(payload, null, 2) + "\n",
       "utf-8"
@@ -4191,8 +4589,8 @@ __export(round_exports, {
   runRoundSyncApprovals: () => runRoundSyncApprovals,
   setRetryDelayMs: () => setRetryDelayMs
 });
-import { access as access3 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { access as access4 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 import { execSync as execSync2 } from "node:child_process";
 function setRetryDelayMs(ms) {
   RETRY_DELAY_MS = ms;
@@ -4373,7 +4771,7 @@ async function runRoundSyncApprovals(args) {
           "sync-approvals: git status failed; proceeding with empty diff\n"
         );
       }
-      const hookPath = join15(
+      const hookPath = join16(
         repoRoot,
         ".claude",
         "hooks",
@@ -4381,7 +4779,7 @@ async function runRoundSyncApprovals(args) {
       );
       let lintFormatHookExists = false;
       try {
-        await access3(hookPath);
+        await access4(hookPath);
         lintFormatHookExists = true;
       } catch {
       }
@@ -4464,8 +4862,8 @@ var init_round = __esm({
 });
 
 // src/lib/migrate-branch-model.ts
-import { readFile as readFile12, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { readFile as readFile13, writeFile as writeFile11 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 function assertValidBranchName(branch) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -4474,8 +4872,8 @@ function assertValidBranchName(branch) {
     );
   }
 }
-async function readJsonFile(filePath) {
-  const raw = await readFile12(filePath, "utf-8");
+async function readJsonFile2(filePath) {
+  const raw = await readFile13(filePath, "utf-8");
   const parsed = JSON.parse(raw);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error(`${filePath} does not contain a JSON object`);
@@ -4544,17 +4942,17 @@ async function runBranchMigration(opts) {
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      configPath = join16(dir, "git.json");
+      configPath = join17(dir, "git.json");
     } else {
       configPath = found.path;
     }
   } else {
-    configPath = join16(cwd, ".codebyplan", "git.json");
+    configPath = join17(cwd, ".codebyplan", "git.json");
   }
   let fileRaw;
   let fileParsed;
   try {
-    const result = await readJsonFile(configPath);
+    const result = await readJsonFile2(configPath);
     fileRaw = result.raw;
     fileParsed = result.parsed;
   } catch (err) {
@@ -4623,7 +5021,7 @@ async function runBranchMigration(opts) {
     const updatedParsed = { ...fileParsed, branch_config: after };
     const newJson = JSON.stringify(updatedParsed, null, 2) + "\n";
     if (newJson !== fileRaw) {
-      await writeFile10(configPath, newJson, "utf-8");
+      await writeFile11(configPath, newJson, "utf-8");
     }
   }
   return {
@@ -4729,24 +5127,24 @@ var init_branch = __esm({
 });
 
 // src/lib/git-utils.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join17 } from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { readFile as readFile14 } from "node:fs/promises";
+import { join as join18 } from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
 async function readBaseBranch(cwd) {
   const found = await findCodebyplanConfig(cwd);
   let gitJsonPath;
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      gitJsonPath = join17(dir, "git.json");
+      gitJsonPath = join18(dir, "git.json");
     } else {
       gitJsonPath = found.path;
     }
   } else {
-    gitJsonPath = join17(cwd, ".codebyplan", "git.json");
+    gitJsonPath = join18(cwd, ".codebyplan", "git.json");
   }
   try {
-    const raw = await readFile13(gitJsonPath, "utf-8");
+    const raw = await readFile14(gitJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return "main";
@@ -4766,7 +5164,7 @@ async function readBaseBranch(cwd) {
 function resolveBaseRef(cwd, baseBranch) {
   if (baseBranch.startsWith("origin/")) return baseBranch;
   const remoteRef = `origin/${baseBranch}`;
-  const check = spawnSync2(
+  const check = spawnSync4(
     "git",
     ["rev-parse", "--verify", "--quiet", `${remoteRef}^{commit}`],
     { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -4784,9 +5182,9 @@ var init_git_utils = __esm({
 });
 
 // src/lib/bump.ts
-import { readFile as readFile14, writeFile as writeFile11, access as access4, readdir as readdir3 } from "node:fs/promises";
-import { join as join18, relative as relative5, resolve as resolve3 } from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { readFile as readFile15, writeFile as writeFile12, access as access5, readdir as readdir3 } from "node:fs/promises";
+import { join as join19, relative as relative5, resolve as resolve3 } from "node:path";
+import { spawnSync as spawnSync5 } from "node:child_process";
 function parsePnpmWorkspaceGlobs(raw) {
   const lines = raw.split("\n");
   const globs = [];
@@ -4815,18 +5213,18 @@ async function expandGlob(cwd, glob) {
   if (parts.length !== 2 || parts[1] !== "*") {
     return [];
   }
-  const parentDir = join18(cwd, parts[0]);
+  const parentDir = join19(cwd, parts[0]);
   let dirs;
   try {
     const entries = await readdir3(parentDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory()).map((e) => join18(parentDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory()).map((e) => join19(parentDir, e.name));
   } catch {
     return [];
   }
   const results = [];
   for (const dir of dirs) {
     try {
-      await access4(join18(dir, "package.json"));
+      await access5(join19(dir, "package.json"));
       results.push(dir);
     } catch {
     }
@@ -4837,7 +5235,7 @@ async function buildPackageMap(cwd) {
   const map = /* @__PURE__ */ new Map();
   let globs = [];
   try {
-    const raw = await readFile14(join18(cwd, "pnpm-workspace.yaml"), "utf-8");
+    const raw = await readFile15(join19(cwd, "pnpm-workspace.yaml"), "utf-8");
     globs = parsePnpmWorkspaceGlobs(raw);
   } catch {
   }
@@ -4845,7 +5243,7 @@ async function buildPackageMap(cwd) {
     const dirs = await expandGlob(cwd, glob);
     for (const dir of dirs) {
       try {
-        const pkgRaw = await readFile14(join18(dir, "package.json"), "utf-8");
+        const pkgRaw = await readFile15(join19(dir, "package.json"), "utf-8");
         const pkg = JSON.parse(pkgRaw);
         const name = pkg.name ?? relative5(cwd, dir);
         map.set(dir, { name, dir });
@@ -4894,7 +5292,7 @@ function compareSemver(a, b) {
   return 0;
 }
 function gitShowFile(cwd, ref, relPath) {
-  const result = spawnSync3("git", ["show", `${ref}:${relPath}`], {
+  const result = spawnSync5("git", ["show", `${ref}:${relPath}`], {
     cwd,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4935,7 +5333,7 @@ function injectVersion(raw, nextVersion, filePath) {
 async function prependChangelog(changelogPath, packageName, nextVersion, now, dryRun) {
   let existing;
   try {
-    existing = await readFile14(changelogPath, "utf-8");
+    existing = await readFile15(changelogPath, "utf-8");
   } catch {
     return false;
   }
@@ -4948,7 +5346,7 @@ async function prependChangelog(changelogPath, packageName, nextVersion, now, dr
 `;
   const updated = entry + existing;
   if (!dryRun) {
-    await writeFile11(changelogPath, updated, "utf-8");
+    await writeFile12(changelogPath, updated, "utf-8");
   }
   return true;
 }
@@ -4958,7 +5356,7 @@ async function runBump(opts) {
   const now = opts?.now ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const baseBranch = await readBaseBranch(cwd);
   const baseRef = resolveBaseRef(cwd, baseBranch);
-  const diffResult = spawnSync3(
+  const diffResult = spawnSync5(
     "git",
     ["diff", "--name-only", `${baseRef}...HEAD`],
     {
@@ -4974,7 +5372,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 = join18(cwd, "package.json");
+  const rootPkgPath = join19(cwd, "package.json");
   const changedPackageDirs = /* @__PURE__ */ new Set();
   for (const absFile of changedFiles) {
     const owner = findOwningPackage(absFile, packageDirs);
@@ -4985,28 +5383,28 @@ async function runBump(opts) {
   const entries = [];
   for (const pkgDir of changedPackageDirs) {
     const pkgInfo = packageMap.get(pkgDir);
-    const pkgJsonPath = join18(pkgDir, "package.json");
+    const pkgJsonPath = join19(pkgDir, "package.json");
     if (pkgJsonPath === rootPkgPath) continue;
     const versionFileCandidates = [
       { abs: pkgJsonPath, rel: relative5(cwd, pkgJsonPath).replace(/\\/g, "/") }
     ];
-    const tauriConfPath = join18(pkgDir, "src-tauri", "tauri.conf.json");
+    const tauriConfPath = join19(pkgDir, "src-tauri", "tauri.conf.json");
     const tauriRelPath = relative5(cwd, tauriConfPath).replace(/\\/g, "/");
     try {
-      await access4(tauriConfPath);
+      await access5(tauriConfPath);
       versionFileCandidates.push({ abs: tauriConfPath, rel: tauriRelPath });
     } catch {
     }
-    const appJsonPath = join18(pkgDir, "app.json");
+    const appJsonPath = join19(pkgDir, "app.json");
     const appJsonRelPath = relative5(cwd, appJsonPath).replace(/\\/g, "/");
     try {
-      await access4(appJsonPath);
+      await access5(appJsonPath);
       versionFileCandidates.push({ abs: appJsonPath, rel: appJsonRelPath });
     } catch {
     }
     let currentPkgJsonRaw;
     try {
-      currentPkgJsonRaw = await readFile14(pkgJsonPath, "utf-8");
+      currentPkgJsonRaw = await readFile15(pkgJsonPath, "utf-8");
     } catch (err) {
       console.warn(
         `runBump: could not read ${pkgJsonPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -5051,7 +5449,7 @@ async function runBump(opts) {
     for (const { abs, rel } of versionFileCandidates) {
       let raw;
       try {
-        raw = await readFile14(abs, "utf-8");
+        raw = await readFile15(abs, "utf-8");
       } catch {
         continue;
       }
@@ -5065,11 +5463,11 @@ async function runBump(opts) {
       }
       const updated = injectVersion(raw, nextVersion, abs);
       if (!dryRun) {
-        await writeFile11(abs, updated, "utf-8");
+        await writeFile12(abs, updated, "utf-8");
       }
       updatedVersionFiles.push(rel);
     }
-    const changelogPath = join18(pkgDir, "CHANGELOG.md");
+    const changelogPath = join19(pkgDir, "CHANGELOG.md");
     const changelogUpdated = await prependChangelog(
       changelogPath,
       pkgInfo.name,
@@ -5190,7 +5588,7 @@ var init_bump2 = __esm({
 });
 
 // src/lib/ship.ts
-import { execSync as execSync4, spawnSync as spawnSync4 } from "node:child_process";
+import { execSync as execSync4, spawnSync as spawnSync6 } from "node:child_process";
 import { relative as relative6 } from "node:path";
 function assertValidBranchName2(branch, label) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -5215,7 +5613,7 @@ async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Prom
   let totalGhErrors = 0;
   let iteration = 0;
   while (Date.now() < deadline) {
-    const ghResult = spawnSync4(
+    const ghResult = spawnSync6(
       "gh",
       ["pr", "checks", feat, "--json", "name,state,conclusion"],
       {
@@ -5373,7 +5771,7 @@ ${statusOut.trim()}`
       ...e.changelogUpdated ? [relative6(cwd, e.packageDir).replace(/\\/g, "/") + "/CHANGELOG.md"] : []
     ]);
     if (toStage.length > 0) {
-      const addResult = spawnSync4("git", ["add", "--", ...toStage], {
+      const addResult = spawnSync6("git", ["add", "--", ...toStage], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -5383,13 +5781,13 @@ ${statusOut.trim()}`
           `Failed to stage bump files: ${addResult.stderr?.trim() ?? addResult.error?.message}`
         );
       }
-      const commitResult = spawnSync4(
+      const commitResult = spawnSync6(
         "git",
         ["commit", "-m", "chore(release): bump versions"],
         { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       );
       if (commitResult.status !== 0 || commitResult.error) {
-        spawnSync4(
+        spawnSync6(
           "git",
           ["restore", "--staged", "--worktree", "--", ...toStage],
           {
@@ -5434,7 +5832,7 @@ ${statusOut.trim()}`
     } else {
       createArgs.push("--body", defaultPrBody(feat, base));
     }
-    const createResult = spawnSync4("gh", createArgs, {
+    const createResult = spawnSync6("gh", createArgs, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5465,7 +5863,7 @@ ${statusOut.trim()}`
   });
   let mergeCommit = null;
   try {
-    const prViewResult = spawnSync4(
+    const prViewResult = spawnSync6(
       "gh",
       ["pr", "view", feat, "--json", "state,mergeCommit"],
       {
@@ -6255,7 +6653,7 @@ __export(version_status_exports, {
 });
 import { execFileSync, execSync as execSync6 } from "node:child_process";
 import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname8, join as join20 } from "node:path";
+import { dirname as dirname8, join as join21 } from "node:path";
 function fetchLatestVersion() {
   try {
     return execFileSync("npm", ["view", "codebyplan", "version"], {
@@ -6294,9 +6692,9 @@ function detectPackageManager2(gitRoot) {
   let dir = process.cwd();
   const stopAt = gitRoot ?? null;
   while (true) {
-    if (existsSync4(join20(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync4(join20(dir, "yarn.lock"))) return "yarn";
-    if (existsSync4(join20(dir, "package-lock.json"))) return "npm";
+    if (existsSync4(join21(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync4(join21(dir, "yarn.lock"))) return "yarn";
+    if (existsSync4(join21(dir, "package-lock.json"))) return "npm";
     if (stopAt !== null && dir === stopAt) break;
     const parent = dirname8(dir);
     if (parent === dir) break;
@@ -6316,7 +6714,7 @@ function buildInstallCommand2(pm) {
 }
 async function resolveGuard(gitRoot, currentBranch) {
   if (gitRoot !== null) {
-    const canonicalPkgPath = join20(
+    const canonicalPkgPath = join21(
       gitRoot,
       "packages",
       "codebyplan-package",
@@ -6340,10 +6738,10 @@ async function resolveGuard(gitRoot, currentBranch) {
       let gitJsonPath;
       if (found.path.endsWith("/repo.json")) {
         const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join20(dir, "git.json");
+        gitJsonPath = join21(dir, "git.json");
       } else {
         const legacyDir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join20(legacyDir, ".codebyplan", "git.json");
+        gitJsonPath = join21(legacyDir, ".codebyplan", "git.json");
       }
       const raw = readFileSync5(gitJsonPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -6422,8 +6820,8 @@ var upload_e2e_images_exports = {};
 __export(upload_e2e_images_exports, {
   runUploadE2eImagesCommand: () => runUploadE2eImagesCommand
 });
-import { readFile as readFile15 } from "node:fs/promises";
-import { join as join21, basename, resolve as resolve5 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { join as join22, basename, resolve as resolve5 } from "node:path";
 import { execSync as execSync7 } from "node:child_process";
 function baseUrl2() {
   return (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
@@ -6457,8 +6855,8 @@ function parseArgs(args) {
 }
 async function readE2eConfig(projectPath) {
   try {
-    const raw = await readFile15(
-      join21(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile16(
+      join22(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -6499,7 +6897,7 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
       continue;
     const isNew = status === "A";
     results.push({
-      absolutePath: join21(projectPath, filePath),
+      absolutePath: join22(projectPath, filePath),
       filename: basename(filePath),
       framework: frameworkName,
       is_new: isNew
@@ -6596,7 +6994,7 @@ async function runUploadE2eImagesCommand(args) {
   for (const png of allPngs) {
     let bytes;
     try {
-      bytes = await readFile15(png.absolutePath);
+      bytes = await readFile16(png.absolutePath);
     } catch {
       process.stderr.write(
         `upload-e2e-images: could not read file: ${png.absolutePath}
@@ -6755,19 +7153,19 @@ var init_worktree_port_resolver = __esm({
 });
 
 // src/lib/migrate-local-config.ts
-import { mkdir as mkdir6, readFile as readFile16, unlink as unlink2, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { mkdir as mkdir7, readFile as readFile17, unlink as unlink3, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join22(projectPath, ".codebyplan.json");
+  return join23(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join22(projectPath, ".codebyplan.local.json");
+  return join23(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join22(projectPath, ".codebyplan");
+  return join23(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join22(projectPath, ".codebyplan", "repo.json");
+  return join23(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
   const { stat: stat2 } = await import("node:fs/promises");
@@ -6806,7 +7204,7 @@ async function runLocalMigration(projectPath) {
   }
   let legacyRaw;
   try {
-    legacyRaw = await readFile16(legacySharedPath(projectPath), "utf-8");
+    legacyRaw = await readFile17(legacySharedPath(projectPath), "utf-8");
   } catch {
     return {
       migrated: true,
@@ -6833,7 +7231,7 @@ async function runLocalMigration(projectPath) {
   let deviceId;
   let deviceWrittenByHelper = false;
   try {
-    const localRaw = await readFile16(legacyLocalPath(projectPath), "utf-8");
+    const localRaw = await readFile17(legacyLocalPath(projectPath), "utf-8");
     const localParsed = JSON.parse(localRaw);
     if (typeof localParsed.device_id === "string") {
       deviceId = localParsed.device_id;
@@ -6841,7 +7239,7 @@ async function runLocalMigration(projectPath) {
   } catch {
   }
   try {
-    await mkdir6(newDirPath(projectPath), { recursive: true });
+    await mkdir7(newDirPath(projectPath), { recursive: true });
   } catch (err) {
     const code = err.code;
     if (code === "ENOTDIR" || code === "EEXIST") {
@@ -6860,8 +7258,8 @@ async function runLocalMigration(projectPath) {
   if ("repo_id" in cfg) repoJson.repo_id = cfg.repo_id;
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "repo.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -6873,8 +7271,8 @@ async function runLocalMigration(projectPath) {
     serverJson.auto_push_enabled = cfg.auto_push_enabled;
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "server.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -6882,44 +7280,44 @@ async function runLocalMigration(projectPath) {
   const gitJson = {};
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "git.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/git.json");
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "shipment.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "vendor.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "e2e.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
-  await writeFile12(
-    join22(projectPath, ".codebyplan", "eslint.json"),
+  await writeFile13(
+    join23(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/eslint.json");
   if (!deviceWrittenByHelper) {
-    await writeFile12(
-      join22(projectPath, ".codebyplan", "device.local.json"),
+    await writeFile13(
+      join23(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -6931,9 +7329,9 @@ async function runLocalMigration(projectPath) {
       "Migration write incomplete: .codebyplan/repo.json was not persisted. Re-run migration to retry from a clean state."
     );
   }
-  const gitignorePath = join22(projectPath, ".gitignore");
+  const gitignorePath = join23(projectPath, ".gitignore");
   try {
-    const gitignoreContent = await readFile16(gitignorePath, "utf-8");
+    const gitignoreContent = await readFile17(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
     const newLine = ".codebyplan/device.local.json";
     const hasLegacy = gitignoreContent.split("\n").some((l) => l.trimEnd() === legacyLine);
@@ -6952,18 +7350,18 @@ async function runLocalMigration(projectPath) {
       updated = gitignoreContent;
     }
     if (updated !== gitignoreContent) {
-      await writeFile12(gitignorePath, updated, "utf-8");
+      await writeFile13(gitignorePath, updated, "utf-8");
       filesChanged.push(".gitignore");
     }
   } catch {
   }
   try {
-    await unlink2(legacySharedPath(projectPath));
+    await unlink3(legacySharedPath(projectPath));
     filesChanged.push(".codebyplan.json (deleted)");
   } catch {
   }
   try {
-    await unlink2(legacyLocalPath(projectPath));
+    await unlink3(legacyLocalPath(projectPath));
     filesChanged.push(".codebyplan.local.json (deleted)");
   } catch {
   }
@@ -6993,8 +7391,8 @@ __export(config_exports, {
   readVendorConfig: () => readVendorConfig,
   runConfig: () => runConfig
 });
-import { mkdir as mkdir7, readFile as readFile17, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile18, writeFile as writeFile14 } from "node:fs/promises";
+import { join as join24 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -7027,7 +7425,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join23(projectPath, ".codebyplan");
+  const codebyplanDir = join24(projectPath, ".codebyplan");
   const {
     resolvedWorktreeId,
     portAllocations,
@@ -7099,7 +7497,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
     console.log("  Config would be updated (dry-run).");
     return;
   }
-  await mkdir7(codebyplanDir, { recursive: true });
+  await mkdir8(codebyplanDir, { recursive: true });
   const files = [
     { name: "repo.json", payload: repoPayload },
     { name: "server.json", payload: serverPayload },
@@ -7111,16 +7509,16 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   ];
   let anyUpdated = false;
   for (const { name, payload, createOnly } of files) {
-    const filePath = join23(codebyplanDir, name);
+    const filePath = join24(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
-      currentJson = await readFile17(filePath, "utf-8");
+      currentJson = await readFile18(filePath, "utf-8");
     } catch {
     }
     if (createOnly && currentJson !== "") continue;
     if (currentJson === newJson) continue;
-    await writeFile13(filePath, newJson, "utf-8");
+    await writeFile14(filePath, newJson, "utf-8");
     console.log(`  Updated .codebyplan/${name}`);
     anyUpdated = true;
   }
@@ -7130,8 +7528,8 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 }
 async function readRepoConfig(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "repo.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7141,8 +7539,8 @@ async function readRepoConfig(projectPath) {
 }
 async function readServerConfig(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "server.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7152,8 +7550,8 @@ async function readServerConfig(projectPath) {
 }
 async function readGitConfig(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "git.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7163,8 +7561,8 @@ async function readGitConfig(projectPath) {
 }
 async function readShipmentConfig(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "shipment.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7174,8 +7572,8 @@ async function readShipmentConfig(projectPath) {
 }
 async function readVendorConfig(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7185,8 +7583,8 @@ async function readVendorConfig(projectPath) {
 }
 async function readE2eConfig2(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7196,8 +7594,8 @@ async function readE2eConfig2(projectPath) {
 }
 async function readServerLocalConfig(projectPath) {
   try {
-    const raw = await readFile17(
-      join23(projectPath, ".codebyplan", "server.local.json"),
+    const raw = await readFile18(
+      join24(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7252,14 +7650,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 async function verifyPorts(projectPath, portAllocations) {
   const mismatches = [];
   const allocatedPorts = new Set(portAllocations.map((a) => a.port));
   const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile18(pkgPath, "utf-8");
+      const raw = await readFile19(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -7322,7 +7720,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile18(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile19(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -7372,8 +7770,8 @@ __export(ports_exports, {
   parseEnvFile: () => parseEnvFile,
   runPorts: () => runPorts
 });
-import { mkdir as mkdir8, readFile as readFile19, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile20, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 async function runPorts() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -7494,12 +7892,12 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // and ServerLocalConfig.port_allocations is typed the same — honest end-to-end.
     port_allocations: portAllocations
   };
-  const codebyplanDir = join24(projectPath, ".codebyplan");
-  const filePath = join24(codebyplanDir, "server.local.json");
+  const codebyplanDir = join25(projectPath, ".codebyplan");
+  const filePath = join25(codebyplanDir, "server.local.json");
   const newJson = JSON.stringify(payload, null, 2) + "\n";
   let currentJson = "";
   try {
-    currentJson = await readFile19(filePath, "utf-8");
+    currentJson = await readFile20(filePath, "utf-8");
   } catch {
   }
   if (currentJson === newJson) {
@@ -7510,18 +7908,18 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     console.log("  Would update .codebyplan/server.local.json (dry-run).");
     return;
   }
-  await mkdir8(codebyplanDir, { recursive: true });
-  await writeFile14(filePath, newJson, "utf-8");
+  await mkdir9(codebyplanDir, { recursive: true });
+  await writeFile15(filePath, newJson, "utf-8");
   console.log(
     `  Updated .codebyplan/server.local.json (worktree ${resolvedWorktreeId ?? "\u2014"}, ${portAllocations.length} allocation${portAllocations.length === 1 ? "" : "s"}).`
   );
 }
 async function provisionE2eEnv(projectPath, dryRun) {
-  const relSource = join24("apps", "web", ".env.local");
-  const sourcePath = join24(projectPath, relSource);
+  const relSource = join25("apps", "web", ".env.local");
+  const sourcePath = join25(projectPath, relSource);
   let sourceRaw;
   try {
-    sourceRaw = await readFile19(sourcePath, "utf-8");
+    sourceRaw = await readFile20(sourcePath, "utf-8");
   } catch {
     console.warn(
       `  Skipped .codebyplan/e2e.env \u2014 source ${relSource} not found.`
@@ -7550,12 +7948,12 @@ async function provisionE2eEnv(projectPath, dryRun) {
     );
     return;
   }
-  const codebyplanDir = join24(projectPath, ".codebyplan");
-  const filePath = join24(codebyplanDir, "e2e.env");
+  const codebyplanDir = join25(projectPath, ".codebyplan");
+  const filePath = join25(codebyplanDir, "e2e.env");
   const newContent = lines.join("\n") + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile19(filePath, "utf-8");
+    currentContent = await readFile20(filePath, "utf-8");
   } catch {
   }
   if (currentContent === newContent) {
@@ -7566,8 +7964,8 @@ async function provisionE2eEnv(projectPath, dryRun) {
     console.log("  Would provision .codebyplan/e2e.env (dry-run).");
     return;
   }
-  await mkdir8(codebyplanDir, { recursive: true });
-  await writeFile14(filePath, newContent, "utf-8");
+  await mkdir9(codebyplanDir, { recursive: true });
+  await writeFile15(filePath, newContent, "utf-8");
   console.log(
     `  Provisioned .codebyplan/e2e.env (${lines.length} var${lines.length === 1 ? "" : "s"}).`
   );
@@ -8414,6 +8812,11 @@ async function runUpdate(opts, deps = {}) {
     if (opts.renderer && !opts.dryRun) {
       await writeStatuslineLocalConfig(projectDir, { renderer: opts.renderer });
     }
+    try {
+      const { runLspFull: runLspFull2 } = await Promise.resolve().then(() => (init_lsp(), lsp_exports));
+      await runLspFull2(projectDir, { dryRun: opts.dryRun });
+    } catch {
+    }
   } catch (err) {
     console.error(
       `codebyplan claude update failed: ${err instanceof Error ? err.message : String(err)}`
@@ -8886,6 +9289,11 @@ void (async () => {
     await runTechStack2();
     process.exit(0);
   }
+  if (arg === "lsp") {
+    const { runLsp: runLsp2 } = await Promise.resolve().then(() => (init_lsp(), lsp_exports));
+    await runLsp2();
+    process.exit(0);
+  }
   if (arg === "claude") {
     const subcommand = process.argv[3];
     const flagArgs = process.argv.slice(3);
@@ -8972,6 +9380,7 @@ void (async () => {
     codebyplan tech-stack            Detect and sync tech stack dependencies
                                      (--full-tech-stack: sync every local worktree on this device)
     codebyplan eslint                ESLint config management (init)
+    codebyplan lsp                   Detect tech stack and enable LSP plugins in Claude Code
     codebyplan round sync-approvals  Sync git diff and approvals with round/task state
     codebyplan bump                  Detect changed packages and patch-bump versions
     codebyplan ship                  Ship current feat branch to production via PR