codebyplan 1.10.2 → 1.11.0

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.10.2";
+    VERSION = "1.11.0";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -22,13 +22,16 @@ var init_version = __esm({
 // src/lib/local-config.ts
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
 import { dirname, join } from "node:path";
 function localConfigPath(projectPath) {
   return join(projectPath, ".codebyplan", "device.local.json");
 }
-async function readLocalConfig(projectPath) {
+function legacyLocalConfigPath(projectPath) {
+  return join(projectPath, ".codebyplan.local.json");
+}
+async function readLocalConfig(projectPath, onMigrationNotice) {
   try {
     const raw = await readFile(localConfigPath(projectPath), "utf-8");
     const parsed = JSON.parse(raw);
@@ -38,22 +41,81 @@ async function readLocalConfig(projectPath) {
     console.error("Failed to read local config: invalid shape");
     return null;
   } catch (err) {
-    console.error(
-      `Failed to read local config: ${err instanceof Error ? err.message : String(err)}`
-    );
+    const code = err.code;
+    if (code === "ENOENT") {
+    } else if (code === "ENOTDIR") {
+      try {
+        const dirPath = dirname(localConfigPath(projectPath));
+        const st = await stat(dirPath);
+        if (!st.isDirectory()) {
+          throw Object.assign(
+            new Error(`${dirPath} is a file, expected directory`),
+            { code: "LEGACY_FILE_BLOCKS_DIR" }
+          );
+        }
+      } catch (statErr) {
+        if (statErr.code === "LEGACY_FILE_BLOCKS_DIR")
+          throw statErr;
+      }
+      throw err;
+    } else if (typeof code === "string") {
+      throw err;
+    } else {
+      console.error(
+        `Failed to read local config: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return null;
+    }
+  }
+  try {
+    const raw = await readFile(legacyLocalConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.device_id === "string") {
+      onMigrationNotice?.(
+        legacyLocalConfigPath(projectPath),
+        localConfigPath(projectPath)
+      );
+      return parsed;
+    }
     return null;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return null;
+    }
+    throw err;
   }
 }
 async function writeLocalConfig(projectPath, config) {
   const content = { device_id: config.device_id };
   const path6 = localConfigPath(projectPath);
+  const dirPath = dirname(path6);
+  let phase = "stat config directory";
   try {
-    await mkdir(dirname(path6), { recursive: true });
+    try {
+      const st = await stat(dirPath);
+      if (!st.isDirectory()) {
+        const err = Object.assign(
+          new Error(`${dirPath} is a file, expected directory`),
+          { code: "LEGACY_FILE_BLOCKS_DIR" }
+        );
+        throw err;
+      }
+    } catch (statErr) {
+      const code = statErr.code;
+      if (code === "LEGACY_FILE_BLOCKS_DIR") throw statErr;
+      if (code !== "ENOENT") throw statErr;
+    }
+    phase = "create config directory";
+    await mkdir(dirPath, { recursive: true });
+    phase = "write local config";
     await writeFile(path6, JSON.stringify(content, null, 2) + "\n", "utf-8");
   } catch (err) {
-    console.error(
-      `Failed to write local config: ${err instanceof Error ? err.message : String(err)}`
-    );
+    const code = err.code;
+    if (code === "LEGACY_FILE_BLOCKS_DIR") {
+      throw err;
+    }
+    console.error(`Failed to ${phase}: ${err.message}`);
     throw err;
   }
 }
@@ -73,8 +135,8 @@ async function resolveMachineSeed() {
   }
   return hostname();
 }
-async function getOrCreateDeviceId(projectPath) {
-  const existing = await readLocalConfig(projectPath);
+async function getOrCreateDeviceId(projectPath, onMigrationNotice) {
+  const existing = await readLocalConfig(projectPath, onMigrationNotice);
   if (existing?.device_id) {
     return existing.device_id;
   }
@@ -89,6 +151,122 @@ var init_local_config = __esm({
   }
 });
 
+// src/lib/statusline-config.ts
+import { spawnSync } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function statuslineConfigPath(projectPath) {
+  return join2(projectPath, ".codebyplan", "statusline.json");
+}
+function statuslineLocalConfigPath(projectPath) {
+  return join2(projectPath, ".codebyplan", "statusline.local.json");
+}
+function isValidRenderer(value) {
+  return typeof value === "string" && VALID_RENDERERS.has(value);
+}
+function mergeOverDefaults(raw) {
+  const result = {
+    lines: { ...STATUSLINE_DEFAULTS.lines },
+    no_color: STATUSLINE_DEFAULTS.no_color
+  };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return result;
+  }
+  const obj = raw;
+  if (typeof obj.no_color === "boolean") {
+    result.no_color = obj.no_color;
+  }
+  if (typeof obj.lines === "object" && obj.lines !== null && !Array.isArray(obj.lines)) {
+    const lines = obj.lines;
+    for (const key of Object.keys(STATUSLINE_DEFAULTS.lines)) {
+      if (typeof lines[key] === "boolean") {
+        result.lines[key] = lines[key];
+      }
+    }
+  }
+  return result;
+}
+async function readStatuslineConfig(projectPath) {
+  try {
+    const raw = await readFile2(statuslineConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    return mergeOverDefaults(parsed);
+  } catch {
+    return mergeOverDefaults(void 0);
+  }
+}
+async function readStatuslineLocalConfig(projectPath) {
+  try {
+    const raw = await readFile2(statuslineLocalConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const obj = parsed;
+      if (isValidRenderer(obj.renderer)) {
+        return { renderer: obj.renderer };
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeStatuslineLocalConfig(projectPath, localConfig) {
+  if (!isValidRenderer(localConfig.renderer)) {
+    throw new TypeError(
+      `Unknown renderer: "${String(localConfig.renderer)}". Must be one of: bash, node, python.`
+    );
+  }
+  const filePath = statuslineLocalConfigPath(projectPath);
+  await mkdir2(join2(projectPath, ".codebyplan"), { recursive: true });
+  await writeFile2(
+    filePath,
+    JSON.stringify(localConfig, null, 2) + "\n",
+    "utf-8"
+  );
+}
+async function resolveRenderer(projectPath) {
+  const local = await readStatuslineLocalConfig(projectPath);
+  return local?.renderer ?? DEFAULT_RENDERER;
+}
+function detectAvailableRenderers() {
+  function probe(cmd, args) {
+    try {
+      const result = spawnSync(cmd, args, {
+        timeout: 1e3,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      return result.status === 0;
+    } catch {
+      return false;
+    }
+  }
+  return {
+    bash: true,
+    node: probe("node", ["--version"]),
+    python: probe("python3", ["--version"])
+  };
+}
+var STATUSLINE_DEFAULTS, DEFAULT_RENDERER, VALID_RENDERERS;
+var init_statusline_config = __esm({
+  "src/lib/statusline-config.ts"() {
+    "use strict";
+    STATUSLINE_DEFAULTS = {
+      lines: {
+        identity: true,
+        context: true,
+        cost: true,
+        rate_limits: true,
+        repo_pr: true,
+        worktree: true
+      },
+      no_color: false
+    };
+    DEFAULT_RENDERER = "bash";
+    VALID_RENDERERS = /* @__PURE__ */ new Set(["bash", "node", "python"]);
+  }
+});
+
 // src/oauth/jwt-decode.ts
 function base64UrlDecode(input) {
   const padded = input + "=".repeat((4 - input.length % 4) % 4);
@@ -119,9 +297,9 @@ var init_jwt_decode = __esm({
 });
 
 // src/oauth/keychain.ts
-import { chmod, mkdir as mkdir2, readFile as readFile2, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod, mkdir as mkdir3, readFile as readFile3, unlink, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir, platform } from "node:os";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 async function loadKeyring() {
   if (keyringOverride !== void 0) return keyringOverride;
   try {
@@ -133,18 +311,18 @@ async function loadKeyring() {
 }
 function fallbackDir() {
   if (platform() === "win32") {
-    const appData = process.env.APPDATA ?? join2(homedir(), "AppData", "Roaming");
-    return join2(appData, "codebyplan");
+    const appData = process.env.APPDATA ?? join3(homedir(), "AppData", "Roaming");
+    return join3(appData, "codebyplan");
   }
-  const xdg = process.env.XDG_CONFIG_HOME ?? join2(homedir(), ".config");
-  return join2(xdg, "codebyplan");
+  const xdg = process.env.XDG_CONFIG_HOME ?? join3(homedir(), ".config");
+  return join3(xdg, "codebyplan");
 }
 function fallbackFile(filename) {
-  return join2(fallbackDir(), filename);
+  return join3(fallbackDir(), filename);
 }
 async function readFallback(filename) {
   try {
-    const raw = await readFile2(fallbackFile(filename), "utf-8");
+    const raw = await readFile3(fallbackFile(filename), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -152,8 +330,8 @@ async function readFallback(filename) {
 }
 async function writeFallback(filename, data) {
   const path6 = fallbackFile(filename);
-  await mkdir2(dirname2(path6), { recursive: true });
-  await writeFile2(path6, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await mkdir3(dirname2(path6), { recursive: true });
+  await writeFile3(path6, JSON.stringify(data, null, 2) + "\n", "utf-8");
   if (platform() !== "win32") {
     try {
       await chmod(path6, 384);
@@ -504,8 +682,8 @@ var init_api = __esm({
 });
 
 // src/lib/resolve-worktree.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 async function resolveAndCacheWorktreeId(repoId, projectPath, options) {
   let worktreeId;
   try {
@@ -527,10 +705,10 @@ async function resolveAndCacheWorktreeId(repoId, projectPath, options) {
   if (options?.skipWrite) {
     return worktreeId;
   }
-  const codebyplanPath = join3(projectPath, ".codebyplan.json");
+  const codebyplanPath = join4(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile3(codebyplanPath, "utf-8");
+    const raw = await readFile4(codebyplanPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       currentConfig = parsed;
@@ -545,7 +723,7 @@ async function resolveAndCacheWorktreeId(repoId, projectPath, options) {
     worktree_id: worktreeId
   };
   try {
-    await writeFile3(
+    await writeFile4(
       codebyplanPath,
       JSON.stringify(merged, null, 2) + "\n",
       "utf-8"
@@ -561,7 +739,8 @@ async function resolveAndCacheWorktreeId(repoId, projectPath, options) {
 async function resolveWorktreeByBranch({
   repoId,
   deviceId,
-  branch
+  branch,
+  onError
 }) {
   if (!deviceId || !branch) {
     return null;
@@ -588,6 +767,10 @@ async function resolveWorktreeByBranch({
     console.warn(
       `Worktree self-heal skipped (non-fatal): branch worktree resolve failed: ${err instanceof Error ? err.message : String(err)}. Continuing.`
     );
+    onError?.(
+      "api_failed",
+      err instanceof Error ? err : new Error(String(err))
+    );
     return null;
   }
 }
@@ -595,7 +778,8 @@ async function resolveWorktreeId({
   repoId,
   repoPath,
   branch,
-  deviceId
+  deviceId,
+  onError
 }) {
   try {
     const res = await apiPost(
@@ -607,6 +791,10 @@ async function resolveWorktreeId({
     console.warn(
       `Worktree self-heal skipped (non-fatal): ${err instanceof Error ? err.message : String(err)}. Continuing \u2014 run \`codebyplan config\` again later to retry.`
     );
+    onError?.(
+      "api_failed",
+      err instanceof Error ? err : new Error(String(err))
+    );
     return null;
   }
 }
@@ -869,13 +1057,13 @@ var setup_exports = {};
 __export(setup_exports, {
   runSetup: () => runSetup
 });
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { stdin, stdout as stdout2 } from "node:process";
 import { createInterface } from "node:readline/promises";
 function getConfigPath(scope) {
-  return scope === "user" ? join4(homedir2(), ".claude.json") : join4(process.cwd(), ".mcp.json");
+  return scope === "user" ? join5(homedir2(), ".claude.json") : join5(process.cwd(), ".mcp.json");
 }
 function legacyMcpUrl() {
   const baseUrl2 = process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com";
@@ -883,7 +1071,7 @@ function legacyMcpUrl() {
 }
 async function readConfig(path6) {
   try {
-    const raw = await readFile4(path6, "utf-8");
+    const raw = await readFile5(path6, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -906,7 +1094,7 @@ async function writeMcpConfig(scope, auth) {
     config.mcpServers = {};
   }
   config.mcpServers.codebyplan = buildMcpEntry(auth);
-  await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile5(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return configPath;
 }
 async function fetchRepos(auth) {
@@ -961,8 +1149,8 @@ async function chooseAuthMode(rl) {
   return { kind: "legacy", apiKey };
 }
 async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
-  const codebyplanDir = join4(projectPath, ".codebyplan");
-  await mkdir3(codebyplanDir, { recursive: true });
+  const codebyplanDir = join5(projectPath, ".codebyplan");
+  await mkdir4(codebyplanDir, { recursive: true });
   const repoJson = {
     repo_id: selectedRepo.id
   };
@@ -973,13 +1161,13 @@ async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
   if (typeof repoAny.project_id === "string") {
     repoJson.project_id = repoAny.project_id;
   }
-  await writeFile4(
-    join4(codebyplanDir, "repo.json"),
+  await writeFile5(
+    join5(codebyplanDir, "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
-  await writeFile4(
-    join4(codebyplanDir, "server.json"),
+  await writeFile5(
+    join5(codebyplanDir, "server.json"),
     JSON.stringify(
       {
         server_port: null,
@@ -992,40 +1180,68 @@ async function writeCodebyplanDirectory(projectPath, selectedRepo, deviceId) {
     ) + "\n",
     "utf-8"
   );
-  await writeFile4(
-    join4(codebyplanDir, "git.json"),
+  await writeFile5(
+    join5(codebyplanDir, "git.json"),
     JSON.stringify({ git_branch: null, branch_config: null }, null, 2) + "\n",
     "utf-8"
   );
-  await writeFile4(
-    join4(codebyplanDir, "shipment.json"),
+  await writeFile5(
+    join5(codebyplanDir, "shipment.json"),
     JSON.stringify({ shipment: null }, null, 2) + "\n",
     "utf-8"
   );
-  await writeFile4(
-    join4(codebyplanDir, "vendor.json"),
+  await writeFile5(
+    join5(codebyplanDir, "vendor.json"),
     JSON.stringify({}, null, 2) + "\n",
     "utf-8"
   );
+  const statuslinePath = join5(codebyplanDir, "statusline.json");
+  let statuslineExists = false;
+  try {
+    await readFile5(statuslinePath, "utf-8");
+    statuslineExists = true;
+  } catch {
+  }
+  if (!statuslineExists) {
+    await writeFile5(
+      statuslinePath,
+      JSON.stringify(STATUSLINE_DEFAULTS, null, 2) + "\n",
+      "utf-8"
+    );
+  }
   await writeLocalConfig(projectPath, { device_id: deviceId });
   console.log(`  Created ${codebyplanDir}/`);
   console.log(
-    `    repo.json, server.json, git.json, shipment.json, vendor.json`
+    `    repo.json, server.json, git.json, shipment.json, vendor.json, statusline.json`
   );
   console.log(`    device.local.json (gitignored)`);
-  const gitignorePath = join4(projectPath, ".gitignore");
+  const gitignorePath = join5(projectPath, ".gitignore");
   const gitignoreEntry = ".codebyplan/device.local.json";
+  const statuslineLocalEntry = ".codebyplan/statusline.local.json";
   try {
-    const existing = await readFile4(gitignorePath, "utf-8");
+    const existing = await readFile5(gitignorePath, "utf-8");
     const lines = existing.split("\n");
+    let content = existing;
     if (!lines.some((l) => l.trimEnd() === gitignoreEntry)) {
-      const appended = (existing.endsWith("\n") ? existing : existing + "\n") + gitignoreEntry + "\n";
-      await writeFile4(gitignorePath, appended, "utf-8");
+      content = (content.endsWith("\n") ? content : content + "\n") + gitignoreEntry + "\n";
       console.log(`  Added '${gitignoreEntry}' to .gitignore`);
     }
+    if (!lines.some((l) => l.trimEnd() === statuslineLocalEntry)) {
+      content = (content.endsWith("\n") ? content : content + "\n") + statuslineLocalEntry + "\n";
+      console.log(`  Added '${statuslineLocalEntry}' to .gitignore`);
+    }
+    if (content !== existing) {
+      await writeFile5(gitignorePath, content, "utf-8");
+    }
   } catch {
-    await writeFile4(gitignorePath, gitignoreEntry + "\n", "utf-8");
-    console.log(`  Created .gitignore with '${gitignoreEntry}'`);
+    await writeFile5(
+      gitignorePath,
+      gitignoreEntry + "\n" + statuslineLocalEntry + "\n",
+      "utf-8"
+    );
+    console.log(
+      `  Created .gitignore with '${gitignoreEntry}' and '${statuslineLocalEntry}'`
+    );
   }
 }
 async function runSetup() {
@@ -1118,6 +1334,31 @@ async function runSetup() {
     const _worktreeId = tupleId ?? pathBasedId;
     void _worktreeId;
     await writeCodebyplanDirectory(projectPath, selectedRepo, deviceId);
+    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."
     );
@@ -1132,6 +1373,7 @@ var init_setup = __esm({
   "src/cli/setup.ts"() {
     "use strict";
     init_local_config();
+    init_statusline_config();
     init_resolve_worktree();
     init_token_refresh();
     init_urls();
@@ -1139,6 +1381,190 @@ var init_setup = __esm({
   }
 });
 
+// src/lib/flags.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join6, resolve } from "node:path";
+async function findCodebyplanConfig(startDir, maxDepth = 20) {
+  let cursor = resolve(startDir);
+  for (let depth = 0; depth < maxDepth; depth++) {
+    const sentinelPath2 = join6(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 = join6(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;
+  }
+  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];
+    }
+  }
+  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`
+    );
+  }
+  return { repoId, worktreeId, projectPath };
+}
+var init_flags = __esm({
+  "src/lib/flags.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/statusline.ts
+var statusline_exports = {};
+__export(statusline_exports, {
+  runStatusline: () => runStatusline
+});
+import { dirname as dirname3 } from "node:path";
+async function resolveProjectPath() {
+  const found = await findCodebyplanConfig(process.cwd());
+  if (found) {
+    return dirname3(dirname3(found.path));
+  }
+  return process.cwd();
+}
+function parseRendererArg(arg) {
+  const normalised = arg.startsWith("--") ? arg.slice(2) : arg;
+  if (VALID_RENDERERS2.has(normalised)) {
+    return normalised;
+  }
+  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
+  );
+  if (rendererTokens.length > 1) {
+    process.stderr.write(
+      "codebyplan statusline: bash, node, and python are mutually exclusive; pass only one.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let rendererArg;
+  for (const a of [...positional, ...flagArgs]) {
+    const parsed = parseRendererArg(a);
+    if (parsed !== null) {
+      rendererArg = a;
+      break;
+    }
+  }
+  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;
+  }
+  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;
+  }
+  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();
+}
+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, {
@@ -1197,15 +1623,15 @@ var upgrade_auth_exports = {};
 __export(upgrade_auth_exports, {
   runUpgradeAuth: () => runUpgradeAuth
 });
-import { readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 function configPaths() {
-  return [join5(homedir3(), ".claude.json"), join5(process.cwd(), ".mcp.json")];
+  return [join7(homedir3(), ".claude.json"), join7(process.cwd(), ".mcp.json")];
 }
 async function readConfig2(path6) {
   try {
-    const raw = await readFile5(path6, "utf-8");
+    const raw = await readFile7(path6, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -1226,7 +1652,7 @@ async function rewriteConfig(path6, config, newUrl) {
   if (!entry) return false;
   if (!entryHasLegacyApiKey(entry) && entry.url === newUrl) return false;
   servers.codebyplan = { url: newUrl };
-  await writeFile5(path6, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile6(path6, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return true;
 }
 async function runUpgradeAuth() {
@@ -1263,77 +1689,6 @@ var init_upgrade_auth = __esm({
   }
 });
 
-// src/lib/flags.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { join as join6, resolve } from "node:path";
-async function findCodebyplanConfig(startDir, maxDepth = 20) {
-  let cursor = resolve(startDir);
-  for (let depth = 0; depth < maxDepth; depth++) {
-    const sentinelPath2 = join6(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 = join6(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;
-  }
-  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];
-    }
-  }
-  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`
-    );
-  }
-  return { repoId, worktreeId, projectPath };
-}
-var init_flags = __esm({
-  "src/lib/flags.ts"() {
-    "use strict";
-  }
-});
-
 // src/cli/confirm.ts
 var confirm_exports = {};
 __export(confirm_exports, {
@@ -1378,8 +1733,8 @@ var init_confirm = __esm({
 });
 
 // src/lib/tech-detect.ts
-import { readFile as readFile7, access, readdir } from "node:fs/promises";
-import { join as join7, relative } from "node:path";
+import { readFile as readFile8, access, readdir } from "node:fs/promises";
+import { join as join8, relative } from "node:path";
 async function fileExists(filePath) {
   try {
     await access(filePath);
@@ -1392,8 +1747,8 @@ async function discoverMonorepoApps(projectPath) {
   const apps = [];
   const patterns = [];
   try {
-    const raw = await readFile7(
-      join7(projectPath, "pnpm-workspace.yaml"),
+    const raw = await readFile8(
+      join8(projectPath, "pnpm-workspace.yaml"),
       "utf-8"
     );
     const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
@@ -1407,7 +1762,7 @@ async function discoverMonorepoApps(projectPath) {
   }
   if (patterns.length === 0) {
     try {
-      const raw = await readFile7(join7(projectPath, "package.json"), "utf-8");
+      const raw = await readFile8(join8(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);
@@ -1417,14 +1772,14 @@ async function discoverMonorepoApps(projectPath) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join7(projectPath, dir);
+      const absDir = join8(projectPath, dir);
       try {
         const entries = await readdir(absDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const relPath = join7(dir, entry.name);
-            const absPath = join7(absDir, entry.name);
-            if (await fileExists(join7(absPath, "package.json"))) {
+            const relPath = join8(dir, entry.name);
+            const absPath = join8(absDir, entry.name);
+            if (await fileExists(join8(absPath, "package.json"))) {
               apps.push({ name: entry.name, path: relPath, absPath });
             }
           }
@@ -1443,7 +1798,7 @@ async function hasJsxFile(dir, depth = 0) {
       const name = entry.name;
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
-        if (await hasJsxFile(join7(dir, name), depth + 1)) return true;
+        if (await hasJsxFile(join8(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;
@@ -1462,7 +1817,7 @@ async function hasJsxFile(dir, depth = 0) {
 async function detectCapabilities(dirPath, pkgJson) {
   const caps = /* @__PURE__ */ new Set();
   for (const sub of JSX_SCAN_DIRS) {
-    if (await hasJsxFile(join7(dirPath, sub))) {
+    if (await hasJsxFile(join8(dirPath, sub))) {
       caps.add("jsx");
       break;
     }
@@ -1484,7 +1839,7 @@ async function detectCapabilities(dirPath, pkgJson) {
       }
     }
   }
-  if (!caps.has("node-server") && await fileExists(join7(dirPath, "src", "main.ts"))) {
+  if (!caps.has("node-server") && await fileExists(join8(dirPath, "src", "main.ts"))) {
     caps.add("node-server");
   }
   if (pkgJson && pkgJson.bin) {
@@ -1500,7 +1855,7 @@ async function detectFromDirectory(dirPath) {
   const seen = /* @__PURE__ */ new Map();
   let pkgJson = null;
   try {
-    const raw = await readFile7(join7(dirPath, "package.json"), "utf-8");
+    const raw = await readFile8(join8(dirPath, "package.json"), "utf-8");
     pkgJson = JSON.parse(raw);
     const allDeps = {
       ...pkgJson.dependencies ?? {},
@@ -1532,7 +1887,7 @@ async function detectFromDirectory(dirPath) {
   }
   for (const { file, rule } of CONFIG_FILE_MAP) {
     const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join7(dirPath, file))) {
+    if (!seen.has(key) && await fileExists(join8(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
@@ -1710,7 +2065,7 @@ function categorizeDependency(depName) {
 async function findPackageJsonFiles(dir, projectPath, depth = 0) {
   if (depth > 4) return [];
   const results = [];
-  const pkgPath = join7(dir, "package.json");
+  const pkgPath = join8(dir, "package.json");
   if (await fileExists(pkgPath)) {
     results.push(pkgPath);
   }
@@ -1719,7 +2074,7 @@ async function findPackageJsonFiles(dir, projectPath, depth = 0) {
     for (const entry of entries) {
       if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
       const subResults = await findPackageJsonFiles(
-        join7(dir, entry.name),
+        join8(dir, entry.name),
         projectPath,
         depth + 1
       );
@@ -1734,7 +2089,7 @@ async function scanAllDependencies(projectPath) {
   const dependencies = [];
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile7(pkgPath, "utf-8");
+      const raw = await readFile8(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const sourcePath = relative(projectPath, pkgPath);
       const depSections = [
@@ -2334,8 +2689,8 @@ __export(eslint_exports, {
   eslintInit: () => eslintInit,
   runEslint: () => runEslint
 });
-import { readFile as readFile8, writeFile as writeFile6, access as access2, readdir as readdir2 } from "node:fs/promises";
-import { join as join8, relative as relative2 } from "node:path";
+import { readFile as readFile9, writeFile as writeFile7, access as access2, readdir as readdir2 } from "node:fs/promises";
+import { join as join9, relative as relative2 } from "node:path";
 async function fileExists2(filePath) {
   try {
     await access2(filePath);
@@ -2346,7 +2701,7 @@ async function fileExists2(filePath) {
 }
 async function autoDetectIgnorePatterns(absPath) {
   const patterns = [];
-  if (await fileExists2(join8(absPath, "esbuild.js"))) {
+  if (await fileExists2(join9(absPath, "esbuild.js"))) {
     patterns.push("esbuild.js");
   }
   let entries = [];
@@ -2366,19 +2721,19 @@ async function autoDetectIgnorePatterns(absPath) {
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vitest.config.${ext}`;
-    if (await fileExists2(join8(absPath, candidate))) {
+    if (await fileExists2(join9(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vite.config.${ext}`;
-    if (await fileExists2(join8(absPath, candidate))) {
+    if (await fileExists2(join9(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
-  if (await fileExists2(join8(absPath, "tauri.conf.json"))) {
+  if (await fileExists2(join9(absPath, "tauri.conf.json"))) {
     patterns.push("src-tauri/**");
     patterns.push("**/*.d.ts");
   }
@@ -2386,14 +2741,14 @@ async function autoDetectIgnorePatterns(absPath) {
 }
 function detectPackageManager(projectPath) {
   return (async () => {
-    if (await fileExists2(join8(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(join8(projectPath, "yarn.lock"))) return "yarn";
+    if (await fileExists2(join9(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(join9(projectPath, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
 async function getInstalledDeps(pkgJsonPath) {
   try {
-    const raw = await readFile8(pkgJsonPath, "utf-8");
+    const raw = await readFile9(pkgJsonPath, "utf-8");
     const pkg = JSON.parse(raw);
     const all = /* @__PURE__ */ new Set();
     for (const name of Object.keys(pkg.dependencies ?? {})) all.add(name);
@@ -2506,7 +2861,7 @@ async function eslintInit(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
-    const configPath = join8(target.absPath, "eslint.config.mjs");
+    const configPath = join9(target.absPath, "eslint.config.mjs");
     configsToWrite.push({
       target,
       presets,
@@ -2528,11 +2883,11 @@ async function eslintInit(repoId, projectPath) {
     return;
   }
   const pm = await detectPackageManager(projectPath);
-  const rootPkgJsonPath = join8(projectPath, "package.json");
+  const rootPkgJsonPath = join9(projectPath, "package.json");
   const installed = await getInstalledDeps(rootPkgJsonPath);
   if (isMonorepo) {
     for (const { target } of configsToWrite) {
-      const appPkgJson = join8(target.absPath, "package.json");
+      const appPkgJson = join9(target.absPath, "package.json");
       const appDeps = await getInstalledDeps(appPkgJson);
       for (const dep of appDeps) {
         installed.add(dep);
@@ -2584,7 +2939,7 @@ async function eslintInit(repoId, projectPath) {
   } of configsToWrite) {
     if (await fileExists2(configPath)) {
       try {
-        const existing = await readFile8(configPath, "utf-8");
+        const existing = await readFile9(configPath, "utf-8");
         const existingHash = hashConfig(existing);
         if (existingHash === hash) {
           console.log(
@@ -2604,7 +2959,7 @@ async function eslintInit(repoId, projectPath) {
       }
     }
     try {
-      await writeFile6(configPath, content, "utf-8");
+      await writeFile7(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${target.name}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -2912,7 +3267,7 @@ __export(round_exports, {
   runRoundSyncApprovals: () => runRoundSyncApprovals
 });
 import { access as access3 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { execSync as execSync2 } from "node:child_process";
 async function runRoundCommand(args) {
   const subcommand = args[0];
@@ -3006,7 +3361,7 @@ async function runRoundSyncApprovals(args) {
         "sync-approvals: git status failed; proceeding with empty diff\n"
       );
     }
-    const hookPath = join9(
+    const hookPath = join10(
       repoRoot,
       ".claude",
       "hooks",
@@ -3128,8 +3483,8 @@ var init_round = __esm({
 });
 
 // src/lib/migrate-branch-model.ts
-import { readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 function assertValidBranchName(branch) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -3139,7 +3494,7 @@ function assertValidBranchName(branch) {
   }
 }
 async function readJsonFile(filePath) {
-  const raw = await readFile9(filePath, "utf-8");
+  const raw = await readFile10(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`);
@@ -3208,12 +3563,12 @@ async function runBranchMigration(opts) {
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      configPath = join10(dir, "git.json");
+      configPath = join11(dir, "git.json");
     } else {
       configPath = found.path;
     }
   } else {
-    configPath = join10(cwd, ".codebyplan", "git.json");
+    configPath = join11(cwd, ".codebyplan", "git.json");
   }
   let fileRaw;
   let fileParsed;
@@ -3287,7 +3642,7 @@ async function runBranchMigration(opts) {
     const updatedParsed = { ...fileParsed, branch_config: after };
     const newJson = JSON.stringify(updatedParsed, null, 2) + "\n";
     if (newJson !== fileRaw) {
-      await writeFile7(configPath, newJson, "utf-8");
+      await writeFile8(configPath, newJson, "utf-8");
     }
   }
   return {
@@ -3393,9 +3748,9 @@ var init_branch = __esm({
 });
 
 // src/lib/ship.ts
-import { readFile as readFile10 } from "node:fs/promises";
-import { join as join11 } from "node:path";
-import { execSync as execSync4, spawnSync } from "node:child_process";
+import { readFile as readFile11 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+import { execSync as execSync4, spawnSync as spawnSync2 } from "node:child_process";
 function assertValidBranchName2(branch, label) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
     throw new Error(
@@ -3409,15 +3764,15 @@ async function readBaseBranch(cwd) {
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      gitJsonPath = join11(dir, "git.json");
+      gitJsonPath = join12(dir, "git.json");
     } else {
       gitJsonPath = found.path;
     }
   } else {
-    gitJsonPath = join11(cwd, ".codebyplan", "git.json");
+    gitJsonPath = join12(cwd, ".codebyplan", "git.json");
   }
   try {
-    const raw = await readFile10(gitJsonPath, "utf-8");
+    const raw = await readFile11(gitJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return "main";
@@ -3450,7 +3805,7 @@ async function pollChecks(feat, timeoutSeconds, cwd, _sleepMs = (ms) => new Prom
   let totalGhErrors = 0;
   let iteration = 0;
   while (Date.now() < deadline) {
-    const ghResult = spawnSync(
+    const ghResult = spawnSync2(
       "gh",
       ["pr", "checks", feat, "--json", "name,state,conclusion"],
       {
@@ -3616,7 +3971,7 @@ ${statusOut.trim()}`
     } else {
       createArgs.push("--body", defaultPrBody(feat, base));
     }
-    const createResult = spawnSync("gh", createArgs, {
+    const createResult = spawnSync2("gh", createArgs, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3646,7 +4001,7 @@ ${statusOut.trim()}`
   });
   let mergeCommit = null;
   try {
-    const prViewResult = spawnSync(
+    const prViewResult = spawnSync2(
       "gh",
       ["pr", "view", feat, "--json", "state,mergeCommit"],
       {
@@ -3806,85 +4161,167 @@ var init_ship2 = __esm({
 // src/cli/resolve-worktree.ts
 var resolve_worktree_exports = {};
 __export(resolve_worktree_exports, {
+  ProcessExitSignal: () => ProcessExitSignal,
   runResolveWorktree: () => runResolveWorktree
 });
 import { execSync as execSync5 } from "node:child_process";
+function distress(kind, message, jsonMode) {
+  if (jsonMode) return;
+  process.stderr.write(`resolve-worktree: ${kind}: ${message}
+`);
+}
 async function runResolveWorktree() {
+  const jsonMode = hasFlag("json", 3);
+  let errorContext = null;
+  const migrationNoticeCallback = (legacyPath, primaryPath) => {
+    if (!jsonMode) {
+      process.stderr.write(
+        `resolve-worktree: local_config_migration: ${legacyPath} is the legacy flat config; move device_id to ${primaryPath}
+`
+      );
+    }
+  };
   try {
     const projectPath = process.cwd();
     const found = await findCodebyplanConfig(projectPath);
     if (!found?.contents.repo_id) {
-      process.exit(0);
+      emitAndExit(null, null, jsonMode);
     }
     const repoId = found.contents.repo_id;
-    const deviceId = await getOrCreateDeviceId(projectPath);
+    try {
+      await readLocalConfig(projectPath);
+    } catch (readErr) {
+      const readErrCode = readErr.code;
+      errorContext = {
+        kind: readErrCode === "LEGACY_FILE_BLOCKS_DIR" ? "legacy_file_blocks_dir" : "local_config_read_failed",
+        message: readErr instanceof Error ? readErr.message : String(readErr)
+      };
+    }
+    let deviceId;
+    try {
+      deviceId = await getOrCreateDeviceId(
+        projectPath,
+        migrationNoticeCallback
+      );
+    } catch (deviceErr) {
+      const code = deviceErr.code;
+      if (code === "LEGACY_FILE_BLOCKS_DIR") {
+        errorContext = {
+          kind: "legacy_file_blocks_dir",
+          message: deviceErr instanceof Error ? deviceErr.message : String(deviceErr)
+        };
+      } else if (errorContext === null || errorContext.kind !== "local_config_read_failed" && errorContext.kind !== "legacy_file_blocks_dir") {
+        errorContext = {
+          kind: "local_config_write_failed",
+          message: deviceErr instanceof Error ? deviceErr.message : String(deviceErr)
+        };
+      }
+      emitAndExit(null, errorContext, jsonMode);
+    }
     let branch = "";
     try {
       branch = execSync5("git symbolic-ref --short HEAD", {
         cwd: projectPath,
         encoding: "utf-8"
       }).trim();
-    } catch {
+    } catch (gitErr) {
+      if (errorContext === null) {
+        errorContext = {
+          kind: "git_failed",
+          message: gitErr instanceof Error ? gitErr.message : String(gitErr)
+        };
+      }
     }
+    const onResolverError = (kind, err) => {
+      if (errorContext === null) {
+        errorContext = { kind, message: err.message };
+      }
+    };
     const worktreeId = await resolveWorktreeId({
       repoId,
       repoPath: projectPath,
       branch,
-      deviceId
+      deviceId,
+      onError: onResolverError
     });
     if (worktreeId) {
-      process.stdout.write(worktreeId);
-      process.exit(0);
+      emitAndExit(worktreeId, errorContext, jsonMode);
     }
     const useFallback = hasFlag("fallback-from-branch", 3);
     if (useFallback) {
       const fallbackId = await resolveWorktreeByBranch({
         repoId,
         deviceId,
-        branch
+        branch,
+        onError: onResolverError
       });
       if (fallbackId) {
-        process.stdout.write(fallbackId);
+        emitAndExit(fallbackId, errorContext, jsonMode);
       }
     }
-    process.exit(0);
+    emitAndExit(null, errorContext, jsonMode);
   } catch (err) {
-    if (process.env.CODEBYPLAN_DEBUG === "1") {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`resolve-worktree: ${msg}
-`);
+    if (err instanceof ProcessExitSignal) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    errorContext = { kind: "unhandled", message: msg };
+    emitAndExit(null, errorContext, jsonMode);
+  }
+}
+function emitAndExit(worktreeId, errorContext, jsonMode) {
+  if (jsonMode) {
+    const errorKind = errorContext?.kind ?? (worktreeId === null ? "tuple_miss" : null);
+    process.stdout.write(
+      JSON.stringify({ worktree_id: worktreeId, error_kind: errorKind }) + "\n"
+    );
+  } else {
+    if (worktreeId !== null) {
+      process.stdout.write(worktreeId);
+    }
+    if (errorContext !== null) {
+      if (errorContext.kind !== "unhandled" || process.env.CODEBYPLAN_DEBUG === "1") {
+        distress(errorContext.kind, errorContext.message, jsonMode);
+      }
     }
-    process.exit(0);
   }
+  process.exit(0);
 }
+var ProcessExitSignal;
 var init_resolve_worktree2 = __esm({
   "src/cli/resolve-worktree.ts"() {
     "use strict";
     init_flags();
     init_local_config();
     init_resolve_worktree();
+    ProcessExitSignal = class extends Error {
+      code;
+      constructor(code) {
+        super(`process.exit(${code})`);
+        this.name = "ProcessExitSignal";
+        this.code = code;
+      }
+    };
   }
 });
 
 // src/lib/migrate-local-config.ts
-import { mkdir as mkdir4, readFile as readFile11, unlink as unlink2, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile12, unlink as unlink2, writeFile as writeFile9 } from "node:fs/promises";
+import { join as join13 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join12(projectPath, ".codebyplan.json");
+  return join13(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join12(projectPath, ".codebyplan.local.json");
+  return join13(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join12(projectPath, ".codebyplan");
+  return join13(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join12(projectPath, ".codebyplan", "repo.json");
+  return join13(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
-  const { stat } = await import("node:fs/promises");
+  const { stat: stat2 } = await import("node:fs/promises");
   try {
-    return await stat(p);
+    return await stat2(p);
   } catch {
     return null;
   }
@@ -3918,7 +4355,7 @@ async function runLocalMigration(projectPath) {
   }
   let legacyRaw;
   try {
-    legacyRaw = await readFile11(legacySharedPath(projectPath), "utf-8");
+    legacyRaw = await readFile12(legacySharedPath(projectPath), "utf-8");
   } catch {
     return {
       migrated: true,
@@ -3945,7 +4382,7 @@ async function runLocalMigration(projectPath) {
   let deviceId;
   let deviceWrittenByHelper = false;
   try {
-    const localRaw = await readFile11(legacyLocalPath(projectPath), "utf-8");
+    const localRaw = await readFile12(legacyLocalPath(projectPath), "utf-8");
     const localParsed = JSON.parse(localRaw);
     if (typeof localParsed.device_id === "string") {
       deviceId = localParsed.device_id;
@@ -3953,7 +4390,7 @@ async function runLocalMigration(projectPath) {
   } catch {
   }
   try {
-    await mkdir4(newDirPath(projectPath), { recursive: true });
+    await mkdir5(newDirPath(projectPath), { recursive: true });
   } catch (err) {
     const code = err.code;
     if (code === "ENOTDIR" || code === "EEXIST") {
@@ -3972,8 +4409,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 writeFile8(
-    join12(projectPath, ".codebyplan", "repo.json"),
+  await writeFile9(
+    join13(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -3985,8 +4422,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 writeFile8(
-    join12(projectPath, ".codebyplan", "server.json"),
+  await writeFile9(
+    join13(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -3994,30 +4431,30 @@ 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 writeFile8(
-    join12(projectPath, ".codebyplan", "git.json"),
+  await writeFile9(
+    join13(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 writeFile8(
-    join12(projectPath, ".codebyplan", "shipment.json"),
+  await writeFile9(
+    join13(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
-  await writeFile8(
-    join12(projectPath, ".codebyplan", "vendor.json"),
+  await writeFile9(
+    join13(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   if (!deviceWrittenByHelper) {
-    await writeFile8(
-      join12(projectPath, ".codebyplan", "device.local.json"),
+    await writeFile9(
+      join13(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -4029,9 +4466,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 = join12(projectPath, ".gitignore");
+  const gitignorePath = join13(projectPath, ".gitignore");
   try {
-    const gitignoreContent = await readFile11(gitignorePath, "utf-8");
+    const gitignoreContent = await readFile12(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
     const newLine = ".codebyplan/device.local.json";
     const hasLegacy = gitignoreContent.split("\n").some((l) => l.trimEnd() === legacyLine);
@@ -4050,7 +4487,7 @@ async function runLocalMigration(projectPath) {
       updated = gitignoreContent;
     }
     if (updated !== gitignoreContent) {
-      await writeFile8(gitignorePath, updated, "utf-8");
+      await writeFile9(gitignorePath, updated, "utf-8");
       filesChanged.push(".gitignore");
     }
   } catch {
@@ -4089,8 +4526,8 @@ __export(config_exports, {
   readVendorConfig: () => readVendorConfig,
   runConfig: () => runConfig
 });
-import { mkdir as mkdir5, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { mkdir as mkdir6, readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -4123,7 +4560,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join13(projectPath, ".codebyplan");
+  const codebyplanDir = join14(projectPath, ".codebyplan");
   let resolvedWorktreeId;
   try {
     const deviceId = await getOrCreateDeviceId(projectPath);
@@ -4252,7 +4689,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
     console.log("  Config would be updated (dry-run).");
     return;
   }
-  await mkdir5(codebyplanDir, { recursive: true });
+  await mkdir6(codebyplanDir, { recursive: true });
   const files = [
     { name: "repo.json", payload: repoPayload },
     { name: "server.json", payload: serverPayload },
@@ -4262,15 +4699,15 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   ];
   let anyUpdated = false;
   for (const { name, payload } of files) {
-    const filePath = join13(codebyplanDir, name);
+    const filePath = join14(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
-      currentJson = await readFile12(filePath, "utf-8");
+      currentJson = await readFile13(filePath, "utf-8");
     } catch {
     }
     if (currentJson === newJson) continue;
-    await writeFile9(filePath, newJson, "utf-8");
+    await writeFile10(filePath, newJson, "utf-8");
     console.log(`  Updated .codebyplan/${name}`);
     anyUpdated = true;
   }
@@ -4280,8 +4717,8 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 }
 async function readRepoConfig(projectPath) {
   try {
-    const raw = await readFile12(
-      join13(projectPath, ".codebyplan", "repo.json"),
+    const raw = await readFile13(
+      join14(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -4291,8 +4728,8 @@ async function readRepoConfig(projectPath) {
 }
 async function readServerConfig(projectPath) {
   try {
-    const raw = await readFile12(
-      join13(projectPath, ".codebyplan", "server.json"),
+    const raw = await readFile13(
+      join14(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -4302,8 +4739,8 @@ async function readServerConfig(projectPath) {
 }
 async function readGitConfig(projectPath) {
   try {
-    const raw = await readFile12(
-      join13(projectPath, ".codebyplan", "git.json"),
+    const raw = await readFile13(
+      join14(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -4313,8 +4750,8 @@ async function readGitConfig(projectPath) {
 }
 async function readShipmentConfig(projectPath) {
   try {
-    const raw = await readFile12(
-      join13(projectPath, ".codebyplan", "shipment.json"),
+    const raw = await readFile13(
+      join14(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -4324,8 +4761,8 @@ async function readShipmentConfig(projectPath) {
 }
 async function readVendorConfig(projectPath) {
   try {
-    const raw = await readFile12(
-      join13(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile13(
+      join14(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -4381,14 +4818,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } 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 readFile13(pkgPath, "utf-8");
+      const raw = await readFile14(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -4451,7 +4888,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile13(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile14(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -5253,6 +5690,11 @@ 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;
   }
@@ -5329,6 +5771,9 @@ async function runInstall(opts, deps = {}) {
     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 });
+    }
   } catch (err) {
     console.error(
       `codebyplan claude install failed: ${err instanceof Error ? err.message : String(err)}`
@@ -5414,6 +5859,7 @@ var init_install = __esm({
     init_template_walker();
     init_manifest();
     init_settings_merge();
+    init_statusline_config();
   }
 });
 
@@ -5541,6 +5987,11 @@ async function runUpdate(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
   if (scope === "user") {
+    if (opts.renderer) {
+      console.warn(
+        "codebyplan claude update: --bash/--node/--python is ignored for --scope user (no project root for statusline.local.json)."
+      );
+    }
     runUpdateUser(opts, deps);
     return;
   }
@@ -5685,6 +6136,9 @@ async function runUpdate(opts, deps = {}) {
     console.log(
       `codebyplan claude update${opts.dryRun ? " (dry-run)" : ""}: ${finalManifestEntries.length} files tracked.`
     );
+    if (opts.renderer && !opts.dryRun) {
+      await writeStatuslineLocalConfig(projectDir, { renderer: opts.renderer });
+    }
   } catch (err) {
     console.error(
       `codebyplan claude update failed: ${err instanceof Error ? err.message : String(err)}`
@@ -5831,6 +6285,7 @@ var init_update = __esm({
     init_manifest();
     init_settings_merge();
     init_prompt();
+    init_statusline_config();
   }
 });
 
@@ -6010,8 +6465,8 @@ function pruneEmptyManagedDirs(projectDir) {
 }
 function pruneLeafFirst(dir) {
   if (!fs5.existsSync(dir)) return;
-  const stat = fs5.statSync(dir);
-  if (!stat.isDirectory()) return;
+  const stat2 = fs5.statSync(dir);
+  if (!stat2.isDirectory()) return;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       pruneLeafFirst(path5.join(dir, entry.name));
@@ -6068,6 +6523,12 @@ void (async () => {
     await runSetup2();
     process.exit(0);
   }
+  if (arg === "statusline") {
+    const { runStatusline: runStatusline2 } = await Promise.resolve().then(() => (init_statusline(), statusline_exports));
+    const rest = process.argv.slice(3);
+    await runStatusline2(rest);
+    process.exit(process.exitCode ?? 0);
+  }
   if (arg === "login") {
     const { runLogin: runLogin2 } = await Promise.resolve().then(() => (init_login(), login_exports));
     try {
@@ -6203,6 +6664,9 @@ void (async () => {
                               user    \u2014 writes only owned base settings into ~/.claude/settings.json;
                                         never copies templates or hooks
     --project-dir <path>    Override the project root (default: cwd). Cannot be combined with --scope user.
+    --bash                  Set statusline renderer to bash after install/update
+    --node                  Set statusline renderer to node after install/update
+    --python                Set statusline renderer to python after install/update
 `);
     process.exit(0);
   }
@@ -6225,6 +6689,7 @@ void (async () => {
     codebyplan ship                  Ship current feat branch to production via PR
     codebyplan branch migrate        Rewrite branch_config from 3-branch to 2-tier model
     codebyplan claude                Claude asset management (install/update/uninstall)
+    codebyplan statusline            Show or set the statusline renderer (bash/node/python)
     codebyplan resolve-worktree      Resolve active worktree UUID from device+path+branch tuple
     codebyplan help                  Show this help message
     codebyplan --version             Print version
@@ -6259,6 +6724,9 @@ void (async () => {
       --verbose               Log every file operation
       --scope <user|project>  Target scope (default: project)
       --project-dir <path>    Override the project root (default: cwd)
+      --bash                  Set statusline renderer to bash after install/update
+      --node                  Set statusline renderer to node after install/update
+      --python                Set statusline renderer to python after install/update
 
   MCP Server:
     Claude Code connects to CodeByPlan via remote MCP:
@@ -6309,8 +6777,19 @@ function parseClaudeFlags(rest) {
     );
     return null;
   }
+  const hasBash = rest.includes("--bash");
+  const hasNode = rest.includes("--node");
+  const hasPython = rest.includes("--python");
+  const rendererCount = [hasBash, hasNode, hasPython].filter(Boolean).length;
+  if (rendererCount > 1) {
+    process.stderr.write(
+      "error: --bash, --node, and --python are mutually exclusive; pass only one.\n"
+    );
+    return null;
+  }
+  const renderer = hasBash ? "bash" : hasNode ? "node" : hasPython ? "python" : void 0;
   return {
-    opts: { yes, dryRun, verbose, scope },
+    opts: { yes, dryRun, verbose, scope, renderer },
     projectDir
   };
 }