codebyplan 1.4.1 → 1.4.3

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.1";
+    VERSION = "1.4.3";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -52,7 +52,7 @@ function isRetryable(err) {
   return false;
 }
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function request(method, path, options) {
   const url = buildUrl(path, options?.params);
@@ -126,7 +126,7 @@ var init_api = __esm({
     "use strict";
     init_version();
     API_KEY = process.env.CODEBYPLAN_API_KEY ?? "";
-    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com").replace(/\/$/, "");
+    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
     REQUEST_TIMEOUT_MS = 12e4;
     MAX_RETRIES = 3;
     BASE_DELAY_MS = 1e3;
@@ -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,14 +270,17 @@ 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 match = content.match(/^#\s*@hook:\s*(\S+)(?:\s+(.+))?$/m);
-  if (!match) return null;
+  const lineMatch = content.match(/^#\s*@hook:(.*)$/m);
+  if (!lineMatch) return null;
+  const parts = lineMatch[1].trim().split(/\s+/);
+  const event = parts[0];
+  if (!event) return null;
   return {
-    event: match[1],
-    matcher: match[2]?.trim() ?? ""
+    event,
+    matcher: parts.slice(1).join(" ")
   };
 }
 async function discoverHooks(hooksDir) {
@@ -228,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);
@@ -375,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);
       }
     }
@@ -423,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 {
@@ -450,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 };
@@ -486,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);
@@ -498,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);
@@ -517,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);
@@ -532,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: [],
@@ -546,26 +611,26 @@ 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,
-        name: `${remote.category ?? ""}/${remote.name}`
+        name: remote.category ? `${remote.category}/${remote.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) {
         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++;
@@ -576,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);
@@ -596,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] ?? [];
@@ -612,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") {
@@ -621,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);
@@ -633,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"
@@ -654,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++;
@@ -667,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++;
@@ -774,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;
@@ -793,7 +858,7 @@ async function readConfig(path) {
   }
 }
 function buildMcpEntry(apiKey) {
-  const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com";
+  const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com";
   return {
     url: `${baseUrl}/mcp`,
     headers: { "x-api-key": apiKey }
@@ -806,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) {
@@ -835,7 +900,7 @@ async function runSetup() {
       return;
     }
     console.log("\n  Validating API key...");
-    const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com";
+    const baseUrl = process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com";
     const res = await fetch(`${baseUrl}/api/repos`, {
       headers: { "x-api-key": apiKey },
       signal: AbortSignal.timeout(1e4)
@@ -887,7 +952,7 @@ async function runSetup() {
 `
       );
       console.log(
-        `    { "url": "https://codebyplan.com/mcp", "headers": { "x-api-key": "${apiKey}" } }
+        `    { "url": "https://www.codebyplan.com/mcp", "headers": { "x-api-key": "${apiKey}" } }
 `
       );
     }
@@ -910,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));
@@ -965,20 +1031,36 @@ 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 } 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 = join5(cursor, ".codebyplan.json");
+    try {
+      const raw = await readFile5(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return { path: configPath, contents: parsed };
+    } catch {
+    }
+    const parent = resolve(cursor, "..");
+    if (parent === cursor) return null;
+    cursor = parent;
+  }
+  return null;
+}
 function parseFlags(startIndex) {
   const flags = {};
   const args = process.argv.slice(startIndex);
   for (let i = 0; i < args.length; i++) {
-    const arg2 = args[i];
-    if (arg2.startsWith("--") && i + 1 < args.length) {
-      const key = arg2.slice(2);
+    const arg = args[i];
+    if (arg.startsWith("--") && i + 1 < args.length) {
+      const key = arg.slice(2);
       flags[key] = args[++i];
     }
   }
@@ -992,13 +1074,10 @@ async function resolveConfig(flags) {
   let repoId = flags["repo-id"] ?? process.env.CODEBYPLAN_REPO_ID;
   let worktreeId = flags["worktree-id"] ?? process.env.CODEBYPLAN_WORKTREE_ID;
   if (!repoId || !worktreeId) {
-    try {
-      const configPath = join4(projectPath, ".codebyplan.json");
-      const raw = await readFile4(configPath, "utf-8");
-      const config = JSON.parse(raw);
-      if (!repoId) repoId = config.repo_id;
-      if (!worktreeId) worktreeId = config.worktree_id;
-    } catch {
+    const found = await findCodebyplanConfig(projectPath);
+    if (found) {
+      if (!repoId) repoId = found.contents.repo_id;
+      if (!worktreeId) worktreeId = found.contents.worktree_id;
     }
   }
   if (!repoId) {
@@ -1015,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);
@@ -1046,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;
 }
@@ -1086,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");
@@ -1109,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, {
@@ -1136,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 });
@@ -1155,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 {
@@ -1164,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);
@@ -1175,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 });
@@ -1194,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;
@@ -1215,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, {
@@ -1229,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;
   }
@@ -1244,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(
@@ -1576,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);
@@ -1590,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);
@@ -1605,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);
@@ -1615,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 });
             }
           }
@@ -1633,12 +1712,77 @@ async function discoverMonorepoApps(projectPath) {
   }
   return apps;
 }
+async function hasJsxFile(dir, depth = 0) {
+  if (depth > 6) return false;
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const name = entry.name;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
+        if (await hasJsxFile(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;
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return false;
+    }
+    console.error(
+      `detectCapabilities: readdir failed for ${dir}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return false;
+}
+async function detectCapabilities(dirPath, pkgJson) {
+  const caps = /* @__PURE__ */ new Set();
+  for (const sub of JSX_SCAN_DIRS) {
+    if (await hasJsxFile(join7(dirPath, sub))) {
+      caps.add("jsx");
+      break;
+    }
+  }
+  if (pkgJson) {
+    const allDeps = {
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    };
+    for (const dep of Object.keys(allDeps)) {
+      if (SERVER_FRAMEWORK_DEPS.has(dep)) {
+        caps.add("node-server");
+        break;
+      }
+    }
+    if (!caps.has("node-server") && typeof pkgJson.main === "string") {
+      if (SERVER_MAIN_ENTRIES.has(pkgJson.main.trim())) {
+        caps.add("node-server");
+      }
+    }
+  }
+  if (!caps.has("node-server") && await fileExists(join7(dirPath, "src", "main.ts"))) {
+    caps.add("node-server");
+  }
+  if (pkgJson && pkgJson.bin) {
+    if (typeof pkgJson.bin === "string" && pkgJson.bin.trim().length > 0) {
+      caps.add("cli-bin");
+    } else if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && Object.keys(pkgJson.bin).length > 0) {
+      caps.add("cli-bin");
+    }
+  }
+  return caps;
+}
 async function detectFromDirectory(dirPath) {
   const seen = /* @__PURE__ */ new Map();
+  let pkgJson = null;
   try {
-    const raw = await readFile6(join6(dirPath, "package.json"), "utf-8");
-    const pkg = JSON.parse(raw);
-    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const raw = await readFile7(join7(dirPath, "package.json"), "utf-8");
+    pkgJson = JSON.parse(raw);
+    const allDeps = {
+      ...pkgJson.dependencies ?? {},
+      ...pkgJson.devDependencies ?? {}
+    };
     for (const depName of Object.keys(allDeps)) {
       const rule = PACKAGE_MAP[depName];
       if (rule) {
@@ -1665,15 +1809,44 @@ 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 });
     }
   }
