@codebyplan/cli 3.1.0 → 3.3.0

package/dist/cli.js

@@ -37,7 +37,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "3.1.0";
+    VERSION = "3.3.0";
     PACKAGE_NAME = "@codebyplan/cli";
   }
 });
@@ -71,13 +71,17 @@ async function validateConnectivity() {
       );
     }
     if (!res.ok) {
-      console.error(`Warning: API returned status ${res.status} during connectivity check`);
+      console.error(
+        `Warning: API returned status ${res.status} during connectivity check`
+      );
     }
   } catch (err) {
     if (err instanceof Error && err.message.includes("Invalid API key")) {
       throw err;
     }
-    console.error("Warning: Could not reach CodeByPlan API. Requests may fail.");
+    console.error(
+      "Warning: Could not reach CodeByPlan API. Requests may fail."
+    );
   }
 }
 function buildUrl(path, params) {
@@ -166,8 +170,8 @@ async function apiPut(path, body) {
 async function apiPatch(path, body) {
   return request("PATCH", path, { body });
 }
-async function apiDelete(path) {
-  await request("DELETE", path);
+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({
@@ -175,10 +179,7 @@ var init_api = __esm({
     "use strict";
     init_version();
     API_KEY = process.env.CODEBYPLAN_API_KEY ?? "";
-    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com").replace(
-      /\/$/,
-      ""
-    );
+    BASE_URL = (process.env.CODEBYPLAN_API_URL ?? "https://codebyplan.com").replace(/\/$/, "");
     REQUEST_TIMEOUT_MS = 3e4;
     MAX_RETRIES = 3;
     BASE_DELAY_MS = 1e3;
@@ -665,7 +666,51 @@ async function executeSyncToLocal(options) {
     byType[typeName] = result;
   }
   if (!dryRun) {
-    await apiPut(`/repos/${repoId}`, { claude_sync_at: (/* @__PURE__ */ new Date()).toISOString() });
+    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] of Object.entries(syncKeyToType)) {
+      const remoteFiles = syncData[syncKey] ?? [];
+      for (const file of remoteFiles) {
+        if (file.id) {
+          fileRepoUpdates.push({
+            claude_file_id: file.id,
+            last_synced_at: syncTimestamp,
+            sync_status: "synced"
+          });
+        }
+      }
+    }
+    for (const typeName of ["claude_md", "settings"]) {
+      const remoteFiles = syncData[typeName] ?? [];
+      for (const file of remoteFiles) {
+        if (file.id) {
+          fileRepoUpdates.push({
+            claude_file_id: file.id,
+            last_synced_at: syncTimestamp,
+            sync_status: "synced"
+          });
+        }
+      }
+    }
+    if (fileRepoUpdates.length > 0) {
+      try {
+        await apiPost("/sync/file-repos", {
+          repo_id: repoId,
+          file_repos: fileRepoUpdates
+        });
+      } catch {
+      }
+    }
   }
   return { byType, totals, dbOnlyFiles };
 }
@@ -683,7 +728,8 @@ var init_sync_engine = __esm({
       skill: { dir: "skills", ext: ".md", subfolder: "SKILL" },
       rule: { dir: "rules", ext: ".md" },
       hook: { dir: "hooks", ext: ".sh" },
-      template: { dir: "templates", ext: "" }
+      template: { dir: "templates", ext: "" },
+      context: { dir: "context", ext: ".md" }
     };
     syncKeyToType = {
       commands: "command",
@@ -691,7 +737,8 @@ var init_sync_engine = __esm({
       skills: "skill",
       rules: "rule",
       hooks: "hook",
-      templates: "template"
+      templates: "template",
+      contexts: "context"
     };
   }
 });
@@ -1051,14 +1098,34 @@ var init_fileMapper = __esm({
 });
 
 // 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 {
-    const answer = await rl.question(message ?? "  Proceed? [Y/n] ");
-    const a = answer.trim().toLowerCase();
-    return a !== "n" && a !== "no";
+    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();
   }
@@ -1069,6 +1136,9 @@ async function promptChoice(message, options) {
     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();
   }
@@ -1088,20 +1158,232 @@ async function confirmEach(items, label) {
         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 readFile6, readdir as readdir4, access } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { readFile as readFile6, access, readdir as readdir4 } from "node:fs/promises";
+import { join as join6, relative } from "node:path";
 async function fileExists(filePath) {
   try {
     await access(filePath);
@@ -1110,14 +1392,56 @@ async function fileExists(filePath) {
     return false;
   }
 }
-async function scanPackageJson(pkgPath, seen) {
+async function discoverMonorepoApps(projectPath) {
+  const apps = [];
+  const patterns = [];
+  try {
+    const raw = await readFile6(join6(projectPath, "pnpm-workspace.yaml"), "utf-8");
+    const matches = raw.match(/^\s*-\s*['"]?([^'"#\n]+)['"]?/gm);
+    if (matches) {
+      for (const m of matches) {
+        const pattern = m.replace(/^\s*-\s*['"]?/, "").replace(/['"]?\s*$/, "").trim();
+        if (pattern) patterns.push(pattern);
+      }
+    }
+  } catch {
+  }
+  if (patterns.length === 0) {
+    try {
+      const raw = await readFile6(join6(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);
+    } catch {
+    }
+  }
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const dir = pattern.slice(0, -2);
+      const absDir = join6(projectPath, dir);
+      try {
+        const entries = await readdir4(absDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const relPath = join6(dir, entry.name);
+            const absPath = join6(absDir, entry.name);
+            if (await fileExists(join6(absPath, "package.json"))) {
+              apps.push({ name: entry.name, path: relPath, absPath });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return apps;
+}
+async function detectFromDirectory(dirPath) {
+  const seen = /* @__PURE__ */ new Map();
   try {
-    const raw = await readFile6(pkgPath, "utf-8");
+    const raw = await readFile6(join6(dirPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
-    const allDeps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const depName of Object.keys(allDeps)) {
       const rule = PACKAGE_MAP[depName];
       if (rule) {
@@ -1125,79 +1449,183 @@ async function scanPackageJson(pkgPath, seen) {
         if (!seen.has(key)) {
           seen.set(key, { name: rule.name, category: rule.category });
         }
+        continue;
+      }
+      for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
+        if (depName.startsWith(prefix)) {
+          const key = prefixRule.name.toLowerCase();
+          if (!seen.has(key)) {
+            seen.set(key, { name: prefixRule.name, category: prefixRule.category });
+          }
+          break;
+        }
       }
     }
   } catch {
   }
-}
-async function scanConfigFiles(dir, seen) {
   for (const { file, rule } of CONFIG_FILE_MAP) {
     const key = rule.name.toLowerCase();
-    if (!seen.has(key) && await fileExists(join6(dir, file))) {
+    if (!seen.has(key) && await fileExists(join6(dirPath, file))) {
       seen.set(key, { name: rule.name, category: rule.category });
     }
   }
+  return Array.from(seen.values()).sort((a, b) => {
+    const catCmp = a.category.localeCompare(b.category);
+    if (catCmp !== 0) return catCmp;
+    return a.name.localeCompare(b.name);
+  });
 }
-async function detectWorkspaceDirs(projectPath) {
-  const isTurbo = await fileExists(join6(projectPath, "turbo.json"));
-  const isPnpm = await fileExists(join6(projectPath, "pnpm-workspace.yaml"));
-  if (!isTurbo && !isPnpm) return [];
-  const dirs = [];
-  for (const parent of ["apps", "packages"]) {
-    try {
-      const entries = await readdir4(join6(projectPath, parent), { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          dirs.push(join6(projectPath, parent, entry.name));
-        }
-      }
-    } catch {
+async function detectTechStack(projectPath) {
+  const repo = await detectFromDirectory(projectPath);
+  const discoveredApps = await discoverMonorepoApps(projectPath);
+  const apps = [];
+  for (const app of discoveredApps) {
+    const stack = await detectFromDirectory(app.absPath);
+    if (stack.length > 0) {
+      apps.push({ name: app.name, path: app.path, stack });
     }
   }
-  return dirs;
-}
-async function detectTechStack(projectPath) {
-  const seen = /* @__PURE__ */ new Map();
-  await scanPackageJson(join6(projectPath, "package.json"), seen);
-  await scanConfigFiles(projectPath, seen);
-  const workspaceDirs = await detectWorkspaceDirs(projectPath);
-  for (const dir of workspaceDirs) {
-    await scanPackageJson(join6(dir, "package.json"), seen);
-    await scanConfigFiles(dir, seen);
+  const flatMap = /* @__PURE__ */ new Map();
+  for (const entry of repo) {
+    flatMap.set(entry.name.toLowerCase(), entry);
   }
-  return Array.from(seen.values()).sort((a, b) => {
+  for (const app of apps) {
+    for (const entry of app.stack) {
+      const key = entry.name.toLowerCase();
+      if (!flatMap.has(key)) {
+        flatMap.set(key, entry);
+      }
+    }
+  }
+  const flat = Array.from(flatMap.values()).sort((a, b) => {
     const catCmp = a.category.localeCompare(b.category);
     if (catCmp !== 0) return catCmp;
     return a.name.localeCompare(b.name);
   });
+  return { repo, apps, flat };
 }
 function mergeTechStack(remote, detected) {
+  const remoteResult = Array.isArray(remote) ? { repo: remote, apps: [], flat: remote } : remote;
   const seen = /* @__PURE__ */ new Map();
-  for (const entry of remote) {
+  for (const entry of remoteResult.flat) {
     seen.set(entry.name.toLowerCase(), entry);
   }
   const added = [];
-  for (const entry of detected) {
+  for (const entry of detected.flat) {
     const key = entry.name.toLowerCase();
     if (!seen.has(key)) {
       seen.set(key, entry);
       added.push(entry);
     }
   }
-  const merged = Array.from(seen.values()).sort((a, b) => {
+  const flat = Array.from(seen.values()).sort((a, b) => {
     const catCmp = a.category.localeCompare(b.category);
     if (catCmp !== 0) return catCmp;
     return a.name.localeCompare(b.name);
   });
+  const merged = {
+    repo: detected.repo,
+    apps: detected.apps,
+    flat
+  };
   return { merged, added };
 }
 function parseTechStack(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter(
+      (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.category === "string"
+    );
+  }
+  if (typeof raw === "object" && raw !== null && "flat" in raw) {
+    return parseTechStack(raw.flat);
+  }
+  return [];
+}
+function parseAppTechStacks(raw) {
   if (!Array.isArray(raw)) return [];
   return raw.filter(
-    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.category === "string"
-  );
+    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.path === "string" && Array.isArray(item.stack)
+  ).map((item) => ({
+    name: item.name,
+    path: item.path,
+    stack: parseTechStack(item.stack)
+  }));
+}
+function parseTechStackResult(raw) {
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && "flat" in raw) {
+    const obj = raw;
+    return {
+      repo: parseTechStack(obj.repo),
+      apps: parseAppTechStacks(obj.apps),
+      flat: parseTechStack(obj.flat)
+    };
+  }
+  const flat = parseTechStack(raw);
+  return { repo: flat, apps: [], flat };
+}
+function categorizeDependency(depName) {
+  const rule = PACKAGE_MAP[depName];
+  if (rule) return rule.category;
+  for (const { prefix, rule: prefixRule } of PACKAGE_PREFIX_MAP) {
+    if (depName.startsWith(prefix)) return prefixRule.category;
+  }
+  return "other";
+}
+async function findPackageJsonFiles(dir, projectPath, depth = 0) {
+  if (depth > 4) return [];
+  const results = [];
+  const pkgPath = join6(dir, "package.json");
+  if (await fileExists(pkgPath)) {
+    results.push(pkgPath);
+  }
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+      const subResults = await findPackageJsonFiles(
+        join6(dir, entry.name),
+        projectPath,
+        depth + 1
+      );
+      results.push(...subResults);
+    }
+  } catch {
+  }
+  return results;
+}
+async function scanAllDependencies(projectPath) {
+  const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
+  const dependencies = [];
+  for (const pkgPath of packageJsonPaths) {
+    try {
+      const raw = await readFile6(pkgPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const sourcePath = relative(projectPath, pkgPath);
+      const depSections = [
+        { deps: pkg.dependencies, depType: "production", isDev: false },
+        { deps: pkg.devDependencies, depType: "dev", isDev: true },
+        { deps: pkg.peerDependencies, depType: "peer", isDev: false },
+        { deps: pkg.optionalDependencies, depType: "optional", isDev: false }
+      ];
+      for (const { deps, depType, isDev } of depSections) {
+        if (!deps) continue;
+        for (const [name, version2] of Object.entries(deps)) {
+          dependencies.push({
+            name,
+            version: version2,
+            category: categorizeDependency(name),
+            source_path: sourcePath,
+            is_dev: isDev,
+            dep_type: depType
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return { dependencies };
 }
-var PACKAGE_MAP, CONFIG_FILE_MAP;
+var PACKAGE_MAP, PACKAGE_PREFIX_MAP, CONFIG_FILE_MAP, SKIP_DIRS;
 var init_tech_detect = __esm({
   "src/lib/tech-detect.ts"() {
     "use strict";
@@ -1240,17 +1668,50 @@ var init_tech_detect = __esm({
       playwright: { name: "Playwright", category: "testing" },
       "@playwright/test": { name: "Playwright", category: "testing" },
       cypress: { name: "Cypress", category: "testing" },
+      supertest: { name: "Supertest", category: "testing" },
       // Build tools
       turbo: { name: "Turborepo", category: "build" },
       vite: { name: "Vite", category: "build" },
       webpack: { name: "Webpack", category: "build" },
       esbuild: { name: "esbuild", category: "build" },
       rollup: { name: "Rollup", category: "build" },
+      nx: { name: "Nx", category: "build" },
+      lerna: { name: "Lerna", category: "build" },
+      tsup: { name: "tsup", category: "build" },
+      "@swc/core": { name: "SWC", category: "build" },
+      parcel: { name: "Parcel", category: "build" },
       // Tools
       eslint: { name: "ESLint", category: "tool" },
       prettier: { name: "Prettier", category: "tool" },
-      "@biomejs/biome": { name: "Biome", category: "tool" }
-    };
+      "@biomejs/biome": { name: "Biome", category: "tool" },
+      storybook: { name: "Storybook", category: "tool" },
+      // Component libs
+      "@mui/material": { name: "MUI", category: "component-lib" },
+      "@chakra-ui/react": { name: "Chakra UI", category: "component-lib" },
+      "@mantine/core": { name: "Mantine", category: "component-lib" },
+      // GraphQL
+      graphql: { name: "GraphQL", category: "graphql" },
+      "@apollo/client": { name: "Apollo Client", category: "graphql" },
+      urql: { name: "urql", category: "graphql" },
+      "graphql-request": { name: "graphql-request", category: "graphql" },
+      // Documentation
+      typedoc: { name: "TypeDoc", category: "documentation" },
+      "@docusaurus/core": { name: "Docusaurus", category: "documentation" },
+      vitepress: { name: "VitePress", category: "documentation" },
+      // Code quality
+      husky: { name: "Husky", category: "quality" },
+      "lint-staged": { name: "lint-staged", category: "quality" },
+      commitlint: { name: "commitlint", category: "quality" },
+      "@commitlint/cli": { name: "commitlint", category: "quality" },
+      // Mobile
+      "react-native": { name: "React Native", category: "mobile" },
+      expo: { name: "Expo", category: "mobile" }
+    };
+    PACKAGE_PREFIX_MAP = [
+      { prefix: "@radix-ui/", rule: { name: "Radix UI", category: "component-lib" } },
+      { prefix: "@storybook/", rule: { name: "Storybook", category: "tool" } },
+      { prefix: "@testing-library/", rule: { name: "Testing Library", category: "testing" } }
+    ];
     CONFIG_FILE_MAP = [
       { file: "tsconfig.json", rule: { name: "TypeScript", category: "language" } },
       { file: "next.config.js", rule: { name: "Next.js", category: "framework" } },
@@ -1262,120 +1723,26 @@ var init_tech_detect = __esm({
       { file: "docker-compose.yml", rule: { name: "Docker", category: "deployment" } },
       { file: "docker-compose.yaml", rule: { name: "Docker", category: "deployment" } },
       { file: "Dockerfile", rule: { name: "Docker", category: "deployment" } },
-      { file: "vercel.json", rule: { name: "Vercel", category: "deployment" } }
+      { file: "vercel.json", rule: { name: "Vercel", category: "deployment" } },
+      { file: ".storybook/main.js", rule: { name: "Storybook", category: "tool" } },
+      { file: ".storybook/main.ts", rule: { name: "Storybook", category: "tool" } },
+      { file: ".storybook/main.mjs", rule: { name: "Storybook", category: "tool" } },
+      { file: "components.json", rule: { name: "shadcn/ui", category: "component-lib" } },
+      { file: "nx.json", rule: { name: "Nx", category: "build" } },
+      { file: "lerna.json", rule: { name: "Lerna", category: "build" } }
     ];
-  }
-});
-
-// src/lib/server-detect.ts
-import { readFile as readFile7, readdir as readdir5, access as access2 } from "node:fs/promises";
-import { join as join7 } from "node:path";
-async function fileExists2(filePath) {
-  try {
-    await access2(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function detectPackageManager(dir) {
-  return (async () => {
-    if (await fileExists2(join7(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(join7(dir, "yarn.lock"))) return "yarn";
-    return "npm";
-  })();
-}
-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;
-      }
-    }
-  }
-  return null;
-}
-async function isMonorepo(dir) {
-  return await fileExists2(join7(dir, "turbo.json")) || await fileExists2(join7(dir, "pnpm-workspace.yaml"));
-}
-async function detectServers(projectPath) {
-  let pkg;
-  try {
-    const raw = await readFile7(join7(projectPath, "package.json"), "utf-8");
-    pkg = JSON.parse(raw);
-  } catch {
-    return {
-      name: "unknown",
-      isMonorepo: false,
-      packageManager: "npm",
-      servers: []
-    };
-  }
-  const rawName = pkg.name ?? "unknown";
-  const name = rawName.startsWith("@") ? projectPath.split("/").pop() ?? rawName : rawName;
-  const pkgManager = await detectPackageManager(projectPath);
-  const mono = await isMonorepo(projectPath);
-  const servers = [];
-  if (mono) {
-    const appsDir = join7(projectPath, "apps");
-    try {
-      const entries = await readdir5(appsDir, { withFileTypes: true });
-      const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
-      for (const entry of sorted) {
-        if (!entry.isDirectory()) continue;
-        const appPkgPath = join7(appsDir, entry.name, "package.json");
-        try {
-          const appRaw = await readFile7(appPkgPath, "utf-8");
-          const appPkg = JSON.parse(appRaw);
-          const appName = entry.name;
-          const framework = detectFramework(appPkg);
-          const port = detectPortFromScripts(appPkg);
-          let command;
-          switch (pkgManager) {
-            case "pnpm":
-              command = `pnpm --filter ${appName} dev`;
-              break;
-            case "yarn":
-              command = `yarn workspace ${appName} dev`;
-              break;
-            default:
-              command = `npm run dev -w apps/${appName}`;
-              break;
-          }
-          servers.push({ label: appName, port, command, server_type: framework });
-        } catch {
-        }
-      }
-    } catch {
-    }
-  } else {
-    const framework = detectFramework(pkg);
-    const port = detectPortFromScripts(pkg);
-    const command = `${pkgManager} run dev`;
-    servers.push({ label: "dev", port, command, server_type: framework });
-  }
-  return { name, isMonorepo: mono, packageManager: pkgManager, servers };
-}
-var init_server_detect = __esm({
-  "src/lib/server-detect.ts"() {
-    "use strict";
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".next",
+      "dist",
+      ".turbo",
+      ".git",
+      "coverage",
+      "build",
+      "out",
+      ".vercel",
+      ".expo"
+    ]);
   }
 });
 
@@ -1384,9 +1751,8 @@ var sync_exports = {};
 __export(sync_exports, {
   runSync: () => runSync
 });
-import { readFile as readFile8, writeFile as writeFile3, mkdir as mkdir2, chmod as chmod2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join8, dirname as dirname2 } from "node:path";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir2, chmod as chmod2, unlink as unlink2 } from "node:fs/promises";
+import { join as join7, dirname as dirname2 } from "node:path";
 async function runSync() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -1401,21 +1767,67 @@ async function runSync() {
   if (dryRun) console.log(`  Mode: dry-run`);
   if (force) console.log(`  Mode: force`);
   console.log();
+  if (!dryRun) {
+    console.log("  Acquiring sync lock...");
+    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;
+      }
+    }
+  }
+  try {
+    await runSyncInner(repoId, projectPath, dryRun, force);
+  } finally {
+    if (!dryRun) {
+      try {
+        await apiDelete("/sync/lock", { repo_id: repoId });
+      } catch {
+      }
+    }
+  }
+}
+async function runSyncInner(repoId, projectPath, dryRun, force) {
   console.log("  Reading local and remote state...");
-  const claudeDir = join8(projectPath, ".claude");
+  const claudeDir = join7(projectPath, ".claude");
   let localFiles = /* @__PURE__ */ new Map();
   try {
     localFiles = await scanLocalFiles(claudeDir, projectPath);
   } catch {
   }
-  const [defaultsRes, repoSyncRes, repoRes] = await Promise.all([
+  const [defaultsRes, repoSyncRes, repoRes, syncStateRes] = await Promise.all([
     apiGet("/sync/defaults"),
     apiGet("/sync/files", { repo_id: repoId }),
-    apiGet(`/repos/${repoId}`)
+    apiGet(`/repos/${repoId}`),
+    apiGet("/sync/state", { repo_id: repoId })
   ]);
+  const syncStartTime = Date.now();
   const repoData = repoRes.data;
   const remoteDefaults = flattenSyncData(defaultsRes.data);
   const remoteRepoFiles = flattenSyncData(repoSyncRes.data);
+  const syncState = syncStateRes.data;
   const remoteFiles = new Map([...remoteDefaults, ...remoteRepoFiles]);
   console.log(`  Local: ${localFiles.size} files, Remote: ${remoteFiles.size} files
 `);
@@ -1429,21 +1841,27 @@ async function runSync() {
         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: null,
+        filePath: getLocalFilePath(claudeDir, projectPath, { type: local.type, name: local.name, category: local.category }),
         type: local.type,
         name: local.name,
         category: local.category,
-        isHook: local.type === "hook"
+        isHook: local.type === "hook",
+        claudeFileId: null
       });
     } else if (!local && remote) {
       const resolvedContent = substituteVariables(remote.content, repoData);
+      const isDefaultOnly = remoteDefaults.has(key) && !remoteRepoFiles.has(key);
+      const hasSyncedBefore = syncState?.last_synced_at != null;
+      const recommended = !isDefaultOnly && hasSyncedBefore ? "delete" : "pull";
       plan.push({
         key,
         displayPath: `${remote.type}/${remote.category ? remote.category + "/" : ""}${remote.name}`,
-        action: "pull",
+        action: recommended,
+        recommended,
         localContent: null,
         remoteContent: resolvedContent,
         pushContent: null,
@@ -1451,43 +1869,48 @@ async function runSync() {
         type: remote.type,
         name: remote.name,
         category: remote.category ?? null,
-        isHook: remote.type === "hook"
+        isHook: remote.type === "hook",
+        claudeFileId: remote.id ?? null
       });
     } else if (local && remote) {
       const resolvedRemote = substituteVariables(remote.content, repoData);
       if (local.content === resolvedRemote) {
         continue;
       }
-      const repoSyncAt = repoRes.data.claude_sync_at;
+      const lastSyncedAt = syncState?.last_synced_at;
       const remoteUpdatedAt = remote.updated_at;
-      const remoteChanged = remoteUpdatedAt && repoSyncAt ? new Date(remoteUpdatedAt) > new Date(repoSyncAt) : true;
+      const remoteChanged = remoteUpdatedAt && lastSyncedAt ? new Date(remoteUpdatedAt) > new Date(lastSyncedAt) : true;
       let action;
       if (remoteChanged && force) {
         action = "pull";
       } else if (!remoteChanged) {
         action = "push";
       } else {
-        action = "pull";
+        action = "conflict";
       }
       plan.push({
         key,
         displayPath: `${local.type}/${local.category ? local.category + "/" : ""}${local.name}`,
         action,
+        recommended: action === "conflict" ? "pull" : action,
         localContent: local.content,
         remoteContent: resolvedRemote,
-        pushContent: action === "push" ? reverseSubstituteVariables(local.content, repoData) : null,
+        pushContent: reverseSubstituteVariables(local.content, repoData),
         filePath: getLocalFilePath(claudeDir, projectPath, remote),
         type: local.type,
         name: local.name,
         category: local.category,
-        isHook: local.type === "hook"
+        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 remoteOnly = plan.filter((p) => p.action === "pull" && p.localContent === null);
+  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}`);
@@ -1496,99 +1919,186 @@ async function runSync() {
     console.log(`  Push (local \u2192 DB): ${pushes.length}`);
     for (const p of pushes) console.log(`    \u2191 ${p.displayPath}`);
   }
-  if (remoteOnly.length > 0) {
+  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(`
-  DB-only (not on disk): ${remoteOnly.length}`);
-    for (const p of remoteOnly) console.log(`    \u2715 ${p.displayPath}`);
+  Conflicts (both sides changed): ${conflicts.length}`);
+    for (const p of conflicts) console.log(`    \u26A0 ${p.displayPath}`);
   }
-  if (contentPulls.length === 0 && pushes.length === 0 && remoteOnly.length === 0) {
+  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) {
-    let toDelete = [];
-    let toPull = contentPulls;
-    if (remoteOnly.length > 0) {
-      console.log();
-      console.log(`  ${remoteOnly.length} file(s) exist in DB but not locally.`);
-      const choice = await promptChoice(
-        "  Delete from DB? [a]ll / [o]ne-by-one / [p]ull instead: ",
-        ["a", "o", "p"]
-      );
-      if (choice === "a") {
-        toDelete = remoteOnly;
-      } else if (choice === "o") {
-        toDelete = await confirmEach(
-          remoteOnly,
-          (p) => p.displayPath
-        );
-        const deleteKeys = new Set(toDelete.map((d) => d.key));
-        const pullBack = remoteOnly.filter((p) => !deleteKeys.has(p.key));
-        toPull = [...toPull, ...pullBack];
-      } else {
-        toPull = [...toPull, ...remoteOnly];
-      }
-    }
-    if (toPull.length + pushes.length + toDelete.length > 0 && !force) {
-      if (toPull.length > 0 || pushes.length > 0) {
-        const confirmed = await confirmProceed(
-          `
-  Apply ${toPull.length} pull(s), ${pushes.length} push(es), ${toDelete.length} deletion(s)? [Y/n] `
-        );
-        if (!confirmed) {
-          console.log("  Cancelled.\n");
-          return;
+    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];
+            }
+          }
         }
       }
     }
-    for (const p of toPull) {
-      if (p.filePath && p.remoteContent !== null) {
-        await mkdir2(dirname2(p.filePath), { recursive: true });
-        await writeFile3(p.filePath, p.remoteContent, "utf-8");
-        if (p.isHook) await chmod2(p.filePath, 493);
+    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 writeFile3(p.filePath, p.remoteContent, "utf-8");
+          if (p.isHook) await chmod2(p.filePath, 493);
+        }
       }
-    }
-    const toUpsert = pushes.filter((p) => p.pushContent !== null).map((p) => ({
-      type: p.type,
-      name: p.name,
-      category: p.category,
-      content: p.pushContent
-    }));
-    if (toUpsert.length > 0) {
-      await apiPost("/sync/files", {
-        repo_id: repoId,
-        files: toUpsert
-      });
-    }
-    if (toDelete.length > 0) {
-      const deleteKeys = toDelete.map((p) => ({
+      const toUpsert = toPush.filter((p) => p.pushContent !== null).map((p) => ({
         type: p.type,
         name: p.name,
-        category: p.category
+        category: p.category,
+        content: p.pushContent
       }));
-      await apiPost("/sync/files", {
-        repo_id: repoId,
-        delete_keys: deleteKeys
-      });
-    }
-    await apiPut(`/repos/${repoId}`, { claude_sync_at: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log(`
-  Applied: ${toPull.length} pulled, ${pushes.length} pushed, ${toDelete.length} deleted from DB`);
-  } 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("  Desktop server configs...");
-  await syncDesktopConfigs(repoId, projectPath, repoData, dryRun);
-  console.log("\n  Sync complete.\n");
-}
-async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun) {
-  const settingsPath = join8(claudeDir, "settings.json");
-  const globalSettingsFiles = syncData.global_settings ?? [];
+      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 {
+            }
+          }
+        }
+      }
+      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) {
+          if (p.claudeFileId) {
+            try {
+              await apiPost("/sync/conflicts", {
+                repo_id: repoId,
+                claude_file_id: p.claudeFileId,
+                conflict_type: "both_modified",
+                local_content: p.localContent,
+                remote_content: p.remoteContent
+              });
+              stored++;
+            } catch {
+            }
+          }
+        }
+        if (stored > 0) {
+          console.log(`
+  ${stored} conflict(s) stored in DB for later resolution.`);
+        }
+      }
+      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, ...toPush]) {
+        if (p.claudeFileId) {
+          fileRepoUpdates.push({
+            claude_file_id: p.claudeFileId,
+            last_synced_at: syncTimestamp,
+            sync_status: "synced"
+          });
+        }
+      }
+      if (fileRepoUpdates.length > 0) {
+        try {
+          await apiPost("/sync/file-repos", {
+            repo_id: repoId,
+            file_repos: fileRepoUpdates
+          });
+        } catch {
+        }
+      }
+      console.log(
+        `
+  Applied: ${toPull.length} pulled, ${toPush.length} pushed, ${toDelete.length} deleted` + (skipped.length > 0 ? `, ${skipped.length} skipped` : "")
+      );
+    }
+  } 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("\n  Sync complete.\n");
+}
+async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun) {
+  const settingsPath = join7(claudeDir, "settings.json");
+  const globalSettingsFiles = syncData.global_settings ?? [];
   let globalSettings = {};
   for (const gf of globalSettingsFiles) {
     const parsed = JSON.parse(substituteVariables(gf.content, repoData));
@@ -1600,11 +2110,11 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
     repoSettings = JSON.parse(substituteVariables(rf.content, repoData));
   }
   const combinedTemplate = mergeGlobalAndRepoSettings(globalSettings, repoSettings);
-  const hooksDir = join8(projectPath, ".claude", "hooks");
+  const hooksDir = join7(projectPath, ".claude", "hooks");
   const discovered = await discoverHooks(hooksDir);
   let localSettings = {};
   try {
-    const raw = await readFile8(settingsPath, "utf-8");
+    const raw = await readFile7(settingsPath, "utf-8");
     localSettings = JSON.parse(raw);
   } catch {
   }
@@ -1619,7 +2129,7 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   const mergedContent = JSON.stringify(merged, null, 2) + "\n";
   let currentContent = "";
   try {
-    currentContent = await readFile8(settingsPath, "utf-8");
+    currentContent = await readFile7(settingsPath, "utf-8");
   } catch {
   }
   if (currentContent === mergedContent) {
@@ -1635,10 +2145,10 @@ async function syncSettings(claudeDir, projectPath, syncData, repoData, dryRun)
   console.log("    Updated settings.json");
 }
 async function syncConfig(repoId, projectPath, dryRun) {
-  const configPath = join8(projectPath, ".codebyplan.json");
+  const configPath = join7(projectPath, ".codebyplan.json");
   let currentConfig = {};
   try {
-    const raw = await readFile8(configPath, "utf-8");
+    const raw = await readFile7(configPath, "utf-8");
     currentConfig = JSON.parse(raw);
   } catch {
     currentConfig = { repo_id: repoId };
@@ -1648,14 +2158,18 @@ async function syncConfig(repoId, projectPath, dryRun) {
   let portAllocations = [];
   try {
     const portsRes = await apiGet(`/port-allocations`, { repo_id: repoId });
-    portAllocations = portsRes.data ?? [];
+    const allAllocations = portsRes.data ?? [];
+    const worktreeId2 = currentConfig.worktree_id;
+    portAllocations = worktreeId2 ? allAllocations.filter((a) => a.worktree_id === worktreeId2) : allAllocations.filter((a) => !a.worktree_id);
   } catch {
   }
+  const worktreeId = currentConfig.worktree_id;
+  const matchingAlloc = portAllocations[0];
   const newConfig = {
     repo_id: repoId,
-    ...currentConfig.worktree_id ? { worktree_id: currentConfig.worktree_id } : {},
-    server_port: repo.server_port,
-    server_type: repo.server_type,
+    ...worktreeId ? { worktree_id: worktreeId } : {},
+    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",
     auto_push_enabled: repo.auto_push_enabled,
     ...portAllocations.length > 0 ? { port_allocations: portAllocations } : {}
@@ -1675,25 +2189,57 @@ async function syncConfig(repoId, projectPath, dryRun) {
 }
 async function syncTechStack(repoId, projectPath, dryRun) {
   try {
-    const detected = await detectTechStack(projectPath);
-    if (detected.length === 0) {
-      console.log("    No tech stack detected.");
+    const { dependencies } = await scanAllDependencies(projectPath);
+    if (dependencies.length === 0) {
+      console.log("    No dependencies found.");
       return;
     }
-    const repoRes = await apiGet(`/repos/${repoId}`);
-    const remote = parseTechStack(repoRes.data.tech_stack);
-    const { merged, added } = mergeTechStack(remote, detected);
-    console.log(`    ${detected.length} detected${added.length > 0 ? ` (${added.length} new)` : ""}`);
-    for (const entry of added) {
-      console.log(`      + ${entry.name} (${entry.category})`);
+    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`);
+      }
     }
-    if (added.length > 0 && !dryRun) {
-      await apiPut(`/repos/${repoId}`, { tech_stack: merged });
+    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 {
     console.log("    Tech stack detection skipped.");
   }
 }
+function groupByType(items) {
+  const groups = /* @__PURE__ */ new Map();
+  const typeLabels = {
+    command: "Commands",
+    agent: "Agents",
+    skill: "Skills",
+    rule: "Rules",
+    hook: "Hooks",
+    template: "Templates",
+    settings: "Settings"
+  };
+  for (const item of items) {
+    const label = typeLabels[item.type] ?? item.type;
+    const group = groups.get(label) ?? [];
+    group.push(item);
+    groups.set(label, group);
+  }
+  return groups;
+}
 function getLocalFilePath(claudeDir, projectPath, remote) {
   const typeConfig2 = {
     command: { dir: "commands", ext: ".md" },
@@ -1705,15 +2251,22 @@ function getLocalFilePath(claudeDir, projectPath, remote) {
     claude_md: { dir: "", ext: "" },
     settings: { dir: "", ext: "" }
   };
-  if (remote.type === "claude_md") return join8(projectPath, "CLAUDE.md");
-  if (remote.type === "settings") return join8(claudeDir, "settings.json");
+  if (remote.type === "claude_md") return join7(projectPath, "CLAUDE.md");
+  if (remote.type === "settings") return join7(claudeDir, "settings.json");
   const cfg = typeConfig2[remote.type];
-  if (!cfg) return join8(claudeDir, remote.name);
-  const typeDir = remote.type === "command" ? join8(claudeDir, cfg.dir, "cbp") : join8(claudeDir, cfg.dir);
-  if (cfg.subfolder) return join8(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
-  if (remote.type === "command" && remote.category) return join8(typeDir, remote.category, `${remote.name}${cfg.ext}`);
-  if (remote.type === "template") return join8(typeDir, remote.name);
-  return join8(typeDir, `${remote.name}${cfg.ext}`);
+  if (!cfg) return join7(claudeDir, remote.name);
+  const typeDir = remote.type === "command" ? join7(claudeDir, cfg.dir, "cbp") : join7(claudeDir, cfg.dir);
+  if (cfg.subfolder) return join7(typeDir, remote.name, `${cfg.subfolder}${cfg.ext}`);
+  if (remote.type === "command" && remote.category) return join7(typeDir, remote.category, `${remote.name}${cfg.ext}`);
+  if (remote.type === "template") return join7(typeDir, remote.name);
+  return join7(typeDir, `${remote.name}${cfg.ext}`);
+}
+function getSyncVersion() {
+  try {
+    return "3.3.0";
+  } catch {
+    return "unknown";
+  }
 }
 function flattenSyncData(data) {
   const result = /* @__PURE__ */ new Map();
@@ -1731,6 +2284,7 @@ function flattenSyncData(data) {
     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,
@@ -1741,99 +2295,6 @@ function flattenSyncData(data) {
   }
   return result;
 }
-async function syncDesktopConfigs(repoId, projectPath, repoData, dryRun) {
-  try {
-    const cbpDir = join8(homedir2(), ".codebyplan");
-    const configsPath = join8(cbpDir, "server-configs.json");
-    let configFile = { repos: [] };
-    try {
-      const raw = await readFile8(configsPath, "utf-8");
-      configFile = JSON.parse(raw);
-    } catch {
-    }
-    const detection = await detectServers(projectPath);
-    let portAllocations = [];
-    try {
-      const localConfigRaw = await readFile8(join8(projectPath, ".codebyplan.json"), "utf-8");
-      const localConfig = JSON.parse(localConfigRaw);
-      portAllocations = localConfig.port_allocations ?? [];
-    } catch {
-    }
-    const rootAllocations = portAllocations.filter((a) => !a.worktree_id);
-    const worktreeAllocations = portAllocations.filter((a) => a.worktree_id);
-    const matchDetected = (alloc) => {
-      let matched = detection.servers.find(
-        (s) => alloc.label.toLowerCase().includes(s.label.toLowerCase())
-      );
-      if (!matched) {
-        matched = detection.servers.find(
-          (s) => s.server_type === alloc.server_type
-        );
-      }
-      return {
-        label: alloc.label,
-        port: alloc.port,
-        command: matched?.command ?? "",
-        server_type: alloc.server_type,
-        auto_start: alloc.auto_start
-      };
-    };
-    let servers;
-    if (rootAllocations.length > 0) {
-      servers = rootAllocations.map(matchDetected);
-    } else {
-      servers = detection.servers.map((s) => ({
-        label: s.label,
-        port: s.port,
-        command: s.command,
-        server_type: s.server_type,
-        auto_start: "off"
-      }));
-    }
-    const worktreeGroups = /* @__PURE__ */ new Map();
-    for (const alloc of worktreeAllocations) {
-      const wId = alloc.worktree_id;
-      if (!worktreeGroups.has(wId)) worktreeGroups.set(wId, []);
-      worktreeGroups.get(wId).push(alloc);
-    }
-    const worktrees = Array.from(worktreeGroups.entries()).map(
-      ([worktreeId, allocs]) => {
-        const firstLabel = allocs[0]?.label ?? "";
-        const parenMatch = firstLabel.match(/\(([^)]+)\)/);
-        const worktreeName = parenMatch?.[1] ?? worktreeId;
-        return {
-          name: worktreeName,
-          path: "",
-          // Path is managed by the desktop app
-          cloud_id: worktreeId,
-          servers: allocs.map(matchDetected)
-        };
-      }
-    );
-    const repoEntry = {
-      name: repoData.name,
-      path: projectPath,
-      servers,
-      cloud_id: repoId,
-      ...worktrees.length > 0 ? { worktrees } : {}
-    };
-    const existingIndex = configFile.repos.findIndex((r) => r.cloud_id === repoId);
-    if (existingIndex >= 0) {
-      configFile.repos[existingIndex] = repoEntry;
-    } else {
-      configFile.repos.push(repoEntry);
-    }
-    if (dryRun) {
-      console.log("    Desktop server configs would be updated (dry-run).");
-      return;
-    }
-    await mkdir2(cbpDir, { recursive: true });
-    await writeFile3(configsPath, JSON.stringify(configFile, null, 2) + "\n", "utf-8");
-    console.log(`    Updated server-configs.json (${servers.length} server(s), ${worktrees.length} worktree(s))`);
-  } catch {
-    console.log("    Desktop server config sync skipped.");
-  }
-}
 var init_sync = __esm({
   "src/cli/sync.ts"() {
     "use strict";
@@ -1843,7 +2304,6 @@ var init_sync = __esm({
     init_api();
     init_variables();
     init_tech_detect();
-    init_server_detect();
     init_settings_merge();
     init_hook_registry();
   }
@@ -18585,49 +19045,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative, options, skipNormalization) {
+    function resolveComponent(base, relative2, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative = parse3(serialize(relative, options), options);
+        relative2 = parse3(serialize(relative2, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative.scheme) {
-        target.scheme = relative.scheme;
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (!options.tolerant && relative2.scheme) {
+        target.scheme = relative2.scheme;
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
-          target.userinfo = relative.userinfo;
-          target.host = relative.host;
-          target.port = relative.port;
-          target.path = removeDotSegments(relative.path || "");
-          target.query = relative.query;
+        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
+          target.userinfo = relative2.userinfo;
+          target.host = relative2.host;
+          target.port = relative2.port;
+          target.path = removeDotSegments(relative2.path || "");
+          target.query = relative2.query;
         } else {
-          if (!relative.path) {
+          if (!relative2.path) {
             target.path = base.path;
-            if (relative.query !== void 0) {
-              target.query = relative.query;
+            if (relative2.query !== void 0) {
+              target.query = relative2.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative.path[0] === "/") {
-              target.path = removeDotSegments(relative.path);
+            if (relative2.path[0] === "/") {
+              target.path = removeDotSegments(relative2.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative.path;
+                target.path = "/" + relative2.path;
               } else if (!base.path) {
-                target.path = relative.path;
+                target.path = relative2.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative.query;
+            target.query = relative2.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -18635,7 +19095,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative.fragment;
+      target.fragment = relative2.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -23385,258 +23845,689 @@ var init_stdio2 = __esm({
 
 // src/tools/read.ts
 function registerReadTools(server) {
-  server.registerTool("get_repos", {
-    description: "List all repos.",
-    inputSchema: {}
-  }, async () => {
-    try {
-      const res = await apiGet("/repos");
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("get_work_plan", {
-    description: "Get the work plan for a specific repo, week, and year.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      week_number: external_exports.number().int().min(1).max(53).describe("ISO week number"),
-      year: external_exports.number().int().describe("Year (e.g. 2026)")
-    }
-  }, async ({ repo_id, week_number, year }) => {
-    try {
-      const res = await apiGet("/work-plans", {
-        repo_id,
-        week_number: String(week_number),
-        year: String(year)
-      });
-      const plan = res.data[0] ?? null;
-      if (!plan) {
-        return { content: [{ type: "text", text: "Error: No work plan found for the specified repo, week, and year" }], isError: true };
+  server.registerTool(
+    "get_repos",
+    {
+      description: "List all repos.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await apiGet("/repos");
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
       }
-      return { content: [{ type: "text", text: JSON.stringify(plan, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("get_checkpoints", {
-    description: "List checkpoints for a repo. Optionally filter by status and/or worktree assignment.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      status: external_exports.string().optional().describe("Filter by status (draft, pending, active, completed)"),
-      worktree_id: external_exports.string().uuid().optional().describe("Filter by worktree UUID assignment")
-    }
-  }, async ({ repo_id, status, worktree_id }) => {
-    try {
-      const res = await apiGet("/checkpoints", { repo_id, status, worktree_id });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("get_tasks", {
-    description: "List tasks for a checkpoint. Optionally filter by status.",
-    inputSchema: {
-      checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID"),
-      status: external_exports.string().optional().describe("Filter by status (pending, in_progress, completed)")
-    }
-  }, async ({ checkpoint_id, status }) => {
-    try {
-      const res = await apiGet("/tasks", { checkpoint_id, status });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("get_rounds", {
-    description: "List rounds for a task. Optionally filter by status.",
-    inputSchema: {
-      task_id: external_exports.string().uuid().describe("The task UUID"),
-      status: external_exports.string().optional().describe("Filter by status (pending, in_progress, completed)")
     }
-  }, async ({ task_id, status }) => {
-    try {
-      const res = await apiGet("/rounds", { task_id, status });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_work_plan",
+    {
+      description: "Get the work plan for a specific repo, week, and year.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        week_number: external_exports.number().int().min(1).max(53).describe("ISO week number"),
+        year: external_exports.number().int().describe("Year (e.g. 2026)")
+      }
+    },
+    async ({ repo_id, week_number, year }) => {
+      try {
+        const res = await apiGet("/work-plans", {
+          repo_id,
+          week_number: String(week_number),
+          year: String(year)
+        });
+        const plan = res.data[0] ?? null;
+        if (!plan) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: No work plan found for the specified repo, week, and year"
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(plan, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_current_task", {
-    description: "Get the current in-progress task for a repo. Finds the active checkpoint, then the in-progress task within it.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      worktree_id: external_exports.string().uuid().optional().describe("Optional worktree UUID to filter checkpoints by assignment")
+  );
+  server.registerTool(
+    "get_checkpoints",
+    {
+      description: "List checkpoints for a repo. Optionally filter by status and/or worktree assignment.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        status: external_exports.string().optional().describe("Filter by status (draft, pending, active, completed)"),
+        worktree_id: external_exports.string().uuid().optional().describe("Filter by worktree UUID assignment")
+      }
+    },
+    async ({ repo_id, status, worktree_id }) => {
+      try {
+        const res = await apiGet("/checkpoints", {
+          repo_id,
+          status,
+          worktree_id
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, worktree_id }) => {
-    try {
-      const checkpointsRes = await apiGet("/checkpoints", {
-        repo_id,
-        status: "active"
-      });
-      let activeCheckpoints = checkpointsRes.data;
-      if (worktree_id) {
-        activeCheckpoints = activeCheckpoints.filter((c) => c.worktree_id === worktree_id);
+  );
+  server.registerTool(
+    "get_tasks",
+    {
+      description: "List tasks for a checkpoint or repo. Filter by checkpoint_id for checkpoint tasks, or repo_id with standalone=true for standalone tasks.",
+      inputSchema: {
+        checkpoint_id: external_exports.string().uuid().optional().describe("The checkpoint UUID (for checkpoint-bound tasks)"),
+        repo_id: external_exports.string().uuid().optional().describe("The repo UUID (for standalone tasks)"),
+        status: external_exports.string().optional().describe("Filter by status (pending, in_progress, completed)"),
+        standalone: external_exports.boolean().optional().describe(
+          "If true, only return tasks with no checkpoint (standalone)"
+        )
       }
-      if (activeCheckpoints.length === 0) {
+    },
+    async ({ checkpoint_id, repo_id, status, standalone }) => {
+      try {
+        const params = {
+          checkpoint_id,
+          repo_id,
+          status
+        };
+        if (standalone) params.standalone = "true";
+        const res = await apiGet("/tasks", params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
         return {
-          content: [{ type: "text", text: "No active checkpoint found for this repo." }]
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
         };
       }
-      const checkpoint = activeCheckpoints[0];
-      const tasksRes = await apiGet("/tasks", {
-        checkpoint_id: checkpoint.id,
-        status: "in_progress"
-      });
-      if (tasksRes.data.length === 0) {
+    }
+  );
+  server.registerTool(
+    "get_rounds",
+    {
+      description: "List rounds for a task. Optionally filter by status.",
+      inputSchema: {
+        task_id: external_exports.string().uuid().describe("The task UUID"),
+        status: external_exports.string().optional().describe("Filter by status (pending, in_progress, completed)")
+      }
+    },
+    async ({ task_id, status }) => {
+      try {
+        const res = await apiGet("/rounds", {
+          task_id,
+          status
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
         return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({
-              checkpoint,
-              task: null,
-              message: "Active checkpoint found but no in-progress task."
-            }, null, 2)
-          }]
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
         };
       }
-      return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({ checkpoint, task: tasksRes.data[0] }, null, 2)
-        }]
-      };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
     }
-  });
-  server.registerTool("get_launches", {
-    description: "List launches for a repo. Optionally filter by status or type.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      status: external_exports.string().optional().describe("Filter by status"),
-      type: external_exports.string().optional().describe("Filter by type")
+  );
+  server.registerTool(
+    "get_current_task",
+    {
+      description: "Get the current in-progress task for a repo. Finds the active checkpoint, then the in-progress task within it.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        worktree_id: external_exports.string().uuid().optional().describe(
+          "Optional worktree UUID to filter checkpoints by assignment"
+        )
+      }
+    },
+    async ({ repo_id, worktree_id }) => {
+      try {
+        const checkpointsRes = await apiGet(
+          "/checkpoints",
+          {
+            repo_id,
+            status: "active"
+          }
+        );
+        let activeCheckpoints = checkpointsRes.data;
+        if (worktree_id) {
+          activeCheckpoints = activeCheckpoints.filter(
+            (c) => c.worktree_id === worktree_id
+          );
+        }
+        if (activeCheckpoints.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No active checkpoint found for this repo."
+              }
+            ]
+          };
+        }
+        const checkpoint = activeCheckpoints[0];
+        const tasksRes = await apiGet("/tasks", {
+          checkpoint_id: checkpoint.id,
+          status: "in_progress"
+        });
+        if (tasksRes.data.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    checkpoint,
+                    task: null,
+                    message: "Active checkpoint found but no in-progress task."
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { checkpoint, task: tasksRes.data[0] },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, status, type }) => {
-    try {
-      const res = await apiGet("/launches", { repo_id, status, type });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("get_launch", {
-    description: "Get a single launch by ID.",
-    inputSchema: {
-      launch_id: external_exports.string().uuid().describe("The launch UUID")
-    }
-  }, async ({ launch_id }) => {
-    try {
-      const res = await apiGet(`/launches/${launch_id}`);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("get_session_logs", {
-    description: "List session logs for a repo. Optionally filter by date.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      session_date: external_exports.string().optional().describe("Filter by session date (YYYY-MM-DD)")
-    }
-  }, async ({ repo_id, session_date }) => {
-    try {
-      const res = await apiGet("/session-logs", { repo_id, session_date });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_launches",
+    {
+      description: "List launches for a repo. Optionally filter by status or type.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        status: external_exports.string().optional().describe("Filter by status"),
+        type: external_exports.string().optional().describe("Filter by type")
+      }
+    },
+    async ({ repo_id, status, type }) => {
+      try {
+        const res = await apiGet("/launches", {
+          repo_id,
+          status,
+          type
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_session_log", {
-    description: "Get a single session log by ID.",
-    inputSchema: {
-      session_log_id: external_exports.string().uuid().describe("The session log UUID")
+  );
+  server.registerTool(
+    "get_launch",
+    {
+      description: "Get a single launch by ID.",
+      inputSchema: {
+        launch_id: external_exports.string().uuid().describe("The launch UUID")
+      }
+    },
+    async ({ launch_id }) => {
+      try {
+        const res = await apiGet(
+          `/launches/${launch_id}`
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ session_log_id }) => {
-    try {
-      const res = await apiGet(`/session-logs/${session_log_id}`);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_session_logs",
+    {
+      description: "List session logs for a repo. Optionally filter by date.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        session_date: external_exports.string().optional().describe("Filter by session date (YYYY-MM-DD)")
+      }
+    },
+    async ({ repo_id, session_date }) => {
+      try {
+        const res = await apiGet("/session-logs", {
+          repo_id,
+          session_date
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_session_state", {
-    description: "Get session state for a repo (active, paused, inactive, needs_refresh, last_session_at).",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID")
+  );
+  server.registerTool(
+    "get_session_log",
+    {
+      description: "Get a single session log by ID.",
+      inputSchema: {
+        session_log_id: external_exports.string().uuid().describe("The session log UUID")
+      }
+    },
+    async ({ session_log_id }) => {
+      try {
+        const res = await apiGet(
+          `/session-logs/${session_log_id}`
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id }) => {
-    try {
-      const res = await apiGet(`/repos/${repo_id}`);
-      const { id, name, is_session_active, session_status, needs_refresh, last_session_at } = res.data;
-      const data = { id, name, is_session_active, session_status, needs_refresh, last_session_at };
-      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_session_state",
+    {
+      description: "Get session state for a repo (active, paused, inactive, needs_refresh, last_session_at).",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID")
+      }
+    },
+    async ({ repo_id }) => {
+      try {
+        const res = await apiGet(`/repos/${repo_id}`);
+        const {
+          id,
+          name,
+          is_session_active,
+          session_status,
+          needs_refresh,
+          last_session_at
+        } = res.data;
+        const data = {
+          id,
+          name,
+          is_session_active,
+          session_status,
+          needs_refresh,
+          last_session_at
+        };
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_server_config", {
-    description: "Get server configuration for a repo (port, type, active servers).",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      worktree_id: external_exports.string().uuid().optional().describe("Optional worktree UUID to filter port allocations by worktree")
+  );
+  server.registerTool(
+    "get_server_config",
+    {
+      description: "Get server configuration for a repo (port, type, active servers).",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        worktree_id: external_exports.string().uuid().optional().describe(
+          "Optional worktree UUID to filter port allocations by worktree"
+        )
+      }
+    },
+    async ({ repo_id, worktree_id }) => {
+      try {
+        const params = {};
+        if (worktree_id) params.worktree_id = worktree_id;
+        const res = await apiGet(
+          `/repos/${repo_id}/server`,
+          params
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, worktree_id }) => {
-    try {
-      const params = {};
-      if (worktree_id) params.worktree_id = worktree_id;
-      const res = await apiGet(`/repos/${repo_id}/server`, params);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_sync_status",
+    {
+      description: "Get cross-repo sync status. Shows which repos need a claude files sync based on latest updates.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await apiGet("/sync/status");
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_sync_status", {
-    description: "Get cross-repo sync status. Shows which repos need a claude files sync based on latest updates.",
-    inputSchema: {}
-  }, async () => {
-    try {
-      const res = await apiGet("/sync/status");
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_next_action",
+    {
+      description: "Compute the next action for a repo based on current workflow state. Returns command, instructions, state, and context.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        worktree_id: external_exports.string().uuid().optional().describe("Optional worktree UUID to filter by assignment")
+      }
+    },
+    async ({ repo_id, worktree_id }) => {
+      try {
+        const params = {};
+        if (worktree_id) params.worktree_id = worktree_id;
+        const res = await apiGet(
+          `/repos/${repo_id}/next-action`,
+          params
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_next_action", {
-    description: "Compute the next action for a repo based on current workflow state. Returns command, instructions, state, and context.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      worktree_id: external_exports.string().uuid().optional().describe("Optional worktree UUID to filter by assignment")
+  );
+  server.registerTool(
+    "get_worktrees",
+    {
+      description: "List worktrees for a repo. Optionally filter by status.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        status: external_exports.string().optional().describe("Filter by status (active, inactive, archived)")
+      }
+    },
+    async ({ repo_id, status }) => {
+      try {
+        const res = await apiGet("/worktrees", {
+          repo_id,
+          status
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, worktree_id }) => {
-    try {
-      const params = {};
-      if (worktree_id) params.worktree_id = worktree_id;
-      const res = await apiGet(`/repos/${repo_id}/next-action`, params);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_sync_lock_status",
+    {
+      description: "Check if a sync lock is currently held for a repo. Cleans up expired locks.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID")
+      }
+    },
+    async ({ repo_id }) => {
+      try {
+        const res = await apiGet("/sync/lock", { repo_id });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("get_worktrees", {
-    description: "List worktrees for a repo. Optionally filter by status.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      status: external_exports.string().optional().describe("Filter by status (active, inactive, archived)")
+  );
+  server.registerTool(
+    "get_sync_conflicts",
+    {
+      description: "List sync conflicts for a repo. Optionally filter by status.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        status: external_exports.string().optional().describe("Filter by status (unresolved, resolved, skipped)")
+      }
+    },
+    async ({ repo_id, status }) => {
+      try {
+        const res = await apiGet("/sync/conflicts", {
+          repo_id,
+          status
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, status }) => {
-    try {
-      const res = await apiGet("/worktrees", { repo_id, status });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "get_file_changes",
+    {
+      description: "List file changes for a repo. Filter by checkpoint, task, round, file path, or source. Use aggregate='task' with task_id to get latest entry per file (task-level view).",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        checkpoint_id: external_exports.string().uuid().optional().describe("Filter by checkpoint"),
+        task_id: external_exports.string().uuid().optional().describe("Filter by task"),
+        round_id: external_exports.string().uuid().optional().describe("Filter by round"),
+        file_path: external_exports.string().optional().describe("Filter by exact file path"),
+        source: external_exports.enum(["round", "fix"]).optional().describe("Filter by source (round or fix)"),
+        aggregate: external_exports.enum(["task"]).optional().describe(
+          "Aggregation mode. 'task' returns latest entry per file_path for a task (requires task_id)"
+        )
+      }
+    },
+    async ({ repo_id, checkpoint_id, task_id, round_id, file_path, source, aggregate }) => {
+      try {
+        const res = await apiGet(
+          "/file-changes",
+          {
+            repo_id,
+            checkpoint_id,
+            task_id,
+            round_id,
+            file_path,
+            source,
+            aggregate
+          }
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
+  );
 }
 var init_read = __esm({
   "src/tools/read.ts"() {
@@ -23914,621 +24805,1591 @@ var init_promotion = __esm({
 
 // src/tools/write.ts
 function registerWriteTools(server) {
-  server.registerTool("create_repo", {
-    description: "Create a new repo entry.",
-    inputSchema: {
-      name: external_exports.string().describe("Repo name (must be unique)"),
-      path: external_exports.string().optional().describe("Local filesystem path to the repo"),
-      git_branch: external_exports.string().optional().describe("Default git branch (default: development)")
-    }
-  }, async ({ name, path, git_branch }) => {
-    try {
-      const res = await apiPost("/repos", {
-        name,
-        path: path ?? null,
-        git_branch: git_branch ?? "development"
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("create_checkpoint", {
-    description: "Create a new checkpoint for a repo. Optionally connect it to a launch via launch_id.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      title: external_exports.string().optional().describe("Checkpoint title (optional \u2014 Claude can generate if missing)"),
-      number: external_exports.number().int().describe("Checkpoint number (e.g. 1 for CHK-001)"),
-      goal: external_exports.string().optional().describe("Checkpoint goal description (max 300 chars, brief overview)"),
-      deadline: external_exports.string().optional().describe("Deadline date (ISO format)"),
-      status: external_exports.string().optional().describe("Initial status (default: pending). Use 'draft' for checkpoints not ready for development."),
-      launch_id: external_exports.string().uuid().optional().describe("Optional launch UUID to connect this checkpoint to"),
-      ideas: external_exports.array(external_exports.object({
-        description: external_exports.string().describe("Idea description"),
-        requirements: external_exports.array(external_exports.string()).optional().describe("List of requirements for this idea"),
-        images: external_exports.array(external_exports.string()).optional().describe("Image URLs for this idea")
-      })).optional().describe("Ideas array \u2014 each idea has description, requirements[], images[]"),
-      context: external_exports.any().optional().describe("Context JSONB (decisions, discoveries, dependencies, constraints, qa_answers)"),
-      research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)"),
-      qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)")
-    }
-  }, async ({ repo_id, title, number: number3, goal, deadline, status, launch_id, ideas, context, research, qa }) => {
-    try {
-      const body = {
-        repo_id,
-        title: title ?? null,
-        number: number3,
-        goal: goal ?? null,
-        deadline: deadline ?? null,
-        status: status ?? "pending",
-        launch_id: launch_id ?? null
-      };
-      if (ideas !== void 0) body.ideas = ideas;
-      if (context !== void 0) body.context = context;
-      if (research !== void 0) body.research = research;
-      if (qa !== void 0) body.qa = qa;
-      const res = await apiPost("/checkpoints", body);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("update_checkpoint", {
-    description: "Update an existing checkpoint. Can connect or disconnect a launch via launch_id.",
-    inputSchema: {
-      checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID"),
-      title: external_exports.string().nullable().optional().describe("New title (or null to clear)"),
-      goal: external_exports.string().optional().describe("New goal (max 300 chars, brief overview)"),
-      status: external_exports.string().optional().describe("New status (draft, pending, active, completed)"),
-      deadline: external_exports.string().optional().describe("New deadline (ISO format)"),
-      completed_at: external_exports.string().optional().describe("Completion timestamp (ISO format)"),
-      launch_id: external_exports.string().uuid().nullable().optional().describe("Launch UUID to connect (or null to disconnect)"),
-      worktree_id: external_exports.string().uuid().nullable().optional().describe("Worktree UUID to assign (or null to unassign)"),
-      assigned_to: external_exports.string().nullable().optional().describe("Who/what claimed this checkpoint"),
-      branch_name: external_exports.string().nullable().optional().describe("Git branch name for this checkpoint (e.g. feat/CHK-061-git-overhaul)"),
-      ideas: external_exports.array(external_exports.object({
-        description: external_exports.string().describe("Idea description"),
-        requirements: external_exports.array(external_exports.string()).optional().describe("List of requirements for this idea"),
-        images: external_exports.array(external_exports.string()).optional().describe("Image URLs for this idea")
-      })).optional().describe("Ideas array \u2014 each idea has description, requirements[], images[]"),
-      context: external_exports.any().optional().describe("Context JSONB (decisions, discoveries, dependencies, constraints, qa_answers)"),
-      research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)"),
-      qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)")
-    }
-  }, async ({ checkpoint_id, title, goal, status, deadline, completed_at, launch_id, worktree_id, assigned_to, branch_name, ideas, context, research, qa }) => {
-    const update = {};
-    if (title !== void 0) update.title = title;
-    if (goal !== void 0) update.goal = goal;
-    if (status !== void 0) update.status = status;
-    if (deadline !== void 0) update.deadline = deadline;
-    if (completed_at !== void 0) update.completed_at = completed_at;
-    if (launch_id !== void 0) update.launch_id = launch_id;
-    if (worktree_id !== void 0) update.worktree_id = worktree_id;
-    if (assigned_to !== void 0) update.assigned_to = assigned_to;
-    if (branch_name !== void 0) update.branch_name = branch_name;
-    if (ideas !== void 0) update.ideas = ideas;
-    if (context !== void 0) update.context = context;
-    if (research !== void 0) update.research = research;
-    if (qa !== void 0) update.qa = qa;
-    if (Object.keys(update).length === 0) {
-      return { content: [{ type: "text", text: "Error: No fields to update" }], isError: true };
-    }
-    try {
-      const res = await apiPut(`/checkpoints/${checkpoint_id}`, update);
-      return { content: [{ type: "text", text: JSON.stringify(res, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("complete_checkpoint", {
-    description: "Mark a checkpoint as completed. Sets status to 'completed', completed_at to now, and triggers promotion (creates PR from feat branch to development).",
-    inputSchema: {
-      checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID")
-    }
-  }, async ({ checkpoint_id }) => {
-    try {
-      const res = await apiPut(`/checkpoints/${checkpoint_id}`, {
-        status: "completed",
-        completed_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      const checkpoint = res.data;
-      const featToDevResult = await promoteCheckpoint(checkpoint_id);
-      let devToMainResult = null;
-      const repoRes = await apiGet(`/repos/${checkpoint.repo_id}`);
-      if (repoRes.data.auto_push_enabled) {
-        devToMainResult = await promoteToMain(checkpoint.repo_id);
-      }
-      return { content: [{ type: "text", text: JSON.stringify({ checkpoint, promotion: { feat_to_development: featToDevResult, development_to_main: devToMainResult } }, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("create_task", {
-    description: "Create a new task within a checkpoint.",
-    inputSchema: {
-      checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID"),
-      title: external_exports.string().describe("Task title"),
-      number: external_exports.number().int().describe("Task number (e.g. 1 for TASK-1)"),
-      requirements: external_exports.string().optional().describe("Task requirements text"),
-      status: external_exports.string().optional().describe("Initial status (default: pending)"),
-      context: external_exports.any().optional().describe("Context JSONB (decisions, discoveries, dependencies, constraints)"),
-      qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
-      research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)")
-    }
-  }, async ({ checkpoint_id, title, number: number3, requirements, status, context, qa, research }) => {
-    try {
-      const body = {
-        checkpoint_id,
-        title,
-        number: number3,
-        requirements: requirements ?? null,
-        status: status ?? "pending"
-      };
-      if (context !== void 0) body.context = context;
-      if (qa !== void 0) body.qa = qa;
-      if (research !== void 0) body.research = research;
-      const res = await apiPost("/tasks", body);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("update_task", {
-    description: "Update an existing task. Use to update status, requirements, or file tracking. Pass claim_worktree_id when setting status to in_progress to auto-claim the parent checkpoint for the worktree.",
-    inputSchema: {
-      task_id: external_exports.string().uuid().describe("The task UUID"),
-      title: external_exports.string().optional().describe("New title"),
-      requirements: external_exports.string().optional().describe("New requirements text"),
-      status: external_exports.string().optional().describe("New status (pending, in_progress, completed)"),
-      files_changed: external_exports.array(external_exports.object({
-        path: external_exports.string().describe("File path relative to repo root"),
-        action: external_exports.string().describe("File action (new, modified, deleted)"),
-        status: external_exports.string().describe("Approval status (approved, not_approved)"),
-        claude_approved: external_exports.boolean().optional().describe("Whether Claude's automated checks passed for this file"),
-        user_approved: external_exports.boolean().optional().describe("Whether the user has approved this file (via git add or web UI)")
-      })).optional().describe("Files changed across all rounds"),
-      claim_worktree_id: external_exports.string().uuid().optional().describe("Worktree UUID to auto-claim the parent checkpoint when setting status to in_progress"),
-      context: external_exports.any().optional().describe("Context JSONB (decisions, discoveries, dependencies, constraints)"),
-      qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
-      research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)")
-    }
-  }, async ({ task_id, title, requirements, status, files_changed, claim_worktree_id, context, qa, research }) => {
-    const update = {};
-    if (title !== void 0) update.title = title;
-    if (requirements !== void 0) update.requirements = requirements;
-    if (status !== void 0) update.status = status;
-    if (files_changed !== void 0) update.files_changed = files_changed;
-    if (claim_worktree_id !== void 0) update.claim_worktree_id = claim_worktree_id;
-    if (context !== void 0) update.context = context;
-    if (qa !== void 0) update.qa = qa;
-    if (research !== void 0) update.research = research;
-    if (Object.keys(update).length === 0) {
-      return { content: [{ type: "text", text: "Error: No fields to update" }], isError: true };
-    }
-    try {
-      const res = await apiPut(`/tasks/${task_id}`, update);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("complete_task", {
-    description: "Mark a task as completed. Sets status to 'completed' and completed_at to now.",
-    inputSchema: {
-      task_id: external_exports.string().uuid().describe("The task UUID")
-    }
-  }, async ({ task_id }) => {
-    try {
-      const res = await apiPut(`/tasks/${task_id}`, {
-        status: "completed",
-        completed_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("add_round", {
-    description: "Add a round to a task.",
-    inputSchema: {
-      task_id: external_exports.string().uuid().describe("The task UUID"),
-      number: external_exports.number().int().describe("Round number"),
-      requirements: external_exports.string().optional().describe("Round requirements text"),
-      status: external_exports.string().optional().describe("Initial status (default: pending)"),
-      started_at: external_exports.string().optional().describe("Start timestamp (ISO format)"),
-      context: external_exports.any().optional().describe("Context JSONB"),
-      qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)")
-    }
-  }, async ({ task_id, number: number3, requirements, status, started_at, context, qa }) => {
-    try {
-      const body = {
-        task_id,
-        number: number3,
-        requirements: requirements ?? null,
-        status: status ?? "pending",
-        started_at: started_at ?? null
-      };
-      if (context !== void 0) body.context = context;
-      if (qa !== void 0) body.qa = qa;
-      const res = await apiPost("/rounds", body);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("update_round", {
-    description: "Update an existing round.",
-    inputSchema: {
-      round_id: external_exports.string().uuid().describe("The round UUID"),
-      requirements: external_exports.string().optional().describe("Round requirements text"),
-      status: external_exports.string().optional().describe("New status (pending, in_progress, completed)"),
-      started_at: external_exports.string().optional().describe("Start timestamp (ISO format)"),
-      completed_at: external_exports.string().optional().describe("Completion timestamp (ISO format)"),
-      duration_minutes: external_exports.number().int().optional().describe("Duration in minutes"),
-      files_changed: external_exports.array(external_exports.object({
-        path: external_exports.string().describe("File path relative to repo root"),
-        action: external_exports.string().describe("File action (new, modified, deleted)"),
-        status: external_exports.string().describe("Approval status (approved, not_approved)"),
-        claude_approved: external_exports.boolean().optional().describe("Whether Claude's automated checks passed for this file"),
-        user_approved: external_exports.boolean().optional().describe("Whether the user has approved this file (via git add or web UI)")
-      })).optional().describe("Files changed in this round with approval status"),
-      context: external_exports.any().optional().describe("Context JSONB"),
-      qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)")
-    }
-  }, async ({ round_id, requirements, status, started_at, completed_at, duration_minutes, files_changed, context, qa }) => {
-    const update = {};
-    if (requirements !== void 0) update.requirements = requirements;
-    if (status !== void 0) update.status = status;
-    if (started_at !== void 0) update.started_at = started_at;
-    if (completed_at !== void 0) update.completed_at = completed_at;
-    if (duration_minutes !== void 0) update.duration_minutes = duration_minutes;
-    if (files_changed !== void 0) update.files_changed = files_changed;
-    if (context !== void 0) update.context = context;
-    if (qa !== void 0) update.qa = qa;
-    if (Object.keys(update).length === 0) {
-      return { content: [{ type: "text", text: "Error: No fields to update" }], isError: true };
-    }
-    try {
-      const res = await apiPut(`/rounds/${round_id}`, update);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  server.registerTool(
+    "create_repo",
+    {
+      description: "Create a new repo entry.",
+      inputSchema: {
+        name: external_exports.string().describe("Repo name (must be unique)"),
+        path: external_exports.string().optional().describe("Local filesystem path to the repo"),
+        git_branch: external_exports.string().optional().describe("Default git branch (default: development)")
+      }
+    },
+    async ({ name, path, git_branch }) => {
+      try {
+        const res = await apiPost("/repos", {
+          name,
+          path: path ?? null,
+          git_branch: git_branch ?? "development"
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("complete_round", {
-    description: "Mark a round as completed. Sets status to 'completed' and completed_at to now.",
-    inputSchema: {
-      round_id: external_exports.string().uuid().describe("The round UUID"),
-      duration_minutes: external_exports.number().int().optional().describe("Duration in minutes")
+  );
+  server.registerTool(
+    "create_checkpoint",
+    {
+      description: "Create a new checkpoint for a repo. Optionally connect it to a launch via launch_id.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        title: external_exports.string().optional().describe(
+          "Checkpoint title (optional \u2014 Claude can generate if missing)"
+        ),
+        number: external_exports.number().int().describe("Checkpoint number (e.g. 1 for CHK-001)"),
+        goal: external_exports.string().optional().describe(
+          "Checkpoint goal description (max 300 chars, brief overview)"
+        ),
+        deadline: external_exports.string().optional().describe("Deadline date (ISO format)"),
+        status: external_exports.string().optional().describe(
+          "Initial status (default: pending). Use 'draft' for checkpoints not ready for development."
+        ),
+        launch_id: external_exports.string().uuid().optional().describe("Optional launch UUID to connect this checkpoint to"),
+        ideas: external_exports.array(
+          external_exports.object({
+            description: external_exports.string().describe("Idea description"),
+            requirements: external_exports.array(external_exports.string()).optional().describe("List of requirements for this idea"),
+            images: external_exports.array(external_exports.string()).optional().describe("Image URLs for this idea")
+          })
+        ).optional().describe(
+          "Ideas array \u2014 each idea has description, requirements[], images[]"
+        ),
+        context: external_exports.any().optional().describe(
+          "Context JSONB (decisions, discoveries, dependencies, constraints, qa_answers)"
+        ),
+        research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)"),
+        qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
+        plan: external_exports.any().optional().describe("Plan JSONB (steps with title, description, scope)"),
+        user_context: external_exports.string().optional().describe("Original user input text (never overwritten once set)"),
+        is_claude_written: external_exports.boolean().optional().describe("Whether Claude wrote the user_context"),
+        context_development: external_exports.any().optional().describe(
+          "Context development JSONB (discussion entries, Q&A, assessment decisions)"
+        ),
+        resources: external_exports.any().optional().describe(
+          "Resources JSONB array [{url, description, type, added_by}]"
+        )
+      }
+    },
+    async ({
+      repo_id,
+      title,
+      number: number3,
+      goal,
+      deadline,
+      status,
+      launch_id,
+      ideas,
+      context,
+      research,
+      qa,
+      plan,
+      user_context,
+      is_claude_written,
+      context_development,
+      resources
+    }) => {
+      try {
+        const body = {
+          repo_id,
+          title: title ?? null,
+          number: number3,
+          goal: goal ?? null,
+          deadline: deadline ?? null,
+          status: status ?? "pending",
+          launch_id: launch_id ?? null
+        };
+        if (ideas !== void 0) body.ideas = ideas;
+        if (context !== void 0) body.context = context;
+        if (research !== void 0) body.research = research;
+        if (qa !== void 0) body.qa = qa;
+        if (plan !== void 0) body.plan = plan;
+        if (user_context !== void 0) body.user_context = user_context;
+        if (is_claude_written !== void 0)
+          body.is_claude_written = is_claude_written;
+        if (context_development !== void 0)
+          body.context_development = context_development;
+        if (resources !== void 0) body.resources = resources;
+        const res = await apiPost(
+          "/checkpoints",
+          body
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ round_id, duration_minutes }) => {
-    try {
-      const update = {
-        status: "completed",
-        completed_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (duration_minutes !== void 0) update.duration_minutes = duration_minutes;
-      const res = await apiPut(`/rounds/${round_id}`, update);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "update_checkpoint",
+    {
+      description: "Update an existing checkpoint. Can connect or disconnect a launch via launch_id.",
+      inputSchema: {
+        checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID"),
+        title: external_exports.string().nullable().optional().describe("New title (or null to clear)"),
+        goal: external_exports.string().optional().describe("New goal (max 300 chars, brief overview)"),
+        status: external_exports.string().optional().describe("New status (draft, pending, active, completed)"),
+        deadline: external_exports.string().optional().describe("New deadline (ISO format)"),
+        completed_at: external_exports.string().optional().describe("Completion timestamp (ISO format)"),
+        launch_id: external_exports.string().uuid().nullable().optional().describe("Launch UUID to connect (or null to disconnect)"),
+        worktree_id: external_exports.string().uuid().nullable().optional().describe("Worktree UUID to assign (or null to unassign)"),
+        assigned_to: external_exports.string().nullable().optional().describe("Who/what claimed this checkpoint"),
+        branch_name: external_exports.string().nullable().optional().describe(
+          "Git branch name for this checkpoint (e.g. feat/CHK-061-git-overhaul)"
+        ),
+        ideas: external_exports.array(
+          external_exports.object({
+            description: external_exports.string().describe("Idea description"),
+            requirements: external_exports.array(external_exports.string()).optional().describe("List of requirements for this idea"),
+            images: external_exports.array(external_exports.string()).optional().describe("Image URLs for this idea")
+          })
+        ).optional().describe(
+          "Ideas array \u2014 each idea has description, requirements[], images[]"
+        ),
+        context: external_exports.any().optional().describe(
+          "Context JSONB (decisions, discoveries, dependencies, constraints, qa_answers)"
+        ),
+        research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)"),
+        qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
+        plan: external_exports.any().optional().describe("Plan JSONB (steps with title, description, scope)"),
+        user_context: external_exports.string().optional().describe("Original user input text (never overwritten once set)"),
+        is_claude_written: external_exports.boolean().optional().describe("Whether Claude wrote the user_context"),
+        context_development: external_exports.any().optional().describe(
+          "Context development JSONB (discussion entries, Q&A, assessment decisions)"
+        ),
+        resources: external_exports.any().optional().describe(
+          "Resources JSONB array [{url, description, type, added_by}]"
+        )
+      }
+    },
+    async ({
+      checkpoint_id,
+      title,
+      goal,
+      status,
+      deadline,
+      completed_at,
+      launch_id,
+      worktree_id,
+      assigned_to,
+      branch_name,
+      ideas,
+      context,
+      research,
+      qa,
+      plan,
+      user_context,
+      is_claude_written,
+      context_development,
+      resources
+    }) => {
+      const update = {};
+      if (title !== void 0) update.title = title;
+      if (goal !== void 0) update.goal = goal;
+      if (status !== void 0) update.status = status;
+      if (deadline !== void 0) update.deadline = deadline;
+      if (completed_at !== void 0) update.completed_at = completed_at;
+      if (launch_id !== void 0) update.launch_id = launch_id;
+      if (worktree_id !== void 0) update.worktree_id = worktree_id;
+      if (assigned_to !== void 0) update.assigned_to = assigned_to;
+      if (branch_name !== void 0) update.branch_name = branch_name;
+      if (ideas !== void 0) update.ideas = ideas;
+      if (context !== void 0) update.context = context;
+      if (research !== void 0) update.research = research;
+      if (qa !== void 0) update.qa = qa;
+      if (plan !== void 0) update.plan = plan;
+      if (user_context !== void 0) update.user_context = user_context;
+      if (is_claude_written !== void 0)
+        update.is_claude_written = is_claude_written;
+      if (context_development !== void 0)
+        update.context_development = context_development;
+      if (resources !== void 0) update.resources = resources;
+      if (Object.keys(update).length === 0) {
+        return {
+          content: [
+            { type: "text", text: "Error: No fields to update" }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const res = await apiPut(`/checkpoints/${checkpoint_id}`, update);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("create_launch", {
-    description: "Create a new launch for a repo.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      title: external_exports.string().describe("Launch title"),
-      type: external_exports.string().describe("Launch type"),
-      status: external_exports.string().optional().describe("Initial status (default: pending)"),
-      version: external_exports.string().optional().describe("Version string"),
-      user_requirements: external_exports.any().optional().describe("User requirements (JSON)")
+  );
+  server.registerTool(
+    "complete_checkpoint",
+    {
+      description: "Mark a checkpoint as completed. Sets status to 'completed', completed_at to now, and triggers promotion (creates PR from feat branch to development).",
+      inputSchema: {
+        checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID")
+      }
+    },
+    async ({ checkpoint_id }) => {
+      try {
+        const res = await apiPut(
+          `/checkpoints/${checkpoint_id}`,
+          {
+            status: "completed",
+            completed_at: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        );
+        const checkpoint = res.data;
+        const featToDevResult = await promoteCheckpoint(checkpoint_id);
+        let devToMainResult = null;
+        const repoRes = await apiGet(
+          `/repos/${checkpoint.repo_id}`
+        );
+        if (repoRes.data.auto_push_enabled) {
+          devToMainResult = await promoteToMain(checkpoint.repo_id);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  checkpoint,
+                  promotion: {
+                    feat_to_development: featToDevResult,
+                    development_to_main: devToMainResult
+                  }
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, title, type, status, version: version2, user_requirements }) => {
-    try {
-      const res = await apiPost("/launches", {
-        repo_id,
-        title,
-        type,
-        status: status ?? "pending",
-        version: version2 ?? null,
-        user_requirements: user_requirements ?? null
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "create_task",
+    {
+      description: "Create a new task within a checkpoint or as a standalone task. Provide checkpoint_id for checkpoint tasks, or repo_id for standalone tasks.",
+      inputSchema: {
+        checkpoint_id: external_exports.string().uuid().optional().describe("The checkpoint UUID (for checkpoint-bound tasks)"),
+        repo_id: external_exports.string().uuid().optional().describe("The repo UUID (for standalone tasks without checkpoint)"),
+        title: external_exports.string().describe("Task title"),
+        number: external_exports.number().int().optional().describe(
+          "Task number (e.g. 1 for TASK-1). Auto-generated for standalone tasks if omitted."
+        ),
+        requirements: external_exports.string().optional().describe("Task requirements text"),
+        status: external_exports.string().optional().describe("Initial status (default: pending)"),
+        context: external_exports.any().optional().describe(
+          "Context JSONB (decisions, discoveries, dependencies, constraints)"
+        ),
+        qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
+        research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)"),
+        user_context: external_exports.string().optional().describe("Original user input text (never overwritten once set)"),
+        is_claude_written: external_exports.boolean().optional().describe("Whether Claude wrote the user_context"),
+        context_development: external_exports.any().optional().describe(
+          "Context development JSONB (discussion entries, Q&A, assessment decisions)"
+        ),
+        resources: external_exports.any().optional().describe(
+          "Resources JSONB array [{url, description, type, added_by}]"
+        )
+      }
+    },
+    async ({
+      checkpoint_id,
+      repo_id,
+      title,
+      number: number3,
+      requirements,
+      status,
+      context,
+      qa,
+      research,
+      user_context,
+      is_claude_written,
+      context_development,
+      resources
+    }) => {
+      try {
+        const body = {
+          title,
+          requirements: requirements ?? null,
+          status: status ?? "pending"
+        };
+        if (checkpoint_id) body.checkpoint_id = checkpoint_id;
+        if (repo_id) body.repo_id = repo_id;
+        if (number3 !== void 0) body.number = number3;
+        if (context !== void 0) body.context = context;
+        if (qa !== void 0) body.qa = qa;
+        if (research !== void 0) body.research = research;
+        if (user_context !== void 0) body.user_context = user_context;
+        if (is_claude_written !== void 0)
+          body.is_claude_written = is_claude_written;
+        if (context_development !== void 0)
+          body.context_development = context_development;
+        if (resources !== void 0) body.resources = resources;
+        const res = await apiPost("/tasks", body);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("update_launch", {
-    description: "Update an existing launch.",
-    inputSchema: {
-      launch_id: external_exports.string().uuid().describe("The launch UUID"),
-      title: external_exports.string().optional().describe("New title"),
-      type: external_exports.string().optional().describe("New type"),
-      status: external_exports.string().optional().describe("New status"),
-      version: external_exports.string().optional().describe("New version"),
-      user_requirements: external_exports.any().optional().describe("New user requirements (JSON)")
-    }
-  }, async ({ launch_id, title, type, status, version: version2, user_requirements }) => {
-    const update = {};
-    if (title !== void 0) update.title = title;
-    if (type !== void 0) update.type = type;
-    if (status !== void 0) update.status = status;
-    if (version2 !== void 0) update.version = version2;
-    if (user_requirements !== void 0) update.user_requirements = user_requirements;
-    if (Object.keys(update).length === 0) {
-      return { content: [{ type: "text", text: "Error: No fields to update" }], isError: true };
+  );
+  server.registerTool(
+    "update_task",
+    {
+      description: "Update an existing task. Use to update status, requirements, or file tracking. Pass claim_worktree_id when setting status to in_progress to auto-claim the parent checkpoint for the worktree.",
+      inputSchema: {
+        task_id: external_exports.string().uuid().describe("The task UUID"),
+        title: external_exports.string().optional().describe("New title"),
+        requirements: external_exports.string().optional().describe("New requirements text"),
+        status: external_exports.string().optional().describe("New status (pending, in_progress, completed)"),
+        files_changed: external_exports.array(
+          external_exports.object({
+            path: external_exports.string().describe("File path relative to repo root"),
+            action: external_exports.string().describe("File action (new, modified, deleted)"),
+            status: external_exports.string().describe("Approval status (approved, not_approved)"),
+            claude_approved: external_exports.boolean().optional().describe(
+              "Whether Claude's automated checks passed for this file"
+            ),
+            user_approved: external_exports.boolean().optional().describe(
+              "Whether the user has approved this file (via git add or web UI)"
+            ),
+            app_approved: external_exports.boolean().optional().describe(
+              "Whether the app has approved this file (via automated checks)"
+            )
+          })
+        ).optional().describe("Files changed across all rounds"),
+        claim_worktree_id: external_exports.string().uuid().optional().describe(
+          "Worktree UUID to auto-claim the parent checkpoint when setting status to in_progress"
+        ),
+        context: external_exports.any().optional().describe(
+          "Context JSONB (decisions, discoveries, dependencies, constraints)"
+        ),
+        qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
+        research: external_exports.any().optional().describe("Research JSONB (topics with findings and sources)"),
+        user_context: external_exports.string().optional().describe("Original user input text (never overwritten once set)"),
+        is_claude_written: external_exports.boolean().optional().describe("Whether Claude wrote the user_context"),
+        context_development: external_exports.any().optional().describe(
+          "Context development JSONB (discussion entries, Q&A, assessment decisions)"
+        ),
+        resources: external_exports.any().optional().describe(
+          "Resources JSONB array [{url, description, type, added_by}]"
+        ),
+        app_file_approval_by_user: external_exports.boolean().optional().describe(
+          "Whether user interacted with file approvals via web UI. CLI resets to false after processing."
+        )
+      }
+    },
+    async ({
+      task_id,
+      title,
+      requirements,
+      status,
+      files_changed,
+      claim_worktree_id,
+      context,
+      qa,
+      research,
+      user_context,
+      is_claude_written,
+      context_development,
+      resources,
+      app_file_approval_by_user
+    }) => {
+      const update = {};
+      if (title !== void 0) update.title = title;
+      if (requirements !== void 0) update.requirements = requirements;
+      if (status !== void 0) update.status = status;
+      if (files_changed !== void 0) update.files_changed = files_changed;
+      if (claim_worktree_id !== void 0)
+        update.claim_worktree_id = claim_worktree_id;
+      if (context !== void 0) update.context = context;
+      if (qa !== void 0) update.qa = qa;
+      if (research !== void 0) update.research = research;
+      if (user_context !== void 0) update.user_context = user_context;
+      if (is_claude_written !== void 0)
+        update.is_claude_written = is_claude_written;
+      if (context_development !== void 0)
+        update.context_development = context_development;
+      if (resources !== void 0) update.resources = resources;
+      if (app_file_approval_by_user !== void 0)
+        update.app_file_approval_by_user = app_file_approval_by_user;
+      if (Object.keys(update).length === 0) {
+        return {
+          content: [
+            { type: "text", text: "Error: No fields to update" }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const res = await apiPut(
+          `/tasks/${task_id}`,
+          update
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-    try {
-      const res = await apiPut(`/launches/${launch_id}`, update);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "complete_task",
+    {
+      description: "Mark a task as completed. Sets status to 'completed' and completed_at to now.",
+      inputSchema: {
+        task_id: external_exports.string().uuid().describe("The task UUID")
+      }
+    },
+    async ({ task_id }) => {
+      try {
+        let hasUnapproved = false;
+        let unapprovedCount = 0;
+        let resolvedRepoId = null;
+        try {
+          const taskRes = await apiGet(
+            `/tasks/${task_id}`
+          );
+          const checkpointRes = await apiGet(
+            `/checkpoints/${taskRes.data.checkpoint_id}`
+          );
+          resolvedRepoId = checkpointRes.data.repo_id;
+          const fileChangesRes = await apiGet("/file-changes", {
+            repo_id: resolvedRepoId,
+            task_id
+          });
+          const unapproved = (fileChangesRes.data ?? []).filter(
+            (f) => !f.user_approved
+          );
+          unapprovedCount = unapproved.length;
+          hasUnapproved = unapprovedCount > 0;
+        } catch {
+        }
+        if (hasUnapproved) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Cannot complete task \u2014 ${unapprovedCount} file(s) are not approved. All files must be user_approved before task completion.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const res = await apiPut(`/tasks/${task_id}`, {
+          status: "completed",
+          completed_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (resolvedRepoId) {
+          try {
+            await apiPatch("/file-changes", {
+              action: "lock_task",
+              task_id,
+              repo_id: resolvedRepoId
+            });
+          } catch {
+          }
+        }
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("delete_launch", {
-    description: "Delete a launch by ID.",
-    inputSchema: {
-      launch_id: external_exports.string().uuid().describe("The launch UUID")
+  );
+  server.registerTool(
+    "add_round",
+    {
+      description: "Add a round to a task.",
+      inputSchema: {
+        task_id: external_exports.string().uuid().describe("The task UUID"),
+        number: external_exports.number().int().describe("Round number"),
+        requirements: external_exports.string().optional().describe("Round requirements text"),
+        status: external_exports.string().optional().describe("Initial status (default: pending)"),
+        started_at: external_exports.string().optional().describe("Start timestamp (ISO format)"),
+        triggered_by: external_exports.enum(["user", "claude"]).optional().describe("Who triggered the round (user or claude)"),
+        context: external_exports.any().optional().describe("Context JSONB"),
+        qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
+        user_context: external_exports.string().optional().describe("Original user input text (never overwritten once set)"),
+        is_claude_written: external_exports.boolean().optional().describe("Whether Claude wrote the user_context"),
+        context_development: external_exports.any().optional().describe(
+          "Context development JSONB (discussion entries, Q&A, assessment decisions)"
+        ),
+        resources: external_exports.any().optional().describe(
+          "Resources JSONB array [{url, description, type, added_by}]"
+        )
+      }
+    },
+    async ({
+      task_id,
+      number: number3,
+      requirements,
+      status,
+      started_at,
+      triggered_by,
+      context,
+      qa,
+      user_context,
+      is_claude_written,
+      context_development,
+      resources
+    }) => {
+      try {
+        const body = {
+          task_id,
+          number: number3,
+          requirements: requirements ?? null,
+          status: status ?? "pending",
+          started_at: started_at ?? null
+        };
+        if (triggered_by !== void 0) body.triggered_by = triggered_by;
+        if (context !== void 0) body.context = context;
+        if (qa !== void 0) body.qa = qa;
+        if (user_context !== void 0) body.user_context = user_context;
+        if (is_claude_written !== void 0)
+          body.is_claude_written = is_claude_written;
+        if (context_development !== void 0)
+          body.context_development = context_development;
+        if (resources !== void 0) body.resources = resources;
+        const res = await apiPost("/rounds", body);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ launch_id }) => {
-    try {
-      await apiDelete(`/launches/${launch_id}`);
-      return { content: [{ type: "text", text: "Launch deleted successfully" }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "update_round",
+    {
+      description: "Update an existing round.",
+      inputSchema: {
+        round_id: external_exports.string().uuid().describe("The round UUID"),
+        requirements: external_exports.string().optional().describe("Round requirements text"),
+        status: external_exports.string().optional().describe("New status (pending, in_progress, completed)"),
+        started_at: external_exports.string().optional().describe("Start timestamp (ISO format)"),
+        completed_at: external_exports.string().optional().describe("Completion timestamp (ISO format)"),
+        duration_minutes: external_exports.number().int().optional().describe("Duration in minutes"),
+        files_changed: external_exports.array(
+          external_exports.object({
+            path: external_exports.string().describe("File path relative to repo root"),
+            action: external_exports.string().describe("File action (new, modified, deleted)"),
+            status: external_exports.string().describe("Approval status (approved, not_approved)"),
+            claude_approved: external_exports.boolean().optional().describe(
+              "Whether Claude's automated checks passed for this file"
+            ),
+            user_approved: external_exports.boolean().optional().describe(
+              "Whether the user has approved this file (via git add or web UI)"
+            ),
+            app_approved: external_exports.boolean().optional().describe(
+              "Whether the app has approved this file (via automated checks)"
+            )
+          })
+        ).optional().describe("Files changed in this round with approval status"),
+        context: external_exports.any().optional().describe("Context JSONB"),
+        qa: external_exports.any().optional().describe("QA JSONB (checklist items with type, check, status)"),
+        user_context: external_exports.string().optional().describe("Original user input text (never overwritten once set)"),
+        is_claude_written: external_exports.boolean().optional().describe("Whether Claude wrote the user_context"),
+        context_development: external_exports.any().optional().describe(
+          "Context development JSONB (discussion entries, Q&A, assessment decisions)"
+        ),
+        resources: external_exports.any().optional().describe(
+          "Resources JSONB array [{url, description, type, added_by}]"
+        )
+      }
+    },
+    async ({
+      round_id,
+      requirements,
+      status,
+      started_at,
+      completed_at,
+      duration_minutes,
+      files_changed,
+      context,
+      qa,
+      user_context,
+      is_claude_written,
+      context_development,
+      resources
+    }) => {
+      const update = {};
+      if (requirements !== void 0) update.requirements = requirements;
+      if (status !== void 0) update.status = status;
+      if (started_at !== void 0) update.started_at = started_at;
+      if (completed_at !== void 0) update.completed_at = completed_at;
+      if (duration_minutes !== void 0)
+        update.duration_minutes = duration_minutes;
+      if (files_changed !== void 0) update.files_changed = files_changed;
+      if (context !== void 0) update.context = context;
+      if (qa !== void 0) update.qa = qa;
+      if (user_context !== void 0) update.user_context = user_context;
+      if (is_claude_written !== void 0)
+        update.is_claude_written = is_claude_written;
+      if (context_development !== void 0)
+        update.context_development = context_development;
+      if (resources !== void 0) update.resources = resources;
+      if (Object.keys(update).length === 0) {
+        return {
+          content: [
+            { type: "text", text: "Error: No fields to update" }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const res = await apiPut(
+          `/rounds/${round_id}`,
+          update
+        );
+        if (files_changed && files_changed.length > 0) {
+          try {
+            const taskRes = await apiGet(
+              `/tasks/${res.data.task_id}`
+            );
+            const checkpointRes = await apiGet(
+              `/checkpoints/${taskRes.data.checkpoint_id}`
+            );
+            await apiPatch("/file-changes", {
+              action: "replace_round_files",
+              round_id,
+              repo_id: checkpointRes.data.repo_id,
+              checkpoint_id: taskRes.data.checkpoint_id,
+              task_id: res.data.task_id,
+              source: "round",
+              files: files_changed.map(
+                (f) => ({
+                  file_path: f.path,
+                  action: f.action,
+                  claude_approved: f.claude_approved ?? false,
+                  user_approved: f.user_approved ?? false
+                })
+              )
+            });
+          } catch {
+          }
+        }
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("create_session_log", {
-    description: "Create a new session log for a repo.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      session_date: external_exports.string().describe("Session date (YYYY-MM-DD)"),
-      day_number: external_exports.number().int().describe("Day number (e.g. 41 for D-41)"),
-      session_number: external_exports.number().int().optional().describe("Session number within the day (default: 1)"),
-      content: external_exports.any().optional().describe("Session log content (JSON)"),
-      worktree_id: external_exports.string().uuid().optional().describe("Worktree UUID that created this session log")
+  );
+  server.registerTool(
+    "complete_round",
+    {
+      description: "Mark a round as completed. Sets status to 'completed' and completed_at to now.",
+      inputSchema: {
+        round_id: external_exports.string().uuid().describe("The round UUID"),
+        duration_minutes: external_exports.number().int().optional().describe("Duration in minutes")
+      }
+    },
+    async ({ round_id, duration_minutes }) => {
+      try {
+        const update = {
+          status: "completed",
+          completed_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (duration_minutes !== void 0)
+          update.duration_minutes = duration_minutes;
+        const res = await apiPut(
+          `/rounds/${round_id}`,
+          update
+        );
+        let unapprovedFiles = [];
+        try {
+          const taskRes = await apiGet(
+            `/tasks/${res.data.task_id}`
+          );
+          const checkpointRes = await apiGet(
+            `/checkpoints/${taskRes.data.checkpoint_id}`
+          );
+          const repoId = checkpointRes.data.repo_id;
+          await apiPatch("/file-changes", {
+            action: "lock_round",
+            round_id,
+            repo_id: repoId
+          });
+          const fileChangesRes = await apiGet("/file-changes", {
+            repo_id: repoId,
+            round_id
+          });
+          unapprovedFiles = (fileChangesRes.data ?? []).filter((f) => !f.user_approved).map((f) => ({ file_path: f.file_path, action: f.action }));
+        } catch {
+        }
+        const result = {
+          ...res.data,
+          unapproved_files: unapprovedFiles,
+          unapproved_count: unapprovedFiles.length
+        };
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, session_date, day_number, session_number, content, worktree_id }) => {
-    try {
-      const body = {
-        repo_id,
-        session_date,
-        day_number,
-        session_number: session_number ?? 1,
-        content: content ?? null
-      };
-      if (worktree_id) body.worktree_id = worktree_id;
-      const res = await apiPost("/session-logs", body);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "create_launch",
+    {
+      description: "Create a new launch for a repo.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        title: external_exports.string().describe("Launch title"),
+        type: external_exports.string().describe("Launch type"),
+        status: external_exports.string().optional().describe("Initial status (default: pending)"),
+        version: external_exports.string().optional().describe("Version string"),
+        user_requirements: external_exports.any().optional().describe("User requirements (JSON)")
+      }
+    },
+    async ({ repo_id, title, type, status, version: version2, user_requirements }) => {
+      try {
+        const res = await apiPost("/launches", {
+          repo_id,
+          title,
+          type,
+          status: status ?? "pending",
+          version: version2 ?? null,
+          user_requirements: user_requirements ?? null
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("update_session_log", {
-    description: "Update an existing session log.",
-    inputSchema: {
-      session_log_id: external_exports.string().uuid().describe("The session log UUID"),
-      session_date: external_exports.string().optional().describe("New session date"),
-      day_number: external_exports.number().int().optional().describe("New day number"),
-      session_number: external_exports.number().int().optional().describe("New session number"),
-      content: external_exports.any().optional().describe("New content (JSON)")
-    }
-  }, async ({ session_log_id, session_date, day_number, session_number, content }) => {
-    const update = {};
-    if (session_date !== void 0) update.session_date = session_date;
-    if (day_number !== void 0) update.day_number = day_number;
-    if (session_number !== void 0) update.session_number = session_number;
-    if (content !== void 0) update.content = content;
-    if (Object.keys(update).length === 0) {
-      return { content: [{ type: "text", text: "Error: No fields to update" }], isError: true };
+  );
+  server.registerTool(
+    "update_launch",
+    {
+      description: "Update an existing launch.",
+      inputSchema: {
+        launch_id: external_exports.string().uuid().describe("The launch UUID"),
+        title: external_exports.string().optional().describe("New title"),
+        type: external_exports.string().optional().describe("New type"),
+        status: external_exports.string().optional().describe("New status"),
+        version: external_exports.string().optional().describe("New version"),
+        user_requirements: external_exports.any().optional().describe("New user requirements (JSON)")
+      }
+    },
+    async ({ launch_id, title, type, status, version: version2, user_requirements }) => {
+      const update = {};
+      if (title !== void 0) update.title = title;
+      if (type !== void 0) update.type = type;
+      if (status !== void 0) update.status = status;
+      if (version2 !== void 0) update.version = version2;
+      if (user_requirements !== void 0)
+        update.user_requirements = user_requirements;
+      if (Object.keys(update).length === 0) {
+        return {
+          content: [
+            { type: "text", text: "Error: No fields to update" }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const res = await apiPut(
+          `/launches/${launch_id}`,
+          update
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-    try {
-      const res = await apiPut(`/session-logs/${session_log_id}`, update);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "delete_launch",
+    {
+      description: "Delete a launch by ID.",
+      inputSchema: {
+        launch_id: external_exports.string().uuid().describe("The launch UUID")
+      }
+    },
+    async ({ launch_id }) => {
+      try {
+        await apiDelete(`/launches/${launch_id}`);
+        return {
+          content: [
+            { type: "text", text: "Launch deleted successfully" }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("delete_session_log", {
-    description: "Delete a session log by ID.",
-    inputSchema: {
-      session_log_id: external_exports.string().uuid().describe("The session log UUID")
+  );
+  server.registerTool(
+    "create_session_log",
+    {
+      description: "Create a new session log for a repo.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        session_date: external_exports.string().describe("Session date (YYYY-MM-DD)"),
+        day_number: external_exports.number().int().describe("Day number (e.g. 41 for D-41)"),
+        session_number: external_exports.number().int().optional().describe("Session number within the day (default: 1)"),
+        content: external_exports.any().optional().describe("Session log content (JSON)"),
+        worktree_id: external_exports.string().uuid().optional().describe("Worktree UUID that created this session log")
+      }
+    },
+    async ({
+      repo_id,
+      session_date,
+      day_number,
+      session_number,
+      content,
+      worktree_id
+    }) => {
+      try {
+        const body = {
+          repo_id,
+          session_date,
+          day_number,
+          session_number: session_number ?? 1,
+          content: content ?? null
+        };
+        if (worktree_id) body.worktree_id = worktree_id;
+        const res = await apiPost(
+          "/session-logs",
+          body
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ session_log_id }) => {
-    try {
-      await apiDelete(`/session-logs/${session_log_id}`);
-      return { content: [{ type: "text", text: "Session log deleted successfully" }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "update_session_log",
+    {
+      description: "Update an existing session log.",
+      inputSchema: {
+        session_log_id: external_exports.string().uuid().describe("The session log UUID"),
+        session_date: external_exports.string().optional().describe("New session date"),
+        day_number: external_exports.number().int().optional().describe("New day number"),
+        session_number: external_exports.number().int().optional().describe("New session number"),
+        content: external_exports.any().optional().describe("New content (JSON)")
+      }
+    },
+    async ({
+      session_log_id,
+      session_date,
+      day_number,
+      session_number,
+      content
+    }) => {
+      const update = {};
+      if (session_date !== void 0) update.session_date = session_date;
+      if (day_number !== void 0) update.day_number = day_number;
+      if (session_number !== void 0) update.session_number = session_number;
+      if (content !== void 0) update.content = content;
+      if (Object.keys(update).length === 0) {
+        return {
+          content: [
+            { type: "text", text: "Error: No fields to update" }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const res = await apiPut(
+          `/session-logs/${session_log_id}`,
+          update
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("sync_claude_files", {
-    description: "Sync .claude infrastructure from CodeByPlan DB to local project. Uses aggregated defaults (latest version across all repos) for shared files (commands, agents, skills, rules, hooks, templates, stack docs). Repo-specific files (CLAUDE.md, settings) are not overwritten.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("Repository ID to sync files for"),
-      project_path: external_exports.string().describe("Absolute path to the project root directory")
+  );
+  server.registerTool(
+    "delete_session_log",
+    {
+      description: "Delete a session log by ID.",
+      inputSchema: {
+        session_log_id: external_exports.string().uuid().describe("The session log UUID")
+      }
+    },
+    async ({ session_log_id }) => {
+      try {
+        await apiDelete(`/session-logs/${session_log_id}`);
+        return {
+          content: [
+            { type: "text", text: "Session log deleted successfully" }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, project_path }) => {
-    try {
-      const syncResult = await executeSyncToLocal({ repoId: repo_id, projectPath: project_path });
-      const { byType, totals, dbOnlyFiles } = syncResult;
-      const summary = {
-        ...byType,
-        totals: { created: totals.created, updated: totals.updated, deleted: totals.deleted },
-        message: totals.created + totals.updated + totals.deleted === 0 ? "All files up to date" : `Synced: ${totals.created} created, ${totals.updated} updated, ${totals.deleted} deleted`
-      };
-      if (dbOnlyFiles.length > 0) {
-        summary.db_only_files = dbOnlyFiles;
-        summary.message += `
+  );
+  server.registerTool(
+    "sync_claude_files",
+    {
+      description: "Sync .claude infrastructure from CodeByPlan DB to local project. Uses aggregated defaults (latest version across all repos) for shared files (commands, agents, skills, rules, hooks, templates, stack docs). Repo-specific files (CLAUDE.md, settings) are not overwritten.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("Repository ID to sync files for"),
+        project_path: external_exports.string().describe("Absolute path to the project root directory")
+      }
+    },
+    async ({ repo_id, project_path }) => {
+      try {
+        const syncResult = await executeSyncToLocal({
+          repoId: repo_id,
+          projectPath: project_path
+        });
+        const { byType, totals, dbOnlyFiles } = syncResult;
+        const summary = {
+          ...byType,
+          totals: {
+            created: totals.created,
+            updated: totals.updated,
+            deleted: totals.deleted
+          },
+          message: totals.created + totals.updated + totals.deleted === 0 ? "All files up to date" : `Synced: ${totals.created} created, ${totals.updated} updated, ${totals.deleted} deleted`
+        };
+        if (dbOnlyFiles.length > 0) {
+          summary.db_only_files = dbOnlyFiles;
+          summary.message += `
 
 ${dbOnlyFiles.length} file(s) exist in DB but were missing locally (recreated). Use delete_claude_files to remove them from DB if they were intentionally deleted.`;
+        }
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(summary, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
       }
-      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("delete_claude_files", {
-    description: "Soft-delete claude files from the CodeByPlan DB. Use after sync_claude_files reports db_only_files that should be removed. Each file is identified by type, name, and optional category.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("Repository ID"),
-      files: external_exports.array(external_exports.object({
-        type: external_exports.string().describe("File type: command, agent, skill, rule, hook, template, docs_stack"),
-        name: external_exports.string().describe("File name"),
-        category: external_exports.string().nullable().optional().describe("Category (for commands: e.g. 'development/checkpoint')")
-      })).describe("Files to soft-delete from DB")
-    }
-  }, async ({ repo_id, files }) => {
-    try {
-      const res = await apiPost("/sync/files", {
-        repo_id,
-        delete_keys: files
-      });
-      return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            deleted: res.data.deleted,
-            message: `Soft-deleted ${res.data.deleted} file(s) from DB. Run sync_claude_files to clean up local copies.`
-          }, null, 2)
-        }]
-      };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
     }
-  });
-  server.registerTool("update_session_state", {
-    description: "Update session state for a repo. Actions: activate (deactivates other repos), deactivate, pause, refresh, clear_refresh.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      action: external_exports.enum(["activate", "deactivate", "pause", "refresh", "clear_refresh"]).describe("Session action to perform")
-    }
-  }, async ({ repo_id, action }) => {
-    try {
-      const res = await apiPatch(`/repos/${repo_id}/session`, { action });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
-    }
-  });
-  server.registerTool("update_server_config", {
-    description: "Update server configuration for a repo (port, type, active servers). Active server entries can include worktree_id to track which worktree is running the server.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      server_port: external_exports.number().int().optional().describe("Server port number"),
-      server_type: external_exports.string().optional().describe("Server type"),
-      active_servers: external_exports.any().optional().describe("Active servers (JSON array)")
-    }
-  }, async ({ repo_id, server_port, server_type, active_servers }) => {
-    const body = {};
-    if (server_port !== void 0) body.server_port = server_port;
-    if (server_type !== void 0) body.server_type = server_type;
-    if (active_servers !== void 0) body.active_servers = active_servers;
-    if (Object.keys(body).length === 0) {
-      return { content: [{ type: "text", text: "Error: No fields to update" }], isError: true };
-    }
-    try {
-      const res = await apiPatch(`/repos/${repo_id}/server`, body);
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "delete_claude_files",
+    {
+      description: "Soft-delete claude files from the CodeByPlan DB. Use after sync_claude_files reports db_only_files that should be removed. Each file is identified by type, name, and optional category.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("Repository ID"),
+        files: external_exports.array(
+          external_exports.object({
+            type: external_exports.string().describe(
+              "File type: command, agent, skill, rule, hook, template, docs_stack, context"
+            ),
+            name: external_exports.string().describe("File name"),
+            category: external_exports.string().nullable().optional().describe(
+              "Category (for commands: e.g. 'development/checkpoint')"
+            )
+          })
+        ).describe("Files to soft-delete from DB")
+      }
+    },
+    async ({ repo_id, files }) => {
+      try {
+        const res = await apiPost("/sync/files", {
+          repo_id,
+          delete_keys: files
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  deleted: res.data.deleted,
+                  message: `Soft-deleted ${res.data.deleted} file(s) from DB. Run sync_claude_files to clean up local copies.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("create_worktree", {
-    description: "Create a new worktree for a repo.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      name: external_exports.string().describe("Worktree name (unique per repo)"),
-      path: external_exports.string().optional().describe("Local filesystem path"),
-      status: external_exports.string().optional().describe("Initial status (default: active)")
+  );
+  server.registerTool(
+    "update_session_state",
+    {
+      description: "Update session state for a repo. Actions: activate (deactivates other repos), deactivate, pause, refresh, clear_refresh.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        action: external_exports.enum(["activate", "deactivate", "pause", "refresh", "clear_refresh"]).describe("Session action to perform")
+      }
+    },
+    async ({ repo_id, action }) => {
+      try {
+        const res = await apiPatch(
+          `/repos/${repo_id}/session`,
+          { action }
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, name, path, status }) => {
-    try {
-      const res = await apiPost("/worktrees", {
-        repo_id,
-        name,
-        path: path ?? null,
-        status: status ?? "active"
-      });
-      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "update_server_config",
+    {
+      description: "Update server configuration for a repo (port, type, active servers). Active server entries can include worktree_id to track which worktree is running the server.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        server_port: external_exports.number().int().optional().describe("Server port number"),
+        server_type: external_exports.string().optional().describe("Server type"),
+        active_servers: external_exports.any().optional().describe("Active servers (JSON array)")
+      }
+    },
+    async ({ repo_id, server_port, server_type, active_servers }) => {
+      const body = {};
+      if (server_port !== void 0) body.server_port = server_port;
+      if (server_type !== void 0) body.server_type = server_type;
+      if (active_servers !== void 0) body.active_servers = active_servers;
+      if (Object.keys(body).length === 0) {
+        return {
+          content: [
+            { type: "text", text: "Error: No fields to update" }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const res = await apiPatch(
+          `/repos/${repo_id}/server`,
+          body
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("delete_worktree", {
-    description: "Delete a worktree by ID.",
-    inputSchema: {
-      worktree_id: external_exports.string().uuid().describe("The worktree UUID")
+  );
+  server.registerTool(
+    "create_worktree",
+    {
+      description: "Create a new worktree for a repo.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        name: external_exports.string().describe("Worktree name (unique per repo)"),
+        path: external_exports.string().optional().describe("Local filesystem path"),
+        status: external_exports.string().optional().describe("Initial status (default: active)")
+      }
+    },
+    async ({ repo_id, name, path, status }) => {
+      try {
+        const res = await apiPost("/worktrees", {
+          repo_id,
+          name,
+          path: path ?? null,
+          status: status ?? "active"
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ worktree_id }) => {
-    try {
-      await apiDelete(`/worktrees/${worktree_id}`);
-      return { content: [{ type: "text", text: "Worktree deleted successfully" }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "delete_worktree",
+    {
+      description: "Delete a worktree by ID.",
+      inputSchema: {
+        worktree_id: external_exports.string().uuid().describe("The worktree UUID")
+      }
+    },
+    async ({ worktree_id }) => {
+      try {
+        await apiDelete(`/worktrees/${worktree_id}`);
+        return {
+          content: [
+            { type: "text", text: "Worktree deleted successfully" }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
-  server.registerTool("create_pr", {
-    description: "Create a GitHub PR for a repo. Uses gh CLI.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      head: external_exports.string().describe("Source branch name"),
-      base: external_exports.string().describe("Target branch name"),
-      title: external_exports.string().describe("PR title"),
-      body: external_exports.string().optional().describe("PR description body")
+  );
+  server.registerTool(
+    "create_pr",
+    {
+      description: "Create a GitHub PR for a repo. Uses gh CLI.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        head: external_exports.string().describe("Source branch name"),
+        base: external_exports.string().describe("Target branch name"),
+        title: external_exports.string().describe("PR title"),
+        body: external_exports.string().optional().describe("PR description body")
+      }
+    },
+    async ({ repo_id, head, base, title, body }) => {
+      try {
+        const repoRes = await apiGet(`/repos/${repo_id}`);
+        const repo = repoRes.data;
+        if (!repo.path) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: Repo path is not configured."
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = await createPR({
+          repoPath: repo.path,
+          head,
+          base,
+          title,
+          body: body ?? ""
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, head, base, title, body }) => {
-    try {
-      const repoRes = await apiGet(`/repos/${repo_id}`);
-      const repo = repoRes.data;
-      if (!repo.path) {
-        return { content: [{ type: "text", text: "Error: Repo path is not configured." }], isError: true };
+  );
+  server.registerTool(
+    "get_pr_status",
+    {
+      description: "Get the status of a GitHub PR by number.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        pr_number: external_exports.number().int().describe("The PR number")
+      }
+    },
+    async ({ repo_id, pr_number }) => {
+      try {
+        const repoRes = await apiGet(`/repos/${repo_id}`);
+        const repo = repoRes.data;
+        if (!repo.path) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: Repo path is not configured."
+              }
+            ],
+            isError: true
+          };
+        }
+        const status = await getPRStatus(repo.path, pr_number);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(status, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
       }
-      const result = await createPR({
-        repoPath: repo.path,
-        head,
-        base,
-        title,
-        body: body ?? ""
-      });
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
     }
-  });
-  server.registerTool("get_pr_status", {
-    description: "Get the status of a GitHub PR by number.",
-    inputSchema: {
-      repo_id: external_exports.string().uuid().describe("The repo UUID"),
-      pr_number: external_exports.number().int().describe("The PR number")
+  );
+  server.registerTool(
+    "promote_checkpoint",
+    {
+      description: "Trigger full promotion flow for a checkpoint. Creates merge checklist from templates and GitHub PR (feat branch \u2192 development).",
+      inputSchema: {
+        checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID")
+      }
+    },
+    async ({ checkpoint_id }) => {
+      try {
+        const result = await promoteCheckpoint(checkpoint_id);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ repo_id, pr_number }) => {
-    try {
-      const repoRes = await apiGet(`/repos/${repo_id}`);
-      const repo = repoRes.data;
-      if (!repo.path) {
-        return { content: [{ type: "text", text: "Error: Repo path is not configured." }], isError: true };
+  );
+  server.registerTool(
+    "acquire_sync_lock",
+    {
+      description: "Acquire a sync lock for a repo. User-scoped: only one active lock per user. Returns conflict if lock already held on a different repo.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID"),
+        locked_by: external_exports.string().describe(
+          "Identifier of the client acquiring the lock (e.g. repo name)"
+        ),
+        reason: external_exports.string().optional().describe("Why the lock is being acquired"),
+        ttl_minutes: external_exports.number().int().optional().describe("Lock TTL in minutes (default 10)"),
+        worktree_id: external_exports.string().uuid().optional().describe("Worktree UUID if syncing from a worktree")
+      }
+    },
+    async ({ repo_id, locked_by, reason, ttl_minutes, worktree_id }) => {
+      try {
+        const res = await apiPost("/sync/lock", {
+          repo_id,
+          locked_by,
+          reason: reason ?? void 0,
+          ttl_minutes: ttl_minutes ?? 10,
+          worktree_id: worktree_id ?? void 0
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
       }
-      const status = await getPRStatus(repo.path, pr_number);
-      return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
     }
-  });
-  server.registerTool("promote_checkpoint", {
-    description: "Trigger full promotion flow for a checkpoint. Creates merge checklist from templates and GitHub PR (feat branch \u2192 development).",
-    inputSchema: {
-      checkpoint_id: external_exports.string().uuid().describe("The checkpoint UUID")
+  );
+  server.registerTool(
+    "release_sync_lock",
+    {
+      description: "Release a sync lock for a repo.",
+      inputSchema: {
+        repo_id: external_exports.string().uuid().describe("The repo UUID")
+      }
+    },
+    async ({ repo_id }) => {
+      try {
+        await apiDelete("/sync/lock", { repo_id });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ released: true }, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  }, async ({ checkpoint_id }) => {
-    try {
-      const result = await promoteCheckpoint(checkpoint_id);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-    } catch (err) {
-      return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+  );
+  server.registerTool(
+    "resolve_sync_conflict",
+    {
+      description: "Resolve a sync conflict. Choose use_local, use_remote, merge (with resolved_content), or skip.",
+      inputSchema: {
+        conflict_id: external_exports.string().uuid().describe("The conflict UUID"),
+        resolution_type: external_exports.enum(["use_local", "use_remote", "merge", "skip"]).describe("Resolution strategy"),
+        resolved_content: external_exports.string().optional().describe("Merged content (required when resolution_type is merge)"),
+        resolved_by_repo_id: external_exports.string().uuid().optional().describe("Repo UUID that resolved the conflict")
+      }
+    },
+    async ({
+      conflict_id,
+      resolution_type,
+      resolved_content,
+      resolved_by_repo_id
+    }) => {
+      try {
+        const res = await apiPatch("/sync/conflicts", {
+          conflict_id,
+          resolution_type,
+          resolved_content: resolved_content ?? void 0,
+          resolved_by_repo_id: resolved_by_repo_id ?? void 0
+        });
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(res.data, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
     }
-  });
+  );
 }
 var init_write = __esm({
   "src/tools/write.ts"() {
@@ -24712,7 +26573,16 @@ if (arg === "setup") {
 }
 if (arg === "sync") {
   const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
-  await runSync2();
+  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 === "help" || arg === "--help" || arg === "-h") {