codebyplan 1.4.2 → 1.4.3

package/README.md

@@ -34,6 +34,8 @@ Bidirectional sync of `.claude/` infrastructure files between your local project
 | `--force`          | Skip confirmation and conflict prompts           |
 | `--fix`            | Auto-create missing port allocations             |
 
+**Side effects:** writes `worktree_id` (UUID) at the top level of `.codebyplan.json`, used as a cached scope for workflow skills. See `.claude/rules/worktree-tagging.md`.
+
 ### `codebyplan help`
 
 Show help message.

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.4.3";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -143,6 +143,68 @@ 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;
+}
+var init_resolve_worktree = __esm({
+  "src/lib/resolve-worktree.ts"() {
+    "use strict";
+    init_api();
+  }
+});
+
 // src/lib/settings-merge.ts
 function mergeSettings(template, local) {
   const merged = { ...local };
@@ -208,8 +270,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 readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
 function parseHookMeta(content) {
   const lineMatch = content.match(/^#\s*@hook:(.*)$/m);
   if (!lineMatch) return null;
@@ -231,7 +293,7 @@ async function discoverHooks(hooksDir) {
     return discovered;
   }
   for (const filename of filenames) {
-    const content = await readFile(join(hooksDir, filename), "utf-8");
+    const content = await readFile2(join2(hooksDir, filename), "utf-8");
     const meta = parseHookMeta(content);
     if (meta) {
       discovered.set(filename.replace(/\.sh$/, ""), meta);
@@ -378,45 +440,45 @@ __export(sync_engine_exports, {
 });
 import {
   readdir as readdir2,
-  readFile as readFile2,
-  writeFile,
+  readFile as readFile3,
+  writeFile as writeFile2,
   unlink,
   mkdir,
   rmdir,
   chmod,
   stat
 } from "node:fs/promises";
-import { join as join2, dirname } from "node:path";
+import { join as join3, dirname } from "node:path";
 function getTypeDir(claudeDir, dir) {
-  if (dir === "commands") return join2(claudeDir, dir, "cbp");
-  return join2(claudeDir, dir);
+  if (dir === "commands") return join3(claudeDir, dir, "cbp");
+  return join3(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 join3(typeDir, file.name, `${cfg.subfolder}${cfg.ext}`);
   }
   if (typeName === "command" && file.category) {
-    return join2(typeDir, file.category, `${file.name}${cfg.ext}`);
+    return join3(typeDir, file.category, `${file.name}${cfg.ext}`);
   }
   if (typeName === "template") {
-    return join2(typeDir, file.name);
+    return join3(typeDir, file.name);
   }
-  return join2(typeDir, `${file.name}${cfg.ext}`);
+  return join3(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 = join3(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 readFile3(fullPath, "utf-8");
         result.set(relPath, fileContent);
       }
     }
@@ -426,7 +488,7 @@ async function readDirRecursive(dir, base = dir) {
 }
 async function isGitWorktree(projectPath) {
   try {
-    const gitPath = join2(projectPath, ".git");
+    const gitPath = join3(projectPath, ".git");
     const info = await stat(gitPath);
     return info.isFile();
   } catch {
@@ -453,7 +515,7 @@ async function executeSyncToLocal(options) {
   const syncData = syncRes.data;
   const repoData = repoRes.data;
   syncData.claude_md = [];
-  const claudeDir = join2(projectPath, ".claude");
+  const claudeDir = join3(projectPath, ".claude");
   const worktree = await isGitWorktree(projectPath);
   const byType = {};
   const totals = { created: 0, updated: 0, deleted: 0, unchanged: 0 };
@@ -489,7 +551,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 = join3(targetDir, relPath);
       const localContent = localFiles.get(relPath);
       if (localContent === void 0) {
         const remoteFile = remoteFiles.find((f) => f.name === name);
@@ -501,14 +563,14 @@ async function executeSyncToLocal(options) {
         });
         if (!dryRun) {
           await mkdir(dirname(fullPath), { recursive: true });
-          await writeFile(fullPath, content, "utf-8");
+          await writeFile2(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 writeFile2(fullPath, content, "utf-8");
           if (typeName === "hook") await chmod(fullPath, 493);
         }
         result.updated.push(name);
@@ -520,7 +582,7 @@ async function executeSyncToLocal(options) {
     }
     for (const [relPath] of localFiles) {
       if (!remotePathMap.has(relPath)) {
-        const fullPath = join2(targetDir, relPath);
+        const fullPath = join3(targetDir, relPath);
         if (!dryRun) {
           await unlink(fullPath);
           await removeEmptyParents(fullPath, targetDir);
@@ -535,7 +597,7 @@ async function executeSyncToLocal(options) {
   {
     const typeName = "docs_stack";
     const syncKey = "docs_stack";
-    const targetDir = join2(projectPath, "docs", "stack");
+    const targetDir = join3(projectPath, "docs", "stack");
     const remoteFiles = syncData[syncKey] ?? [];
     const result = {
       created: [],
@@ -549,7 +611,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 ? join3(remote.category, remote.name) : remote.name;
       const substituted = substituteVariables(remote.content, repoData);
       remotePathMap.set(relPath, {
         content: substituted,
@@ -557,18 +619,18 @@ async function executeSyncToLocal(options) {
       });
     }
     for (const [relPath, { content, name }] of remotePathMap) {
-      const fullPath = join2(targetDir, relPath);
+      const fullPath = join3(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 writeFile2(fullPath, content, "utf-8");
         }
         result.created.push(name);
         totals.created++;
       } else if (localContent !== content) {
         if (!dryRun) {
-          await writeFile(fullPath, content, "utf-8");
+          await writeFile2(fullPath, content, "utf-8");
         }
         result.updated.push(name);
         totals.updated++;
@@ -579,7 +641,7 @@ async function executeSyncToLocal(options) {
     }
     for (const [relPath] of localFiles) {
       if (!remotePathMap.has(relPath)) {
-        const fullPath = join2(targetDir, relPath);
+        const fullPath = join3(targetDir, relPath);
         if (!dryRun) {
           await unlink(fullPath);
           await removeEmptyParents(fullPath, targetDir);
@@ -599,8 +661,8 @@ async function executeSyncToLocal(options) {
     globalSettings = { ...globalSettings, ...parsed };
   }
   const specialTypes = {
-    claude_md: () => join2(projectPath, "CLAUDE.md"),
-    settings: () => join2(projectPath, ".claude", "settings.json")
+    claude_md: () => join3(projectPath, "CLAUDE.md"),
+    settings: () => join3(projectPath, ".claude", "settings.json")
   };
   for (const [typeName, getPath] of Object.entries(specialTypes)) {
     const remoteFiles = syncData[typeName] ?? [];
@@ -615,7 +677,7 @@ async function executeSyncToLocal(options) {
       const remoteContent = substituteVariables(remote.content, repoData);
       let localContent;
       try {
-        localContent = await readFile2(targetPath, "utf-8");
+        localContent = await readFile3(targetPath, "utf-8");
       } catch {
       }
       if (typeName === "settings") {
@@ -624,7 +686,7 @@ async function executeSyncToLocal(options) {
           globalSettings,
           repoSettings
         );
-        const hooksDir = join2(projectPath, ".claude", "hooks");
+        const hooksDir = join3(projectPath, ".claude", "hooks");
         const discovered = await discoverHooks(hooksDir);
         if (localContent === void 0) {
           const finalSettings = stripPermissionsAllow(combinedTemplate);
@@ -636,7 +698,7 @@ async function executeSyncToLocal(options) {
           }
           if (!dryRun) {
             await mkdir(dirname(targetPath), { recursive: true });
-            await writeFile(
+            await writeFile2(
               targetPath,
               JSON.stringify(finalSettings, null, 2) + "\n",
               "utf-8"
@@ -657,7 +719,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 writeFile2(targetPath, mergedContent, "utf-8");
             }
             result.updated.push(remote.name);
             totals.updated++;
@@ -670,13 +732,13 @@ async function executeSyncToLocal(options) {
         if (localContent === void 0) {
           if (!dryRun) {
             await mkdir(dirname(targetPath), { recursive: true });
-            await writeFile(targetPath, remoteContent, "utf-8");
+            await writeFile2(targetPath, remoteContent, "utf-8");
           }
           result.created.push(remote.name);
           totals.created++;
         } else if (localContent !== remoteContent) {
           if (!dryRun) {
-            await writeFile(targetPath, remoteContent, "utf-8");
+            await writeFile2(targetPath, remoteContent, "utf-8");
           }
           result.updated.push(remote.name);
           totals.updated++;
@@ -777,15 +839,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 readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function getConfigPath(scope) {
-  return scope === "user" ? join3(homedir(), ".claude.json") : join3(process.cwd(), ".mcp.json");
+  return scope === "user" ? join4(homedir(), ".claude.json") : join4(process.cwd(), ".mcp.json");
 }
 async function readConfig(path) {
   try {
-    const raw = await readFile3(path, "utf-8");
+    const raw = await readFile4(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -809,7 +871,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 writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return configPath;
 }
 async function verifyMcpConfig(scope, apiKey) {
@@ -913,27 +975,28 @@ async function runSetup() {
           console.log(`
   Selected: ${selectedRepo.name}
 `);
-          let worktreeId;
           const projectPath = process.cwd();
-          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;
-          } catch {
-          }
-          const codebyplanPath = join3(projectPath, ".codebyplan.json");
+          const worktreeId = await resolveAndCacheWorktreeId(
+            selectedRepo.id,
+            projectPath,
+            { skipWrite: true }
+          );
+          const codebyplanPath = join4(projectPath, ".codebyplan.json");
           const codebyplanConfig = {
             repo_id: selectedRepo.id
           };
           if (worktreeId) codebyplanConfig.worktree_id = worktreeId;
-          await writeFile2(
+          await writeFile3(
             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 +1031,19 @@ async function runSetup() {
 var init_setup = __esm({
   "src/cli/setup.ts"() {
     "use strict";
-    init_api();
+    init_resolve_worktree();
   }
 });
 
 // src/cli/config.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join4, resolve } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join5, 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 = join5(cursor, ".codebyplan.json");
     try {
-      const raw = await readFile4(configPath, "utf-8");
+      const raw = await readFile5(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       return { path: configPath, contents: parsed };
     } catch {
@@ -1031,8 +1094,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 readFile6 } from "node:fs/promises";
+import { join as join6, extname } from "node:path";
 function extractScope(content, type) {
   if (type === "hook") {
     const match = content.match(/^#\s*@scope:\s*(\S+)/m);
@@ -1062,29 +1125,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(join6(claudeDir, "commands", "cbp"), result);
   await scanSubfolderType(
-    join5(claudeDir, "agents"),
+    join6(claudeDir, "agents"),
     "agent",
     "AGENT.md",
     result
   );
   await scanSubfolderType(
-    join5(claudeDir, "skills"),
+    join6(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(join6(claudeDir, "rules"), "rule", ".md", result);
+  await scanFlatType(join6(claudeDir, "hooks"), "hook", ".sh", result);
+  await scanTemplates(join6(claudeDir, "templates"), result);
   await scanCategorizedType(
-    join5(claudeDir, "context"),
+    join6(claudeDir, "context"),
     "context",
     ".md",
     result
   );
-  await scanDocsRecursive(join5(claudeDir, "docs"), result);
+  await scanDocsRecursive(join6(claudeDir, "docs"), result);
   await scanSettings(claudeDir, projectPath, result);
   return result;
 }
@@ -1102,12 +1165,12 @@ async function scanCommandsRecursive(baseDir, currentDir, result) {
     if (entry.isDirectory()) {
       await scanCommandsRecursive(
         baseDir,
-        join5(currentDir, entry.name),
+        join6(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 readFile6(join6(currentDir, entry.name), "utf-8");
       const relDir = currentDir.slice(baseDir.length + 1);
       const category = relDir || null;
       const scope = extractScope(content, "command");
@@ -1125,9 +1188,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 = join6(dir, entry.name, fileName);
       try {
-        const content = await readFile5(filePath, "utf-8");
+        const content = await readFile6(filePath, "utf-8");
         const scope = extractScope(content, type);
         const key = compositeKey(type, entry.name, null);
         result.set(key, {
@@ -1152,7 +1215,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 readFile6(join6(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 +1234,7 @@ async function scanCategorizedType(dir, type, ext, result) {
       const category = entry.name;
       let subEntries;
       try {
-        subEntries = await readdir3(join5(dir, category), {
+        subEntries = await readdir3(join6(dir, category), {
           withFileTypes: true
         });
       } catch {
@@ -1180,8 +1243,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 readFile6(
+            join6(dir, category, sub.name),
             "utf-8"
           );
           const scope = extractScope(content, type);
@@ -1191,7 +1254,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 readFile6(join6(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 +1273,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, join6(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 readFile6(join6(currentDir, entry.name), "utf-8");
       const scope = extractScope(content, "docs");
       const relDir = currentDir.slice(baseDir.length + 1);
       const category = relDir || null;
@@ -1231,7 +1294,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 readFile6(join6(dir, entry.name), "utf-8");
       const scope = extractScope(content, "template");
       const key = compositeKey("template", entry.name, null);
       result.set(key, {
@@ -1245,10 +1308,10 @@ async function scanTemplates(dir, result) {
   }
 }
 async function scanSettings(claudeDir, projectPath, result) {
-  const settingsPath = join5(claudeDir, "settings.json");
+  const settingsPath = join6(claudeDir, "settings.json");
   let raw;
   try {
-    raw = await readFile5(settingsPath, "utf-8");
+    raw = await readFile6(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -1260,7 +1323,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 ? join6(projectPath, ".claude", "hooks") : join6(claudeDir, "hooks");
     const discovered = await discoverHooks(hooksDir);
     if (discovered.size > 0) {
       parsed.hooks = stripDiscoveredHooks(
@@ -1592,8 +1655,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 readFile7, access, readdir as readdir4 } from "node:fs/promises";
+import { join as join7, relative } from "node:path";
 async function fileExists(filePath) {
   try {
     await access(filePath);
@@ -1606,8 +1669,8 @@ async function discoverMonorepoApps(projectPath) {
   const apps = [];
   const patterns = [];
   try {
-    const raw = await readFile6(
-      join6(projectPath, "pnpm-workspace.yaml"),
+    const raw = await readFile7(
+      join7(projectPath, "pnpm-workspace.yaml"),
       "utf-8"
     );
     const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
@@ -1621,7 +1684,7 @@ async function discoverMonorepoApps(projectPath) {
   }
   if (patterns.length === 0) {
     try {
-      const raw = await readFile6(join6(projectPath, "package.json"), "utf-8");
+      const raw = await readFile7(join7(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 +1694,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 = join7(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 = join7(dir, entry.name);
+            const absPath = join7(absDir, entry.name);
+            if (await fileExists(join7(absPath, "package.json"))) {
               apps.push({ name: entry.name, path: relPath, absPath });
             }
           }
@@ -1657,7 +1720,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(join7(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 +1739,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(join7(dirPath, sub))) {
       caps.add("jsx");
       break;
     }
@@ -1698,7 +1761,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(join7(dirPath, "src", "main.ts"))) {
     caps.add("node-server");
   }
   if (pkgJson && pkgJson.bin) {
@@ -1714,7 +1777,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 readFile7(join7(dirPath, "package.json"), "utf-8");
     pkgJson = JSON.parse(raw);
     const allDeps = {
       ...pkgJson.dependencies ?? {},
@@ -1746,7 +1809,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(join7(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
@@ -1924,7 +1987,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 = join7(dir, "package.json");
   if (await fileExists(pkgPath)) {
     results.push(pkgPath);
   }
@@ -1933,7 +1996,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),
+        join7(dir, entry.name),
         projectPath,
         depth + 1
       );
@@ -1948,7 +2011,7 @@ async function scanAllDependencies(projectPath) {
   const dependencies = [];
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile6(pkgPath, "utf-8");
+      const raw = await readFile7(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const sourcePath = relative(projectPath, pkgPath);
       const depSections = [
@@ -2197,14 +2260,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } 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 readFile8(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -2267,7 +2330,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile7(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile8(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -2700,8 +2763,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 readFile9, writeFile as writeFile4, access as access2, readdir as readdir5 } from "node:fs/promises";
+import { join as join8, relative as relative2 } from "node:path";
 async function fileExists2(filePath) {
   try {
     await access2(filePath);
@@ -2712,7 +2775,7 @@ async function fileExists2(filePath) {
 }
 async function autoDetectIgnorePatterns(absPath) {
   const patterns = [];
-  if (await fileExists2(join7(absPath, "esbuild.js"))) {
+  if (await fileExists2(join8(absPath, "esbuild.js"))) {
     patterns.push("esbuild.js");
   }
   let entries = [];
@@ -2732,19 +2795,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(join8(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(join8(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
-  if (await fileExists2(join7(absPath, "tauri.conf.json"))) {
+  if (await fileExists2(join8(absPath, "tauri.conf.json"))) {
     patterns.push("src-tauri/**");
     patterns.push("**/*.d.ts");
   }
@@ -2752,14 +2815,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(join8(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(join8(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);
@@ -2872,7 +2935,7 @@ async function eslintInit(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
-    const configPath = join7(target.absPath, "eslint.config.mjs");
+    const configPath = join8(target.absPath, "eslint.config.mjs");
     configsToWrite.push({
       target,
       presets,
@@ -2894,11 +2957,11 @@ async function eslintInit(repoId, projectPath) {
     return;
   }
   const pm = await detectPackageManager(projectPath);
-  const rootPkgJsonPath = join7(projectPath, "package.json");
+  const rootPkgJsonPath = join8(projectPath, "package.json");
   const installed = await getInstalledDeps(rootPkgJsonPath);
   if (isMonorepo) {
     for (const { target } of configsToWrite) {
-      const appPkgJson = join7(target.absPath, "package.json");
+      const appPkgJson = join8(target.absPath, "package.json");
       const appDeps = await getInstalledDeps(appPkgJson);
       for (const dep of appDeps) {
         installed.add(dep);
@@ -2950,7 +3013,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(
@@ -2970,7 +3033,7 @@ async function eslintInit(repoId, projectPath) {
       }
     }
     try {
-      await writeFile3(configPath, content, "utf-8");
+      await writeFile4(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${target.name}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -3020,8 +3083,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 : join8(projectPath, config.source_path);
+    const configPath = join8(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 +3098,7 @@ async function eslintSync(repoId, projectPath) {
     if (!presetsChanged) {
       if (await fileExists2(configPath)) {
         try {
-          const currentContent = await readFile8(configPath, "utf-8");
+          const currentContent = await readFile9(configPath, "utf-8");
           const currentHash = hashConfig(currentContent);
           if (config.generated_hash && currentHash !== config.generated_hash) {
             console.log(
@@ -3068,7 +3131,7 @@ async function eslintSync(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     try {
-      await writeFile3(configPath, content, "utf-8");
+      await writeFile4(configPath, content, "utf-8");
     } catch (err) {
       console.error(
         `  ${config.source_path}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
@@ -3104,11 +3167,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 : join8(projectPath, config.source_path);
+      const configPath = join8(absPath, "eslint.config.mjs");
       if (!await fileExists2(configPath)) continue;
       try {
-        const content = await readFile8(configPath, "utf-8");
+        const content = await readFile9(configPath, "utf-8");
         const currentHash = hashConfig(content);
         if (currentHash !== config.generated_hash) {
           return true;
@@ -3160,8 +3223,8 @@ __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 { readFile as readFile10, writeFile as writeFile5, mkdir as mkdir2, chmod as chmod2, unlink as unlink2 } from "node:fs/promises";
+import { join as join9, dirname as dirname2 } from "node:path";
 function contentHash(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
@@ -3229,7 +3292,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 = join9(projectPath, ".claude");
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
@@ -3464,7 +3527,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 writeFile5(p.filePath, p.remoteContent, "utf-8");
           if (p.isHook) await chmod2(p.filePath, 493);
         }
       }
@@ -3618,7 +3681,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 = join9(claudeDir, "settings.json");
   const globalSettingsFiles = syncData.global_settings ?? [];
   let globalSettings = {};
   for (const gf of globalSettingsFiles) {
@@ -3638,11 +3701,11 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     globalSettings,
     repoSettings
   );
-  const hooksDir = join8(projectPath, ".claude", "hooks");
+  const hooksDir = join9(projectPath, ".claude", "hooks");
   const discovered = await discoverHooks(hooksDir);
   let localSettings = {};
   try {
-    const raw = await readFile9(settingsPath, "utf-8");
+    const raw = await readFile10(settingsPath, "utf-8");
     localSettings = JSON.parse(raw);
   } catch {
   }
@@ -3657,7 +3720,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 readFile10(settingsPath, "utf-8");
   } catch {
   }
   if (currentContent === mergedContent) {
@@ -3669,18 +3732,30 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     return;
   }
   await mkdir2(dirname2(settingsPath), { recursive: true });
-  await writeFile4(settingsPath, mergedContent, "utf-8");
+  await writeFile5(settingsPath, mergedContent, "utf-8");
   console.log("    Updated settings.json");
 }
 async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join8(projectPath, ".codebyplan.json");
+  const configPath = join9(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile9(configPath, "utf-8");
+    const raw = await readFile10(configPath, "utf-8");
     currentConfig = JSON.parse(raw);
   } catch {
     currentConfig = { repo_id: repoId };
   }
+  let resolvedWorktreeId;
+  try {
+    resolvedWorktreeId = await resolveAndCacheWorktreeId(repoId, projectPath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `  Warning: failed to cache worktree_id (self-heal skipped): ${msg}`
+    );
+  }
+  if (resolvedWorktreeId && currentConfig.worktree_id !== resolvedWorktreeId) {
+    currentConfig = { ...currentConfig, worktree_id: resolvedWorktreeId };
+  }
   const repoRes = await apiGet(`/repos/${repoId}`);
   const repo = repoRes.data;
   let portAllocations = [];
@@ -3748,7 +3823,7 @@ async function syncConfig(repoId, projectPath, dryRun) {
     console.log("    Config would be updated (dry-run).");
     return;
   }
-  await writeFile4(configPath, newJson + "\n", "utf-8");
+  await writeFile5(configPath, newJson + "\n", "utf-8");
   console.log("    Updated .codebyplan.json");
 }
 async function syncTechStack(repoId, projectPath, dryRun) {
@@ -3900,28 +3975,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: join9("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 join9(projectPath, "CLAUDE.md");
+  if (remote.type === "settings") return join9(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 join9(claudeDir, remote.name);
+  const typeDir = remote.type === "command" ? join9(claudeDir, cfg.dir, "cbp") : join9(claudeDir, cfg.dir);
   if (cfg.subfolder)
-    return join8(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
+    return join9(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 join9(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  if (remote.type === "template") return join9(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 join9(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  return join9(typeDir, `${remote.name}${cfg.ext}`);
 }
 function getSyncVersion() {
   try {
-    return "1.4.2";
+    return "1.4.3";
   } catch {
     return "unknown";
   }
@@ -3970,6 +4045,7 @@ var init_sync = __esm({
     init_settings_merge();
     init_hook_registry();
     init_port_verify();
+    init_resolve_worktree();
     init_eslint();
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "CLI for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {