codebyplan 1.4.2 → 1.5.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.4.2";
+    VERSION = "1.5.0";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -143,6 +143,159 @@ var init_api = __esm({
   }
 });
 
+// src/lib/resolve-worktree.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function resolveAndCacheWorktreeId(repoId, projectPath, options) {
+  let worktreeId;
+  try {
+    const worktreesRes = await apiGet(`/worktrees?repo_id=${repoId}`);
+    const match = worktreesRes.data.find((wt) => {
+      const wtPath = wt.path.endsWith("/") ? wt.path.slice(0, -1) : wt.path;
+      return projectPath === wtPath || projectPath.startsWith(wtPath + "/");
+    });
+    if (match) worktreeId = match.id;
+  } catch (err) {
+    console.error(
+      `Worktree lookup failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return void 0;
+  }
+  if (!worktreeId) {
+    return void 0;
+  }
+  if (options?.skipWrite) {
+    return worktreeId;
+  }
+  const codebyplanPath = join(projectPath, ".codebyplan.json");
+  let currentConfig = {};
+  try {
+    const raw = await readFile(codebyplanPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      currentConfig = parsed;
+    }
+  } catch {
+  }
+  if (currentConfig.worktree_id === worktreeId) {
+    return worktreeId;
+  }
+  const merged = {
+    ...currentConfig,
+    worktree_id: worktreeId
+  };
+  try {
+    await writeFile(
+      codebyplanPath,
+      JSON.stringify(merged, null, 2) + "\n",
+      "utf-8"
+    );
+  } catch (err) {
+    console.error(
+      `Failed to cache worktree_id in ${codebyplanPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    throw err;
+  }
+  return worktreeId;
+}
+async function resolveWorktreeId({
+  repoId,
+  repoPath,
+  branch,
+  deviceId
+}) {
+  try {
+    const res = await apiPost(
+      "/worktrees/resolve",
+      { repo_id: repoId, device_id: deviceId, repo_path: repoPath, branch }
+    );
+    return res.worktree_id ?? null;
+  } catch (err) {
+    console.error(
+      `Tuple worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+var init_resolve_worktree = __esm({
+  "src/lib/resolve-worktree.ts"() {
+    "use strict";
+    init_api();
+  }
+});
+
+// src/lib/local-config.ts
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join as join2 } from "node:path";
+function localConfigPath(projectPath) {
+  return join2(projectPath, ".codebyplan.local.json");
+}
+async function readLocalConfig(projectPath) {
+  try {
+    const raw = await readFile2(localConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.device_id === "string") {
+      return parsed;
+    }
+    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)}`
+    );
+    return null;
+  }
+}
+async function writeLocalConfig(projectPath, config) {
+  const content = { device_id: config.device_id };
+  try {
+    await writeFile2(
+      localConfigPath(projectPath),
+      JSON.stringify(content, null, 2) + "\n",
+      "utf-8"
+    );
+  } catch (err) {
+    console.error(
+      `Failed to write local config: ${err instanceof Error ? err.message : String(err)}`
+    );
+    throw err;
+  }
+}
+async function resolveMachineSeed() {
+  try {
+    const raw = await readFile2("/etc/machine-id", "utf-8");
+    const trimmed = raw.trim();
+    if (trimmed) return trimmed;
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    try {
+      const out = execSync("sysctl -n kern.uuid", { encoding: "utf-8" }).trim();
+      if (out) return out;
+    } catch {
+    }
+  }
+  return hostname();
+}
+async function getOrCreateDeviceId(projectPath) {
+  const existing = await readLocalConfig(projectPath);
+  if (existing?.device_id) {
+    return existing.device_id;
+  }
+  const seed = await resolveMachineSeed();
+  const deviceId = createHash("sha256").update(seed).digest("hex").slice(0, 16);
+  await writeLocalConfig(projectPath, { device_id: deviceId });
+  return deviceId;
+}
+var init_local_config = __esm({
+  "src/lib/local-config.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/settings-merge.ts
 function mergeSettings(template, local) {
   const merged = { ...local };
@@ -208,8 +361,8 @@ var init_settings_merge = __esm({
 });
 
 // src/lib/hook-registry.ts
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { readdir, readFile as readFile3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
 function parseHookMeta(content) {
   const lineMatch = content.match(/^#\s*@hook:(.*)$/m);
   if (!lineMatch) return null;
@@ -231,7 +384,7 @@ async function discoverHooks(hooksDir) {
     return discovered;
   }
   for (const filename of filenames) {
-    const content = await readFile(join(hooksDir, filename), "utf-8");
+    const content = await readFile3(join3(hooksDir, filename), "utf-8");
     const meta = parseHookMeta(content);
     if (meta) {
       discovered.set(filename.replace(/\.sh$/, ""), meta);
@@ -378,45 +531,45 @@ __export(sync_engine_exports, {
 });
 import {
   readdir as readdir2,
-  readFile as readFile2,
-  writeFile,
+  readFile as readFile4,
+  writeFile as writeFile3,
   unlink,
   mkdir,
   rmdir,
   chmod,
   stat
 } from "node:fs/promises";
-import { join as join2, dirname } from "node:path";
+import { join as join4, dirname } from "node:path";
 function getTypeDir(claudeDir, dir) {
-  if (dir === "commands") return join2(claudeDir, dir, "cbp");
-  return join2(claudeDir, dir);
+  if (dir === "commands") return join4(claudeDir, dir, "cbp");
+  return join4(claudeDir, dir);
 }
 function getFilePath(claudeDir, typeName, file) {
   const cfg = typeConfig[typeName];
   const typeDir = getTypeDir(claudeDir, cfg.dir);
   if (cfg.subfolder) {
-    return join2(typeDir, file.name, `${cfg.subfolder}${cfg.ext}`);
+    return join4(typeDir, file.name, `${cfg.subfolder}${cfg.ext}`);
   }
   if (typeName === "command" && file.category) {
-    return join2(typeDir, file.category, `${file.name}${cfg.ext}`);
+    return join4(typeDir, file.category, `${file.name}${cfg.ext}`);
   }
   if (typeName === "template") {
-    return join2(typeDir, file.name);
+    return join4(typeDir, file.name);
   }
-  return join2(typeDir, `${file.name}${cfg.ext}`);
+  return join4(typeDir, `${file.name}${cfg.ext}`);
 }
 async function readDirRecursive(dir, base = dir) {
   const result = /* @__PURE__ */ new Map();
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join2(dir, entry.name);
+      const fullPath = join4(dir, entry.name);
       if (entry.isDirectory()) {
         const sub = await readDirRecursive(fullPath, base);
         for (const [k, v] of sub) result.set(k, v);
       } else {
         const relPath = fullPath.slice(base.length + 1);
-        const fileContent = await readFile2(fullPath, "utf-8");
+        const fileContent = await readFile4(fullPath, "utf-8");
         result.set(relPath, fileContent);
       }
     }
@@ -426,7 +579,7 @@ async function readDirRecursive(dir, base = dir) {
 }
 async function isGitWorktree(projectPath) {
   try {
-    const gitPath = join2(projectPath, ".git");
+    const gitPath = join4(projectPath, ".git");
     const info = await stat(gitPath);
     return info.isFile();
   } catch {
@@ -453,7 +606,7 @@ async function executeSyncToLocal(options) {
   const syncData = syncRes.data;
   const repoData = repoRes.data;
   syncData.claude_md = [];
-  const claudeDir = join2(projectPath, ".claude");
+  const claudeDir = join4(projectPath, ".claude");
   const worktree = await isGitWorktree(projectPath);
   const byType = {};
   const totals = { created: 0, updated: 0, deleted: 0, unchanged: 0 };
@@ -489,7 +642,7 @@ async function executeSyncToLocal(options) {
       remotePathMap.set(relPath, { content: substituted, name: remote.name });
     }
     for (const [relPath, { content, name }] of remotePathMap) {
-      const fullPath = join2(targetDir, relPath);
+      const fullPath = join4(targetDir, relPath);
       const localContent = localFiles.get(relPath);
       if (localContent === void 0) {
         const remoteFile = remoteFiles.find((f) => f.name === name);
@@ -501,14 +654,14 @@ async function executeSyncToLocal(options) {
         });
         if (!dryRun) {
           await mkdir(dirname(fullPath), { recursive: true });
-          await writeFile(fullPath, content, "utf-8");
+          await writeFile3(fullPath, content, "utf-8");
           if (typeName === "hook") await chmod(fullPath, 493);
         }
         result.created.push(name);
         totals.created++;
       } else if (localContent !== content) {
         if (!dryRun) {
-          await writeFile(fullPath, content, "utf-8");
+          await writeFile3(fullPath, content, "utf-8");
           if (typeName === "hook") await chmod(fullPath, 493);
         }
         result.updated.push(name);
@@ -520,7 +673,7 @@ async function executeSyncToLocal(options) {
     }
     for (const [relPath] of localFiles) {
       if (!remotePathMap.has(relPath)) {
-        const fullPath = join2(targetDir, relPath);
+        const fullPath = join4(targetDir, relPath);
         if (!dryRun) {
           await unlink(fullPath);
           await removeEmptyParents(fullPath, targetDir);
@@ -535,7 +688,7 @@ async function executeSyncToLocal(options) {
   {
     const typeName = "docs_stack";
     const syncKey = "docs_stack";
-    const targetDir = join2(projectPath, "docs", "stack");
+    const targetDir = join4(projectPath, "docs", "stack");
     const remoteFiles = syncData[syncKey] ?? [];
     const result = {
       created: [],
@@ -549,7 +702,7 @@ async function executeSyncToLocal(options) {
     const localFiles = await readDirRecursive(targetDir);
     const remotePathMap = /* @__PURE__ */ new Map();
     for (const remote of remoteFiles) {
-      const relPath = remote.category ? join2(remote.category, remote.name) : remote.name;
+      const relPath = remote.category ? join4(remote.category, remote.name) : remote.name;
       const substituted = substituteVariables(remote.content, repoData);
       remotePathMap.set(relPath, {
         content: substituted,
@@ -557,18 +710,18 @@ async function executeSyncToLocal(options) {
       });
     }
     for (const [relPath, { content, name }] of remotePathMap) {
-      const fullPath = join2(targetDir, relPath);
+      const fullPath = join4(targetDir, relPath);
       const localContent = localFiles.get(relPath);
       if (localContent === void 0) {
         if (!dryRun) {
           await mkdir(dirname(fullPath), { recursive: true });
-          await writeFile(fullPath, content, "utf-8");
+          await writeFile3(fullPath, content, "utf-8");
         }
         result.created.push(name);
         totals.created++;
       } else if (localContent !== content) {
         if (!dryRun) {
-          await writeFile(fullPath, content, "utf-8");
+          await writeFile3(fullPath, content, "utf-8");
         }
         result.updated.push(name);
         totals.updated++;
@@ -579,7 +732,7 @@ async function executeSyncToLocal(options) {
     }
     for (const [relPath] of localFiles) {
       if (!remotePathMap.has(relPath)) {
-        const fullPath = join2(targetDir, relPath);
+        const fullPath = join4(targetDir, relPath);
         if (!dryRun) {
           await unlink(fullPath);
           await removeEmptyParents(fullPath, targetDir);
@@ -599,8 +752,8 @@ async function executeSyncToLocal(options) {
     globalSettings = { ...globalSettings, ...parsed };
   }
   const specialTypes = {
-    claude_md: () => join2(projectPath, "CLAUDE.md"),
-    settings: () => join2(projectPath, ".claude", "settings.json")
+    claude_md: () => join4(projectPath, "CLAUDE.md"),
+    settings: () => join4(projectPath, ".claude", "settings.json")
   };
   for (const [typeName, getPath] of Object.entries(specialTypes)) {
     const remoteFiles = syncData[typeName] ?? [];
@@ -615,7 +768,7 @@ async function executeSyncToLocal(options) {
       const remoteContent = substituteVariables(remote.content, repoData);
       let localContent;
       try {
-        localContent = await readFile2(targetPath, "utf-8");
+        localContent = await readFile4(targetPath, "utf-8");
       } catch {
       }
       if (typeName === "settings") {
@@ -624,7 +777,7 @@ async function executeSyncToLocal(options) {
           globalSettings,
           repoSettings
         );
-        const hooksDir = join2(projectPath, ".claude", "hooks");
+        const hooksDir = join4(projectPath, ".claude", "hooks");
         const discovered = await discoverHooks(hooksDir);
         if (localContent === void 0) {
           const finalSettings = stripPermissionsAllow(combinedTemplate);
@@ -636,7 +789,7 @@ async function executeSyncToLocal(options) {
           }
           if (!dryRun) {
             await mkdir(dirname(targetPath), { recursive: true });
-            await writeFile(
+            await writeFile3(
               targetPath,
               JSON.stringify(finalSettings, null, 2) + "\n",
               "utf-8"
@@ -657,7 +810,7 @@ async function executeSyncToLocal(options) {
           const mergedContent = JSON.stringify(merged, null, 2) + "\n";
           if (localContent !== mergedContent) {
             if (!dryRun) {
-              await writeFile(targetPath, mergedContent, "utf-8");
+              await writeFile3(targetPath, mergedContent, "utf-8");
             }
             result.updated.push(remote.name);
             totals.updated++;
@@ -670,13 +823,13 @@ async function executeSyncToLocal(options) {
         if (localContent === void 0) {
           if (!dryRun) {
             await mkdir(dirname(targetPath), { recursive: true });
-            await writeFile(targetPath, remoteContent, "utf-8");
+            await writeFile3(targetPath, remoteContent, "utf-8");
           }
           result.created.push(remote.name);
           totals.created++;
         } else if (localContent !== remoteContent) {
           if (!dryRun) {
-            await writeFile(targetPath, remoteContent, "utf-8");
+            await writeFile3(targetPath, remoteContent, "utf-8");
           }
           result.updated.push(remote.name);
           totals.updated++;
@@ -777,15 +930,15 @@ __export(setup_exports, {
 });
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 function getConfigPath(scope) {
-  return scope === "user" ? join3(homedir(), ".claude.json") : join3(process.cwd(), ".mcp.json");
+  return scope === "user" ? join5(homedir(), ".claude.json") : join5(process.cwd(), ".mcp.json");
 }
 async function readConfig(path) {
   try {
-    const raw = await readFile3(path, "utf-8");
+    const raw = await readFile5(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -809,7 +962,7 @@ async function writeMcpConfig(scope, apiKey) {
     config.mcpServers = {};
   }
   config.mcpServers.codebyplan = buildMcpEntry(apiKey);
-  await writeFile2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return configPath;
 }
 async function verifyMcpConfig(scope, apiKey) {
@@ -913,27 +1066,45 @@ async function runSetup() {
           console.log(`
   Selected: ${selectedRepo.name}
 `);
-          let worktreeId;
           const projectPath = process.cwd();
+          const pathBasedId = await resolveAndCacheWorktreeId(
+            selectedRepo.id,
+            projectPath,
+            { skipWrite: true }
+          );
+          const deviceId = await getOrCreateDeviceId(projectPath);
+          let branch = "main";
           try {
-            const worktreesRes = await apiGet(`/worktrees?repo_id=${selectedRepo.id}`);
-            const match = worktreesRes.data.find(
-              (wt) => projectPath === wt.path || projectPath.startsWith(wt.path + "/")
-            );
-            if (match) worktreeId = match.id;
+            const { execSync: execSync3 } = await import("node:child_process");
+            branch = execSync3("git symbolic-ref --short HEAD", {
+              cwd: projectPath,
+              encoding: "utf-8"
+            }).trim();
           } catch {
           }
-          const codebyplanPath = join3(projectPath, ".codebyplan.json");
+          const tupleId = await resolveWorktreeId({
+            repoId: selectedRepo.id,
+            repoPath: projectPath,
+            branch,
+            deviceId
+          });
+          const worktreeId = tupleId ?? pathBasedId;
+          const codebyplanPath = join5(projectPath, ".codebyplan.json");
           const codebyplanConfig = {
             repo_id: selectedRepo.id
           };
           if (worktreeId) codebyplanConfig.worktree_id = worktreeId;
-          await writeFile2(
+          await writeFile4(
             codebyplanPath,
             JSON.stringify(codebyplanConfig, null, 2) + "\n",
             "utf-8"
           );
           console.log(`  Created ${codebyplanPath}`);
+          if (worktreeId) {
+            console.log(
+              `  Worktree id set (${worktreeId}) \u2014 this worktree is now identified for hard-lock enforcement.`
+            );
+          }
           console.log("\n  Running initial sync...\n");
           try {
             const { executeSyncToLocal: executeSyncToLocal2 } = await Promise.resolve().then(() => (init_sync_engine(), sync_engine_exports));
@@ -968,19 +1139,20 @@ async function runSetup() {
 var init_setup = __esm({
   "src/cli/setup.ts"() {
     "use strict";
-    init_api();
+    init_resolve_worktree();
+    init_local_config();
   }
 });
 
 // src/cli/config.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join4, resolve } from "node:path";
+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 configPath = join4(cursor, ".codebyplan.json");
+    const configPath = join6(cursor, ".codebyplan.json");
     try {
-      const raw = await readFile4(configPath, "utf-8");
+      const raw = await readFile6(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       return { path: configPath, contents: parsed };
     } catch {
@@ -1031,8 +1203,8 @@ var init_config = __esm({
 });
 
 // src/cli/fileMapper.ts
-import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
-import { join as join5, extname } from "node:path";
+import { readdir as readdir3, readFile as readFile7 } from "node:fs/promises";
+import { join as join7, extname } from "node:path";
 function extractScope(content, type) {
   if (type === "hook") {
     const match = content.match(/^#\s*@scope:\s*(\S+)/m);
@@ -1062,29 +1234,29 @@ function compositeKey(type, name, category) {
 }
 async function scanLocalFiles(claudeDir, projectPath) {
   const result = /* @__PURE__ */ new Map();
-  await scanCommands(join5(claudeDir, "commands", "cbp"), result);
+  await scanCommands(join7(claudeDir, "commands", "cbp"), result);
   await scanSubfolderType(
-    join5(claudeDir, "agents"),
+    join7(claudeDir, "agents"),
     "agent",
     "AGENT.md",
     result
   );
   await scanSubfolderType(
-    join5(claudeDir, "skills"),
+    join7(claudeDir, "skills"),
     "skill",
     "SKILL.md",
     result
   );
-  await scanFlatType(join5(claudeDir, "rules"), "rule", ".md", result);
-  await scanFlatType(join5(claudeDir, "hooks"), "hook", ".sh", result);
-  await scanTemplates(join5(claudeDir, "templates"), result);
+  await scanFlatType(join7(claudeDir, "rules"), "rule", ".md", result);
+  await scanFlatType(join7(claudeDir, "hooks"), "hook", ".sh", result);
+  await scanTemplates(join7(claudeDir, "templates"), result);
   await scanCategorizedType(
-    join5(claudeDir, "context"),
+    join7(claudeDir, "context"),
     "context",
     ".md",
     result
   );
-  await scanDocsRecursive(join5(claudeDir, "docs"), result);
+  await scanDocsRecursive(join7(claudeDir, "docs"), result);
   await scanSettings(claudeDir, projectPath, result);
   return result;
 }
@@ -1102,12 +1274,12 @@ async function scanCommandsRecursive(baseDir, currentDir, result) {
     if (entry.isDirectory()) {
       await scanCommandsRecursive(
         baseDir,
-        join5(currentDir, entry.name),
+        join7(currentDir, entry.name),
         result
       );
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
       const name = entry.name.slice(0, -3);
-      const content = await readFile5(join5(currentDir, entry.name), "utf-8");
+      const content = await readFile7(join7(currentDir, entry.name), "utf-8");
       const relDir = currentDir.slice(baseDir.length + 1);
       const category = relDir || null;
       const scope = extractScope(content, "command");
@@ -1125,9 +1297,9 @@ async function scanSubfolderType(dir, type, fileName, result) {
   }
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const filePath = join5(dir, entry.name, fileName);
+      const filePath = join7(dir, entry.name, fileName);
       try {
-        const content = await readFile5(filePath, "utf-8");
+        const content = await readFile7(filePath, "utf-8");
         const scope = extractScope(content, type);
         const key = compositeKey(type, entry.name, null);
         result.set(key, {
@@ -1152,7 +1324,7 @@ async function scanFlatType(dir, type, ext, result) {
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(ext)) {
       const name = entry.name.slice(0, -ext.length);
-      const content = await readFile5(join5(dir, entry.name), "utf-8");
+      const content = await readFile7(join7(dir, entry.name), "utf-8");
       const scope = extractScope(content, type);
       const key = compositeKey(type, name, null);
       result.set(key, { type, name, category: null, content, scope });
@@ -1171,7 +1343,7 @@ async function scanCategorizedType(dir, type, ext, result) {
       const category = entry.name;
       let subEntries;
       try {
-        subEntries = await readdir3(join5(dir, category), {
+        subEntries = await readdir3(join7(dir, category), {
           withFileTypes: true
         });
       } catch {
@@ -1180,8 +1352,8 @@ async function scanCategorizedType(dir, type, ext, result) {
       for (const sub of subEntries) {
         if (sub.isFile() && sub.name.endsWith(ext)) {
           const name = sub.name.slice(0, -ext.length);
-          const content = await readFile5(
-            join5(dir, category, sub.name),
+          const content = await readFile7(
+            join7(dir, category, sub.name),
             "utf-8"
           );
           const scope = extractScope(content, type);
@@ -1191,7 +1363,7 @@ async function scanCategorizedType(dir, type, ext, result) {
       }
     } else if (entry.isFile() && entry.name.endsWith(ext)) {
       const name = entry.name.slice(0, -ext.length);
-      const content = await readFile5(join5(dir, entry.name), "utf-8");
+      const content = await readFile7(join7(dir, entry.name), "utf-8");
       const scope = extractScope(content, type);
       const key = compositeKey(type, name, null);
       result.set(key, { type, name, category: null, content, scope });
@@ -1210,10 +1382,10 @@ async function scanDocsDir(baseDir, currentDir, result) {
   }
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      await scanDocsDir(baseDir, join5(currentDir, entry.name), result);
+      await scanDocsDir(baseDir, join7(currentDir, entry.name), result);
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
       const name = entry.name.slice(0, -3);
-      const content = await readFile5(join5(currentDir, entry.name), "utf-8");
+      const content = await readFile7(join7(currentDir, entry.name), "utf-8");
       const scope = extractScope(content, "docs");
       const relDir = currentDir.slice(baseDir.length + 1);
       const category = relDir || null;
@@ -1231,7 +1403,7 @@ async function scanTemplates(dir, result) {
   }
   for (const entry of entries) {
     if (entry.isFile() && extname(entry.name)) {
-      const content = await readFile5(join5(dir, entry.name), "utf-8");
+      const content = await readFile7(join7(dir, entry.name), "utf-8");
       const scope = extractScope(content, "template");
       const key = compositeKey("template", entry.name, null);
       result.set(key, {
@@ -1245,10 +1417,10 @@ async function scanTemplates(dir, result) {
   }
 }
 async function scanSettings(claudeDir, projectPath, result) {
-  const settingsPath = join5(claudeDir, "settings.json");
+  const settingsPath = join7(claudeDir, "settings.json");
   let raw;
   try {
-    raw = await readFile5(settingsPath, "utf-8");
+    raw = await readFile7(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -1260,7 +1432,7 @@ async function scanSettings(claudeDir, projectPath, result) {
   }
   parsed = stripPermissionsAllow(parsed);
   if (parsed.hooks && typeof parsed.hooks === "object") {
-    const hooksDir = projectPath ? join5(projectPath, ".claude", "hooks") : join5(claudeDir, "hooks");
+    const hooksDir = projectPath ? join7(projectPath, ".claude", "hooks") : join7(claudeDir, "hooks");
     const discovered = await discoverHooks(hooksDir);
     if (discovered.size > 0) {
       parsed.hooks = stripDiscoveredHooks(
@@ -1592,8 +1764,8 @@ var init_confirm = __esm({
 });
 
 // src/lib/tech-detect.ts
-import { readFile as readFile6, access, readdir as readdir4 } from "node:fs/promises";
-import { join as join6, relative } from "node:path";
+import { readFile as readFile8, access, readdir as readdir4 } from "node:fs/promises";
+import { join as join8, relative } from "node:path";
 async function fileExists(filePath) {
   try {
     await access(filePath);
@@ -1606,8 +1778,8 @@ async function discoverMonorepoApps(projectPath) {
   const apps = [];
   const patterns = [];
   try {
-    const raw = await readFile6(
-      join6(projectPath, "pnpm-workspace.yaml"),
+    const raw = await readFile8(
+      join8(projectPath, "pnpm-workspace.yaml"),
       "utf-8"
     );
     const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
@@ -1621,7 +1793,7 @@ async function discoverMonorepoApps(projectPath) {
   }
   if (patterns.length === 0) {
     try {
-      const raw = await readFile6(join6(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);
@@ -1631,14 +1803,14 @@ async function discoverMonorepoApps(projectPath) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join6(projectPath, dir);
+      const absDir = join8(projectPath, dir);
       try {
         const entries = await readdir4(absDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const relPath = join6(dir, entry.name);
-            const absPath = join6(absDir, entry.name);
-            if (await fileExists(join6(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 });
             }
           }
@@ -1657,7 +1829,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(join6(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;
@@ -1676,7 +1848,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(join6(dirPath, sub))) {
+    if (await hasJsxFile(join8(dirPath, sub))) {
       caps.add("jsx");
       break;
     }
@@ -1698,7 +1870,7 @@ async function detectCapabilities(dirPath, pkgJson) {
       }
     }
   }
-  if (!caps.has("node-server") && await fileExists(join6(dirPath, "src", "main.ts"))) {
+  if (!caps.has("node-server") && await fileExists(join8(dirPath, "src", "main.ts"))) {
     caps.add("node-server");
   }
   if (pkgJson && pkgJson.bin) {
@@ -1714,7 +1886,7 @@ async function detectFromDirectory(dirPath) {
   const seen = /* @__PURE__ */ new Map();
   let pkgJson = null;
   try {
-    const raw = await readFile6(join6(dirPath, "package.json"), "utf-8");
+    const raw = await readFile8(join8(dirPath, "package.json"), "utf-8");
     pkgJson = JSON.parse(raw);
     const allDeps = {
       ...pkgJson.dependencies ?? {},
@@ -1746,7 +1918,7 @@ async function detectFromDirectory(dirPath) {
   }
   for (const { file, rule } of CONFIG_FILE_MAP) {
     const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join6(dirPath, file))) {
+    if (!seen.has(key) && await fileExists(join8(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
@@ -1924,7 +2096,7 @@ function categorizeDependency(depName) {
 async function findPackageJsonFiles(dir, projectPath, depth = 0) {
   if (depth > 4) return [];
   const results = [];
-  const pkgPath = join6(dir, "package.json");
+  const pkgPath = join8(dir, "package.json");
   if (await fileExists(pkgPath)) {
     results.push(pkgPath);
   }
@@ -1933,7 +2105,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(
-        join6(dir, entry.name),
+        join8(dir, entry.name),
         projectPath,
         depth + 1
       );
@@ -1948,7 +2120,7 @@ async function scanAllDependencies(projectPath) {
   const dependencies = [];
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile6(pkgPath, "utf-8");
+      const raw = await readFile8(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const sourcePath = relative(projectPath, pkgPath);
       const depSections = [
@@ -2197,14 +2369,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile9 } 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 readFile7(pkgPath, "utf-8");
+      const raw = await readFile9(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -2267,7 +2439,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile7(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile9(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -2311,8 +2483,70 @@ var init_port_verify = __esm({
   }
 });
 
+// src/lib/migrate-local-config.ts
+import { readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+function sharedConfigPath(projectPath) {
+  return join9(projectPath, ".codebyplan.json");
+}
+async function needsLocalMigration(projectPath) {
+  try {
+    const raw = await readFile10(sharedConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return false;
+    }
+    const cfg = parsed;
+    if (typeof cfg.worktree_id !== "string" || cfg.worktree_id === "") {
+      return false;
+    }
+    const local = await readLocalConfig(projectPath);
+    if (local?.device_id) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runLocalMigration(projectPath) {
+  const raw = await readFile10(sharedConfigPath(projectPath), "utf-8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(
+      ".codebyplan.json does not contain a JSON object \u2014 cannot migrate"
+    );
+  }
+  const cfg = parsed;
+  const hadWorktreeId = "worktree_id" in cfg;
+  const localBefore = await readLocalConfig(projectPath);
+  const localWillBeCreated = !localBefore?.device_id;
+  const device_id = await getOrCreateDeviceId(projectPath);
+  const cleaned = { ...cfg };
+  delete cleaned.worktree_id;
+  await writeFile5(
+    sharedConfigPath(projectPath),
+    JSON.stringify(cleaned, null, 2) + "\n",
+    "utf-8"
+  );
+  const files_changed = [".codebyplan.json"];
+  if (localWillBeCreated) files_changed.push(".codebyplan.local.json");
+  return {
+    migrated: true,
+    was_dirty: hadWorktreeId || localWillBeCreated,
+    files_changed,
+    device_id
+  };
+}
+var init_migrate_local_config = __esm({
+  "src/lib/migrate-local-config.ts"() {
+    "use strict";
+    init_local_config();
+  }
+});
+
 // src/lib/eslint-generator.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function importedIdentifiers(importLines) {
   const names = /* @__PURE__ */ new Set();
   for (const line of importLines) {
@@ -2380,7 +2614,7 @@ function collectDependencies(presets) {
   return deps;
 }
 function hashConfig(content) {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash2("sha256").update(content).digest("hex");
 }
 function buildRules(presets) {
   const merged = {};
@@ -2700,8 +2934,8 @@ __export(eslint_exports, {
   eslintSync: () => eslintSync,
   runEslint: () => runEslint
 });
-import { readFile as readFile8, writeFile as writeFile3, access as access2, readdir as readdir5 } from "node:fs/promises";
-import { join as join7, relative as relative2 } from "node:path";
+import { readFile as readFile11, writeFile as writeFile6, access as access2, readdir as readdir5 } from "node:fs/promises";
+import { join as join10, relative as relative2 } from "node:path";
 async function fileExists2(filePath) {
   try {
     await access2(filePath);
@@ -2712,7 +2946,7 @@ async function fileExists2(filePath) {
 }
 async function autoDetectIgnorePatterns(absPath) {
   const patterns = [];
-  if (await fileExists2(join7(absPath, "esbuild.js"))) {
+  if (await fileExists2(join10(absPath, "esbuild.js"))) {
     patterns.push("esbuild.js");
   }
   let entries = [];
@@ -2732,19 +2966,19 @@ async function autoDetectIgnorePatterns(absPath) {
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vitest.config.${ext}`;
-    if (await fileExists2(join7(absPath, candidate))) {
+    if (await fileExists2(join10(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vite.config.${ext}`;
-    if (await fileExists2(join7(absPath, candidate))) {
+    if (await fileExists2(join10(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
-  if (await fileExists2(join7(absPath, "tauri.conf.json"))) {
+  if (await fileExists2(join10(absPath, "tauri.conf.json"))) {
     patterns.push("src-tauri/**");
     patterns.push("**/*.d.ts");
   }
@@ -2752,14 +2986,14 @@ async function autoDetectIgnorePatterns(absPath) {
 }
 function detectPackageManager(projectPath) {
   return (async () => {
-    if (await fileExists2(join7(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(join7(projectPath, "yarn.lock"))) return "yarn";
+    if (await fileExists2(join10(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(join10(projectPath, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
 async function getInstalledDeps(pkgJsonPath) {
   try {
-    const raw = await readFile8(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);
@@ -2872,7 +3106,7 @@ async function eslintInit(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
-    const configPath = join7(target.absPath, "eslint.config.mjs");
+    const configPath = join10(target.absPath, "eslint.config.mjs");
     configsToWrite.push({
       target,
       presets,
@@ -2894,11 +3128,11 @@ async function eslintInit(repoId, projectPath) {
     return;
   }
   const pm = await detectPackageManager(projectPath);
-  const rootPkgJsonPath = join7(projectPath, "package.json");
+  const rootPkgJsonPath = join10(projectPath, "package.json");
   const installed = await getInstalledDeps(rootPkgJsonPath);
   if (isMonorepo) {
     for (const { target } of configsToWrite) {
-      const appPkgJson = join7(target.absPath, "package.json");
+      const appPkgJson = join10(target.absPath, "package.json");
       const appDeps = await getInstalledDeps(appPkgJson);
       for (const dep of appDeps) {
         installed.add(dep);
@@ -2924,9 +3158,9 @@ async function eslintInit(repoId, projectPath) {
   Install ${missingPkgs.length} missing packages? [Y/n] `
     );
     if (confirmed) {
-      const { execSync } = await import("node:child_process");
+      const { execSync: execSync3 } = await import("node:child_process");
       try {
-        execSync(installCmd, { cwd: projectPath, stdio: "inherit" });
+        execSync3(installCmd, { cwd: projectPath, stdio: "inherit" });
         console.log("  Packages installed.\n");
       } catch (err) {
         console.error(
@@ -2950,7 +3184,7 @@ async function eslintInit(repoId, projectPath) {
   } of configsToWrite) {
     if (await fileExists2(configPath)) {
       try {
-        const existing = await readFile8(configPath, "utf-8");
+        const existing = await readFile11(configPath, "utf-8");
         const existingHash = hashConfig(existing);
         if (existingHash === hash) {
           console.log(
@@ -2970,7 +3204,7 @@ async function eslintInit(repoId, projectPath) {
       }
     }
     try {
-      await writeFile3(configPath, content, "utf-8");
+      await writeFile6(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${target.name}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -3020,8 +3254,8 @@ async function eslintSync(repoId, projectPath) {
   let skippedCount = 0;
   let driftCount = 0;
   for (const config of configs) {
-    const absPath = config.source_path === "." ? projectPath : join7(projectPath, config.source_path);
-    const configPath = join7(absPath, "eslint.config.mjs");
+    const absPath = config.source_path === "." ? projectPath : join10(projectPath, config.source_path);
+    const configPath = join10(absPath, "eslint.config.mjs");
     const detected = await detectTechStack(absPath);
     const techNames = detected.flat.map((t) => t.name).filter((n) => n !== SYNTHETIC_CARRIER_NAME);
     const capabilities = collectCapabilities(detected.flat);
@@ -3035,7 +3269,7 @@ async function eslintSync(repoId, projectPath) {
     if (!presetsChanged) {
       if (await fileExists2(configPath)) {
         try {
-          const currentContent = await readFile8(configPath, "utf-8");
+          const currentContent = await readFile11(configPath, "utf-8");
           const currentHash = hashConfig(currentContent);
           if (config.generated_hash && currentHash !== config.generated_hash) {
             console.log(
@@ -3068,7 +3302,7 @@ async function eslintSync(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     try {
-      await writeFile3(configPath, content, "utf-8");
+      await writeFile6(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${config.source_path}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -3104,11 +3338,11 @@ async function checkEslintDrift(repoId, projectPath) {
     const configs = res.data ?? [];
     for (const config of configs) {
       if (!config.generated_hash) continue;
-      const absPath = config.source_path === "." ? projectPath : join7(projectPath, config.source_path);
-      const configPath = join7(absPath, "eslint.config.mjs");
+      const absPath = config.source_path === "." ? projectPath : join10(projectPath, config.source_path);
+      const configPath = join10(absPath, "eslint.config.mjs");
       if (!await fileExists2(configPath)) continue;
       try {
-        const content = await readFile8(configPath, "utf-8");
+        const content = await readFile11(configPath, "utf-8");
         const currentHash = hashConfig(content);
         if (currentHash !== config.generated_hash) {
           return true;
@@ -3159,11 +3393,11 @@ var sync_exports = {};
 __export(sync_exports, {
   runSync: () => runSync
 });
-import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile9, writeFile as writeFile4, mkdir as mkdir2, chmod as chmod2, unlink as unlink2 } from "node:fs/promises";
-import { join as join8, dirname as dirname2 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { readFile as readFile12, writeFile as writeFile7, mkdir as mkdir2, chmod as chmod2, unlink as unlink2 } from "node:fs/promises";
+import { join as join11, dirname as dirname2 } from "node:path";
 function contentHash(content) {
-  return createHash2("sha256").update(content).digest("hex");
+  return createHash3("sha256").update(content).digest("hex");
 }
 async function runSync() {
   const flags = parseFlags(3);
@@ -3229,7 +3463,7 @@ async function runSync() {
 }
 async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
   console.log("  Reading local and remote state...");
-  const claudeDir = join8(projectPath, ".claude");
+  const claudeDir = join11(projectPath, ".claude");
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
@@ -3464,7 +3698,7 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
       for (const p of toPull) {
         if (p.filePath && p.remoteContent !== null) {
           await mkdir2(dirname2(p.filePath), { recursive: true });
-          await writeFile4(p.filePath, p.remoteContent, "utf-8");
+          await writeFile7(p.filePath, p.remoteContent, "utf-8");
           if (p.isHook) await chmod2(p.filePath, 493);
         }
       }
@@ -3618,7 +3852,7 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
   console.log("\n  Sync complete.\n");
 }
 async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun) {
-  const settingsPath = join8(claudeDir, "settings.json");
+  const settingsPath = join11(claudeDir, "settings.json");
   const globalSettingsFiles = syncData.global_settings ?? [];
   let globalSettings = {};
   for (const gf of globalSettingsFiles) {
@@ -3638,11 +3872,11 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     globalSettings,
     repoSettings
   );
-  const hooksDir = join8(projectPath, ".claude", "hooks");
+  const hooksDir = join11(projectPath, ".claude", "hooks");
   const discovered = await discoverHooks(hooksDir);
   let localSettings = {};
   try {
-    const raw = await readFile9(settingsPath, "utf-8");
+    const raw = await readFile12(settingsPath, "utf-8");
     localSettings = JSON.parse(raw);
   } catch {
   }
@@ -3657,7 +3891,7 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   const mergedContent = JSON.stringify(merged, null, 2) + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile9(settingsPath, "utf-8");
+    currentContent = await readFile12(settingsPath, "utf-8");
   } catch {
   }
   if (currentContent === mergedContent) {
@@ -3669,18 +3903,74 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     return;
   }
   await mkdir2(dirname2(settingsPath), { recursive: true });
-  await writeFile4(settingsPath, mergedContent, "utf-8");
+  await writeFile7(settingsPath, mergedContent, "utf-8");
   console.log("    Updated settings.json");
 }
 async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join8(projectPath, ".codebyplan.json");
+  const configPath = join11(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile9(configPath, "utf-8");
+    const raw = await readFile12(configPath, "utf-8");
     currentConfig = JSON.parse(raw);
   } catch {
     currentConfig = { repo_id: repoId };
   }
+  if (dryRun) {
+    try {
+      if (await needsLocalMigration(projectPath)) {
+        console.log(
+          `  Would migrate .codebyplan.json -> worktree_id to .codebyplan.local.json (dry-run, skipping actual write).`
+        );
+      }
+    } catch {
+    }
+  } else {
+    try {
+      if (await needsLocalMigration(projectPath)) {
+        const result = await runLocalMigration(projectPath);
+        delete currentConfig.worktree_id;
+        console.log(
+          `  Migrated .codebyplan.json -> moved worktree_id to gitignored .codebyplan.local.json (device_id=${result.device_id.slice(0, 8)})`
+        );
+        console.log(
+          `  Suggest /cbp-git-commit to stage the cleaned shared file.`
+        );
+      }
+    } catch (err) {
+      console.warn(
+        `  Warning: local migration failed (continuing): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  let resolvedWorktreeId;
+  try {
+    const deviceId = await getOrCreateDeviceId(projectPath);
+    let branch = "main";
+    try {
+      const { execSync: execSync3 } = await import("node:child_process");
+      branch = execSync3("git symbolic-ref --short HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+    }
+    const tupleId = await resolveWorktreeId({
+      repoId,
+      repoPath: projectPath,
+      branch,
+      deviceId
+    });
+    if (tupleId) {
+      resolvedWorktreeId = tupleId;
+    } else {
+      resolvedWorktreeId = await resolveAndCacheWorktreeId(repoId, projectPath) ?? void 0;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `  Warning: failed to cache worktree_id (self-heal skipped): ${msg}`
+    );
+  }
   const repoRes = await apiGet(`/repos/${repoId}`);
   const repo = repoRes.data;
   let portAllocations = [];
@@ -3690,8 +3980,8 @@ async function syncConfig(repoId, projectPath, dryRun) {
       { repo_id: repoId }
     );
     const allAllocations = portsRes.data ?? [];
-    const worktreeId2 = currentConfig.worktree_id;
-    const filtered = worktreeId2 ? allAllocations.filter((a) => a.worktree_id === worktreeId2) : allAllocations.filter((a) => !a.worktree_id);
+    const filteredByWorktree = resolvedWorktreeId;
+    const filtered = filteredByWorktree ? allAllocations.filter((a) => a.worktree_id === filteredByWorktree) : allAllocations.filter((a) => !a.worktree_id);
     const ALLOWED_FIELDS = [
       "id",
       "repo_id",
@@ -3719,7 +4009,7 @@ async function syncConfig(repoId, projectPath, dryRun) {
       `  Warning: failed to fetch port allocations: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const worktreeId = currentConfig.worktree_id;
+  const worktreeId = resolvedWorktreeId;
   const matchingAlloc = portAllocations[0];
   const defaultBranchConfig = {
     protected: ["main", "development"],
@@ -3730,7 +4020,9 @@ async function syncConfig(repoId, projectPath, dryRun) {
   const branchConfig = repo.branch_config ?? defaultBranchConfig;
   const newConfig = {
     repo_id: repoId,
-    ...worktreeId ? { worktree_id: worktreeId } : {},
+    // worktree_id is intentionally omitted — it is never persisted in
+    // .codebyplan.json (CHK-108). The in-memory worktreeId is used only
+    // for server_port / server_type resolution immediately below.
     server_port: worktreeId && matchingAlloc ? matchingAlloc.port : repo.server_port,
     server_type: worktreeId && matchingAlloc ? matchingAlloc.server_type : repo.server_type,
     git_branch: repo.git_branch ?? "development",
@@ -3748,7 +4040,7 @@ async function syncConfig(repoId, projectPath, dryRun) {
     console.log("    Config would be updated (dry-run).");
     return;
   }
-  await writeFile4(configPath, newJson + "\n", "utf-8");
+  await writeFile7(configPath, newJson + "\n", "utf-8");
   console.log("    Updated .codebyplan.json");
 }
 async function syncTechStack(repoId, projectPath, dryRun) {
@@ -3900,28 +4192,28 @@ function getLocalFilePath(claudeDir, projectPath, remote) {
     hook: { dir: "hooks", ext: ".sh" },
     template: { dir: "templates", ext: "" },
     context: { dir: "context", ext: ".md" },
-    docs_stack: { dir: join8("docs", "stack"), ext: ".md" },
+    docs_stack: { dir: join11("docs", "stack"), ext: ".md" },
     docs: { dir: "docs", ext: ".md" },
     claude_md: { dir: "", ext: "" },
     settings: { dir: "", ext: "" }
   };
-  if (remote.type === "claude_md") return join8(projectPath, "CLAUDE.md");
-  if (remote.type === "settings") return join8(claudeDir, "settings.json");
+  if (remote.type === "claude_md") return join11(projectPath, "CLAUDE.md");
+  if (remote.type === "settings") return join11(claudeDir, "settings.json");
   const cfg = typeConfig2[remote.type];
-  if (!cfg) return join8(claudeDir, remote.name);
-  const typeDir = remote.type === "command" ? join8(claudeDir, cfg.dir, "cbp") : join8(claudeDir, cfg.dir);
+  if (!cfg) return join11(claudeDir, remote.name);
+  const typeDir = remote.type === "command" ? join11(claudeDir, cfg.dir, "cbp") : join11(claudeDir, cfg.dir);
   if (cfg.subfolder)
-    return join8(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
+    return join11(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
   if (remote.type === "command" && remote.category)
-    return join8(typeDir, remote.category, `${remote.name}${cfg.ext}`);
-  if (remote.type === "template") return join8(typeDir, remote.name);
+    return join11(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  if (remote.type === "template") return join11(typeDir, remote.name);
   if (remote.category && (remote.type === "context" || remote.type === "docs_stack" || remote.type === "docs"))
-    return join8(typeDir, remote.category, `${remote.name}${cfg.ext}`);
-  return join8(typeDir, `${remote.name}${cfg.ext}`);
+    return join11(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  return join11(typeDir, `${remote.name}${cfg.ext}`);
 }
 function getSyncVersion() {
   try {
-    return "1.4.2";
+    return "1.5.0";
   } catch {
     return "unknown";
   }
@@ -3970,10 +4262,64 @@ var init_sync = __esm({
     init_settings_merge();
     init_hook_registry();
     init_port_verify();
+    init_resolve_worktree();
+    init_local_config();
+    init_migrate_local_config();
     init_eslint();
   }
 });
 
+// src/cli/resolve-worktree.ts
+var resolve_worktree_exports = {};
+__export(resolve_worktree_exports, {
+  runResolveWorktree: () => runResolveWorktree
+});
+import { execSync as execSync2 } from "node:child_process";
+async function runResolveWorktree() {
+  try {
+    const projectPath = process.cwd();
+    const found = await findCodebyplanConfig(projectPath);
+    if (!found?.contents.repo_id) {
+      process.exit(0);
+    }
+    const repoId = found.contents.repo_id;
+    const deviceId = await getOrCreateDeviceId(projectPath);
+    let branch = "";
+    try {
+      branch = execSync2("git symbolic-ref --short HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+    }
+    const worktreeId = await resolveWorktreeId({
+      repoId,
+      repoPath: projectPath,
+      branch,
+      deviceId
+    });
+    if (worktreeId) {
+      process.stdout.write(worktreeId);
+    }
+    process.exit(0);
+  } catch (err) {
+    if (process.env.CODEBYPLAN_DEBUG === "1") {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`resolve-worktree: ${msg}
+`);
+    }
+    process.exit(0);
+  }
+}
+var init_resolve_worktree2 = __esm({
+  "src/cli/resolve-worktree.ts"() {
+    "use strict";
+    init_config();
+    init_local_config();
+    init_resolve_worktree();
+  }
+});
+
 // src/index.ts
 init_version();
 import { readFileSync } from "node:fs";
@@ -4038,16 +4384,22 @@ void (async () => {
     }
     process.exit(0);
   }
+  if (arg === "resolve-worktree") {
+    const { runResolveWorktree: runResolveWorktree2 } = await Promise.resolve().then(() => (init_resolve_worktree2(), resolve_worktree_exports));
+    await runResolveWorktree2();
+    process.exit(0);
+  }
   if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
     console.log(`
   CodeByPlan CLI v${VERSION}
 
   Usage:
-    codebyplan setup        Interactive setup (API key + project init + first sync)
-    codebyplan sync         Bidirectional sync (pull + push + config)
-    codebyplan eslint       ESLint config management (init, sync)
-    codebyplan help         Show this help message
-    codebyplan --version    Print version
+    codebyplan setup             Interactive setup (API key + project init + first sync)
+    codebyplan sync              Bidirectional sync (pull + push + config)
+    codebyplan eslint            ESLint config management (init, sync)
+    codebyplan resolve-worktree  Resolve active worktree UUID from device+path+branch tuple
+    codebyplan help              Show this help message
+    codebyplan --version         Print version
 
   Sync options:
     --path <dir>            Project root directory (default: cwd)