codebyplan 1.13.64 → 1.13.65

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.64";
+    VERSION = "1.13.65";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -303,6 +303,7 @@ var init_gitignore_block = __esm({
       ".codebyplan/state/",
       ".codebyplan/clear/",
       ".codebyplan/todo/",
+      "!.codebyplan/handoff/",
       ".codebyplan/claude-status.local.json",
       ".codebyplan.local.json"
     ];
@@ -314,8 +315,8 @@ var init_gitignore_block = __esm({
 // src/lib/worktree.ts
 import { mkdir as mkdir2, writeFile as writeFile3, readFile as readFile3 } from "node:fs/promises";
 import { join as join3 } from "node:path";
-function defaultExists(path23) {
-  return readFile3(path23, "utf-8").then(() => true).catch(() => false);
+function defaultExists(path25) {
+  return readFile3(path25, "utf-8").then(() => true).catch(() => false);
 }
 async function writeRepoJson(codebyplanDir, selectedRepo, deps) {
   const repoJson = {
@@ -432,9 +433,9 @@ var init_worktree = __esm({
     init_statusline_config();
     init_gitignore_block();
     defaultFsDeps = {
-      mkdir: (path23, opts) => mkdir2(path23, opts).then(() => void 0),
-      writeFile: (path23, data, encoding) => writeFile3(path23, data, encoding),
-      readFile: (path23, encoding) => readFile3(path23, encoding),
+      mkdir: (path25, opts) => mkdir2(path25, opts).then(() => void 0),
+      writeFile: (path25, data, encoding) => writeFile3(path25, data, encoding),
+      readFile: (path25, encoding) => readFile3(path25, encoding),
       exists: defaultExists
     };
   }
@@ -502,12 +503,12 @@ async function readFallback(filename) {
   }
 }
 async function writeFallback(filename, data) {
-  const path23 = fallbackFile(filename);
-  await mkdir3(dirname(path23), { recursive: true });
-  await writeFile4(path23, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const path25 = fallbackFile(filename);
+  await mkdir3(dirname(path25), { recursive: true });
+  await writeFile4(path25, JSON.stringify(data, null, 2) + "\n", "utf-8");
   if (platform() !== "win32") {
     try {
-      await chmod(path23, 384);
+      await chmod(path25, 384);
     } catch {
     }
   }
@@ -3140,9 +3141,9 @@ import { createInterface } from "node:readline/promises";
 function getConfigPath(scope) {
   return scope === "user" ? join12(homedir4(), ".claude.json") : join12(process.cwd(), ".mcp.json");
 }
-async function readConfig(path23) {
+async function readConfig(path25) {
   try {
-    const raw = await readFile9(path23, "utf-8");
+    const raw = await readFile9(path25, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -3551,9 +3552,9 @@ import { join as join13 } from "node:path";
 function configPaths() {
   return [join13(homedir5(), ".claude.json"), join13(process.cwd(), ".mcp.json")];
 }
-async function readConfig2(path23) {
+async function readConfig2(path25) {
   try {
-    const raw = await readFile10(path23, "utf-8");
+    const raw = await readFile10(path25, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -3567,7 +3568,7 @@ function entryHasLegacyApiKey(entry) {
   if (!entry || !entry.headers) return false;
   return "x-api-key" in entry.headers;
 }
-async function rewriteConfig(path23, config, newUrl) {
+async function rewriteConfig(path25, config, newUrl) {
   const servers = config.mcpServers;
   if (!servers) return false;
   const entry = servers.codebyplan;
@@ -3575,7 +3576,7 @@ async function rewriteConfig(path23, config, newUrl) {
   if (!entryHasLegacyApiKey(entry) && entry.url === newUrl && entry.type === "http")
     return false;
   servers.codebyplan = { type: "http", url: newUrl };
-  await writeFile8(path23, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile8(path25, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return true;
 }
 async function runUpgradeAuth() {
@@ -3583,12 +3584,12 @@ async function runUpgradeAuth() {
   await runLogin();
   const newUrl = mcpEndpoint();
   let migrated = 0;
-  for (const path23 of configPaths()) {
-    const config = await readConfig2(path23);
+  for (const path25 of configPaths()) {
+    const config = await readConfig2(path25);
     if (!config) continue;
-    const changed = await rewriteConfig(path23, config, newUrl);
+    const changed = await rewriteConfig(path25, config, newUrl);
     if (changed) {
-      console.log(`  Updated ${path23}`);
+      console.log(`  Updated ${path25}`);
       migrated++;
     }
   }
@@ -3731,8 +3732,8 @@ async function validateConnectivity() {
     );
   }
 }
-function buildUrl(path23, params) {
-  const url = new URL(`${baseUrl()}/api${path23}`);
+function buildUrl(path25, params) {
+  const url = new URL(`${baseUrl()}/api${path25}`);
   if (params) {
     for (const [key, value] of Object.entries(params)) {
       if (value !== void 0) {
@@ -3751,8 +3752,8 @@ function isRetryable(err) {
 function delay(ms) {
   return new Promise((resolve17) => setTimeout(resolve17, ms));
 }
-async function request(method, path23, options) {
-  const url = buildUrl(path23, options?.params);
+async function request(method, path25, options) {
+  const url = buildUrl(path25, options?.params);
   const auth = await getAuthHeaders();
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -3772,7 +3773,7 @@ async function request(method, path23, options) {
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
       });
       if (!res.ok) {
-        let message = `API ${method} ${path23} failed with status ${res.status}`;
+        let message = `API ${method} ${path25} failed with status ${res.status}`;
         let code;
         try {
           const body = await res.json();
@@ -3806,20 +3807,20 @@ async function request(method, path23, options) {
   }
   throw lastError;
 }
-async function apiGet(path23, params) {
-  return request("GET", path23, { params });
+async function apiGet(path25, params) {
+  return request("GET", path25, { params });
 }
-async function apiPost(path23, body) {
-  return request("POST", path23, { body });
+async function apiPost(path25, body) {
+  return request("POST", path25, { body });
 }
-async function apiPut(path23, body) {
-  return request("PUT", path23, { body });
+async function apiPut(path25, body) {
+  return request("PUT", path25, { body });
 }
-async function apiPatch(path23, body) {
-  return request("PATCH", path23, { body });
+async function apiPatch(path25, body) {
+  return request("PATCH", path25, { body });
 }
-async function apiDelete(path23, params) {
-  await request("DELETE", path23, { params });
+async function apiDelete(path25, params) {
+  await request("DELETE", path25, { params });
 }
 async function callMcpTool(toolName, params) {
   const url = mcpEndpoint();
@@ -5680,13 +5681,13 @@ function __disposeResources(env) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path23, preserveJsx) {
-  if (typeof path23 === "string" && /^\.\.?\//.test(path23)) {
-    return path23.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+function __rewriteRelativeImportExtension(path25, preserveJsx) {
+  if (typeof path25 === "string" && /^\.\.?\//.test(path25)) {
+    return path25.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
       return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
     });
   }
-  return path23;
+  return path25;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -14324,8 +14325,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 */
@@ -15208,8 +15209,8 @@ var require_main2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/iceberg-js@0.8.1/node_modules/iceberg-js/dist/index.mjs
-function buildUrl2(baseUrl3, path23, query) {
-  const url = new URL(path23, baseUrl3);
+function buildUrl2(baseUrl3, path25, query) {
+  const url = new URL(path25, baseUrl3);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -15239,12 +15240,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path23,
+      path: path25,
       query,
       body,
       headers
     }) {
-      const url = buildUrl2(options.baseUrl, path23, query);
+      const url = buildUrl2(options.baseUrl, path25, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -16142,7 +16143,7 @@ var init_dist3 = __esm({
       * @param path The relative file path. Should be of the format `folder/subfolder/filename.png`. The bucket must already exist before attempting to upload.
       * @param fileBody The body of the file to be stored in the bucket.
       */
-      async uploadOrUpdate(method, path23, fileBody, fileOptions) {
+      async uploadOrUpdate(method, path25, fileBody, fileOptions) {
         var _this = this;
         return _this.handleOperation(async () => {
           let body;
@@ -16166,7 +16167,7 @@ var init_dist3 = __esm({
             if ((typeof ReadableStream !== "undefined" && body instanceof ReadableStream || body && typeof body === "object" && "pipe" in body && typeof body.pipe === "function") && !options.duplex) options.duplex = "half";
           }
           if (fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.headers) for (const [key, value] of Object.entries(fileOptions.headers)) headers = setHeader(headers, key, value);
-          const cleanPath = _this._removeEmptyFolders(path23);
+          const cleanPath = _this._removeEmptyFolders(path25);
           const _path = _this._getFinalPath(cleanPath);
           const data = await (method == "PUT" ? put : post)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread22({ headers }, (options === null || options === void 0 ? void 0 : options.duplex) ? { duplex: options.duplex } : {}));
           return {
@@ -16228,8 +16229,8 @@ var init_dist3 = __esm({
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Upload file using `ArrayBuffer` from base64 file data instead, see example below.
       */
-      async upload(path23, fileBody, fileOptions) {
-        return this.uploadOrUpdate("POST", path23, fileBody, fileOptions);
+      async upload(path25, fileBody, fileOptions) {
+        return this.uploadOrUpdate("POST", path25, fileBody, fileOptions);
       }
       /**
       * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -16269,9 +16270,9 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: none
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async uploadToSignedUrl(path23, token, fileBody, fileOptions) {
+      async uploadToSignedUrl(path25, token, fileBody, fileOptions) {
         var _this3 = this;
-        const cleanPath = _this3._removeEmptyFolders(path23);
+        const cleanPath = _this3._removeEmptyFolders(path25);
         const _path = _this3._getFinalPath(cleanPath);
         const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
         url.searchParams.set("token", token);
@@ -16340,10 +16341,10 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `insert`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async createSignedUploadUrl(path23, options) {
+      async createSignedUploadUrl(path25, options) {
         var _this4 = this;
         return _this4.handleOperation(async () => {
-          let _path = _this4._getFinalPath(path23);
+          let _path = _this4._getFinalPath(path25);
           const headers = _objectSpread22({}, _this4.headers);
           if (options === null || options === void 0 ? void 0 : options.upsert) headers["x-upsert"] = "true";
           const data = await post(_this4.fetch, `${_this4.url}/object/upload/sign/${_path}`, {}, { headers });
@@ -16352,7 +16353,7 @@ var init_dist3 = __esm({
           if (!token) throw new StorageError("No token returned by API");
           return {
             signedUrl: url.toString(),
-            path: path23,
+            path: path25,
             token
           };
         });
@@ -16412,8 +16413,8 @@ var init_dist3 = __esm({
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       * - For React Native, using either `Blob`, `File` or `FormData` does not work as intended. Update file using `ArrayBuffer` from base64 file data instead, see example below.
       */
-      async update(path23, fileBody, fileOptions) {
-        return this.uploadOrUpdate("PUT", path23, fileBody, fileOptions);
+      async update(path25, fileBody, fileOptions) {
+        return this.uploadOrUpdate("PUT", path25, fileBody, fileOptions);
       }
       /**
       * Moves an existing file to a new path in the same bucket.
@@ -16564,10 +16565,10 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `select`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async createSignedUrl(path23, expiresIn, options) {
+      async createSignedUrl(path25, expiresIn, options) {
         var _this8 = this;
         return _this8.handleOperation(async () => {
-          let _path = _this8._getFinalPath(path23);
+          let _path = _this8._getFinalPath(path25);
           const hasTransform = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0;
           let data = await post(_this8.fetch, `${_this8.url}/object/sign/${_path}`, _objectSpread22({ expiresIn }, hasTransform ? { transform: options.transform } : {}), { headers: _this8.headers });
           const query = new URLSearchParams();
@@ -16703,13 +16704,13 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `select`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      download(path23, options, parameters) {
+      download(path25, options, parameters) {
         const renderPath = typeof (options === null || options === void 0 ? void 0 : options.transform) === "object" && options.transform !== null && Object.keys(options.transform).length > 0 ? "render/image/authenticated" : "object";
         const query = new URLSearchParams();
         if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
         if ((options === null || options === void 0 ? void 0 : options.cacheNonce) != null) query.set("cacheNonce", String(options.cacheNonce));
         const queryString = query.toString();
-        const _path = this._getFinalPath(path23);
+        const _path = this._getFinalPath(path25);
         const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString ? `?${queryString}` : ""}`, {
           headers: this.headers,
           noResolveJson: true
@@ -16740,9 +16741,9 @@ var init_dist3 = __esm({
       * }
       * ```
       */
-      async info(path23) {
+      async info(path25) {
         var _this10 = this;
-        const _path = _this10._getFinalPath(path23);
+        const _path = _this10._getFinalPath(path25);
         return _this10.handleOperation(async () => {
           return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
         });
@@ -16763,9 +16764,9 @@ var init_dist3 = __esm({
       *   .exists('folder/avatar1.png')
       * ```
       */
-      async exists(path23) {
+      async exists(path25) {
         var _this11 = this;
-        const _path = _this11._getFinalPath(path23);
+        const _path = _this11._getFinalPath(path25);
         try {
           await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
           return {
@@ -16844,8 +16845,8 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: none
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      getPublicUrl(path23, options) {
-        const _path = this._getFinalPath(path23);
+      getPublicUrl(path25, options) {
+        const _path = this._getFinalPath(path25);
         const query = new URLSearchParams();
         if (options === null || options === void 0 ? void 0 : options.download) query.set("download", options.download === true ? "" : options.download);
         if (options === null || options === void 0 ? void 0 : options.transform) this.applyTransformOptsToQuery(query, options.transform);
@@ -16984,10 +16985,10 @@ var init_dist3 = __esm({
       *   - `objects` table permissions: `select`
       * - Refer to the [Storage guide](/docs/guides/storage/security/access-control) on how access control works
       */
-      async list(path23, options, parameters) {
+      async list(path25, options, parameters) {
         var _this13 = this;
         return _this13.handleOperation(async () => {
-          const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path23 || "" });
+          const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path25 || "" });
           return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
         });
       }
@@ -17052,11 +17053,11 @@ var init_dist3 = __esm({
         if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
         return btoa(data);
       }
-      _getFinalPath(path23) {
-        return `${this.bucketId}/${path23.replace(/^\/+/, "")}`;
+      _getFinalPath(path25) {
+        return `${this.bucketId}/${path25.replace(/^\/+/, "")}`;
       }
-      _removeEmptyFolders(path23) {
-        return path23.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+      _removeEmptyFolders(path25) {
+        return path25.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
       }
       /** Modifies the `query`, appending values the from `transform` */
       applyTransformOptsToQuery(query, transform) {
@@ -27774,8 +27775,8 @@ var init_watch = __esm({
 function isConflict(err) {
   return err instanceof BackendError && err.status === 409;
 }
-async function backendRequest(method, path23, body) {
-  const url = `${getBackendBase()}${path23}`;
+async function backendRequest(method, path25, body) {
+  const url = `${getBackendBase()}${path25}`;
   const auth = await getAuthHeaders();
   const res = await fetch(url, {
     method,
@@ -27787,7 +27788,7 @@ async function backendRequest(method, path23, body) {
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
   });
   if (!res.ok) {
-    let message = `Backend ${method} ${path23} failed with status ${res.status}`;
+    let message = `Backend ${method} ${path25} failed with status ${res.status}`;
     try {
       const errBody = await res.json();
       const msg = typeof errBody.message === "string" ? errBody.message : typeof errBody.error === "string" ? errBody.error : void 0;
@@ -27801,11 +27802,11 @@ async function backendRequest(method, path23, body) {
   }
   return res.json();
 }
-async function apiBackendPost(path23, body) {
-  return backendRequest("POST", path23, body);
+async function apiBackendPost(path25, body) {
+  return backendRequest("POST", path25, body);
 }
-async function apiBackendPatch(path23, body) {
-  return backendRequest("PATCH", path23, body);
+async function apiBackendPatch(path25, body) {
+  return backendRequest("PATCH", path25, body);
 }
 var REQUEST_TIMEOUT_MS2, BackendError;
 var init_state_client = __esm({
@@ -28081,8 +28082,8 @@ ${taskRows}
   for (const task of data.tasks) {
     if (Array.isArray(task.files_changed)) {
       for (const f of task.files_changed) {
-        const path23 = typeof f === "string" ? f : f?.path;
-        if (path23) allFiles.add(path23);
+        const path25 = typeof f === "string" ? f : f?.path;
+        if (path25) allFiles.add(path25);
       }
     }
   }
@@ -30690,7 +30691,7 @@ __export(start_exports, {
   runSessionStartCli: () => runSessionStartCli
 });
 import { spawnSync as spawnSync8 } from "node:child_process";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname7, join as join24 } from "node:path";
 async function updateCursorHashLocal(repoRoot, entityId, row) {
   const cursor = await readCursor(repoRoot);
   if (!cursor) return;
@@ -30738,7 +30739,7 @@ async function defaultUpdateStateActivate(repoId, repoRoot) {
     );
   }
 }
-function buildCreateLogBody(repoId, now = /* @__PURE__ */ new Date()) {
+function buildCreateLogBody(repoId, now = /* @__PURE__ */ new Date(), claudeSessionId) {
   const session_date = now.toISOString().slice(0, 10);
   const jan1 = Date.UTC(now.getUTCFullYear(), 0, 1);
   const day_number = Math.floor((now.getTime() - jan1) / 864e5) + 1;
@@ -30747,11 +30748,28 @@ function buildCreateLogBody(repoId, now = /* @__PURE__ */ new Date()) {
     session_date,
     day_number,
     started_at: now.toISOString(),
-    summary: ""
+    ...claudeSessionId != null ? { claude_session_id: claudeSessionId } : {}
   };
 }
 async function defaultCreateLog(repoId, repoRoot) {
-  const body = buildCreateLogBody(repoId);
+  let claudeSessionId = null;
+  try {
+    const sessionIdFile = join24(
+      repoRoot,
+      ".codebyplan",
+      "state",
+      "session",
+      "session-id.json"
+    );
+    const raw = await readEntityFile(
+      sessionIdFile
+    );
+    if (raw?.claude_session_id && typeof raw.claude_session_id === "string") {
+      claudeSessionId = raw.claude_session_id;
+    }
+  } catch {
+  }
+  const body = buildCreateLogBody(repoId, /* @__PURE__ */ new Date(), claudeSessionId);
   try {
     const created = await apiBackendPost(new URL(backendSessionLogsEndpoint()).pathname, body);
     const sessionLog = created.session_log ?? created;
@@ -31356,9 +31374,464 @@ var init_session2 = __esm({
   }
 });
 
+// src/lib/handoff-file.ts
+import * as path9 from "node:path";
+function handoffPath(projectDir, level, opts = {}) {
+  const base = path9.join(projectDir, ".codebyplan", "handoff");
+  switch (level) {
+    case "repo":
+      return path9.join(base, "repo.md");
+    case "checkpoint": {
+      if (opts.checkpoint == null) {
+        throw new Error(
+          'handoffPath: opts.checkpoint is required for level "checkpoint"'
+        );
+      }
+      const n = String(opts.checkpoint).padStart(3, "0");
+      return path9.join(base, "checkpoint", `${n}.md`);
+    }
+    case "task": {
+      if (opts.checkpoint == null) {
+        throw new Error(
+          'handoffPath: opts.checkpoint is required for level "task"'
+        );
+      }
+      if (opts.task == null) {
+        throw new Error('handoffPath: opts.task is required for level "task"');
+      }
+      const n = String(opts.checkpoint).padStart(3, "0");
+      return path9.join(base, "task", `${n}-${opts.task}.md`);
+    }
+    case "standalone": {
+      if (opts.number == null) {
+        throw new Error(
+          'handoffPath: opts.number is required for level "standalone"'
+        );
+      }
+      return path9.join(base, "standalone", `${opts.number}.md`);
+    }
+  }
+}
+function isHandoffEmpty(content) {
+  if (content == null) return true;
+  return content.trim() === "";
+}
+function readHandoffSection(fileContent, sectionLabel) {
+  const heading = `## ${sectionLabel}`;
+  const lines = fileContent.split("\n");
+  const startIdx = lines.findIndex((l) => l.trim() === heading);
+  if (startIdx === -1) return null;
+  const bodyLines = [];
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) break;
+    bodyLines.push(line);
+  }
+  let start = 0;
+  while (start < bodyLines.length && (bodyLines[start] ?? "").trim() === "") {
+    start++;
+  }
+  let end = bodyLines.length - 1;
+  while (end >= start && (bodyLines[end] ?? "").trim() === "") {
+    end--;
+  }
+  const body = bodyLines.slice(start, end + 1).join("\n");
+  return body.trim() === "" ? null : body;
+}
+function replaceHandoffSection(fileContent, sectionLabel, body) {
+  if (isHandoffEmpty(body)) {
+    return removeHandoffSection(fileContent, sectionLabel);
+  }
+  const heading = `## ${sectionLabel}`;
+  const lines = fileContent.split("\n");
+  const startIdx = lines.findIndex((l) => l.trim() === heading);
+  const newSection = [heading, "", body.trim(), ""].join("\n");
+  if (startIdx === -1) {
+    const trimmed = fileContent.trimEnd();
+    const separator = trimmed.length > 0 ? "\n\n" : "";
+    return trimmed + separator + newSection;
+  }
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if ((lines[i] ?? "").startsWith("## ")) {
+      endIdx = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, startIdx).join("\n");
+  const after = lines.slice(endIdx).join("\n");
+  const parts = [];
+  if (before.trimEnd().length > 0) parts.push(before.trimEnd());
+  parts.push(newSection.trimEnd());
+  if (after.trimStart().length > 0) parts.push(after.trimStart());
+  return parts.join("\n\n") + "\n";
+}
+function removeHandoffSection(fileContent, sectionLabel) {
+  const heading = `## ${sectionLabel}`;
+  const lines = fileContent.split("\n");
+  const startIdx = lines.findIndex((l) => l.trim() === heading);
+  if (startIdx === -1) return fileContent;
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if ((lines[i] ?? "").startsWith("## ")) {
+      endIdx = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, startIdx);
+  const after = lines.slice(endIdx);
+  while (before.length > 0 && (before[before.length - 1] ?? "").trim() === "") {
+    before.pop();
+  }
+  while (after.length > 0 && (after[0] ?? "").trim() === "") {
+    after.shift();
+  }
+  if (before.length === 0 && after.length === 0) return "";
+  const parts = [];
+  if (before.length > 0) parts.push(before.join("\n"));
+  if (after.length > 0) parts.push(after.join("\n"));
+  return parts.join("\n\n") + (fileContent.endsWith("\n") ? "\n" : "");
+}
+var HANDOFF_LEVELS;
+var init_handoff_file = __esm({
+  "src/lib/handoff-file.ts"() {
+    "use strict";
+    HANDOFF_LEVELS = [
+      "repo",
+      "checkpoint",
+      "task",
+      "standalone"
+    ];
+  }
+});
+
+// src/cli/handoff.ts
+var handoff_exports = {};
+__export(handoff_exports, {
+  runHandoffCommand: () => runHandoffCommand
+});
+import { readFile as readFile15, writeFile as writeFile12, mkdir as mkdir7, unlink as unlink5, readdir as readdir4 } from "node:fs/promises";
+import * as path10 from "node:path";
+async function resolveWorktreeLabel(repoRoot) {
+  let branch = "";
+  try {
+    branch = getCurrentBranch(repoRoot);
+  } catch {
+  }
+  if (branch) {
+    try {
+      const worktreesPath = path10.join(
+        repoRoot,
+        ".codebyplan",
+        "state",
+        "worktrees.json"
+      );
+      const raw = await readFile15(worktreesPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const entries = Array.isArray(parsed) ? parsed : parsed.data ?? [];
+      const match = entries.find((e) => e.branch === branch);
+      if (match?.name) return match.name;
+    } catch {
+    }
+    return branch.replace(/\//g, "-");
+  }
+  return "default";
+}
+async function readHandoffFile(filePath) {
+  try {
+    return await readFile15(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeHandoffFile(filePath, content) {
+  await mkdir7(path10.dirname(filePath), { recursive: true });
+  await writeFile12(filePath, content, "utf-8");
+}
+async function deleteHandoffFile(filePath) {
+  try {
+    await unlink5(filePath);
+  } catch {
+  }
+}
+function parseLevel(flags) {
+  const raw = flags["level"];
+  if (!raw) {
+    process.stderr.write("handoff: --level <level> is required\n");
+    process.exit(1);
+  }
+  if (!HANDOFF_LEVELS.includes(raw)) {
+    process.stderr.write(
+      `handoff: unknown level "${raw}". Valid levels: ${HANDOFF_LEVELS.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  return raw;
+}
+function parsePathOpts(flags) {
+  const opts = {};
+  if (flags["number"] !== void 0) opts.number = Number(flags["number"]);
+  if (flags["task"] !== void 0) opts.task = Number(flags["task"]);
+  if (flags["checkpoint"] !== void 0)
+    opts.checkpoint = Number(flags["checkpoint"]);
+  if (opts.checkpoint == null && flags["number"] !== void 0) {
+    opts.checkpoint = Number(flags["number"]);
+  }
+  return opts;
+}
+async function resolveRepoRoot5() {
+  const found = await findCodebyplanConfig(process.cwd());
+  if (!found) {
+    process.stderr.write(
+      "handoff: no .codebyplan/repo.json found. Run `codebyplan setup`.\n"
+    );
+    process.exit(1);
+  }
+  return deriveRepoRoot(found.path);
+}
+async function runHandoffRead(args) {
+  const { flags } = parseFlagsFromArgs(args);
+  const level = parseLevel(flags);
+  const repoRoot = await resolveRepoRoot5();
+  let filePath;
+  try {
+    filePath = handoffPath(repoRoot, level, parsePathOpts(flags));
+  } catch (err) {
+    process.stderr.write(
+      `handoff read: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+  const content = await readHandoffFile(filePath);
+  if (content === null || isHandoffEmpty(content)) {
+    process.exit(0);
+  }
+  if (level === "repo") {
+    const label = await resolveWorktreeLabel(repoRoot);
+    const section = readHandoffSection(content, label);
+    if (section !== null) {
+      process.stdout.write(section + "\n");
+    }
+  } else {
+    process.stdout.write(content);
+  }
+  process.exit(0);
+}
+async function runHandoffWrite(args) {
+  const { flags } = parseFlagsFromArgs(args);
+  const level = parseLevel(flags);
+  const newContent = flags["content"];
+  if (newContent === void 0) {
+    process.stderr.write("handoff write: --content <text> is required\n");
+    process.exit(1);
+  }
+  const repoRoot = await resolveRepoRoot5();
+  let filePath;
+  try {
+    filePath = handoffPath(repoRoot, level, parsePathOpts(flags));
+  } catch (err) {
+    process.stderr.write(
+      `handoff write: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+  if (level === "repo") {
+    const label = await resolveWorktreeLabel(repoRoot);
+    const existing = await readHandoffFile(filePath) ?? "";
+    const updated = replaceHandoffSection(existing, label, newContent);
+    if (isHandoffEmpty(updated)) {
+      await deleteHandoffFile(filePath);
+    } else {
+      await writeHandoffFile(filePath, updated);
+    }
+  } else {
+    if (isHandoffEmpty(newContent)) {
+      await deleteHandoffFile(filePath);
+    } else {
+      await writeHandoffFile(filePath, newContent);
+    }
+  }
+  process.exit(0);
+}
+async function runHandoffAppend(args) {
+  const { flags } = parseFlagsFromArgs(args);
+  const level = parseLevel(flags);
+  const appendContent = flags["content"];
+  if (appendContent === void 0) {
+    process.stderr.write("handoff append: --content <text> is required\n");
+    process.exit(1);
+  }
+  const repoRoot = await resolveRepoRoot5();
+  let filePath;
+  try {
+    filePath = handoffPath(repoRoot, level, parsePathOpts(flags));
+  } catch (err) {
+    process.stderr.write(
+      `handoff append: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+  const existing = await readHandoffFile(filePath) ?? "";
+  if (level === "repo") {
+    const label = await resolveWorktreeLabel(repoRoot);
+    const currentSection = readHandoffSection(existing, label) ?? "";
+    const combined = isHandoffEmpty(currentSection) ? appendContent : currentSection + "\n" + appendContent;
+    const updated = replaceHandoffSection(existing, label, combined);
+    if (isHandoffEmpty(updated)) {
+      await deleteHandoffFile(filePath);
+    } else {
+      await writeHandoffFile(filePath, updated);
+    }
+  } else {
+    const combined = isHandoffEmpty(existing) ? appendContent : existing.trimEnd() + "\n" + appendContent;
+    if (isHandoffEmpty(combined)) {
+      await deleteHandoffFile(filePath);
+    } else {
+      await writeHandoffFile(filePath, combined);
+    }
+  }
+  process.exit(0);
+}
+async function runHandoffClear(args) {
+  const { flags } = parseFlagsFromArgs(args);
+  const level = parseLevel(flags);
+  const repoRoot = await resolveRepoRoot5();
+  let filePath;
+  try {
+    filePath = handoffPath(repoRoot, level, parsePathOpts(flags));
+  } catch (err) {
+    process.stderr.write(
+      `handoff clear: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+  if (level === "repo") {
+    const label = await resolveWorktreeLabel(repoRoot);
+    const existing = await readHandoffFile(filePath) ?? "";
+    const updated = removeHandoffSection(existing, label);
+    if (isHandoffEmpty(updated)) {
+      await deleteHandoffFile(filePath);
+    } else {
+      await writeHandoffFile(filePath, updated);
+    }
+  } else {
+    await deleteHandoffFile(filePath);
+  }
+  process.exit(0);
+}
+async function scanHandoffDir(baseDir, level, subDir) {
+  const dir = path10.join(baseDir, subDir);
+  const entries = [];
+  let files;
+  try {
+    files = await readdir4(dir);
+  } catch {
+    return entries;
+  }
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const filePath = path10.join(dir, file);
+    const content = await readHandoffFile(filePath);
+    if (!isHandoffEmpty(content)) {
+      entries.push({
+        level,
+        identifier: path10.basename(file, ".md"),
+        path: filePath
+      });
+    }
+  }
+  return entries;
+}
+async function runHandoffStatus(args) {
+  const { booleans } = parseFlagsFromArgs(args);
+  const jsonMode = booleans.has("json");
+  const repoRoot = await resolveRepoRoot5();
+  const baseDir = path10.join(repoRoot, ".codebyplan", "handoff");
+  const nonEmpty = [];
+  const repoFile = path10.join(baseDir, "repo.md");
+  const repoContent = await readHandoffFile(repoFile);
+  if (!isHandoffEmpty(repoContent)) {
+    nonEmpty.push({ level: "repo", identifier: "repo", path: repoFile });
+  }
+  nonEmpty.push(...await scanHandoffDir(baseDir, "checkpoint", "checkpoint"));
+  nonEmpty.push(...await scanHandoffDir(baseDir, "task", "task"));
+  nonEmpty.push(...await scanHandoffDir(baseDir, "standalone", "standalone"));
+  const output = { nonEmpty, empty: [] };
+  if (jsonMode) {
+    process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+  } else {
+    if (nonEmpty.length === 0) {
+      process.stdout.write("No handoff content found.\n");
+    } else {
+      process.stdout.write("Handoffs with content:\n");
+      for (const entry of nonEmpty) {
+        process.stdout.write(
+          `  [${entry.level}] ${entry.identifier}  ${entry.path}
+`
+        );
+      }
+    }
+  }
+  process.exit(0);
+}
+async function runHandoffCommand(args) {
+  const subcommand = args[0];
+  if (subcommand === "read") {
+    await runHandoffRead(args.slice(1));
+    return;
+  }
+  if (subcommand === "write") {
+    await runHandoffWrite(args.slice(1));
+    return;
+  }
+  if (subcommand === "append") {
+    await runHandoffAppend(args.slice(1));
+    return;
+  }
+  if (subcommand === "clear") {
+    await runHandoffClear(args.slice(1));
+    return;
+  }
+  if (subcommand === "status") {
+    await runHandoffStatus(args.slice(1));
+    return;
+  }
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    printHandoffHelp();
+    process.exit(0);
+  }
+  if (subcommand) {
+    process.stderr.write(
+      `Unknown handoff subcommand: ${subcommand}
+Run 'codebyplan handoff help' for usage.
+`
+    );
+  } else {
+    printHandoffHelp();
+  }
+  process.exit(1);
+}
+function printHandoffHelp() {
+  process.stdout.write(
+    "\n  codebyplan handoff <subcommand>\n\n  Manage per-level handoff notes in .codebyplan/handoff/\n\n  Levels:\n    repo        Per-worktree section in .codebyplan/handoff/repo.md\n    checkpoint  .codebyplan/handoff/checkpoint/<NNN>.md\n    task        .codebyplan/handoff/task/<NNN>-<T>.md\n    standalone  .codebyplan/handoff/standalone/<N>.md\n\n  Subcommands:\n    read    --level <l> [--number N] [--task T]\n              Print current handoff content (empty output if absent)\n    write   --level <l> [--number N] [--task T] --content <text>\n              Replace handoff content; deletes file when content is empty\n    append  --level <l> [--number N] [--task T] --content <text>\n              Append to existing handoff (creates if absent)\n    clear   --level <l> [--number N] [--task T]\n              Delete handoff file (idempotent; repo level removes section)\n    status  [--json]\n              List all levels with non-empty handoff content\n\n  Level flags:\n    --number N        Standalone task number (level=standalone)\n                      or checkpoint number (level=checkpoint)\n    --checkpoint N    Checkpoint number (level=checkpoint or task)\n    --task T          Task number within checkpoint (level=task)\n\n"
+  );
+}
+var init_handoff = __esm({
+  "src/cli/handoff.ts"() {
+    "use strict";
+    init_flags();
+    init_git_utils();
+    init_handoff_file();
+  }
+});
+
 // src/lib/migrate-branch-model.ts
-import { readFile as readFile15, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { readFile as readFile16, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join27 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 function assertValidBranchName(branch) {
   if (!/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
@@ -31368,7 +31841,7 @@ function assertValidBranchName(branch) {
   }
 }
 async function readJsonFile3(filePath) {
-  const raw = await readFile15(filePath, "utf-8");
+  const raw = await readFile16(filePath, "utf-8");
   const parsed = JSON.parse(raw);
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error(`${filePath} does not contain a JSON object`);
@@ -31437,12 +31910,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;
@@ -31516,7 +31989,7 @@ async function runBranchMigration(opts) {
     const updatedParsed = { ...fileParsed, branch_config: after };
     const newJson = JSON.stringify(updatedParsed, null, 2) + "\n";
     if (newJson !== fileRaw) {
-      await writeFile12(configPath, newJson, "utf-8");
+      await writeFile13(configPath, newJson, "utf-8");
     }
   }
   return {
@@ -31788,8 +32261,8 @@ var init_branch = __esm({
 });
 
 // src/lib/bump.ts
-import { readFile as readFile16, writeFile as writeFile13, access as access5, readdir as readdir4 } from "node:fs/promises";
-import { join as join25, relative as relative5, resolve as resolve3 } from "node:path";
+import { readFile as readFile17, writeFile as writeFile14, access as access5, readdir as readdir5 } from "node:fs/promises";
+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");
@@ -31819,18 +32292,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));
+    const entries = await readdir5(parentDir, { withFileTypes: true });
+    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 {
     }
@@ -31841,7 +32314,7 @@ async function buildPackageMap(cwd) {
   const map = /* @__PURE__ */ new Map();
   let globs = [];
   try {
-    const raw = await readFile16(join25(cwd, "pnpm-workspace.yaml"), "utf-8");
+    const raw = await readFile17(join28(cwd, "pnpm-workspace.yaml"), "utf-8");
     globs = parsePnpmWorkspaceGlobs(raw);
   } catch {
   }
@@ -31849,7 +32322,7 @@ async function buildPackageMap(cwd) {
     const dirs = await expandGlob(cwd, glob);
     for (const dir of dirs) {
       try {
-        const pkgRaw = await readFile16(join25(dir, "package.json"), "utf-8");
+        const pkgRaw = await readFile17(join28(dir, "package.json"), "utf-8");
         const pkg = JSON.parse(pkgRaw);
         const name = pkg.name ?? relative5(cwd, dir);
         map.set(dir, { name, dir });
@@ -31968,7 +32441,7 @@ function injectVersion(raw, nextVersion, filePath) {
 async function prependChangelog(changelogPath, packageName, nextVersion, now, dryRun) {
   let existing;
   try {
-    existing = await readFile16(changelogPath, "utf-8");
+    existing = await readFile17(changelogPath, "utf-8");
   } catch {
     return false;
   }
@@ -31981,7 +32454,7 @@ async function prependChangelog(changelogPath, packageName, nextVersion, now, dr
 `;
   const updated = entry + existing;
   if (!dryRun) {
-    await writeFile13(changelogPath, updated, "utf-8");
+    await writeFile14(changelogPath, updated, "utf-8");
   }
   return true;
 }
@@ -32008,7 +32481,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);
@@ -32019,19 +32492,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);
@@ -32040,7 +32513,7 @@ async function runBump(opts) {
     }
     let currentPkgJsonRaw;
     try {
-      currentPkgJsonRaw = await readFile16(pkgJsonPath, "utf-8");
+      currentPkgJsonRaw = await readFile17(pkgJsonPath, "utf-8");
     } catch (err) {
       console.warn(
         `runBump: could not read ${pkgJsonPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -32085,7 +32558,7 @@ async function runBump(opts) {
     for (const { abs, rel } of versionFileCandidates) {
       let raw;
       try {
-        raw = await readFile16(abs, "utf-8");
+        raw = await readFile17(abs, "utf-8");
       } catch {
         continue;
       }
@@ -32099,11 +32572,11 @@ async function runBump(opts) {
       }
       const updated = injectVersion(raw, nextVersion, abs);
       if (!dryRun) {
-        await writeFile13(abs, updated, "utf-8");
+        await writeFile14(abs, updated, "utf-8");
       }
       updatedVersionFiles.push(rel);
     }
-    const changelogPath = join25(pkgDir, "CHANGELOG.md");
+    const changelogPath = join28(pkgDir, "CHANGELOG.md");
     const changelogUpdated = await prependChangelog(
       changelogPath,
       pkgInfo.name,
@@ -32646,14 +33119,14 @@ var init_ship2 = __esm({
 
 // src/lib/scaffold-publish-workflow.ts
 import * as fs6 from "node:fs";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 async function runScaffoldPublishWorkflow(opts) {
   await Promise.resolve();
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const projectDir = path9.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path11.resolve(opts?.projectDir ?? process.cwd());
   const templatesDir = opts?.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path9.join(
+  const templatePath = path11.join(
     templatesDir,
     "github-workflows",
     "publish.yml"
@@ -32664,7 +33137,7 @@ async function runScaffoldPublishWorkflow(opts) {
     );
   }
   const templateContent = fs6.readFileSync(templatePath, "utf-8");
-  const targetPath = path9.join(
+  const targetPath = path11.join(
     projectDir,
     ".github",
     "workflows",
@@ -32688,7 +33161,7 @@ async function runScaffoldPublishWorkflow(opts) {
       );
     }
   }
-  const targetDir = path9.dirname(targetPath);
+  const targetDir = path11.dirname(targetPath);
   fs6.mkdirSync(targetDir, { recursive: true });
   fs6.writeFileSync(targetPath, templateContent, "utf-8");
   return { status: "written", path: targetPath };
@@ -32785,7 +33258,7 @@ var init_atomic_write = __esm({
 
 // src/lib/repo-reader.ts
 import * as fsPromises from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path12 from "node:path";
 var LocalFsReader;
 var init_repo_reader = __esm({
   "src/lib/repo-reader.ts"() {
@@ -32796,7 +33269,7 @@ var init_repo_reader = __esm({
       }
       rootDir;
       resolve(p) {
-        return path10.isAbsolute(p) ? p : path10.resolve(this.rootDir, p);
+        return path12.isAbsolute(p) ? p : path12.resolve(this.rootDir, p);
       }
       async list(dir) {
         const abs = this.resolve(dir);
@@ -32832,7 +33305,7 @@ var init_repo_reader = __esm({
 
 // src/lib/ci-init.ts
 import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as path13 from "node:path";
 async function tryReadJson(reader, filePath) {
   try {
     const raw = await reader.read(filePath);
@@ -32910,10 +33383,10 @@ function buildDefaultCiConfig(platforms) {
   return config;
 }
 async function runCiInit(opts) {
-  const projectDir = path11.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path13.resolve(opts?.projectDir ?? process.cwd());
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const ciPath = path11.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path13.join(projectDir, ".codebyplan", "ci.json");
   const reader = opts?.reader ?? new LocalFsReader(projectDir);
   const platforms = await detectPlatforms(reader);
   if (dryRun) {
@@ -32959,7 +33432,7 @@ async function runCiInit(opts) {
       platforms: newPlatforms.length > 0 ? newPlatforms : platforms
     };
   }
-  const codebyplanDir = path11.join(projectDir, ".codebyplan");
+  const codebyplanDir = path13.join(projectDir, ".codebyplan");
   fs8.mkdirSync(codebyplanDir, { recursive: true });
   writeJsonAtomic(ciPath, newConfig);
   return { status: "written", path: ciPath, platforms };
@@ -33169,7 +33642,7 @@ var init_ci_init = __esm({
 
 // src/lib/scaffold-ci-workflow.ts
 import * as fs9 from "node:fs";
-import * as path12 from "node:path";
+import * as path14 from "node:path";
 function substituteTokens(template, tokens) {
   let result = template;
   for (const [token, value] of Object.entries(tokens)) {
@@ -33203,13 +33676,13 @@ async function detectStrictEnforcedFromCiJson(reader) {
   }
 }
 async function renderCiWorkflowContent(opts) {
-  const projectDir = path12.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path14.resolve(opts?.projectDir ?? process.cwd());
   const reader = opts?.reader ?? new LocalFsReader(projectDir);
   const pnpmVersion = opts?.pnpmVersion ?? await detectPnpmVersionFromPackageJson(reader);
   const nodeVersion = opts?.nodeVersion ?? "22";
   const strictEnforced = opts?.strictEnforced ?? await detectStrictEnforcedFromCiJson(reader);
   const templatesDir = opts?.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path12.join(templatesDir, "github-workflows", "ci.yml");
+  const templatePath = path14.join(templatesDir, "github-workflows", "ci.yml");
   if (!fs9.existsSync(templatePath)) {
     throw new Error(
       `scaffold-ci-workflow: template not found at ${templatePath}`
@@ -33226,9 +33699,9 @@ async function renderCiWorkflowContent(opts) {
 async function runScaffoldCiWorkflow(opts) {
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const projectDir = path12.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path14.resolve(opts?.projectDir ?? process.cwd());
   const renderedContent = await renderCiWorkflowContent(opts);
-  const targetPath = path12.join(projectDir, ".github", "workflows", "ci.yml");
+  const targetPath = path14.join(projectDir, ".github", "workflows", "ci.yml");
   if (dryRun) {
     return { status: "dry_run", path: targetPath };
   }
@@ -33247,7 +33720,7 @@ async function runScaffoldCiWorkflow(opts) {
       );
     }
   }
-  const targetDir = path12.dirname(targetPath);
+  const targetDir = path14.dirname(targetPath);
   fs9.mkdirSync(targetDir, { recursive: true });
   const tmpPath = targetPath + ".tmp";
   try {
@@ -33272,10 +33745,10 @@ var init_scaffold_ci_workflow = __esm({
 
 // src/lib/gh-required-checks.ts
 import * as fs10 from "node:fs";
-import * as path13 from "node:path";
+import * as path15 from "node:path";
 import { execSync as execSync5 } from "node:child_process";
 function readCiJson(projectDir) {
-  const ciPath = path13.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path15.join(projectDir, ".codebyplan", "ci.json");
   if (!fs10.existsSync(ciPath)) {
     return {
       platforms: {},
@@ -33294,15 +33767,15 @@ function readCiJson(projectDir) {
   }
 }
 function writeCiJsonAtomic(projectDir, config) {
-  const ciPath = path13.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path15.join(projectDir, ".codebyplan", "ci.json");
   writeJsonAtomic(ciPath, config);
 }
 function enforceRequiredCheck(opts) {
-  const projectDir = path13.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path15.resolve(opts?.projectDir ?? process.cwd());
   const branch = opts?.branch ?? "main";
   const checkName = opts?.checkName ?? "Lint + typecheck + test + build";
   const dryRun = opts?.dryRun ?? false;
-  const ciPath = path13.join(projectDir, ".codebyplan", "ci.json");
+  const ciPath = path15.join(projectDir, ".codebyplan", "ci.json");
   const config = readCiJson(projectDir);
   if (config.workflow?.required_check_enforced === true) {
     return { status: "already_enforced", path: ciPath };
@@ -33709,9 +34182,9 @@ var init_ci = __esm({
 
 // src/lib/cd-init.ts
 import * as fs11 from "node:fs";
-import * as path14 from "node:path";
+import * as path16 from "node:path";
 function detectSurfaces(projectDir) {
-  const shipmentPath = path14.join(projectDir, ".codebyplan", "shipment.json");
+  const shipmentPath = path16.join(projectDir, ".codebyplan", "shipment.json");
   let shipment;
   try {
     shipment = JSON.parse(fs11.readFileSync(shipmentPath, "utf-8"));
@@ -33764,10 +34237,10 @@ function buildDefaultCdConfig(rawSurfaceKeys) {
 }
 async function runCdInit(opts) {
   await Promise.resolve();
-  const projectDir = path14.resolve(opts?.projectDir ?? process.cwd());
+  const projectDir = path16.resolve(opts?.projectDir ?? process.cwd());
   const dryRun = opts?.dryRun ?? false;
   const force = opts?.force ?? false;
-  const cdPath = path14.join(projectDir, ".codebyplan", "cd.json");
+  const cdPath = path16.join(projectDir, ".codebyplan", "cd.json");
   const rawSurfaceKeys = detectSurfaces(projectDir);
   const seen = /* @__PURE__ */ new Set();
   const surfaces = [];
@@ -33808,7 +34281,7 @@ async function runCdInit(opts) {
       surfaces: newSurfaces
     };
   }
-  const codebyplanDir = path14.join(projectDir, ".codebyplan");
+  const codebyplanDir = path16.join(projectDir, ".codebyplan");
   fs11.mkdirSync(codebyplanDir, { recursive: true });
   writeJsonAtomic(cdPath, newConfig);
   return { status: "written", path: cdPath, surfaces };
@@ -33898,14 +34371,14 @@ var init_cd_init = __esm({
 
 // src/lib/scaffold-cd-workflow.ts
 import * as fs12 from "node:fs";
-import * as path15 from "node:path";
+import * as path17 from "node:path";
 async function scaffoldOneWorkflow(templateName, targetName, opts) {
   await Promise.resolve();
   const dryRun = opts.dryRun ?? false;
   const force = opts.force ?? false;
-  const projectDir = path15.resolve(opts.projectDir ?? process.cwd());
+  const projectDir = path17.resolve(opts.projectDir ?? process.cwd());
   const templatesDir = opts.templatesDir ?? resolveTemplatesDir();
-  const templatePath = path15.join(
+  const templatePath = path17.join(
     templatesDir,
     "github-workflows",
     templateName
@@ -33916,7 +34389,7 @@ async function scaffoldOneWorkflow(templateName, targetName, opts) {
     );
   }
   const templateContent = fs12.readFileSync(templatePath, "utf-8");
-  const targetPath = path15.join(projectDir, ".github", "workflows", targetName);
+  const targetPath = path17.join(projectDir, ".github", "workflows", targetName);
   if (dryRun) {
     return { status: "dry_run", path: targetPath };
   }
@@ -33935,7 +34408,7 @@ async function scaffoldOneWorkflow(templateName, targetName, opts) {
       );
     }
   }
-  const targetDir = path15.dirname(targetPath);
+  const targetDir = path17.dirname(targetPath);
   fs12.mkdirSync(targetDir, { recursive: true });
   const tmpPath = targetPath + ".tmp";
   try {
@@ -34461,7 +34934,7 @@ __export(version_status_exports, {
 });
 import { execFileSync, execSync as execSync6 } from "node:child_process";
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname11, join as join32 } from "node:path";
+import { dirname as dirname12, join as join35 } from "node:path";
 function fetchLatestVersion() {
   try {
     return execFileSync("npm", ["view", "codebyplan", "version"], {
@@ -34485,11 +34958,11 @@ 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 = dirname11(dir);
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -34507,7 +34980,7 @@ function buildInstallCommand2(pm) {
 }
 async function resolveGuard(gitRoot, currentBranch) {
   if (gitRoot !== null) {
-    const canonicalPkgPath = join32(
+    const canonicalPkgPath = join35(
       gitRoot,
       "packages",
       "codebyplan-package",
@@ -34531,10 +35004,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);
@@ -34618,8 +35091,8 @@ var upload_e2e_images_exports = {};
 __export(upload_e2e_images_exports, {
   runUploadE2eImagesCommand: () => runUploadE2eImagesCommand
 });
-import { readFile as readFile18 } from "node:fs/promises";
-import { join as join33, basename as basename2, resolve as resolve11 } from "node:path";
+import { readFile as readFile19 } from "node:fs/promises";
+import { join as join36, basename as basename3, resolve as resolve11 } from "node:path";
 import { execSync as execSync7 } from "node:child_process";
 function baseUrl2() {
   return (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
@@ -34653,8 +35126,8 @@ function parseArgs(args) {
 }
 async function readE2eConfig(projectPath) {
   try {
-    const raw = await readFile18(
-      join33(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile19(
+      join36(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -34695,8 +35168,8 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
       continue;
     const isNew = status === "A";
     results.push({
-      absolutePath: join33(projectPath, filePath),
-      filename: basename2(filePath),
+      absolutePath: join36(projectPath, filePath),
+      filename: basename3(filePath),
       framework: frameworkName,
       is_new: isNew
     });
@@ -34711,11 +35184,11 @@ function deriveTestName(absolutePath) {
       return seg.replace(".spec.ts-snapshots", "");
     }
   }
-  return basename2(absolutePath, ".png");
+  return basename3(absolutePath, ".png");
 }
 function buildManifestItem(png) {
   const testName = deriveTestName(png.absolutePath);
-  const pageOrScreen = basename2(png.absolutePath, ".png");
+  const pageOrScreen = basename3(png.absolutePath, ".png");
   return {
     filename: png.filename,
     test_name: testName,
@@ -34792,7 +35265,7 @@ async function runUploadE2eImagesCommand(args) {
   for (const png of allPngs) {
     let bytes;
     try {
-      bytes = await readFile18(png.absolutePath);
+      bytes = await readFile19(png.absolutePath);
     } catch {
       process.stderr.write(
         `upload-e2e-images: could not read file: ${png.absolutePath}
@@ -34869,9 +35342,9 @@ __export(arch_map_exports, {
   runArchMapCommand: () => runArchMapCommand,
   updateFrontmatterFields: () => updateFrontmatterFields
 });
-import { readFile as readFile19, writeFile as writeFile14 } from "node:fs/promises";
+import { readFile as readFile20, writeFile as writeFile15 } from "node:fs/promises";
 import { existsSync as existsSync11, readdirSync as readdirSync3 } 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(/\/+$/, "");
@@ -34896,9 +35369,9 @@ async function resolveCodebyplanDir(startDir) {
   }
 }
 async function readArchitectureConfig(codebyplanDir) {
-  const filePath = join34(codebyplanDir, "architecture.json");
+  const filePath = join37(codebyplanDir, "architecture.json");
   try {
-    const raw = await readFile19(filePath, "utf-8");
+    const raw = await readFile20(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.modules)) {
       return { version: 1, modules: [] };
@@ -34909,8 +35382,8 @@ async function readArchitectureConfig(codebyplanDir) {
   }
 }
 async function writeArchitectureConfig(codebyplanDir, config) {
-  const filePath = join34(codebyplanDir, "architecture.json");
-  await writeFile14(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const filePath = join37(codebyplanDir, "architecture.json");
+  await writeFile15(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function resolveGitSha(modulePath, cwd) {
   try {
@@ -34928,10 +35401,10 @@ 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 readFile19(workspacePath, "utf-8");
+    const raw = await readFile20(workspacePath, "utf-8");
     const lines = raw.split("\n");
     let inPackages = false;
     for (const line of lines) {
@@ -34955,7 +35428,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 = readdirSync3(absDir, { withFileTypes: true });
@@ -34968,7 +35441,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);
       }
@@ -34976,7 +35449,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);
@@ -35162,10 +35635,10 @@ 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 readFile19(mapAbsPath, "utf-8");
+    mapContent = await readFile20(mapAbsPath, "utf-8");
   } catch {
     console.warn(
       "  Warning: map file " + stampedEntry.map_file + " not found \u2014 stamped manifest only"
@@ -35187,7 +35660,7 @@ async function runStamp(modulePath, sha, depthArg, projectRoot) {
       );
     } else {
       try {
-        await writeFile14(mapAbsPath, updated, "utf-8");
+        await writeFile15(mapAbsPath, updated, "utf-8");
       } catch (writeErr) {
         console.warn(
           "  Warning: could not write map file " + stampedEntry.map_file + " \u2014 " + (writeErr instanceof Error ? writeErr.message : String(writeErr)) + " \u2014 stamped manifest only"
@@ -35340,19 +35813,19 @@ var init_branch_port_resolver = __esm({
 });
 
 // src/lib/migrate-local-config.ts
-import { mkdir as mkdir7, readFile as readFile20, unlink as unlink5, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join35 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile21, unlink as unlink6, writeFile as writeFile16 } from "node:fs/promises";
+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: stat2 } = await import("node:fs/promises");
@@ -35391,7 +35864,7 @@ async function runLocalMigration(projectPath) {
   }
   let legacyRaw;
   try {
-    legacyRaw = await readFile20(legacySharedPath(projectPath), "utf-8");
+    legacyRaw = await readFile21(legacySharedPath(projectPath), "utf-8");
   } catch {
     return {
       migrated: true,
@@ -35416,7 +35889,7 @@ async function runLocalMigration(projectPath) {
   }
   const cfg = parsed;
   try {
-    await mkdir7(newDirPath(projectPath), { recursive: true });
+    await mkdir8(newDirPath(projectPath), { recursive: true });
   } catch (err) {
     const code = err.code;
     if (code === "ENOTDIR" || code === "EEXIST") {
@@ -35431,8 +35904,8 @@ async function runLocalMigration(projectPath) {
   if ("repo_id" in cfg) repoJson.repo_id = cfg.repo_id;
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "repo.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -35444,8 +35917,8 @@ async function runLocalMigration(projectPath) {
     serverJson.auto_push_enabled = cfg.auto_push_enabled;
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "server.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -35453,37 +35926,37 @@ async function runLocalMigration(projectPath) {
   const gitJson = {};
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "git.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/git.json");
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "shipment.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "vendor.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "e2e.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
-  await writeFile15(
-    join35(projectPath, ".codebyplan", "eslint.json"),
+  await writeFile16(
+    join38(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
@@ -35494,9 +35967,9 @@ 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 readFile20(gitignorePath, "utf-8");
+    const gitignoreContent = await readFile21(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
     const newLine = ".codebyplan/device.local.json";
     const hasLegacy = gitignoreContent.split("\n").some((l) => l.trimEnd() === legacyLine);
@@ -35515,18 +35988,18 @@ async function runLocalMigration(projectPath) {
       updated = gitignoreContent;
     }
     if (updated !== gitignoreContent) {
-      await writeFile15(gitignorePath, updated, "utf-8");
+      await writeFile16(gitignorePath, updated, "utf-8");
       filesChanged.push(".gitignore");
     }
   } catch {
   }
   try {
-    await unlink5(legacySharedPath(projectPath));
+    await unlink6(legacySharedPath(projectPath));
     filesChanged.push(".codebyplan.json (deleted)");
   } catch {
   }
   try {
-    await unlink5(legacyLocalPath(projectPath));
+    await unlink6(legacyLocalPath(projectPath));
     filesChanged.push(".codebyplan.local.json (deleted)");
   } catch {
   }
@@ -35556,8 +36029,8 @@ __export(config_exports, {
   runConfig: () => runConfig,
   runConfigMigrate: () => runConfigMigrate
 });
-import { mkdir as mkdir8, readFile as readFile21, writeFile as writeFile16 } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile22, writeFile as writeFile17 } from "node:fs/promises";
+import { join as join39 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -35590,7 +36063,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 {
     currentBranch,
     portAllocations,
@@ -35666,7 +36139,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
     console.log("  Config would be updated (dry-run).");
     return;
   }
-  await mkdir8(codebyplanDir, { recursive: true });
+  await mkdir9(codebyplanDir, { recursive: true });
   const files = [
     { name: "repo.json", payload: repoPayload },
     { name: "server.json", payload: serverPayload },
@@ -35683,16 +36156,16 @@ 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 {
-      currentJson = await readFile21(filePath, "utf-8");
+      currentJson = await readFile22(filePath, "utf-8");
     } catch {
     }
     if (createOnly && currentJson !== "") continue;
     if (currentJson === newJson) continue;
-    await writeFile16(filePath, newJson, "utf-8");
+    await writeFile17(filePath, newJson, "utf-8");
     console.log(`  Updated .codebyplan/${name}`);
     anyUpdated = true;
   }
@@ -35702,8 +36175,8 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 }
 async function readRepoConfig(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "repo.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35713,8 +36186,8 @@ async function readRepoConfig(projectPath) {
 }
 async function readServerConfig(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "server.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35724,8 +36197,8 @@ async function readServerConfig(projectPath) {
 }
 async function readGitConfig2(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "git.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35735,8 +36208,8 @@ async function readGitConfig2(projectPath) {
 }
 async function readShipmentConfig2(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "shipment.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35746,8 +36219,8 @@ async function readShipmentConfig2(projectPath) {
 }
 async function readVendorConfig(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35757,8 +36230,8 @@ async function readVendorConfig(projectPath) {
 }
 async function readE2eConfig2(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "e2e.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35768,8 +36241,8 @@ async function readE2eConfig2(projectPath) {
 }
 async function readServerLocalConfig(projectPath) {
   try {
-    const raw = await readFile21(
-      join36(projectPath, ".codebyplan", "server.local.json"),
+    const raw = await readFile22(
+      join39(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -35841,8 +36314,8 @@ var init_config = __esm({
 });
 
 // src/lib/server-detect.ts
-import { readFile as readFile22, readdir as readdir6, access as access7 } from "node:fs/promises";
-import { join as join37 } from "node:path";
+import { readFile as readFile23, readdir as readdir7, access as access7 } from "node:fs/promises";
+import { join as join40 } from "node:path";
 async function fileExists4(filePath) {
   try {
     await access7(filePath);
@@ -35853,8 +36326,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";
   })();
 }
@@ -35886,12 +36359,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 readFile22(join37(projectPath, "package.json"), "utf-8");
+    const raw = await readFile23(join40(projectPath, "package.json"), "utf-8");
     pkg = JSON.parse(raw);
   } catch {
     return {
@@ -35907,15 +36380,15 @@ 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 readdir6(appsDir, { withFileTypes: true });
+      const entries = await readdir7(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 readFile22(appPkgPath, "utf-8");
+          const appRaw = await readFile23(appPkgPath, "utf-8");
           const appPkg = JSON.parse(appRaw);
           const appName = entry.name;
           const framework = detectFramework(appPkg);
@@ -35958,14 +36431,14 @@ var init_server_detect = __esm({
 });
 
 // src/lib/port-verify.ts
-import { readFile as readFile23 } from "node:fs/promises";
+import { readFile as readFile24 } from "node:fs/promises";
 async function verifyPorts(projectPath, portAllocations) {
   const mismatches = [];
   const allocatedPorts = new Set(portAllocations.map((a) => a.port));
   const packageJsonPaths = await findPackageJsonFiles(projectPath, projectPath);
   for (const pkgPath of packageJsonPaths) {
     try {
-      const raw = await readFile23(pkgPath, "utf-8");
+      const raw = await readFile24(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scriptPort = detectPortFromScripts(pkg);
       if (scriptPort !== null && !allocatedPorts.has(scriptPort)) {
@@ -36028,7 +36501,7 @@ async function findUnallocatedApps(projectPath, portAllocations) {
     }
     let pkg;
     try {
-      const raw = await readFile23(`${app.absPath}/package.json`, "utf-8");
+      const raw = await readFile24(`${app.absPath}/package.json`, "utf-8");
       pkg = JSON.parse(raw);
     } catch {
       continue;
@@ -36078,8 +36551,8 @@ __export(ports_exports, {
   parseEnvFile: () => parseEnvFile,
   runPorts: () => runPorts
 });
-import { mkdir as mkdir9, readFile as readFile24, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join38 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile25, writeFile as writeFile18 } from "node:fs/promises";
+import { join as join41 } from "node:path";
 function printDetectionResult(result, projectPath) {
   console.log(`
   CodeByPlan Ports - List`);
@@ -36236,12 +36709,12 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // which matches ServerLocalConfig.port_allocations — 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 {
-    currentJson = await readFile24(filePath, "utf-8");
+    currentJson = await readFile25(filePath, "utf-8");
   } catch {
   }
   if (currentJson === newJson) {
@@ -36252,18 +36725,18 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     console.log("  Would update .codebyplan/server.local.json (dry-run).");
     return;
   }
-  await mkdir9(codebyplanDir, { recursive: true });
-  await writeFile17(filePath, newJson, "utf-8");
+  await mkdir10(codebyplanDir, { recursive: true });
+  await writeFile18(filePath, newJson, "utf-8");
   console.log(
     `  Updated .codebyplan/server.local.json (branch '${currentBranch}', ${portAllocations.length} allocation${portAllocations.length === 1 ? "" : "s"}).`
   );
 }
 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 readFile24(sourcePath, "utf-8");
+    sourceRaw = await readFile25(sourcePath, "utf-8");
   } catch {
     console.warn(
       `  Skipped .codebyplan/e2e.env \u2014 source ${relSource} not found.`
@@ -36292,12 +36765,12 @@ 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 {
-    currentContent = await readFile24(filePath, "utf-8");
+    currentContent = await readFile25(filePath, "utf-8");
   } catch {
   }
   if (currentContent === newContent) {
@@ -36308,8 +36781,8 @@ async function provisionE2eEnv(projectPath, dryRun) {
     console.log("  Would provision .codebyplan/e2e.env (dry-run).");
     return;
   }
-  await mkdir9(codebyplanDir, { recursive: true });
-  await writeFile17(filePath, newContent, "utf-8");
+  await mkdir10(codebyplanDir, { recursive: true });
+  await writeFile18(filePath, newContent, "utf-8");
   console.log(
     `  Provisioned .codebyplan/e2e.env (${lines.length} var${lines.length === 1 ? "" : "s"}).`
   );
@@ -36517,8 +36990,8 @@ __export(docs_exports, {
   stripRangePrefix: () => stripRangePrefix
 });
 import { existsSync as existsSync12 } from "node:fs";
-import { mkdir as mkdir10, readFile as readFile25, readdir as readdir7, rm as rm2, writeFile as writeFile18 } from "node:fs/promises";
-import { dirname as dirname12, isAbsolute as isAbsolute3, join as join39, relative as relative7, sep as sep2 } from "node:path";
+import { mkdir as mkdir11, readFile as readFile26, readdir as readdir8, rm as rm2, writeFile as writeFile19 } from "node:fs/promises";
+import { dirname as dirname13, isAbsolute as isAbsolute3, 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) {
@@ -36572,12 +37045,12 @@ async function mapWithConcurrency(items, limit, fn) {
 }
 async function resolveExactVersion(projectPath, dep) {
   const candidateDirs = [projectPath];
-  const sourceDir = join39(projectPath, dirname12(dep.sourcePath));
+  const sourceDir = join42(projectPath, dirname13(dep.sourcePath));
   if (sourceDir !== projectPath) candidateDirs.push(sourceDir);
   for (const base of candidateDirs) {
     try {
-      const raw = await readFile25(
-        join39(base, "node_modules", dep.name, "package.json"),
+      const raw = await readFile26(
+        join42(base, "node_modules", dep.name, "package.json"),
         "utf-8"
       );
       const pkg = JSON.parse(raw);
@@ -36591,8 +37064,8 @@ async function resolveExactVersion(projectPath, dep) {
 }
 async function readVendorDocsPath(projectPath) {
   try {
-    const raw = await readFile25(
-      join39(projectPath, ".codebyplan", "vendor.json"),
+    const raw = await readFile26(
+      join42(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     const parsed = JSON.parse(raw);
@@ -36605,7 +37078,7 @@ async function readVendorDocsPath(projectPath) {
 }
 async function resolveDocsDir(projectPath, flags) {
   const configured = flags["dir"] ?? await readVendorDocsPath(projectPath) ?? DEFAULT_DOCS_DIR;
-  const absDir = isAbsolute3(configured) ? configured : join39(projectPath, configured);
+  const absDir = isAbsolute3(configured) ? configured : join42(projectPath, configured);
   const rel = relative7(projectPath, absDir);
   const relDir = rel === "" || rel.startsWith("..") ? null : rel.split(sep2).join("/");
   return { absDir, relDir };
@@ -36614,7 +37087,7 @@ async function readDocsLock(absDir) {
   const empty = { generated_at: "", libraries: {} };
   let raw;
   try {
-    raw = await readFile25(join39(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile26(join42(absDir, LOCK_FILE), "utf-8");
   } catch {
     return empty;
   }
@@ -36710,10 +37183,10 @@ 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 readFile25(gitignorePath, "utf-8");
+    existing = await readFile26(gitignorePath, "utf-8");
   } catch {
   }
   const lines = existing.split(/\r?\n/).map((l) => l.trim());
@@ -36725,7 +37198,7 @@ async function ensureDocsGitignoreEntry(projectPath, relDir, dryRun) {
     content += `${GITIGNORE_COMMENT}
 ${entry}
 `;
-    await writeFile18(gitignorePath, content, "utf-8");
+    await writeFile19(gitignorePath, content, "utf-8");
   }
   return "added";
 }
@@ -36733,7 +37206,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 (existsSync12(libPath)) {
     if (ctx.dryRun) {
       console.log(`  would remove stale mirror dir ${libPath}`);
@@ -36786,14 +37259,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 && !existsSync12(join39(libPath, "INDEX.md"))) {
-      await mkdir10(libPath, { recursive: true });
-      await writeFile18(
-        join39(libPath, "INDEX.md"),
+    if (!ctx.dryRun && !existsSync12(join42(libPath, "INDEX.md"))) {
+      await mkdir11(libPath, { recursive: true });
+      await writeFile19(
+        join42(libPath, "INDEX.md"),
         buildLibIndex(dep.name, manifest),
         "utf-8"
       );
@@ -36815,14 +37288,14 @@ async function syncOneLibrary(dep, ctx) {
       );
       continue;
     }
-    const target = join39(versionPath, rel);
+    const target = join42(versionPath, rel);
     if (sameVersionLockFiles[file.path] === file.content_hash && existsSync12(target)) {
       continue;
     }
     written++;
     if (!ctx.dryRun) {
-      await mkdir10(dirname12(target), { recursive: true });
-      await writeFile18(target, file.content, "utf-8");
+      await mkdir11(dirname13(target), { recursive: true });
+      await writeFile19(target, file.content, "utf-8");
     }
   }
   let removedFiles = 0;
@@ -36833,13 +37306,13 @@ 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;
   let libEntries = [];
   try {
-    libEntries = await readdir7(libPath, { withFileTypes: true });
+    libEntries = await readdir8(libPath, { withFileTypes: true });
   } catch {
   }
   for (const entry of libEntries) {
@@ -36848,13 +37321,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 mkdir10(libPath, { recursive: true });
-    await writeFile18(
-      join39(libPath, "INDEX.md"),
+    await mkdir11(libPath, { recursive: true });
+    await writeFile19(
+      join42(libPath, "INDEX.md"),
       buildLibIndex(dep.name, manifest),
       "utf-8"
     );
@@ -36907,8 +37380,8 @@ async function runDocsSync() {
     (dep) => syncOneLibrary(dep, ctx)
   );
   if (!dryRun) {
-    await mkdir10(absDir, { recursive: true });
-    await writeFile18(join39(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
+    await mkdir11(absDir, { recursive: true });
+    await writeFile19(join42(absDir, "INDEX.md"), buildTopIndex(outcomes), "utf-8");
     const libraries = {};
     for (const o of outcomes) {
       if (o.kind === "synced" || o.kind === "unchanged") {
@@ -36933,8 +37406,8 @@ async function runDocsSync() {
       generated_at: (/* @__PURE__ */ new Date()).toISOString(),
       libraries: sortedLibraries
     };
-    await writeFile18(
-      join39(absDir, LOCK_FILE),
+    await writeFile19(
+      join42(absDir, LOCK_FILE),
       JSON.stringify(newLock, null, 2) + "\n",
       "utf-8"
     );
@@ -36969,14 +37442,14 @@ async function runDocsSync() {
 async function countFilesRecursively(dirPath) {
   let entries;
   try {
-    entries = await readdir7(dirPath, { withFileTypes: true });
+    entries = await readdir8(dirPath, { withFileTypes: true });
   } catch {
     return 0;
   }
   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++;
     }
@@ -36993,7 +37466,7 @@ async function runDocsStatus() {
 `);
   let raw;
   try {
-    raw = await readFile25(join39(absDir, LOCK_FILE), "utf-8");
+    raw = await readFile26(join42(absDir, LOCK_FILE), "utf-8");
   } catch {
     console.log(
       `  No ${LOCK_FILE} found \u2014 run \`codebyplan docs sync\` first.
@@ -37022,7 +37495,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 (!existsSync12(versionPath)) {
       outOfSync++;
@@ -37110,7 +37583,7 @@ var init_docs = __esm({
 
 // src/lib/check-baseline.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join40 } from "node:path";
+import { join as join43 } from "node:path";
 function emptyBaseline() {
   return {
     lint: { known_failing: [] },
@@ -37120,7 +37593,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);
@@ -37144,7 +37617,7 @@ function loadBaseline(projectRoot) {
   }
 }
 function saveBaseline(projectRoot, baseline) {
-  const filePath = join40(projectRoot, BASELINE_FILENAME);
+  const filePath = join43(projectRoot, BASELINE_FILENAME);
   writeFileSync8(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
 }
 function diffBaseline(check, currentFailingPackages, baseline) {
@@ -37194,7 +37667,7 @@ var init_check_baseline = __esm({
 
 // src/lib/check.ts
 import { readFileSync as readFileSync13, existsSync as existsSync13 } 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([
@@ -37262,9 +37735,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 (existsSync13(localBin)) return localBin;
-  const workspaceRootBin = join41(
+  const workspaceRootBin = join44(
     projectRoot,
     "..",
     "..",
@@ -37781,7 +38254,7 @@ var init_check2 = __esm({
 
 // src/lib/claude-plan.ts
 import * as fs13 from "node:fs";
-import * as path16 from "node:path";
+import * as path18 from "node:path";
 function buildDriftPlan(projectDir, templatesDir, manifest) {
   const packaged = walkTemplates(templatesDir);
   const packagedBySrc = new Map(packaged.map((f) => [f.src, f]));
@@ -37795,8 +38268,8 @@ function buildDriftPlan(projectDir, templatesDir, manifest) {
   };
   for (const pkg of packaged) {
     const inManifest = manifestBySrc.get(pkg.src);
-    const absDest = path16.join(projectDir, ".claude", pkg.dest);
-    const absSrc = path16.join(templatesDir, pkg.src);
+    const absDest = path18.join(projectDir, ".claude", pkg.dest);
+    const absSrc = path18.join(templatesDir, pkg.src);
     if (!inManifest) {
       plan.newOptIn.push({
         packaged: { src: pkg.src, dest: pkg.dest, hash: pkg.hash },
@@ -37845,7 +38318,7 @@ __export(status_exports, {
   runStatus: () => runStatus2
 });
 import * as fs14 from "node:fs";
-import * as path17 from "node:path";
+import * as path19 from "node:path";
 import { execSync as execSync8 } from "node:child_process";
 function makeFailSafe(checked_at) {
   return {
@@ -37954,12 +38427,12 @@ async function runStatus2(argv) {
     const latest = fetchLatestVersion();
     const newer = latest !== null && compareSemver(latest, installed) > 0;
     let settings_drift = false;
-    const settingsPath = path17.join(projectDir, ".claude", "settings.json");
-    const baseSettingsPath = path17.join(
+    const settingsPath = path19.join(projectDir, ".claude", "settings.json");
+    const baseSettingsPath = path19.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const hooksJsonPath = path17.join(templatesDir, "hooks", "hooks.json");
+    const hooksJsonPath = path19.join(templatesDir, "hooks", "hooks.json");
     if (fs14.existsSync(settingsPath)) {
       try {
         const settingsRaw = fs14.readFileSync(settingsPath, "utf8");
@@ -38029,10 +38502,10 @@ function emitResult(result, writeCache, quiet, projectDir) {
   const json = JSON.stringify(result, null, 2);
   if (writeCache) {
     try {
-      const cacheDir = path17.join(projectDir, ".codebyplan");
+      const cacheDir = path19.join(projectDir, ".codebyplan");
       fs14.mkdirSync(cacheDir, { recursive: true });
       fs14.writeFileSync(
-        path17.join(cacheDir, "claude-status.local.json"),
+        path19.join(cacheDir, "claude-status.local.json"),
         json + "\n",
         "utf8"
       );
@@ -38176,7 +38649,7 @@ __export(update_exports, {
 });
 import * as fs15 from "node:fs";
 import * as os3 from "node:os";
-import * as path18 from "node:path";
+import * as path20 from "node:path";
 async function runUpdate(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -38212,9 +38685,9 @@ async function runUpdate(opts, deps = {}) {
       finalManifestEntries.push(e);
     }
     for (const { packaged, absSrc } of plan.overwriteSafe) {
-      const absDest = path18.join(projectDir, ".claude", packaged.dest);
+      const absDest = path20.join(projectDir, ".claude", packaged.dest);
       if (!opts.dryRun) {
-        fs15.mkdirSync(path18.dirname(absDest), { recursive: true });
+        fs15.mkdirSync(path20.dirname(absDest), { recursive: true });
         fs15.copyFileSync(absSrc, absDest);
         if (opts.verbose) console.log(`updated ${packaged.dest}`);
       } else if (opts.verbose) {
@@ -38227,7 +38700,7 @@ async function runUpdate(opts, deps = {}) {
       absSrc,
       onDiskContent
     } of plan.overwriteHandEdited) {
-      const absDest = path18.join(projectDir, ".claude", packaged.dest);
+      const absDest = path20.join(projectDir, ".claude", packaged.dest);
       const newContent = fs15.readFileSync(absSrc);
       const showDiff = () => {
         console.log(
@@ -38240,7 +38713,7 @@ async function runUpdate(opts, deps = {}) {
       const answer = await promptOverwrite(packaged.dest, opts, showDiff);
       if (answer === "overwrite") {
         if (!opts.dryRun) {
-          fs15.mkdirSync(path18.dirname(absDest), { recursive: true });
+          fs15.mkdirSync(path20.dirname(absDest), { recursive: true });
           fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
@@ -38256,9 +38729,9 @@ async function runUpdate(opts, deps = {}) {
     for (const { packaged, absSrc } of plan.newOptIn) {
       const answer = await promptOptIn(packaged.dest, opts);
       if (answer === "opt-in") {
-        const absDest = path18.join(projectDir, ".claude", packaged.dest);
+        const absDest = path20.join(projectDir, ".claude", packaged.dest);
         if (!opts.dryRun) {
-          fs15.mkdirSync(path18.dirname(absDest), { recursive: true });
+          fs15.mkdirSync(path20.dirname(absDest), { recursive: true });
           fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
@@ -38270,25 +38743,25 @@ async function runUpdate(opts, deps = {}) {
     for (const e of plan.removedFromPackage) {
       const answer = await promptRemove(e.dest, opts);
       if (answer === "remove") {
-        const absDest = path18.join(projectDir, ".claude", e.dest);
+        const absDest = path20.join(projectDir, ".claude", e.dest);
         if (!opts.dryRun && fs15.existsSync(absDest)) {
           fs15.rmSync(absDest);
-          const claudeDir = path18.join(projectDir, ".claude");
-          let cur = path18.dirname(absDest);
-          while (cur !== claudeDir && cur !== path18.dirname(cur)) {
-            if (path18.dirname(cur) === claudeDir) break;
+          const claudeDir = path20.join(projectDir, ".claude");
+          let cur = path20.dirname(absDest);
+          while (cur !== claudeDir && cur !== path20.dirname(cur)) {
+            if (path20.dirname(cur) === claudeDir) break;
             try {
               fs15.rmdirSync(cur);
               if (opts.verbose)
                 console.log(
-                  `pruned empty dir ${path18.relative(claudeDir, cur)}`
+                  `pruned empty dir ${path20.relative(claudeDir, cur)}`
                 );
-              cur = path18.dirname(cur);
+              cur = path20.dirname(cur);
             } catch (err) {
               const code = err.code;
               if (code !== "ENOTEMPTY" && code !== "ENOENT") {
                 console.warn(
-                  `codebyplan claude: could not prune empty dir ${path18.relative(claudeDir, cur)}: ${err.message}`
+                  `codebyplan claude: could not prune empty dir ${path20.relative(claudeDir, cur)}: ${err.message}`
                 );
               }
               break;
@@ -38300,12 +38773,12 @@ async function runUpdate(opts, deps = {}) {
         if (opts.verbose) console.log(`kept (untracked) ${e.dest}`);
       }
     }
-    const hooksJsonPath = path18.join(templatesDir, "hooks", "hooks.json");
-    const baseSettingsPath = path18.join(
+    const hooksJsonPath = path20.join(templatesDir, "hooks", "hooks.json");
+    const baseSettingsPath = path20.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const settingsPath = path18.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path20.join(projectDir, ".claude", "settings.json");
     const existingSettings = fs15.existsSync(settingsPath) ? JSON.parse(fs15.readFileSync(settingsPath, "utf8")) : {};
     if (fs15.existsSync(baseSettingsPath)) {
       const base = JSON.parse(
@@ -38332,7 +38805,7 @@ async function runUpdate(opts, deps = {}) {
       deps.detectHealDeps
     );
     if (!opts.dryRun) {
-      fs15.mkdirSync(path18.dirname(settingsPath), { recursive: true });
+      fs15.mkdirSync(path20.dirname(settingsPath), { recursive: true });
       fs15.writeFileSync(
         settingsPath,
         JSON.stringify(existingSettings, null, 2) + "\n",
@@ -38348,7 +38821,7 @@ async function runUpdate(opts, deps = {}) {
     );
     if (opts.verbose && gitignoreAction !== "unchanged") {
       console.log(
-        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path18.relative(projectDir, path18.join(projectDir, ".gitignore"))}`
+        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path20.relative(projectDir, path20.join(projectDir, ".gitignore"))}`
       );
     }
     if (!opts.dryRun) {
@@ -38388,9 +38861,9 @@ function runUpdateUser(opts, deps) {
     return;
   }
   try {
-    const userDir = deps.userDir ?? path18.join(os3.homedir(), ".claude");
-    const settingsPath = path18.join(userDir, "settings.json");
-    const userBaseSettingsPath = path18.join(
+    const userDir = deps.userDir ?? path20.join(os3.homedir(), ".claude");
+    const settingsPath = path20.join(userDir, "settings.json");
+    const userBaseSettingsPath = path20.join(
       templatesDir,
       "settings.user.base.json"
     );
@@ -38462,7 +38935,7 @@ __export(uninstall_exports, {
 });
 import * as fs16 from "node:fs";
 import * as os4 from "node:os";
-import * as path19 from "node:path";
+import * as path21 from "node:path";
 async function runUninstall(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -38491,7 +38964,7 @@ async function runUninstall(opts, deps = {}) {
     let removed = 0;
     let warnings = 0;
     for (const entry of manifest.files) {
-      const abs = path19.join(projectDir, ".claude", entry.dest);
+      const abs = path21.join(projectDir, ".claude", entry.dest);
       if (!fs16.existsSync(abs)) {
         console.warn(
           `codebyplan claude uninstall: ${entry.dest} already absent (skipping).`
@@ -38515,12 +38988,12 @@ async function runUninstall(opts, deps = {}) {
     if (!opts.dryRun) {
       pruneEmptyManagedDirs(projectDir);
     }
-    const settingsPath = path19.join(projectDir, ".claude", "settings.json");
+    const settingsPath = path21.join(projectDir, ".claude", "settings.json");
     if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
         fs16.readFileSync(settingsPath, "utf8")
       );
-      const baseSettingsPath = templatesDir ? path19.join(templatesDir, "settings.project.base.json") : null;
+      const baseSettingsPath = templatesDir ? path21.join(templatesDir, "settings.project.base.json") : null;
       if (baseSettingsPath && fs16.existsSync(baseSettingsPath)) {
         const base = JSON.parse(
           fs16.readFileSync(baseSettingsPath, "utf8")
@@ -38578,7 +39051,7 @@ function runUninstallUser(opts, deps) {
     }
   }
   try {
-    const userDir = deps.userDir ?? path19.join(os4.homedir(), ".claude");
+    const userDir = deps.userDir ?? path21.join(os4.homedir(), ".claude");
     const existingManifest = readManifestForScope("user", userDir);
     if (!existingManifest) {
       console.error(
@@ -38587,12 +39060,12 @@ function runUninstallUser(opts, deps) {
       process.exitCode = 1;
       return;
     }
-    const settingsPath = path19.join(userDir, "settings.json");
+    const settingsPath = path21.join(userDir, "settings.json");
     if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
         fs16.readFileSync(settingsPath, "utf8")
       );
-      const userBaseSettingsPath = templatesDir != null ? path19.join(templatesDir, "settings.user.base.json") : null;
+      const userBaseSettingsPath = templatesDir != null ? path21.join(templatesDir, "settings.user.base.json") : null;
       if (userBaseSettingsPath && fs16.existsSync(userBaseSettingsPath)) {
         const userBase = JSON.parse(
           fs16.readFileSync(userBaseSettingsPath, "utf8")
@@ -38633,7 +39106,7 @@ function runUninstallUser(opts, deps) {
 function pruneEmptyManagedDirs(projectDir) {
   const managedRoots = ["skills", "agents", "hooks", "rules"];
   for (const root of managedRoots) {
-    const abs = path19.join(projectDir, ".claude", root);
+    const abs = path21.join(projectDir, ".claude", root);
     if (!fs16.existsSync(abs)) continue;
     pruneLeafFirst(abs);
   }
@@ -38644,7 +39117,7 @@ function pruneLeafFirst(dir) {
   if (!stat2.isDirectory()) return;
   for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      pruneLeafFirst(path19.join(dir, entry.name));
+      pruneLeafFirst(path21.join(dir, entry.name));
     }
   }
   const remaining = fs16.readdirSync(dir);
@@ -38665,7 +39138,7 @@ var init_uninstall = __esm({
 
 // src/lib/verify-parity.ts
 import * as fs17 from "node:fs";
-import * as path20 from "node:path";
+import * as path22 from "node:path";
 function isValidScope(s) {
   return s === "org-shared" || s === "project-shared" || REPO_ONLY_RE.test(s);
 }
@@ -38682,25 +39155,25 @@ function checkSiblingParity(opts) {
     expectedOneSided = DEFAULT_EXPECTED_ONE_SIDED,
     ignoredSubtrees
   } = opts;
-  const defaultIgnored = [path20.join(claudeDir, "hooks", "__test-fixtures__")];
+  const defaultIgnored = [path22.join(claudeDir, "hooks", "__test-fixtures__")];
   const ignored = ignoredSubtrees ?? defaultIgnored;
   const violations = [];
   const claudeSideRels = /* @__PURE__ */ new Set();
   for (const scanDir of SCAN_DIRS) {
-    const baseDir = path20.join(claudeDir, scanDir);
+    const baseDir = path22.join(claudeDir, scanDir);
     if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path20.join(baseDir, entry);
+      const absPath = path22.join(baseDir, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (ignored.some(
-        (ig) => absPath.startsWith(ig + path20.sep) || absPath === ig
+        (ig) => absPath.startsWith(ig + path22.sep) || absPath === ig
       )) {
         continue;
       }
-      const relPath = path20.join(scanDir, entry).split(path20.sep).join("/");
+      const relPath = path22.join(scanDir, entry).split(path22.sep).join("/");
       claudeSideRels.add(relPath);
-      const templatePath = path20.join(templatesDir, relPath);
+      const templatePath = path22.join(templatesDir, relPath);
       if (!fs17.existsSync(templatePath)) {
         if (!expectedOneSided.has(relPath) && !isScaffoldFile(entry)) {
           violations.push({ type: "missing-twin", path: relPath });
@@ -38715,14 +39188,14 @@ function checkSiblingParity(opts) {
     }
   }
   for (const scanDir of SCAN_DIRS) {
-    const tplBase = path20.join(templatesDir, scanDir);
+    const tplBase = path22.join(templatesDir, scanDir);
     if (!fs17.existsSync(tplBase)) continue;
     const entries = readdirRecursive(tplBase);
     for (const entry of entries) {
-      const absPath = path20.join(tplBase, entry);
+      const absPath = path22.join(tplBase, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (isScaffoldFile(entry)) continue;
-      const relPath = path20.join(scanDir, entry).split(path20.sep).join("/");
+      const relPath = path22.join(scanDir, entry).split(path22.sep).join("/");
       if (!claudeSideRels.has(relPath) && !expectedOneSided.has(relPath)) {
         violations.push({ type: "extra-twin", path: relPath });
       }
@@ -38758,18 +39231,18 @@ function checkScopeMarkers(opts) {
   const twinDetectionActive = templatesDir != null && fs17.existsSync(templatesDir);
   const violations = [];
   for (const scanDir of scanDirs) {
-    const baseDir = path20.join(claudeDir, scanDir);
+    const baseDir = path22.join(claudeDir, scanDir);
     if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path20.join(baseDir, entry);
+      const absPath = path22.join(baseDir, entry);
       if (!fs17.lstatSync(absPath).isFile()) continue;
       if (!isStructuralEntry(scanDir, entry)) continue;
-      const ext = path20.extname(entry).toLowerCase();
+      const ext = path22.extname(entry).toLowerCase();
       const isMd = ext === ".md";
       const isSh = ext === ".sh";
       if (!isMd && !isSh) continue;
-      const relPath = path20.join(scanDir, entry).split(path20.sep).join("/");
+      const relPath = path22.join(scanDir, entry).split(path22.sep).join("/");
       if (allowlist.has(relPath)) continue;
       let content;
       try {
@@ -38783,7 +39256,7 @@ function checkScopeMarkers(opts) {
         continue;
       }
       const scopeValue = isMd ? extractFrontmatterScope(content) : extractShScope(content);
-      const managed = twinDetectionActive && fs17.existsSync(path20.join(templatesDir, relPath));
+      const managed = twinDetectionActive && fs17.existsSync(path22.join(templatesDir, relPath));
       if (managed) {
         if (scopeValue === null) {
         } else if (scopeValue === "org-shared") {
@@ -38837,7 +39310,7 @@ function readdirRecursive(dir, rel = "", visited = /* @__PURE__ */ new Set()) {
   visited.add(realDir);
   const results = [];
   for (const name of fs17.readdirSync(dir)) {
-    const full = path20.join(dir, name);
+    const full = path22.join(dir, name);
     const relName = rel ? `${rel}/${name}` : name;
     if (fs17.lstatSync(full).isDirectory()) {
       results.push(...readdirRecursive(full, relName, visited));
@@ -38910,12 +39383,12 @@ __export(verify_parity_exports, {
   verifyParity: () => verifyParity
 });
 import * as fs18 from "node:fs";
-import * as path21 from "node:path";
+import * as path23 from "node:path";
 function verifyParity(args, deps = {}) {
   const warnOnly = args.includes("--warn-only");
   const jsonMode = args.includes("--json");
   const projectDir = deps.cwd ?? process.cwd();
-  const claudeDir = path21.join(projectDir, ".claude");
+  const claudeDir = path23.join(projectDir, ".claude");
   if (!fs18.existsSync(claudeDir)) {
     const msg = "codebyplan claude verify-parity: .claude/ not found in cwd \u2014 run from the project root.\n";
     process.stderr.write(msg);
@@ -39422,11 +39895,11 @@ var generate_exports = {};
 __export(generate_exports, {
   runGenerate: () => runGenerate
 });
-import { readFile as readFile26, mkdir as mkdir11, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join48, resolve as resolve12 } from "node:path";
+import { readFile as readFile27, mkdir as mkdir12, writeFile as writeFile20 } from "node:fs/promises";
+import { join as join51, resolve as resolve12 } from "node:path";
 async function readJsonFile4(filePath) {
   try {
-    const raw = await readFile26(filePath, "utf-8");
+    const raw = await readFile27(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -39434,7 +39907,7 @@ async function readJsonFile4(filePath) {
 }
 async function readPkgName(absPath) {
   try {
-    const raw = await readFile26(join48(absPath, "package.json"), "utf-8");
+    const raw = await readFile27(join51(absPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
@@ -39448,7 +39921,7 @@ async function runGenerate(opts) {
   const rootDir = resolve12(projectDir);
   let packageManager;
   try {
-    const raw = await readFile26(join48(rootDir, "package.json"), "utf-8");
+    const raw = await readFile27(join51(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.packageManager === "string") {
       packageManager = pkg.packageManager;
@@ -39456,7 +39929,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 ?? []) {
@@ -39469,7 +39942,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,
@@ -39478,7 +39951,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 ?? {};
@@ -39549,10 +40022,10 @@ 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 readFile26(agentsMdPath2, "utf-8");
+      existingAgents = await readFile27(agentsMdPath2, "utf-8");
     } catch {
       existingAgents = null;
     }
@@ -39588,16 +40061,16 @@ async function runGenerate(opts) {
     process.stdout.write(agentsContent);
     return;
   }
-  const outputDir = join48(rootDir, ".claude", "generated");
-  await mkdir11(outputDir, { recursive: true });
-  const outputPath = join48(outputDir, "structure.md");
-  await writeFile19(outputPath, structureMdContent, "utf-8");
+  const outputDir = join51(rootDir, ".claude", "generated");
+  await mkdir12(outputDir, { recursive: true });
+  const outputPath = join51(outputDir, "structure.md");
+  await writeFile20(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 readFile26(agentsMdPath, "utf-8");
+    existingAgentsContent = await readFile27(agentsMdPath, "utf-8");
   } catch {
     existingAgentsContent = null;
   }
@@ -39605,7 +40078,7 @@ async function runGenerate(opts) {
     process.stdout.write(`Up to date: AGENTS.md
 `);
   } else {
-    await writeFile19(agentsMdPath, agentsContent, "utf-8");
+    await writeFile20(agentsMdPath, agentsContent, "utf-8");
     process.stdout.write(`Wrote: AGENTS.md
 `);
   }
@@ -39625,11 +40098,11 @@ __export(readme_exports, {
   runReadme: () => runReadme,
   runReadmeCommand: () => runReadmeCommand
 });
-import { readFile as readFile27, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join49, resolve as resolve13, relative as relative9 } from "node:path";
+import { readFile as readFile28, writeFile as writeFile21 } from "node:fs/promises";
+import { join as join52, resolve as resolve13, relative as relative9 } from "node:path";
 async function readJsonFile5(filePath) {
   try {
-    const raw = await readFile27(filePath, "utf-8");
+    const raw = await readFile28(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -39698,7 +40171,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({
@@ -39724,7 +40197,7 @@ async function runReadme(opts) {
   const init = opts.init ?? opts["init"] ?? false;
   const rootDir = resolve13(projectDir);
   const rootPkgJson = await readJsonFile5(
-    join49(rootDir, "package.json")
+    join52(rootDir, "package.json")
   );
   const { units, allPackages, pkgJsonByPath } = await discoverUnits(
     rootDir,
@@ -39733,11 +40206,11 @@ 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 readFile27(readmePath, "utf-8");
+      existingContent = await readFile28(readmePath, "utf-8");
     } catch {
       existingContent = null;
     }
@@ -39772,7 +40245,7 @@ ${newContent}
 `
         );
       } else {
-        await writeFile20(readmePath, newContent, "utf-8");
+        await writeFile21(readmePath, newContent, "utf-8");
         process.stdout.write(`Wrote (scaffold): ${relPath}
 `);
       }
@@ -39810,7 +40283,7 @@ ${newContent}
 `
         );
       } else {
-        await writeFile20(readmePath, newContent, "utf-8");
+        await writeFile21(readmePath, newContent, "utf-8");
         process.stdout.write(`Wrote (refresh): ${relPath}
 `);
       }
@@ -39829,7 +40302,7 @@ ${newContent}
 `
           );
         } else {
-          await writeFile20(readmePath, newContent, "utf-8");
+          await writeFile21(readmePath, newContent, "utf-8");
           process.stdout.write(`Wrote (init): ${relPath}
 `);
         }
@@ -39917,15 +40390,15 @@ __export(migrate_memory_exports, {
   runMigrateMemory: () => runMigrateMemory
 });
 import {
-  readFile as readFile28,
-  writeFile as writeFile21,
-  mkdir as mkdir12,
-  unlink as unlink6,
+  readFile as readFile29,
+  writeFile as writeFile22,
+  mkdir as mkdir13,
+  unlink as unlink7,
   rmdir,
-  readdir as readdir8
+  readdir as readdir9
 } from "node:fs/promises";
 import { existsSync as existsSync20 } from "node:fs";
-import { join as join50, resolve as resolve14, dirname as dirname14, sep as sep4 } from "node:path";
+import { join as join53, resolve as resolve14, dirname as dirname15, sep as sep4 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function encodeProjectPath(absPath) {
   return resolve14(absPath).replace(/[/\\]/g, "-");
@@ -39936,7 +40409,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");
@@ -39995,17 +40468,17 @@ function parseFrontmatter(content) {
 async function inventoryFiles(dir) {
   let filenames;
   try {
-    const entries = await readdir8(dir);
+    const entries = await readdir9(dir);
     filenames = entries.filter((f) => f.endsWith(".md") && f !== "MEMORY.md").sort();
   } catch {
     return [];
   }
   const results = [];
   for (const filename of filenames) {
-    const sourcePath = join50(dir, filename);
+    const sourcePath = join53(dir, filename);
     let raw;
     try {
-      raw = await readFile28(sourcePath, "utf-8");
+      raw = await readFile29(sourcePath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       results.push({
@@ -40091,8 +40564,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 = resolve14(join50(projectDir, relPath));
-    const targetFile = join50(targetDir, "CLAUDE.md");
+    const targetDir = resolve14(join53(projectDir, relPath));
+    const targetFile = join53(targetDir, "CLAUDE.md");
     if (!targetDir.startsWith(resolve14(projectDir) + sep4)) {
       process.stderr.write(
         `migrate-memory: skipping unsafe suggested_target "${entry.suggested_target}" \u2014 resolves outside projectDir
@@ -40121,18 +40594,18 @@ ${anchor}
       }
       continue;
     }
-    await mkdir12(targetDir, { recursive: true });
+    await mkdir13(targetDir, { recursive: true });
     let existing = "";
     try {
-      existing = await readFile28(targetFile, "utf-8");
+      existing = await readFile29(targetFile, "utf-8");
     } catch {
     }
     if (!existing.includes(anchor)) {
-      await writeFile21(targetFile, existing + appendContent, "utf-8");
+      await writeFile22(targetFile, existing + appendContent, "utf-8");
     }
     if (resolve14(entry.source_path).startsWith(resolve14(plan.auto_memory_dir) + sep4)) {
       try {
-        await unlink6(entry.source_path);
+        await unlink7(entry.source_path);
       } catch {
       }
     } else {
@@ -40142,7 +40615,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}
@@ -40151,12 +40624,12 @@ ${anchor}
   } else {
     let claudeMdContent = "";
     try {
-      claudeMdContent = await readFile28(rootClaudeMd, "utf-8");
+      claudeMdContent = await readFile29(rootClaudeMd, "utf-8");
     } catch {
-      await mkdir12(dirname14(rootClaudeMd), { recursive: true });
+      await mkdir13(dirname15(rootClaudeMd), { recursive: true });
     }
     if (!claudeMdContent.includes(IMPORT_LINE)) {
-      await writeFile21(
+      await writeFile22(
         rootClaudeMd,
         claudeMdContent + `
 ${IMPORT_LINE}
@@ -40182,19 +40655,19 @@ ${IMPORT_LINE}
       continue;
     }
     try {
-      await unlink6(entry.source_path);
+      await unlink7(entry.source_path);
     } 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}
 `);
   } else {
     if (resolve14(plan.auto_memory_dir).startsWith(safeRmdirBase + sep4)) {
       try {
-        await unlink6(memoryMd);
+        await unlink7(memoryMd);
       } catch {
       }
     } else {
@@ -40217,7 +40690,7 @@ ${IMPORT_LINE}
       );
     } else {
       try {
-        const remaining = await readdir8(plan.auto_memory_dir);
+        const remaining = await readdir9(plan.auto_memory_dir);
         if (remaining.length === 0) {
           await rmdir(plan.auto_memory_dir);
         }
@@ -40240,7 +40713,7 @@ async function runMigrateMemory(opts) {
   if (applyFile) {
     let planJson;
     try {
-      planJson = await readFile28(resolve14(applyFile), "utf-8");
+      planJson = await readFile29(resolve14(applyFile), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(
@@ -40311,7 +40784,7 @@ var init_migrate_memory = __esm({
 
 // src/lib/claude-mode-audit.ts
 import { readdirSync as readdirSync6, readFileSync as readFileSync19, existsSync as existsSync21 } from "node:fs";
-import { join as join51, basename as basename3 } from "node:path";
+import { join as join54, basename as basename4 } from "node:path";
 function parseFrontmatter2(content) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
   if (!match) return {};
@@ -40331,7 +40804,7 @@ function parseFrontmatter2(content) {
 function auditAgent(filePath) {
   const content = readFileSync19(filePath, "utf-8");
   const fm = parseFrontmatter2(content);
-  const agentName = fm.name ?? basename3(filePath, ".md");
+  const agentName = fm.name ?? basename4(filePath, ".md");
   const expected = AGENT_EXCEPTIONS[agentName] ?? AGENT_DEFAULT;
   const expectedStr = `model:${expected.model}/effort:${expected.effort}`;
   const model = fm.model ?? null;
@@ -40390,19 +40863,19 @@ function auditSkill(filePath) {
 }
 function auditMode(templatesDir) {
   const entries = [];
-  const agentsDir = join51(templatesDir, "agents");
+  const agentsDir = join54(templatesDir, "agents");
   if (existsSync21(agentsDir)) {
     const agentFiles = readdirSync6(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 (existsSync21(skillsDir)) {
     const skillDirs = readdirSync6(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
     for (const dir of skillDirs) {
-      if (existsSync21(join51(skillsDir, dir, "PROVENANCE.md"))) continue;
-      const skillMd = join51(skillsDir, dir, "SKILL.md");
+      if (existsSync21(join54(skillsDir, dir, "PROVENANCE.md"))) continue;
+      const skillMd = join54(skillsDir, dir, "SKILL.md");
       if (existsSync21(skillMd)) {
         entries.push(auditSkill(skillMd));
       }
@@ -40667,7 +41140,7 @@ __export(new_migration_exports, {
   newMigration: () => newMigration
 });
 import * as fs19 from "node:fs";
-import * as path22 from "node:path";
+import * as path24 from "node:path";
 function slugify(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
@@ -40688,9 +41161,9 @@ function newMigration(args, deps = {}) {
   }
   const slug = slugify(rawName);
   const stamp = genTimestamp({ cwd });
-  const migrationsDir = path22.join(cwd, "supabase", "migrations");
+  const migrationsDir = path24.join(cwd, "supabase", "migrations");
   const filename = `${stamp}_${slug}.sql`;
-  const filePath = path22.join(migrationsDir, filename);
+  const filePath = path24.join(migrationsDir, filename);
   mkdirSync12(migrationsDir, { recursive: true });
   writeFileSync13(filePath, "");
   process.stdout.write(JSON.stringify({ path: filePath }) + "\n");
@@ -41056,13 +41529,13 @@ function validateWaves(waves) {
       pathOwners.set(file, owners);
     }
   }
-  for (const [path23, owners] of pathOwners) {
+  for (const [path25, owners] of pathOwners) {
     if (owners.length > 1) {
       violations.push({
         invariant: "I",
         code: "DUPLICATE_FILE",
-        message: `File "${path23}" appears in multiple waves: ${owners.join(", ")}.`,
-        detail: { path: path23, waves: owners }
+        message: `File "${path25}" appears in multiple waves: ${owners.join(", ")}.`,
+        detail: { path: path25, waves: owners }
       });
     }
   }
@@ -41156,7 +41629,7 @@ var validate_waves_exports = {};
 __export(validate_waves_exports, {
   runValidateWavesCommand: () => runValidateWavesCommand
 });
-import { readFile as readFile29 } from "node:fs/promises";
+import { readFile as readFile30 } from "node:fs/promises";
 async function readStdin() {
   return new Promise((resolve17, reject) => {
     const chunks = [];
@@ -41175,7 +41648,7 @@ async function runValidateWavesCommand(args) {
   let raw;
   if (filePath) {
     try {
-      raw = await readFile29(filePath, "utf-8");
+      raw = await readFile30(filePath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(
@@ -41255,12 +41728,12 @@ var init_validate_waves2 = __esm({
 });
 
 // src/cli/worktree/path.ts
-import { dirname as dirname15, basename as basename4, join as join53 } from "node:path";
+import { dirname as dirname16, basename as basename5, join as join56 } from "node:path";
 function computeWorktreePath(cwd, checkpointNumber) {
-  const parent = dirname15(cwd);
-  const base = basename4(cwd);
+  const parent = dirname16(cwd);
+  const base = basename5(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"() {
@@ -41269,8 +41742,8 @@ var init_path = __esm({
 });
 
 // src/cli/worktree/add.ts
-import { join as join54 } from "node:path";
-import { mkdir as mkdir13, readFile as readFile30, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join57 } from "node:path";
+import { mkdir as mkdir14, readFile as readFile31, writeFile as writeFile23 } from "node:fs/promises";
 import { spawnSync as spawnSync18 } from "node:child_process";
 async function defaultGetRepoId(cwd) {
   const found = await findCodebyplanConfig(cwd);
@@ -41313,17 +41786,17 @@ function defaultGitRun(args, cwd) {
   };
 }
 async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
-  const readFileFn = deps.readFileFn ?? ((p) => readFile30(p, "utf-8"));
-  const writeFileFn = deps.writeFileFn ?? ((p, content) => writeFile22(p, content, "utf-8"));
+  const readFileFn = deps.readFileFn ?? ((p) => readFile31(p, "utf-8"));
+  const writeFileFn = deps.writeFileFn ?? ((p, content) => writeFile23(p, content, "utf-8"));
   const existsFn = deps.existsFn ?? ((p) => import("node:fs/promises").then(
     (fsp) => fsp.access(p).then(() => true).catch(() => false)
   ));
-  const mkdirFn = deps.mkdirFn ?? ((p, opts) => mkdir13(p, opts));
-  await mkdirFn(join54(destPath, ".claude"), { recursive: true });
+  const mkdirFn = deps.mkdirFn ?? ((p, opts) => mkdir14(p, opts));
+  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;
@@ -41334,22 +41807,22 @@ async function copyClaudeSettings(srcCwd, destPath, deps = {}) {
   }
 }
 async function defaultCopyConfigStubs(srcCwd, destPath) {
-  await mkdir13(join54(destPath, ".codebyplan"), { recursive: true });
+  await mkdir14(join57(destPath, ".codebyplan"), { recursive: true });
   const topLevelStubs = [".mcp.json", ".env.local"];
   for (const stub of topLevelStubs) {
     try {
-      const content = await readFile30(join54(srcCwd, stub), "utf-8");
-      await writeFile22(join54(destPath, stub), content, "utf-8");
+      const content = await readFile31(join57(srcCwd, stub), "utf-8");
+      await writeFile23(join57(destPath, stub), content, "utf-8");
     } catch {
     }
   }
   try {
-    const content = await readFile30(
-      join54(srcCwd, ".codebyplan", "repo.json"),
+    const content = await readFile31(
+      join57(srcCwd, ".codebyplan", "repo.json"),
       "utf-8"
     );
-    await writeFile22(
-      join54(destPath, ".codebyplan", "repo.json"),
+    await writeFile23(
+      join57(destPath, ".codebyplan", "repo.json"),
       content,
       "utf-8"
     );
@@ -41483,7 +41956,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;
@@ -41528,7 +42001,7 @@ async function runWorktreeCreate(args, deps = {}) {
     );
     return 1;
   }
-  const worktreePath = explicitPath ?? join55(cwd, "..", name);
+  const worktreePath = explicitPath ?? join58(cwd, "..", name);
   let filesWritten = false;
   try {
     await createWorktreeFiles(
@@ -41938,7 +42411,7 @@ var init_e2e = __esm({
 });
 
 // src/cli/e2e/verify-round.ts
-import { readFile as readFile31 } from "node:fs/promises";
+import { readFile as readFile32 } from "node:fs/promises";
 import { resolve as resolve15 } from "node:path";
 async function defaultFetchRounds(taskId) {
   return mcpCall("get_rounds", { task_id: taskId });
@@ -41946,7 +42419,7 @@ async function defaultFetchRounds(taskId) {
 async function defaultReadE2eConfig(cwd) {
   try {
     const p = resolve15(cwd, ".codebyplan", "e2e.json");
-    const raw = await readFile31(p, "utf-8");
+    const raw = await readFile32(p, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -42113,7 +42586,7 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { existsSync as existsSync22 } from "node:fs";
-import { join as join56 } from "node:path";
+import { join as join59 } from "node:path";
 import { execSync as execSync10 } from "node:child_process";
 async function checkAuth() {
   try {
@@ -42190,7 +42663,7 @@ function checkSettings() {
         detail: "codebyplan not installed (no .cbp.manifest.json)"
       };
     }
-    if (!existsSync22(join56(projectDir, ".claude", "settings.json"))) {
+    if (!existsSync22(join59(projectDir, ".claude", "settings.json"))) {
       return {
         name: "settings",
         status: "warn",
@@ -42435,6 +42908,11 @@ void (async () => {
     await runRoundCommand2(rest);
     process.exit(0);
   }
+  if (arg === "handoff") {
+    const { runHandoffCommand: runHandoffCommand2 } = await Promise.resolve().then(() => (init_handoff(), handoff_exports));
+    await runHandoffCommand2(process.argv.slice(3));
+    process.exit(process.exitCode ?? 0);
+  }
   if (arg === "branch") {
     const { runBranchCommand: runBranchCommand2 } = await Promise.resolve().then(() => (init_branch(), branch_exports));
     const rest = process.argv.slice(3);
@@ -42772,6 +43250,8 @@ void (async () => {
     codebyplan watch stop             Stop the running daemon
     codebyplan watch status           Show daemon status (--json for machine-readable)
     codebyplan watch run              Run daemon in foreground (used internally by start)
+    codebyplan handoff                Manage per-level handoff notes in .codebyplan/handoff/
+                                     (read/write/append/clear/status -- --level repo|checkpoint|task|standalone)
     codebyplan round sync-approvals   Sync git diff and approvals with round/task state
     codebyplan standalone-task        Standalone task writes via MCP (create/update/complete)
                                      (create --title; update --id; complete --id \u2014 no --checkpoint-id)