-  return Array.from(seen.values()).sort((a, b) => {
-    const catCmp = a.category.localeCompare(b.category);
-    if (catCmp !== 0) return catCmp;
-    return a.name.localeCompare(b.name);
+  const capabilities = await detectCapabilities(dirPath, pkgJson);
+  const capsArray = Array.from(capabilities).sort();
+  const entries = Array.from(seen.values()).map((entry) => {
+    const isBearer = CAPABILITY_BEARER_NAMES.has(entry.name.toLowerCase());
+    return {
+      ...entry,
+      capabilities: isBearer ? capsArray : []
+    };
   });
+  if (capsArray.length > 0) {
+    const hasBearerWithCaps = entries.some(
+      (e) => CAPABILITY_BEARER_NAMES.has(e.name.toLowerCase()) && (e.capabilities?.some((c) => c.length > 0) ?? false)
+    );
+    if (!hasBearerWithCaps) {
+      entries.push({
+        name: SYNTHETIC_CARRIER_NAME,
+        category: "tool",
+        capabilities: capsArray
+      });
+    }
+  }
+  return entries.sort(compareByCategoryThenName);
+}
+function collectCapabilities(entries) {
+  const set = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.capabilities) continue;
+    for (const cap of entry.capabilities) {
+      if (typeof cap === "string" && cap.length > 0) {
+        set.add(cap.toLowerCase());
+      }
+    }
+  }
+  return Array.from(set).sort();
 }
 async function detectTechStack(projectPath) {
   const repo = await detectFromDirectory(projectPath);
@@ -1692,40 +1865,80 @@ async function detectTechStack(projectPath) {
   for (const app of apps) {
     for (const entry of app.stack) {
       const key = entry.name.toLowerCase();
-      if (!flatMap.has(key)) {
+      const existing = flatMap.get(key);
+      if (!existing) {
         flatMap.set(key, entry);
+      } else if (entry.capabilities?.length) {
+        const merged = Array.from(
+          /* @__PURE__ */ new Set([...existing.capabilities ?? [], ...entry.capabilities])
+        ).sort();
+        flatMap.set(key, { ...existing, capabilities: merged });
       }
     }
   }
-  const flat = Array.from(flatMap.values()).sort((a, b) => {
-    const catCmp = a.category.localeCompare(b.category);
-    if (catCmp !== 0) return catCmp;
-    return a.name.localeCompare(b.name);
-  });
-  return { repo, apps, flat };
+  const repoCleaned = stripSyntheticIfCovered(repo).sort(
+    compareByCategoryThenName
+  );
+  const appsCleaned = apps.map((a) => ({
+    ...a,
+    stack: stripSyntheticIfCovered(a.stack).sort(compareByCategoryThenName)
+  }));
+  const flat = stripSyntheticIfCovered(Array.from(flatMap.values())).sort(
+    compareByCategoryThenName
+  );
+  return { repo: repoCleaned, apps: appsCleaned, flat };
+}
+function stripSyntheticIfCovered(entries) {
+  const synth = entries.find((e) => e.name === SYNTHETIC_CARRIER_NAME);
+  if (!synth?.capabilities?.length) return entries;
+  const realBearerCaps = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.name === SYNTHETIC_CARRIER_NAME) continue;
+    for (const c of e.capabilities ?? []) realBearerCaps.add(c);
+  }
+  if (synth.capabilities.every((c) => realBearerCaps.has(c))) {
+    return entries.filter((e) => e.name !== SYNTHETIC_CARRIER_NAME);
+  }
+  return entries;
 }
 function mergeTechStack(remote, detected) {
-  const remoteResult = Array.isArray(remote) ? { repo: remote, apps: [], flat: remote } : remote;
+  const stripCarrier = (e) => e.name !== SYNTHETIC_CARRIER_NAME;
+  const cleanDetected = {
+    repo: detected.repo.filter(stripCarrier),
+    apps: detected.apps.map((a) => ({
+      ...a,
+      stack: a.stack.filter(stripCarrier)
+    })),
+    flat: detected.flat.filter(stripCarrier)
+  };
+  const remoteResult = Array.isArray(remote) ? {
+    repo: remote.filter(stripCarrier),
+    apps: [],
+    flat: remote.filter(stripCarrier)
+  } : {
+    repo: remote.repo.filter(stripCarrier),
+    apps: remote.apps.map((a) => ({
+      ...a,
+      stack: a.stack.filter(stripCarrier)
+    })),
+    flat: remote.flat.filter(stripCarrier)
+  };
   const seen = /* @__PURE__ */ new Map();
   for (const entry of remoteResult.flat) {
     seen.set(entry.name.toLowerCase(), entry);
   }
   const added = [];
-  for (const entry of detected.flat) {
+  for (const entry of cleanDetected.flat) {
     const key = entry.name.toLowerCase();
     if (!seen.has(key)) {
       seen.set(key, entry);
       added.push(entry);
     }
   }
-  const flat = Array.from(seen.values()).sort((a, b) => {
-    const catCmp = a.category.localeCompare(b.category);
-    if (catCmp !== 0) return catCmp;
-    return a.name.localeCompare(b.name);
-  });
+  const flat = Array.from(seen.values()).sort(compareByCategoryThenName);
   const merged = {
-    repo: detected.repo,
-    apps: detected.apps,
+    repo: cleanDetected.repo,
+    apps: cleanDetected.apps,
     flat
   };
   return { merged, added };
@@ -1774,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);
   }
