codebyplan 1.13.58 → 1.13.60

package/dist/cli.js

@@ -48,7 +48,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.58";
+    VERSION = "1.13.60";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -186,6 +186,17 @@ var init_local_config = __esm({
 });
 
 // src/lib/flags.ts
+var flags_exports = {};
+__export(flags_exports, {
+  coerceFieldValues: () => coerceFieldValues,
+  deriveRepoRoot: () => deriveRepoRoot,
+  findCodebyplanConfig: () => findCodebyplanConfig,
+  hasFlag: () => hasFlag,
+  kebabToSnakeKeys: () => kebabToSnakeKeys,
+  parseFlags: () => parseFlags,
+  parseFlagsFromArgs: () => parseFlagsFromArgs,
+  resolveConfig: () => resolveConfig
+});
 import { readFile as readFile2 } from "node:fs/promises";
 import { join as join2, resolve } from "node:path";
 async function findCodebyplanConfig(startDir, maxDepth = 20) {
@@ -869,29 +880,42 @@ async function deleteFallback(filename) {
   } catch {
   }
 }
+function useKeychain() {
+  const v = process.env.CODEBYPLAN_USE_KEYCHAIN;
+  return v === "1" || v === "true";
+}
 async function saveTokens(tokens) {
-  const Keyring = await loadKeyring();
-  if (Keyring) {
-    try {
-      new Keyring(SERVICE, TOKEN_ACCOUNT).setPassword(JSON.stringify(tokens));
-      return;
-    } catch {
+  if (useKeychain()) {
+    const Keyring = await loadKeyring();
+    if (Keyring) {
+      try {
+        new Keyring(SERVICE, TOKEN_ACCOUNT).setPassword(JSON.stringify(tokens));
+        return;
+      } catch {
+      }
     }
   }
   await writeFallback("credentials.json", tokens);
 }
 async function loadTokens() {
+  const fromFile = await readFallback("credentials.json");
+  if (fromFile) return fromFile;
   const Keyring = await loadKeyring();
   if (Keyring) {
     try {
       const raw = new Keyring(SERVICE, TOKEN_ACCOUNT).getPassword();
-      if (raw) return JSON.parse(raw);
+      if (raw) {
+        const tokens = JSON.parse(raw);
+        if (!useKeychain()) await writeFallback("credentials.json", tokens);
+        return tokens;
+      }
     } catch {
     }
   }
-  return readFallback("credentials.json");
+  return null;
 }
 async function clearTokens() {
+  await deleteFallback("credentials.json");
   const Keyring = await loadKeyring();
   if (Keyring) {
     try {
@@ -899,31 +923,39 @@ async function clearTokens() {
     } catch {
     }
   }
-  await deleteFallback("credentials.json");
 }
 async function saveClientRegistration(reg) {
-  const Keyring = await loadKeyring();
-  if (Keyring) {
-    try {
-      new Keyring(SERVICE, CLIENT_ACCOUNT).setPassword(JSON.stringify(reg));
-      return;
-    } catch {
+  if (useKeychain()) {
+    const Keyring = await loadKeyring();
+    if (Keyring) {
+      try {
+        new Keyring(SERVICE, CLIENT_ACCOUNT).setPassword(JSON.stringify(reg));
+        return;
+      } catch {
+      }
     }
   }
   await writeFallback("client.json", reg);
 }
 async function loadClientRegistration() {
+  const fromFile = await readFallback("client.json");
+  if (fromFile) return fromFile;
   const Keyring = await loadKeyring();
   if (Keyring) {
     try {
       const raw = new Keyring(SERVICE, CLIENT_ACCOUNT).getPassword();
-      if (raw) return JSON.parse(raw);
+      if (raw) {
+        const reg = JSON.parse(raw);
+        if (!useKeychain()) await writeFallback("client.json", reg);
+        return reg;
+      }
     } catch {
     }
   }
-  return readFallback("client.json");
+  return null;
 }
 async function clearClientRegistration() {
+  await deleteFallback("client.json");
   const Keyring = await loadKeyring();
   if (Keyring) {
     try {
@@ -931,7 +963,6 @@ async function clearClientRegistration() {
     } catch {
     }
   }
-  await deleteFallback("client.json");
 }
 var SERVICE, TOKEN_ACCOUNT, CLIENT_ACCOUNT, keyringOverride;
 var init_keychain = __esm({
@@ -4809,9 +4840,9 @@ async function eslintInit(repoId, projectPath) {
   Install ${missingPkgs.length} missing packages? [Y/n] `
     );
     if (confirmed) {
-      const { execSync: execSync11 } = await import("node:child_process");
+      const { execSync: execSync12 } = await import("node:child_process");
       try {
-        execSync11(installCmd, { cwd: projectPath, stdio: "inherit" });
+        execSync12(installCmd, { cwd: projectPath, stdio: "inherit" });
         console.log("  Packages installed.\n");
       } catch (err) {
         console.error(
@@ -4989,6 +5020,7 @@ __export(state_store_exports, {
   deleteEntityFile: () => deleteEntityFile,
   hashEntity: () => hashEntity,
   listEntityFiles: () => listEntityFiles,
+  pendingDir: () => pendingDir,
   pendingMarkerPath: () => pendingMarkerPath,
   pruneEntityTree: () => pruneEntityTree,
   readCursor: () => readCursor,
@@ -5054,6 +5086,9 @@ function todosPath(repoRoot) {
 function worktreesPath(repoRoot) {
   return join19(stateDir(repoRoot), "worktrees.json");
 }
+function pendingDir(repoRoot) {
+  return join19(stateDir(repoRoot), "_pending");
+}
 function pendingMarkerPath(repoRoot, entityId) {
   return join19(stateDir(repoRoot), "_pending", `${entityId}.json`);
 }
@@ -5251,6 +5286,126 @@ var state_sync_exports = {};
 __export(state_sync_exports, {
   runSync: () => runSync
 });
+async function replayOutbox(repoRoot, authHeaders) {
+  const markerPaths = await listEntityFiles(pendingDir(repoRoot));
+  for (const markerPath of markerPaths) {
+    try {
+      const marker = await readEntityFile(markerPath);
+      if (!marker) {
+        await deleteEntityFile(markerPath);
+        continue;
+      }
+      if (marker.operation === "complete") {
+        process.stderr.write(
+          `state-sync: replayOutbox: skipping "complete" marker for ${marker.entity} ${marker.id} (deferred; different endpoint \u2014 see CHK-222 TASK-4 follow-up)
+`
+        );
+        continue;
+      }
+      if (marker.operation !== "update" && marker.operation !== "update-log") {
+        process.stderr.write(
+          `state-sync: replayOutbox: discarding unknown operation "${marker.operation}" for ${marker.entity} ${marker.id}
+`
+        );
+        await deleteEntityFile(markerPath);
+        continue;
+      }
+      let entityPath = null;
+      let patchEndpoint = null;
+      switch (marker.entity) {
+        case "checkpoint":
+          entityPath = checkpointPath(repoRoot, marker.id);
+          patchEndpoint = `${backendCheckpointsEndpoint()}/${marker.id}`;
+          break;
+        case "task":
+          if (marker.checkpoint_id) {
+            entityPath = taskPath(repoRoot, marker.checkpoint_id, marker.id);
+          }
+          patchEndpoint = `${backendTasksEndpoint()}/${marker.id}`;
+          break;
+        case "round":
+          if (marker.checkpoint_id && marker.task_id) {
+            entityPath = roundPath(
+              repoRoot,
+              marker.checkpoint_id,
+              marker.task_id,
+              marker.id
+            );
+          }
+          patchEndpoint = `${backendRoundsEndpoint()}/${marker.id}`;
+          break;
+        case "session_log":
+          entityPath = sessionLogPath(repoRoot);
+          patchEndpoint = `${backendSessionLogsEndpoint()}/${marker.id}`;
+          break;
+        default:
+          process.stderr.write(
+            `state-sync: replayOutbox: discarding unknown entity type "${marker.entity}" ${marker.id}
+`
+          );
+          await deleteEntityFile(markerPath);
+          continue;
+      }
+      if (!entityPath) {
+        process.stderr.write(
+          `state-sync: replayOutbox: missing FK for ${marker.entity} ${marker.id} \u2014 discarding marker
+`
+        );
+        await deleteEntityFile(markerPath);
+        continue;
+      }
+      const entityData = await readEntityFile(entityPath);
+      if (!entityData) {
+        await deleteEntityFile(markerPath);
+        continue;
+      }
+      try {
+        const res = await fetch(patchEndpoint, {
+          method: "PATCH",
+          headers: { ...authHeaders, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            ...entityData,
+            expected_sync_seq: entityData["sync_seq"]
+          }),
+          signal: AbortSignal.timeout(3e4)
+        });
+        if (res.ok || res.status >= 400 && res.status < 500) {
+          await deleteEntityFile(markerPath);
+        }
+      } catch {
+      }
+    } catch (err) {
+      process.stderr.write(
+        `state-sync: replayOutbox: unexpected error for marker ${markerPath} (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+}
+function resolveTombstoneEntityPath(repoRoot, tomb) {
+  switch (tomb.entity_table) {
+    case "checkpoints":
+      return checkpointPath(repoRoot, tomb.entity_id);
+    case "tasks": {
+      const checkpointId = tomb.parent_ids?.checkpoint_id;
+      if (!checkpointId) return null;
+      return taskPath(repoRoot, checkpointId, tomb.entity_id);
+    }
+    case "rounds": {
+      const checkpointId = tomb.parent_ids?.checkpoint_id;
+      const taskId = tomb.parent_ids?.task_id;
+      if (!checkpointId || !taskId) return null;
+      return roundPath(repoRoot, checkpointId, taskId, tomb.entity_id);
+    }
+    // Single-slot caches: no per-id file — reconcile on next full hydrate.
+    //   session_logs → session/current.json (deleting it would kill active session data)
+    //   todos        → todos.json
+    //   worktrees    → worktrees.json
+    // Port allocations are intentionally not mirrored to state/.
+    default:
+      return null;
+  }
+}
 async function runSync(repoRoot, repoId, worktreeId, opts = {}) {
   const { full = false, dryRun = false } = opts;
   try {
@@ -5273,6 +5428,9 @@ async function runSync(repoRoot, repoId, worktreeId, opts = {}) {
         error: `auth: ${err instanceof Error ? err.message : String(err)}`
       };
     }
+    if (!dryRun) {
+      await replayOutbox(repoRoot, authHeaders);
+    }
     let result;
     try {
       const res = await fetch(url.toString(), {
@@ -5299,6 +5457,7 @@ async function runSync(repoRoot, repoId, worktreeId, opts = {}) {
         ok: true,
         written: 0,
         pruned: 0,
+        tombstoned: 0,
         mode: isFull ? "full" : "delta",
         max_seq: result.max_seq
       };
@@ -5352,6 +5511,15 @@ async function runSync(repoRoot, repoId, worktreeId, opts = {}) {
       await writeEntityFile(worktreesPath(repoRoot), result.worktrees);
       written++;
     }
+    let tombstoned = 0;
+    for (const tomb of result.deleted ?? []) {
+      const filePath = resolveTombstoneEntityPath(repoRoot, tomb);
+      if (filePath) {
+        await deleteEntityFile(filePath);
+        delete entityHashes[tomb.entity_id];
+        tombstoned++;
+      }
+    }
     let pruned = 0;
     if (isFull) {
       const knownIdsByTable = {
@@ -5378,6 +5546,7 @@ async function runSync(repoRoot, repoId, worktreeId, opts = {}) {
       ok: true,
       written,
       pruned,
+      tombstoned,
       mode: isFull ? "full" : "delta",
       max_seq: result.max_seq
     };
@@ -14535,8 +14704,8 @@ var require_RealtimeChannel = __commonJS({
       }
       /** @internal */
       _notThisChannelEvent(event, ref) {
-        const { close, error, leave, join: join57 } = constants_1.CHANNEL_EVENTS;
-        const events = [close, error, leave, join57];
+        const { close, error, leave, join: join60 } = constants_1.CHANNEL_EVENTS;
+        const events = [close, error, leave, join60];
         return ref && events.includes(event) && ref !== this.joinPush.ref;
       }
       /** @internal */
@@ -27986,6 +28155,9 @@ var init_watch = __esm({
 });
 
 // src/lib/state-client.ts
+function isConflict(err) {
+  return err instanceof BackendError && err.status === 409;
+}
 async function backendRequest(method, path22, body) {
   const url = `${getBackendBase()}${path22}`;
   const auth = await getAuthHeaders();
@@ -28037,11 +28209,316 @@ var init_state_client = __esm({
   }
 });
 
+// src/lib/mcp-client.ts
+async function mcpCall(toolName, args) {
+  let accessToken;
+  try {
+    accessToken = await getAccessToken();
+  } catch (err) {
+    if (err instanceof NoTokenError) {
+      throw new McpError(
+        "Not logged in. Run `codebyplan login` to authenticate."
+      );
+    }
+    throw err;
+  }
+  const body = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: toolName, arguments: args }
+  };
+  let res;
+  try {
+    res = await fetch(mcpEndpoint(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new McpError(`mcp ${toolName} network error: ${message}`);
+  }
+  if (res.status === 401) {
+    throw new McpError(
+      "Authentication failed. Run `codebyplan login` to refresh your session.",
+      401
+    );
+  }
+  if (!res.ok) {
+    throw new McpError(
+      `mcp ${toolName} failed with status ${res.status}`,
+      res.status
+    );
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  let envelope;
+  if (contentType.includes("text/event-stream")) {
+    const text = await res.text();
+    envelope = parseSseEnvelope(text, toolName);
+  } else {
+    envelope = await res.json();
+  }
+  if (envelope.error) {
+    throw new McpError(
+      envelope.error.message ?? `mcp ${toolName} protocol error`,
+      void 0,
+      envelope.error.code !== void 0 ? String(envelope.error.code) : void 0
+    );
+  }
+  const result = envelope.result;
+  if (!result) {
+    throw new McpError(`mcp ${toolName} returned no result`);
+  }
+  const textContent = result.content?.find((c) => c.type === "text")?.text;
+  if (textContent === void 0) {
+    throw new McpError(`mcp ${toolName} returned no text content`);
+  }
+  if (result.isError === true) {
+    throw new McpError(textContent);
+  }
+  try {
+    return JSON.parse(textContent);
+  } catch {
+    throw new McpError(
+      `mcp ${toolName} returned non-JSON payload: ${textContent.slice(0, 200)}`
+    );
+  }
+}
+function parseSseEnvelope(text, toolName) {
+  const frames = text.split("\n\n");
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const frame = frames[i];
+    const dataLines = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+    if (dataLines.length === 0) continue;
+    const dataText = dataLines.join("\n");
+    try {
+      return JSON.parse(dataText);
+    } catch {
+      continue;
+    }
+  }
+  throw new McpError(`mcp ${toolName} returned unparseable SSE body`);
+}
+var REQUEST_TIMEOUT_MS3, McpError;
+var init_mcp_client = __esm({
+  "src/lib/mcp-client.ts"() {
+    "use strict";
+    init_token_refresh();
+    init_urls();
+    REQUEST_TIMEOUT_MS3 = 12e4;
+    McpError = class extends Error {
+      status;
+      code;
+      constructor(message, status, code) {
+        super(message);
+        this.name = "McpError";
+        this.status = status;
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/cli/export-writer.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join21 } from "node:path";
+async function buildCheckpointExport(checkpointId) {
+  const checkpointResponse = await apiGet(
+    `/checkpoints/${checkpointId}`
+  );
+  const checkpoint = checkpointResponse.data;
+  if (!checkpoint) {
+    throw new Error(
+      `buildCheckpointExport: checkpoint ${checkpointId} not found`
+    );
+  }
+  const tasksResponse = await apiGet(
+    "/tasks",
+    { checkpoint_id: checkpointId }
+  );
+  const rawTasks = tasksResponse.data ?? [];
+  const tasks = await Promise.all(
+    rawTasks.map(async (task) => {
+      const rawRounds = await fetchRoundsForTask(task.id);
+      const rounds = rawRounds.map((r) => ({
+        id: r.id,
+        number: r.number,
+        status: r.status,
+        files_changed: r.files_changed ?? [],
+        context: r.context ?? null
+      }));
+      return {
+        id: task.id,
+        number: task.number,
+        title: task.title ?? null,
+        status: task.status,
+        completed_at: task.completed_at ?? null,
+        files_changed: task.files_changed ?? [],
+        qa: task.qa ?? null,
+        rounds
+      };
+    })
+  );
+  return {
+    schema_version: EXPORT_SCHEMA_VERSION,
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    checkpoint_id: checkpointId,
+    number: checkpoint.number,
+    sync_seq: checkpoint.sync_seq,
+    title: checkpoint.title ?? null,
+    status: checkpoint.status,
+    completed_at: checkpoint.completed_at ?? null,
+    context: checkpoint.context ?? null,
+    files_changed: checkpoint.files_changed ?? [],
+    qa: checkpoint.qa ?? null,
+    tasks
+  };
+}
+async function buildStandaloneExport(taskId, repoRoot, repoIdHint) {
+  let repoId = repoIdHint;
+  if (!repoId) {
+    const { findCodebyplanConfig: findCodebyplanConfig2 } = await Promise.resolve().then(() => (init_flags(), flags_exports));
+    const found = await findCodebyplanConfig2(repoRoot);
+    repoId = found?.contents.repo_id;
+  }
+  if (!repoId) {
+    throw new Error(
+      "buildStandaloneExport: could not resolve repo_id from .codebyplan/repo.json"
+    );
+  }
+  const allTasks = await mcpCall("get_standalone_tasks", {
+    repo_id: repoId
+  });
+  const task = allTasks.find((t) => t.id === taskId);
+  if (!task) {
+    throw new Error(
+      `buildStandaloneExport: standalone task ${taskId} not found`
+    );
+  }
+  const rawRounds = await mcpCall("get_standalone_rounds", {
+    standalone_task_id: taskId
+  });
+  const rounds = rawRounds.map((r) => ({
+    id: r.id,
+    number: r.number,
+    status: r.status,
+    files_changed: r.files_changed ?? [],
+    context: r.context ?? null
+  }));
+  const taskEntry = {
+    id: task.id,
+    number: task.number,
+    title: task.title,
+    status: task.status,
+    completed_at: task.completed_at ?? null,
+    files_changed: task.files_changed ?? [],
+    qa: task.qa ?? null,
+    rounds
+  };
+  return {
+    schema_version: EXPORT_SCHEMA_VERSION,
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    standalone_task_id: taskId,
+    number: task.number,
+    title: task.title,
+    status: task.status,
+    completed_at: task.completed_at ?? null,
+    context: task.context ?? null,
+    files_changed: task.files_changed ?? [],
+    qa: task.qa ?? null,
+    tasks: [taskEntry]
+  };
+}
+function renderSummaryMd(data) {
+  const isCheckpoint = "checkpoint_id" in data;
+  const entityLabel = isCheckpoint ? "Checkpoint" : "Standalone Task";
+  const entityId = isCheckpoint ? data.checkpoint_id : data.standalone_task_id;
+  const completedLine = data.completed_at ? `**Completed**: ${data.completed_at}` : `**Status**: ${data.status}`;
+  const ctx = data.context;
+  const decisions = Array.isArray(ctx?.decisions) ? ctx.decisions : [];
+  const decisionsBlock = decisions.length > 0 ? `
+## Decisions
+
+${decisions.map(
+    (d, i) => `${i + 1}. ${typeof d === "string" ? d : JSON.stringify(d)}`
+  ).join("\n")}
+` : "";
+  const taskRows = data.tasks.map((t) => {
+    const roundCount = t.rounds.length;
+    const fileCount = Array.isArray(t.files_changed) ? t.files_changed.length : 0;
+    return `| ${t.number} | ${t.title ?? "(untitled)"} | ${t.status} | ${roundCount} | ${fileCount} |`;
+  }).join("\n");
+  const tasksBlock = data.tasks.length > 0 ? `
+## Tasks
+
+| # | Title | Status | Rounds | Files |
+|---|-------|--------|--------|-------|
+${taskRows}
+` : "";
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const task of data.tasks) {
+    if (Array.isArray(task.files_changed)) {
+      for (const f of task.files_changed) {
+        const path22 = typeof f === "string" ? f : f?.path;
+        if (path22) allFiles.add(path22);
+      }
+    }
+  }
+  const filesBlock = allFiles.size > 0 ? `
+## Files Changed (${allFiles.size})
+
+${[...allFiles].sort().map((f) => `- \`${f}\``).join("\n")}
+` : "";
+  return `# ${entityLabel} Export
+
+**${entityLabel} ID**: \`${entityId}\`
+**Number**: ${data.number}
+**Title**: ${data.title ?? "(untitled)"}
+${completedLine}
+**Exported**: ${data.exported_at}
+` + decisionsBlock + tasksBlock + filesBlock;
+}
+function writeExportArtifacts(outDir, exportData, summaryMd) {
+  mkdirSync3(outDir, { recursive: true });
+  const exportJsonPath = join21(outDir, "export.json");
+  const summaryMdPath = join21(outDir, "summary.md");
+  writeFileSync3(
+    exportJsonPath,
+    JSON.stringify(exportData, null, 2) + "\n",
+    "utf-8"
+  );
+  writeFileSync3(summaryMdPath, summaryMd, "utf-8");
+  return { exportJsonPath, summaryMdPath };
+}
+async function fetchRoundsForTask(taskId) {
+  try {
+    return await mcpCall("get_rounds", { task_id: taskId });
+  } catch {
+    return [];
+  }
+}
+var EXPORT_SCHEMA_VERSION;
+var init_export_writer = __esm({
+  "src/cli/export-writer.ts"() {
+    "use strict";
+    init_api();
+    init_mcp_client();
+    EXPORT_SCHEMA_VERSION = 1;
+  }
+});
+
 // src/cli/checkpoint.ts
 var checkpoint_exports = {};
 __export(checkpoint_exports, {
   runCheckpointCommand: () => runCheckpointCommand
 });
+import { join as join22 } from "node:path";
 async function resolveRepoRoot() {
   const found = await findCodebyplanConfig(process.cwd());
   if (!found?.contents.repo_id) return null;
@@ -28127,41 +28604,91 @@ async function runCheckpointUpdate(args) {
   const snakePatch = coerceFieldValues(kebabToSnakeKeys(patchBody));
   const optimistic = { ...snapshot ?? {}, ...snakePatch, id };
   await writeEntityFile(filePath, optimistic);
-  try {
-    const updated = await apiBackendPatch(
-      `${new URL(backendCheckpointsEndpoint()).pathname}/${id}`,
-      snakePatch
-    );
-    await writeEntityFile(filePath, updated);
-    await updateCursorHash(repoRoot, id, updated);
-    process.stdout.write(JSON.stringify(updated) + "\n");
-  } catch (err) {
-    if (err instanceof BackendError && err.status < 500) {
-      if (snapshot !== null) {
-        await writeEntityFile(filePath, snapshot);
-      } else {
-        await deleteEntityFile(filePath);
-      }
-      process.stderr.write(
-        `checkpoint update: backend rejected (${err.status}): ${err.message}
-`
+  let freshRow = snapshot;
+  let lastErr;
+  let successRow = null;
+  if (freshRow === null) {
+    try {
+      const bootstrapResponse = await apiGet(
+        `/checkpoints/${id}`
       );
+      freshRow = bootstrapResponse.data;
+      await writeEntityFile(filePath, freshRow);
+    } catch {
+    }
+  }
+  for (let attempt = 0; attempt <= MAX_OCC_RETRIES; attempt++) {
+    const currentSeq = freshRow !== null && typeof freshRow.sync_seq === "number" ? freshRow.sync_seq : void 0;
+    const patchWithSeq = currentSeq !== void 0 ? { ...snakePatch, expected_sync_seq: currentSeq } : { ...snakePatch };
+    try {
+      const updated = await apiBackendPatch(
+        `${new URL(backendCheckpointsEndpoint()).pathname}/${id}`,
+        patchWithSeq
+      );
+      await writeEntityFile(filePath, updated);
+      await updateCursorHash(repoRoot, id, updated);
+      successRow = updated;
+      break;
+    } catch (err2) {
+      if (isConflict(err2) && attempt < MAX_OCC_RETRIES) {
+        try {
+          const freshResponse = await apiGet(
+            `/checkpoints/${id}`
+          );
+          freshRow = freshResponse.data;
+          await writeEntityFile(filePath, freshRow);
+        } catch {
+          lastErr = err2;
+          break;
+        }
+        lastErr = err2;
+        continue;
+      }
+      lastErr = err2;
+      break;
+    }
+  }
+  if (successRow !== null) {
+    process.stdout.write(JSON.stringify(successRow) + "\n");
+    process.exit(0);
+  }
+  const err = lastErr;
+  if (isConflict(err)) {
+    if (freshRow !== null) {
+      await writeEntityFile(filePath, freshRow);
+    } else if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
     } else {
-      await writeEntityFile(pendingMarkerPath(repoRoot, id), {
-        entity: "checkpoint",
-        id,
-        operation: "update",
-        attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: err instanceof Error ? err.message : String(err)
-      });
-      process.stderr.write(
-        `checkpoint update: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `checkpoint update: conflict \u2014 another writer updated checkpoint ${id} concurrently. Re-read the checkpoint and retry.
 `
-      );
+    );
+  } else if (err instanceof BackendError && err.status < 500) {
+    if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
+    } else {
+      await deleteEntityFile(filePath);
     }
-    process.exit(1);
+    process.stderr.write(
+      `checkpoint update: backend rejected (${err.status}): ${err.message}
+`
+    );
+  } else {
+    await writeEntityFile(pendingMarkerPath(repoRoot, id), {
+      entity: "checkpoint",
+      id,
+      operation: "update",
+      attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: err instanceof Error ? err.message : String(err)
+    });
+    process.stderr.write(
+      `checkpoint update: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-  process.exit(0);
+  process.exit(1);
 }
 async function runCheckpointComplete(args) {
   const { flags } = parseFlagsFromArgs(args);
@@ -28184,45 +28711,145 @@ async function runCheckpointComplete(args) {
   const snapshot = await readEntityFile(filePath);
   const optimistic = { ...snapshot ?? {}, id, status: "completed" };
   await writeEntityFile(filePath, optimistic);
-  try {
-    const completed = await apiBackendPost(
-      `${new URL(backendCheckpointsEndpoint()).pathname}/${id}/complete`,
-      {}
-    );
-    await writeEntityFile(filePath, completed);
-    await updateCursorHash(repoRoot, id, completed);
-    process.stdout.write(JSON.stringify(completed) + "\n");
-  } catch (err) {
-    if (err instanceof BackendError && err.status < 500) {
-      if (snapshot !== null) {
-        await writeEntityFile(filePath, snapshot);
-      } else {
-        await deleteEntityFile(filePath);
+  let freshRow = snapshot;
+  let lastErr;
+  let successRow = null;
+  for (let attempt = 0; attempt <= MAX_OCC_RETRIES; attempt++) {
+    try {
+      const completed = await apiBackendPost(
+        `${new URL(backendCheckpointsEndpoint()).pathname}/${id}/complete`,
+        {}
+      );
+      await writeEntityFile(filePath, completed);
+      await updateCursorHash(repoRoot, id, completed);
+      successRow = completed;
+      break;
+    } catch (err2) {
+      if (isConflict(err2) && attempt < MAX_OCC_RETRIES) {
+        try {
+          const freshResponse = await apiGet(
+            `/checkpoints/${id}`
+          );
+          freshRow = freshResponse.data;
+          await writeEntityFile(filePath, freshRow);
+        } catch {
+          lastErr = err2;
+          break;
+        }
+        lastErr = err2;
+        continue;
       }
-      process.stderr.write(
-        `checkpoint complete: backend rejected (${err.status}): ${err.message}
+      lastErr = err2;
+      break;
+    }
+  }
+  if (successRow !== null) {
+    process.stdout.write(JSON.stringify(successRow) + "\n");
+    process.exit(0);
+  }
+  const err = lastErr;
+  if (isConflict(err)) {
+    if (freshRow !== null) {
+      await writeEntityFile(filePath, freshRow);
+    } else if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
+    } else {
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `checkpoint complete: conflict \u2014 another writer updated checkpoint ${id} concurrently. Re-read the checkpoint and retry.
 `
-      );
+    );
+  } else if (err instanceof BackendError && err.status < 500) {
+    if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
     } else {
-      await writeEntityFile(pendingMarkerPath(repoRoot, id), {
-        entity: "checkpoint",
-        id,
-        operation: "complete",
-        attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: err instanceof Error ? err.message : String(err)
-      });
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `checkpoint complete: backend rejected (${err.status}): ${err.message}
+`
+    );
+  } else {
+    await writeEntityFile(pendingMarkerPath(repoRoot, id), {
+      entity: "checkpoint",
+      id,
+      operation: "complete",
+      attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: err instanceof Error ? err.message : String(err)
+    });
+    process.stderr.write(
+      `checkpoint complete: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  process.exit(1);
+}
+async function runCheckpointExport(args) {
+  const { flags } = parseFlagsFromArgs(args);
+  const id = flags.id ?? flags["checkpoint-id"];
+  if (!id) {
+    process.stderr.write(
+      "checkpoint export: --id <checkpoint-id> is required\n"
+    );
+    process.exit(1);
+  }
+  const repoInfo = await resolveRepoRoot();
+  if (!repoInfo) {
+    process.stderr.write(
+      "checkpoint export: no .codebyplan/repo.json found. Run `codebyplan setup`.\n"
+    );
+    process.exit(1);
+  }
+  const { repoRoot } = repoInfo;
+  try {
+    const exportData = await buildCheckpointExport(id);
+    const outDir = join22(
+      repoRoot,
+      ".codebyplan",
+      "exports",
+      String(exportData.number)
+    );
+    const summaryMd = renderSummaryMd(exportData);
+    const { exportJsonPath, summaryMdPath } = writeExportArtifacts(
+      outDir,
+      exportData,
+      summaryMd
+    );
+    const last_exported_at = exportData.exported_at;
+    try {
+      await apiBackendPatch(
+        `${new URL(backendCheckpointsEndpoint()).pathname}/${id}`,
+        { last_exported_at, expected_sync_seq: exportData.sync_seq }
+      );
+    } catch (err) {
+      const detail = err instanceof BackendError ? `(${err.status}): ${err.message}` : err instanceof Error ? err.message : String(err);
       process.stderr.write(
-        `checkpoint complete: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+        `checkpoint export: warning \u2014 could not stamp last_exported_at ${detail}
 `
       );
     }
+    process.stdout.write(
+      JSON.stringify({
+        exported: true,
+        path: outDir,
+        export_json: exportJsonPath,
+        summary_md: summaryMdPath,
+        last_exported_at
+      }) + "\n"
+    );
+  } catch (err) {
+    process.stderr.write(
+      `checkpoint export: ${err instanceof Error ? err.message : String(err)}
+`
+    );
     process.exit(1);
   }
   process.exit(0);
 }
 function printCheckpointHelp() {
   process.stdout.write(
-    "\n  codebyplan checkpoint <subcommand>\n\n  Subcommands:\n    create    Create a checkpoint (--repo-id auto-resolved, pass extra fields as --key value)\n    update    Update a checkpoint (--id <uuid> required, then --key value pairs)\n    complete  Complete a checkpoint (--id <uuid> required)\n\n"
+    "\n  codebyplan checkpoint <subcommand>\n\n  Subcommands:\n    create    Create a checkpoint (--repo-id auto-resolved, pass extra fields as --key value)\n    update    Update a checkpoint (--id <uuid> required, then --key value pairs)\n    complete  Complete a checkpoint (--id <uuid> required)\n    export    Export checkpoint data to .codebyplan/exports/{N}/ (--id <uuid> required)\n\n"
   );
 }
 async function runCheckpointCommand(args) {
@@ -28239,6 +28866,10 @@ async function runCheckpointCommand(args) {
     await runCheckpointComplete(args.slice(1));
     return;
   }
+  if (subcommand === "export") {
+    await runCheckpointExport(args.slice(1));
+    return;
+  }
   if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
     printCheckpointHelp();
     process.exit(0);
@@ -28254,13 +28885,17 @@ Run 'codebyplan checkpoint help' for usage.
   }
   process.exit(1);
 }
+var MAX_OCC_RETRIES;
 var init_checkpoint = __esm({
   "src/cli/checkpoint.ts"() {
     "use strict";
+    init_api();
     init_flags();
     init_state_store();
     init_state_client();
     init_urls();
+    init_export_writer();
+    MAX_OCC_RETRIES = 3;
   }
 });
 
@@ -28364,42 +28999,88 @@ async function runTaskUpdate(args) {
   const snakePatch = coerceFieldValues(kebabToSnakeKeys(patchBody));
   const optimistic = { ...snapshot ?? {}, ...snakePatch, id };
   await writeEntityFile(filePath, optimistic);
-  try {
-    const updated = await apiBackendPatch(
-      `${new URL(backendTasksEndpoint()).pathname}/${id}`,
-      snakePatch
-    );
-    await writeEntityFile(filePath, updated);
-    await updateCursorHash2(repoRoot, id, updated);
-    process.stdout.write(JSON.stringify(updated) + "\n");
-  } catch (err) {
-    if (err instanceof BackendError && err.status < 500) {
-      if (snapshot !== null) {
-        await writeEntityFile(filePath, snapshot);
-      } else {
-        await deleteEntityFile(filePath);
-      }
-      process.stderr.write(
-        `task update: backend rejected (${err.status}): ${err.message}
-`
+  let freshRow = snapshot;
+  let lastErr;
+  let successRow = null;
+  if (freshRow === null) {
+    try {
+      const bootstrapResponse = await apiGet(`/tasks/${id}`);
+      freshRow = bootstrapResponse.data;
+      await writeEntityFile(filePath, freshRow);
+    } catch {
+    }
+  }
+  for (let attempt = 0; attempt <= MAX_OCC_RETRIES2; attempt++) {
+    const currentSeq = freshRow !== null && typeof freshRow.sync_seq === "number" ? freshRow.sync_seq : void 0;
+    const patchWithSeq = currentSeq !== void 0 ? { ...snakePatch, expected_sync_seq: currentSeq } : { ...snakePatch };
+    try {
+      const updated = await apiBackendPatch(
+        `${new URL(backendTasksEndpoint()).pathname}/${id}`,
+        patchWithSeq
       );
+      await writeEntityFile(filePath, updated);
+      await updateCursorHash2(repoRoot, id, updated);
+      successRow = updated;
+      break;
+    } catch (err2) {
+      if (isConflict(err2) && attempt < MAX_OCC_RETRIES2) {
+        try {
+          const freshResponse = await apiGet(`/tasks/${id}`);
+          freshRow = freshResponse.data;
+          await writeEntityFile(filePath, freshRow);
+        } catch {
+          lastErr = err2;
+          break;
+        }
+        lastErr = err2;
+        continue;
+      }
+      lastErr = err2;
+      break;
+    }
+  }
+  if (successRow !== null) {
+    process.stdout.write(JSON.stringify(successRow) + "\n");
+    process.exit(0);
+  }
+  const err = lastErr;
+  if (isConflict(err)) {
+    if (freshRow !== null) {
+      await writeEntityFile(filePath, freshRow);
+    } else if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
     } else {
-      await writeEntityFile(pendingMarkerPath(repoRoot, id), {
-        entity: "task",
-        id,
-        checkpoint_id: checkpointId,
-        operation: "update",
-        attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: err instanceof Error ? err.message : String(err)
-      });
-      process.stderr.write(
-        `task update: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `task update: conflict \u2014 another writer updated task ${id} concurrently. Re-read the task and retry.
 `
-      );
+    );
+  } else if (err instanceof BackendError && err.status < 500) {
+    if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
+    } else {
+      await deleteEntityFile(filePath);
     }
-    process.exit(1);
+    process.stderr.write(
+      `task update: backend rejected (${err.status}): ${err.message}
+`
+    );
+  } else {
+    await writeEntityFile(pendingMarkerPath(repoRoot, id), {
+      entity: "task",
+      id,
+      checkpoint_id: checkpointId,
+      operation: "update",
+      attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: err instanceof Error ? err.message : String(err)
+    });
+    process.stderr.write(
+      `task update: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-  process.exit(0);
+  process.exit(1);
 }
 async function runTaskComplete(args) {
   const { flags } = parseFlagsFromArgs(args);
@@ -28427,42 +29108,78 @@ async function runTaskComplete(args) {
   const snapshot = await readEntityFile(filePath);
   const optimistic = { ...snapshot ?? {}, id, status: "completed" };
   await writeEntityFile(filePath, optimistic);
-  try {
-    const completed = await apiBackendPost(
-      `${new URL(backendTasksEndpoint()).pathname}/${id}/complete`,
-      {}
-    );
-    await writeEntityFile(filePath, completed);
-    await updateCursorHash2(repoRoot, id, completed);
-    process.stdout.write(JSON.stringify(completed) + "\n");
-  } catch (err) {
-    if (err instanceof BackendError && err.status < 500) {
-      if (snapshot !== null) {
-        await writeEntityFile(filePath, snapshot);
-      } else {
-        await deleteEntityFile(filePath);
-      }
-      process.stderr.write(
-        `task complete: backend rejected (${err.status}): ${err.message}
-`
+  let freshRow = snapshot;
+  let lastErr;
+  let successRow = null;
+  for (let attempt = 0; attempt <= MAX_OCC_RETRIES2; attempt++) {
+    try {
+      const completed = await apiBackendPost(
+        `${new URL(backendTasksEndpoint()).pathname}/${id}/complete`,
+        {}
       );
+      await writeEntityFile(filePath, completed);
+      await updateCursorHash2(repoRoot, id, completed);
+      successRow = completed;
+      break;
+    } catch (err2) {
+      if (isConflict(err2) && attempt < MAX_OCC_RETRIES2) {
+        try {
+          const freshResponse = await apiGet(`/tasks/${id}`);
+          freshRow = freshResponse.data;
+          await writeEntityFile(filePath, freshRow);
+        } catch {
+          lastErr = err2;
+          break;
+        }
+        lastErr = err2;
+        continue;
+      }
+      lastErr = err2;
+      break;
+    }
+  }
+  if (successRow !== null) {
+    process.stdout.write(JSON.stringify(successRow) + "\n");
+    process.exit(0);
+  }
+  const err = lastErr;
+  if (isConflict(err)) {
+    if (freshRow !== null) {
+      await writeEntityFile(filePath, freshRow);
+    } else if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
     } else {
-      await writeEntityFile(pendingMarkerPath(repoRoot, id), {
-        entity: "task",
-        id,
-        checkpoint_id: checkpointId,
-        operation: "complete",
-        attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: err instanceof Error ? err.message : String(err)
-      });
-      process.stderr.write(
-        `task complete: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `task complete: conflict \u2014 another writer updated task ${id} concurrently. Re-read the task and retry.
 `
-      );
+    );
+  } else if (err instanceof BackendError && err.status < 500) {
+    if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
+    } else {
+      await deleteEntityFile(filePath);
     }
-    process.exit(1);
+    process.stderr.write(
+      `task complete: backend rejected (${err.status}): ${err.message}
+`
+    );
+  } else {
+    await writeEntityFile(pendingMarkerPath(repoRoot, id), {
+      entity: "task",
+      id,
+      checkpoint_id: checkpointId,
+      operation: "complete",
+      attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: err instanceof Error ? err.message : String(err)
+    });
+    process.stderr.write(
+      `task complete: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-  process.exit(0);
+  process.exit(1);
 }
 function printTaskHelp() {
   process.stdout.write(
@@ -28498,129 +29215,16 @@ Run 'codebyplan task help' for usage.
   }
   process.exit(1);
 }
+var MAX_OCC_RETRIES2;
 var init_task = __esm({
   "src/cli/task.ts"() {
     "use strict";
+    init_api();
     init_flags();
     init_state_store();
     init_state_client();
     init_urls();
-  }
-});
-
-// src/lib/mcp-client.ts
-async function mcpCall(toolName, args) {
-  let accessToken;
-  try {
-    accessToken = await getAccessToken();
-  } catch (err) {
-    if (err instanceof NoTokenError) {
-      throw new McpError(
-        "Not logged in. Run `codebyplan login` to authenticate."
-      );
-    }
-    throw err;
-  }
-  const body = {
-    jsonrpc: "2.0",
-    id: 1,
-    method: "tools/call",
-    params: { name: toolName, arguments: args }
-  };
-  let res;
-  try {
-    res = await fetch(mcpEndpoint(), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json, text/event-stream",
-        Authorization: `Bearer ${accessToken}`
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new McpError(`mcp ${toolName} network error: ${message}`);
-  }
-  if (res.status === 401) {
-    throw new McpError(
-      "Authentication failed. Run `codebyplan login` to refresh your session.",
-      401
-    );
-  }
-  if (!res.ok) {
-    throw new McpError(
-      `mcp ${toolName} failed with status ${res.status}`,
-      res.status
-    );
-  }
-  const contentType = res.headers.get("content-type") ?? "";
-  let envelope;
-  if (contentType.includes("text/event-stream")) {
-    const text = await res.text();
-    envelope = parseSseEnvelope(text, toolName);
-  } else {
-    envelope = await res.json();
-  }
-  if (envelope.error) {
-    throw new McpError(
-      envelope.error.message ?? `mcp ${toolName} protocol error`,
-      void 0,
-      envelope.error.code !== void 0 ? String(envelope.error.code) : void 0
-    );
-  }
-  const result = envelope.result;
-  if (!result) {
-    throw new McpError(`mcp ${toolName} returned no result`);
-  }
-  const textContent = result.content?.find((c) => c.type === "text")?.text;
-  if (textContent === void 0) {
-    throw new McpError(`mcp ${toolName} returned no text content`);
-  }
-  if (result.isError === true) {
-    throw new McpError(textContent);
-  }
-  try {
-    return JSON.parse(textContent);
-  } catch {
-    throw new McpError(
-      `mcp ${toolName} returned non-JSON payload: ${textContent.slice(0, 200)}`
-    );
-  }
-}
-function parseSseEnvelope(text, toolName) {
-  const frames = text.split("\n\n");
-  for (let i = frames.length - 1; i >= 0; i--) {
-    const frame = frames[i];
-    const dataLines = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
-    if (dataLines.length === 0) continue;
-    const dataText = dataLines.join("\n");
-    try {
-      return JSON.parse(dataText);
-    } catch {
-      continue;
-    }
-  }
-  throw new McpError(`mcp ${toolName} returned unparseable SSE body`);
-}
-var REQUEST_TIMEOUT_MS3, McpError;
-var init_mcp_client = __esm({
-  "src/lib/mcp-client.ts"() {
-    "use strict";
-    init_token_refresh();
-    init_urls();
-    REQUEST_TIMEOUT_MS3 = 12e4;
-    McpError = class extends Error {
-      status;
-      code;
-      constructor(message, status, code) {
-        super(message);
-        this.name = "McpError";
-        this.status = status;
-        this.code = code;
-      }
-    };
+    MAX_OCC_RETRIES2 = 3;
   }
 });
 
@@ -28766,6 +29370,7 @@ var init_sync_approvals = __esm({
 var round_exports = {};
 __export(round_exports, {
   GIT_STATUS_CMD: () => GIT_STATUS_CMD,
+  MAX_OCC_RETRIES: () => MAX_OCC_RETRIES3,
   RETRY_DELAY_MS: () => RETRY_DELAY_MS,
   fetchRoundsWithRetry: () => fetchRoundsWithRetry,
   isTransientMcpError: () => isTransientMcpError,
@@ -28777,7 +29382,7 @@ __export(round_exports, {
   setRetryDelayMs: () => setRetryDelayMs
 });
 import { access as access4 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 function setRetryDelayMs(ms) {
   RETRY_DELAY_MS = ms;
@@ -28953,43 +29558,89 @@ async function runRoundUpdate(args) {
   const snakePatch = coerceFieldValues(kebabToSnakeKeys(patchBody));
   const optimistic = { ...snapshot ?? {}, ...snakePatch, id };
   await writeEntityFile(filePath, optimistic);
-  try {
-    const updated = await apiBackendPatch(
-      `${new URL(backendRoundsEndpoint()).pathname}/${id}`,
-      snakePatch
-    );
-    await writeEntityFile(filePath, updated);
-    await updateRoundCursorHash(repoRoot, id, updated);
-    process.stdout.write(JSON.stringify(updated) + "\n");
-  } catch (err) {
-    if (err instanceof BackendError && err.status < 500) {
-      if (snapshot !== null) {
-        await writeEntityFile(filePath, snapshot);
-      } else {
-        await deleteEntityFile(filePath);
-      }
-      process.stderr.write(
-        `round update: backend rejected (${err.status}): ${err.message}
-`
+  let freshRow = snapshot;
+  let lastErr;
+  let successRow = null;
+  if (freshRow === null) {
+    try {
+      const bootstrapResponse = await apiGet(`/rounds/${id}`);
+      freshRow = bootstrapResponse.data;
+      await writeEntityFile(filePath, freshRow);
+    } catch {
+    }
+  }
+  for (let attempt = 0; attempt <= MAX_OCC_RETRIES3; attempt++) {
+    const currentSeq = freshRow !== null && typeof freshRow.sync_seq === "number" ? freshRow.sync_seq : void 0;
+    const patchWithSeq = currentSeq !== void 0 ? { ...snakePatch, expected_sync_seq: currentSeq } : { ...snakePatch };
+    try {
+      const updated = await apiBackendPatch(
+        `${new URL(backendRoundsEndpoint()).pathname}/${id}`,
+        patchWithSeq
       );
+      await writeEntityFile(filePath, updated);
+      await updateRoundCursorHash(repoRoot, id, updated);
+      successRow = updated;
+      break;
+    } catch (err2) {
+      if (isConflict(err2) && attempt < MAX_OCC_RETRIES3) {
+        try {
+          const freshResponse = await apiGet(`/rounds/${id}`);
+          freshRow = freshResponse.data;
+          await writeEntityFile(filePath, freshRow);
+        } catch {
+          lastErr = err2;
+          break;
+        }
+        lastErr = err2;
+        continue;
+      }
+      lastErr = err2;
+      break;
+    }
+  }
+  if (successRow !== null) {
+    process.stdout.write(JSON.stringify(successRow) + "\n");
+    process.exit(0);
+  }
+  const err = lastErr;
+  if (isConflict(err)) {
+    if (freshRow !== null) {
+      await writeEntityFile(filePath, freshRow);
+    } else if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
     } else {
-      await writeEntityFile(pendingMarkerPath(repoRoot, id), {
-        entity: "round",
-        id,
-        checkpoint_id: checkpointId,
-        task_id: taskId,
-        operation: "update",
-        attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: err instanceof Error ? err.message : String(err)
-      });
-      process.stderr.write(
-        `round update: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `round update: conflict \u2014 another writer updated round ${id} concurrently. Re-read the round and retry.
 `
-      );
+    );
+  } else if (err instanceof BackendError && err.status < 500) {
+    if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
+    } else {
+      await deleteEntityFile(filePath);
     }
-    process.exit(1);
+    process.stderr.write(
+      `round update: backend rejected (${err.status}): ${err.message}
+`
+    );
+  } else {
+    await writeEntityFile(pendingMarkerPath(repoRoot, id), {
+      entity: "round",
+      id,
+      checkpoint_id: checkpointId,
+      task_id: taskId,
+      operation: "update",
+      attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: err instanceof Error ? err.message : String(err)
+    });
+    process.stderr.write(
+      `round update: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-  process.exit(0);
+  process.exit(1);
 }
 async function runRoundComplete(args) {
   const { flags } = parseFlagsFromArgs(args);
@@ -29022,43 +29673,79 @@ async function runRoundComplete(args) {
   const snapshot = await readEntityFile(filePath);
   const optimistic = { ...snapshot ?? {}, id, status: "completed" };
   await writeEntityFile(filePath, optimistic);
-  try {
-    const completed = await apiBackendPost(
-      `${new URL(backendRoundsEndpoint()).pathname}/${id}/complete`,
-      {}
-    );
-    await writeEntityFile(filePath, completed);
-    await updateRoundCursorHash(repoRoot, id, completed);
-    process.stdout.write(JSON.stringify(completed) + "\n");
-  } catch (err) {
-    if (err instanceof BackendError && err.status < 500) {
-      if (snapshot !== null) {
-        await writeEntityFile(filePath, snapshot);
-      } else {
-        await deleteEntityFile(filePath);
-      }
-      process.stderr.write(
-        `round complete: backend rejected (${err.status}): ${err.message}
-`
+  let freshRow = snapshot;
+  let lastErr;
+  let successRow = null;
+  for (let attempt = 0; attempt <= MAX_OCC_RETRIES3; attempt++) {
+    try {
+      const completed = await apiBackendPost(
+        `${new URL(backendRoundsEndpoint()).pathname}/${id}/complete`,
+        {}
       );
+      await writeEntityFile(filePath, completed);
+      await updateRoundCursorHash(repoRoot, id, completed);
+      successRow = completed;
+      break;
+    } catch (err2) {
+      if (isConflict(err2) && attempt < MAX_OCC_RETRIES3) {
+        try {
+          const freshResponse = await apiGet(`/rounds/${id}`);
+          freshRow = freshResponse.data;
+          await writeEntityFile(filePath, freshRow);
+        } catch {
+          lastErr = err2;
+          break;
+        }
+        lastErr = err2;
+        continue;
+      }
+      lastErr = err2;
+      break;
+    }
+  }
+  if (successRow !== null) {
+    process.stdout.write(JSON.stringify(successRow) + "\n");
+    process.exit(0);
+  }
+  const err = lastErr;
+  if (isConflict(err)) {
+    if (freshRow !== null) {
+      await writeEntityFile(filePath, freshRow);
+    } else if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
     } else {
-      await writeEntityFile(pendingMarkerPath(repoRoot, id), {
-        entity: "round",
-        id,
-        checkpoint_id: checkpointId,
-        task_id: taskId,
-        operation: "complete",
-        attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
-        error: err instanceof Error ? err.message : String(err)
-      });
-      process.stderr.write(
-        `round complete: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+      await deleteEntityFile(filePath);
+    }
+    process.stderr.write(
+      `round complete: conflict \u2014 another writer updated round ${id} concurrently. Re-read the round and retry.
 `
-      );
+    );
+  } else if (err instanceof BackendError && err.status < 500) {
+    if (snapshot !== null) {
+      await writeEntityFile(filePath, snapshot);
+    } else {
+      await deleteEntityFile(filePath);
     }
-    process.exit(1);
+    process.stderr.write(
+      `round complete: backend rejected (${err.status}): ${err.message}
+`
+    );
+  } else {
+    await writeEntityFile(pendingMarkerPath(repoRoot, id), {
+      entity: "round",
+      id,
+      checkpoint_id: checkpointId,
+      task_id: taskId,
+      operation: "complete",
+      attempted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: err instanceof Error ? err.message : String(err)
+    });
+    process.stderr.write(
+      `round complete: backend unavailable \u2014 local write kept, pending marker written. Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
   }
-  process.exit(0);
+  process.exit(1);
 }
 async function resolveCallerWorktreeId(repoRoot, currentBranch, repoId, overrideId) {
   if (overrideId) {
@@ -29157,7 +29844,7 @@ async function runRoundSyncApprovals(args) {
           "sync-approvals: git status failed; proceeding with empty diff\n"
         );
       }
-      const hookPath = join21(
+      const hookPath = join23(
         repoRoot,
         ".claude",
         "hooks",
@@ -29234,7 +29921,7 @@ async function runRoundSyncApprovals(args) {
   process.stdout.write(stdoutPayload + "\n");
   process.exit(0);
 }
-var RETRY_DELAY_MS, GIT_STATUS_CMD;
+var RETRY_DELAY_MS, MAX_OCC_RETRIES3, GIT_STATUS_CMD;
 var init_round = __esm({
   "src/cli/round.ts"() {
     "use strict";
@@ -29250,6 +29937,7 @@ var init_round = __esm({
     init_state_client();
     init_urls();
     RETRY_DELAY_MS = 1e3;
+    MAX_OCC_RETRIES3 = 3;
     GIT_STATUS_CMD = "git status --short --porcelain --untracked-files=all -z";
   }
 });
@@ -29259,6 +29947,7 @@ var standalone_task_exports = {};
 __export(standalone_task_exports, {
   runStandaloneTaskCommand: () => runStandaloneTaskCommand
 });
+import { join as join24 } from "node:path";
 async function resolveRepoRoot3() {
   const found = await findCodebyplanConfig(process.cwd());
   if (!found?.contents.repo_id) return null;
@@ -29520,9 +30209,62 @@ async function runStandaloneTaskComplete(args) {
   }
   process.exit(0);
 }
+async function runStandaloneTaskExport(args) {
+  const { flags } = parseFlagsFromArgs(args);
+  const id = flags.id ?? flags["standalone-task-id"];
+  if (!id) {
+    process.stderr.write(
+      "standalone-task export: --id <standalone-task-id> is required\n"
+    );
+    process.exit(1);
+  }
+  const repoInfo = await resolveRepoRoot3();
+  if (!repoInfo) {
+    process.stderr.write(
+      "standalone-task export: no .codebyplan/repo.json found. Run `codebyplan setup`.\n"
+    );
+    process.exit(1);
+  }
+  const { repoRoot, repoId } = repoInfo;
+  try {
+    const exportData = await buildStandaloneExport(id, repoRoot, repoId);
+    const outDir = join24(
+      repoRoot,
+      ".codebyplan",
+      "exports",
+      "standalone",
+      String(exportData.number)
+    );
+    const summaryMd = renderSummaryMd(exportData);
+    const { exportJsonPath, summaryMdPath } = writeExportArtifacts(
+      outDir,
+      exportData,
+      summaryMd
+    );
+    process.stderr.write(
+      "standalone-task export: note \u2014 standalone_tasks does not have a last_exported_at column; stamp skipped.\n"
+    );
+    process.stdout.write(
+      JSON.stringify({
+        exported: true,
+        path: outDir,
+        export_json: exportJsonPath,
+        summary_md: summaryMdPath,
+        last_exported_at: null
+      }) + "\n"
+    );
+  } catch (err) {
+    process.stderr.write(
+      `standalone-task export: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+  process.exit(0);
+}
 function printStandaloneTaskHelp() {
   process.stdout.write(
-    "\n  codebyplan standalone-task <subcommand>\n\n  Standalone tasks are independent work items (no checkpoint parent).\n  Writes go through the standalone MCP tools \u2014 no --checkpoint-id flag.\n\n  Subcommands:\n    create    Create a standalone task (--title required, pass extra fields as --key value)\n    update    Update a standalone task (--id required, then --key value pairs)\n    complete  Complete a standalone task (--id required; caller worktree must resolve)\n\n"
+    "\n  codebyplan standalone-task <subcommand>\n\n  Standalone tasks are independent work items (no checkpoint parent).\n  Writes go through the standalone MCP tools \u2014 no --checkpoint-id flag.\n\n  Subcommands:\n    create    Create a standalone task (--title required, pass extra fields as --key value)\n    update    Update a standalone task (--id required, then --key value pairs)\n    complete  Complete a standalone task (--id required; caller worktree must resolve)\n    export    Export task data to .codebyplan/exports/standalone/{N}/ (--id required)\n\n"
   );
 }
 async function runStandaloneTaskCommand(args) {
@@ -29539,6 +30281,10 @@ async function runStandaloneTaskCommand(args) {
     await runStandaloneTaskComplete(args.slice(1));
     return;
   }
+  if (subcommand === "export") {
+    await runStandaloneTaskExport(args.slice(1));
+    return;
+  }
   if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
     printStandaloneTaskHelp();
     process.exit(0);
@@ -29561,6 +30307,7 @@ var init_standalone_task = __esm({
     init_mcp_client();
     init_round();
     init_flags();
+    init_export_writer();
     init_git_utils();
     init_worktree_cache();
     init_resolve_worktree();
@@ -31101,7 +31848,7 @@ var init_session2 = __esm({
 
 // src/lib/migrate-branch-model.ts
 import { readFile as readFile18, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { join as join27 } from "node:path";
 import { execSync as execSync4 } from "node:child_process";
 function assertValidBranchName(branch) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -31180,12 +31927,12 @@ async function runBranchMigration(opts) {
   if (found) {
     if (found.path.endsWith("/repo.json")) {
       const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-      configPath = join24(dir, "git.json");
+      configPath = join27(dir, "git.json");
     } else {
       configPath = found.path;
     }
   } else {
-    configPath = join24(cwd, ".codebyplan", "git.json");
+    configPath = join27(cwd, ".codebyplan", "git.json");
   }
   let fileRaw;
   let fileParsed;
@@ -31532,7 +32279,7 @@ var init_branch = __esm({
 
 // src/lib/bump.ts
 import { readFile as readFile19, writeFile as writeFile16, access as access5, readdir as readdir4 } from "node:fs/promises";
-import { join as join25, relative as relative5, resolve as resolve3 } from "node:path";
+import { join as join28, relative as relative5, resolve as resolve3 } from "node:path";
 import { spawnSync as spawnSync10 } from "node:child_process";
 function parsePnpmWorkspaceGlobs(raw) {
   const lines = raw.split("\n");
@@ -31562,18 +32309,18 @@ async function expandGlob(cwd, glob) {
   if (parts.length !== 2 || parts[1] !== "*") {
     return [];
   }
-  const parentDir = join25(cwd, parts[0]);
+  const parentDir = join28(cwd, parts[0]);
   let dirs;
   try {
     const entries = await readdir4(parentDir, { withFileTypes: true });
-    dirs = entries.filter((e) => e.isDirectory()).map((e) => join25(parentDir, e.name));
+    dirs = entries.filter((e) => e.isDirectory()).map((e) => join28(parentDir, e.name));
   } catch {
     return [];
   }
   const results = [];
   for (const dir of dirs) {
     try {
-      await access5(join25(dir, "package.json"));
+      await access5(join28(dir, "package.json"));
       results.push(dir);
     } catch {
     }
@@ -31584,7 +32331,7 @@ async function buildPackageMap(cwd) {
   const map = /* @__PURE__ */ new Map();
   let globs = [];
   try {
-    const raw = await readFile19(join25(cwd, "pnpm-workspace.yaml"), "utf-8");
+    const raw = await readFile19(join28(cwd, "pnpm-workspace.yaml"), "utf-8");
     globs = parsePnpmWorkspaceGlobs(raw);
   } catch {
   }
@@ -31592,7 +32339,7 @@ async function buildPackageMap(cwd) {
     const dirs = await expandGlob(cwd, glob);
     for (const dir of dirs) {
       try {
-        const pkgRaw = await readFile19(join25(dir, "package.json"), "utf-8");
+        const pkgRaw = await readFile19(join28(dir, "package.json"), "utf-8");
         const pkg = JSON.parse(pkgRaw);
         const name = pkg.name ?? relative5(cwd, dir);
         map.set(dir, { name, dir });
@@ -31751,7 +32498,7 @@ async function runBump(opts) {
   const changedFiles = (diffResult.stdout ?? "").trim().split("\n").filter(Boolean).map((f) => resolve3(cwd, f));
   const packageMap = await buildPackageMap(cwd);
   const packageDirs = Array.from(packageMap.keys());
-  const rootPkgPath = join25(cwd, "package.json");
+  const rootPkgPath = join28(cwd, "package.json");
   const changedPackageDirs = /* @__PURE__ */ new Set();
   for (const absFile of changedFiles) {
     const owner = findOwningPackage(absFile, packageDirs);
@@ -31762,19 +32509,19 @@ async function runBump(opts) {
   const entries = [];
   for (const pkgDir of changedPackageDirs) {
     const pkgInfo = packageMap.get(pkgDir);
-    const pkgJsonPath = join25(pkgDir, "package.json");
+    const pkgJsonPath = join28(pkgDir, "package.json");
     if (pkgJsonPath === rootPkgPath) continue;
     const versionFileCandidates = [
       { abs: pkgJsonPath, rel: relative5(cwd, pkgJsonPath).replace(/\\/g, "/") }
     ];
-    const tauriConfPath = join25(pkgDir, "src-tauri", "tauri.conf.json");
+    const tauriConfPath = join28(pkgDir, "src-tauri", "tauri.conf.json");
     const tauriRelPath = relative5(cwd, tauriConfPath).replace(/\\/g, "/");
     try {
       await access5(tauriConfPath);
       versionFileCandidates.push({ abs: tauriConfPath, rel: tauriRelPath });
     } catch {
     }
-    const appJsonPath = join25(pkgDir, "app.json");
+    const appJsonPath = join28(pkgDir, "app.json");
     const appJsonRelPath = relative5(cwd, appJsonPath).replace(/\\/g, "/");
     try {
       await access5(appJsonPath);
@@ -31846,7 +32593,7 @@ async function runBump(opts) {
       }
       updatedVersionFiles.push(rel);
     }
-    const changelogPath = join25(pkgDir, "CHANGELOG.md");
+    const changelogPath = join28(pkgDir, "CHANGELOG.md");
     const changelogUpdated = await prependChangelog(
       changelogPath,
       pkgInfo.name,
@@ -34314,7 +35061,7 @@ __export(version_status_exports, {
 });
 import { execFileSync, execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname13, join as join32 } from "node:path";
+import { dirname as dirname13, join as join35 } from "node:path";
 function fetchLatestVersion() {
   try {
     return execFileSync("npm", ["view", "codebyplan", "version"], {
@@ -34338,9 +35085,9 @@ function detectPackageManager2(gitRoot) {
   let dir = process.cwd();
   const stopAt = gitRoot ?? null;
   while (true) {
-    if (existsSync10(join32(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync10(join32(dir, "yarn.lock"))) return "yarn";
-    if (existsSync10(join32(dir, "package-lock.json"))) return "npm";
+    if (existsSync10(join35(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync10(join35(dir, "yarn.lock"))) return "yarn";
+    if (existsSync10(join35(dir, "package-lock.json"))) return "npm";
     if (stopAt !== null && dir === stopAt) break;
     const parent = dirname13(dir);
     if (parent === dir) break;
@@ -34360,7 +35107,7 @@ function buildInstallCommand2(pm) {
 }
 async function resolveGuard(gitRoot, currentBranch) {
   if (gitRoot !== null) {
-    const canonicalPkgPath = join32(
+    const canonicalPkgPath = join35(
       gitRoot,
       "packages",
       "codebyplan-package",
@@ -34384,10 +35131,10 @@ async function resolveGuard(gitRoot, currentBranch) {
       let gitJsonPath;
       if (found.path.endsWith("/repo.json")) {
         const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join32(dir, "git.json");
+        gitJsonPath = join35(dir, "git.json");
       } else {
         const legacyDir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join32(legacyDir, ".codebyplan", "git.json");
+        gitJsonPath = join35(legacyDir, ".codebyplan", "git.json");
       }
       const raw = readFileSync11(gitJsonPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -34472,7 +35219,7 @@ __export(upload_e2e_images_exports, {
   runUploadE2eImagesCommand: () => runUploadE2eImagesCommand
 });
 import { readFile as readFile20 } from "node:fs/promises";
-import { join as join33, basename as basename2, resolve as resolve10 } from "node:path";
+import { join as join36, basename as basename2, resolve as resolve10 } from "node:path";
 import { execSync as execSync8 } from "node:child_process";
 function baseUrl2() {
   return (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
@@ -34507,7 +35254,7 @@ function parseArgs(args) {
 async function readE2eConfig(projectPath) {
   try {
     const raw = await readFile20(
-      join33(projectPath, ".codebyplan", "e2e.json"),
+      join36(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34548,7 +35295,7 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
       continue;
     const isNew = status === "A";
     results.push({
-      absolutePath: join33(projectPath, filePath),
+      absolutePath: join36(projectPath, filePath),
       filename: basename2(filePath),
       framework: frameworkName,
       is_new: isNew
@@ -34724,7 +35471,7 @@ __export(arch_map_exports, {
 });
 import { readFile as readFile21, writeFile as writeFile17 } from "node:fs/promises";
 import { existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join37 } from "node:path";
 import { spawnSync as spawnSync12 } from "node:child_process";
 function normalizeModulePath(modulePath) {
   return modulePath.replace(/\/+$/, "");
@@ -34749,7 +35496,7 @@ async function resolveCodebyplanDir(startDir) {
   }
 }
 async function readArchitectureConfig(codebyplanDir) {
-  const filePath = join34(codebyplanDir, "architecture.json");
+  const filePath = join37(codebyplanDir, "architecture.json");
   try {
     const raw = await readFile21(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -34762,7 +35509,7 @@ async function readArchitectureConfig(codebyplanDir) {
   }
 }
 async function writeArchitectureConfig(codebyplanDir, config) {
-  const filePath = join34(codebyplanDir, "architecture.json");
+  const filePath = join37(codebyplanDir, "architecture.json");
   await writeFile17(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function resolveGitSha(modulePath, cwd) {
@@ -34781,7 +35528,7 @@ function resolveGitSha(modulePath, cwd) {
 }
 async function discoverModulePaths(projectRoot) {
   const paths = [];
-  const workspacePath = join34(projectRoot, "pnpm-workspace.yaml");
+  const workspacePath = join37(projectRoot, "pnpm-workspace.yaml");
   let patterns = [];
   try {
     const raw = await readFile21(workspacePath, "utf-8");
@@ -34808,7 +35555,7 @@ async function discoverModulePaths(projectRoot) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join34(projectRoot, dir);
+      const absDir = join37(projectRoot, dir);
       try {
         if (existsSync11(absDir)) {
           const entries = readdirSync4(absDir, { withFileTypes: true });
@@ -34821,7 +35568,7 @@ async function discoverModulePaths(projectRoot) {
       } catch {
       }
     } else if (!pattern.includes("*")) {
-      const absPath = join34(projectRoot, pattern);
+      const absPath = join37(projectRoot, pattern);
       if (existsSync11(absPath)) {
         paths.push(pattern);
       }
@@ -34829,7 +35576,7 @@ async function discoverModulePaths(projectRoot) {
   }
   const crossCutting = ["supabase", ".github", "scripts"];
   for (const dir of crossCutting) {
-    const absPath = join34(projectRoot, dir);
+    const absPath = join37(projectRoot, dir);
     try {
       if (existsSync11(absPath)) {
         paths.push(dir);
@@ -35015,7 +35762,7 @@ async function runStamp(modulePath, sha, depthArg, projectRoot) {
   }
   await writeArchitectureConfig(codebyplanDir, config);
   const stampedEntry = existingIndex >= 0 ? config.modules[existingIndex] : config.modules[config.modules.length - 1];
-  const mapAbsPath = join34(repoRoot, stampedEntry.map_file);
+  const mapAbsPath = join37(repoRoot, stampedEntry.map_file);
   let mapContent = null;
   try {
     mapContent = await readFile21(mapAbsPath, "utf-8");
@@ -35221,18 +35968,18 @@ var init_worktree_port_resolver = __esm({
 
 // src/lib/migrate-local-config.ts
 import { mkdir as mkdir9, readFile as readFile22, unlink as unlink5, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join35 } from "node:path";
+import { join as join38 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join35(projectPath, ".codebyplan.json");
+  return join38(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join35(projectPath, ".codebyplan.local.json");
+  return join38(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join35(projectPath, ".codebyplan");
+  return join38(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join35(projectPath, ".codebyplan", "repo.json");
+  return join38(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
   const { stat: stat3 } = await import("node:fs/promises");
@@ -35326,7 +36073,7 @@ async function runLocalMigration(projectPath) {
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
   await writeFile18(
-    join35(projectPath, ".codebyplan", "repo.json"),
+    join38(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -35339,7 +36086,7 @@ async function runLocalMigration(projectPath) {
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
   await writeFile18(
-    join35(projectPath, ".codebyplan", "server.json"),
+    join38(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -35348,7 +36095,7 @@ async function runLocalMigration(projectPath) {
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
   await writeFile18(
-    join35(projectPath, ".codebyplan", "git.json"),
+    join38(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
@@ -35356,35 +36103,35 @@ async function runLocalMigration(projectPath) {
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
   await writeFile18(
-    join35(projectPath, ".codebyplan", "shipment.json"),
+    join38(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
   await writeFile18(
-    join35(projectPath, ".codebyplan", "vendor.json"),
+    join38(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
   await writeFile18(
-    join35(projectPath, ".codebyplan", "e2e.json"),
+    join38(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
   await writeFile18(
-    join35(projectPath, ".codebyplan", "eslint.json"),
+    join38(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/eslint.json");
   if (!deviceWrittenByHelper) {
     await writeFile18(
-      join35(projectPath, ".codebyplan", "device.local.json"),
+      join38(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -35396,7 +36143,7 @@ async function runLocalMigration(projectPath) {
       "Migration write incomplete: .codebyplan/repo.json was not persisted. Re-run migration to retry from a clean state."
     );
   }
-  const gitignorePath = join35(projectPath, ".gitignore");
+  const gitignorePath = join38(projectPath, ".gitignore");
   try {
     const gitignoreContent = await readFile22(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
@@ -35460,7 +36207,7 @@ __export(config_exports, {
   runConfigMigrate: () => runConfigMigrate
 });
 import { mkdir as mkdir10, readFile as readFile23, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { join as join39 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -35493,7 +36240,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join36(projectPath, ".codebyplan");
+  const codebyplanDir = join39(projectPath, ".codebyplan");
   const {
     resolvedWorktreeId,
     portAllocations,
@@ -35586,7 +36333,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   ];
   let anyUpdated = false;
   for (const { name, payload, createOnly } of files) {
-    const filePath = join36(codebyplanDir, name);
+    const filePath = join39(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
@@ -35606,7 +36353,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 async function readRepoConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "repo.json"),
+      join39(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35617,7 +36364,7 @@ async function readRepoConfig(projectPath) {
 async function readServerConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "server.json"),
+      join39(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35628,7 +36375,7 @@ async function readServerConfig(projectPath) {
 async function readGitConfig2(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "git.json"),
+      join39(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35639,7 +36386,7 @@ async function readGitConfig2(projectPath) {
 async function readShipmentConfig2(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "shipment.json"),
+      join39(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35650,7 +36397,7 @@ async function readShipmentConfig2(projectPath) {
 async function readVendorConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "vendor.json"),
+      join39(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35661,7 +36408,7 @@ async function readVendorConfig(projectPath) {
 async function readE2eConfig2(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "e2e.json"),
+      join39(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35672,7 +36419,7 @@ async function readE2eConfig2(projectPath) {
 async function readServerLocalConfig(projectPath) {
   try {
     const raw = await readFile23(
-      join36(projectPath, ".codebyplan", "server.local.json"),
+      join39(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35745,7 +36492,7 @@ var init_config = __esm({
 
 // src/lib/server-detect.ts
 import { readFile as readFile24, readdir as readdir5, access as access6 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { join as join40 } from "node:path";
 async function fileExists4(filePath) {
   try {
     await access6(filePath);
@@ -35756,8 +36503,8 @@ async function fileExists4(filePath) {
 }
 function detectPackageManager3(dir) {
   return (async () => {
-    if (await fileExists4(join37(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists4(join37(dir, "yarn.lock"))) return "yarn";
+    if (await fileExists4(join40(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists4(join40(dir, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
@@ -35789,12 +36536,12 @@ function detectPortFromScripts(pkg) {
   return null;
 }
 async function isMonorepo(dir) {
-  return await fileExists4(join37(dir, "turbo.json")) || await fileExists4(join37(dir, "pnpm-workspace.yaml"));
+  return await fileExists4(join40(dir, "turbo.json")) || await fileExists4(join40(dir, "pnpm-workspace.yaml"));
 }
 async function detectServers(projectPath) {
   let pkg;
   try {
-    const raw = await readFile24(join37(projectPath, "package.json"), "utf-8");
+    const raw = await readFile24(join40(projectPath, "package.json"), "utf-8");
     pkg = JSON.parse(raw);
   } catch {
     return {
@@ -35810,13 +36557,13 @@ async function detectServers(projectPath) {
   const mono = await isMonorepo(projectPath);
   const servers = [];
   if (mono) {
-    const appsDir = join37(projectPath, "apps");
+    const appsDir = join40(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 = join37(appsDir, entry.name, "package.json");
+        const appPkgPath = join40(appsDir, entry.name, "package.json");
         try {
           const appRaw = await readFile24(appPkgPath, "utf-8");
           const appPkg = JSON.parse(appRaw);
@@ -35982,7 +36729,7 @@ __export(ports_exports, {
   runPorts: () => runPorts
 });
 import { mkdir as mkdir11, readFile as readFile26, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join38 } from "node:path";
+import { join as join41 } from "node:path";
 function printDetectionResult(result, projectPath) {
   console.log(`
   CodeByPlan Ports - List`);
@@ -36138,8 +36885,8 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // and ServerLocalConfig.port_allocations is typed the same — honest end-to-end.
     port_allocations: portAllocations
   };
-  const codebyplanDir = join38(projectPath, ".codebyplan");
-  const filePath = join38(codebyplanDir, "server.local.json");
+  const codebyplanDir = join41(projectPath, ".codebyplan");
+  const filePath = join41(codebyplanDir, "server.local.json");
   const newJson = JSON.stringify(payload, null, 2) + "\n";
   let currentJson = "";
   try {
@@ -36161,8 +36908,8 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
   );
 }
 async function provisionE2eEnv(projectPath, dryRun) {
-  const relSource = join38("apps", "web", ".env.local");
-  const sourcePath = join38(projectPath, relSource);
+  const relSource = join41("apps", "web", ".env.local");
+  const sourcePath = join41(projectPath, relSource);
   let sourceRaw;
   try {
     sourceRaw = await readFile26(sourcePath, "utf-8");
@@ -36194,8 +36941,8 @@ async function provisionE2eEnv(projectPath, dryRun) {
     );
     return;
   }
-  const codebyplanDir = join38(projectPath, ".codebyplan");
-  const filePath = join38(codebyplanDir, "e2e.env");
+  const codebyplanDir = join41(projectPath, ".codebyplan");
+  const filePath = join41(codebyplanDir, "e2e.env");
   const newContent = lines.join("\n") + "\n";
   let currentContent = "";
   try {
@@ -36480,7 +37227,7 @@ __export(docs_exports, {
 });
 import { existsSync as existsSync13 } from "node:fs";
 import { mkdir as mkdir12, readFile as readFile27, readdir as readdir6, rm as rm2, writeFile as writeFile21 } from "node:fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute2, join as join39, relative as relative7, sep as sep2 } from "node:path";
+import { dirname as dirname14, isAbsolute as isAbsolute2, join as join42, relative as relative7, sep as sep2 } from "node:path";
 function selectDependencies(deps) {
   const byName = /* @__PURE__ */ new Map();
   for (const dep of deps) {
@@ -36534,12 +37281,12 @@ async function mapWithConcurrency(items, limit, fn) {
 }
 async function resolveExactVersion(projectPath, dep) {
   const candidateDirs = [projectPath];
-  const sourceDir = join39(projectPath, dirname14(dep.sourcePath));
+  const sourceDir = join42(projectPath, dirname14(dep.sourcePath));
   if (sourceDir !== projectPath) candidateDirs.push(sourceDir);
   for (const base of candidateDirs) {
     try {
       const raw = await readFile27(
-        join39(base, "node_modules", dep.name, "package.json"),
+        join42(base, "node_modules", dep.name, "package.json"),
         "utf-8"
       );
       const pkg = JSON.parse(raw);
@@ -36554,7 +37301,7 @@ async function resolveExactVersion(projectPath, dep) {
 async function readVendorDocsPath(projectPath) {
   try {
     const raw = await readFile27(
-      join39(projectPath, ".codebyplan", "vendor.json"),
+      join42(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     const parsed = JSON.parse(raw);
@@ -36567,7 +37314,7 @@ async function readVendorDocsPath(projectPath) {
 }
 async function resolveDocsDir(projectPath, flags) {
   const configured = flags["dir"] ?? await readVendorDocsPath(projectPath) ?? DEFAULT_DOCS_DIR;
-  const absDir = isAbsolute2(configured) ? configured : join39(projectPath, configured);
+  const absDir = isAbsolute2(configured) ? configured : join42(projectPath, configured);
   const rel = relative7(projectPath, absDir);
   const relDir = rel === "" || rel.startsWith("..") ? null : rel.split(sep2).join("/");
   return { absDir, relDir };
@@ -36576,7 +37323,7 @@ async function readDocsLock(absDir) {
   const empty = { generated_at: "", libraries: {} };
   let raw;
   try {
-    raw = await readFile27(join39(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile27(join42(absDir, LOCK_FILE), "utf-8");
   } catch {
     return empty;
   }
@@ -36672,7 +37419,7 @@ function buildTopIndex(outcomes) {
 }
 async function ensureDocsGitignoreEntry(projectPath, relDir, dryRun) {
   const entry = `/${relDir}/`;
-  const gitignorePath = join39(projectPath, ".gitignore");
+  const gitignorePath = join42(projectPath, ".gitignore");
   let existing = "";
   try {
     existing = await readFile27(gitignorePath, "utf-8");
@@ -36695,7 +37442,7 @@ async function markUncovered(dep, exactVersion, ctx) {
   console.log(
     `  uncovered ${dep.name}@${exactVersion || "?"} \u2014 no docs in the library mirror`
   );
-  const libPath = join39(ctx.absDir, libDirName(dep.name));
+  const libPath = join42(ctx.absDir, libDirName(dep.name));
   if (existsSync13(libPath)) {
     if (ctx.dryRun) {
       console.log(`  would remove stale mirror dir ${libPath}`);
@@ -36748,14 +37495,14 @@ async function syncOneLibrary(dep, ctx) {
     }
   }
   const lockEntry = ctx.lock.libraries[dep.name];
-  const libPath = join39(ctx.absDir, libDirName(dep.name));
-  const versionPath = join39(libPath, manifest.resolved_version);
+  const libPath = join42(ctx.absDir, libDirName(dep.name));
+  const versionPath = join42(libPath, manifest.resolved_version);
   if (manifestMatchesLock(manifest, lockEntry)) {
     console.log(`  unchanged ${dep.name}@${manifest.resolved_version}`);
-    if (!ctx.dryRun && !existsSync13(join39(libPath, "INDEX.md"))) {
+    if (!ctx.dryRun && !existsSync13(join42(libPath, "INDEX.md"))) {
       await mkdir12(libPath, { recursive: true });
       await writeFile21(
-        join39(libPath, "INDEX.md"),
+        join42(libPath, "INDEX.md"),
         buildLibIndex(dep.name, manifest),
         "utf-8"
       );
@@ -36777,7 +37524,7 @@ async function syncOneLibrary(dep, ctx) {
       );
       continue;
     }
-    const target = join39(versionPath, rel);
+    const target = join42(versionPath, rel);
     if (sameVersionLockFiles[file.path] === file.content_hash && existsSync13(target)) {
       continue;
     }
@@ -36795,7 +37542,7 @@ async function syncOneLibrary(dep, ctx) {
       const rel = sanitizeDocPath(lockedPath);
       if (rel === null) continue;
       removedFiles++;
-      if (!ctx.dryRun) await rm2(join39(versionPath, rel), { force: true });
+      if (!ctx.dryRun) await rm2(join42(versionPath, rel), { force: true });
     }
   }
   let removedVersionDirs = 0;
@@ -36810,13 +37557,13 @@ async function syncOneLibrary(dep, ctx) {
     }
     removedVersionDirs++;
     if (!ctx.dryRun) {
-      await rm2(join39(libPath, entry.name), { recursive: true, force: true });
+      await rm2(join42(libPath, entry.name), { recursive: true, force: true });
     }
   }
   if (!ctx.dryRun) {
     await mkdir12(libPath, { recursive: true });
     await writeFile21(
-      join39(libPath, "INDEX.md"),
+      join42(libPath, "INDEX.md"),
       buildLibIndex(dep.name, manifest),
       "utf-8"
     );
@@ -36870,7 +37617,7 @@ async function runDocsSync() {
   );
   if (!dryRun) {
     await mkdir12(absDir, { recursive: true });
-    await writeFile21(join39(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
+    await writeFile21(join42(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
     const libraries = {};
     for (const o of outcomes) {
       if (o.kind === "synced" || o.kind === "unchanged") {
@@ -36896,7 +37643,7 @@ async function runDocsSync() {
       libraries: sortedLibraries
     };
     await writeFile21(
-      join39(absDir, LOCK_FILE),
+      join42(absDir, LOCK_FILE),
       JSON.stringify(newLock, null, 2) + "\n",
       "utf-8"
     );
@@ -36938,7 +37685,7 @@ async function countFilesRecursively(dirPath) {
   let count = 0;
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      count += await countFilesRecursively(join39(dirPath, entry.name));
+      count += await countFilesRecursively(join42(dirPath, entry.name));
     } else if (entry.isFile()) {
       count++;
     }
@@ -36955,7 +37702,7 @@ async function runDocsStatus() {
 `);
   let raw;
   try {
-    raw = await readFile27(join39(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile27(join42(absDir, LOCK_FILE), "utf-8");
   } catch {
     console.log(
       `  No ${LOCK_FILE} found \u2014 run \`codebyplan docs sync\` first.
@@ -36984,7 +37731,7 @@ async function runDocsStatus() {
   let outOfSync = 0;
   for (const name of names) {
     const entry = lock.libraries[name];
-    const versionPath = join39(absDir, libDirName(name), entry.resolved_version);
+    const versionPath = join42(absDir, libDirName(name), entry.resolved_version);
     const expected = Object.keys(entry.files).length;
     if (!existsSync13(versionPath)) {
       outOfSync++;
@@ -37071,8 +37818,8 @@ var init_docs = __esm({
 });
 
 // src/lib/check-baseline.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join40 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join43 } from "node:path";
 function emptyBaseline() {
   return {
     lint: { known_failing: [] },
@@ -37082,7 +37829,7 @@ function emptyBaseline() {
   };
 }
 function loadBaseline(projectRoot) {
-  const filePath = join40(projectRoot, BASELINE_FILENAME);
+  const filePath = join43(projectRoot, BASELINE_FILENAME);
   try {
     const raw = readFileSync12(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -37106,8 +37853,8 @@ function loadBaseline(projectRoot) {
   }
 }
 function saveBaseline(projectRoot, baseline) {
-  const filePath = join40(projectRoot, BASELINE_FILENAME);
-  writeFileSync7(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
+  const filePath = join43(projectRoot, BASELINE_FILENAME);
+  writeFileSync8(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
 }
 function diffBaseline(check, currentFailingPackages, baseline) {
   const knownFailing = new Set(baseline[check].known_failing);
@@ -37156,7 +37903,7 @@ var init_check_baseline = __esm({
 
 // src/lib/check.ts
 import { readFileSync as readFileSync13, existsSync as existsSync14 } from "node:fs";
-import { join as join41 } from "node:path";
+import { join as join44 } from "node:path";
 import { spawnSync as spawnSync13 } from "node:child_process";
 function hasSentinelValue(arrays) {
   const SENTINELS = /* @__PURE__ */ new Set([
@@ -37224,9 +37971,9 @@ function parseFailingPackagesFromSummary(summaryPath) {
   return Array.from(failing).sort();
 }
 function resolveTurboBin(projectRoot) {
-  const localBin = join41(projectRoot, "node_modules", ".bin", "turbo");
+  const localBin = join44(projectRoot, "node_modules", ".bin", "turbo");
   if (existsSync14(localBin)) return localBin;
-  const workspaceRootBin = join41(
+  const workspaceRootBin = join44(
     projectRoot,
     "..",
     "..",
@@ -39365,7 +40112,7 @@ __export(generate_exports, {
   runGenerate: () => runGenerate
 });
 import { readFile as readFile28, mkdir as mkdir13, writeFile as writeFile22 } from "node:fs/promises";
-import { join as join48, resolve as resolve11 } from "node:path";
+import { join as join51, resolve as resolve11 } from "node:path";
 async function readJsonFile4(filePath) {
   try {
     const raw = await readFile28(filePath, "utf-8");
@@ -39376,7 +40123,7 @@ async function readJsonFile4(filePath) {
 }
 async function readPkgName(absPath) {
   try {
-    const raw = await readFile28(join48(absPath, "package.json"), "utf-8");
+    const raw = await readFile28(join51(absPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
@@ -39390,7 +40137,7 @@ async function runGenerate(opts) {
   const rootDir = resolve11(projectDir);
   let packageManager;
   try {
-    const raw = await readFile28(join48(rootDir, "package.json"), "utf-8");
+    const raw = await readFile28(join51(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.packageManager === "string") {
       packageManager = pkg.packageManager;
@@ -39398,7 +40145,7 @@ async function runGenerate(opts) {
   } catch {
   }
   const serverJson = await readJsonFile4(
-    join48(rootDir, ".codebyplan", "server.json")
+    join51(rootDir, ".codebyplan", "server.json")
   );
   const ports = [];
   for (const alloc of serverJson?.port_allocations ?? []) {
@@ -39411,7 +40158,7 @@ async function runGenerate(opts) {
     }
   }
   const gitJson = await readJsonFile4(
-    join48(rootDir, ".codebyplan", "git.json")
+    join51(rootDir, ".codebyplan", "git.json")
   );
   const branchModel = gitJson?.branch_config?.production ? {
     production: gitJson.branch_config.production,
@@ -39420,7 +40167,7 @@ async function runGenerate(opts) {
     )
   } : void 0;
   const shipmentJson = await readJsonFile4(
-    join48(rootDir, ".codebyplan", "shipment.json")
+    join51(rootDir, ".codebyplan", "shipment.json")
   );
   const shipmentSurfaces = [];
   const rawSurfaces = shipmentJson?.shipment?.surfaces ?? shipmentJson?.surfaces ?? {};
@@ -39491,7 +40238,7 @@ async function runGenerate(opts) {
   const structureMdContent = generateStructureMd(config);
   const agentsContent = generateAgentsMd(structureMdContent);
   if (check) {
-    const agentsMdPath2 = join48(rootDir, "AGENTS.md");
+    const agentsMdPath2 = join51(rootDir, "AGENTS.md");
     let existingAgents = null;
     try {
       existingAgents = await readFile28(agentsMdPath2, "utf-8");
@@ -39530,13 +40277,13 @@ async function runGenerate(opts) {
     process.stdout.write(agentsContent);
     return;
   }
-  const outputDir = join48(rootDir, ".claude", "generated");
+  const outputDir = join51(rootDir, ".claude", "generated");
   await mkdir13(outputDir, { recursive: true });
-  const outputPath = join48(outputDir, "structure.md");
+  const outputPath = join51(outputDir, "structure.md");
   await writeFile22(outputPath, structureMdContent, "utf-8");
   process.stdout.write(`Wrote: .claude/generated/structure.md
 `);
-  const agentsMdPath = join48(rootDir, "AGENTS.md");
+  const agentsMdPath = join51(rootDir, "AGENTS.md");
   let existingAgentsContent = null;
   try {
     existingAgentsContent = await readFile28(agentsMdPath, "utf-8");
@@ -39568,7 +40315,7 @@ __export(readme_exports, {
   runReadmeCommand: () => runReadmeCommand
 });
 import { readFile as readFile29, writeFile as writeFile23 } from "node:fs/promises";
-import { join as join49, resolve as resolve12, relative as relative9 } from "node:path";
+import { join as join52, resolve as resolve12, relative as relative9 } from "node:path";
 async function readJsonFile5(filePath) {
   try {
     const raw = await readFile29(filePath, "utf-8");
@@ -39640,7 +40387,7 @@ async function discoverUnits(rootDir, rootPkgJson) {
   const discovered = await discoverMonorepoApps(rootDir);
   for (const app of discovered) {
     const pkgJson = await readJsonFile5(
-      join49(app.absPath, "package.json")
+      join52(app.absPath, "package.json")
     );
     pkgJsonByPath.set(app.absPath, pkgJson);
     allPackages.push({
@@ -39666,7 +40413,7 @@ async function runReadme(opts) {
   const init = opts.init ?? opts["init"] ?? false;
   const rootDir = resolve12(projectDir);
   const rootPkgJson = await readJsonFile5(
-    join49(rootDir, "package.json")
+    join52(rootDir, "package.json")
   );
   const { units, allPackages, pkgJsonByPath } = await discoverUnits(
     rootDir,
@@ -39675,8 +40422,8 @@ async function runReadme(opts) {
   const driftUnits = [];
   const missingUnits = [];
   for (const unit of units) {
-    const readmePath = join49(unit.absPath, "README.md");
-    const relPath = unit.isRoot ? "README.md" : join49(relative9(rootDir, unit.absPath), "README.md");
+    const readmePath = join52(unit.absPath, "README.md");
+    const relPath = unit.isRoot ? "README.md" : join52(relative9(rootDir, unit.absPath), "README.md");
     let existingContent = null;
     try {
       existingContent = await readFile29(readmePath, "utf-8");
@@ -39867,7 +40614,7 @@ import {
   readdir as readdir7
 } from "node:fs/promises";
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join50, resolve as resolve13, dirname as dirname16, sep as sep4 } from "node:path";
+import { join as join53, resolve as resolve13, dirname as dirname16, sep as sep4 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function encodeProjectPath(absPath) {
   return resolve13(absPath).replace(/[/\\]/g, "-");
@@ -39878,7 +40625,7 @@ function resolveAutoMemoryDir(opts) {
   }
   const projectDir = opts.projectDir ?? process.cwd();
   const encoded = encodeProjectPath(projectDir);
-  return join50(homedir8(), ".claude", "projects", encoded, "memory");
+  return join53(homedir8(), ".claude", "projects", encoded, "memory");
 }
 function parseFrontmatter(content) {
   content = content.replace(/\r\n/g, "\n");
@@ -39944,7 +40691,7 @@ async function inventoryFiles(dir) {
   }
   const results = [];
   for (const filename of filenames) {
-    const sourcePath = join50(dir, filename);
+    const sourcePath = join53(dir, filename);
     let raw;
     try {
       raw = await readFile30(sourcePath, "utf-8");
@@ -40033,8 +40780,8 @@ async function applyPlan(plan, opts) {
     if (entry.suggested_action !== "keep") continue;
     if (!entry.suggested_target?.startsWith("nested:")) continue;
     const relPath = entry.suggested_target.slice("nested:".length);
-    const targetDir = resolve13(join50(projectDir, relPath));
-    const targetFile = join50(targetDir, "CLAUDE.md");
+    const targetDir = resolve13(join53(projectDir, relPath));
+    const targetFile = join53(targetDir, "CLAUDE.md");
     if (!targetDir.startsWith(resolve13(projectDir) + sep4)) {
       process.stderr.write(
         `migrate-memory: skipping unsafe suggested_target "${entry.suggested_target}" \u2014 resolves outside projectDir
@@ -40084,7 +40831,7 @@ ${anchor}
       );
     }
   }
-  const rootClaudeMd = join50(projectDir, ".claude", "CLAUDE.md");
+  const rootClaudeMd = join53(projectDir, ".claude", "CLAUDE.md");
   if (dryRun) {
     process.stdout.write(
       `[dry-run] Would ensure ${rootClaudeMd} contains: ${IMPORT_LINE}
@@ -40128,8 +40875,8 @@ ${IMPORT_LINE}
     } catch {
     }
   }
-  const memoryMd = join50(plan.auto_memory_dir, "MEMORY.md");
-  const safeRmdirBase = join50(homedir8(), ".claude", "projects");
+  const memoryMd = join53(plan.auto_memory_dir, "MEMORY.md");
+  const safeRmdirBase = join53(homedir8(), ".claude", "projects");
   if (dryRun) {
     process.stdout.write(`[dry-run] Would delete MEMORY.md: ${memoryMd}
 `);
@@ -40253,7 +41000,7 @@ var init_migrate_memory = __esm({
 
 // src/lib/claude-mode-audit.ts
 import { readdirSync as readdirSync7, readFileSync as readFileSync19, existsSync as existsSync22 } from "node:fs";
-import { join as join51, basename as basename3 } from "node:path";
+import { join as join54, basename as basename3 } from "node:path";
 function parseFrontmatter2(content) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
   if (!match) return {};
@@ -40330,19 +41077,19 @@ function auditSkill(filePath) {
 }
 function auditMode(templatesDir) {
   const entries = [];
-  const agentsDir = join51(templatesDir, "agents");
+  const agentsDir = join54(templatesDir, "agents");
   if (existsSync22(agentsDir)) {
     const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md")).sort();
     for (const f of agentFiles) {
-      entries.push(auditAgent(join51(agentsDir, f)));
+      entries.push(auditAgent(join54(agentsDir, f)));
     }
   }
-  const skillsDir = join51(templatesDir, "skills");
+  const skillsDir = join54(templatesDir, "skills");
   if (existsSync22(skillsDir)) {
     const skillDirs = readdirSync7(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
     for (const dir of skillDirs) {
-      if (existsSync22(join51(skillsDir, dir, "PROVENANCE.md"))) continue;
-      const skillMd = join51(skillsDir, dir, "SKILL.md");
+      if (existsSync22(join54(skillsDir, dir, "PROVENANCE.md"))) continue;
+      const skillMd = join54(skillsDir, dir, "SKILL.md");
       if (existsSync22(skillMd)) {
         entries.push(auditSkill(skillMd));
       }
@@ -40608,8 +41355,8 @@ function slugify(name) {
 function newMigration(args, deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const genTimestamp = deps.generateTimestamp ?? generateMonotonicTimestamp;
-  const mkdirSync11 = deps.mkdirSyncFn ?? ((dir, opts) => fs19.mkdirSync(dir, opts));
-  const writeFileSync12 = deps.writeFileSyncFn ?? ((filePath2, content) => fs19.writeFileSync(filePath2, content));
+  const mkdirSync12 = deps.mkdirSyncFn ?? ((dir, opts) => fs19.mkdirSync(dir, opts));
+  const writeFileSync13 = deps.writeFileSyncFn ?? ((filePath2, content) => fs19.writeFileSync(filePath2, content));
   const rawName = args[0];
   if (!rawName) {
     process.stderr.write(
@@ -40625,8 +41372,8 @@ function newMigration(args, deps = {}) {
   const migrationsDir = path21.join(cwd, "supabase", "migrations");
   const filename = `${stamp}_${slug}.sql`;
   const filePath = path21.join(migrationsDir, filename);
-  mkdirSync11(migrationsDir, { recursive: true });
-  writeFileSync12(filePath, "");
+  mkdirSync12(migrationsDir, { recursive: true });
+  writeFileSync13(filePath, "");
   process.stdout.write(JSON.stringify({ path: filePath }) + "\n");
   return 0;
 }
@@ -41189,12 +41936,12 @@ var init_validate_waves2 = __esm({
 });
 
 // src/cli/worktree/path.ts
-import { dirname as dirname17, basename as basename4, join as join53 } from "node:path";
+import { dirname as dirname17, basename as basename4, join as join56 } from "node:path";
 function computeWorktreePath(cwd, checkpointNumber) {
   const parent = dirname17(cwd);
   const base = basename4(cwd);
   const nnn = String(checkpointNumber).padStart(3, "0");
-  return join53(parent, `${base}-CHK-${nnn}`);
+  return join56(parent, `${base}-CHK-${nnn}`);
 }
 var init_path = __esm({
   "src/cli/worktree/path.ts"() {
@@ -41203,7 +41950,7 @@ var init_path = __esm({
 });
 
 // src/cli/worktree/add.ts
-import { join as join54, basename as basename5 } from "node:path";
+import { join as join57, basename as basename5 } from "node:path";
 import { mkdir as mkdir15, readFile as readFile32, writeFile as writeFile25 } from "node:fs/promises";
 import { spawnSync as spawnSync18 } from "node:child_process";
 async function defaultGetRepoId(cwd) {
@@ -41253,11 +42000,11 @@ async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
     (fsp) => fsp.access(p).then(() => true).catch(() => false)
   ));
   const mkdirFn = deps.mkdirFn ?? ((p, opts) => mkdir15(p, opts));
-  await mkdirFn(join54(destPath, ".claude"), { recursive: true });
+  await mkdirFn(join57(destPath, ".claude"), { recursive: true });
   const claudeStubs = ["settings.json", "settings.local.json"];
   for (const stub of claudeStubs) {
-    const srcFile = join54(srcCwd, ".claude", stub);
-    const destFile = join54(destPath, ".claude", stub);
+    const srcFile = join57(srcCwd, ".claude", stub);
+    const destFile = join57(destPath, ".claude", stub);
     try {
       const destExists = await existsFn(destFile);
       if (destExists) continue;
@@ -41268,22 +42015,22 @@ async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
   }
 }
 async function defaultCopyConfigStubs(srcCwd, destPath) {
-  await mkdir15(join54(destPath, ".codebyplan"), { recursive: true });
+  await mkdir15(join57(destPath, ".codebyplan"), { recursive: true });
   const topLevelStubs = [".mcp.json", ".env.local"];
   for (const stub of topLevelStubs) {
     try {
-      const content = await readFile32(join54(srcCwd, stub), "utf-8");
-      await writeFile25(join54(destPath, stub), content, "utf-8");
+      const content = await readFile32(join57(srcCwd, stub), "utf-8");
+      await writeFile25(join57(destPath, stub), content, "utf-8");
     } catch {
     }
   }
   try {
     const content = await readFile32(
-      join54(srcCwd, ".codebyplan", "repo.json"),
+      join57(srcCwd, ".codebyplan", "repo.json"),
       "utf-8"
     );
     await writeFile25(
-      join54(destPath, ".codebyplan", "repo.json"),
+      join57(destPath, ".codebyplan", "repo.json"),
       content,
       "utf-8"
     );
@@ -41448,7 +42195,7 @@ var init_add = __esm({
 });
 
 // src/cli/worktree/create.ts
-import { join as join55 } from "node:path";
+import { join as join58 } from "node:path";
 async function defaultGetRepoIdentity(cwd) {
   const found = await findCodebyplanConfig(cwd);
   const contents = found?.contents ?? null;
@@ -41504,7 +42251,7 @@ async function runWorktreeCreate(args, deps = {}) {
     );
     return 1;
   }
-  const worktreePath = explicitPath ?? join55(cwd, "..", name);
+  const worktreePath = explicitPath ?? join58(cwd, "..", name);
   const deviceId = await getDeviceId(cwd);
   let filesWritten = false;
   try {
@@ -42143,14 +42890,55 @@ var init_e2e2 = __esm({
   }
 });
 
+// src/cli/cleanup-plan-folders.ts
+var cleanup_plan_folders_exports = {};
+__export(cleanup_plan_folders_exports, {
+  runCleanupPlanFolders: () => runCleanupPlanFolders
+});
+import { execSync as execSync10 } from "node:child_process";
+async function runCleanupPlanFolders(args) {
+  void args;
+  const found = await findCodebyplanConfig(process.cwd());
+  if (!found) {
+    process.stderr.write(
+      "cleanup-plan-folders: no .codebyplan/repo.json found. Run `codebyplan setup`.\n"
+    );
+    process.exit(1);
+  }
+  const repoRoot = deriveRepoRoot(found.path);
+  const targets = [".codebyplan/checkpoint", ".codebyplan/standalone"];
+  let stdout7 = "";
+  try {
+    const result = execSync10(
+      `git rm -r --ignore-unmatch -- ${targets.map((t) => `"${t}"`).join(" ")}`,
+      { cwd: repoRoot, stdio: "pipe" }
+    );
+    stdout7 = result.toString("utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`cleanup-plan-folders: git rm failed: ${msg}
+`);
+    process.exit(1);
+  }
+  const removed = stdout7.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("rm '") && line.endsWith("'")).map((line) => line.slice(4, -1));
+  process.stdout.write(JSON.stringify({ removed, skipped: [] }) + "\n");
+  process.exit(0);
+}
+var init_cleanup_plan_folders = __esm({
+  "src/cli/cleanup-plan-folders.ts"() {
+    "use strict";
+    init_flags();
+  }
+});
+
 // src/cli/doctor.ts
 var doctor_exports = {};
 __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { existsSync as existsSync23 } from "node:fs";
-import { join as join56 } from "node:path";
-import { execSync as execSync10 } from "node:child_process";
+import { join as join59 } from "node:path";
+import { execSync as execSync11 } from "node:child_process";
 async function checkAuth() {
   try {
     await validateAuth();
@@ -42171,7 +42959,7 @@ async function checkVersion() {
     const installed = VERSION;
     let gitRoot = null;
     try {
-      gitRoot = execSync10("git rev-parse --show-toplevel", {
+      gitRoot = execSync11("git rev-parse --show-toplevel", {
         encoding: "utf-8"
       }).trim();
     } catch {
@@ -42260,7 +43048,7 @@ function checkSettings() {
   try {
     let projectDir;
     try {
-      projectDir = execSync10("git rev-parse --show-toplevel", {
+      projectDir = execSync11("git rev-parse --show-toplevel", {
         encoding: "utf-8"
       }).trim();
     } catch {
@@ -42273,7 +43061,7 @@ function checkSettings() {
         detail: "codebyplan not installed (no .cbp.manifest.json)"
       };
     }
-    if (!existsSync23(join56(projectDir, ".claude", "settings.json"))) {
+    if (!existsSync23(join59(projectDir, ".claude", "settings.json"))) {
       return {
         name: "settings",
         status: "warn",
@@ -42819,6 +43607,12 @@ void (async () => {
     const rest = process.argv.slice(3);
     process.exit(await runE2eCommand2(rest));
   }
+  if (arg === "cleanup-plan-folders") {
+    const { runCleanupPlanFolders: runCleanupPlanFolders2 } = await Promise.resolve().then(() => (init_cleanup_plan_folders(), cleanup_plan_folders_exports));
+    const rest = process.argv.slice(3);
+    await runCleanupPlanFolders2(rest);
+    process.exit(0);
+  }
   if (arg === "doctor") {
     const { runDoctor: runDoctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
     const rest = process.argv.slice(3);