codebyplan 1.4.3 → 1.5.1

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.3";
+    VERSION = "1.5.1";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -117,9 +117,6 @@ async function apiPost(path, body) {
 async function apiPut(path, body) {
   return request("PUT", path, { body });
 }
-async function apiDelete(path, params) {
-  await request("DELETE", path, { params });
-}
 var API_KEY, BASE_URL, REQUEST_TIMEOUT_MS, MAX_RETRIES, BASE_DELAY_MS, ApiError;
 var init_api = __esm({
   "src/lib/api.ts"() {
@@ -198,6 +195,25 @@ async function resolveAndCacheWorktreeId(repoId, projectPath, options) {
   }
   return worktreeId;
 }
+async function resolveWorktreeId({
+  repoId,
+  repoPath,
+  branch,
+  deviceId
+}) {
+  try {
+    const res = await apiPost(
+      "/worktrees/resolve",
+      { repo_id: repoId, device_id: deviceId, repo_path: repoPath, branch }
+    );
+    return res.worktree_id ?? null;
+  } catch (err) {
+    console.error(
+      `Tuple worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
 var init_resolve_worktree = __esm({
   "src/lib/resolve-worktree.ts"() {
     "use strict";
@@ -205,630 +221,75 @@ var init_resolve_worktree = __esm({
   }
 });
 
-// src/lib/settings-merge.ts
-function mergeSettings(template, local) {
-  const merged = { ...local };
-  for (const key of TEMPLATE_MANAGED_KEYS) {
-    if (key in template) {
-      merged[key] = template[key];
-    }
-  }
-  if (template.permissions && typeof template.permissions === "object") {
-    const templatePerms = template.permissions;
-    const localPerms = local.permissions && typeof local.permissions === "object" ? local.permissions : {};
-    const mergedPerms = { ...localPerms };
-    for (const key of TEMPLATE_MANAGED_PERMISSION_KEYS) {
-      if (key in templatePerms) {
-        mergedPerms[key] = templatePerms[key];
-      }
-    }
-    merged.permissions = mergedPerms;
-  }
-  return merged;
-}
-function mergeGlobalAndRepoSettings(global, repo) {
-  const merged = { ...global, ...repo };
-  const globalPerms = global.permissions && typeof global.permissions === "object" ? global.permissions : {};
-  const repoPerms = repo.permissions && typeof repo.permissions === "object" ? repo.permissions : {};
-  if (Object.keys(globalPerms).length > 0 || Object.keys(repoPerms).length > 0) {
-    const mergedPerms = { ...globalPerms, ...repoPerms };
-    for (const key of ARRAY_PERMISSION_KEYS) {
-      const globalArr = Array.isArray(globalPerms[key]) ? globalPerms[key] : [];
-      const repoArr = Array.isArray(repoPerms[key]) ? repoPerms[key] : [];
-      if (globalArr.length > 0 || repoArr.length > 0) {
-        mergedPerms[key] = [.../* @__PURE__ */ new Set([...globalArr, ...repoArr])];
-      }
-    }
-    merged.permissions = mergedPerms;
-  }
-  return merged;
-}
-function stripPermissionsAllow(settings) {
-  if (!settings.permissions || typeof settings.permissions !== "object") {
-    return settings;
-  }
-  const perms = { ...settings.permissions };
-  delete perms.allow;
-  if (Object.keys(perms).length === 0) {
-    const { permissions: _, ...rest } = settings;
-    return rest;
-  }
-  return { ...settings, permissions: perms };
-}
-var TEMPLATE_MANAGED_KEYS, TEMPLATE_MANAGED_PERMISSION_KEYS, ARRAY_PERMISSION_KEYS;
-var init_settings_merge = __esm({
-  "src/lib/settings-merge.ts"() {
-    "use strict";
-    TEMPLATE_MANAGED_KEYS = ["attribution", "hooks", "statusLine"];
-    TEMPLATE_MANAGED_PERMISSION_KEYS = [
-      "deny",
-      "ask",
-      "additionalDirectories"
-    ];
-    ARRAY_PERMISSION_KEYS = ["deny", "ask"];
-  }
-});
-
-// src/lib/hook-registry.ts
-import { readdir, readFile as readFile2 } from "node:fs/promises";
+// src/lib/local-config.ts
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { hostname } from "node:os";
 import { join as join2 } from "node:path";
-function parseHookMeta(content) {
-  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,
-    matcher: parts.slice(1).join(" ")
-  };
+function localConfigPath(projectPath) {
+  return join2(projectPath, ".codebyplan.local.json");
 }
-async function discoverHooks(hooksDir) {
-  const discovered = /* @__PURE__ */ new Map();
-  let filenames;
+async function readLocalConfig(projectPath) {
   try {
-    const entries = await readdir(hooksDir);
-    filenames = entries.filter((e) => e.endsWith(".sh"));
-  } catch {
-    return discovered;
-  }
-  for (const filename of filenames) {
-    const content = await readFile2(join2(hooksDir, filename), "utf-8");
-    const meta = parseHookMeta(content);
-    if (meta) {
-      discovered.set(filename.replace(/\.sh$/, ""), meta);
-    }
-  }
-  return discovered;
-}
-function mergeDiscoveredHooks(existing, discovered, hooksRelPath = ".claude/hooks") {
-  if (discovered.size === 0) return existing;
-  const merged = {};
-  for (const [event, matchers] of Object.entries(existing)) {
-    merged[event] = matchers.map((m) => ({
-      matcher: m.matcher,
-      hooks: [...m.hooks]
-    }));
-  }
-  for (const [filename, meta] of discovered) {
-    const command = `bash ${hooksRelPath}/${filename}.sh`;
-    if (!merged[meta.event]) {
-      merged[meta.event] = [];
+    const raw = await readFile2(localConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.device_id === "string") {
+      return parsed;
     }
-    const eventEntries = merged[meta.event];
-    const alreadyRegistered = eventEntries.some(
-      (m) => m.hooks.some((h) => h.command === command)
+    console.error("Failed to read local config: invalid shape");
+    return null;
+  } catch (err) {
+    console.error(
+      `Failed to read local config: ${err instanceof Error ? err.message : String(err)}`
     );
-    if (alreadyRegistered) continue;
-    const matcherEntry = eventEntries.find((m) => m.matcher === meta.matcher);
-    if (matcherEntry) {
-      matcherEntry.hooks.push({ type: "command", command });
-    } else {
-      eventEntries.push({
-        matcher: meta.matcher,
-        hooks: [{ type: "command", command }]
-      });
-    }
-  }
-  return merged;
-}
-function stripDiscoveredHooks(config, hooksRelPath = ".claude/hooks") {
-  const prefix = `bash ${hooksRelPath}/`;
-  const stripped = {};
-  for (const [event, matchers] of Object.entries(config)) {
-    const filteredMatchers = [];
-    for (const matcher of matchers) {
-      const filteredHooks = matcher.hooks.filter(
-        (h) => !(h.command && h.command.startsWith(prefix) && h.command.endsWith(".sh"))
-      );
-      if (filteredHooks.length > 0) {
-        filteredMatchers.push({
-          matcher: matcher.matcher,
-          hooks: filteredHooks
-        });
-      }
-    }
-    if (filteredMatchers.length > 0) {
-      stripped[event] = filteredMatchers;
-    }
-  }
-  return stripped;
-}
-var init_hook_registry = __esm({
-  "src/lib/hook-registry.ts"() {
-    "use strict";
-  }
-});
-
-// src/lib/variables.ts
-function splitFrontmatter(content) {
-  const fmMatch = content.match(/^(---\s*\n[\s\S]*?\n---\n?)([\s\S]*)$/);
-  if (fmMatch) {
-    return { frontmatter: fmMatch[1], body: fmMatch[2] };
-  }
-  if (content.startsWith("#!/") || content.startsWith("# @")) {
-    const lines = content.split("\n");
-    let headerEnd = 0;
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].startsWith("#") || lines[i].startsWith("#!/") || lines[i].trim() === "") {
-        headerEnd = i + 1;
-      } else {
-        break;
-      }
-    }
-    return {
-      frontmatter: lines.slice(0, headerEnd).join("\n") + "\n",
-      body: lines.slice(headerEnd).join("\n")
-    };
+    return null;
   }
-  return { frontmatter: "", body: content };
 }
-function substituteVariables(content, repoData) {
-  if (!content.includes("{{")) return content;
-  const { frontmatter, body } = splitFrontmatter(content);
-  let result = body;
-  for (const [name, resolver] of Object.entries(TEMPLATE_VARIABLES)) {
-    const placeholder = `{{${name}}}`;
-    if (result.includes(placeholder)) {
-      result = result.replaceAll(placeholder, resolver(repoData));
-    }
-  }
-  return frontmatter + result;
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function reverseSubstituteVariables(content, repoData) {
-  const { frontmatter, body } = splitFrontmatter(content);
-  const entries = [];
-  for (const [name, resolver] of Object.entries(TEMPLATE_VARIABLES)) {
-    const value = resolver(repoData);
-    if (value.length === 0) continue;
-    entries.push([value, `{{${name}}}`]);
-  }
-  entries.sort((a, b) => b[0].length - a[0].length);
-  let result = body;
-  for (const [value, placeholder] of entries) {
-    if (value.length < 8) {
-      const pattern = new RegExp(`\\b${escapeRegex(value)}\\b`, "g");
-      result = result.replace(pattern, placeholder);
-    } else {
-      result = result.replaceAll(value, placeholder);
-    }
-  }
-  return frontmatter + result;
-}
-var TEMPLATE_VARIABLES;
-var init_variables = __esm({
-  "src/lib/variables.ts"() {
-    "use strict";
-    TEMPLATE_VARIABLES = {
-      REPO_ID: (repo) => repo.id,
-      REPO_NAME: (repo) => repo.name,
-      REPO_PATH: (repo) => repo.path ?? "",
-      GIT_BRANCH: (repo) => repo.git_branch ?? "development",
-      SERVER_PORT: (repo) => repo.server_port != null ? String(repo.server_port) : "",
-      SERVER_TYPE: (repo) => repo.server_type ?? "none"
-    };
-  }
-});
-
-// src/lib/sync-engine.ts
-var sync_engine_exports = {};
-__export(sync_engine_exports, {
-  executeSyncToLocal: () => executeSyncToLocal
-});
-import {
-  readdir as readdir2,
-  readFile as readFile3,
-  writeFile as writeFile2,
-  unlink,
-  mkdir,
-  rmdir,
-  chmod,
-  stat
-} from "node:fs/promises";
-import { join as join3, dirname } from "node:path";
-function getTypeDir(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 join3(typeDir, file.name, `${cfg.subfolder}${cfg.ext}`);
-  }
-  if (typeName === "command" && file.category) {
-    return join3(typeDir, file.category, `${file.name}${cfg.ext}`);
-  }
-  if (typeName === "template") {
-    return join3(typeDir, file.name);
-  }
-  return join3(typeDir, `${file.name}${cfg.ext}`);
-}
-async function readDirRecursive(dir, base = dir) {
-  const result = /* @__PURE__ */ new Map();
+async function writeLocalConfig(projectPath, config) {
+  const content = { device_id: config.device_id };
   try {
-    const entries = await readdir2(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      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 readFile3(fullPath, "utf-8");
-        result.set(relPath, fileContent);
-      }
-    }
-  } catch {
+    await writeFile2(
+      localConfigPath(projectPath),
+      JSON.stringify(content, null, 2) + "\n",
+      "utf-8"
+    );
+  } catch (err) {
+    console.error(
+      `Failed to write local config: ${err instanceof Error ? err.message : String(err)}`
+    );
+    throw err;
   }
-  return result;
 }
-async function isGitWorktree(projectPath) {
+async function resolveMachineSeed() {
   try {
-    const gitPath = join3(projectPath, ".git");
-    const info = await stat(gitPath);
-    return info.isFile();
+    const raw = await readFile2("/etc/machine-id", "utf-8");
+    const trimmed = raw.trim();
+    if (trimmed) return trimmed;
   } catch {
-    return false;
   }
-}
-async function removeEmptyParents(filePath, stopAt) {
-  let dir = dirname(filePath);
-  while (dir.length > stopAt.length && dir.startsWith(stopAt)) {
+  if (process.platform === "darwin") {
     try {
-      await rmdir(dir);
-      dir = dirname(dir);
+      const out = execSync("sysctl -n kern.uuid", { encoding: "utf-8" }).trim();
+      if (out) return out;
     } catch {
-      break;
     }
   }
+  return hostname();
 }
-async function executeSyncToLocal(options) {
-  const { repoId, projectPath, dryRun = false } = options;
-  const [syncRes, repoRes] = await Promise.all([
-    apiGet("/sync/defaults"),
-    apiGet(`/repos/${repoId}`)
-  ]);
-  const syncData = syncRes.data;
-  const repoData = repoRes.data;
-  syncData.claude_md = [];
-  const claudeDir = join3(projectPath, ".claude");
-  const worktree = await isGitWorktree(projectPath);
-  const byType = {};
-  const totals = { created: 0, updated: 0, deleted: 0, unchanged: 0 };
-  const dbOnlyFiles = [];
-  for (const [syncKey, typeName] of Object.entries(syncKeyToType)) {
-    if (worktree && typeName === "command") {
-      byType["commands"] = {
-        created: [],
-        updated: [],
-        deleted: [],
-        unchanged: []
-      };
-      continue;
-    }
-    const cfg = typeConfig[typeName];
-    const targetDir = getTypeDir(claudeDir, cfg.dir);
-    const remoteFiles = syncData[syncKey] ?? [];
-    const result = {
-      created: [],
-      updated: [],
-      deleted: [],
-      unchanged: []
-    };
-    if (!dryRun) {
-      await mkdir(targetDir, { recursive: true });
-    }
-    const localFiles = await readDirRecursive(targetDir);
-    const remotePathMap = /* @__PURE__ */ new Map();
-    for (const remote of remoteFiles) {
-      const fullPath = getFilePath(claudeDir, typeName, remote);
-      const relPath = fullPath.slice(targetDir.length + 1);
-      const substituted = substituteVariables(remote.content, repoData);
-      remotePathMap.set(relPath, { content: substituted, name: remote.name });
-    }
-    for (const [relPath, { content, name }] of remotePathMap) {
-      const fullPath = join3(targetDir, relPath);
-      const localContent = localFiles.get(relPath);
-      if (localContent === void 0) {
-        const remoteFile = remoteFiles.find((f) => f.name === name);
-        dbOnlyFiles.push({
-          type: typeName,
-          name,
-          category: remoteFile?.category ?? null,
-          localPath: fullPath
-        });
-        if (!dryRun) {
-          await mkdir(dirname(fullPath), { recursive: true });
-          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 writeFile2(fullPath, content, "utf-8");
-          if (typeName === "hook") await chmod(fullPath, 493);
-        }
-        result.updated.push(name);
-        totals.updated++;
-      } else {
-        result.unchanged.push(name);
-        totals.unchanged++;
-      }
-    }
-    for (const [relPath] of localFiles) {
-      if (!remotePathMap.has(relPath)) {
-        const fullPath = join3(targetDir, relPath);
-        if (!dryRun) {
-          await unlink(fullPath);
-          await removeEmptyParents(fullPath, targetDir);
-        }
-        const pathName = relPath.replace(/\.(md|sh)$/, "").replace(/\/(AGENT|SKILL)$/, "");
-        result.deleted.push(pathName);
-        totals.deleted++;
-      }
-    }
-    byType[`${typeName}s`] = result;
-  }
-  {
-    const typeName = "docs_stack";
-    const syncKey = "docs_stack";
-    const targetDir = join3(projectPath, "docs", "stack");
-    const remoteFiles = syncData[syncKey] ?? [];
-    const result = {
-      created: [],
-      updated: [],
-      deleted: [],
-      unchanged: []
-    };
-    if (remoteFiles.length > 0 && !dryRun) {
-      await mkdir(targetDir, { recursive: true });
-    }
-    const localFiles = await readDirRecursive(targetDir);
-    const remotePathMap = /* @__PURE__ */ new Map();
-    for (const remote of remoteFiles) {
-      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.category}/${remote.name}` : remote.name
-      });
-    }
-    for (const [relPath, { content, name }] of remotePathMap) {
-      const fullPath = join3(targetDir, relPath);
-      const localContent = localFiles.get(relPath);
-      if (localContent === void 0) {
-        if (!dryRun) {
-          await mkdir(dirname(fullPath), { recursive: true });
-          await writeFile2(fullPath, content, "utf-8");
-        }
-        result.created.push(name);
-        totals.created++;
-      } else if (localContent !== content) {
-        if (!dryRun) {
-          await writeFile2(fullPath, content, "utf-8");
-        }
-        result.updated.push(name);
-        totals.updated++;
-      } else {
-        result.unchanged.push(name);
-        totals.unchanged++;
-      }
-    }
-    for (const [relPath] of localFiles) {
-      if (!remotePathMap.has(relPath)) {
-        const fullPath = join3(targetDir, relPath);
-        if (!dryRun) {
-          await unlink(fullPath);
-          await removeEmptyParents(fullPath, targetDir);
-        }
-        result.deleted.push(relPath);
-        totals.deleted++;
-      }
-    }
-    byType[typeName] = result;
-  }
-  const globalSettingsFiles = syncData.global_settings ?? [];
-  let globalSettings = {};
-  for (const gf of globalSettingsFiles) {
-    const parsed = JSON.parse(
-      substituteVariables(gf.content, repoData)
-    );
-    globalSettings = { ...globalSettings, ...parsed };
-  }
-  const specialTypes = {
-    claude_md: () => join3(projectPath, "CLAUDE.md"),
-    settings: () => join3(projectPath, ".claude", "settings.json")
-  };
-  for (const [typeName, getPath] of Object.entries(specialTypes)) {
-    const remoteFiles = syncData[typeName] ?? [];
-    const result = {
-      created: [],
-      updated: [],
-      deleted: [],
-      unchanged: []
-    };
-    for (const remote of remoteFiles) {
-      const targetPath = getPath(remote.name);
-      const remoteContent = substituteVariables(remote.content, repoData);
-      let localContent;
-      try {
-        localContent = await readFile3(targetPath, "utf-8");
-      } catch {
-      }
-      if (typeName === "settings") {
-        const repoSettings = JSON.parse(remoteContent);
-        const combinedTemplate = mergeGlobalAndRepoSettings(
-          globalSettings,
-          repoSettings
-        );
-        const hooksDir = join3(projectPath, ".claude", "hooks");
-        const discovered = await discoverHooks(hooksDir);
-        if (localContent === void 0) {
-          const finalSettings = stripPermissionsAllow(combinedTemplate);
-          if (discovered.size > 0) {
-            finalSettings.hooks = mergeDiscoveredHooks(
-              finalSettings.hooks ?? {},
-              discovered
-            );
-          }
-          if (!dryRun) {
-            await mkdir(dirname(targetPath), { recursive: true });
-            await writeFile2(
-              targetPath,
-              JSON.stringify(finalSettings, null, 2) + "\n",
-              "utf-8"
-            );
-          }
-          result.created.push(remote.name);
-          totals.created++;
-        } else {
-          const localSettings = JSON.parse(localContent);
-          let merged = mergeSettings(combinedTemplate, localSettings);
-          merged = stripPermissionsAllow(merged);
-          if (discovered.size > 0) {
-            merged.hooks = mergeDiscoveredHooks(
-              merged.hooks ?? {},
-              discovered
-            );
-          }
-          const mergedContent = JSON.stringify(merged, null, 2) + "\n";
-          if (localContent !== mergedContent) {
-            if (!dryRun) {
-              await writeFile2(targetPath, mergedContent, "utf-8");
-            }
-            result.updated.push(remote.name);
-            totals.updated++;
-          } else {
-            result.unchanged.push(remote.name);
-            totals.unchanged++;
-          }
-        }
-      } else {
-        if (localContent === void 0) {
-          if (!dryRun) {
-            await mkdir(dirname(targetPath), { recursive: true });
-            await writeFile2(targetPath, remoteContent, "utf-8");
-          }
-          result.created.push(remote.name);
-          totals.created++;
-        } else if (localContent !== remoteContent) {
-          if (!dryRun) {
-            await writeFile2(targetPath, remoteContent, "utf-8");
-          }
-          result.updated.push(remote.name);
-          totals.updated++;
-        } else {
-          result.unchanged.push(remote.name);
-          totals.unchanged++;
-        }
-      }
-    }
-    byType[typeName] = result;
-  }
-  if (!dryRun) {
-    await apiPost("/sync/state", {
-      repo_id: repoId,
-      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
-      was_skipped: false,
-      files_synced_count: totals.created + totals.updated + totals.deleted + totals.unchanged,
-      files_pushed: 0,
-      files_pulled: totals.created + totals.updated,
-      files_deleted: totals.deleted,
-      files_skipped: 0
-    });
-    const fileRepoUpdates = [];
-    const syncTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-    for (const [syncKey, typeName] of Object.entries(syncKeyToType)) {
-      const remoteFiles = syncData[syncKey] ?? [];
-      for (const file of remoteFiles) {
-        fileRepoUpdates.push({
-          claude_file_id: file.id ?? void 0,
-          file_type: typeName,
-          file_name: file.name,
-          file_category: file.category ?? null,
-          file_scope: file.scope ?? "shared",
-          last_synced_at: syncTimestamp,
-          sync_status: "synced"
-        });
-      }
-    }
-    for (const typeName of ["claude_md", "settings"]) {
-      const remoteFiles = syncData[typeName] ?? [];
-      for (const file of remoteFiles) {
-        fileRepoUpdates.push({
-          claude_file_id: file.id ?? void 0,
-          file_type: typeName,
-          file_name: file.name,
-          file_category: file.category ?? null,
-          file_scope: file.scope ?? `local:${repoId}`,
-          last_synced_at: syncTimestamp,
-          sync_status: "synced"
-        });
-      }
-    }
-    if (fileRepoUpdates.length > 0) {
-      try {
-        await apiPost("/sync/file-repos", {
-          repo_id: repoId,
-          file_repos: fileRepoUpdates
-        });
-      } catch {
-      }
-    }
+async function getOrCreateDeviceId(projectPath) {
+  const existing = await readLocalConfig(projectPath);
+  if (existing?.device_id) {
+    return existing.device_id;
   }
-  return { byType, totals, dbOnlyFiles };
+  const seed = await resolveMachineSeed();
+  const deviceId = createHash("sha256").update(seed).digest("hex").slice(0, 16);
+  await writeLocalConfig(projectPath, { device_id: deviceId });
+  return deviceId;
 }
-var typeConfig, syncKeyToType;
-var init_sync_engine = __esm({
-  "src/lib/sync-engine.ts"() {
+var init_local_config = __esm({
+  "src/lib/local-config.ts"() {
     "use strict";
-    init_api();
-    init_settings_merge();
-    init_hook_registry();
-    init_variables();
-    typeConfig = {
-      command: { dir: "commands", ext: ".md" },
-      agent: { dir: "agents", ext: ".md", subfolder: "AGENT" },
-      skill: { dir: "skills", ext: ".md", subfolder: "SKILL" },
-      rule: { dir: "rules", ext: ".md" },
-      hook: { dir: "hooks", ext: ".sh" },
-      template: { dir: "templates", ext: "" },
-      context: { dir: "context", ext: ".md" }
-    };
-    syncKeyToType = {
-      commands: "command",
-      agents: "agent",
-      skills: "skill",
-      rules: "rule",
-      hooks: "hook",
-      templates: "template",
-      contexts: "context"
-    };
   }
 });
 
@@ -839,15 +300,15 @@ __export(setup_exports, {
 });
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join3 } from "node:path";
 function getConfigPath(scope) {
-  return scope === "user" ? join4(homedir(), ".claude.json") : join4(process.cwd(), ".mcp.json");
+  return scope === "user" ? join3(homedir(), ".claude.json") : join3(process.cwd(), ".mcp.json");
 }
 async function readConfig(path) {
   try {
-    const raw = await readFile4(path, "utf-8");
+    const raw = await readFile3(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -976,12 +437,29 @@ async function runSetup() {
   Selected: ${selectedRepo.name}
 `);
           const projectPath = process.cwd();
-          const worktreeId = await resolveAndCacheWorktreeId(
+          const pathBasedId = await resolveAndCacheWorktreeId(
             selectedRepo.id,
             projectPath,
             { skipWrite: true }
           );
-          const codebyplanPath = join4(projectPath, ".codebyplan.json");
+          const deviceId = await getOrCreateDeviceId(projectPath);
+          let branch = "main";
+          try {
+            const { execSync: execSync3 } = await import("node:child_process");
+            branch = execSync3("git symbolic-ref --short HEAD", {
+              cwd: projectPath,
+              encoding: "utf-8"
+            }).trim();
+          } catch {
+          }
+          const tupleId = await resolveWorktreeId({
+            repoId: selectedRepo.id,
+            repoPath: projectPath,
+            branch,
+            deviceId
+          });
+          const worktreeId = tupleId ?? pathBasedId;
+          const codebyplanPath = join3(projectPath, ".codebyplan.json");
           const codebyplanConfig = {
             repo_id: selectedRepo.id
           };
@@ -997,27 +475,6 @@ async function runSetup() {
               `  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));
-            const syncResult = await executeSyncToLocal2({
-              repoId: selectedRepo.id,
-              projectPath
-            });
-            const totalChanges = syncResult.totals.created + syncResult.totals.updated + syncResult.totals.deleted;
-            if (totalChanges > 0) {
-              console.log(
-                `  Synced: ${syncResult.totals.created} created, ${syncResult.totals.updated} updated, ${syncResult.totals.deleted} deleted
-`
-              );
-            } else {
-              console.log("  All files already up to date.\n");
-            }
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.log(`  Sync failed: ${msg}`);
-            console.log("  Run 'codebyplan sync' later to sync files.\n");
-          }
         }
       }
     }
@@ -1032,18 +489,19 @@ var init_setup = __esm({
   "src/cli/setup.ts"() {
     "use strict";
     init_resolve_worktree();
+    init_local_config();
   }
 });
 
-// src/cli/config.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join5, resolve } from "node:path";
+// src/cli/flags.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join4, 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");
+    const configPath = join4(cursor, ".codebyplan.json");
     try {
-      const raw = await readFile5(configPath, "utf-8");
+      const raw = await readFile4(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       return { path: configPath, contents: parsed };
     } catch {
@@ -1087,590 +545,72 @@ async function resolveConfig(flags) {
   }
   return { repoId, worktreeId, projectPath };
 }
-var init_config = __esm({
-  "src/cli/config.ts"() {
+var init_flags = __esm({
+  "src/cli/flags.ts"() {
     "use strict";
   }
 });
 
-// src/cli/fileMapper.ts
-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);
-    if (match) {
-      const raw = match[1];
-      return raw === "shared" ? "shared" : `local:${raw}`;
-    }
-    return "shared";
-  }
-  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
-  if (fmMatch) {
-    const scopeLine = fmMatch[1].match(/^scope:\s*(\S+)/m);
-    if (scopeLine) {
-      const raw = scopeLine[1];
-      return raw === "shared" ? "shared" : `local:${raw}`;
-    }
-    if (/^scope\b/m.test(fmMatch[1])) {
-      console.error(
-        `  Warning: frontmatter contains "scope" but could not parse it. Expected format: "scope: shared" or "scope: <repo-name>". Defaulting to "shared".`
-      );
-    }
-  }
-  return "shared";
-}
-function compositeKey(type, name, category) {
-  return category ? `${type}:${category}/${name}` : `${type}:${name}`;
-}
-async function scanLocalFiles(claudeDir, projectPath) {
-  const result = /* @__PURE__ */ new Map();
-  await scanCommands(join6(claudeDir, "commands", "cbp"), result);
-  await scanSubfolderType(
-    join6(claudeDir, "agents"),
-    "agent",
-    "AGENT.md",
-    result
-  );
-  await scanSubfolderType(
-    join6(claudeDir, "skills"),
-    "skill",
-    "SKILL.md",
-    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(
-    join6(claudeDir, "context"),
-    "context",
-    ".md",
-    result
-  );
-  await scanDocsRecursive(join6(claudeDir, "docs"), result);
-  await scanSettings(claudeDir, projectPath, result);
-  return result;
-}
-async function scanCommands(dir, result) {
-  await scanCommandsRecursive(dir, dir, result);
+// src/cli/confirm.ts
+var confirm_exports = {};
+__export(confirm_exports, {
+  SyncCancelledError: () => SyncCancelledError,
+  confirmProceed: () => confirmProceed
+});
+import { createInterface as createInterface2 } from "node:readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "node:process";
+function isAbortError(err) {
+  return err instanceof Error && err.code === "ABORT_ERR";
 }
-async function scanCommandsRecursive(baseDir, currentDir, result) {
-  let entries;
+async function confirmProceed(message) {
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
   try {
-    entries = await readdir3(currentDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      await scanCommandsRecursive(
-        baseDir,
-        join6(currentDir, entry.name),
-        result
+    while (true) {
+      const answer = await rl.question(message ?? "  Proceed? [Y/n] ");
+      const a = answer.trim().toLowerCase();
+      if (a === "" || a === "y" || a === "yes") return true;
+      if (a === "n" || a === "no") return false;
+      console.log(
+        `    Unknown option "${answer.trim()}". Valid: y/yes, n/no, or Enter for yes.`
       );
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      const name = entry.name.slice(0, -3);
-      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");
-      const key = compositeKey("command", name, category);
-      result.set(key, { type: "command", name, category, content, scope });
     }
+  } catch (err) {
+    if (isAbortError(err)) throw new SyncCancelledError();
+    throw err;
+  } finally {
+    rl.close();
   }
 }
-async function scanSubfolderType(dir, type, fileName, result) {
-  let entries;
-  try {
-    entries = await readdir3(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const filePath = join6(dir, entry.name, fileName);
-      try {
-        const content = await readFile6(filePath, "utf-8");
-        const scope = extractScope(content, type);
-        const key = compositeKey(type, entry.name, null);
-        result.set(key, {
-          type,
-          name: entry.name,
-          category: null,
-          content,
-          scope
-        });
-      } catch {
+var SyncCancelledError;
+var init_confirm = __esm({
+  "src/cli/confirm.ts"() {
+    "use strict";
+    SyncCancelledError = class extends Error {
+      constructor() {
+        super("Sync cancelled");
+        this.name = "SyncCancelledError";
       }
-    }
+    };
   }
-}
-async function scanFlatType(dir, type, ext, result) {
-  let entries;
+});
+
+// src/lib/tech-detect.ts
+import { readFile as readFile5, access, readdir } from "node:fs/promises";
+import { join as join5, relative } from "node:path";
+async function fileExists(filePath) {
   try {
-    entries = await readdir3(dir, { withFileTypes: true });
+    await access(filePath);
+    return true;
   } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isFile() && entry.name.endsWith(ext)) {
-      const name = entry.name.slice(0, -ext.length);
-      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 });
-    }
-  }
-}
-async function scanCategorizedType(dir, type, ext, result) {
-  let entries;
-  try {
-    entries = await readdir3(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const category = entry.name;
-      let subEntries;
-      try {
-        subEntries = await readdir3(join6(dir, category), {
-          withFileTypes: true
-        });
-      } catch {
-        continue;
-      }
-      for (const sub of subEntries) {
-        if (sub.isFile() && sub.name.endsWith(ext)) {
-          const name = sub.name.slice(0, -ext.length);
-          const content = await readFile6(
-            join6(dir, category, sub.name),
-            "utf-8"
-          );
-          const scope = extractScope(content, type);
-          const key = compositeKey(type, name, category);
-          result.set(key, { type, name, category, content, scope });
-        }
-      }
-    } else if (entry.isFile() && entry.name.endsWith(ext)) {
-      const name = entry.name.slice(0, -ext.length);
-      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 });
-    }
-  }
-}
-async function scanDocsRecursive(docsDir, result) {
-  await scanDocsDir(docsDir, docsDir, result);
-}
-async function scanDocsDir(baseDir, currentDir, result) {
-  let entries;
-  try {
-    entries = await readdir3(currentDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      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 readFile6(join6(currentDir, entry.name), "utf-8");
-      const scope = extractScope(content, "docs");
-      const relDir = currentDir.slice(baseDir.length + 1);
-      const category = relDir || null;
-      const key = compositeKey("docs", name, category);
-      result.set(key, { type: "docs", name, category, content, scope });
-    }
-  }
-}
-async function scanTemplates(dir, result) {
-  let entries;
-  try {
-    entries = await readdir3(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isFile() && extname(entry.name)) {
-      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, {
-        type: "template",
-        name: entry.name,
-        category: null,
-        content,
-        scope
-      });
-    }
-  }
-}
-async function scanSettings(claudeDir, projectPath, result) {
-  const settingsPath = join6(claudeDir, "settings.json");
-  let raw;
-  try {
-    raw = await readFile6(settingsPath, "utf-8");
-  } catch {
-    return;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return;
-  }
-  parsed = stripPermissionsAllow(parsed);
-  if (parsed.hooks && typeof parsed.hooks === "object") {
-    const hooksDir = projectPath ? join6(projectPath, ".claude", "hooks") : join6(claudeDir, "hooks");
-    const discovered = await discoverHooks(hooksDir);
-    if (discovered.size > 0) {
-      parsed.hooks = stripDiscoveredHooks(
-        parsed.hooks,
-        ".claude/hooks"
-      );
-      if (Object.keys(parsed.hooks).length === 0) {
-        delete parsed.hooks;
-      }
-    }
-  }
-  const content = JSON.stringify(parsed, null, 2) + "\n";
-  const key = compositeKey("settings", "settings", null);
-  result.set(key, {
-    type: "settings",
-    name: "settings",
-    category: null,
-    content,
-    scope: "shared"
-  });
-}
-var init_fileMapper = __esm({
-  "src/cli/fileMapper.ts"() {
-    "use strict";
-    init_settings_merge();
-    init_hook_registry();
-  }
-});
-
-// src/cli/confirm.ts
-var confirm_exports = {};
-__export(confirm_exports, {
-  SyncCancelledError: () => SyncCancelledError,
-  confirmEach: () => confirmEach,
-  confirmProceed: () => confirmProceed,
-  promptChoice: () => promptChoice,
-  promptReviewMode: () => promptReviewMode,
-  reviewFilesOneByOne: () => reviewFilesOneByOne,
-  reviewFolder: () => reviewFolder
-});
-import { createInterface as createInterface2 } from "node:readline/promises";
-import { stdin as stdin2, stdout as stdout2 } from "node:process";
-function isAbortError(err) {
-  return err instanceof Error && err.code === "ABORT_ERR";
-}
-async function confirmProceed(message) {
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  try {
-    while (true) {
-      const answer = await rl.question(message ?? "  Proceed? [Y/n] ");
-      const a = answer.trim().toLowerCase();
-      if (a === "" || a === "y" || a === "yes") return true;
-      if (a === "n" || a === "no") return false;
-      console.log(
-        `    Unknown option "${answer.trim()}". Valid: y/yes, n/no, or Enter for yes.`
-      );
-    }
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
-  }
-}
-async function promptChoice(message, options) {
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  try {
-    const answer = await rl.question(message);
-    const a = answer.trim().toLowerCase();
-    return options.includes(a) ? a : options[0];
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
-  }
-}
-async function confirmEach(items, label) {
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  const accepted = [];
-  try {
-    for (const item of items) {
-      const answer = await rl.question(`    ${label(item)} \u2014 delete? [y/n/a] `);
-      const a = answer.trim().toLowerCase();
-      if (a === "a") {
-        accepted.push(item, ...items.slice(items.indexOf(item) + 1));
-        break;
-      }
-      if (a === "y" || a === "yes" || a === "") {
-        accepted.push(item);
-      }
-    }
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
-  }
-  return accepted;
-}
-function parseReviewAction(input) {
-  const a = input.trim().toLowerCase();
-  switch (a) {
-    case "d":
-    case "delete":
-      return { action: "delete", all: false, special: null };
-    case "p":
-    case "pull":
-      return { action: "pull", all: false, special: null };
-    case "s":
-    case "push":
-      return { action: "push", all: false, special: null };
-    case "k":
-    case "skip":
-      return { action: "skip", all: false, special: null };
-    case "da":
-      return { action: "delete", all: true, special: null };
-    case "pa":
-      return { action: "pull", all: true, special: null };
-    case "sa":
-      return { action: "push", all: true, special: null };
-    case "ka":
-      return { action: "skip", all: true, special: null };
-    case "v":
-    case "view":
-      return { action: null, all: false, special: "view" };
-    case "r":
-    case "recommended":
-      return { action: null, all: false, special: "recommended" };
-    case "":
-      return { action: null, all: false, special: "recommended" };
-    // Enter = recommended
-    default:
-      return { action: null, all: false, special: null };
-  }
-}
-function formatActionPrompt(recommended, includeView, includeRecommended) {
-  const actions = [
-    `[d]elete${recommended === "delete" ? "\u2605" : ""}`,
-    `[p]ull${recommended === "pull" ? "\u2605" : ""}`,
-    `pu[s]h${recommended === "push" ? "\u2605" : ""}`,
-    `s[k]ip${recommended === "skip" ? "\u2605" : ""}`
-  ];
-  if (includeView) actions.push("[v]iew");
-  if (includeRecommended) actions.push("[r]ecommended");
-  return actions.join(" ");
-}
-function showDiff(local, remote, displayPath) {
-  console.log(`
-    --- ${displayPath} (diff) ---`);
-  if (local === null && remote !== null) {
-    console.log("    (no local file \u2014 remote content below)");
-    for (const line of remote.split("\n").slice(0, 30)) {
-      console.log(`    + ${line}`);
-    }
-    if (remote.split("\n").length > 30) console.log("    ... (truncated)");
-  } else if (local !== null && remote === null) {
-    console.log("    (no remote file \u2014 local content below)");
-    for (const line of local.split("\n").slice(0, 30)) {
-      console.log(`    - ${line}`);
-    }
-    if (local.split("\n").length > 30) console.log("    ... (truncated)");
-  } else if (local !== null && remote !== null) {
-    const localLines = local.split("\n");
-    const remoteLines = remote.split("\n");
-    let shown = 0;
-    const maxLines = 40;
-    for (let i = 0; i < Math.max(localLines.length, remoteLines.length) && shown < maxLines; i++) {
-      const l = localLines[i];
-      const r = remoteLines[i];
-      if (l === r) {
-        console.log(`      ${l ?? ""}`);
-      } else {
-        if (l !== void 0) console.log(`    - ${l}`);
-        if (r !== void 0) console.log(`    + ${r}`);
-      }
-      shown++;
-    }
-    if (Math.max(localLines.length, remoteLines.length) > maxLines) {
-      console.log("    ... (truncated)");
-    }
-  }
-  console.log();
-}
-async function promptReviewMode() {
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  try {
-    while (true) {
-      const answer = await rl.question(
-        "  Review [o]ne-by-one or [f]older-by-folder? "
-      );
-      const a = answer.trim().toLowerCase();
-      if (a === "o" || a === "one-by-one" || a === "one" || a === "file")
-        return "file";
-      if (a === "f" || a === "folder") return "folder";
-      console.log(
-        `    Unknown option "${answer.trim()}". Valid: o/one-by-one, f/folder`
-      );
-    }
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
-  }
-}
-async function reviewFilesOneByOne(items, label, plannedAction, recommendedAction, content) {
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  const results = [];
-  try {
-    let applyAll = null;
-    for (const item of items) {
-      if (applyAll) {
-        results.push(applyAll);
-        continue;
-      }
-      const planned = plannedAction(item);
-      const rec = recommendedAction ? recommendedAction(item) : planned;
-      const hasContent = content != null;
-      const prompt = `    ${label(item)} (${planned}) \u2014 ${formatActionPrompt(rec, hasContent, false)}: `;
-      while (true) {
-        const answer = await rl.question(prompt);
-        const result = parseReviewAction(answer);
-        if (result.special === "view") {
-          if (content) {
-            showDiff(content.local(item), content.remote(item), label(item));
-          } else {
-            console.log("    No content available for diff.");
-          }
-          continue;
-        }
-        if (result.special === "recommended") {
-          results.push(rec);
-          break;
-        }
-        if (result.action === null) {
-          console.log(
-            `    Unknown option "${answer.trim()}". Valid: ${formatActionPrompt(rec, hasContent, false)}`
-          );
-          continue;
-        }
-        results.push(result.action);
-        if (result.all) applyAll = result.action;
-        break;
-      }
-    }
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
-  }
-  return results;
-}
-async function reviewFolder(folderName, items, label, plannedAction, recommendedAction, content) {
-  console.log(`
-  ${folderName} (${items.length} files):`);
-  for (const item of items) {
-    const rec = recommendedAction ? recommendedAction(item) : plannedAction(item);
-    const actionLabel = plannedAction(item);
-    const star = actionLabel === rec ? "\u2605" : "";
-    console.log(`    ${label(item)} (${actionLabel}${star})`);
-  }
-  const rl = createInterface2({ input: stdin2, output: stdout2 });
-  try {
-    while (true) {
-      const promptStr = `  Action for all: ${formatActionPrompt(
-        recommendedAction ? recommendedAction(items[0]) : plannedAction(items[0]),
-        false,
-        true
-      )} [o]ne-by-one: `;
-      const answer = await rl.question(promptStr);
-      const a = answer.trim().toLowerCase();
-      if (a === "o" || a === "one-by-one") {
-        rl.close();
-        return reviewFilesOneByOne(
-          items,
-          label,
-          plannedAction,
-          recommendedAction,
-          content
-        );
-      }
-      if (a === "r" || a === "recommended") {
-        return items.map(
-          (item) => recommendedAction ? recommendedAction(item) : plannedAction(item)
-        );
-      }
-      if (a === "v" || a === "view") {
-        if (content) {
-          for (const item of items) {
-            showDiff(content.local(item), content.remote(item), label(item));
-          }
-        } else {
-          console.log("    No content available for diff.");
-        }
-        continue;
-      }
-      const result = parseReviewAction(a);
-      if (result.action !== null) {
-        return items.map(() => result.action);
-      }
-      console.log(
-        `    Unknown option "${answer.trim()}". Valid: ${formatActionPrompt(
-          recommendedAction ? recommendedAction(items[0]) : plannedAction(items[0]),
-          false,
-          true
-        )} [o]ne-by-one`
-      );
-    }
-  } catch (err) {
-    if (isAbortError(err)) throw new SyncCancelledError();
-    throw err;
-  } finally {
-    rl.close();
-  }
-}
-var SyncCancelledError;
-var init_confirm = __esm({
-  "src/cli/confirm.ts"() {
-    "use strict";
-    SyncCancelledError = class extends Error {
-      constructor() {
-        super("Sync cancelled");
-        this.name = "SyncCancelledError";
-      }
-    };
-  }
-});
-
-// src/lib/tech-detect.ts
-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);
-    return true;
-  } catch {
-    return false;
+    return false;
   }
 }
 async function discoverMonorepoApps(projectPath) {
   const apps = [];
   const patterns = [];
   try {
-    const raw = await readFile7(
-      join7(projectPath, "pnpm-workspace.yaml"),
+    const raw = await readFile5(
+      join5(projectPath, "pnpm-workspace.yaml"),
       "utf-8"
     );
     const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
@@ -1684,7 +624,7 @@ async function discoverMonorepoApps(projectPath) {
   }
   if (patterns.length === 0) {
     try {
-      const raw = await readFile7(join7(projectPath, "package.json"), "utf-8");
+      const raw = await readFile5(join5(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);
@@ -1694,14 +634,14 @@ async function discoverMonorepoApps(projectPath) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join7(projectPath, dir);
+      const absDir = join5(projectPath, dir);
       try {
-        const entries = await readdir4(absDir, { withFileTypes: true });
+        const entries = await readdir(absDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            const relPath = join7(dir, entry.name);
-            const absPath = join7(absDir, entry.name);
-            if (await fileExists(join7(absPath, "package.json"))) {
+            const relPath = join5(dir, entry.name);
+            const absPath = join5(absDir, entry.name);
+            if (await fileExists(join5(absPath, "package.json"))) {
               apps.push({ name: entry.name, path: relPath, absPath });
             }
           }
@@ -1715,12 +655,12 @@ async function discoverMonorepoApps(projectPath) {
 async function hasJsxFile(dir, depth = 0) {
   if (depth > 6) return false;
   try {
-    const entries = await readdir4(dir, { withFileTypes: true });
+    const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const name = entry.name;
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(name) || JSX_SKIP_DIRS.has(name)) continue;
-        if (await hasJsxFile(join7(dir, name), depth + 1)) return true;
+        if (await hasJsxFile(join5(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;
@@ -1739,7 +679,7 @@ async function hasJsxFile(dir, depth = 0) {
 async function detectCapabilities(dirPath, pkgJson) {
   const caps = /* @__PURE__ */ new Set();
   for (const sub of JSX_SCAN_DIRS) {
-    if (await hasJsxFile(join7(dirPath, sub))) {
+    if (await hasJsxFile(join5(dirPath, sub))) {
       caps.add("jsx");
       break;
     }
@@ -1761,7 +701,7 @@ async function detectCapabilities(dirPath, pkgJson) {
       }
     }
   }
-  if (!caps.has("node-server") && await fileExists(join7(dirPath, "src", "main.ts"))) {
+  if (!caps.has("node-server") && await fileExists(join5(dirPath, "src", "main.ts"))) {
     caps.add("node-server");
   }
   if (pkgJson && pkgJson.bin) {
@@ -1777,7 +717,7 @@ async function detectFromDirectory(dirPath) {
   const seen = /* @__PURE__ */ new Map();
   let pkgJson = null;
   try {
-    const raw = await readFile7(join7(dirPath, "package.json"), "utf-8");
+    const raw = await readFile5(join5(dirPath, "package.json"), "utf-8");
     pkgJson = JSON.parse(raw);
     const allDeps = {
       ...pkgJson.dependencies ?? {},
@@ -1809,7 +749,7 @@ async function detectFromDirectory(dirPath) {
   }
   for (const { file, rule } of CONFIG_FILE_MAP) {
     const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join7(dirPath, file))) {
+    if (!seen.has(key) && await fileExists(join5(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
@@ -1987,16 +927,16 @@ function categorizeDependency(depName) {
 async function findPackageJsonFiles(dir, projectPath, depth = 0) {
   if (depth > 4) return [];
   const results = [];
-  const pkgPath = join7(dir, "package.json");
+  const pkgPath = join5(dir, "package.json");
   if (await fileExists(pkgPath)) {
     results.push(pkgPath);
   }
   try {
-    const entries = await readdir4(dir, { withFileTypes: true });
+    const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
       const subResults = await findPackageJsonFiles(
-        join7(dir, entry.name),
+        join5(dir, entry.name),
         projectPath,
         depth + 1
       );
@@ -2011,7 +951,7 @@ async function scanAllDependencies(projectPath) {
   const dependencies = [];
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile7(pkgPath, "utf-8");
+      const raw = await readFile5(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const sourcePath = relative(projectPath, pkgPath);
       const depSections = [
@@ -2225,176 +1165,27 @@ var init_tech_detect = __esm({
   }
 });
 
-// src/lib/server-detect.ts
-function detectFramework(pkg) {
-  const deps = pkg.dependencies ?? {};
-  const devDeps = pkg.devDependencies ?? {};
-  const hasDep = (name) => name in deps || name in devDeps;
-  if (hasDep("next")) return "nextjs";
-  if (hasDep("@tauri-apps/api") || hasDep("@tauri-apps/cli")) return "tauri";
-  if (hasDep("expo")) return "expo";
-  if (hasDep("vite")) return "vite";
-  if (hasDep("express")) return "express";
-  if (hasDep("@nestjs/core")) return "nestjs";
-  return "custom";
-}
-function detectPortFromScripts(pkg) {
-  const scripts = pkg.scripts;
-  if (!scripts?.dev) return null;
-  const parts = scripts.dev.split(/\s+/);
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (parts[i] === "--port" || parts[i] === "-p") {
-      const next = parts[i + 1];
-      if (next) {
-        const port = parseInt(next, 10);
-        if (!isNaN(port)) return port;
+// src/lib/eslint-generator.ts
+import { createHash as createHash2 } 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 null;
-}
-var init_server_detect = __esm({
-  "src/lib/server-detect.ts"() {
-    "use strict";
-  }
-});
-
-// src/lib/port-verify.ts
-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 readFile8(pkgPath, "utf-8");
-      const pkg = JSON.parse(raw);
-      const scriptPort = detectPortFromScripts(pkg);
-      if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
-        const relativePath = pkgPath.replace(projectPath + "/", "");
-        const matchingAlloc = portAllocations.find(
-          (a) => a.label === getAppLabel(relativePath)
-        );
-        mismatches.push({
-          packageJsonPath: relativePath,
-          scriptPort,
-          allocation: matchingAlloc ?? null,
-          reason: matchingAlloc ? `Script uses port ${scriptPort} but allocation has port ${matchingAlloc.port}` : `Port ${scriptPort} in scripts is not in any allocation`
-        });
-      }
-    } catch {
-    }
-  }
-  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 unallocated = [];
-  for (const app of apps) {
-    if (portAllocations.some((a) => labelMatchesAppName(a.label ?? "", app.name))) {
-      continue;
-    }
-    let pkg;
-    try {
-      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;
-}
-function getAppLabel(relativePath) {
-  const parts = relativePath.split("/");
-  if (parts.length >= 3 && parts[0] === "apps") {
-    return parts[1];
-  }
-  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;
+  return names;
 }
 function parseFragment(fragment) {
   if (!fragment) return { imports: [], configComments: [] };
@@ -2443,7 +1234,7 @@ function collectDependencies(presets) {
   return deps;
 }
 function hashConfig(content) {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash2("sha256").update(content).digest("hex");
 }
 function buildRules(presets) {
   const merged = {};
@@ -2556,8 +1347,7 @@ function generateEslintConfig(input) {
   sections.push(
     "/**",
     " * ESLint flat config \u2014 generated by CodeByPlan CLI.",
-    " * Edit rule overrides via the web UI, then run `codebyplan eslint sync`.",
-    " * Manual edits will be detected as drift.",
+    " * Edit rule overrides via the web UI, then run `codebyplan eslint init` to regenerate.",
     " */",
     ""
   );
@@ -2758,13 +1548,11 @@ var init_eslint_generator = __esm({
 var eslint_exports = {};
 __export(eslint_exports, {
   autoDetectIgnorePatterns: () => autoDetectIgnorePatterns,
-  checkEslintDrift: () => checkEslintDrift,
   eslintInit: () => eslintInit,
-  eslintSync: () => eslintSync,
   runEslint: () => runEslint
 });
-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";
+import { readFile as readFile6, writeFile as writeFile4, access as access2, readdir as readdir2 } from "node:fs/promises";
+import { join as join6, relative as relative2 } from "node:path";
 async function fileExists2(filePath) {
   try {
     await access2(filePath);
@@ -2775,12 +1563,12 @@ async function fileExists2(filePath) {
 }
 async function autoDetectIgnorePatterns(absPath) {
   const patterns = [];
-  if (await fileExists2(join8(absPath, "esbuild.js"))) {
+  if (await fileExists2(join6(absPath, "esbuild.js"))) {
     patterns.push("esbuild.js");
   }
   let entries = [];
   try {
-    entries = await readdir5(absPath);
+    entries = await readdir2(absPath);
   } catch (err) {
     console.error(
       `  autoDetectIgnorePatterns: failed to read ${absPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -2795,19 +1583,19 @@ async function autoDetectIgnorePatterns(absPath) {
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vitest.config.${ext}`;
-    if (await fileExists2(join8(absPath, candidate))) {
+    if (await fileExists2(join6(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
   for (const ext of ["ts", "mts", "js", "mjs"]) {
     const candidate = `vite.config.${ext}`;
-    if (await fileExists2(join8(absPath, candidate))) {
+    if (await fileExists2(join6(absPath, candidate))) {
       patterns.push(candidate);
       break;
     }
   }
-  if (await fileExists2(join8(absPath, "tauri.conf.json"))) {
+  if (await fileExists2(join6(absPath, "tauri.conf.json"))) {
     patterns.push("src-tauri/**");
     patterns.push("**/*.d.ts");
   }
@@ -2815,14 +1603,14 @@ async function autoDetectIgnorePatterns(absPath) {
 }
 function detectPackageManager(projectPath) {
   return (async () => {
-    if (await fileExists2(join8(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(join8(projectPath, "yarn.lock"))) return "yarn";
+    if (await fileExists2(join6(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(join6(projectPath, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
 async function getInstalledDeps(pkgJsonPath) {
   try {
-    const raw = await readFile9(pkgJsonPath, "utf-8");
+    const raw = await readFile6(pkgJsonPath, "utf-8");
     const pkg = JSON.parse(raw);
     const all = /* @__PURE__ */ new Set();
     for (const name of Object.keys(pkg.dependencies ?? {})) all.add(name);
@@ -2935,7 +1723,7 @@ async function eslintInit(repoId, projectPath) {
       ignorePatterns: detectedIgnores
     });
     const hash = hashConfig(content);
-    const configPath = join8(target.absPath, "eslint.config.mjs");
+    const configPath = join6(target.absPath, "eslint.config.mjs");
     configsToWrite.push({
       target,
       presets,
@@ -2957,11 +1745,11 @@ async function eslintInit(repoId, projectPath) {
     return;
   }
   const pm = await detectPackageManager(projectPath);
-  const rootPkgJsonPath = join8(projectPath, "package.json");
+  const rootPkgJsonPath = join6(projectPath, "package.json");
   const installed = await getInstalledDeps(rootPkgJsonPath);
   if (isMonorepo) {
     for (const { target } of configsToWrite) {
-      const appPkgJson = join8(target.absPath, "package.json");
+      const appPkgJson = join6(target.absPath, "package.json");
       const appDeps = await getInstalledDeps(appPkgJson);
       for (const dep of appDeps) {
         installed.add(dep);
@@ -2987,9 +1775,9 @@ async function eslintInit(repoId, projectPath) {
   Install ${missingPkgs.length} missing packages? [Y/n] `
     );
     if (confirmed) {
-      const { execSync } = await import("node:child_process");
+      const { execSync: execSync3 } = await import("node:child_process");
       try {
-        execSync(installCmd, { cwd: projectPath, stdio: "inherit" });
+        execSync3(installCmd, { cwd: projectPath, stdio: "inherit" });
         console.log("  Packages installed.\n");
       } catch (err) {
         console.error(
@@ -3013,7 +1801,7 @@ async function eslintInit(repoId, projectPath) {
   } of configsToWrite) {
     if (await fileExists2(configPath)) {
       try {
-        const existing = await readFile9(configPath, "utf-8");
+        const existing = await readFile6(configPath, "utf-8");
         const existingHash = hashConfig(existing);
         if (existingHash === hash) {
           console.log(
@@ -3056,134 +1844,6 @@ async function eslintInit(repoId, projectPath) {
   }
   console.log("\n  ESLint init complete.\n");
 }
-async function eslintSync(repoId, projectPath) {
-  console.log("\n  ESLint Sync");
-  console.log(`  Repo: ${repoId}`);
-  console.log(`  Path: ${projectPath}
-`);
-  let configs;
-  try {
-    const res = await apiGet(
-      `/repos/${repoId}/eslint-config`
-    );
-    configs = res.data ?? [];
-  } catch {
-    console.log(
-      "  No existing ESLint config found. Run `codebyplan eslint init` first.\n"
-    );
-    return;
-  }
-  if (configs.length === 0) {
-    console.log(
-      "  No ESLint configs registered. Run `codebyplan eslint init` first.\n"
-    );
-    return;
-  }
-  let updatedCount = 0;
-  let skippedCount = 0;
-  let driftCount = 0;
-  for (const config of configs) {
-    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);
-    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 readFile9(configPath, "utf-8");
-          const currentHash = hashConfig(currentContent);
-          if (config.generated_hash && currentHash !== config.generated_hash) {
-            console.log(
-              `  ${config.source_path}: drift detected (manually edited). Not overwriting.`
-            );
-            driftCount++;
-            continue;
-          }
-          skippedCount++;
-          continue;
-        } catch {
-          console.warn(
-            `  ${config.source_path}: config file unreadable, regenerating...`
-          );
-        }
-      } else {
-        console.log(
-          `  ${config.source_path}: config file missing, 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,
-      ignorePatterns: detectedIgnores
-    });
-    try {
-      await writeFile4(configPath, content, "utf-8");
-    } catch (err) {
-      console.error(
-        `  ${config.source_path}: Failed to write config: ${err instanceof Error ? err.message : String(err)}`
-      );
-      continue;
-    }
-    const newHash = hashConfig(content);
-    try {
-      await apiPut(`/repos/${repoId}/eslint-config`, {
-        source_path: config.source_path,
-        preset_ids: currentPresetIds,
-        rule_overrides: userOverrides ?? {},
-        generated_hash: newHash
-      });
-    } catch (err) {
-      console.error(
-        `  Warning: Failed to update server: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    updatedCount++;
-  }
-  console.log(
-    `
-  Sync: ${updatedCount} updated, ${skippedCount} unchanged, ${driftCount} drift detected.
-`
-  );
-}
-async function checkEslintDrift(repoId, projectPath) {
-  try {
-    const res = await apiGet(
-      `/repos/${repoId}/eslint-config`
-    );
-    const configs = res.data ?? [];
-    for (const config of configs) {
-      if (!config.generated_hash) continue;
-      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 readFile9(configPath, "utf-8");
-        const currentHash = hashConfig(content);
-        if (currentHash !== config.generated_hash) {
-          return true;
-        }
-      } catch {
-      }
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
 async function runEslint() {
   const subcommand = process.argv[3];
   const flags = parseFlags(4);
@@ -3194,14 +1854,10 @@ async function runEslint() {
     case "init":
       await eslintInit(repoId, projectPath);
       break;
-    case "sync":
-      await eslintSync(repoId, projectPath);
-      break;
     default:
       console.log(`
   Usage:
     codebyplan eslint init     Detect tech stack, resolve presets, generate eslint.config.mjs
-    codebyplan eslint sync     Regenerate if presets changed, detect drift
 `);
       break;
   }
@@ -3209,7 +1865,7 @@ async function runEslint() {
 var init_eslint = __esm({
   "src/cli/eslint.ts"() {
     "use strict";
-    init_config();
+    init_flags();
     init_confirm();
     init_api();
     init_tech_detect();
@@ -3217,556 +1873,128 @@ var init_eslint = __esm({
   }
 });
 
-// src/cli/sync.ts
-var sync_exports = {};
-__export(sync_exports, {
-  runSync: () => runSync
+// src/cli/resolve-worktree.ts
+var resolve_worktree_exports = {};
+__export(resolve_worktree_exports, {
+  runResolveWorktree: () => runResolveWorktree
 });
-import { createHash as createHash2 } from "node:crypto";
-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");
+import { execSync as execSync2 } from "node:child_process";
+async function runResolveWorktree() {
+  try {
+    const projectPath = process.cwd();
+    const found = await findCodebyplanConfig(projectPath);
+    if (!found?.contents.repo_id) {
+      process.exit(0);
+    }
+    const repoId = found.contents.repo_id;
+    const deviceId = await getOrCreateDeviceId(projectPath);
+    let branch = "";
+    try {
+      branch = execSync2("git symbolic-ref --short HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+    }
+    const worktreeId = await resolveWorktreeId({
+      repoId,
+      repoPath: projectPath,
+      branch,
+      deviceId
+    });
+    if (worktreeId) {
+      process.stdout.write(worktreeId);
+    }
+    process.exit(0);
+  } catch (err) {
+    if (process.env.CODEBYPLAN_DEBUG === "1") {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`resolve-worktree: ${msg}
+`);
+    }
+    process.exit(0);
+  }
 }
-async function runSync() {
+var init_resolve_worktree2 = __esm({
+  "src/cli/resolve-worktree.ts"() {
+    "use strict";
+    init_flags();
+    init_local_config();
+    init_resolve_worktree();
+  }
+});
+
+// src/cli/config.ts
+var config_exports = {};
+__export(config_exports, {
+  runConfig: () => runConfig
+});
+import { readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
-  const force = hasFlag("force", 3);
-  const fix = hasFlag("fix", 3);
   validateApiKey();
   const config = await resolveConfig(flags);
   const { repoId, projectPath } = config;
   console.log(`
-  CodeByPlan Sync`);
+  CodeByPlan Config`);
   console.log(`  Repo: ${repoId}`);
   console.log(`  Path: ${projectPath}`);
   if (dryRun) console.log(`  Mode: dry-run`);
-  if (force) console.log(`  Mode: force`);
   console.log();
-  if (!dryRun) {
-    console.log("  Acquiring sync lock...");
+  await syncConfigToFile(repoId, projectPath, dryRun);
+  console.log("\n  Config complete.\n");
+}
+async function syncConfigToFile(repoId, projectPath, dryRun) {
+  const configPath = join7(projectPath, ".codebyplan.json");
+  let currentConfig = {};
+  try {
+    const raw = await readFile7(configPath, "utf-8");
+    currentConfig = JSON.parse(raw);
+  } catch {
+    currentConfig = { repo_id: repoId };
+  }
+  let resolvedWorktreeId;
+  try {
+    const deviceId = await getOrCreateDeviceId(projectPath);
+    let branch = "main";
     try {
-      await apiPost("/sync/lock", {
-        repo_id: repoId,
-        locked_by: `cli-sync`,
-        reason: "Bidirectional sync",
-        ttl_minutes: 10
-      });
-      console.log("  Lock acquired.\n");
-    } catch (lockErr) {
-      const lockStatus = await apiGet("/sync/lock", { repo_id: repoId });
-      if (lockStatus.data.locked && lockStatus.data.lock) {
-        const lock = lockStatus.data.lock;
-        console.log(
-          `  Sync locked by ${lock.locked_by} since ${lock.locked_at}.`
-        );
-        console.log(`  Expires: ${lock.expires_at}`);
-        console.log(`  Use --force to override, or wait for lock to expire.
-`);
-        if (!force) return;
-        await apiPost("/sync/lock", {
-          repo_id: repoId,
-          locked_by: `cli-sync`,
-          reason: "Bidirectional sync (forced)",
-          ttl_minutes: 10
-        });
-        console.log("  Lock acquired (forced).\n");
-      } else {
-        throw lockErr;
-      }
+      const { execSync: execSync3 } = await import("node:child_process");
+      branch = execSync3("git symbolic-ref --short HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8"
+      }).trim();
+    } catch {
+    }
+    const tupleId = await resolveWorktreeId({
+      repoId,
+      repoPath: projectPath,
+      branch,
+      deviceId
+    });
+    if (tupleId) {
+      resolvedWorktreeId = tupleId;
+    } else {
+      resolvedWorktreeId = await resolveAndCacheWorktreeId(repoId, projectPath) ?? void 0;
     }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `  Warning: failed to cache worktree_id (self-heal skipped): ${msg}`
+    );
   }
-  try {
-    await runSyncInner(repoId, projectPath, dryRun, force, fix);
-  } finally {
-    if (!dryRun) {
-      try {
-        await apiDelete("/sync/lock", { repo_id: repoId });
-      } catch (err) {
-        console.error(
-          `  Warning: failed to release sync lock: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }
-}
-async function runSyncInner(repoId, projectPath, dryRun, force, fix = false) {
-  console.log("  Reading local and remote state...");
-  const claudeDir = join9(projectPath, ".claude");
-  let localFiles = /* @__PURE__ */ new Map();
-  try {
-    localFiles = await scanLocalFiles(claudeDir, projectPath);
-  } catch (err) {
-    console.warn(
-      `  Local file scan incomplete: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const [defaultsRes, repoSyncRes, repoRes, , fileReposRes] = await Promise.all(
-    [
-      apiGet("/sync/defaults"),
-      apiGet("/sync/files", { repo_id: repoId }),
-      apiGet(`/repos/${repoId}`),
-      apiGet("/sync/state", {
-        repo_id: repoId
-      }),
-      apiGet("/sync/file-repos", {
-        repo_id: repoId
-      })
-    ]
-  );
-  const syncStartTime = Date.now();
-  const repoData = repoRes.data;
-  const remoteDefaults = flattenSyncData(defaultsRes.data);
-  const remoteRepoFiles = flattenSyncData(repoSyncRes.data);
-  const fileRepoHashes = /* @__PURE__ */ new Map();
-  const fileRepoByClaudeFileId = /* @__PURE__ */ new Map();
-  for (const entry of fileReposRes.data ?? []) {
-    const baseKey = compositeKey(
-      entry.file_type,
-      entry.file_name,
-      entry.file_category
-    );
-    const scopedKey = `${baseKey}:${entry.file_scope}`;
-    fileRepoHashes.set(scopedKey, entry.last_synced_content_hash);
-    if (!fileRepoHashes.has(baseKey)) {
-      fileRepoHashes.set(baseKey, entry.last_synced_content_hash);
-    }
-    if (entry.claude_file_id) {
-      fileRepoByClaudeFileId.set(
-        entry.claude_file_id,
-        entry.last_synced_content_hash
-      );
-    }
-  }
-  const remoteFiles = new Map([...remoteDefaults, ...remoteRepoFiles]);
-  console.log(
-    `  Local: ${localFiles.size} files, Remote: ${remoteFiles.size} files
-`
-  );
-  const plan = [];
-  const allKeys = /* @__PURE__ */ new Set([...localFiles.keys(), ...remoteFiles.keys()]);
-  for (const key of allKeys) {
-    const local = localFiles.get(key);
-    const remote = remoteFiles.get(key);
-    if (local && !remote) {
-      plan.push({
-        key,
-        displayPath: `${local.type}/${local.category ? local.category + "/" : ""}${local.name}`,
-        action: "push",
-        recommended: "push",
-        localContent: local.content,
-        remoteContent: null,
-        pushContent: reverseSubstituteVariables(local.content, repoData),
-        filePath: getLocalFilePath(claudeDir, projectPath, {
-          type: local.type,
-          name: local.name,
-          category: local.category
-        }),
-        type: local.type,
-        name: local.name,
-        category: local.category,
-        scope: local.scope,
-        isHook: local.type === "hook",
-        claudeFileId: null
-      });
-    } else if (!local && remote) {
-      const remoteScope = remote.scope ?? "shared";
-      if (remoteScope.startsWith("local:") && remoteScope !== `local:${repoData.name}`) {
-        continue;
-      }
-      const resolvedContent = substituteVariables(remote.content, repoData);
-      const hadSyncedThisFile = remote.id ? fileRepoByClaudeFileId.has(remote.id) : fileRepoHashes.has(key);
-      const recommended = hadSyncedThisFile ? "delete" : "pull";
-      plan.push({
-        key,
-        displayPath: `${remote.type}/${remote.category ? remote.category + "/" : ""}${remote.name}`,
-        action: recommended,
-        recommended,
-        localContent: null,
-        remoteContent: resolvedContent,
-        pushContent: null,
-        filePath: getLocalFilePath(claudeDir, projectPath, remote),
-        type: remote.type,
-        name: remote.name,
-        category: remote.category ?? null,
-        scope: remote.scope ?? "shared",
-        isHook: remote.type === "hook",
-        claudeFileId: remote.id ?? null
-      });
-    } else if (local && remote) {
-      const remoteScope = remote.scope ?? "shared";
-      if (remoteScope.startsWith("local:") && remoteScope !== `local:${repoData.name}`) {
-        continue;
-      }
-      const resolvedRemote = substituteVariables(remote.content, repoData);
-      if (local.content === resolvedRemote) {
-        continue;
-      }
-      const localHash = contentHash(local.content);
-      const scopedKey = `${key}:${local.scope}`;
-      const lastSyncedHash = fileRepoHashes.get(scopedKey) ?? fileRepoHashes.get(key) ?? null;
-      const localChanged = lastSyncedHash ? localHash !== lastSyncedHash : true;
-      let action;
-      if (force) {
-        action = "pull";
-      } else if (!localChanged) {
-        action = "pull";
-      } else if (lastSyncedHash === null) {
-        action = "conflict";
-      } else {
-        const remoteResolvedHash = contentHash(resolvedRemote);
-        const remoteChanged = remoteResolvedHash !== lastSyncedHash;
-        if (remoteChanged) {
-          action = "conflict";
-        } else {
-          action = "push";
-        }
-      }
-      plan.push({
-        key,
-        displayPath: `${local.type}/${local.category ? local.category + "/" : ""}${local.name}`,
-        action,
-        recommended: action === "conflict" ? "pull" : action,
-        localContent: local.content,
-        remoteContent: resolvedRemote,
-        pushContent: reverseSubstituteVariables(local.content, repoData),
-        filePath: getLocalFilePath(claudeDir, projectPath, remote),
-        type: local.type,
-        name: local.name,
-        category: local.category,
-        scope: local.scope,
-        isHook: local.type === "hook",
-        claudeFileId: remote.id ?? null
-      });
-    }
-  }
-  const pulls = plan.filter((p) => p.action === "pull");
-  const pushes = plan.filter((p) => p.action === "push");
-  const conflicts = plan.filter((p) => p.action === "conflict");
-  const contentPulls = pulls.filter((p) => p.localContent !== null);
-  const dbOnlyPull = plan.filter(
-    (p) => p.localContent === null && p.action === "pull"
-  );
-  const dbOnlyDelete = plan.filter(
-    (p) => p.localContent === null && p.action === "delete"
-  );
-  if (contentPulls.length > 0) {
-    console.log(`  Pull (DB \u2192 local): ${contentPulls.length}`);
-    for (const p of contentPulls) console.log(`    \u2193 ${p.displayPath}`);
-  }
-  if (pushes.length > 0) {
-    console.log(`  Push (local \u2192 DB): ${pushes.length}`);
-    for (const p of pushes) console.log(`    \u2191 ${p.displayPath}`);
-  }
-  if (dbOnlyPull.length > 0) {
-    console.log(`
-  DB-only (new, will pull): ${dbOnlyPull.length}`);
-    for (const p of dbOnlyPull) console.log(`    \u2193 ${p.displayPath}`);
-  }
-  if (dbOnlyDelete.length > 0) {
-    console.log(
-      `
-  DB-only (previously synced, will delete): ${dbOnlyDelete.length}`
-    );
-    for (const p of dbOnlyDelete) console.log(`    \u2715 ${p.displayPath}`);
-  }
-  if (conflicts.length > 0) {
-    console.log(`
-  Conflicts (both sides changed): ${conflicts.length}`);
-    for (const p of conflicts) console.log(`    \u26A0 ${p.displayPath}`);
-  }
-  if (contentPulls.length === 0 && pushes.length === 0 && dbOnlyPull.length === 0 && dbOnlyDelete.length === 0 && conflicts.length === 0) {
-    console.log("  All .claude/ files in sync.");
-  }
-  if (plan.length > 0 && !dryRun) {
-    if (!force) {
-      const agreed = await confirmProceed(`
-  Agree with sync? [Y/n] `);
-      if (!agreed) {
-        const mode = await promptReviewMode();
-        const contentProvider = {
-          local: (p) => p.localContent,
-          remote: (p) => p.remoteContent
-        };
-        if (mode === "file") {
-          const actions = await reviewFilesOneByOne(
-            plan,
-            (p) => p.displayPath,
-            (p) => p.action,
-            (p) => p.recommended,
-            contentProvider
-          );
-          for (let i = 0; i < plan.length; i++) {
-            plan[i].action = actions[i];
-          }
-        } else {
-          const groups = groupByType(plan);
-          for (const [typeName, items] of groups) {
-            const actions = await reviewFolder(
-              typeName,
-              items,
-              (p) => p.displayPath,
-              (p) => p.action,
-              (p) => p.recommended,
-              contentProvider
-            );
-            for (let i = 0; i < items.length; i++) {
-              items[i].action = actions[i];
-            }
-          }
-        }
-      }
-    }
-    const toPull = plan.filter((p) => p.action === "pull");
-    const toPush = plan.filter((p) => p.action === "push");
-    const toDelete = plan.filter((p) => p.action === "delete");
-    const skipped = plan.filter((p) => p.action === "skip");
-    if (toPull.length + toPush.length + toDelete.length === 0) {
-      console.log("\n  All items skipped \u2014 no changes applied.");
-    } else {
-      for (const p of toPull) {
-        if (p.filePath && p.remoteContent !== null) {
-          await mkdir2(dirname2(p.filePath), { recursive: true });
-          await writeFile5(p.filePath, p.remoteContent, "utf-8");
-          if (p.isHook) await chmod2(p.filePath, 493);
-        }
-      }
-      const toUpsert = toPush.filter((p) => p.pushContent !== null).map((p) => ({
-        type: p.type,
-        name: p.name,
-        category: p.category,
-        content: p.pushContent,
-        scope: p.scope
-      }));
-      if (toUpsert.length > 0) {
-        await apiPost("/sync/files", {
-          repo_id: repoId,
-          files: toUpsert,
-          changed_by_repo_id: repoId
-        });
-      }
-      if (toDelete.length > 0) {
-        const deleteKeys = toDelete.map((p) => ({
-          type: p.type,
-          name: p.name,
-          category: p.category
-        }));
-        await apiPost("/sync/files", {
-          repo_id: repoId,
-          delete_keys: deleteKeys
-        });
-        for (const p of toDelete) {
-          if (p.filePath) {
-            try {
-              await unlink2(p.filePath);
-            } catch (err) {
-              if (err instanceof Error && "code" in err && err.code !== "ENOENT") {
-                console.error(
-                  `  Warning: failed to delete ${p.filePath}: ${err.message}`
-                );
-              }
-            }
-          }
-        }
-      }
-      const syncDurationMs = Date.now() - syncStartTime;
-      await apiPost("/sync/state", {
-        repo_id: repoId,
-        last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
-        was_skipped: skipped.length > 0,
-        files_synced_count: toPull.length + toPush.length + toDelete.length,
-        files_pushed: toPush.length,
-        files_pulled: toPull.length,
-        files_deleted: toDelete.length,
-        files_skipped: skipped.length,
-        sync_duration_ms: syncDurationMs,
-        sync_version: getSyncVersion()
-      });
-      const syncTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const fileRepoUpdates = [];
-      for (const p of toPull) {
-        if (p.remoteContent !== null) {
-          fileRepoUpdates.push({
-            claude_file_id: p.claudeFileId ?? void 0,
-            file_type: p.type,
-            file_name: p.name,
-            file_category: p.category,
-            file_scope: p.scope,
-            last_synced_at: syncTimestamp,
-            last_synced_content_hash: contentHash(p.remoteContent),
-            sync_status: "synced"
-          });
-        }
-      }
-      for (const p of toPush) {
-        if (p.localContent !== null) {
-          fileRepoUpdates.push({
-            claude_file_id: p.claudeFileId ?? void 0,
-            file_type: p.type,
-            file_name: p.name,
-            file_category: p.category,
-            file_scope: p.scope,
-            last_synced_at: syncTimestamp,
-            last_synced_content_hash: contentHash(p.localContent),
-            sync_status: "synced"
-          });
-        }
-      }
-      if (fileRepoUpdates.length > 0) {
-        try {
-          await apiPost("/sync/file-repos", {
-            repo_id: repoId,
-            file_repos: fileRepoUpdates
-          });
-        } catch (err) {
-          console.warn(
-            `  Warning: failed to update file-repo tracking for ${fileRepoUpdates.length} files: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-      console.log(
-        `
-  Applied: ${toPull.length} pulled, ${toPush.length} pushed, ${toDelete.length} deleted` + (skipped.length > 0 ? `, ${skipped.length} skipped` : "")
-      );
-    }
-    const unresolvedConflicts = plan.filter(
-      (p) => p.action === "conflict" || p.action === "skip" && p.localContent !== null && p.remoteContent !== null
-    );
-    if (unresolvedConflicts.length > 0) {
-      let stored = 0;
-      for (const p of unresolvedConflicts) {
-        try {
-          await apiPost("/sync/conflicts", {
-            repo_id: repoId,
-            claude_file_id: p.claudeFileId ?? void 0,
-            file_type: p.type,
-            file_name: p.name,
-            file_category: p.category,
-            file_scope: p.scope,
-            conflict_type: "both_modified",
-            local_content: p.localContent,
-            remote_content: p.remoteContent
-          });
-          stored++;
-        } catch (err) {
-          console.error(`Failed to store conflict for ${p.displayPath}:`, err);
-        }
-      }
-      if (stored > 0) {
-        console.log(
-          `
-  ${stored} conflict(s) stored in DB for later resolution.`
-        );
-      }
-    }
-  } else if (dryRun) {
-    console.log("\n  (dry-run \u2014 no changes)");
-  }
-  console.log("\n  Settings sync...");
-  await syncSettings(
-    claudeDir,
-    projectPath,
-    defaultsRes.data,
-    repoData,
-    dryRun
-  );
-  console.log("  Config sync...");
-  await syncConfig(repoId, projectPath, dryRun);
-  console.log("  Tech stack...");
-  await syncTechStack(repoId, projectPath, dryRun);
-  console.log("  ESLint config...");
-  await syncEslintDriftCheck(repoId, projectPath);
-  console.log("  Port verification...");
-  await syncPortVerification(repoId, projectPath, dryRun, fix);
-  console.log("\n  Sync complete.\n");
-}
-async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun) {
-  const settingsPath = join9(claudeDir, "settings.json");
-  const globalSettingsFiles = syncData.global_settings ?? [];
-  let globalSettings = {};
-  for (const gf of globalSettingsFiles) {
-    const parsed = JSON.parse(
-      substituteVariables(gf.content, repoData)
-    );
-    globalSettings = { ...globalSettings, ...parsed };
-  }
-  const repoSettingsFiles = syncData.settings ?? [];
-  let repoSettings = {};
-  for (const rf of repoSettingsFiles) {
-    repoSettings = JSON.parse(
-      substituteVariables(rf.content, repoData)
-    );
-  }
-  const combinedTemplate = mergeGlobalAndRepoSettings(
-    globalSettings,
-    repoSettings
-  );
-  const hooksDir = join9(projectPath, ".claude", "hooks");
-  const discovered = await discoverHooks(hooksDir);
-  let localSettings = {};
-  try {
-    const raw = await readFile10(settingsPath, "utf-8");
-    localSettings = JSON.parse(raw);
-  } catch {
-  }
-  let merged = Object.keys(localSettings).length > 0 ? mergeSettings(combinedTemplate, localSettings) : combinedTemplate;
-  merged = stripPermissionsAllow(merged);
-  if (discovered.size > 0) {
-    merged.hooks = mergeDiscoveredHooks(
-      merged.hooks ?? {},
-      discovered
-    );
-  }
-  const mergedContent = JSON.stringify(merged, null, 2) + "\n";
-  let currentContent = "";
-  try {
-    currentContent = await readFile10(settingsPath, "utf-8");
-  } catch {
-  }
-  if (currentContent === mergedContent) {
-    console.log("    Settings up to date.");
-    return;
-  }
-  if (dryRun) {
-    console.log("    Settings would be updated (dry-run).");
-    return;
-  }
-  await mkdir2(dirname2(settingsPath), { recursive: true });
-  await writeFile5(settingsPath, mergedContent, "utf-8");
-  console.log("    Updated settings.json");
-}
-async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join9(projectPath, ".codebyplan.json");
-  let currentConfig = {};
-  try {
-    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 = [];
+  const repoRes = await apiGet(`/repos/${repoId}`);
+  const repo = repoRes.data;
+  let portAllocations = [];
   try {
     const portsRes = await apiGet(
       `/port-allocations`,
       { repo_id: repoId }
     );
     const allAllocations = portsRes.data ?? [];
-    const worktreeId2 = currentConfig.worktree_id;
-    const filtered = worktreeId2 ? allAllocations.filter((a) => a.worktree_id === worktreeId2) : allAllocations.filter((a) => !a.worktree_id);
+    const filteredByWorktree = resolvedWorktreeId;
+    const filtered = filteredByWorktree ? allAllocations.filter((a) => a.worktree_id === filteredByWorktree) : allAllocations.filter((a) => !a.worktree_id);
     const ALLOWED_FIELDS = [
       "id",
       "repo_id",
@@ -3794,7 +2022,7 @@ async function syncConfig(repoId, projectPath, dryRun) {
       `  Warning: failed to fetch port allocations: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const worktreeId = currentConfig.worktree_id;
+  const worktreeId = resolvedWorktreeId;
   const matchingAlloc = portAllocations[0];
   const defaultBranchConfig = {
     protected: ["main", "development"],
@@ -3805,7 +2033,9 @@ async function syncConfig(repoId, projectPath, dryRun) {
   const branchConfig = repo.branch_config ?? defaultBranchConfig;
   const newConfig = {
     repo_id: repoId,
-    ...worktreeId ? { worktree_id: worktreeId } : {},
+    // worktree_id is intentionally omitted — it is never persisted in
+    // .codebyplan.json (CHK-108). The in-memory worktreeId is used only
+    // for server_port / server_type resolution immediately below.
     server_port: worktreeId && matchingAlloc ? matchingAlloc.port : repo.server_port,
     server_type: worktreeId && matchingAlloc ? matchingAlloc.server_type : repo.server_type,
     git_branch: repo.git_branch ?? "development",
@@ -3816,68 +2046,194 @@ async function syncConfig(repoId, projectPath, dryRun) {
   const currentJson = JSON.stringify(currentConfig, null, 2);
   const newJson = JSON.stringify(newConfig, null, 2);
   if (currentJson === newJson) {
-    console.log("    Config up to date.");
+    console.log("  Config up to date.");
     return;
   }
   if (dryRun) {
-    console.log("    Config would be updated (dry-run).");
+    console.log("  Config would be updated (dry-run).");
     return;
   }
   await writeFile5(configPath, newJson + "\n", "utf-8");
-  console.log("    Updated .codebyplan.json");
+  console.log("  Updated .codebyplan.json");
 }
-async function syncTechStack(repoId, projectPath, dryRun) {
-  try {
-    const { dependencies } = await scanAllDependencies(projectPath);
-    if (dependencies.length === 0) {
-      console.log("    No dependencies found.");
-      return;
-    }
-    const sourcePaths = new Set(dependencies.map((d) => d.source_path));
-    console.log(
-      `    ${dependencies.length} dependencies from ${sourcePaths.size} package.json file${sourcePaths.size !== 1 ? "s" : ""}`
-    );
-    if (!dryRun) {
-      const result = await apiPost(`/repos/${repoId}/tech-stack`, { dependencies });
-      if (result.data.stale_removed > 0) {
-        console.log(
-          `    ${result.data.stale_removed} stale dependencies removed`
-        );
+var init_config = __esm({
+  "src/cli/config.ts"() {
+    "use strict";
+    init_flags();
+    init_api();
+    init_resolve_worktree();
+    init_local_config();
+  }
+});
+
+// src/lib/server-detect.ts
+function detectFramework(pkg) {
+  const deps = pkg.dependencies ?? {};
+  const devDeps = pkg.devDependencies ?? {};
+  const hasDep = (name) => name in deps || name in devDeps;
+  if (hasDep("next")) return "nextjs";
+  if (hasDep("@tauri-apps/api") || hasDep("@tauri-apps/cli")) return "tauri";
+  if (hasDep("expo")) return "expo";
+  if (hasDep("vite")) return "vite";
+  if (hasDep("express")) return "express";
+  if (hasDep("@nestjs/core")) return "nestjs";
+  return "custom";
+}
+function detectPortFromScripts(pkg) {
+  const scripts = pkg.scripts;
+  if (!scripts?.dev) return null;
+  const parts = scripts.dev.split(/\s+/);
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (parts[i] === "--port" || parts[i] === "-p") {
+      const next = parts[i + 1];
+      if (next) {
+        const port = parseInt(next, 10);
+        if (!isNaN(port)) return port;
       }
     }
-    const detected = await detectTechStack(projectPath);
-    if (detected.flat.length > 0) {
-      const repoRes = await apiGet(`/repos/${repoId}`);
-      const remote = parseTechStackResult(repoRes.data.tech_stack);
-      const { merged, added } = mergeTechStack(remote, detected);
-      if (added.length > 0) {
-        console.log(`    ${added.length} new tech entries`);
-        if (!dryRun) {
-          await apiPut(`/repos/${repoId}`, { tech_stack: merged });
-        }
+  }
+  return null;
+}
+var init_server_detect = __esm({
+  "src/lib/server-detect.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/port-verify.ts
+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 readFile8(pkgPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const scriptPort = detectPortFromScripts(pkg);
+      if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
+        const relativePath = pkgPath.replace(projectPath + "/", "");
+        const matchingAlloc = portAllocations.find(
+          (a) => a.label === getAppLabel(relativePath)
+        );
+        mismatches.push({
+          packageJsonPath: relativePath,
+          scriptPort,
+          allocation: matchingAlloc ?? null,
+          reason: matchingAlloc ? `Script uses port ${scriptPort} but allocation has port ${matchingAlloc.port}` : `Port ${scriptPort} in scripts is not in any allocation`
+        });
       }
+    } catch {
     }
-  } catch (err) {
-    console.warn(
-      `    Tech stack detection skipped: ${err instanceof Error ? err.message : String(err)}`
-    );
   }
+  return mismatches;
 }
-async function syncEslintDriftCheck(repoId, projectPath) {
-  try {
-    const hasDrift = await checkEslintDrift(repoId, projectPath);
-    if (hasDrift) {
-      console.log(
-        "    ESLint config drift detected. Run `codebyplan eslint sync` to update."
-      );
-    } else {
-      console.log("    ESLint configs up to date.");
+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 unallocated = [];
+  for (const app of apps) {
+    if (portAllocations.some((a) => labelMatchesAppName(a.label ?? "", app.name))) {
+      continue;
     }
-  } catch (error) {
-    console.warn("    ESLint drift check skipped:", error);
+    let pkg;
+    try {
+      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;
 }
-async function syncPortVerification(repoId, projectPath, dryRun, fix) {
+function getAppLabel(relativePath) {
+  const parts = relativePath.split("/");
+  if (parts.length >= 3 && parts[0] === "apps") {
+    return parts[1];
+  }
+  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/cli/ports.ts
+var ports_exports = {};
+__export(ports_exports, {
+  runPorts: () => runPorts
+});
+async function runPorts() {
+  const flags = parseFlags(3);
+  const dryRun = hasFlag("dry-run", 3);
+  const fix = hasFlag("fix", 3);
+  validateApiKey();
+  const config = await resolveConfig(flags);
+  const { repoId, projectPath } = config;
+  console.log(`
+  CodeByPlan Ports`);
+  console.log(`  Repo: ${repoId}`);
+  console.log(`  Path: ${projectPath}`);
+  if (dryRun) console.log(`  Mode: dry-run`);
+  if (fix) console.log(`  Mode: fix`);
+  console.log();
   try {
     const portsRes = await apiGet(
       `/port-allocations`,
@@ -3885,22 +2241,23 @@ async function syncPortVerification(repoId, projectPath, dryRun, fix) {
     );
     const allocations = portsRes.data ?? [];
     if (allocations.length === 0) {
-      console.log("    No port allocations found \u2014 skipping verification.");
+      console.log("  No port allocations found \u2014 skipping verification.");
+      console.log("\n  Ports complete.\n");
       return;
     }
     const mismatches = await verifyPorts(projectPath, allocations);
     if (mismatches.length > 0) {
-      console.log(`    Port mismatches: ${mismatches.length}`);
+      console.log(`  Port mismatches: ${mismatches.length}`);
       for (const m of mismatches) {
-        console.log(`      ! ${m.packageJsonPath}: ${m.reason}`);
+        console.log(`    ! ${m.packageJsonPath}: ${m.reason}`);
       }
     }
     const unallocated = await findUnallocatedApps(projectPath, allocations);
     if (unallocated.length > 0) {
-      console.log(`    Unallocated apps: ${unallocated.length}`);
+      console.log(`  Unallocated apps: ${unallocated.length}`);
       for (const app of unallocated) {
         console.log(
-          `      + ${app.name} (${app.framework}${app.detectedPort ? `, port ${app.detectedPort}` : ""})`
+          `    + ${app.name} (${app.framework}${app.detectedPort ? `, port ${app.detectedPort}` : ""})`
         );
       }
       if (fix && !dryRun) {
@@ -3918,11 +2275,11 @@ async function syncPortVerification(repoId, projectPath, dryRun, fix) {
               command: app.command,
               working_dir: app.path
             });
-            console.log(`      Created allocation: ${app.name} \u2192 port ${port}`);
+            console.log(`    Created allocation: ${app.name} \u2192 port ${port}`);
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             console.log(
-              `      Failed to create allocation for ${app.name}: ${msg}`
+              `    Failed to create allocation for ${app.name}: ${msg}`
             );
           }
           if (app.detectedPort && app.detectedPort >= nextPort) {
@@ -3930,123 +2287,180 @@ async function syncPortVerification(repoId, projectPath, dryRun, fix) {
           }
         }
       } else if (fix && dryRun) {
-        console.log("    (dry-run \u2014 would create allocations with --fix)");
+        console.log("  (dry-run \u2014 would create allocations with --fix)");
       } else {
-        console.log("    Run with --fix to auto-create allocations.");
+        console.log("  Run with --fix to auto-create allocations.");
       }
     }
     if (mismatches.length === 0 && unallocated.length === 0) {
-      console.log("    Ports verified.");
+      console.log("  Ports verified.");
     }
   } catch (err) {
     console.warn(
-      `    Port verification skipped: ${err instanceof Error ? err.message : String(err)}`
+      `  Port verification skipped: ${err instanceof Error ? err.message : String(err)}`
     );
   }
+  console.log("\n  Ports complete.\n");
 }
-function groupByType(items) {
-  const groups = /* @__PURE__ */ new Map();
-  const typeLabels = {
-    command: "Commands",
-    agent: "Agents",
-    skill: "Skills",
-    rule: "Rules",
-    hook: "Hooks",
-    template: "Templates",
-    settings: "Settings",
-    context: "Context",
-    docs_stack: "Stack Docs",
-    docs: "Docs"
-  };
-  for (const item of items) {
-    const label = typeLabels[item.type] ?? item.type;
-    const group = groups.get(label) ?? [];
-    group.push(item);
-    groups.set(label, group);
+var init_ports = __esm({
+  "src/cli/ports.ts"() {
+    "use strict";
+    init_flags();
+    init_api();
+    init_port_verify();
   }
-  return groups;
-}
-function getLocalFilePath(claudeDir, projectPath, remote) {
-  const typeConfig2 = {
-    command: { dir: "commands", ext: ".md" },
-    agent: { dir: "agents", ext: ".md", subfolder: "AGENT" },
-    skill: { dir: "skills", ext: ".md", subfolder: "SKILL" },
-    rule: { dir: "rules", ext: ".md" },
-    hook: { dir: "hooks", ext: ".sh" },
-    template: { dir: "templates", ext: "" },
-    context: { dir: "context", 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 join9(projectPath, "CLAUDE.md");
-  if (remote.type === "settings") return join9(claudeDir, "settings.json");
-  const cfg = typeConfig2[remote.type];
-  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 join9(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
-  if (remote.type === "command" && remote.category)
-    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 join9(typeDir, remote.category, `${remote.name}${cfg.ext}`);
-  return join9(typeDir, `${remote.name}${cfg.ext}`);
+});
+
+// src/lib/migrate-local-config.ts
+import { readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+function sharedConfigPath(projectPath) {
+  return join8(projectPath, ".codebyplan.json");
 }
-function getSyncVersion() {
+async function needsLocalMigration(projectPath) {
   try {
-    return "1.4.3";
+    const raw = await readFile9(sharedConfigPath(projectPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return false;
+    }
+    const cfg = parsed;
+    if (typeof cfg.worktree_id !== "string" || cfg.worktree_id === "") {
+      return false;
+    }
+    const local = await readLocalConfig(projectPath);
+    if (local?.device_id) {
+      return false;
+    }
+    return true;
   } catch {
-    return "unknown";
+    return false;
   }
 }
-function flattenSyncData(data) {
-  const result = /* @__PURE__ */ new Map();
-  const typeMap = {
-    commands: "command",
-    agents: "agent",
-    skills: "skill",
-    rules: "rule",
-    hooks: "hook",
-    templates: "template",
-    settings: "settings",
-    contexts: "context",
-    docs_stack: "docs_stack",
-    docs: "docs"
+async function runLocalMigration(projectPath) {
+  const raw = await readFile9(sharedConfigPath(projectPath), "utf-8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(
+      ".codebyplan.json does not contain a JSON object \u2014 cannot migrate"
+    );
+  }
+  const cfg = parsed;
+  const hadWorktreeId = "worktree_id" in cfg;
+  const localBefore = await readLocalConfig(projectPath);
+  const localWillBeCreated = !localBefore?.device_id;
+  const device_id = await getOrCreateDeviceId(projectPath);
+  const cleaned = { ...cfg };
+  delete cleaned.worktree_id;
+  await writeFile6(
+    sharedConfigPath(projectPath),
+    JSON.stringify(cleaned, null, 2) + "\n",
+    "utf-8"
+  );
+  const files_changed = [".codebyplan.json"];
+  if (localWillBeCreated) files_changed.push(".codebyplan.local.json");
+  return {
+    migrated: true,
+    was_dirty: hadWorktreeId || localWillBeCreated,
+    files_changed,
+    device_id
   };
-  for (const [syncKey, typeName] of Object.entries(typeMap)) {
-    const files = data[syncKey] ?? [];
-    for (const file of files) {
-      const key = compositeKey(typeName, file.name, file.category ?? null);
-      result.set(key, {
-        id: file.id,
-        type: typeName,
-        name: file.name,
-        content: file.content,
-        category: file.category,
-        updated_at: file.updated_at,
-        content_hash: file.content_hash,
-        scope: file.scope
-      });
+}
+var init_migrate_local_config = __esm({
+  "src/lib/migrate-local-config.ts"() {
+    "use strict";
+    init_local_config();
+  }
+});
+
+// src/cli/tech-stack.ts
+var tech_stack_exports = {};
+__export(tech_stack_exports, {
+  runTechStack: () => runTechStack
+});
+async function runTechStack() {
+  const flags = parseFlags(3);
+  const dryRun = hasFlag("dry-run", 3);
+  validateApiKey();
+  const config = await resolveConfig(flags);
+  const { repoId, projectPath } = config;
+  console.log(`
+  CodeByPlan Tech Stack`);
+  console.log(`  Repo: ${repoId}`);
+  console.log(`  Path: ${projectPath}`);
+  if (dryRun) console.log(`  Mode: dry-run`);
+  console.log();
+  if (dryRun) {
+    try {
+      if (await needsLocalMigration(projectPath)) {
+        console.log(
+          `  Would migrate .codebyplan.json -> worktree_id to .codebyplan.local.json (dry-run, skipping actual write).`
+        );
+      }
+    } catch {
+    }
+  } else {
+    try {
+      if (await needsLocalMigration(projectPath)) {
+        const result = await runLocalMigration(projectPath);
+        console.log(
+          `  Migrated .codebyplan.json -> moved worktree_id to gitignored .codebyplan.local.json (device_id=${result.device_id.slice(0, 8)})`
+        );
+        console.log(
+          `  Suggest /cbp-git-commit to stage the cleaned shared file.`
+        );
+      }
+    } catch (err) {
+      console.warn(
+        `  Warning: local migration failed (continuing): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  try {
+    const { dependencies } = await scanAllDependencies(projectPath);
+    if (dependencies.length === 0) {
+      console.log("  No dependencies found.");
+      console.log("\n  Tech stack complete.\n");
+      return;
+    }
+    const sourcePaths = new Set(dependencies.map((d) => d.source_path));
+    console.log(
+      `  ${dependencies.length} dependencies from ${sourcePaths.size} package.json file${sourcePaths.size !== 1 ? "s" : ""}`
+    );
+    if (!dryRun) {
+      const result = await apiPost(`/repos/${repoId}/tech-stack`, { dependencies });
+      if (result.data.stale_removed > 0) {
+        console.log(
+          `  ${result.data.stale_removed} stale dependencies removed`
+        );
+      }
     }
+    const detected = await detectTechStack(projectPath);
+    if (detected.flat.length > 0) {
+      const repoRes = await apiGet(`/repos/${repoId}`);
+      const remote = parseTechStackResult(repoRes.data.tech_stack);
+      const { merged, added } = mergeTechStack(remote, detected);
+      if (added.length > 0) {
+        console.log(`  ${added.length} new tech entries`);
+        if (!dryRun) {
+          await apiPut(`/repos/${repoId}`, { tech_stack: merged });
+        }
+      }
+    }
+  } catch (err) {
+    console.warn(
+      `  Tech stack detection skipped: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
-  return result;
+  console.log("\n  Tech stack complete.\n");
 }
-var init_sync = __esm({
-  "src/cli/sync.ts"() {
+var init_tech_stack = __esm({
+  "src/cli/tech-stack.ts"() {
     "use strict";
-    init_config();
-    init_fileMapper();
-    init_confirm();
+    init_flags();
     init_api();
-    init_variables();
     init_tech_detect();
-    init_settings_merge();
-    init_hook_registry();
-    init_port_verify();
-    init_resolve_worktree();
-    init_eslint();
+    init_migrate_local_config();
   }
 });
 
@@ -4086,20 +2500,6 @@ void (async () => {
     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;
-    }
-    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));
@@ -4114,27 +2514,58 @@ void (async () => {
     }
     process.exit(0);
   }
+  if (arg === "resolve-worktree") {
+    const { runResolveWorktree: runResolveWorktree2 } = await Promise.resolve().then(() => (init_resolve_worktree2(), resolve_worktree_exports));
+    await runResolveWorktree2();
+    process.exit(0);
+  }
+  if (arg === "config") {
+    const { runConfig: runConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    await runConfig2();
+    process.exit(0);
+  }
+  if (arg === "ports") {
+    const { runPorts: runPorts2 } = await Promise.resolve().then(() => (init_ports(), ports_exports));
+    await runPorts2();
+    process.exit(0);
+  }
+  if (arg === "tech-stack") {
+    const { runTechStack: runTechStack2 } = await Promise.resolve().then(() => (init_tech_stack(), tech_stack_exports));
+    await runTechStack2();
+    process.exit(0);
+  }
   if (arg === "help" || arg === "--help" || arg === "-h" || arg === void 0) {
     console.log(`
   CodeByPlan CLI v${VERSION}
 
   Usage:
-    codebyplan setup        Interactive setup (API key + project init + first sync)
-    codebyplan sync         Bidirectional sync (pull + push + config)
-    codebyplan eslint       ESLint config management (init, sync)
-    codebyplan help         Show this help message
-    codebyplan --version    Print version
+    codebyplan setup             Interactive setup (API key + project init)
+    codebyplan config            Sync repo config from DB to .codebyplan.json
+    codebyplan ports             Verify port allocations against local package.json scripts
+    codebyplan tech-stack        Detect and sync tech stack dependencies
+    codebyplan eslint            ESLint config management (init)
+    codebyplan resolve-worktree  Resolve active worktree UUID from device+path+branch tuple
+    codebyplan help              Show this help message
+    codebyplan --version         Print version
 
-  Sync options:
+  Config options:
+    --path <dir>            Project root directory (default: cwd)
+    --repo-id <uuid>        Repository ID (or set via .codebyplan.json)
+    --dry-run               Preview changes without writing
+
+  Ports options:
     --path <dir>            Project root directory (default: cwd)
     --repo-id <uuid>        Repository ID (or set via .codebyplan.json)
     --dry-run               Preview changes without writing
-    --force                 Skip confirmation and conflict prompts
     --fix                   Auto-create missing port allocations
 
+  Tech stack options:
+    --path <dir>            Project root directory (default: cwd)
+    --repo-id <uuid>        Repository ID (or set via .codebyplan.json)
+    --dry-run               Preview changes without writing
+
   ESLint commands:
     codebyplan eslint init  Detect tech stack, resolve presets, generate configs
-    codebyplan eslint sync  Regenerate if presets changed, detect drift
 
   MCP Server:
     Claude Code connects to CodeByPlan via remote MCP: