codebyplan 1.13.51 → 1.13.53

package/dist/cli.js

@@ -39,7 +39,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.51";
+    VERSION = "1.13.53";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -113,8 +113,8 @@ async function readLocalConfig(projectPath, onMigrationNotice) {
 }
 async function writeLocalConfig(projectPath, config) {
   const content = { device_id: config.device_id };
-  const path16 = localConfigPath(projectPath);
-  const dirPath = dirname(path16);
+  const path21 = localConfigPath(projectPath);
+  const dirPath = dirname(path21);
   let phase = "stat config directory";
   try {
     try {
@@ -134,7 +134,7 @@ async function writeLocalConfig(projectPath, config) {
     phase = "create config directory";
     await mkdir(dirPath, { recursive: true });
     phase = "write local config";
-    await writeFile(path16, JSON.stringify(content, null, 2) + "\n", "utf-8");
+    await writeFile(path21, JSON.stringify(content, null, 2) + "\n", "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "LEGACY_FILE_BLOCKS_DIR") {
@@ -652,8 +652,8 @@ var init_gitignore_block = __esm({
 // src/lib/worktree.ts
 import { mkdir as mkdir3, writeFile as writeFile4, readFile as readFile6 } from "node:fs/promises";
 import { join as join6 } from "node:path";
-function defaultExists(path16) {
-  return readFile6(path16, "utf-8").then(() => true).catch(() => false);
+function defaultExists(path21) {
+  return readFile6(path21, "utf-8").then(() => true).catch(() => false);
 }
 async function writeRepoJson(codebyplanDir, selectedRepo, deps) {
   const repoJson = {
@@ -774,9 +774,9 @@ var init_worktree = __esm({
     init_local_config();
     init_gitignore_block();
     defaultFsDeps = {
-      mkdir: (path16, opts) => mkdir3(path16, opts).then(() => void 0),
-      writeFile: (path16, data, encoding) => writeFile4(path16, data, encoding),
-      readFile: (path16, encoding) => readFile6(path16, encoding),
+      mkdir: (path21, opts) => mkdir3(path21, opts).then(() => void 0),
+      writeFile: (path21, data, encoding) => writeFile4(path21, data, encoding),
+      readFile: (path21, encoding) => readFile6(path21, encoding),
       exists: defaultExists
     };
   }
@@ -844,12 +844,12 @@ async function readFallback(filename) {
   }
 }
 async function writeFallback(filename, data) {
-  const path16 = fallbackFile(filename);
-  await mkdir4(dirname2(path16), { recursive: true });
-  await writeFile5(path16, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  const path21 = fallbackFile(filename);
+  await mkdir4(dirname2(path21), { recursive: true });
+  await writeFile5(path21, JSON.stringify(data, null, 2) + "\n", "utf-8");
   if (platform() !== "win32") {
     try {
-      await chmod(path16, 384);
+      await chmod(path21, 384);
     } catch {
     }
   }
@@ -1141,8 +1141,8 @@ async function validateConnectivity() {
     );
   }
 }
-function buildUrl(path16, params) {
-  const url = new URL(`${baseUrl()}/api${path16}`);
+function buildUrl(path21, params) {
+  const url = new URL(`${baseUrl()}/api${path21}`);
   if (params) {
     for (const [key, value] of Object.entries(params)) {
       if (value !== void 0) {
@@ -1159,10 +1159,10 @@ function isRetryable(err) {
   return false;
 }
 function delay(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
-async function request(method, path16, options) {
-  const url = buildUrl(path16, options?.params);
+async function request(method, path21, options) {
+  const url = buildUrl(path21, options?.params);
   const auth = await getAuthHeaders();
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -1182,7 +1182,7 @@ async function request(method, path16, options) {
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
       });
       if (!res.ok) {
-        let message = `API ${method} ${path16} failed with status ${res.status}`;
+        let message = `API ${method} ${path21} failed with status ${res.status}`;
         let code;
         try {
           const body = await res.json();
@@ -1216,20 +1216,20 @@ async function request(method, path16, options) {
   }
   throw lastError;
 }
-async function apiGet(path16, params) {
-  return request("GET", path16, { params });
+async function apiGet(path21, params) {
+  return request("GET", path21, { params });
 }
-async function apiPost(path16, body) {
-  return request("POST", path16, { body });
+async function apiPost(path21, body) {
+  return request("POST", path21, { body });
 }
-async function apiPut(path16, body) {
-  return request("PUT", path16, { body });
+async function apiPut(path21, body) {
+  return request("PUT", path21, { body });
 }
-async function apiPatch(path16, body) {
-  return request("PATCH", path16, { body });
+async function apiPatch(path21, body) {
+  return request("PATCH", path21, { body });
 }
-async function apiDelete(path16, params) {
-  await request("DELETE", path16, { params });
+async function apiDelete(path21, params) {
+  await request("DELETE", path21, { params });
 }
 async function callMcpTool(toolName, params) {
   const url = mcpEndpoint();
@@ -1523,7 +1523,7 @@ var init_device_flow = __esm({
         this.name = "OAuthInvalidClientError";
       }
     };
-    defaultSleep = (ms) => new Promise((resolve11) => setTimeout(resolve11, ms));
+    defaultSleep = (ms) => new Promise((resolve16) => setTimeout(resolve16, ms));
   }
 });
 
@@ -3411,9 +3411,9 @@ import { createInterface } from "node:readline/promises";
 function getConfigPath(scope) {
   return scope === "user" ? join14(homedir4(), ".claude.json") : join14(process.cwd(), ".mcp.json");
 }
-async function readConfig(path16) {
+async function readConfig(path21) {
   try {
-    const raw = await readFile11(path16, "utf-8");
+    const raw = await readFile11(path21, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -3844,9 +3844,9 @@ import { join as join15 } from "node:path";
 function configPaths() {
   return [join15(homedir5(), ".claude.json"), join15(process.cwd(), ".mcp.json")];
 }
-async function readConfig2(path16) {
+async function readConfig2(path21) {
   try {
-    const raw = await readFile12(path16, "utf-8");
+    const raw = await readFile12(path21, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -3860,7 +3860,7 @@ function entryHasLegacyApiKey(entry) {
   if (!entry || !entry.headers) return false;
   return "x-api-key" in entry.headers;
 }
-async function rewriteConfig(path16, config, newUrl) {
+async function rewriteConfig(path21, config, newUrl) {
   const servers = config.mcpServers;
   if (!servers) return false;
   const entry = servers.codebyplan;
@@ -3868,7 +3868,7 @@ async function rewriteConfig(path16, config, newUrl) {
   if (!entryHasLegacyApiKey(entry) && entry.url === newUrl && entry.type === "http")
     return false;
   servers.codebyplan = { type: "http", url: newUrl };
-  await writeFile9(path16, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile9(path21, JSON.stringify(config, null, 2) + "\n", "utf-8");
   return true;
 }
 async function runUpgradeAuth() {
@@ -3876,12 +3876,12 @@ async function runUpgradeAuth() {
   await runLogin();
   const newUrl = mcpEndpoint();
   let migrated = 0;
-  for (const path16 of configPaths()) {
-    const config = await readConfig2(path16);
+  for (const path21 of configPaths()) {
+    const config = await readConfig2(path21);
     if (!config) continue;
-    const changed = await rewriteConfig(path16, config, newUrl);
+    const changed = await rewriteConfig(path21, config, newUrl);
     if (changed) {
-      console.log(`  Updated ${path16}`);
+      console.log(`  Updated ${path21}`);
       migrated++;
     }
   }
@@ -4558,9 +4558,9 @@ async function eslintInit(repoId, projectPath) {
   Install ${missingPkgs.length} missing packages? [Y/n] `
     );
     if (confirmed) {
-      const { execSync: execSync10 } = await import("node:child_process");
+      const { execSync: execSync11 } = await import("node:child_process");
       try {
-        execSync10(installCmd, { cwd: projectPath, stdio: "inherit" });
+        execSync11(installCmd, { cwd: projectPath, stdio: "inherit" });
         console.log("  Packages installed.\n");
       } catch (err) {
         console.error(
@@ -5326,11 +5326,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve11) {
-      resolve11(value);
+    return value instanceof P ? value : new P(function(resolve16) {
+      resolve16(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve11, reject) {
+  return new (P || (P = Promise))(function(resolve16, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -5346,7 +5346,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve11(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve16(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -5537,14 +5537,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve11, reject) {
-        v = o[n](v), settle(resolve11, reject, v.done, v.value);
+      return new Promise(function(resolve16, reject) {
+        v = o[n](v), settle(resolve16, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve11, reject, d, v) {
+  function settle(resolve16, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve11({ value: v2, done: d });
+      resolve16({ value: v2, done: d });
     }, reject);
   }
 }
@@ -5636,13 +5636,13 @@ function __disposeResources(env) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path16, preserveJsx) {
-  if (typeof path16 === "string" && /^\.\.?\//.test(path16)) {
-    return path16.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+function __rewriteRelativeImportExtension(path21, preserveJsx) {
+  if (typeof path21 === "string" && /^\.\.?\//.test(path21)) {
+    return path21.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 path16;
+  return path21;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -6117,18 +6117,18 @@ var require_main = __commonJS({
 
 // ../../node_modules/.pnpm/@supabase+postgrest-js@2.106.0/node_modules/@supabase/postgrest-js/dist/index.mjs
 function sleep(ms, signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve16) => {
     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-      resolve11();
+      resolve16();
       return;
     }
     const id = setTimeout(() => {
       signal === null || signal === void 0 || signal.removeEventListener("abort", onAbort);
-      resolve11();
+      resolve16();
     }, ms);
     function onAbort() {
       clearTimeout(id);
-      resolve11();
+      resolve16();
     }
     signal === null || signal === void 0 || signal.addEventListener("abort", onAbort);
   });
@@ -14165,15 +14165,15 @@ var require_RealtimeChannel = __commonJS({
             }
           }
         } else {
-          return new Promise((resolve11) => {
+          return new Promise((resolve16) => {
             var _a2, _b2, _c;
             const push = this.channelAdapter.push(args.type, args, opts.timeout || this.timeout);
             if (args.type === "broadcast" && !((_c = (_b2 = (_a2 = this.params) === null || _a2 === void 0 ? void 0 : _a2.config) === null || _b2 === void 0 ? void 0 : _b2.broadcast) === null || _c === void 0 ? void 0 : _c.ack)) {
-              resolve11("ok");
+              resolve16("ok");
             }
-            push.receive("ok", () => resolve11("ok"));
-            push.receive("error", () => resolve11("error"));
-            push.receive("timeout", () => resolve11("timed out"));
+            push.receive("ok", () => resolve16("ok"));
+            push.receive("error", () => resolve16("error"));
+            push.receive("timeout", () => resolve16("timed out"));
           });
         }
       }
@@ -14198,8 +14198,8 @@ var require_RealtimeChannel = __commonJS({
        * @category Realtime
        */
       async unsubscribe(timeout = this.timeout) {
-        return new Promise((resolve11) => {
-          this.channelAdapter.unsubscribe(timeout).receive("ok", () => resolve11("ok")).receive("timeout", () => resolve11("timed out")).receive("error", () => resolve11("error"));
+        return new Promise((resolve16) => {
+          this.channelAdapter.unsubscribe(timeout).receive("ok", () => resolve16("ok")).receive("timeout", () => resolve16("timed out")).receive("error", () => resolve16("error"));
         });
       }
       /**
@@ -14280,8 +14280,8 @@ var require_RealtimeChannel = __commonJS({
       }
       /** @internal */
       _notThisChannelEvent(event, ref) {
-        const { close, error, leave, join: join48 } = constants_1.CHANNEL_EVENTS;
-        const events = [close, error, leave, join48];
+        const { close, error, leave, join: join53 } = constants_1.CHANNEL_EVENTS;
+        const events = [close, error, leave, join53];
         return ref && events.includes(event) && ref !== this.joinPush.ref;
       }
       /** @internal */
@@ -14403,11 +14403,11 @@ var require_socketAdapter = __commonJS({
         this.socket.connect();
       }
       disconnect(callback, code, reason, timeout = 1e4) {
-        return new Promise((resolve11) => {
-          setTimeout(() => resolve11("timeout"), timeout);
+        return new Promise((resolve16) => {
+          setTimeout(() => resolve16("timeout"), timeout);
           this.socket.disconnect(() => {
             callback();
-            resolve11("ok");
+            resolve16("ok");
           }, code, reason);
         });
       }
@@ -15164,8 +15164,8 @@ var require_main2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/iceberg-js@0.8.1/node_modules/iceberg-js/dist/index.mjs
-function buildUrl2(baseUrl3, path16, query) {
-  const url = new URL(path16, baseUrl3);
+function buildUrl2(baseUrl3, path21, query) {
+  const url = new URL(path21, baseUrl3);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) {
@@ -15195,12 +15195,12 @@ function createFetchClient(options) {
   return {
     async request({
       method,
-      path: path16,
+      path: path21,
       query,
       body,
       headers
     }) {
-      const url = buildUrl2(options.baseUrl, path16, query);
+      const url = buildUrl2(options.baseUrl, path21, query);
       const authHeaders = await buildAuthHeaders(options.auth);
       const res = await fetchFn(url, {
         method,
@@ -15769,7 +15769,7 @@ function normalizeHeaders(headers) {
   return result;
 }
 async function _handleRequest(fetcher, method, url, options, parameters, body, namespace) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve16, reject) => {
     fetcher(url, _getRequestParams(method, options, parameters, body)).then((result) => {
       if (!result.ok) throw result;
       if (options === null || options === void 0 ? void 0 : options.noResolveJson) return result;
@@ -15779,7 +15779,7 @@ async function _handleRequest(fetcher, method, url, options, parameters, body, n
         if (!contentType || !contentType.includes("application/json")) return {};
       }
       return result.json();
-    }).then((data) => resolve11(data)).catch((error) => handleError(error, reject, options, namespace));
+    }).then((data) => resolve16(data)).catch((error) => handleError(error, reject, options, namespace));
   });
 }
 function createFetchApi(namespace = "storage") {
@@ -16098,7 +16098,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, path16, fileBody, fileOptions) {
+      async uploadOrUpdate(method, path21, fileBody, fileOptions) {
         var _this = this;
         return _this.handleOperation(async () => {
           let body;
@@ -16122,7 +16122,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(path16);
+          const cleanPath = _this._removeEmptyFolders(path21);
           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 {
@@ -16184,8 +16184,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(path16, fileBody, fileOptions) {
-        return this.uploadOrUpdate("POST", path16, fileBody, fileOptions);
+      async upload(path21, fileBody, fileOptions) {
+        return this.uploadOrUpdate("POST", path21, fileBody, fileOptions);
       }
       /**
       * Upload a file with a token generated from `createSignedUploadUrl`.
@@ -16225,9 +16225,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(path16, token, fileBody, fileOptions) {
+      async uploadToSignedUrl(path21, token, fileBody, fileOptions) {
         var _this3 = this;
-        const cleanPath = _this3._removeEmptyFolders(path16);
+        const cleanPath = _this3._removeEmptyFolders(path21);
         const _path = _this3._getFinalPath(cleanPath);
         const url = new URL(_this3.url + `/object/upload/sign/${_path}`);
         url.searchParams.set("token", token);
@@ -16296,10 +16296,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(path16, options) {
+      async createSignedUploadUrl(path21, options) {
         var _this4 = this;
         return _this4.handleOperation(async () => {
-          let _path = _this4._getFinalPath(path16);
+          let _path = _this4._getFinalPath(path21);
           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 });
@@ -16308,7 +16308,7 @@ var init_dist3 = __esm({
           if (!token) throw new StorageError("No token returned by API");
           return {
             signedUrl: url.toString(),
-            path: path16,
+            path: path21,
             token
           };
         });
@@ -16368,8 +16368,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(path16, fileBody, fileOptions) {
-        return this.uploadOrUpdate("PUT", path16, fileBody, fileOptions);
+      async update(path21, fileBody, fileOptions) {
+        return this.uploadOrUpdate("PUT", path21, fileBody, fileOptions);
       }
       /**
       * Moves an existing file to a new path in the same bucket.
@@ -16520,10 +16520,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(path16, expiresIn, options) {
+      async createSignedUrl(path21, expiresIn, options) {
         var _this8 = this;
         return _this8.handleOperation(async () => {
-          let _path = _this8._getFinalPath(path16);
+          let _path = _this8._getFinalPath(path21);
           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();
@@ -16659,13 +16659,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(path16, options, parameters) {
+      download(path21, 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(path16);
+        const _path = this._getFinalPath(path21);
         const downloadFn = () => get(this.fetch, `${this.url}/${renderPath}/${_path}${queryString ? `?${queryString}` : ""}`, {
           headers: this.headers,
           noResolveJson: true
@@ -16696,9 +16696,9 @@ var init_dist3 = __esm({
       * }
       * ```
       */
-      async info(path16) {
+      async info(path21) {
         var _this10 = this;
-        const _path = _this10._getFinalPath(path16);
+        const _path = _this10._getFinalPath(path21);
         return _this10.handleOperation(async () => {
           return recursiveToCamel(await get(_this10.fetch, `${_this10.url}/object/info/${_path}`, { headers: _this10.headers }));
         });
@@ -16719,9 +16719,9 @@ var init_dist3 = __esm({
       *   .exists('folder/avatar1.png')
       * ```
       */
-      async exists(path16) {
+      async exists(path21) {
         var _this11 = this;
-        const _path = _this11._getFinalPath(path16);
+        const _path = _this11._getFinalPath(path21);
         try {
           await head(_this11.fetch, `${_this11.url}/object/${_path}`, { headers: _this11.headers });
           return {
@@ -16800,8 +16800,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(path16, options) {
-        const _path = this._getFinalPath(path16);
+      getPublicUrl(path21, options) {
+        const _path = this._getFinalPath(path21);
         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);
@@ -16940,10 +16940,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(path16, options, parameters) {
+      async list(path21, options, parameters) {
         var _this13 = this;
         return _this13.handleOperation(async () => {
-          const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path16 || "" });
+          const body = _objectSpread22(_objectSpread22(_objectSpread22({}, DEFAULT_SEARCH_OPTIONS), options), {}, { prefix: path21 || "" });
           return await post(_this13.fetch, `${_this13.url}/object/list/${_this13.bucketId}`, body, { headers: _this13.headers }, parameters);
         });
       }
@@ -17008,11 +17008,11 @@ var init_dist3 = __esm({
         if (typeof Buffer !== "undefined") return Buffer.from(data).toString("base64");
         return btoa(data);
       }
-      _getFinalPath(path16) {
-        return `${this.bucketId}/${path16.replace(/^\/+/, "")}`;
+      _getFinalPath(path21) {
+        return `${this.bucketId}/${path21.replace(/^\/+/, "")}`;
       }
-      _removeEmptyFolders(path16) {
-        return path16.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
+      _removeEmptyFolders(path21) {
+        return path21.replace(/^\/|\/$/g, "").replace(/\/+/g, "/");
       }
       /** Modifies the `query`, appending values the from `transform` */
       applyTransformOptsToQuery(query, transform) {
@@ -26390,11 +26390,11 @@ __export(dist_exports, {
 });
 function __awaiter2(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve11) {
-      resolve11(value);
+    return value instanceof P ? value : new P(function(resolve16) {
+      resolve16(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve11, reject) {
+  return new (P || (P = Promise))(function(resolve16, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -26410,7 +26410,7 @@ function __awaiter2(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve11(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve16(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -27145,8 +27145,8 @@ var init_watch_daemon = __esm({
           );
         }
         this.startSafetyPoll(repoRoot, repoId, worktreeId);
-        await new Promise((resolve11) => {
-          this.stopResolve = resolve11;
+        await new Promise((resolve16) => {
+          this.stopResolve = resolve16;
         });
       }
       /**
@@ -27417,7 +27417,7 @@ var init_watch_daemon = __esm({
       }
       /** Sleep for `ms` milliseconds — uses setTimeout so fake timers work in tests. */
       sleep(ms) {
-        return new Promise((resolve11) => setTimeout(resolve11, ms));
+        return new Promise((resolve16) => setTimeout(resolve16, ms));
       }
     };
   }
@@ -27731,8 +27731,8 @@ var init_watch = __esm({
 });
 
 // src/lib/state-client.ts
-async function backendRequest(method, path16, body) {
-  const url = `${getBackendBase()}${path16}`;
+async function backendRequest(method, path21, body) {
+  const url = `${getBackendBase()}${path21}`;
   const auth = await getAuthHeaders();
   const res = await fetch(url, {
     method,
@@ -27744,7 +27744,7 @@ async function backendRequest(method, path16, body) {
     signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
   });
   if (!res.ok) {
-    let message = `Backend ${method} ${path16} failed with status ${res.status}`;
+    let message = `Backend ${method} ${path21} 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;
@@ -27758,11 +27758,11 @@ async function backendRequest(method, path16, body) {
   }
   return res.json();
 }
-async function apiBackendPost(path16, body) {
-  return backendRequest("POST", path16, body);
+async function apiBackendPost(path21, body) {
+  return backendRequest("POST", path21, body);
 }
-async function apiBackendPatch(path16, body) {
-  return backendRequest("PATCH", path16, body);
+async function apiBackendPatch(path21, body) {
+  return backendRequest("PATCH", path21, body);
 }
 var REQUEST_TIMEOUT_MS2, BackendError;
 var init_state_client = __esm({
@@ -28766,7 +28766,7 @@ function setRetryDelayMs(ms) {
   RETRY_DELAY_MS = ms;
 }
 function sleep2(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function isTransientMcpError(err) {
   if (!(err instanceof McpError)) return false;
@@ -29610,7 +29610,7 @@ function generateMonotonicTimestamp(opts = {}) {
 }
 async function pollGhPreviewCheck(opts = {}) {
   const run = opts.run ?? defaultRun;
-  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, ms)));
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve16) => setTimeout(resolve16, ms)));
   const maxPolls = opts.maxPolls ?? 20;
   const intervalMs = opts.intervalMs ?? 15e3;
   if (!opts.prNumber) {
@@ -30956,6 +30956,1321 @@ var init_scaffold_publish_workflow2 = __esm({
   }
 });
 
+// src/lib/atomic-write.ts
+import * as fs7 from "node:fs";
+function writeJsonAtomic(filePath, value) {
+  const tmpPath = filePath + ".tmp";
+  try {
+    fs7.writeFileSync(tmpPath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+    fs7.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try {
+      fs7.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+var init_atomic_write = __esm({
+  "src/lib/atomic-write.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/ci-init.ts
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
+function tryReadJson(filePath) {
+  try {
+    return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function hasDep(pkg, name) {
+  if (!pkg) return false;
+  const deps = pkg["dependencies"];
+  const devDeps = pkg["devDependencies"];
+  return Boolean(deps?.[name] ?? devDeps?.[name]);
+}
+function hasDevDep(pkg, name) {
+  if (!pkg) return false;
+  const devDeps = pkg["devDependencies"];
+  return Boolean(devDeps?.[name]);
+}
+function detectPlatforms(projectDir) {
+  const detected = /* @__PURE__ */ new Set();
+  const dirsToScan = [projectDir];
+  const appsDir = path8.join(projectDir, "apps");
+  if (fs8.existsSync(appsDir)) {
+    try {
+      const appsEntries = fs8.readdirSync(appsDir, { withFileTypes: true });
+      for (const entry of appsEntries) {
+        if (entry.isDirectory()) {
+          dirsToScan.push(path8.join(appsDir, entry.name));
+        }
+      }
+    } catch {
+    }
+  }
+  for (const dir of dirsToScan) {
+    const pkg = tryReadJson(path8.join(dir, "package.json"));
+    if (fs8.existsSync(path8.join(dir, "next.config.ts")) || fs8.existsSync(path8.join(dir, "next.config.js")) || fs8.existsSync(path8.join(dir, "next.config.mjs"))) {
+      detected.add("next_js");
+    }
+    if (hasDep(pkg, "@nestjs/core")) {
+      detected.add("nestjs");
+    }
+    if (fs8.existsSync(path8.join(dir, "tauri.conf.json")) || fs8.existsSync(path8.join(dir, "src-tauri"))) {
+      detected.add("tauri");
+    }
+    if (hasDevDep(pkg, "@types/vscode")) {
+      detected.add("vscode");
+    }
+    const deps = pkg?.["dependencies"];
+    if (deps?.["expo"]) {
+      detected.add("expo");
+    }
+  }
+  const packagesDir = path8.join(projectDir, "packages");
+  if (fs8.existsSync(packagesDir)) {
+    try {
+      const pkgEntries = fs8.readdirSync(packagesDir, { withFileTypes: true });
+      if (pkgEntries.some((e) => e.isDirectory())) {
+        detected.add("package");
+      }
+    } catch {
+    }
+  }
+  if (detected.size === 0) {
+    detected.add("package");
+  }
+  return Array.from(detected);
+}
+function buildDefaultCiConfig(platforms) {
+  const config = {
+    platforms: {},
+    delegation: {
+      lint: ".codebyplan/eslint.json",
+      e2e: ".codebyplan/e2e.json",
+      detection: ".claude/docs/architecture/testing-matrix.md"
+    },
+    workflow: {
+      required_check_enforced: false
+    }
+  };
+  for (const platform2 of platforms) {
+    const checks = PLATFORM_COMMAND_MAP[platform2] ?? PLATFORM_COMMAND_MAP["package"];
+    if (checks) {
+      config.platforms[platform2] = { ...checks };
+    }
+  }
+  return config;
+}
+async function runCiInit(opts) {
+  await Promise.resolve();
+  const projectDir = path8.resolve(opts?.projectDir ?? process.cwd());
+  const dryRun = opts?.dryRun ?? false;
+  const force = opts?.force ?? false;
+  const ciPath = path8.join(projectDir, ".codebyplan", "ci.json");
+  const platforms = detectPlatforms(projectDir);
+  if (dryRun) {
+    return { status: "dry_run", path: ciPath, platforms };
+  }
+  let existing = null;
+  if (fs8.existsSync(ciPath)) {
+    try {
+      existing = JSON.parse(fs8.readFileSync(ciPath, "utf-8"));
+    } catch {
+    }
+  }
+  const newConfig = buildDefaultCiConfig(platforms);
+  if (existing !== null && !force) {
+    if (!existing.platforms) existing.platforms = {};
+    const newPlatforms = platforms.filter((p) => !(p in existing.platforms));
+    for (const p of newPlatforms) {
+      const checks = newConfig.platforms[p];
+      if (checks) {
+        existing.platforms[p] = checks;
+      }
+    }
+    let categoriesAdded = false;
+    for (const p of platforms) {
+      if (newPlatforms.includes(p)) continue;
+      const existingChecks = existing.platforms[p];
+      const defaultChecks = newConfig.platforms[p];
+      if (!existingChecks || !defaultChecks) continue;
+      for (const [cat, check] of Object.entries(defaultChecks)) {
+        if (!(cat in existingChecks)) {
+          existingChecks[cat] = check;
+          categoriesAdded = true;
+        }
+      }
+    }
+    if (newPlatforms.length === 0 && !categoriesAdded) {
+      return { status: "skipped", path: ciPath, platforms };
+    }
+    writeJsonAtomic(ciPath, existing);
+    return {
+      status: "written",
+      path: ciPath,
+      platforms: newPlatforms.length > 0 ? newPlatforms : platforms
+    };
+  }
+  const codebyplanDir = path8.join(projectDir, ".codebyplan");
+  fs8.mkdirSync(codebyplanDir, { recursive: true });
+  writeJsonAtomic(ciPath, newConfig);
+  return { status: "written", path: ciPath, platforms };
+}
+var PLATFORM_COMMAND_MAP;
+var init_ci_init = __esm({
+  "src/lib/ci-init.ts"() {
+    "use strict";
+    init_atomic_write();
+    PLATFORM_COMMAND_MAP = {
+      next_js: {
+        unit_test: {
+          command: "pnpm turbo test",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        typecheck: {
+          command: "pnpm turbo typecheck",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        build: {
+          command: "pnpm turbo build",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        lint: {
+          scope: "per_app_changed",
+          hard_fail: true,
+          delegates_to: ".codebyplan/eslint.json"
+        },
+        e2e: {
+          scope: "per_app_changed",
+          hard_fail: false,
+          delegates_to: ".codebyplan/e2e.json"
+        },
+        audit: {
+          command: "pnpm audit --json",
+          scope: "full_repo",
+          hard_fail: true
+        }
+      },
+      nestjs: {
+        unit_test: {
+          command: "pnpm turbo test",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        typecheck: {
+          command: "pnpm turbo typecheck",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        build: {
+          command: "pnpm turbo build",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        lint: {
+          scope: "per_app_changed",
+          hard_fail: true,
+          delegates_to: ".codebyplan/eslint.json"
+        },
+        e2e: {
+          scope: "per_app_changed",
+          hard_fail: false,
+          delegates_to: ".codebyplan/e2e.json"
+        },
+        audit: {
+          command: "pnpm audit --json",
+          scope: "full_repo",
+          hard_fail: true
+        }
+      },
+      tauri: {
+        unit_test: {
+          command: "pnpm turbo test",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        typecheck: {
+          command: "pnpm turbo typecheck",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        build: {
+          command: "pnpm turbo build",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        lint: {
+          scope: "per_app_changed",
+          hard_fail: true,
+          delegates_to: ".codebyplan/eslint.json"
+        },
+        e2e: {
+          scope: "per_app_changed",
+          hard_fail: false,
+          delegates_to: ".codebyplan/e2e.json"
+        },
+        audit: {
+          command: "pnpm audit --json",
+          scope: "full_repo",
+          hard_fail: true
+        }
+      },
+      vscode: {
+        unit_test: {
+          command: "pnpm turbo test",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        typecheck: {
+          command: "pnpm turbo typecheck",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        build: {
+          command: "pnpm turbo build",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        lint: {
+          scope: "per_app_changed",
+          hard_fail: true,
+          delegates_to: ".codebyplan/eslint.json"
+        },
+        e2e: {
+          scope: "per_app_changed",
+          hard_fail: false,
+          delegates_to: ".codebyplan/e2e.json"
+        },
+        audit: {
+          command: "pnpm audit --json",
+          scope: "full_repo",
+          hard_fail: true
+        }
+      },
+      expo: {
+        unit_test: {
+          command: "pnpm turbo test",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        typecheck: {
+          command: "pnpm turbo typecheck",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        build: {
+          command: "pnpm turbo build",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        lint: {
+          scope: "per_app_changed",
+          hard_fail: true,
+          delegates_to: ".codebyplan/eslint.json"
+        },
+        e2e: {
+          scope: "per_app_changed",
+          hard_fail: false,
+          delegates_to: ".codebyplan/e2e.json"
+        },
+        audit: {
+          command: "pnpm audit --json",
+          scope: "full_repo",
+          hard_fail: true
+        }
+      },
+      package: {
+        unit_test: {
+          command: "pnpm turbo test",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        typecheck: {
+          command: "pnpm turbo typecheck",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        build: {
+          command: "pnpm turbo build",
+          scope: "per_app_changed",
+          hard_fail: true
+        },
+        lint: {
+          scope: "per_app_changed",
+          hard_fail: true,
+          delegates_to: ".codebyplan/eslint.json"
+        },
+        e2e: {
+          scope: "per_app_changed",
+          hard_fail: false,
+          delegates_to: ".codebyplan/e2e.json"
+        },
+        audit: {
+          command: "pnpm audit --json",
+          scope: "full_repo",
+          hard_fail: true
+        }
+      }
+    };
+  }
+});
+
+// src/lib/scaffold-ci-workflow.ts
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
+function substituteTokens(template, tokens) {
+  let result = template;
+  for (const [token, value] of Object.entries(tokens)) {
+    result = result.split(`{{${token}}}`).join(value);
+  }
+  return result;
+}
+function detectPnpmVersionFromPackageJson(projectDir) {
+  try {
+    const pkgPath = path9.join(projectDir, "package.json");
+    const raw = fs9.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const pm = pkg.packageManager;
+    if (typeof pm === "string" && pm.startsWith("pnpm@")) {
+      const version3 = pm.slice("pnpm@".length).split("+")[0];
+      if (version3 && /^\d/.test(version3)) {
+        return version3;
+      }
+    }
+    return "10";
+  } catch {
+    return "10";
+  }
+}
+async function runScaffoldCiWorkflow(opts) {
+  await Promise.resolve();
+  const dryRun = opts?.dryRun ?? false;
+  const force = opts?.force ?? false;
+  const projectDir = path9.resolve(opts?.projectDir ?? process.cwd());
+  const pnpmVersion = opts?.pnpmVersion ?? detectPnpmVersionFromPackageJson(projectDir);
+  const nodeVersion = opts?.nodeVersion ?? "22";
+  const templatesDir = opts?.templatesDir ?? resolveTemplatesDir();
+  const templatePath = path9.join(templatesDir, "github-workflows", "ci.yml");
+  if (!fs9.existsSync(templatePath)) {
+    throw new Error(
+      `scaffold-ci-workflow: template not found at ${templatePath}`
+    );
+  }
+  const rawTemplate = fs9.readFileSync(templatePath, "utf-8");
+  const renderedContent = substituteTokens(rawTemplate, {
+    PNPM_VERSION: pnpmVersion,
+    NODE_VERSION: nodeVersion
+  });
+  const targetPath = path9.join(projectDir, ".github", "workflows", "ci.yml");
+  if (dryRun) {
+    return { status: "dry_run", path: targetPath };
+  }
+  if (fs9.existsSync(targetPath)) {
+    const existingContent = fs9.readFileSync(targetPath, "utf-8");
+    if (existingContent === renderedContent) {
+      return {
+        status: "skipped",
+        path: targetPath,
+        reason: "already up to date"
+      };
+    }
+    if (!force) {
+      throw new Error(
+        `scaffold-ci-workflow: ${targetPath} already exists and differs from the template. Pass --force to overwrite.`
+      );
+    }
+  }
+  const targetDir = path9.dirname(targetPath);
+  fs9.mkdirSync(targetDir, { recursive: true });
+  const tmpPath = targetPath + ".tmp";
+  try {
+    fs9.writeFileSync(tmpPath, renderedContent, "utf-8");
+    fs9.renameSync(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      fs9.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  return { status: "written", path: targetPath };
+}
+var init_scaffold_ci_workflow = __esm({
+  "src/lib/scaffold-ci-workflow.ts"() {
+    "use strict";
+    init_install();
+  }
+});
+
+// src/lib/gh-required-checks.ts
+import * as fs10 from "node:fs";
+import * as path10 from "node:path";
+import { execSync as execSync6 } from "node:child_process";
+function readCiJson(projectDir) {
+  const ciPath = path10.join(projectDir, ".codebyplan", "ci.json");
+  if (!fs10.existsSync(ciPath)) {
+    return {
+      platforms: {},
+      delegation: {},
+      workflow: { required_check_enforced: false }
+    };
+  }
+  try {
+    return JSON.parse(fs10.readFileSync(ciPath, "utf-8"));
+  } catch {
+    return {
+      platforms: {},
+      delegation: {},
+      workflow: { required_check_enforced: false }
+    };
+  }
+}
+function writeCiJsonAtomic(projectDir, config) {
+  const ciPath = path10.join(projectDir, ".codebyplan", "ci.json");
+  writeJsonAtomic(ciPath, config);
+}
+function enforceRequiredCheck(opts) {
+  const projectDir = path10.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 = path10.join(projectDir, ".codebyplan", "ci.json");
+  const config = readCiJson(projectDir);
+  if (config.workflow?.required_check_enforced === true) {
+    return { status: "already_enforced", path: ciPath };
+  }
+  if (dryRun) {
+    process.stdout.write(
+      `
+  [dry-run] Would add required status check "${checkName}" to branch "${branch}" protection and set workflow.required_check_enforced=true in ci.json.
+  No GitHub API call or file write performed.
+
+`
+    );
+    return { status: "dry_run", path: ciPath };
+  }
+  const manualInstructions = [
+    "",
+    `  Manual GitHub branch protection setup for branch "${branch}":`,
+    "  1. Go to: Settings \u2192 Branches \u2192 Branch protection rules",
+    `  2. Add or edit a rule for "${branch}"`,
+    '  3. Enable "Require status checks to pass before merging"',
+    `  4. Search for and add the required check: "${checkName}"`,
+    "  5. Save changes.",
+    ""
+  ].join("\n");
+  try {
+    let protectionExists = true;
+    try {
+      execSync6(`gh api repos/{owner}/{repo}/branches/${branch}/protection`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+      protectionExists = false;
+    }
+    if (protectionExists) {
+      execSync6(
+        `gh api --method POST repos/{owner}/{repo}/branches/${branch}/protection/required_status_checks/contexts --input -`,
+        {
+          encoding: "utf-8",
+          input: JSON.stringify([checkName]),
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+    } else {
+      const putBody = {
+        required_status_checks: { strict: true, contexts: [checkName] },
+        enforce_admins: false,
+        required_pull_request_reviews: null,
+        restrictions: null
+      };
+      execSync6(
+        `gh api --method PUT repos/{owner}/{repo}/branches/${branch}/protection --input -`,
+        {
+          encoding: "utf-8",
+          input: JSON.stringify(putBody),
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+    }
+    config.workflow = {
+      ...config.workflow,
+      required_check_enforced: true,
+      required_check_enforced_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeCiJsonAtomic(projectDir, config);
+    return { status: "enforced", path: ciPath };
+  } catch {
+    console.error(
+      "enforce-check: gh api command failed. Set up branch protection manually."
+    );
+    process.stdout.write(manualInstructions);
+    return {
+      status: "manual_required",
+      path: ciPath,
+      instructions: manualInstructions
+    };
+  }
+}
+var init_gh_required_checks = __esm({
+  "src/lib/gh-required-checks.ts"() {
+    "use strict";
+    init_atomic_write();
+  }
+});
+
+// src/lib/ci-resolve.ts
+function toResult(category, platform2, check, fromFallback) {
+  if (check.delegates_to !== void 0) {
+    return {
+      status: "delegates",
+      category,
+      platform: platform2,
+      delegates_to: check.delegates_to,
+      scope: check.scope,
+      hard_fail: check.hard_fail,
+      fallback_used: fromFallback
+    };
+  }
+  if (check.command !== void 0) {
+    return {
+      status: fromFallback ? "fallback" : "resolved",
+      category,
+      platform: platform2,
+      command: check.command,
+      scope: check.scope,
+      hard_fail: check.hard_fail,
+      fallback_used: fromFallback
+    };
+  }
+  return null;
+}
+function resolveCiCommand(opts) {
+  const { category } = opts;
+  const projectDir = opts.projectDir ?? process.cwd();
+  const config = readCiJson(projectDir);
+  const ciPlatforms = config.platforms ?? {};
+  const ciKeys = Object.keys(ciPlatforms);
+  const slug = opts.platform ?? ciKeys[0] ?? "package";
+  const ciCheck = ciPlatforms[slug]?.[category];
+  if (ciCheck !== void 0) {
+    const result = toResult(category, slug, ciCheck, false);
+    if (result !== null) return result;
+  }
+  const mapSlug = slug in PLATFORM_COMMAND_MAP ? slug : "package";
+  const mapCheck = PLATFORM_COMMAND_MAP[mapSlug]?.[category];
+  if (mapCheck !== void 0) {
+    const result = toResult(category, mapSlug, mapCheck, true);
+    if (result !== null) return result;
+  }
+  return {
+    status: "not_found",
+    category,
+    platform: slug,
+    fallback_used: ciCheck === void 0
+  };
+}
+var init_ci_resolve = __esm({
+  "src/lib/ci-resolve.ts"() {
+    "use strict";
+    init_gh_required_checks();
+    init_ci_init();
+  }
+});
+
+// src/cli/ci.ts
+var ci_exports = {};
+__export(ci_exports, {
+  runCiCommand: () => runCiCommand
+});
+function parseFlagsFromArgs2(args) {
+  const flags = {};
+  const booleans = /* @__PURE__ */ new Set();
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        booleans.add(key);
+      }
+    }
+  }
+  return { flags, booleans };
+}
+function printHelp3() {
+  process.stdout.write(
+    '\n  codebyplan ci\n\n  CI configuration management \u2014 detect platforms, scaffold workflow, enforce required check.\n\n  Subcommands:\n    init               Detect platforms and write/update .codebyplan/ci.json\n    scaffold-workflow  Write .github/workflows/ci.yml from the bundled template\n    enforce-check      Enforce the required CI status check on a GitHub branch\n    resolve <category>   Resolve the shell command for a CI check category (unit_test|typecheck|build|lint|e2e|audit)\n\n  Flags (all subcommands):\n    --dry-run            Preview the operation without writing any files\n    --force              Overwrite existing content that differs\n    --project-dir <p>    Target project root (default: current directory)\n    --json               Emit structured JSON to stdout\n\n  Flags (scaffold-workflow only):\n    --pnpm-version <v>   pnpm version for {{PNPM_VERSION}} token (default: auto-detected from package.json packageManager, falls back to "10")\n    --node-version <v>   Node.js version for {{NODE_VERSION}} token (default: "22")\n\n  Flags (enforce-check only):\n    --branch <b>         Branch to enforce (default: "main")\n    --check-name <n>     Status check name (default: "Lint + typecheck + test + build")\n\n  Flags (resolve only):\n    --platform <slug>    Platform slug to resolve against (e.g. next_js, nestjs, package)\n    --json               Emit the full CiResolveResult as JSON\n\n'
+  );
+}
+function printInitResult(result) {
+  switch (result.status) {
+    case "written":
+      process.stdout.write(
+        `Written: ${result.path} (platforms: ${result.platforms.join(", ")})
+`
+      );
+      break;
+    case "skipped":
+      process.stdout.write(
+        `Skipped: ${result.path} (platforms already configured: ${result.platforms.join(", ")})
+`
+      );
+      break;
+    case "dry_run":
+      process.stdout.write(
+        `[dry-run] Would write: ${result.path} (detected platforms: ${result.platforms.join(", ")})
+`
+      );
+      break;
+  }
+}
+function printScaffoldResult(result) {
+  switch (result.status) {
+    case "written":
+      process.stdout.write(`Written: ${result.path}
+`);
+      break;
+    case "skipped":
+      process.stdout.write(`Skipped: ${result.path} (${result.reason})
+`);
+      break;
+    case "dry_run":
+      process.stdout.write(`[dry-run] Would write: ${result.path}
+`);
+      break;
+  }
+}
+function printEnforceResult(result) {
+  switch (result.status) {
+    case "enforced":
+      process.stdout.write(
+        `Enforced required check. Branch protection updated: ${result.path}
+`
+      );
+      break;
+    case "already_enforced":
+      process.stdout.write(
+        `Skipped: required check already enforced (${result.path})
+`
+      );
+      break;
+    case "manual_required":
+      process.stdout.write(
+        `Manual setup required \u2014 see instructions above. (${result.path})
+`
+      );
+      break;
+    case "dry_run":
+      break;
+  }
+}
+async function runCiCommand(args) {
+  const subcommand = args[0];
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h" || subcommand === void 0) {
+    printHelp3();
+    process.exit(0);
+  }
+  const rest = args.slice(1);
+  const { flags, booleans } = parseFlagsFromArgs2(rest);
+  const dryRun = booleans.has("dry-run");
+  const force = booleans.has("force");
+  const jsonOutput = booleans.has("json");
+  const projectDir = flags["project-dir"];
+  if (subcommand === "init") {
+    let result;
+    try {
+      result = await runCiInit({ dryRun, force, projectDir });
+    } catch (err) {
+      process.stderr.write(
+        `ci init: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (jsonOutput) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    printInitResult(result);
+    return;
+  }
+  if (subcommand === "scaffold-workflow") {
+    const pnpmVersion = flags["pnpm-version"];
+    const nodeVersion = flags["node-version"];
+    let result;
+    try {
+      result = await runScaffoldCiWorkflow({
+        dryRun,
+        force,
+        projectDir,
+        pnpmVersion,
+        nodeVersion
+      });
+    } catch (err) {
+      process.stderr.write(
+        `ci scaffold-workflow: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (jsonOutput) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    printScaffoldResult(result);
+    return;
+  }
+  if (subcommand === "enforce-check") {
+    const branch = flags["branch"];
+    const checkName = flags["check-name"];
+    let result;
+    try {
+      result = enforceRequiredCheck({ projectDir, branch, checkName, dryRun });
+    } catch (err) {
+      process.stderr.write(
+        `ci enforce-check: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (jsonOutput) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    printEnforceResult(result);
+    return;
+  }
+  if (subcommand === "resolve") {
+    const validCategories = [
+      "unit_test",
+      "typecheck",
+      "build",
+      "lint",
+      "e2e",
+      "audit"
+    ];
+    const categoryArg = rest[0];
+    if (categoryArg === void 0 || categoryArg.startsWith("--") || !validCategories.includes(categoryArg)) {
+      process.stderr.write(
+        "ci resolve: category required (one of: unit_test, typecheck, build, lint, e2e, audit)\n"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const category = categoryArg;
+    const resolveRest = rest.slice(1);
+    const { flags: resolveFlags, booleans: resolveBooleans } = parseFlagsFromArgs2(resolveRest);
+    const platform2 = resolveFlags["platform"];
+    const resolveProjectDir = resolveFlags["project-dir"] ?? projectDir;
+    const resolveJsonOutput = resolveBooleans.has("json") || jsonOutput;
+    let result;
+    try {
+      result = resolveCiCommand({
+        category,
+        platform: platform2,
+        projectDir: resolveProjectDir
+      });
+    } catch (err) {
+      process.stderr.write(
+        `ci resolve: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (resolveJsonOutput) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    switch (result.status) {
+      case "resolved":
+        process.stdout.write(`${result.command}
+`);
+        break;
+      case "fallback":
+        process.stderr.write(
+          `ci resolve: no ci.json entry for ${result.platform}/${category}, using default
+`
+        );
+        process.stdout.write(`${result.command}
+`);
+        break;
+      case "delegates":
+        process.stderr.write(
+          `ci resolve: '${category}' delegates to ${result.delegates_to} \u2014 config path, not a runnable command
+`
+        );
+        process.stdout.write(`${result.delegates_to}
+`);
+        break;
+      case "not_found":
+        process.stderr.write(
+          `ci resolve: category '${category}' not found for platform '${result.platform}'
+`
+        );
+        process.exitCode = 1;
+        break;
+    }
+    return;
+  }
+  process.stderr.write(
+    `ci: unknown subcommand '${subcommand}'. Run 'codebyplan ci help' for usage.
+`
+  );
+  process.exitCode = 1;
+}
+var init_ci = __esm({
+  "src/cli/ci.ts"() {
+    "use strict";
+    init_ci_init();
+    init_scaffold_ci_workflow();
+    init_gh_required_checks();
+    init_ci_resolve();
+  }
+});
+
+// src/lib/cd-init.ts
+import * as fs11 from "node:fs";
+import * as path11 from "node:path";
+function detectSurfaces(projectDir) {
+  const shipmentPath = path11.join(projectDir, ".codebyplan", "shipment.json");
+  let shipment;
+  try {
+    shipment = JSON.parse(fs11.readFileSync(shipmentPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const outer = shipment["shipment"];
+  const surfacesBlock = outer?.["surfaces"] ?? shipment["surfaces"];
+  if (!surfacesBlock || typeof surfacesBlock !== "object") {
+    return [];
+  }
+  return Object.keys(surfacesBlock);
+}
+function normaliseSurfaceKey(key) {
+  const known = [
+    "vercel",
+    "eas",
+    "npm",
+    "tauri",
+    "railway",
+    "supabase",
+    "vscode"
+  ];
+  if (known.includes(key)) {
+    return key;
+  }
+  for (const id of known) {
+    if (key.startsWith(id + "-") || key.startsWith(id + "_")) {
+      return id;
+    }
+  }
+  return key;
+}
+function buildDefaultCdConfig(rawSurfaceKeys) {
+  const config = {
+    surfaces: {},
+    workflow: {
+      workflows_scaffolded: false
+    }
+  };
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawKey of rawSurfaceKeys) {
+    const normalised = normaliseSurfaceKey(rawKey);
+    if (seen.has(normalised)) continue;
+    seen.add(normalised);
+    const defaults = SURFACE_DEFAULTS[normalised] ?? DEFAULT_SURFACE;
+    config.surfaces[normalised] = { ...defaults };
+  }
+  return config;
+}
+async function runCdInit(opts) {
+  await Promise.resolve();
+  const projectDir = path11.resolve(opts?.projectDir ?? process.cwd());
+  const dryRun = opts?.dryRun ?? false;
+  const force = opts?.force ?? false;
+  const cdPath = path11.join(projectDir, ".codebyplan", "cd.json");
+  const rawSurfaceKeys = detectSurfaces(projectDir);
+  const seen = /* @__PURE__ */ new Set();
+  const surfaces = [];
+  for (const rawKey of rawSurfaceKeys) {
+    const normalised = normaliseSurfaceKey(rawKey);
+    if (!seen.has(normalised)) {
+      seen.add(normalised);
+      surfaces.push(normalised);
+    }
+  }
+  if (dryRun) {
+    return { status: "dry_run", path: cdPath, surfaces };
+  }
+  let existing = null;
+  if (fs11.existsSync(cdPath)) {
+    try {
+      existing = JSON.parse(fs11.readFileSync(cdPath, "utf-8"));
+    } catch {
+    }
+  }
+  const newConfig = buildDefaultCdConfig(rawSurfaceKeys);
+  if (existing !== null && !force) {
+    if (!existing.surfaces) existing.surfaces = {};
+    const newSurfaces = surfaces.filter((s) => !(s in existing.surfaces));
+    for (const s of newSurfaces) {
+      const surfaceConfig = newConfig.surfaces[s];
+      if (surfaceConfig) {
+        existing.surfaces[s] = surfaceConfig;
+      }
+    }
+    if (newSurfaces.length === 0) {
+      return { status: "skipped", path: cdPath, surfaces };
+    }
+    writeJsonAtomic(cdPath, existing);
+    return {
+      status: "written",
+      path: cdPath,
+      surfaces: newSurfaces
+    };
+  }
+  const codebyplanDir = path11.join(projectDir, ".codebyplan");
+  fs11.mkdirSync(codebyplanDir, { recursive: true });
+  writeJsonAtomic(cdPath, newConfig);
+  return { status: "written", path: cdPath, surfaces };
+}
+var SURFACE_DEFAULTS, DEFAULT_SURFACE;
+var init_cd_init = __esm({
+  "src/lib/cd-init.ts"() {
+    "use strict";
+    init_atomic_write();
+    SURFACE_DEFAULTS = {
+      npm: {
+        trigger: "push-to-main",
+        path_filter: "packages/**",
+        approval_required: false,
+        oidc_auth: true,
+        version_gate: true,
+        credentials: { env_var_names: [] }
+      },
+      tauri: {
+        trigger: "push-to-main",
+        path_filter: "apps/desktop/**",
+        approval_required: false,
+        oidc_auth: false,
+        version_gate: true,
+        credentials: {
+          env_var_names: [
+            "TAURI_SIGNING_PRIVATE_KEY",
+            "TAURI_SIGNING_PRIVATE_KEY_PASSWORD",
+            "APPLE_CERTIFICATE",
+            "APPLE_CERTIFICATE_PASSWORD",
+            "APPLE_SIGNING_IDENTITY",
+            "APPLE_API_ISSUER",
+            "APPLE_API_KEY",
+            "APPLE_API_KEY_CONTENT",
+            "WINDOWS_CERTIFICATE",
+            "WINDOWS_CERTIFICATE_PASSWORD"
+          ]
+        }
+      },
+      vercel: {
+        trigger: "push-to-main",
+        approval_required: false,
+        oidc_auth: false,
+        version_gate: false,
+        credentials: { env_var_names: ["VERCEL_TOKEN"] }
+      },
+      eas: {
+        trigger: "push-to-main",
+        approval_required: false,
+        oidc_auth: false,
+        version_gate: true,
+        credentials: { env_var_names: ["EXPO_TOKEN"] }
+      },
+      railway: {
+        trigger: "push-to-main",
+        approval_required: false,
+        oidc_auth: false,
+        version_gate: false,
+        credentials: { env_var_names: ["RAILWAY_TOKEN"] }
+      },
+      supabase: {
+        trigger: "push-to-main",
+        approval_required: false,
+        oidc_auth: false,
+        version_gate: false,
+        credentials: {
+          env_var_names: ["SUPABASE_ACCESS_TOKEN", "SUPABASE_PROJECT_REF"]
+        }
+      },
+      vscode: {
+        trigger: "push-to-main",
+        approval_required: false,
+        oidc_auth: false,
+        version_gate: true,
+        credentials: { env_var_names: ["VSCE_PAT"] }
+      }
+    };
+    DEFAULT_SURFACE = {
+      trigger: "push-to-main",
+      approval_required: false,
+      oidc_auth: false,
+      version_gate: false,
+      credentials: { env_var_names: [] }
+    };
+  }
+});
+
+// src/lib/scaffold-cd-workflow.ts
+import * as fs12 from "node:fs";
+import * as path12 from "node:path";
+async function scaffoldOneWorkflow(templateName, targetName, opts) {
+  await Promise.resolve();
+  const dryRun = opts.dryRun ?? false;
+  const force = opts.force ?? false;
+  const projectDir = path12.resolve(opts.projectDir ?? process.cwd());
+  const templatesDir = opts.templatesDir ?? resolveTemplatesDir();
+  const templatePath = path12.join(
+    templatesDir,
+    "github-workflows",
+    templateName
+  );
+  if (!fs12.existsSync(templatePath)) {
+    throw new Error(
+      `scaffold-cd-workflow: template not found at ${templatePath}`
+    );
+  }
+  const templateContent = fs12.readFileSync(templatePath, "utf-8");
+  const targetPath = path12.join(projectDir, ".github", "workflows", targetName);
+  if (dryRun) {
+    return { status: "dry_run", path: targetPath };
+  }
+  if (fs12.existsSync(targetPath)) {
+    const existingContent = fs12.readFileSync(targetPath, "utf-8");
+    if (existingContent === templateContent) {
+      return {
+        status: "skipped",
+        path: targetPath,
+        reason: "already up to date"
+      };
+    }
+    if (!force) {
+      throw new Error(
+        `scaffold-cd-workflow: ${targetPath} already exists and differs from the template. Pass --force to overwrite.`
+      );
+    }
+  }
+  const targetDir = path12.dirname(targetPath);
+  fs12.mkdirSync(targetDir, { recursive: true });
+  const tmpPath = targetPath + ".tmp";
+  try {
+    fs12.writeFileSync(tmpPath, templateContent, "utf-8");
+    fs12.renameSync(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      fs12.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  return { status: "written", path: targetPath };
+}
+async function runScaffoldCdWorkflow(opts) {
+  const workflows = opts?.workflows ?? ["publish", "release-desktop"];
+  const results = [];
+  const workflowMap = {
+    publish: { template: "publish.yml", target: "publish.yml" },
+    "release-desktop": {
+      template: "release-desktop.yml",
+      target: "release-desktop.yml"
+    }
+  };
+  for (const wf of workflows) {
+    const entry = workflowMap[wf];
+    if (!entry) {
+      throw new Error(
+        `scaffold-cd-workflow: unknown workflow '${wf}'. Valid options: publish, release-desktop.`
+      );
+    }
+    const result = await scaffoldOneWorkflow(
+      entry.template,
+      entry.target,
+      opts ?? {}
+    );
+    results.push({ ...result, workflow: wf });
+  }
+  return { results };
+}
+var init_scaffold_cd_workflow = __esm({
+  "src/lib/scaffold-cd-workflow.ts"() {
+    "use strict";
+    init_templates_dir();
+  }
+});
+
+// src/cli/cd.ts
+var cd_exports = {};
+__export(cd_exports, {
+  runCdCommand: () => runCdCommand
+});
+function parseFlagsFromArgs3(args) {
+  const flags = {};
+  const booleans = /* @__PURE__ */ new Set();
+  const multi = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        if (multi[key]) {
+          multi[key].push(next);
+        } else {
+          multi[key] = [next];
+          flags[key] = next;
+        }
+        i++;
+      } else {
+        booleans.add(key);
+      }
+    }
+  }
+  return { flags, booleans, multi };
+}
+function printHelp4() {
+  process.stdout.write(
+    "\n  codebyplan cd\n\n  CD configuration management \u2014 detect surfaces, scaffold workflow files.\n\n  Subcommands:\n    init               Detect surfaces from .codebyplan/shipment.json and write/update .codebyplan/cd.json\n    scaffold-workflow  Write .github/workflows/publish.yml + release-desktop.yml from bundled templates\n\n  Flags (all subcommands):\n    --dry-run            Preview the operation without writing any files\n    --force              Overwrite existing content that differs\n    --project-dir <p>    Target project root (default: current directory)\n    --json               Emit structured JSON to stdout\n\n  Flags (scaffold-workflow only):\n    --workflow <name>    Workflow to scaffold: publish | release-desktop\n                         May be specified multiple times. Defaults to both.\n\n"
+  );
+}
+function printInitResult2(result) {
+  switch (result.status) {
+    case "written":
+      process.stdout.write(
+        `Written: ${result.path} (surfaces: ${result.surfaces.join(", ") || "(none)"})
+`
+      );
+      break;
+    case "skipped":
+      process.stdout.write(
+        `Skipped: ${result.path} (surfaces already configured: ${result.surfaces.join(", ") || "(none)"})
+`
+      );
+      break;
+    case "dry_run":
+      process.stdout.write(
+        `[dry-run] Would write: ${result.path} (detected surfaces: ${result.surfaces.join(", ") || "(none)"})
+`
+      );
+      break;
+  }
+}
+function printScaffoldResult2(result) {
+  for (const r of result.results) {
+    switch (r.status) {
+      case "written":
+        process.stdout.write(`Written: ${r.path} (${r.workflow})
+`);
+        break;
+      case "skipped":
+        process.stdout.write(
+          `Skipped: ${r.path} (${r.workflow} \u2014 ${"reason" in r ? r.reason : "already up to date"})
+`
+        );
+        break;
+      case "dry_run":
+        process.stdout.write(
+          `[dry-run] Would write: ${r.path} (${r.workflow})
+`
+        );
+        break;
+    }
+  }
+}
+async function runCdCommand(args) {
+  const subcommand = args[0];
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h" || subcommand === void 0) {
+    printHelp4();
+    process.exit(0);
+  }
+  const rest = args.slice(1);
+  const { flags, booleans, multi } = parseFlagsFromArgs3(rest);
+  const dryRun = booleans.has("dry-run");
+  const force = booleans.has("force");
+  const jsonOutput = booleans.has("json");
+  const projectDir = flags["project-dir"];
+  if (subcommand === "init") {
+    let result;
+    try {
+      result = await runCdInit({ dryRun, force, projectDir });
+    } catch (err) {
+      process.stderr.write(
+        `cd init: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (jsonOutput) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    printInitResult2(result);
+    return;
+  }
+  if (subcommand === "scaffold-workflow") {
+    const workflowArgs = multi["workflow"] ?? [];
+    const workflows = workflowArgs.length > 0 ? workflowArgs : void 0;
+    let result;
+    try {
+      result = await runScaffoldCdWorkflow({
+        dryRun,
+        force,
+        projectDir,
+        workflows
+      });
+    } catch (err) {
+      process.stderr.write(
+        `cd scaffold-workflow: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (jsonOutput) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    printScaffoldResult2(result);
+    return;
+  }
+  process.stderr.write(
+    `cd: unknown subcommand '${subcommand}'. Run 'codebyplan cd help' for usage.
+`
+  );
+  process.exitCode = 1;
+}
+var init_cd = __esm({
+  "src/cli/cd.ts"() {
+    "use strict";
+    init_cd_init();
+    init_scaffold_cd_workflow();
+  }
+});
+
 // src/cli/process-exit-signal.ts
 var ProcessExitSignal;
 var init_process_exit_signal = __esm({
@@ -31433,9 +32748,9 @@ __export(version_status_exports, {
   resolveGuard: () => resolveGuard,
   runVersionStatus: () => runVersionStatus
 });
-import { execFileSync, execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname10, join as join25 } from "node:path";
+import { execFileSync, execSync as execSync7 } from "node:child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
+import { dirname as dirname12, join as join30 } from "node:path";
 function fetchLatestVersion() {
   try {
     return execFileSync("npm", ["view", "codebyplan", "version"], {
@@ -31448,7 +32763,7 @@ function fetchLatestVersion() {
 }
 function resolveGitRoot() {
   try {
-    return execSync6("git rev-parse --show-toplevel", {
+    return execSync7("git rev-parse --show-toplevel", {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -31459,11 +32774,11 @@ function detectPackageManager2(gitRoot) {
   let dir = process.cwd();
   const stopAt = gitRoot ?? null;
   while (true) {
-    if (existsSync5(join25(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync5(join25(dir, "yarn.lock"))) return "yarn";
-    if (existsSync5(join25(dir, "package-lock.json"))) return "npm";
+    if (existsSync10(join30(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync10(join30(dir, "yarn.lock"))) return "yarn";
+    if (existsSync10(join30(dir, "package-lock.json"))) return "npm";
     if (stopAt !== null && dir === stopAt) break;
-    const parent = dirname10(dir);
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -31481,15 +32796,15 @@ function buildInstallCommand2(pm) {
 }
 async function resolveGuard(gitRoot, currentBranch) {
   if (gitRoot !== null) {
-    const canonicalPkgPath = join25(
+    const canonicalPkgPath = join30(
       gitRoot,
       "packages",
       "codebyplan-package",
       "package.json"
     );
     try {
-      if (existsSync5(canonicalPkgPath)) {
-        const raw = readFileSync6(canonicalPkgPath, "utf-8");
+      if (existsSync10(canonicalPkgPath)) {
+        const raw = readFileSync11(canonicalPkgPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && parsed["name"] === "codebyplan") {
           return { guarded: true, guardReason: "canonical_source" };
@@ -31505,12 +32820,12 @@ async function resolveGuard(gitRoot, currentBranch) {
       let gitJsonPath;
       if (found.path.endsWith("/repo.json")) {
         const dir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join25(dir, "git.json");
+        gitJsonPath = join30(dir, "git.json");
       } else {
         const legacyDir = found.path.slice(0, found.path.lastIndexOf("/"));
-        gitJsonPath = join25(legacyDir, ".codebyplan", "git.json");
+        gitJsonPath = join30(legacyDir, ".codebyplan", "git.json");
       }
-      const raw = readFileSync6(gitJsonPath, "utf-8");
+      const raw = readFileSync11(gitJsonPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         const bc = parsed["branch_config"];
@@ -31593,8 +32908,8 @@ __export(upload_e2e_images_exports, {
   runUploadE2eImagesCommand: () => runUploadE2eImagesCommand
 });
 import { readFile as readFile19 } from "node:fs/promises";
-import { join as join26, basename, resolve as resolve5 } from "node:path";
-import { execSync as execSync7 } from "node:child_process";
+import { join as join31, basename, resolve as resolve10 } from "node:path";
+import { execSync as execSync8 } from "node:child_process";
 function baseUrl2() {
   return (process.env.CODEBYPLAN_API_URL ?? "https://www.codebyplan.com").replace(/\/$/, "");
 }
@@ -31628,7 +32943,7 @@ function parseArgs(args) {
 async function readE2eConfig(projectPath) {
   try {
     const raw = await readFile19(
-      join26(projectPath, ".codebyplan", "e2e.json"),
+      join31(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -31643,7 +32958,7 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
   }
   let stdout7;
   try {
-    stdout7 = execSync7(
+    stdout7 = execSync8(
       `git diff --name-status --diff-filter=AM "${baseBranch}...HEAD" -- "${pathspec}"`,
       { cwd: projectPath, encoding: "utf-8" }
     );
@@ -31669,7 +32984,7 @@ function collectPngsFromGitDiff(projectPath, frameworkName, frameworkConfig, bas
       continue;
     const isNew = status === "A";
     results.push({
-      absolutePath: join26(projectPath, filePath),
+      absolutePath: join31(projectPath, filePath),
       filename: basename(filePath),
       framework: frameworkName,
       is_new: isNew
@@ -31708,7 +33023,7 @@ async function runUploadE2eImagesCommand(args) {
     process.exit(1);
   }
   const checkpointId = parsed.checkpointId;
-  const projectPath = resolve5(process.cwd());
+  const projectPath = resolve10(process.cwd());
   let repoId = parsed.repoId;
   if (!repoId) {
     const found = await findCodebyplanConfig(projectPath);
@@ -31844,8 +33159,8 @@ __export(arch_map_exports, {
   updateFrontmatterFields: () => updateFrontmatterFields
 });
 import { readFile as readFile20, writeFile as writeFile16 } from "node:fs/promises";
-import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
+import { join as join32 } from "node:path";
 import { spawnSync as spawnSync9 } from "node:child_process";
 function normalizeModulePath(modulePath) {
   return modulePath.replace(/\/+$/, "");
@@ -31870,7 +33185,7 @@ async function resolveCodebyplanDir(startDir) {
   }
 }
 async function readArchitectureConfig(codebyplanDir) {
-  const filePath = join27(codebyplanDir, "architecture.json");
+  const filePath = join32(codebyplanDir, "architecture.json");
   try {
     const raw = await readFile20(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -31883,7 +33198,7 @@ async function readArchitectureConfig(codebyplanDir) {
   }
 }
 async function writeArchitectureConfig(codebyplanDir, config) {
-  const filePath = join27(codebyplanDir, "architecture.json");
+  const filePath = join32(codebyplanDir, "architecture.json");
   await writeFile16(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function resolveGitSha(modulePath, cwd) {
@@ -31902,7 +33217,7 @@ function resolveGitSha(modulePath, cwd) {
 }
 async function discoverModulePaths(projectRoot) {
   const paths = [];
-  const workspacePath = join27(projectRoot, "pnpm-workspace.yaml");
+  const workspacePath = join32(projectRoot, "pnpm-workspace.yaml");
   let patterns = [];
   try {
     const raw = await readFile20(workspacePath, "utf-8");
@@ -31929,10 +33244,10 @@ async function discoverModulePaths(projectRoot) {
   for (const pattern of patterns) {
     if (pattern.endsWith("/*")) {
       const dir = pattern.slice(0, -2);
-      const absDir = join27(projectRoot, dir);
+      const absDir = join32(projectRoot, dir);
       try {
-        if (existsSync6(absDir)) {
-          const entries = readdirSync3(absDir, { withFileTypes: true });
+        if (existsSync11(absDir)) {
+          const entries = readdirSync4(absDir, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isDirectory()) {
               paths.push(`${dir}/${entry.name}`);
@@ -31942,17 +33257,17 @@ async function discoverModulePaths(projectRoot) {
       } catch {
       }
     } else if (!pattern.includes("*")) {
-      const absPath = join27(projectRoot, pattern);
-      if (existsSync6(absPath)) {
+      const absPath = join32(projectRoot, pattern);
+      if (existsSync11(absPath)) {
         paths.push(pattern);
       }
     }
   }
   const crossCutting = ["supabase", ".github", "scripts"];
   for (const dir of crossCutting) {
-    const absPath = join27(projectRoot, dir);
+    const absPath = join32(projectRoot, dir);
     try {
-      if (existsSync6(absPath)) {
+      if (existsSync11(absPath)) {
         paths.push(dir);
       }
     } catch {
@@ -32136,7 +33451,7 @@ async function runStamp(modulePath, sha, depthArg, projectRoot) {
   }
   await writeArchitectureConfig(codebyplanDir, config);
   const stampedEntry = existingIndex >= 0 ? config.modules[existingIndex] : config.modules[config.modules.length - 1];
-  const mapAbsPath = join27(repoRoot, stampedEntry.map_file);
+  const mapAbsPath = join32(repoRoot, stampedEntry.map_file);
   let mapContent = null;
   try {
     mapContent = await readFile20(mapAbsPath, "utf-8");
@@ -32342,18 +33657,18 @@ var init_worktree_port_resolver = __esm({
 
 // src/lib/migrate-local-config.ts
 import { mkdir as mkdir9, readFile as readFile21, unlink as unlink5, writeFile as writeFile17 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { join as join33 } from "node:path";
 function legacySharedPath(projectPath) {
-  return join28(projectPath, ".codebyplan.json");
+  return join33(projectPath, ".codebyplan.json");
 }
 function legacyLocalPath(projectPath) {
-  return join28(projectPath, ".codebyplan.local.json");
+  return join33(projectPath, ".codebyplan.local.json");
 }
 function newDirPath(projectPath) {
-  return join28(projectPath, ".codebyplan");
+  return join33(projectPath, ".codebyplan");
 }
 function sentinelPath(projectPath) {
-  return join28(projectPath, ".codebyplan", "repo.json");
+  return join33(projectPath, ".codebyplan", "repo.json");
 }
 async function statSafe(p) {
   const { stat: stat3 } = await import("node:fs/promises");
@@ -32447,7 +33762,7 @@ async function runLocalMigration(projectPath) {
   if ("organization_id" in cfg) repoJson.organization_id = cfg.organization_id;
   if ("project_id" in cfg) repoJson.project_id = cfg.project_id;
   await writeFile17(
-    join28(projectPath, ".codebyplan", "repo.json"),
+    join33(projectPath, ".codebyplan", "repo.json"),
     JSON.stringify(repoJson, null, 2) + "\n",
     "utf-8"
   );
@@ -32460,7 +33775,7 @@ async function runLocalMigration(projectPath) {
   if ("port_allocations" in cfg)
     serverJson.port_allocations = cfg.port_allocations;
   await writeFile17(
-    join28(projectPath, ".codebyplan", "server.json"),
+    join33(projectPath, ".codebyplan", "server.json"),
     JSON.stringify(serverJson, null, 2) + "\n",
     "utf-8"
   );
@@ -32469,7 +33784,7 @@ async function runLocalMigration(projectPath) {
   if ("git_branch" in cfg) gitJson.git_branch = cfg.git_branch;
   if ("branch_config" in cfg) gitJson.branch_config = cfg.branch_config;
   await writeFile17(
-    join28(projectPath, ".codebyplan", "git.json"),
+    join33(projectPath, ".codebyplan", "git.json"),
     JSON.stringify(gitJson, null, 2) + "\n",
     "utf-8"
   );
@@ -32477,35 +33792,35 @@ async function runLocalMigration(projectPath) {
   const shipmentJson = {};
   if ("shipment" in cfg) shipmentJson.shipment = cfg.shipment;
   await writeFile17(
-    join28(projectPath, ".codebyplan", "shipment.json"),
+    join33(projectPath, ".codebyplan", "shipment.json"),
     JSON.stringify(shipmentJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/shipment.json");
   const vendorJson = {};
   await writeFile17(
-    join28(projectPath, ".codebyplan", "vendor.json"),
+    join33(projectPath, ".codebyplan", "vendor.json"),
     JSON.stringify(vendorJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/vendor.json");
   const e2eJson = {};
   await writeFile17(
-    join28(projectPath, ".codebyplan", "e2e.json"),
+    join33(projectPath, ".codebyplan", "e2e.json"),
     JSON.stringify(e2eJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/e2e.json");
   const eslintJson = {};
   await writeFile17(
-    join28(projectPath, ".codebyplan", "eslint.json"),
+    join33(projectPath, ".codebyplan", "eslint.json"),
     JSON.stringify(eslintJson, null, 2) + "\n",
     "utf-8"
   );
   filesChanged.push(".codebyplan/eslint.json");
   if (!deviceWrittenByHelper) {
     await writeFile17(
-      join28(projectPath, ".codebyplan", "device.local.json"),
+      join33(projectPath, ".codebyplan", "device.local.json"),
       JSON.stringify({ device_id: deviceId }, null, 2) + "\n",
       "utf-8"
     );
@@ -32517,7 +33832,7 @@ async function runLocalMigration(projectPath) {
       "Migration write incomplete: .codebyplan/repo.json was not persisted. Re-run migration to retry from a clean state."
     );
   }
-  const gitignorePath = join28(projectPath, ".gitignore");
+  const gitignorePath = join33(projectPath, ".gitignore");
   try {
     const gitignoreContent = await readFile21(gitignorePath, "utf-8");
     const legacyLine = ".codebyplan.local.json";
@@ -32581,7 +33896,7 @@ __export(config_exports, {
   runConfigMigrate: () => runConfigMigrate
 });
 import { mkdir as mkdir10, readFile as readFile22, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join29 } from "node:path";
+import { join as join34 } from "node:path";
 async function runConfig() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -32614,7 +33929,7 @@ async function runConfig() {
   console.log("\n  Config complete.\n");
 }
 async function syncConfigToFile(repoId, projectPath, dryRun) {
-  const codebyplanDir = join29(projectPath, ".codebyplan");
+  const codebyplanDir = join34(projectPath, ".codebyplan");
   const {
     resolvedWorktreeId,
     portAllocations,
@@ -32707,7 +34022,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
   ];
   let anyUpdated = false;
   for (const { name, payload, createOnly } of files) {
-    const filePath = join29(codebyplanDir, name);
+    const filePath = join34(codebyplanDir, name);
     const newJson = JSON.stringify(payload, null, 2) + "\n";
     let currentJson = "";
     try {
@@ -32727,7 +34042,7 @@ async function syncConfigToFile(repoId, projectPath, dryRun) {
 async function readRepoConfig(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "repo.json"),
+      join34(projectPath, ".codebyplan", "repo.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32738,7 +34053,7 @@ async function readRepoConfig(projectPath) {
 async function readServerConfig(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "server.json"),
+      join34(projectPath, ".codebyplan", "server.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32749,7 +34064,7 @@ async function readServerConfig(projectPath) {
 async function readGitConfig2(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "git.json"),
+      join34(projectPath, ".codebyplan", "git.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32760,7 +34075,7 @@ async function readGitConfig2(projectPath) {
 async function readShipmentConfig2(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "shipment.json"),
+      join34(projectPath, ".codebyplan", "shipment.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32771,7 +34086,7 @@ async function readShipmentConfig2(projectPath) {
 async function readVendorConfig(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "vendor.json"),
+      join34(projectPath, ".codebyplan", "vendor.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32782,7 +34097,7 @@ async function readVendorConfig(projectPath) {
 async function readE2eConfig2(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "e2e.json"),
+      join34(projectPath, ".codebyplan", "e2e.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32793,7 +34108,7 @@ async function readE2eConfig2(projectPath) {
 async function readServerLocalConfig(projectPath) {
   try {
     const raw = await readFile22(
-      join29(projectPath, ".codebyplan", "server.local.json"),
+      join34(projectPath, ".codebyplan", "server.local.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32866,7 +34181,7 @@ var init_config = __esm({
 
 // src/lib/server-detect.ts
 import { readFile as readFile23, readdir as readdir5, access as access6 } from "node:fs/promises";
-import { join as join30 } from "node:path";
+import { join as join35 } from "node:path";
 async function fileExists4(filePath) {
   try {
     await access6(filePath);
@@ -32877,21 +34192,21 @@ async function fileExists4(filePath) {
 }
 function detectPackageManager3(dir) {
   return (async () => {
-    if (await fileExists4(join30(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists4(join30(dir, "yarn.lock"))) return "yarn";
+    if (await fileExists4(join35(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists4(join35(dir, "yarn.lock"))) return "yarn";
     return "npm";
   })();
 }
 function detectFramework(pkg) {
   const deps = pkg.dependencies ?? {};
   const devDeps = pkg.devDependencies ?? {};
-  const hasDep = (name) => name in deps || name in devDeps;
-  if (hasDep("next")) return "nextjs";
-  if (hasDep("@tauri-apps/api") || hasDep("@tauri-apps/cli")) return "tauri";
-  if (hasDep("expo")) return "expo";
-  if (hasDep("vite")) return "vite";
-  if (hasDep("express")) return "express";
-  if (hasDep("@nestjs/core")) return "nestjs";
+  const hasDep2 = (name) => name in deps || name in devDeps;
+  if (hasDep2("next")) return "nextjs";
+  if (hasDep2("@tauri-apps/api") || hasDep2("@tauri-apps/cli")) return "tauri";
+  if (hasDep2("expo")) return "expo";
+  if (hasDep2("vite")) return "vite";
+  if (hasDep2("express")) return "express";
+  if (hasDep2("@nestjs/core")) return "nestjs";
   return "custom";
 }
 function detectPortFromScripts(pkg) {
@@ -32910,12 +34225,12 @@ function detectPortFromScripts(pkg) {
   return null;
 }
 async function isMonorepo(dir) {
-  return await fileExists4(join30(dir, "turbo.json")) || await fileExists4(join30(dir, "pnpm-workspace.yaml"));
+  return await fileExists4(join35(dir, "turbo.json")) || await fileExists4(join35(dir, "pnpm-workspace.yaml"));
 }
 async function detectServers(projectPath) {
   let pkg;
   try {
-    const raw = await readFile23(join30(projectPath, "package.json"), "utf-8");
+    const raw = await readFile23(join35(projectPath, "package.json"), "utf-8");
     pkg = JSON.parse(raw);
   } catch {
     return {
@@ -32931,13 +34246,13 @@ async function detectServers(projectPath) {
   const mono = await isMonorepo(projectPath);
   const servers = [];
   if (mono) {
-    const appsDir = join30(projectPath, "apps");
+    const appsDir = join35(projectPath, "apps");
     try {
       const entries = await readdir5(appsDir, { withFileTypes: true });
       const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
       for (const entry of sorted) {
         if (!entry.isDirectory()) continue;
-        const appPkgPath = join30(appsDir, entry.name, "package.json");
+        const appPkgPath = join35(appsDir, entry.name, "package.json");
         try {
           const appRaw = await readFile23(appPkgPath, "utf-8");
           const appPkg = JSON.parse(appRaw);
@@ -33103,7 +34418,7 @@ __export(ports_exports, {
   runPorts: () => runPorts
 });
 import { mkdir as mkdir11, readFile as readFile25, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join31 } from "node:path";
+import { join as join36 } from "node:path";
 function printDetectionResult(result, projectPath) {
   console.log(`
   CodeByPlan Ports - List`);
@@ -33259,8 +34574,8 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
     // and ServerLocalConfig.port_allocations is typed the same — honest end-to-end.
     port_allocations: portAllocations
   };
-  const codebyplanDir = join31(projectPath, ".codebyplan");
-  const filePath = join31(codebyplanDir, "server.local.json");
+  const codebyplanDir = join36(projectPath, ".codebyplan");
+  const filePath = join36(codebyplanDir, "server.local.json");
   const newJson = JSON.stringify(payload, null, 2) + "\n";
   let currentJson = "";
   try {
@@ -33282,8 +34597,8 @@ async function writeServerLocalConfig(repoId, projectPath, dryRun) {
   );
 }
 async function provisionE2eEnv(projectPath, dryRun) {
-  const relSource = join31("apps", "web", ".env.local");
-  const sourcePath = join31(projectPath, relSource);
+  const relSource = join36("apps", "web", ".env.local");
+  const sourcePath = join36(projectPath, relSource);
   let sourceRaw;
   try {
     sourceRaw = await readFile25(sourcePath, "utf-8");
@@ -33315,8 +34630,8 @@ async function provisionE2eEnv(projectPath, dryRun) {
     );
     return;
   }
-  const codebyplanDir = join31(projectPath, ".codebyplan");
-  const filePath = join31(codebyplanDir, "e2e.env");
+  const codebyplanDir = join36(projectPath, ".codebyplan");
+  const filePath = join36(codebyplanDir, "e2e.env");
   const newContent = lines.join("\n") + "\n";
   let currentContent = "";
   try {
@@ -33383,7 +34698,7 @@ __export(tech_stack_exports, {
   runFullTechStack: () => runFullTechStack,
   runTechStack: () => runTechStack
 });
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 async function runTechStack() {
   const flags = parseFlags(3);
   const dryRun = hasFlag("dry-run", 3);
@@ -33552,7 +34867,7 @@ async function runFullTechStack(dryRun) {
       continue;
     }
     const localWorktrees = worktrees.filter(
-      (wt) => wt.path ? existsSync7(wt.path) : false
+      (wt) => wt.path ? existsSync12(wt.path) : false
     );
     if (localWorktrees.length === 0) {
       console.log(`  skipping ${repo.name} \u2014 no local worktree on this device`);
@@ -33591,8 +34906,8 @@ var init_tech_stack = __esm({
 });
 
 // src/lib/check-baseline.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join37 } from "node:path";
 function emptyBaseline() {
   return {
     lint: { known_failing: [] },
@@ -33602,9 +34917,9 @@ function emptyBaseline() {
   };
 }
 function loadBaseline(projectRoot) {
-  const filePath = join32(projectRoot, BASELINE_FILENAME);
+  const filePath = join37(projectRoot, BASELINE_FILENAME);
   try {
-    const raw = readFileSync7(filePath, "utf-8");
+    const raw = readFileSync12(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     const defaults = emptyBaseline();
     return {
@@ -33626,8 +34941,8 @@ function loadBaseline(projectRoot) {
   }
 }
 function saveBaseline(projectRoot, baseline) {
-  const filePath = join32(projectRoot, BASELINE_FILENAME);
-  writeFileSync4(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
+  const filePath = join37(projectRoot, BASELINE_FILENAME);
+  writeFileSync7(filePath, JSON.stringify(baseline, null, 2) + "\n", "utf-8");
 }
 function diffBaseline(check, currentFailingPackages, baseline) {
   const knownFailing = new Set(baseline[check].known_failing);
@@ -33675,8 +34990,8 @@ var init_check_baseline = __esm({
 });
 
 // src/lib/check.ts
-import { readFileSync as readFileSync8, existsSync as existsSync8 } from "node:fs";
-import { join as join33 } from "node:path";
+import { readFileSync as readFileSync13, existsSync as existsSync13 } from "node:fs";
+import { join as join38 } from "node:path";
 import { spawnSync as spawnSync10 } from "node:child_process";
 function hasSentinelValue(arrays) {
   const SENTINELS = /* @__PURE__ */ new Set([
@@ -33707,7 +35022,7 @@ function parseSummaryPath(output) {
 function parseFailingPackagesFromSummary(summaryPath) {
   let raw;
   try {
-    raw = readFileSync8(summaryPath, "utf-8");
+    raw = readFileSync13(summaryPath, "utf-8");
   } catch {
     return [SUMMARY_UNREADABLE];
   }
@@ -33739,9 +35054,9 @@ function parseFailingPackagesFromSummary(summaryPath) {
   return Array.from(failing).sort();
 }
 function resolveTurboBin(projectRoot) {
-  const localBin = join33(projectRoot, "node_modules", ".bin", "turbo");
-  if (existsSync8(localBin)) return localBin;
-  const workspaceRootBin = join33(
+  const localBin = join38(projectRoot, "node_modules", ".bin", "turbo");
+  if (existsSync13(localBin)) return localBin;
+  const workspaceRootBin = join38(
     projectRoot,
     "..",
     "..",
@@ -33749,7 +35064,7 @@ function resolveTurboBin(projectRoot) {
     ".bin",
     "turbo"
   );
-  if (existsSync8(workspaceRootBin)) return workspaceRootBin;
+  if (existsSync13(workspaceRootBin)) return workspaceRootBin;
   return TURBO_NOT_FOUND_SENTINEL;
 }
 function runTurboWithSummary(task, projectRoot, spawnFn) {
@@ -34177,8 +35492,8 @@ var init_check2 = __esm({
 });
 
 // src/lib/claude-plan.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs13 from "node:fs";
+import * as path13 from "node:path";
 function buildDriftPlan(projectDir, templatesDir, manifest) {
   const packaged = walkTemplates(templatesDir);
   const packagedBySrc = new Map(packaged.map((f) => [f.src, f]));
@@ -34192,8 +35507,8 @@ function buildDriftPlan(projectDir, templatesDir, manifest) {
   };
   for (const pkg of packaged) {
     const inManifest = manifestBySrc.get(pkg.src);
-    const absDest = path8.join(projectDir, ".claude", pkg.dest);
-    const absSrc = path8.join(templatesDir, pkg.src);
+    const absDest = path13.join(projectDir, ".claude", pkg.dest);
+    const absSrc = path13.join(templatesDir, pkg.src);
     if (!inManifest) {
       plan.newOptIn.push({
         packaged: { src: pkg.src, dest: pkg.dest, hash: pkg.hash },
@@ -34201,8 +35516,8 @@ function buildDriftPlan(projectDir, templatesDir, manifest) {
       });
       continue;
     }
-    const onDiskExists = fs7.existsSync(absDest);
-    const onDiskContent = onDiskExists ? fs7.readFileSync(absDest) : Buffer.alloc(0);
+    const onDiskExists = fs13.existsSync(absDest);
+    const onDiskContent = onDiskExists ? fs13.readFileSync(absDest) : Buffer.alloc(0);
     const onDiskHash = onDiskExists ? sha256(onDiskContent) : null;
     if (pkg.hash === inManifest.hash && onDiskHash === inManifest.hash) {
       plan.unchanged.push(inManifest);
@@ -34241,9 +35556,9 @@ var status_exports = {};
 __export(status_exports, {
   runStatus: () => runStatus2
 });
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
-import { execSync as execSync8 } from "node:child_process";
+import * as fs14 from "node:fs";
+import * as path14 from "node:path";
+import { execSync as execSync9 } from "node:child_process";
 function makeFailSafe(checked_at) {
   return {
     installed: VERSION,
@@ -34264,7 +35579,7 @@ function makeFailSafe(checked_at) {
 }
 function resolveGitRoot2() {
   try {
-    return execSync8("git rev-parse --show-toplevel", {
+    return execSync9("git rev-parse --show-toplevel", {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -34347,26 +35662,26 @@ async function runStatus2(argv) {
     const latest = fetchLatestVersion();
     const newer = latest !== null && compareSemver(latest, installed) > 0;
     let settings_drift = false;
-    const settingsPath = path9.join(projectDir, ".claude", "settings.json");
-    const baseSettingsPath = path9.join(
+    const settingsPath = path14.join(projectDir, ".claude", "settings.json");
+    const baseSettingsPath = path14.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const hooksJsonPath = path9.join(templatesDir, "hooks", "hooks.json");
-    if (fs8.existsSync(settingsPath)) {
+    const hooksJsonPath = path14.join(templatesDir, "hooks", "hooks.json");
+    if (fs14.existsSync(settingsPath)) {
       try {
-        const settingsRaw = fs8.readFileSync(settingsPath, "utf8");
+        const settingsRaw = fs14.readFileSync(settingsPath, "utf8");
         const before = JSON.stringify(JSON.parse(settingsRaw));
         const cloned = JSON.parse(settingsRaw);
-        if (fs8.existsSync(baseSettingsPath)) {
+        if (fs14.existsSync(baseSettingsPath)) {
           const base = JSON.parse(
-            fs8.readFileSync(baseSettingsPath, "utf8")
+            fs14.readFileSync(baseSettingsPath, "utf8")
           );
           mergeBaseSettingsIntoSettings(cloned, base);
         }
-        if (fs8.existsSync(hooksJsonPath)) {
+        if (fs14.existsSync(hooksJsonPath)) {
           const hooksJson = JSON.parse(
-            fs8.readFileSync(hooksJsonPath, "utf8")
+            fs14.readFileSync(hooksJsonPath, "utf8")
           );
           mergeHooksIntoSettings(cloned, hooksJson);
         }
@@ -34418,10 +35733,10 @@ function emitResult(result, writeCache, quiet, projectDir) {
   const json = JSON.stringify(result, null, 2);
   if (writeCache) {
     try {
-      const cacheDir = path9.join(projectDir, ".codebyplan");
-      fs8.mkdirSync(cacheDir, { recursive: true });
-      fs8.writeFileSync(
-        path9.join(cacheDir, "claude-status.local.json"),
+      const cacheDir = path14.join(projectDir, ".codebyplan");
+      fs14.mkdirSync(cacheDir, { recursive: true });
+      fs14.writeFileSync(
+        path14.join(cacheDir, "claude-status.local.json"),
         json + "\n",
         "utf8"
       );
@@ -34464,11 +35779,11 @@ async function ask(q, opts) {
   try {
     while (true) {
       const choices = q.choices.map((c) => `[${c.key}] ${c.label}`).join("  ");
-      const answer = await new Promise((resolve11) => {
+      const answer = await new Promise((resolve16) => {
         rl.question(`${q.message}
   ${choices}
 > `, (input) => {
-          resolve11(input.trim().toLowerCase());
+          resolve16(input.trim().toLowerCase());
         });
       });
       const match = q.choices.find(
@@ -34562,9 +35877,9 @@ var update_exports = {};
 __export(update_exports, {
   runUpdate: () => runUpdate
 });
-import * as fs9 from "node:fs";
+import * as fs15 from "node:fs";
 import * as os3 from "node:os";
-import * as path10 from "node:path";
+import * as path15 from "node:path";
 async function runUpdate(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -34600,10 +35915,10 @@ async function runUpdate(opts, deps = {}) {
       finalManifestEntries.push(e);
     }
     for (const { packaged, absSrc } of plan.overwriteSafe) {
-      const absDest = path10.join(projectDir, ".claude", packaged.dest);
+      const absDest = path15.join(projectDir, ".claude", packaged.dest);
       if (!opts.dryRun) {
-        fs9.mkdirSync(path10.dirname(absDest), { recursive: true });
-        fs9.copyFileSync(absSrc, absDest);
+        fs15.mkdirSync(path15.dirname(absDest), { recursive: true });
+        fs15.copyFileSync(absSrc, absDest);
         if (opts.verbose) console.log(`updated ${packaged.dest}`);
       } else if (opts.verbose) {
         console.log(`[dry-run] would update ${packaged.dest}`);
@@ -34615,8 +35930,8 @@ async function runUpdate(opts, deps = {}) {
       absSrc,
       onDiskContent
     } of plan.overwriteHandEdited) {
-      const absDest = path10.join(projectDir, ".claude", packaged.dest);
-      const newContent = fs9.readFileSync(absSrc);
+      const absDest = path15.join(projectDir, ".claude", packaged.dest);
+      const newContent = fs15.readFileSync(absSrc);
       const showDiff = () => {
         console.log(
           renderDiff(
@@ -34628,8 +35943,8 @@ async function runUpdate(opts, deps = {}) {
       const answer = await promptOverwrite(packaged.dest, opts, showDiff);
       if (answer === "overwrite") {
         if (!opts.dryRun) {
-          fs9.mkdirSync(path10.dirname(absDest), { recursive: true });
-          fs9.copyFileSync(absSrc, absDest);
+          fs15.mkdirSync(path15.dirname(absDest), { recursive: true });
+          fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
       } else {
@@ -34644,10 +35959,10 @@ 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 = path10.join(projectDir, ".claude", packaged.dest);
+        const absDest = path15.join(projectDir, ".claude", packaged.dest);
         if (!opts.dryRun) {
-          fs9.mkdirSync(path10.dirname(absDest), { recursive: true });
-          fs9.copyFileSync(absSrc, absDest);
+          fs15.mkdirSync(path15.dirname(absDest), { recursive: true });
+          fs15.copyFileSync(absSrc, absDest);
         }
         finalManifestEntries.push(packaged);
         if (opts.verbose) console.log(`installed new file ${packaged.dest}`);
@@ -34658,25 +35973,25 @@ async function runUpdate(opts, deps = {}) {
     for (const e of plan.removedFromPackage) {
       const answer = await promptRemove(e.dest, opts);
       if (answer === "remove") {
-        const absDest = path10.join(projectDir, ".claude", e.dest);
-        if (!opts.dryRun && fs9.existsSync(absDest)) {
-          fs9.rmSync(absDest);
-          const claudeDir = path10.join(projectDir, ".claude");
-          let cur = path10.dirname(absDest);
-          while (cur !== claudeDir && cur !== path10.dirname(cur)) {
-            if (path10.dirname(cur) === claudeDir) break;
+        const absDest = path15.join(projectDir, ".claude", e.dest);
+        if (!opts.dryRun && fs15.existsSync(absDest)) {
+          fs15.rmSync(absDest);
+          const claudeDir = path15.join(projectDir, ".claude");
+          let cur = path15.dirname(absDest);
+          while (cur !== claudeDir && cur !== path15.dirname(cur)) {
+            if (path15.dirname(cur) === claudeDir) break;
             try {
-              fs9.rmdirSync(cur);
+              fs15.rmdirSync(cur);
               if (opts.verbose)
                 console.log(
-                  `pruned empty dir ${path10.relative(claudeDir, cur)}`
+                  `pruned empty dir ${path15.relative(claudeDir, cur)}`
                 );
-              cur = path10.dirname(cur);
+              cur = path15.dirname(cur);
             } catch (err) {
               const code = err.code;
               if (code !== "ENOTEMPTY" && code !== "ENOENT") {
                 console.warn(
-                  `codebyplan claude: could not prune empty dir ${path10.relative(claudeDir, cur)}: ${err.message}`
+                  `codebyplan claude: could not prune empty dir ${path15.relative(claudeDir, cur)}: ${err.message}`
                 );
               }
               break;
@@ -34688,22 +36003,22 @@ async function runUpdate(opts, deps = {}) {
         if (opts.verbose) console.log(`kept (untracked) ${e.dest}`);
       }
     }
-    const hooksJsonPath = path10.join(templatesDir, "hooks", "hooks.json");
-    const baseSettingsPath = path10.join(
+    const hooksJsonPath = path15.join(templatesDir, "hooks", "hooks.json");
+    const baseSettingsPath = path15.join(
       templatesDir,
       "settings.project.base.json"
     );
-    const settingsPath = path10.join(projectDir, ".claude", "settings.json");
-    const existingSettings = fs9.existsSync(settingsPath) ? JSON.parse(fs9.readFileSync(settingsPath, "utf8")) : {};
-    if (fs9.existsSync(baseSettingsPath)) {
+    const settingsPath = path15.join(projectDir, ".claude", "settings.json");
+    const existingSettings = fs15.existsSync(settingsPath) ? JSON.parse(fs15.readFileSync(settingsPath, "utf8")) : {};
+    if (fs15.existsSync(baseSettingsPath)) {
       const base = JSON.parse(
-        fs9.readFileSync(baseSettingsPath, "utf8")
+        fs15.readFileSync(baseSettingsPath, "utf8")
       );
       mergeBaseSettingsIntoSettings(existingSettings, base);
     }
-    if (fs9.existsSync(hooksJsonPath)) {
+    if (fs15.existsSync(hooksJsonPath)) {
       const hooksJson = JSON.parse(
-        fs9.readFileSync(hooksJsonPath, "utf8")
+        fs15.readFileSync(hooksJsonPath, "utf8")
       );
       mergeHooksIntoSettings(existingSettings, hooksJson);
       pruneMissingManagedHooks(
@@ -34715,8 +36030,8 @@ async function runUpdate(opts, deps = {}) {
       );
     }
     if (!opts.dryRun) {
-      fs9.mkdirSync(path10.dirname(settingsPath), { recursive: true });
-      fs9.writeFileSync(
+      fs15.mkdirSync(path15.dirname(settingsPath), { recursive: true });
+      fs15.writeFileSync(
         settingsPath,
         JSON.stringify(existingSettings, null, 2) + "\n",
         "utf8"
@@ -34728,7 +36043,7 @@ async function runUpdate(opts, deps = {}) {
     );
     if (opts.verbose && gitignoreAction !== "unchanged") {
       console.log(
-        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path10.relative(projectDir, path10.join(projectDir, ".gitignore"))}`
+        `${opts.dryRun ? "[dry-run] would " : ""}${gitignoreAction} managed .gitignore block in ${path15.relative(projectDir, path15.join(projectDir, ".gitignore"))}`
       );
     }
     if (!opts.dryRun) {
@@ -34768,9 +36083,9 @@ function runUpdateUser(opts, deps) {
     return;
   }
   try {
-    const userDir = deps.userDir ?? path10.join(os3.homedir(), ".claude");
-    const settingsPath = path10.join(userDir, "settings.json");
-    const userBaseSettingsPath = path10.join(
+    const userDir = deps.userDir ?? path15.join(os3.homedir(), ".claude");
+    const settingsPath = path15.join(userDir, "settings.json");
+    const userBaseSettingsPath = path15.join(
       templatesDir,
       "settings.user.base.json"
     );
@@ -34782,7 +36097,7 @@ function runUpdateUser(opts, deps) {
       process.exitCode = 1;
       return;
     }
-    if (!fs9.existsSync(userBaseSettingsPath)) {
+    if (!fs15.existsSync(userBaseSettingsPath)) {
       console.error(
         "codebyplan claude update: settings.user.base.json not found in templates."
       );
@@ -34790,13 +36105,13 @@ function runUpdateUser(opts, deps) {
       return;
     }
     const userBase = JSON.parse(
-      fs9.readFileSync(userBaseSettingsPath, "utf8")
+      fs15.readFileSync(userBaseSettingsPath, "utf8")
     );
-    const existingSettings = fs9.existsSync(settingsPath) ? JSON.parse(fs9.readFileSync(settingsPath, "utf8")) : {};
+    const existingSettings = fs15.existsSync(settingsPath) ? JSON.parse(fs15.readFileSync(settingsPath, "utf8")) : {};
     mergeBaseSettingsIntoSettings(existingSettings, userBase);
     if (!opts.dryRun) {
-      fs9.mkdirSync(userDir, { recursive: true });
-      fs9.writeFileSync(
+      fs15.mkdirSync(userDir, { recursive: true });
+      fs15.writeFileSync(
         settingsPath,
         JSON.stringify(existingSettings, null, 2) + "\n",
         "utf8"
@@ -34839,9 +36154,9 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   runUninstall: () => runUninstall
 });
-import * as fs10 from "node:fs";
+import * as fs16 from "node:fs";
 import * as os4 from "node:os";
-import * as path11 from "node:path";
+import * as path16 from "node:path";
 async function runUninstall(opts, deps = {}) {
   await Promise.resolve();
   const scope = opts.scope ?? "project";
@@ -34870,15 +36185,15 @@ async function runUninstall(opts, deps = {}) {
     let removed = 0;
     let warnings = 0;
     for (const entry of manifest.files) {
-      const abs = path11.join(projectDir, ".claude", entry.dest);
-      if (!fs10.existsSync(abs)) {
+      const abs = path16.join(projectDir, ".claude", entry.dest);
+      if (!fs16.existsSync(abs)) {
         console.warn(
           `codebyplan claude uninstall: ${entry.dest} already absent (skipping).`
         );
         warnings += 1;
         continue;
       }
-      const onDiskHash = sha256(fs10.readFileSync(abs));
+      const onDiskHash = sha256(fs16.readFileSync(abs));
       if (onDiskHash !== entry.hash) {
         console.warn(
           `codebyplan claude uninstall: ${entry.dest} has been modified locally; removing anyway.`
@@ -34886,7 +36201,7 @@ async function runUninstall(opts, deps = {}) {
         warnings += 1;
       }
       if (!opts.dryRun) {
-        fs10.rmSync(abs);
+        fs16.rmSync(abs);
       }
       removed += 1;
       if (opts.verbose) console.log(`removed ${entry.dest}`);
@@ -34894,15 +36209,15 @@ async function runUninstall(opts, deps = {}) {
     if (!opts.dryRun) {
       pruneEmptyManagedDirs(projectDir);
     }
-    const settingsPath = path11.join(projectDir, ".claude", "settings.json");
-    if (fs10.existsSync(settingsPath)) {
+    const settingsPath = path16.join(projectDir, ".claude", "settings.json");
+    if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
-        fs10.readFileSync(settingsPath, "utf8")
+        fs16.readFileSync(settingsPath, "utf8")
       );
-      const baseSettingsPath = templatesDir ? path11.join(templatesDir, "settings.project.base.json") : null;
-      if (baseSettingsPath && fs10.existsSync(baseSettingsPath)) {
+      const baseSettingsPath = templatesDir ? path16.join(templatesDir, "settings.project.base.json") : null;
+      if (baseSettingsPath && fs16.existsSync(baseSettingsPath)) {
         const base = JSON.parse(
-          fs10.readFileSync(baseSettingsPath, "utf8")
+          fs16.readFileSync(baseSettingsPath, "utf8")
         );
         stripBaseSettingsFromSettings(settings, base);
       }
@@ -34910,9 +36225,9 @@ async function runUninstall(opts, deps = {}) {
       if (!opts.dryRun) {
         const isEmpty = Object.keys(settings).length === 0;
         if (isEmpty) {
-          fs10.rmSync(settingsPath);
+          fs16.rmSync(settingsPath);
         } else {
-          fs10.writeFileSync(
+          fs16.writeFileSync(
             settingsPath,
             JSON.stringify(settings, null, 2) + "\n",
             "utf8"
@@ -34931,11 +36246,11 @@ async function runUninstall(opts, deps = {}) {
     }
     if (!opts.dryRun) {
       const m = manifestPath(projectDir);
-      if (fs10.existsSync(m)) fs10.rmSync(m);
+      if (fs16.existsSync(m)) fs16.rmSync(m);
       const mid = midManifestPath(projectDir);
-      if (fs10.existsSync(mid)) fs10.rmSync(mid);
+      if (fs16.existsSync(mid)) fs16.rmSync(mid);
       const legacy = oldManifestPath(projectDir);
-      if (fs10.existsSync(legacy)) fs10.rmSync(legacy);
+      if (fs16.existsSync(legacy)) fs16.rmSync(legacy);
     }
     console.log(
       `codebyplan claude uninstall${opts.dryRun ? " (dry-run)" : ""}: removed ${removed} files${warnings > 0 ? ` (${warnings} warnings)` : ""}.`
@@ -34957,7 +36272,7 @@ function runUninstallUser(opts, deps) {
     }
   }
   try {
-    const userDir = deps.userDir ?? path11.join(os4.homedir(), ".claude");
+    const userDir = deps.userDir ?? path16.join(os4.homedir(), ".claude");
     const existingManifest = readManifestForScope("user", userDir);
     if (!existingManifest) {
       console.error(
@@ -34966,24 +36281,24 @@ function runUninstallUser(opts, deps) {
       process.exitCode = 1;
       return;
     }
-    const settingsPath = path11.join(userDir, "settings.json");
-    if (fs10.existsSync(settingsPath)) {
+    const settingsPath = path16.join(userDir, "settings.json");
+    if (fs16.existsSync(settingsPath)) {
       const settings = JSON.parse(
-        fs10.readFileSync(settingsPath, "utf8")
+        fs16.readFileSync(settingsPath, "utf8")
       );
-      const userBaseSettingsPath = templatesDir != null ? path11.join(templatesDir, "settings.user.base.json") : null;
-      if (userBaseSettingsPath && fs10.existsSync(userBaseSettingsPath)) {
+      const userBaseSettingsPath = templatesDir != null ? path16.join(templatesDir, "settings.user.base.json") : null;
+      if (userBaseSettingsPath && fs16.existsSync(userBaseSettingsPath)) {
         const userBase = JSON.parse(
-          fs10.readFileSync(userBaseSettingsPath, "utf8")
+          fs16.readFileSync(userBaseSettingsPath, "utf8")
         );
         stripBaseSettingsFromSettings(settings, userBase);
       }
       if (!opts.dryRun) {
         const isEmpty = Object.keys(settings).length === 0;
         if (isEmpty) {
-          fs10.rmSync(settingsPath);
+          fs16.rmSync(settingsPath);
         } else {
-          fs10.writeFileSync(
+          fs16.writeFileSync(
             settingsPath,
             JSON.stringify(settings, null, 2) + "\n",
             "utf8"
@@ -34993,11 +36308,11 @@ function runUninstallUser(opts, deps) {
     }
     if (!opts.dryRun) {
       const m = userManifestPath(userDir);
-      if (fs10.existsSync(m)) fs10.rmSync(m);
+      if (fs16.existsSync(m)) fs16.rmSync(m);
       const midUser = userMidManifestPath(userDir);
-      if (fs10.existsSync(midUser)) fs10.rmSync(midUser);
+      if (fs16.existsSync(midUser)) fs16.rmSync(midUser);
       const oldUser = userOldManifestPath(userDir);
-      if (fs10.existsSync(oldUser)) fs10.rmSync(oldUser);
+      if (fs16.existsSync(oldUser)) fs16.rmSync(oldUser);
     }
     console.log(
       `codebyplan claude uninstall --scope user${opts.dryRun ? " (dry-run)" : ""}: user base settings stripped.`
@@ -35012,23 +36327,23 @@ function runUninstallUser(opts, deps) {
 function pruneEmptyManagedDirs(projectDir) {
   const managedRoots = ["skills", "agents", "hooks", "rules"];
   for (const root of managedRoots) {
-    const abs = path11.join(projectDir, ".claude", root);
-    if (!fs10.existsSync(abs)) continue;
+    const abs = path16.join(projectDir, ".claude", root);
+    if (!fs16.existsSync(abs)) continue;
     pruneLeafFirst(abs);
   }
 }
 function pruneLeafFirst(dir) {
-  if (!fs10.existsSync(dir)) return;
-  const stat3 = fs10.statSync(dir);
+  if (!fs16.existsSync(dir)) return;
+  const stat3 = fs16.statSync(dir);
   if (!stat3.isDirectory()) return;
-  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      pruneLeafFirst(path11.join(dir, entry.name));
+      pruneLeafFirst(path16.join(dir, entry.name));
     }
   }
-  const remaining = fs10.readdirSync(dir);
+  const remaining = fs16.readdirSync(dir);
   if (remaining.length === 0) {
-    fs10.rmdirSync(dir);
+    fs16.rmdirSync(dir);
   }
 }
 var init_uninstall = __esm({
@@ -35043,8 +36358,8 @@ var init_uninstall = __esm({
 });
 
 // src/lib/verify-parity.ts
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
 function isValidScope(s) {
   return s === "org-shared" || s === "project-shared" || REPO_ONLY_RE.test(s);
 }
@@ -35061,47 +36376,47 @@ function checkSiblingParity(opts) {
     expectedOneSided = DEFAULT_EXPECTED_ONE_SIDED,
     ignoredSubtrees
   } = opts;
-  const defaultIgnored = [path12.join(claudeDir, "hooks", "__test-fixtures__")];
+  const defaultIgnored = [path17.join(claudeDir, "hooks", "__test-fixtures__")];
   const ignored = ignoredSubtrees ?? defaultIgnored;
   const violations = [];
   const claudeSideRels = /* @__PURE__ */ new Set();
   for (const scanDir of SCAN_DIRS) {
-    const baseDir = path12.join(claudeDir, scanDir);
-    if (!fs11.existsSync(baseDir)) continue;
+    const baseDir = path17.join(claudeDir, scanDir);
+    if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path12.join(baseDir, entry);
-      if (!fs11.lstatSync(absPath).isFile()) continue;
+      const absPath = path17.join(baseDir, entry);
+      if (!fs17.lstatSync(absPath).isFile()) continue;
       if (ignored.some(
-        (ig) => absPath.startsWith(ig + path12.sep) || absPath === ig
+        (ig) => absPath.startsWith(ig + path17.sep) || absPath === ig
       )) {
         continue;
       }
-      const relPath = path12.join(scanDir, entry).split(path12.sep).join("/");
+      const relPath = path17.join(scanDir, entry).split(path17.sep).join("/");
       claudeSideRels.add(relPath);
-      const templatePath = path12.join(templatesDir, relPath);
-      if (!fs11.existsSync(templatePath)) {
+      const templatePath = path17.join(templatesDir, relPath);
+      if (!fs17.existsSync(templatePath)) {
         if (!expectedOneSided.has(relPath) && !isScaffoldFile(entry)) {
           violations.push({ type: "missing-twin", path: relPath });
         }
         continue;
       }
-      const srcBuf = fs11.readFileSync(absPath);
-      const tplBuf = fs11.readFileSync(templatePath);
+      const srcBuf = fs17.readFileSync(absPath);
+      const tplBuf = fs17.readFileSync(templatePath);
       if (Buffer.compare(srcBuf, tplBuf) !== 0) {
         violations.push({ type: "divergent", path: relPath });
       }
     }
   }
   for (const scanDir of SCAN_DIRS) {
-    const tplBase = path12.join(templatesDir, scanDir);
-    if (!fs11.existsSync(tplBase)) continue;
+    const tplBase = path17.join(templatesDir, scanDir);
+    if (!fs17.existsSync(tplBase)) continue;
     const entries = readdirRecursive(tplBase);
     for (const entry of entries) {
-      const absPath = path12.join(tplBase, entry);
-      if (!fs11.lstatSync(absPath).isFile()) continue;
+      const absPath = path17.join(tplBase, entry);
+      if (!fs17.lstatSync(absPath).isFile()) continue;
       if (isScaffoldFile(entry)) continue;
-      const relPath = path12.join(scanDir, entry).split(path12.sep).join("/");
+      const relPath = path17.join(scanDir, entry).split(path17.sep).join("/");
       if (!claudeSideRels.has(relPath) && !expectedOneSided.has(relPath)) {
         violations.push({ type: "extra-twin", path: relPath });
       }
@@ -35134,25 +36449,25 @@ function checkScopeMarkers(opts) {
     allowlist = /* @__PURE__ */ new Set(),
     templatesDir
   } = opts;
-  const twinDetectionActive = templatesDir != null && fs11.existsSync(templatesDir);
+  const twinDetectionActive = templatesDir != null && fs17.existsSync(templatesDir);
   const violations = [];
   for (const scanDir of scanDirs) {
-    const baseDir = path12.join(claudeDir, scanDir);
-    if (!fs11.existsSync(baseDir)) continue;
+    const baseDir = path17.join(claudeDir, scanDir);
+    if (!fs17.existsSync(baseDir)) continue;
     const entries = readdirRecursive(baseDir);
     for (const entry of entries) {
-      const absPath = path12.join(baseDir, entry);
-      if (!fs11.lstatSync(absPath).isFile()) continue;
+      const absPath = path17.join(baseDir, entry);
+      if (!fs17.lstatSync(absPath).isFile()) continue;
       if (!isStructuralEntry(scanDir, entry)) continue;
-      const ext = path12.extname(entry).toLowerCase();
+      const ext = path17.extname(entry).toLowerCase();
       const isMd = ext === ".md";
       const isSh = ext === ".sh";
       if (!isMd && !isSh) continue;
-      const relPath = path12.join(scanDir, entry).split(path12.sep).join("/");
+      const relPath = path17.join(scanDir, entry).split(path17.sep).join("/");
       if (allowlist.has(relPath)) continue;
       let content;
       try {
-        content = fs11.readFileSync(absPath, "utf8");
+        content = fs17.readFileSync(absPath, "utf8");
       } catch (err) {
         violations.push({
           type: "missing-scope",
@@ -35162,7 +36477,7 @@ function checkScopeMarkers(opts) {
         continue;
       }
       const scopeValue = isMd ? extractFrontmatterScope(content) : extractShScope(content);
-      const managed = twinDetectionActive && fs11.existsSync(path12.join(templatesDir, relPath));
+      const managed = twinDetectionActive && fs17.existsSync(path17.join(templatesDir, relPath));
       if (managed) {
         if (scopeValue === null) {
         } else if (scopeValue === "org-shared") {
@@ -35198,7 +36513,7 @@ function runVerifyParity(opts) {
   const allScopeItems = [];
   const parityItems = [];
   allScopeItems.push(...checkScopeMarkers({ claudeDir, templatesDir }));
-  if (templatesDir != null && fs11.existsSync(templatesDir)) {
+  if (templatesDir != null && fs17.existsSync(templatesDir)) {
     parityItems.push(
       ...checkSiblingParity({ claudeDir, templatesDir, expectedOneSided })
     );
@@ -35211,14 +36526,14 @@ function runVerifyParity(opts) {
   return { violations, warnings };
 }
 function readdirRecursive(dir, rel = "", visited = /* @__PURE__ */ new Set()) {
-  const realDir = fs11.realpathSync(dir);
+  const realDir = fs17.realpathSync(dir);
   if (visited.has(realDir)) return [];
   visited.add(realDir);
   const results = [];
-  for (const name of fs11.readdirSync(dir)) {
-    const full = path12.join(dir, name);
+  for (const name of fs17.readdirSync(dir)) {
+    const full = path17.join(dir, name);
     const relName = rel ? `${rel}/${name}` : name;
-    if (fs11.lstatSync(full).isDirectory()) {
+    if (fs17.lstatSync(full).isDirectory()) {
       results.push(...readdirRecursive(full, relName, visited));
     } else {
       results.push(relName);
@@ -35288,14 +36603,14 @@ var verify_parity_exports = {};
 __export(verify_parity_exports, {
   verifyParity: () => verifyParity
 });
-import * as fs12 from "node:fs";
-import * as path13 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 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 = path13.join(projectDir, ".claude");
-  if (!fs12.existsSync(claudeDir)) {
+  const claudeDir = path18.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);
     return 2;
@@ -35802,7 +37117,7 @@ __export(generate_exports, {
   runGenerate: () => runGenerate
 });
 import { readFile as readFile26, mkdir as mkdir12, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join40, resolve as resolve6 } from "node:path";
+import { join as join45, resolve as resolve11 } from "node:path";
 async function readJsonFile4(filePath) {
   try {
     const raw = await readFile26(filePath, "utf-8");
@@ -35813,7 +37128,7 @@ async function readJsonFile4(filePath) {
 }
 async function readPkgName(absPath) {
   try {
-    const raw = await readFile26(join40(absPath, "package.json"), "utf-8");
+    const raw = await readFile26(join45(absPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" ? pkg.name : null;
   } catch {
@@ -35824,10 +37139,10 @@ async function runGenerate(opts) {
   const projectDir = opts.projectDir ?? opts["project-dir"] ?? process.cwd();
   const dryRun = opts.dryRun ?? opts["dryRun"] ?? false;
   const check = opts.check ?? opts["check"] ?? false;
-  const rootDir = resolve6(projectDir);
+  const rootDir = resolve11(projectDir);
   let packageManager;
   try {
-    const raw = await readFile26(join40(rootDir, "package.json"), "utf-8");
+    const raw = await readFile26(join45(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.packageManager === "string") {
       packageManager = pkg.packageManager;
@@ -35835,7 +37150,7 @@ async function runGenerate(opts) {
   } catch {
   }
   const serverJson = await readJsonFile4(
-    join40(rootDir, ".codebyplan", "server.json")
+    join45(rootDir, ".codebyplan", "server.json")
   );
   const ports = [];
   for (const alloc of serverJson?.port_allocations ?? []) {
@@ -35848,7 +37163,7 @@ async function runGenerate(opts) {
     }
   }
   const gitJson = await readJsonFile4(
-    join40(rootDir, ".codebyplan", "git.json")
+    join45(rootDir, ".codebyplan", "git.json")
   );
   const branchModel = gitJson?.branch_config?.production ? {
     production: gitJson.branch_config.production,
@@ -35857,7 +37172,7 @@ async function runGenerate(opts) {
     )
   } : void 0;
   const shipmentJson = await readJsonFile4(
-    join40(rootDir, ".codebyplan", "shipment.json")
+    join45(rootDir, ".codebyplan", "shipment.json")
   );
   const shipmentSurfaces = [];
   const rawSurfaces = shipmentJson?.shipment?.surfaces ?? shipmentJson?.surfaces ?? {};
@@ -35928,7 +37243,7 @@ async function runGenerate(opts) {
   const structureMdContent = generateStructureMd(config);
   const agentsContent = generateAgentsMd(structureMdContent);
   if (check) {
-    const agentsMdPath2 = join40(rootDir, "AGENTS.md");
+    const agentsMdPath2 = join45(rootDir, "AGENTS.md");
     let existingAgents = null;
     try {
       existingAgents = await readFile26(agentsMdPath2, "utf-8");
@@ -35967,13 +37282,13 @@ async function runGenerate(opts) {
     process.stdout.write(agentsContent);
     return;
   }
-  const outputDir = join40(rootDir, ".claude", "generated");
+  const outputDir = join45(rootDir, ".claude", "generated");
   await mkdir12(outputDir, { recursive: true });
-  const outputPath = join40(outputDir, "structure.md");
+  const outputPath = join45(outputDir, "structure.md");
   await writeFile20(outputPath, structureMdContent, "utf-8");
   process.stdout.write(`Wrote: .claude/generated/structure.md
 `);
-  const agentsMdPath = join40(rootDir, "AGENTS.md");
+  const agentsMdPath = join45(rootDir, "AGENTS.md");
   let existingAgentsContent = null;
   try {
     existingAgentsContent = await readFile26(agentsMdPath, "utf-8");
@@ -36005,7 +37320,7 @@ __export(readme_exports, {
   runReadmeCommand: () => runReadmeCommand
 });
 import { readFile as readFile27, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join41, resolve as resolve7, relative as relative8 } from "node:path";
+import { join as join46, resolve as resolve12, relative as relative8 } from "node:path";
 async function readJsonFile5(filePath) {
   try {
     const raw = await readFile27(filePath, "utf-8");
@@ -36077,7 +37392,7 @@ async function discoverUnits(rootDir, rootPkgJson) {
   const discovered = await discoverMonorepoApps(rootDir);
   for (const app of discovered) {
     const pkgJson = await readJsonFile5(
-      join41(app.absPath, "package.json")
+      join46(app.absPath, "package.json")
     );
     pkgJsonByPath.set(app.absPath, pkgJson);
     allPackages.push({
@@ -36101,9 +37416,9 @@ async function runReadme(opts) {
   const dryRun = opts.dryRun ?? opts["dryRun"] ?? false;
   const check = opts.check ?? opts["check"] ?? false;
   const init = opts.init ?? opts["init"] ?? false;
-  const rootDir = resolve7(projectDir);
+  const rootDir = resolve12(projectDir);
   const rootPkgJson = await readJsonFile5(
-    join41(rootDir, "package.json")
+    join46(rootDir, "package.json")
   );
   const { units, allPackages, pkgJsonByPath } = await discoverUnits(
     rootDir,
@@ -36112,8 +37427,8 @@ async function runReadme(opts) {
   const driftUnits = [];
   const missingUnits = [];
   for (const unit of units) {
-    const readmePath = join41(unit.absPath, "README.md");
-    const relPath = unit.isRoot ? "README.md" : join41(relative8(rootDir, unit.absPath), "README.md");
+    const readmePath = join46(unit.absPath, "README.md");
+    const relPath = unit.isRoot ? "README.md" : join46(relative8(rootDir, unit.absPath), "README.md");
     let existingContent = null;
     try {
       existingContent = await readFile27(readmePath, "utf-8");
@@ -36303,11 +37618,11 @@ import {
   rmdir,
   readdir as readdir6
 } from "node:fs/promises";
-import { existsSync as existsSync15 } from "node:fs";
-import { join as join42, resolve as resolve8, dirname as dirname12, sep as sep3 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join47, resolve as resolve13, dirname as dirname14, sep as sep3 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function encodeProjectPath(absPath) {
-  return resolve8(absPath).replace(/[/\\]/g, "-");
+  return resolve13(absPath).replace(/[/\\]/g, "-");
 }
 function resolveAutoMemoryDir(opts) {
   if (opts.autoMemoryDir) {
@@ -36315,7 +37630,7 @@ function resolveAutoMemoryDir(opts) {
   }
   const projectDir = opts.projectDir ?? process.cwd();
   const encoded = encodeProjectPath(projectDir);
-  return join42(homedir8(), ".claude", "projects", encoded, "memory");
+  return join47(homedir8(), ".claude", "projects", encoded, "memory");
 }
 function parseFrontmatter(content) {
   content = content.replace(/\r\n/g, "\n");
@@ -36381,7 +37696,7 @@ async function inventoryFiles(dir) {
   }
   const results = [];
   for (const filename of filenames) {
-    const sourcePath = join42(dir, filename);
+    const sourcePath = join47(dir, filename);
     let raw;
     try {
       raw = await readFile28(sourcePath, "utf-8");
@@ -36464,15 +37779,15 @@ function buildPlan(entries, opts) {
   return plan;
 }
 async function applyPlan(plan, opts) {
-  const projectDir = resolve8(opts.projectDir);
+  const projectDir = resolve13(opts.projectDir);
   const dryRun = opts.dryRun ?? false;
   for (const entry of plan.entries) {
     if (entry.suggested_action !== "keep") continue;
     if (!entry.suggested_target?.startsWith("nested:")) continue;
     const relPath = entry.suggested_target.slice("nested:".length);
-    const targetDir = resolve8(join42(projectDir, relPath));
-    const targetFile = join42(targetDir, "CLAUDE.md");
-    if (!targetDir.startsWith(resolve8(projectDir) + sep3)) {
+    const targetDir = resolve13(join47(projectDir, relPath));
+    const targetFile = join47(targetDir, "CLAUDE.md");
+    if (!targetDir.startsWith(resolve13(projectDir) + sep3)) {
       process.stderr.write(
         `migrate-memory: skipping unsafe suggested_target "${entry.suggested_target}" \u2014 resolves outside projectDir
 `
@@ -36490,8 +37805,8 @@ ${anchor}
     if (dryRun) {
       process.stdout.write(`[dry-run] Would create/append: ${targetFile}
 `);
-      if (resolve8(entry.source_path).startsWith(
-        resolve8(plan.auto_memory_dir) + sep3
+      if (resolve13(entry.source_path).startsWith(
+        resolve13(plan.auto_memory_dir) + sep3
       )) {
         process.stdout.write(
           `[dry-run] Would delete migrated keep source: ${entry.source_path}
@@ -36509,7 +37824,7 @@ ${anchor}
     if (!existing.includes(anchor)) {
       await writeFile22(targetFile, existing + appendContent, "utf-8");
     }
-    if (resolve8(entry.source_path).startsWith(resolve8(plan.auto_memory_dir) + sep3)) {
+    if (resolve13(entry.source_path).startsWith(resolve13(plan.auto_memory_dir) + sep3)) {
       try {
         await unlink6(entry.source_path);
       } catch {
@@ -36521,7 +37836,7 @@ ${anchor}
       );
     }
   }
-  const rootClaudeMd = join42(projectDir, ".claude", "CLAUDE.md");
+  const rootClaudeMd = join47(projectDir, ".claude", "CLAUDE.md");
   if (dryRun) {
     process.stdout.write(
       `[dry-run] Would ensure ${rootClaudeMd} contains: ${IMPORT_LINE}
@@ -36532,7 +37847,7 @@ ${anchor}
     try {
       claudeMdContent = await readFile28(rootClaudeMd, "utf-8");
     } catch {
-      await mkdir13(dirname12(rootClaudeMd), { recursive: true });
+      await mkdir13(dirname14(rootClaudeMd), { recursive: true });
     }
     if (!claudeMdContent.includes(IMPORT_LINE)) {
       await writeFile22(
@@ -36546,8 +37861,8 @@ ${IMPORT_LINE}
   }
   for (const entry of plan.entries) {
     if (entry.suggested_action !== "drop") continue;
-    if (!resolve8(entry.source_path).startsWith(
-      resolve8(plan.auto_memory_dir) + sep3
+    if (!resolve13(entry.source_path).startsWith(
+      resolve13(plan.auto_memory_dir) + sep3
     )) {
       process.stderr.write(
         `migrate-memory: skipping delete of "${entry.source_path}" \u2014 resolves outside auto_memory_dir
@@ -36565,13 +37880,13 @@ ${IMPORT_LINE}
     } catch {
     }
   }
-  const memoryMd = join42(plan.auto_memory_dir, "MEMORY.md");
-  const safeRmdirBase = join42(homedir8(), ".claude", "projects");
+  const memoryMd = join47(plan.auto_memory_dir, "MEMORY.md");
+  const safeRmdirBase = join47(homedir8(), ".claude", "projects");
   if (dryRun) {
     process.stdout.write(`[dry-run] Would delete MEMORY.md: ${memoryMd}
 `);
   } else {
-    if (resolve8(plan.auto_memory_dir).startsWith(safeRmdirBase + sep3)) {
+    if (resolve13(plan.auto_memory_dir).startsWith(safeRmdirBase + sep3)) {
       try {
         await unlink6(memoryMd);
       } catch {
@@ -36589,7 +37904,7 @@ ${IMPORT_LINE}
 `
     );
   } else {
-    if (!resolve8(plan.auto_memory_dir).startsWith(safeRmdirBase + sep3)) {
+    if (!resolve13(plan.auto_memory_dir).startsWith(safeRmdirBase + sep3)) {
       process.stderr.write(
         `migrate-memory: skipping rmdir of "${plan.auto_memory_dir}" \u2014 not under ~/.claude/projects
 `
@@ -36619,7 +37934,7 @@ async function runMigrateMemory(opts) {
   if (applyFile) {
     let planJson;
     try {
-      planJson = await readFile28(resolve8(applyFile), "utf-8");
+      planJson = await readFile28(resolve13(applyFile), "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(
@@ -36647,7 +37962,7 @@ async function runMigrateMemory(opts) {
     );
     return;
   }
-  if (!existsSync15(autoMemoryDir)) {
+  if (!existsSync20(autoMemoryDir)) {
     process.stdout.write(
       JSON.stringify(
         {
@@ -36689,8 +38004,8 @@ var init_migrate_memory = __esm({
 });
 
 // src/lib/claude-mode-audit.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync14, existsSync as existsSync16 } from "node:fs";
-import { join as join43, basename as basename2 } from "node:path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync19, existsSync as existsSync21 } from "node:fs";
+import { join as join48, basename as basename2 } from "node:path";
 function parseFrontmatter2(content) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
   if (!match) return {};
@@ -36708,7 +38023,7 @@ function parseFrontmatter2(content) {
   return result;
 }
 function auditAgent(filePath) {
-  const content = readFileSync14(filePath, "utf-8");
+  const content = readFileSync19(filePath, "utf-8");
   const fm = parseFrontmatter2(content);
   const agentName = fm.name ?? basename2(filePath, ".md");
   const expected = AGENT_EXCEPTIONS[agentName] ?? AGENT_DEFAULT;
@@ -36740,7 +38055,7 @@ function auditAgent(filePath) {
   };
 }
 function auditSkill(filePath) {
-  const content = readFileSync14(filePath, "utf-8");
+  const content = readFileSync19(filePath, "utf-8");
   const fm = parseFrontmatter2(content);
   const model = fm.model ?? null;
   const effort = fm.effort ?? null;
@@ -36767,20 +38082,20 @@ function auditSkill(filePath) {
 }
 function auditMode(templatesDir) {
   const entries = [];
-  const agentsDir = join43(templatesDir, "agents");
-  if (existsSync16(agentsDir)) {
-    const agentFiles = readdirSync6(agentsDir).filter((f) => f.endsWith(".md")).sort();
+  const agentsDir = join48(templatesDir, "agents");
+  if (existsSync21(agentsDir)) {
+    const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md")).sort();
     for (const f of agentFiles) {
-      entries.push(auditAgent(join43(agentsDir, f)));
+      entries.push(auditAgent(join48(agentsDir, f)));
     }
   }
-  const skillsDir = join43(templatesDir, "skills");
-  if (existsSync16(skillsDir)) {
-    const skillDirs = readdirSync6(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  const skillsDir = join48(templatesDir, "skills");
+  if (existsSync21(skillsDir)) {
+    const skillDirs = readdirSync7(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
     for (const dir of skillDirs) {
-      if (existsSync16(join43(skillsDir, dir, "PROVENANCE.md"))) continue;
-      const skillMd = join43(skillsDir, dir, "SKILL.md");
-      if (existsSync16(skillMd)) {
+      if (existsSync21(join48(skillsDir, dir, "PROVENANCE.md"))) continue;
+      const skillMd = join48(skillsDir, dir, "SKILL.md");
+      if (existsSync21(skillMd)) {
         entries.push(auditSkill(skillMd));
       }
     }
@@ -36807,7 +38122,7 @@ var audit_mode_exports = {};
 __export(audit_mode_exports, {
   runAuditMode: () => runAuditMode
 });
-function printHelp3() {
+function printHelp5() {
   process.stdout.write(
     "\n  codebyplan claude audit-mode\n\n  Audit model/effort frontmatter convention across authoring templates.\n\n  Scans templates/agents/*.md and templates/skills/*/SKILL.md.\n  Exits 0 when all files comply; exits 1 on any gap.\n\n  Flags:\n    --json   Emit entries array as JSON\n\n"
   );
@@ -36846,7 +38161,7 @@ ${total} audited, ${ok} ok, ${gaps} gap${gaps !== 1 ? "s" : ""}
 async function runAuditMode(args) {
   const first = args[0];
   if (first === "--help" || first === "-h" || first === "help") {
-    printHelp3();
+    printHelp5();
     process.exit(0);
   }
   const { booleans } = parseFlagsFromArgs(args);
@@ -37037,16 +38352,16 @@ var new_migration_exports = {};
 __export(new_migration_exports, {
   newMigration: () => newMigration
 });
-import * as fs13 from "node:fs";
-import * as path14 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 function slugify(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
 function newMigration(args, deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const genTimestamp = deps.generateTimestamp ?? generateMonotonicTimestamp;
-  const mkdirSync7 = deps.mkdirSyncFn ?? ((dir, opts) => fs13.mkdirSync(dir, opts));
-  const writeFileSync9 = deps.writeFileSyncFn ?? ((filePath2, content) => fs13.writeFileSync(filePath2, content));
+  const mkdirSync11 = deps.mkdirSyncFn ?? ((dir, opts) => fs19.mkdirSync(dir, opts));
+  const writeFileSync12 = deps.writeFileSyncFn ?? ((filePath2, content) => fs19.writeFileSync(filePath2, content));
   const rawName = args[0];
   if (!rawName) {
     process.stderr.write(
@@ -37059,11 +38374,11 @@ function newMigration(args, deps = {}) {
   }
   const slug = slugify(rawName);
   const stamp = genTimestamp({ cwd });
-  const migrationsDir = path14.join(cwd, "supabase", "migrations");
+  const migrationsDir = path19.join(cwd, "supabase", "migrations");
   const filename = `${stamp}_${slug}.sql`;
-  const filePath = path14.join(migrationsDir, filename);
-  mkdirSync7(migrationsDir, { recursive: true });
-  writeFileSync9(filePath, "");
+  const filePath = path19.join(migrationsDir, filename);
+  mkdirSync11(migrationsDir, { recursive: true });
+  writeFileSync12(filePath, "");
   process.stdout.write(JSON.stringify({ path: filePath }) + "\n");
   return 0;
 }
@@ -37107,7 +38422,7 @@ function defaultGetPrNumber(cwd, run) {
 async function previewCheck(args, deps = {}) {
   const cwd = deps.cwd ?? process.cwd();
   const run = deps.run ?? defaultRun3;
-  const sleep3 = deps.sleep ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, ms)));
+  const sleep3 = deps.sleep ?? ((ms) => new Promise((resolve16) => setTimeout(resolve16, ms)));
   const getPrNumber = deps.getPrNumber ?? defaultGetPrNumber;
   const poll = deps.pollCheck ?? pollGhPreviewCheck;
   let mode = "pre_merge";
@@ -37137,7 +38452,7 @@ var init_preview_check = __esm({
 
 // src/lib/session.ts
 import { spawnSync as spawnSync13 } from "node:child_process";
-import * as path15 from "node:path";
+import * as path20 from "node:path";
 function defaultRun4(cmd, args, cwd) {
   const result = spawnSync13(cmd, args, {
     cwd,
@@ -37167,7 +38482,7 @@ function homeFf(opts = {}) {
       reason: "git rev-parse --show-toplevel failed"
     };
   }
-  const folder = path15.basename(repoRoot);
+  const folder = path20.basename(repoRoot);
   let current;
   try {
     current = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd).trim();
@@ -37734,13 +39049,13 @@ function validateWaves(waves) {
       pathOwners.set(file, owners);
     }
   }
-  for (const [path16, owners] of pathOwners) {
+  for (const [path21, owners] of pathOwners) {
     if (owners.length > 1) {
       violations.push({
         invariant: "I",
         code: "DUPLICATE_FILE",
-        message: `File "${path16}" appears in multiple waves: ${owners.join(", ")}.`,
-        detail: { path: path16, waves: owners }
+        message: `File "${path21}" appears in multiple waves: ${owners.join(", ")}.`,
+        detail: { path: path21, waves: owners }
       });
     }
   }
@@ -37836,12 +39151,12 @@ __export(validate_waves_exports, {
 });
 import { readFile as readFile29 } from "node:fs/promises";
 async function readStdin() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve16, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => chunks.push(chunk));
     process.stdin.on(
       "end",
-      () => resolve11(Buffer.concat(chunks).toString("utf-8"))
+      () => resolve16(Buffer.concat(chunks).toString("utf-8"))
     );
     process.stdin.on("error", reject);
   });
@@ -37933,12 +39248,12 @@ var init_validate_waves2 = __esm({
 });
 
 // src/cli/worktree/path.ts
-import { dirname as dirname13, basename as basename4, join as join45 } from "node:path";
+import { dirname as dirname15, basename as basename4, join as join50 } from "node:path";
 function computeWorktreePath(cwd, checkpointNumber) {
-  const parent = dirname13(cwd);
+  const parent = dirname15(cwd);
   const base = basename4(cwd);
   const nnn = String(checkpointNumber).padStart(3, "0");
-  return join45(parent, `${base}-CHK-${nnn}`);
+  return join50(parent, `${base}-CHK-${nnn}`);
 }
 var init_path = __esm({
   "src/cli/worktree/path.ts"() {
@@ -37947,7 +39262,7 @@ var init_path = __esm({
 });
 
 // src/cli/worktree/add.ts
-import { join as join46, basename as basename5 } from "node:path";
+import { join as join51, basename as basename5 } from "node:path";
 import { mkdir as mkdir14, readFile as readFile30, writeFile as writeFile23 } from "node:fs/promises";
 import { spawnSync as spawnSync16 } from "node:child_process";
 async function defaultGetRepoId(cwd) {
@@ -37991,33 +39306,33 @@ function defaultGitRun(args, cwd) {
   };
 }
 async function defaultCopyConfigStubs(srcCwd, destPath) {
-  await mkdir14(join46(destPath, ".codebyplan"), { recursive: true });
+  await mkdir14(join51(destPath, ".codebyplan"), { recursive: true });
   const topLevelStubs = [".mcp.json", ".env.local"];
   for (const stub of topLevelStubs) {
     try {
-      const content = await readFile30(join46(srcCwd, stub), "utf-8");
-      await writeFile23(join46(destPath, stub), content, "utf-8");
+      const content = await readFile30(join51(srcCwd, stub), "utf-8");
+      await writeFile23(join51(destPath, stub), content, "utf-8");
     } catch {
     }
   }
   try {
     const content = await readFile30(
-      join46(srcCwd, ".codebyplan", "repo.json"),
+      join51(srcCwd, ".codebyplan", "repo.json"),
       "utf-8"
     );
     await writeFile23(
-      join46(destPath, ".codebyplan", "repo.json"),
+      join51(destPath, ".codebyplan", "repo.json"),
       content,
       "utf-8"
     );
   } catch {
   }
 }
-async function defaultRegisterWorktree(repoId, name, path16) {
+async function defaultRegisterWorktree(repoId, name, path21) {
   const res = await apiPost("/worktrees", {
     repo_id: repoId,
     name,
-    path: path16,
+    path: path21,
     status: "active"
   });
   return { worktree_id: res.data.id };
@@ -38051,7 +39366,7 @@ async function runWorktreeAdd(args, deps = {}) {
   const getRepoId = deps.getRepoId ?? defaultGetRepoId;
   const lookupBranch = deps.lookupBranch ?? defaultLookupBranch;
   const gitRun = deps.gitRun ?? defaultGitRun;
-  const sleep3 = deps.sleep ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, ms)));
+  const sleep3 = deps.sleep ?? ((ms) => new Promise((resolve16) => setTimeout(resolve16, ms)));
   const copyConfigStubs = deps.copyConfigStubs ?? defaultCopyConfigStubs;
   const registerWorktree = deps.registerWorktree ?? defaultRegisterWorktree;
   try {
@@ -38167,7 +39482,7 @@ var init_add = __esm({
 });
 
 // src/cli/worktree/create.ts
-import { join as join47 } from "node:path";
+import { join as join52 } from "node:path";
 async function defaultGetRepoIdentity(cwd) {
   const found = await findCodebyplanConfig(cwd);
   const contents = found?.contents ?? null;
@@ -38179,11 +39494,11 @@ async function defaultGetRepoIdentity(cwd) {
     project_id: typeof contents?.["project_id"] === "string" ? contents["project_id"] : void 0
   };
 }
-async function defaultRegisterWorktree2(repoId, name, path16) {
+async function defaultRegisterWorktree2(repoId, name, path21) {
   const res = await apiPost("/worktrees", {
     repo_id: repoId,
     name,
-    path: path16,
+    path: path21,
     status: "active"
   });
   return { worktree_id: res.data.id };
@@ -38222,7 +39537,7 @@ async function runWorktreeCreate(args, deps = {}) {
     );
     return 1;
   }
-  const worktreePath = explicitPath ?? join47(cwd, "..", name);
+  const worktreePath = explicitPath ?? join52(cwd, "..", name);
   const deviceId = await getDeviceId(cwd);
   let filesWritten = false;
   try {
@@ -38708,13 +40023,13 @@ var init_e2e = __esm({
 
 // src/cli/e2e/verify-round.ts
 import { readFile as readFile31 } from "node:fs/promises";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 async function defaultFetchRounds(taskId) {
   return mcpCall("get_rounds", { task_id: taskId });
 }
 async function defaultReadE2eConfig(cwd) {
   try {
-    const p = resolve9(cwd, ".codebyplan", "e2e.json");
+    const p = resolve14(cwd, ".codebyplan", "e2e.json");
     const raw = await readFile31(p, "utf-8");
     return JSON.parse(raw);
   } catch {
@@ -38840,7 +40155,7 @@ var doctor_exports = {};
 __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
-import { execSync as execSync9 } from "node:child_process";
+import { execSync as execSync10 } from "node:child_process";
 async function checkAuth() {
   try {
     await validateAuth();
@@ -38861,7 +40176,7 @@ async function checkVersion() {
     const installed = VERSION;
     let gitRoot = null;
     try {
-      gitRoot = execSync9("git rev-parse --show-toplevel", {
+      gitRoot = execSync10("git rev-parse --show-toplevel", {
         encoding: "utf-8"
       }).trim();
     } catch {
@@ -38968,7 +40283,7 @@ function printHuman(result) {
 
 `);
 }
-function printHelp4() {
+function printHelp6() {
   process.stdout.write(
     "\n  codebyplan doctor [--json]\n\n  Run diagnostics: auth, version, worktree.\n  Always exits 0 \u2014 safe for scripted use.\n\n  Flags:\n    --json   Emit structured JSON instead of the human table\n\n"
   );
@@ -38976,7 +40291,7 @@ function printHelp4() {
 async function runDoctor(args) {
   const first = args[0];
   if (first === "--help" || first === "-h" || first === "help") {
-    printHelp4();
+    printHelp6();
     process.exit(0);
   }
   const { booleans } = parseFlagsFromArgs(args);
@@ -39013,13 +40328,13 @@ var init_doctor = __esm({
 
 // src/index.ts
 init_version();
-import { readFileSync as readFileSync15 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+import { readFileSync as readFileSync20 } from "node:fs";
+import { resolve as resolve15 } from "node:path";
 void (async () => {
   if (!process.env.CODEBYPLAN_API_KEY) {
     try {
-      const envPath = resolve10(process.cwd(), ".env.local");
-      const content = readFileSync15(envPath, "utf-8");
+      const envPath = resolve15(process.cwd(), ".env.local");
+      const content = readFileSync20(envPath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
@@ -39156,6 +40471,16 @@ void (async () => {
     await runScaffoldPublishWorkflowCommand2(process.argv.slice(3));
     process.exit(process.exitCode ?? 0);
   }
+  if (arg === "ci") {
+    const { runCiCommand: runCiCommand2 } = await Promise.resolve().then(() => (init_ci(), ci_exports));
+    await runCiCommand2(process.argv.slice(3));
+    process.exit(process.exitCode ?? 0);
+  }
+  if (arg === "cd") {
+    const { runCdCommand: runCdCommand2 } = await Promise.resolve().then(() => (init_cd(), cd_exports));
+    await runCdCommand2(process.argv.slice(3));
+    process.exit(process.exitCode ?? 0);
+  }
   if (arg === "resolve-worktree") {
     const { runResolveWorktree: runResolveWorktree2 } = await Promise.resolve().then(() => (init_resolve_worktree2(), resolve_worktree_exports));
     await runResolveWorktree2();
@@ -39474,6 +40799,8 @@ void (async () => {
     codebyplan tech-stack            Detect and sync tech stack dependencies
                                      (--full-tech-stack: sync every local worktree on this device)
     codebyplan eslint                ESLint config management (init)
+    codebyplan ci                    CI configuration management (init / scaffold-workflow / enforce-check)
+    codebyplan cd                    CD configuration management (init / scaffold-workflow)
     codebyplan check                 Run unified check matrix (lint, tsc, tests, audit)
                                      (--scope <round|task|merged>, --files <csv>, --json)
     codebyplan lsp                   Detect tech stack and enable LSP plugins in Claude Code