@@ -1783,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
       );
@@ -1798,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 = [
@@ -1825,7 +2038,7 @@ async function scanAllDependencies(projectPath) {
   }
   return { dependencies };
 }
-var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SKIP_DIRS;
+var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SYNTHETIC_CARRIER_NAME, CAPABILITY_BEARER_NAMES, JSX_TEST_PATTERN, JSX_SKIP_DIRS, JSX_SCAN_DIRS, SERVER_MAIN_ENTRIES, SERVER_FRAMEWORK_DEPS, compareByCategoryThenName, SKIP_DIRS;
 var init_tech_detect = __esm({
   "src/lib/tech-detect.ts"() {
     "use strict";
@@ -1841,6 +2054,7 @@ var init_tech_detect = __esm({
       svelte: { name: "Svelte", category: "framework" },
       astro: { name: "Astro", category: "framework" },
       "@angular/core": { name: "Angular", category: "framework" },
+      "@nestjs/core": { name: "NestJS", category: "framework" },
       // Libraries (UI)
       react: { name: "React", category: "framework" },
       vue: { name: "Vue", category: "framework" },
@@ -1955,6 +2169,47 @@ var init_tech_detect = __esm({
       { file: "nx.json", rule: { name: "Nx", category: "build" } },
       { file: "lerna.json", rule: { name: "Lerna", category: "build" } }
     ];
+    SYNTHETIC_CARRIER_NAME = "__capabilities__";
+    CAPABILITY_BEARER_NAMES = /* @__PURE__ */ new Set([
+      "react",
+      "next.js",
+      "vue",
+      "svelte",
+      "solid",
+      "preact",
+      "remix",
+      "astro",
+      "angular",
+      "nestjs",
+      "nuxt",
+      "gatsby",
+      "express",
+      "fastify",
+      "hono",
+      "react native",
+      "expo"
+    ]);
+    JSX_TEST_PATTERN = /\.(test|spec)\.(tsx|jsx)$/;
+    JSX_SKIP_DIRS = /* @__PURE__ */ new Set(["__tests__", "test", "tests"]);
+    JSX_SCAN_DIRS = ["src", "app", "pages"];
+    SERVER_MAIN_ENTRIES = /* @__PURE__ */ new Set([
+      "dist/main.js",
+      "dist/server.js",
+      "dist/index.js",
+      "main.js",
+      "server.js"
+    ]);
+    SERVER_FRAMEWORK_DEPS = /* @__PURE__ */ new Set([
+      "@nestjs/core",
+      "express",
+      "fastify",
+      "hono"
+    ]);
+    compareByCategoryThenName = (a, b) => {
+      const catCmp = a.category.localeCompare(b.category);
+      if (catCmp !== 0) return catCmp;
+      return a.name.localeCompare(b.name);
+    };
     SKIP_DIRS = /* @__PURE__ */ new Set([
       "node_modules",
       ".next",
@@ -2005,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)) {
@@ -2032,30 +2287,65 @@ async function verifyPorts(projectPath, portAllocations) {
   }
   return mismatches;
 }
+function isDevServerScript(pkg) {
+  const scripts = pkg.scripts;
+  const raw = scripts?.dev;
+  if (!raw || typeof raw !== "string") return false;
+  const script = raw.trim().toLowerCase();
+  if (!script) return false;
+  for (const pattern of DEV_SERVER_BIN_PATTERNS) {
+    if (pattern.test(script)) return true;
+  }
+  const tokens = script.split(/\s+/);
+  for (const token of tokens) {
+    if (token === "--port" || token === "-p") return true;
+    if (token.startsWith("--port=")) return true;
+  }
+  return false;
+}
+function labelMatchesAppName(label, appName) {
+  if (!label || !appName) return false;
+  const normalize = (s) => s.toLowerCase().replace(/-/g, " ").replace(/[()]/g, " ").replace(/\s+/g, " ").trim();
+  const labelTokens = normalize(label).split(" ").filter(Boolean);
+  const appToken = normalize(appName);
+  if (!appToken) return false;
+  const appTokens = appToken.split(" ").filter(Boolean);
+  if (appTokens.length === 1) {
+    return labelTokens.includes(appTokens[0]);
+  }
+  for (let i = 0; i <= labelTokens.length - appTokens.length; i++) {
+    if (appTokens.every((t, j) => labelTokens[i + j] === t)) return true;
+  }
+  return false;
+}
 async function findUnallocatedApps(projectPath, portAllocations) {
   const apps = await discoverMonorepoApps(projectPath);
   if (apps.length === 0) {
     return [];
   }
-  const allocatedLabels = new Set(portAllocations.map((a) => a.label));
   const unallocated = [];
   for (const app of apps) {
-    if (allocatedLabels.has(app.name)) continue;
+    if (portAllocations.some((a) => labelMatchesAppName(a.label ?? "", app.name))) {
+      continue;
+    }
+    let pkg;
     try {
-      const raw = await readFile7(`${app.absPath}/package.json`, "utf-8");
-      const pkg = JSON.parse(raw);
-      const framework = detectFramework(pkg);
-      const detectedPort = detectPortFromScripts(pkg);
-      const command = `pnpm --filter ${app.name} dev`;
-      unallocated.push({
-        name: app.name,
-        path: app.path,
-        framework,
-        detectedPort,
-        command
-      });
+      const raw = await readFile8(`${app.absPath}/package.json`, "utf-8");
+      pkg = JSON.parse(raw);
     } catch {
+      continue;
     }
+    if (!isDevServerScript(pkg)) continue;
+    const framework = detectFramework(pkg);
+    const detectedPort = detectPortFromScripts(pkg);
+    const command = `pnpm --filter ${app.name} dev`;
+    unallocated.push({
+      name: app.name,
+      path: app.path,
+      framework,
+      detectedPort,
+      command
+    });
   }
   return unallocated;
 }
@@ -2066,16 +2356,46 @@ function getAppLabel(relativePath) {
   }
   return "root";
 }
+var DEV_SERVER_BIN_PATTERNS;
 var init_port_verify = __esm({
   "src/lib/port-verify.ts"() {
     "use strict";
     init_tech_detect();
     init_server_detect();
+    DEV_SERVER_BIN_PATTERNS = [
+      /\bnext\s+dev\b/,
+      /\bnest\s+start\b/,
+      /\bvite\s+(?:dev|serve)\b/,
+      /\bvite\s+preview\b/,
+      /\bnuxt\s+dev\b/,
+      /\b(?:svelte-kit|sveltekit)\s+dev\b/,
+      /\bexpo\s+start\b/
+    ];
   }
 });
 
 // src/lib/eslint-generator.ts
 import { createHash } from "node:crypto";
+function importedIdentifiers(importLines) {
+  const names = /* @__PURE__ */ new Set();
+  for (const line of importLines) {
+    let m = line.match(/^import\s+([A-Za-z_$][\w$]*)\s+from/);
+    if (m) names.add(m[1]);
+    m = line.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from/);
+    if (m) names.add(m[1]);
+    m = line.match(/^import\s*\{([^}]*)\}\s*from/);
+    if (m) {
+      for (const entry of m[1].split(",")) {
+        const parts = entry.trim().split(/\s+as\s+/);
+        const n = (parts[1] ?? parts[0]).trim();
+        if (n) names.add(n);
+      }
+    }
+    m = line.match(/^const\s+([A-Za-z_$][\w$]*)\s*=\s*require/);
+    if (m) names.add(m[1]);
+  }
+  return names;
+}
 function parseFragment(fragment) {
   if (!fragment) return { imports: [], configComments: [] };
   const lines = fragment.split("\n");
@@ -2125,7 +2445,7 @@ function collectDependencies(presets) {
 function hashConfig(content) {
   return createHash("sha256").update(content).digest("hex");
 }
-function buildRules(presets, userOverrides) {
+function buildRules(presets) {
   const merged = {};
   for (const preset of presets) {
     const rules = preset.rules;
@@ -2133,11 +2453,30 @@ function buildRules(presets, userOverrides) {
       Object.assign(merged, rules);
     }
   }
-  if (userOverrides) {
-    Object.assign(merged, userOverrides);
-  }
   return merged;
 }
+function splitRulesByPlugin(rules, hasNextJs) {
+  const reactHooks = {};
+  const reactOrA11y = {};
+  const importPlugin = {};
+  const generic = {};
+  for (const [key, value] of Object.entries(rules)) {
+    if (key.startsWith("react-hooks/") || key.startsWith("react-compiler/")) {
+      reactHooks[key] = value;
+    } else if (key.startsWith("react/") || key.startsWith("jsx-a11y/")) {
+      reactOrA11y[key] = value;
+    } else if (key.startsWith("import/")) {
+      if (hasNextJs) {
+        importPlugin[key] = value;
+      } else {
+        generic[key] = value;
+      }
+    } else {
+      generic[key] = value;
+    }
+  }
+  return { reactHooks, reactOrA11y, importPlugin, generic };
+}
 function formatRules(rules, indent) {
   const entries = Object.entries(rules);
   if (entries.length === 0) return "{}";
@@ -2151,6 +2490,7 @@ ${indent}}`;
 }
 function generateEslintConfig(input) {
   const { presets, ruleOverrides, tsconfigRootDir, ignorePatterns } = input;
+  const hasNextJs = presets.some((p) => p.is_system && p.name === "nextjs");
   const allImports = [];
   const allConfigComments = [];
   for (const preset of presets) {
@@ -2163,7 +2503,14 @@ function generateEslintConfig(input) {
   const dedupedImports = deduplicateImports(allImports);
   const tsCheck = dedupedImports.find((i) => i === "// @ts-check");
   const importLines = dedupedImports.filter((i) => i !== "// @ts-check");
-  const rules = buildRules(presets, ruleOverrides);
+  const presetRules = buildRules(presets);
+  const userOverrides = ruleOverrides ?? {};
+  const presetRulesClean = Object.fromEntries(
+    Object.entries(presetRules).filter(
+      ([k]) => !Object.hasOwn(userOverrides, k)
+    )
+  );
+  const splitRules = splitRulesByPlugin(presetRulesClean, hasNextJs);
   const defaultIgnores = [
     "eslint.config.mjs",
     "node_modules/**",
@@ -2174,7 +2521,24 @@ function generateEslintConfig(input) {
   const ignores = [.../* @__PURE__ */ new Set([...defaultIgnores, ...ignorePatterns ?? []])];
   const rootDir = tsconfigRootDir ?? "import.meta.dirname";
   const rootDirValue = rootDir === "import.meta.dirname" ? "import.meta.dirname" : `"${rootDir}"`;
-  const hasNextJs = presets.some((p) => p.is_system && p.name === "nextjs");
+  const KNOWN_SYSTEM_PRESETS = [
+    "base",
+    "react",
+    "nextjs",
+    "node",
+    "cli",
+    "testing",
+    "testing-react",
+    "testing-e2e"
+  ];
+  for (const preset of presets) {
+    if (preset.is_system && !KNOWN_SYSTEM_PRESETS.includes(preset.name) && !warnedPresetNames.has(preset.name)) {
+      console.warn(
+        `Unknown system preset: ${preset.name} \u2014 skipping structural emission`
+      );
+      warnedPresetNames.add(preset.name);
+    }
+  }
   const hasReact = presets.some((p) => p.is_system && p.name === "react");
   const hasNode = presets.some((p) => p.is_system && p.name === "node");
   const hasTesting = presets.some((p) => p.is_system && p.name === "testing");
@@ -2204,8 +2568,9 @@ function generateEslintConfig(input) {
   if ((hasNode || hasReact || hasNextJs) && !hasGlobalsImport) {
     sections.push('import globals from "globals";');
   }
+  sections.push('import { defineConfig } from "eslint/config";');
   sections.push("");
-  sections.push("export default [");
+  sections.push("export default defineConfig([");
   sections.push(`  { ignores: ${JSON.stringify(ignores)} },`);
   sections.push("");
   const hasBase = presets.some((p) => p.is_system && p.name === "base");
@@ -2226,11 +2591,43 @@ function generateEslintConfig(input) {
     sections.push("");
   }
   if (hasNextJs) {
+    const bindings = importedIdentifiers(importLines);
+    const nextFusedRules = {
+      ...splitRules.reactHooks,
+      ...splitRules.importPlugin
+    };
     sections.push("  // Next.js: Core Web Vitals + TypeScript");
     sections.push("  ...nextCoreWebVitals,");
     sections.push("  ...nextTypescript,");
-    sections.push("  { rules: jsxA11y.flatConfigs.strict.rules },");
-    sections.push('  { plugins: { "react-compiler": reactCompiler } },');
+    if (bindings.has("jsxA11y")) {
+      sections.push("  { rules: jsxA11y.flatConfigs.strict.rules },");
+    } else {
+      console.warn(
+        "eslint-generator: skipping `jsxA11y.flatConfigs.strict.rules` emission \u2014 `jsxA11y` binding missing from nextjs preset config_fragment. See CHK-087 TASK-4/TASK-5."
+      );
+    }
+    if (Object.keys(nextFusedRules).length > 0) {
+      sections.push("  {");
+      sections.push('    plugins: { "react-compiler": reactCompiler },');
+      sections.push(`    rules: ${formatRules(nextFusedRules, "    ")},`);
+      sections.push("  },");
+    } else {
+      sections.push('  { plugins: { "react-compiler": reactCompiler } },');
+    }
+    if (Object.keys(splitRules.reactOrA11y).length > 0) {
+      if (bindings.has("react") && bindings.has("jsxA11y")) {
+        sections.push("  {");
+        sections.push('    plugins: { react, "jsx-a11y": jsxA11y },');
+        sections.push(
+          `    rules: ${formatRules(splitRules.reactOrA11y, "    ")},`
+        );
+        sections.push("  },");
+      } else {
+        console.warn(
+          "eslint-generator: skipping defensive reactOrA11y block \u2014 requires both `react` and `jsxA11y` bindings from nextjs preset config_fragment. See CHK-087 TASK-4/TASK-5."
+        );
+      }
+    }
     sections.push("");
   }
   if (hasReact && !hasNextJs) {
@@ -2250,6 +2647,12 @@ function generateEslintConfig(input) {
     sections.push("    rules: {");
     sections.push("      ...react.configs.flat.recommended.rules,");
     sections.push('      ...react.configs.flat["jsx-runtime"].rules,');
+    for (const [key, value] of Object.entries(splitRules.reactHooks)) {
+      sections.push(`      "${key}": ${JSON.stringify(value)},`);
+    }
+    for (const [key, value] of Object.entries(splitRules.reactOrA11y)) {
+      sections.push(`      "${key}": ${JSON.stringify(value)},`);
+    }
     sections.push("    },");
     sections.push("  },");
     sections.push("  jsxA11y.flatConfigs.strict,");
@@ -2270,10 +2673,14 @@ function generateEslintConfig(input) {
     sections.push("  prettier,");
     sections.push("");
   }
-  if (Object.keys(rules).length > 0) {
+  const overridesCombined = {
+    ...splitRules.generic,
+    ...userOverrides
+  };
+  if (Object.keys(overridesCombined).length > 0) {
     sections.push("  // Rule overrides");
     sections.push("  {");
-    sections.push(`    rules: ${formatRules(rules, "    ")},`);
+    sections.push(`    rules: ${formatRules(overridesCombined, "    ")},`);
     sections.push("  },");
     sections.push("");
   }
@@ -2335,26 +2742,29 @@ function generateEslintConfig(input) {
     sections.push("  },");
     sections.push("");
   }
-  sections.push("];");
+  sections.push("]);");
   sections.push("");
   return sections.join("\n");
 }
+var warnedPresetNames;
 var init_eslint_generator = __esm({
   "src/lib/eslint-generator.ts"() {
     "use strict";
+    warnedPresetNames = /* @__PURE__ */ new Set();
   }
 });
 
 // src/cli/eslint.ts
 var eslint_exports = {};
 __export(eslint_exports, {
+  autoDetectIgnorePatterns: () => autoDetectIgnorePatterns,
   checkEslintDrift: () => checkEslintDrift,
   eslintInit: () => eslintInit,
   eslintSync: () => eslintSync,
   runEslint: () => runEslint
 });
-import { readFile as readFile8, writeFile as writeFile3, access as access2 } 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);
@@ -2363,16 +2773,56 @@ async function fileExists2(filePath) {
     return false;
   }
 }
+async function autoDetectIgnorePatterns(absPath) {
+  const patterns = [];
+  if (await fileExists2(join8(absPath, "esbuild.js"))) {
+    patterns.push("esbuild.js");
+  }
+  let entries = [];
+  try {
+    entries = await readdir5(absPath);
+  } catch (err) {
+    console.error(
+      `  autoDetectIgnorePatterns: failed to read ${absPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    entries = [];
+  }
+  const esbuildVariant = /^esbuild\.[^.]+\.(mjs|cjs|js)$/;
+  for (const name of entries) {
+    if (esbuildVariant.test(name)) {
+      patterns.push(name);
+    }
+  }
+  for (const ext of ["ts", "mts", "js", "mjs"]) {
+    const candidate = `vitest.config.${ext}`;
+    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(join8(absPath, candidate))) {
+      patterns.push(candidate);
+      break;
+    }
+  }
+  if (await fileExists2(join8(absPath, "tauri.conf.json"))) {
+    patterns.push("src-tauri/**");
+    patterns.push("**/*.d.ts");
+  }
+  return patterns;
+}
 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);
@@ -2393,11 +2843,13 @@ function buildInstallCommand(pm, packages, workspaceRoot) {
       return `npm install -D ${pkgStr}`;
   }
 }
-async function resolvePresetsForTechStack(techNames) {
+async function resolvePresetsForTechStack(techNames, capabilities = []) {
   const techParam = techNames.join(",");
-  const res = await apiGet("/eslint-presets", {
-    tech_stack: techParam
-  });
+  const query = { tech_stack: techParam };
+  if (capabilities.length > 0) {
+    query.capabilities = capabilities.join(",");
+  }
+  const res = await apiGet("/eslint-presets", query);
   return res.data ?? [];
 }
 async function eslintInit(repoId, projectPath) {
@@ -2432,19 +2884,27 @@ async function eslintInit(repoId, projectPath) {
   const allRequiredDeps = /* @__PURE__ */ new Map();
   const configsToWrite = [];
   for (const target of targets) {
-    const techNames = target.techStack.map((t) => t.name);
+    const techNames = target.techStack.map((t) => t.name).filter((n) => n !== SYNTHETIC_CARRIER_NAME);
+    const capabilities = collectCapabilities(target.techStack);
     console.log(
       `  ${target.name}: ${techNames.length > 0 ? techNames.join(", ") : "(no tech detected)"}`
     );
-    if (techNames.length === 0) {
-      console.log(`    Skipping \u2014 no tech stack detected.
-`);
+    if (capabilities.length > 0) {
+      console.log(`    Capabilities: ${capabilities.join(", ")}`);
+    }
+    if (techNames.length === 0 && capabilities.length === 0) {
+      console.log(
+        `    Skipping ${target.name}: no tech or capabilities detected
+`
+      );
       continue;
     }
-    const presets = await resolvePresetsForTechStack(techNames);
+    const presets = await resolvePresetsForTechStack(techNames, capabilities);
     if (presets.length === 0) {
-      console.log(`    No matching presets found.
-`);
+      console.log(
+        `    No preset matches ${target.name}; skipping (override via --force-preset if needed)
+`
+      );
       continue;
     }
     console.log(`    Presets: ${presets.map((p) => p.name).join(", ")}`);
@@ -2465,12 +2925,17 @@ async function eslintInit(repoId, projectPath) {
       }
     } catch {
     }
+    const detectedIgnores = await autoDetectIgnorePatterns(target.absPath);
+    if (detectedIgnores.length > 0) {
+      console.log(`    Auto-ignore: ${detectedIgnores.join(", ")}`);
+    }
     const content = generateEslintConfig({
       presets,
-      ruleOverrides: userOverrides
+      ruleOverrides: userOverrides,
+      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,
@@ -2492,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);
@@ -2548,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(
@@ -2568,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)}`
@@ -2618,18 +3083,22 @@ 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);
-    const currentPresets = await resolvePresetsForTechStack(techNames);
+    const techNames = detected.flat.map((t) => t.name).filter((n) => n !== SYNTHETIC_CARRIER_NAME);
+    const capabilities = collectCapabilities(detected.flat);
+    const currentPresets = await resolvePresetsForTechStack(
+      techNames,
+      capabilities
+    );
     const currentPresetIds = currentPresets.map((p) => p.id).sort();
     const savedPresetIds = [...config.active_preset_ids ?? []].sort();
     const presetsChanged = currentPresetIds.length !== savedPresetIds.length || currentPresetIds.some((id) => !savedPresetIds.includes(id));
     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(
@@ -2651,14 +3120,18 @@ async function eslintSync(repoId, projectPath) {
         );
       }
     }
-    console.log(`  ${config.source_path}: presets changed, regenerating...`);
+    if (presetsChanged) {
+      console.log(`  ${config.source_path}: presets changed, regenerating...`);
+    }
     const userOverrides = config.rule_overrides;
+    const detectedIgnores = await autoDetectIgnorePatterns(absPath);
     const content = generateEslintConfig({
       presets: currentPresets,
-      ruleOverrides: userOverrides && Object.keys(userOverrides).length > 0 ? userOverrides : void 0
+      ruleOverrides: userOverrides && Object.keys(userOverrides).length > 0 ? userOverrides : void 0,
+      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)}`
@@ -2694,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;
@@ -2750,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");
 }
@@ -2819,11 +3292,14 @@ 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);
-  } catch {
+  } catch (err) {
+    console.warn(
+      `  Local file scan incomplete: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
   const [defaultsRes, repoSyncRes, repoRes, , fileReposRes] = await Promise.all(
     [
@@ -3051,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);
         }
       }
@@ -3142,7 +3618,10 @@ async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
             repo_id: repoId,
             file_repos: fileRepoUpdates
           });
-        } catch {
+        } catch (err) {
+          console.warn(
+            `  Warning: failed to update file-repo tracking for ${fileRepoUpdates.length} files: ${err instanceof Error ? err.message : String(err)}`
+          );
         }
       }
       console.log(
@@ -3202,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) {
@@ -3222,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 {
   }
@@ -3241,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) {
@@ -3253,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 = [];
@@ -3298,7 +3789,10 @@ async function syncConfig(repoId, projectPath, dryRun) {
       }
       return clean;
     });
-  } catch {
+  } catch (err) {
+    console.warn(
+      `  Warning: failed to fetch port allocations: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
   const worktreeId = currentConfig.worktree_id;
   const matchingAlloc = portAllocations[0];
@@ -3329,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) {
@@ -3363,8 +3857,10 @@ async function syncTechStack(repoId, projectPath, dryRun) {
         }
       }
     }
-  } catch {
-    console.log("    Tech stack detection skipped.");
+  } catch (err) {
+    console.warn(
+      `    Tech stack detection skipped: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 async function syncEslintDriftCheck(repoId, projectPath) {
@@ -3442,8 +3938,10 @@ async function syncPortVerification(repoId, projectPath, dryRun, fix) {
     if (mismatches.length === 0 && unallocated.length === 0) {
       console.log("    Ports verified.");
     }
-  } catch {
-    console.log("    Port verification skipped.");
+  } catch (err) {
+    console.warn(
+      `    Port verification skipped: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 function groupByType(items) {
@@ -3477,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.1";
+    return "1.4.3";
   } catch {
     return "unknown";
   }
@@ -3547,6 +4045,7 @@ var init_sync = __esm({
     init_settings_merge();
     init_hook_registry();
     init_port_verify();
+    init_resolve_worktree();
     init_eslint();
   }
 });
@@ -3554,68 +4053,69 @@ var init_sync = __esm({
 // src/index.ts
 init_version();
 import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-if (!process.env.CODEBYPLAN_API_KEY) {
-  try {
-    const envPath = resolve(process.cwd(), ".env.local");
-    const content = readFileSync(envPath, "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eq = trimmed.indexOf("=");
-      if (eq === -1) continue;
-      const key = trimmed.slice(0, eq).trim();
-      const val = trimmed.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
-      if (!process.env[key]) process.env[key] = val;
+import { resolve as resolve2 } from "node:path";
+void (async () => {
+  if (!process.env.CODEBYPLAN_API_KEY) {
+    try {
+      const envPath = resolve2(process.cwd(), ".env.local");
+      const content = readFileSync(envPath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1) continue;
+        const key = trimmed.slice(0, eq).trim();
+        const val = trimmed.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+        if (!process.env[key]) process.env[key] = val;
+      }
+    } catch {
     }
-  } catch {
   }
-}
-if (process.env.CODEBYPLAN_API_KEY?.startsWith("CODEBYPLAN_API_KEY=")) {
-  process.env.CODEBYPLAN_API_KEY = process.env.CODEBYPLAN_API_KEY.slice(
-    "CODEBYPLAN_API_KEY=".length
-  );
-}
-var arg = process.argv[2];
-if (arg === "--version" || arg === "-v") {
-  console.log(VERSION);
-  process.exit(0);
-}
-if (arg === "setup") {
-  const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
-  await runSetup2();
-  process.exit(0);
-}
-if (arg === "sync") {
-  const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
-  const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
-  try {
-    await runSync2();
-  } catch (err) {
-    if (err instanceof SyncCancelledError2) {
-      console.log("\n  Sync cancelled.\n");
-      process.exit(0);
+  if (process.env.CODEBYPLAN_API_KEY?.startsWith("CODEBYPLAN_API_KEY=")) {
+    process.env.CODEBYPLAN_API_KEY = process.env.CODEBYPLAN_API_KEY.slice(
+      "CODEBYPLAN_API_KEY=".length
+    );
+  }
+  const arg = process.argv[2];
+  if (arg === "--version" || arg === "-v") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (arg === "setup") {
+    const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+    await runSetup2();
+    process.exit(0);
+  }
+  if (arg === "sync") {
+    const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
+    try {
+      await runSync2();
+    } catch (err) {
+      if (err instanceof SyncCancelledError2) {
+        console.log("\n  Sync cancelled.\n");
+        process.exit(0);
+      }
+      throw err;
     }
-    throw err;
+    process.exit(0);
   }
-  process.exit(0);
-}
-if (arg === "eslint") {
-  const { runEslint: runEslint2 } = await Promise.resolve().then(() => (init_eslint(), eslint_exports));
-  const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
-  try {
-    await runEslint2();
-  } catch (err) {
-    if (err instanceof SyncCancelledError2) {
-      console.log("\n  Cancelled.\n");
-      process.exit(0);
+  if (arg === "eslint") {
+    const { runEslint: runEslint2 } = await Promise.resolve().then(() => (init_eslint(), eslint_exports));
+    const { SyncCancelledError: SyncCancelledError2 } = await Promise.resolve().then(() => (init_confirm(), confirm_exports));
+    try {
+      await runEslint2();
+    } catch (err) {
+      if (err instanceof SyncCancelledError2) {
+        console.log("\n  Cancelled.\n");
+        process.exit(0);
+      }
+      throw err;
     }
-    throw err;
+    process.exit(0);
   }
-  process.exit(0);
-}
-if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
-  console.log(`
+  if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
+    console.log(`
   CodeByPlan CLI v${VERSION}
 
   Usage:
@@ -3638,13 +4138,14 @@ if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
 
   MCP Server:
     Claude Code connects to CodeByPlan via remote MCP:
-      URL: https://codebyplan.com/mcp
+      URL: https://www.codebyplan.com/mcp
       Auth: x-api-key header (configured during setup)
 
   Learn more: https://codebyplan.com
 `);
-  process.exit(0);
-}
-console.error(`Unknown command: ${arg}`);
-console.error("Run 'codebyplan help' for usage.");
-process.exit(1);
+    process.exit(0);
+  }
+  console.error(`Unknown command: ${arg}`);
+  console.error("Run 'codebyplan help' for usage.");
+  process.exit(1);
+})();