prjct-cli 1.7.0 → 1.7.1

package/dist/bin/prjct.mjs

@@ -932,6 +932,60 @@ var init_author_detector = __esm({
   }
 });
 
+// core/storage/safe-reader.ts
+import fs4 from "node:fs/promises";
+async function safeRead(filePath, schema) {
+  let content;
+  try {
+    content = await fs4.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    await createBackup(filePath, content);
+    logCorruption(filePath, "Malformed JSON");
+    return null;
+  }
+  const result = schema.safeParse(raw);
+  if (result.success) {
+    return raw;
+  }
+  await createBackup(filePath, content);
+  logCorruption(filePath, formatZodError(result.error));
+  return null;
+}
+async function createBackup(filePath, content) {
+  const backupPath = `${filePath}.backup`;
+  try {
+    await fs4.writeFile(backupPath, content, "utf-8");
+  } catch {
+  }
+}
+function logCorruption(filePath, reason2) {
+  console.error(`[prjct] Warning: Corrupted storage file: ${filePath}`);
+  console.error(`[prjct]   Reason: ${reason2}`);
+  console.error(`[prjct]   A .backup file has been created. Returning defaults.`);
+}
+function formatZodError(error) {
+  return error.issues.slice(0, 3).map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+}
+var init_safe_reader = __esm({
+  "core/storage/safe-reader.ts"() {
+    "use strict";
+    init_fs();
+    __name(safeRead, "safeRead");
+    __name(createBackup, "createBackup");
+    __name(logCorruption, "logCorruption");
+    __name(formatZodError, "formatZodError");
+  }
+});
+
 // core/utils/file-helper.ts
 var file_helper_exports = {};
 __export(file_helper_exports, {
@@ -958,11 +1012,15 @@ __export(file_helper_exports, {
   writeJson: () => writeJson,
   writeLines: () => writeLines
 });
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import path4 from "node:path";
-async function readJson(filePath, defaultValue = null) {
+async function readJson(filePath, defaultValue = null, schema) {
+  if (schema) {
+    const data = await safeRead(filePath, schema);
+    return data ?? defaultValue;
+  }
   try {
-    const content = await fs4.readFile(filePath, "utf-8");
+    const content = await fs5.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -973,11 +1031,11 @@ async function readJson(filePath, defaultValue = null) {
 }
 async function writeJson(filePath, data, indent = 2) {
   const content = JSON.stringify(data, null, indent);
-  await fs4.writeFile(filePath, content, "utf-8");
+  await fs5.writeFile(filePath, content, "utf-8");
 }
 async function readFile(filePath, defaultValue = "") {
   try {
-    return await fs4.readFile(filePath, "utf-8");
+    return await fs5.readFile(filePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return defaultValue;
@@ -987,32 +1045,32 @@ async function readFile(filePath, defaultValue = "") {
 }
 async function writeFile(filePath, content) {
   const dir = path4.dirname(filePath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.writeFile(filePath, content, "utf-8");
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(filePath, content, "utf-8");
 }
 async function atomicWrite(filePath, content) {
   const dir = path4.dirname(filePath);
-  await fs4.mkdir(dir, { recursive: true });
+  await fs5.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.${Date.now()}.tmp`;
-  await fs4.writeFile(tempPath, content, "utf-8");
-  await fs4.rename(tempPath, filePath);
+  await fs5.writeFile(tempPath, content, "utf-8");
+  await fs5.rename(tempPath, filePath);
 }
 async function appendToFile(filePath, content) {
-  await fs4.appendFile(filePath, content, "utf-8");
+  await fs5.appendFile(filePath, content, "utf-8");
 }
 async function appendLine(filePath, line) {
   const dir = path4.dirname(filePath);
-  await fs4.mkdir(dir, { recursive: true });
-  await fs4.appendFile(filePath, `${line}
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.appendFile(filePath, `${line}
 `, "utf-8");
 }
 async function prependToFile(filePath, content) {
   try {
-    const existing = await fs4.readFile(filePath, "utf-8");
-    await fs4.writeFile(filePath, content + existing, "utf-8");
+    const existing = await fs5.readFile(filePath, "utf-8");
+    await fs5.writeFile(filePath, content + existing, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
-      await fs4.writeFile(filePath, content, "utf-8");
+      await fs5.writeFile(filePath, content, "utf-8");
     } else {
       throw error;
     }
@@ -1020,7 +1078,7 @@ async function prependToFile(filePath, content) {
 }
 async function fileExists2(filePath) {
   try {
-    await fs4.access(filePath);
+    await fs5.access(filePath);
     return true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -1031,7 +1089,7 @@ async function fileExists2(filePath) {
 }
 async function dirExists(dirPath) {
   try {
-    const stats = await fs4.stat(dirPath);
+    const stats = await fs5.stat(dirPath);
     return stats.isDirectory();
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -1041,11 +1099,11 @@ async function dirExists(dirPath) {
   }
 }
 async function ensureDir(dirPath) {
-  await fs4.mkdir(dirPath, { recursive: true });
+  await fs5.mkdir(dirPath, { recursive: true });
 }
 async function deleteFile(filePath) {
   try {
-    await fs4.unlink(filePath);
+    await fs5.unlink(filePath);
     return true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -1056,7 +1114,7 @@ async function deleteFile(filePath) {
 }
 async function deleteDir(dirPath) {
   try {
-    await fs4.rm(dirPath, { recursive: true, force: true });
+    await fs5.rm(dirPath, { recursive: true, force: true });
     return true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -1067,7 +1125,7 @@ async function deleteDir(dirPath) {
 }
 async function listFiles(dirPath, options = {}) {
   try {
-    const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs5.readdir(dirPath, { withFileTypes: true });
     let files = entries;
     if (options.filesOnly) {
       files = files.filter((entry) => entry.isFile());
@@ -1087,18 +1145,18 @@ async function listFiles(dirPath, options = {}) {
   }
 }
 async function getFileSize(filePath) {
-  const stats = await fs4.stat(filePath);
+  const stats = await fs5.stat(filePath);
   return stats.size;
 }
 async function getFileModifiedTime(filePath) {
-  const stats = await fs4.stat(filePath);
+  const stats = await fs5.stat(filePath);
   return stats.mtime;
 }
 async function copyFile(sourcePath, destPath) {
-  await fs4.copyFile(sourcePath, destPath);
+  await fs5.copyFile(sourcePath, destPath);
 }
 async function moveFile(oldPath, newPath) {
-  await fs4.rename(oldPath, newPath);
+  await fs5.rename(oldPath, newPath);
 }
 async function readLines(filePath) {
   const content = await readFile(filePath, "");
@@ -1117,6 +1175,7 @@ function getFileNameWithoutExtension(filePath) {
 var init_file_helper = __esm({
   "core/utils/file-helper.ts"() {
     "use strict";
+    init_safe_reader();
     init_fs();
     __name(readJson, "readJson");
     __name(writeJson, "writeJson");
@@ -1145,7 +1204,7 @@ var init_file_helper = __esm({
 
 // core/infrastructure/path-manager.ts
 import crypto2 from "node:crypto";
-import fs5 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import os3 from "node:os";
 import path5 from "node:path";
 import { globSync } from "glob";
@@ -1285,17 +1344,17 @@ var init_path_manager = __esm({
         const sessionsDir = path5.join(this.getGlobalProjectPath(projectId), "sessions");
         const sessions = [];
         try {
-          const years = await fs5.readdir(sessionsDir, { withFileTypes: true });
+          const years = await fs6.readdir(sessionsDir, { withFileTypes: true });
           for (const yearEntry of years) {
             if (!yearEntry.isDirectory()) continue;
             if (year && yearEntry.name !== year.toString()) continue;
             const yearPath = path5.join(sessionsDir, yearEntry.name);
-            const months = await fs5.readdir(yearPath, { withFileTypes: true });
+            const months = await fs6.readdir(yearPath, { withFileTypes: true });
             for (const monthEntry of months) {
               if (!monthEntry.isDirectory()) continue;
               if (month && monthEntry.name !== month.toString().padStart(2, "0")) continue;
               const monthPath = path5.join(yearPath, monthEntry.name);
-              const days = await fs5.readdir(monthPath, { withFileTypes: true });
+              const days = await fs6.readdir(monthPath, { withFileTypes: true });
               for (const dayEntry of days) {
                 if (!dayEntry.isDirectory()) continue;
                 sessions.push({
@@ -1333,7 +1392,7 @@ var init_path_manager = __esm({
       async listProjects() {
         try {
           await this.ensureGlobalStructure();
-          const entries = await fs5.readdir(this.globalProjectsDir, { withFileTypes: true });
+          const entries = await fs6.readdir(this.globalProjectsDir, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
         } catch (_error) {
           return [];
@@ -1473,7 +1532,7 @@ var init_path_manager = __esm({
           const packageJsonPath = path5.join(projectPath, "package.json");
           if (await fileExists2(packageJsonPath)) {
             try {
-              const content = await fs5.readFile(packageJsonPath, "utf-8");
+              const content = await fs6.readFile(packageJsonPath, "utf-8");
               const pkg = JSON.parse(content);
               if (pkg.workspaces) {
                 result.isMonorepo = true;
@@ -1496,14 +1555,14 @@ var init_path_manager = __esm({
         let patterns = [];
         try {
           if (type === "pnpm") {
-            const yaml = await fs5.readFile(path5.join(rootPath, "pnpm-workspace.yaml"), "utf-8");
+            const yaml = await fs6.readFile(path5.join(rootPath, "pnpm-workspace.yaml"), "utf-8");
             const match = yaml.match(/packages:\s*\n((?:\s*-\s*.+\n?)+)/);
             if (match) {
               patterns = match[1].split("\n").map((line) => line.replace(/^\s*-\s*['"]?|['"]?\s*$/g, "")).filter(Boolean);
             }
           } else if (type === "npm" || type === "lerna") {
             const packageJsonPath = path5.join(rootPath, "package.json");
-            const content = await fs5.readFile(packageJsonPath, "utf-8");
+            const content = await fs6.readFile(packageJsonPath, "utf-8");
             const pkg = JSON.parse(content);
             if (Array.isArray(pkg.workspaces)) {
               patterns = pkg.workspaces;
@@ -1513,7 +1572,7 @@ var init_path_manager = __esm({
             if (type === "lerna") {
               const lernaPath = path5.join(rootPath, "lerna.json");
               if (await fileExists2(lernaPath)) {
-                const lernaContent = await fs5.readFile(lernaPath, "utf-8");
+                const lernaContent = await fs6.readFile(lernaPath, "utf-8");
                 const lerna = JSON.parse(lernaContent);
                 if (lerna.packages) {
                   patterns = lerna.packages;
@@ -1524,7 +1583,7 @@ var init_path_manager = __esm({
             patterns = ["apps/*", "libs/*", "packages/*"];
           } else if (type === "turborepo") {
             const packageJsonPath = path5.join(rootPath, "package.json");
-            const content = await fs5.readFile(packageJsonPath, "utf-8");
+            const content = await fs6.readFile(packageJsonPath, "utf-8");
             const pkg = JSON.parse(content);
             if (Array.isArray(pkg.workspaces)) {
               patterns = pkg.workspaces;
@@ -1544,7 +1603,7 @@ var init_path_manager = __esm({
               const packageJsonPath = path5.join(packagePath, "package.json");
               if (await fileExists2(packageJsonPath)) {
                 try {
-                  const content = await fs5.readFile(packageJsonPath, "utf-8");
+                  const content = await fs6.readFile(packageJsonPath, "utf-8");
                   const pkg = JSON.parse(content);
                   const prjctMdPath = path5.join(packagePath, "PRJCT.md");
                   packages.push({
@@ -1600,7 +1659,7 @@ var init_path_manager = __esm({
 });
 
 // core/infrastructure/config-manager.ts
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import path6 from "node:path";
 import * as jsonc from "jsonc-parser";
 function parseJsonc(content) {
@@ -1639,7 +1698,7 @@ var init_config_manager = __esm({
       async readConfig(projectPath) {
         try {
           const configPath = path_manager_default.getLocalConfigPath(projectPath);
-          const content = await fs6.readFile(configPath, "utf-8");
+          const content = await fs7.readFile(configPath, "utf-8");
           return parseJsonc(content);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -1655,9 +1714,9 @@ var init_config_manager = __esm({
       async writeConfig(projectPath, config) {
         const configPath = path_manager_default.getLocalConfigPath(projectPath);
         const configDir = path_manager_default.getLegacyPrjctPath(projectPath);
-        await fs6.mkdir(configDir, { recursive: true });
+        await fs7.mkdir(configDir, { recursive: true });
         const content = JSON.stringify(config, null, 2);
-        await fs6.writeFile(configPath, `${content}
+        await fs7.writeFile(configPath, `${content}
 `, "utf-8");
       }
       /**
@@ -1668,7 +1727,7 @@ var init_config_manager = __esm({
       async readGlobalConfig(projectId) {
         try {
           const configPath = path_manager_default.getGlobalProjectConfigPath(projectId);
-          const content = await fs6.readFile(configPath, "utf-8");
+          const content = await fs7.readFile(configPath, "utf-8");
           return parseJsonc(content);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -1686,9 +1745,9 @@ var init_config_manager = __esm({
       async writeGlobalConfig(projectId, config) {
         const configPath = path_manager_default.getGlobalProjectConfigPath(projectId);
         const configDir = path_manager_default.getGlobalProjectPath(projectId);
-        await fs6.mkdir(configDir, { recursive: true });
+        await fs7.mkdir(configDir, { recursive: true });
         const content = JSON.stringify(config, null, 2);
-        await fs6.writeFile(configPath, `${content}
+        await fs7.writeFile(configPath, `${content}
 `, "utf-8");
       }
       /**
@@ -1778,7 +1837,7 @@ var init_config_manager = __esm({
         if (!config || !config.projectId) return true;
         const globalPath = path_manager_default.getGlobalProjectPath(config.projectId);
         try {
-          const coreFiles = await fs6.readdir(path6.join(globalPath, "core"));
+          const coreFiles = await fs7.readdir(path6.join(globalPath, "core"));
           return coreFiles.length === 0;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -1901,7 +1960,7 @@ var init_config_manager = __esm({
 });
 
 // core/infrastructure/editors-config.ts
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import os4 from "node:os";
 import path7 from "node:path";
 var EditorsConfig, editorsConfig, editors_config_default;
@@ -1926,7 +1985,7 @@ var init_editors_config = __esm({
        */
       async ensureConfigDir() {
         try {
-          await fs7.mkdir(this.configDir, { recursive: true });
+          await fs8.mkdir(this.configDir, { recursive: true });
         } catch (error) {
           console.error("[editors-config] Error creating config directory:", getErrorMessage2(error));
         }
@@ -1936,7 +1995,7 @@ var init_editors_config = __esm({
        */
       async loadConfig() {
         try {
-          const content = await fs7.readFile(this.configFile, "utf-8");
+          const content = await fs8.readFile(this.configFile, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (error.code === "ENOENT") {
@@ -1960,7 +2019,7 @@ var init_editors_config = __esm({
             lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
             path: installPath
           };
-          await fs7.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+          await fs8.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
           return true;
         } catch (error) {
           console.error("[editors-config] Error saving config:", getErrorMessage2(error));
@@ -2000,7 +2059,7 @@ var init_editors_config = __esm({
           }
           config.version = version;
           config.lastInstall = (/* @__PURE__ */ new Date()).toISOString();
-          await fs7.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+          await fs8.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
           return true;
         } catch (error) {
           console.error("[editors-config] Error updating version:", getErrorMessage2(error));
@@ -2012,7 +2071,7 @@ var init_editors_config = __esm({
        */
       async configExists() {
         try {
-          await fs7.access(this.configFile);
+          await fs8.access(this.configFile);
           return true;
         } catch (_error) {
           return false;
@@ -2026,7 +2085,7 @@ var init_editors_config = __esm({
         try {
           const exists = await this.configExists();
           if (exists) {
-            await fs7.unlink(this.configFile);
+            await fs8.unlink(this.configFile);
           }
           return true;
         } catch (error) {
@@ -2709,7 +2768,7 @@ __export(session_tracker_exports, {
   default: () => session_tracker_default,
   sessionTracker: () => sessionTracker
 });
-import fs10 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 import path10 from "node:path";
 var SESSION_FILENAME, DEFAULT_IDLE_TIMEOUT_MS, MAX_COMMAND_HISTORY, MAX_FILE_HISTORY, SessionTracker, sessionTracker, session_tracker_default;
 var init_session_tracker = __esm({
@@ -2735,7 +2794,7 @@ var init_session_tracker = __esm({
       async read(projectId) {
         const filePath = this.getPath(projectId);
         try {
-          const content = await fs10.readFile(filePath, "utf-8");
+          const content = await fs11.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -2749,8 +2808,8 @@ var init_session_tracker = __esm({
        */
       async write(projectId, data) {
         const filePath = this.getPath(projectId);
-        await fs10.mkdir(path10.dirname(filePath), { recursive: true });
-        await fs10.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs11.mkdir(path10.dirname(filePath), { recursive: true });
+        await fs11.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
       }
       getDefault() {
         return {
@@ -2912,7 +2971,7 @@ var start_exports = {};
 __export(start_exports, {
   runStart: () => runStart
 });
-import fs11 from "node:fs/promises";
+import fs12 from "node:fs/promises";
 import os5 from "node:os";
 import path11 from "node:path";
 import chalk3 from "chalk";
@@ -3018,14 +3077,14 @@ async function installRouter(provider) {
   }
   try {
     const commandsDir = path11.join(config.configDir, "commands");
-    await fs11.mkdir(commandsDir, { recursive: true });
+    await fs12.mkdir(commandsDir, { recursive: true });
     const { getPackageRoot: getPackageRoot2 } = await Promise.resolve().then(() => (init_version(), version_exports));
     const packageRoot = getPackageRoot2();
     const routerFile = provider === "claude" ? "p.md" : "p.toml";
     const src = path11.join(packageRoot, "templates", "commands", routerFile);
     const dest = path11.join(commandsDir, routerFile);
     if (await fileExists(src)) {
-      await fs11.copyFile(src, dest);
+      await fs12.copyFile(src, dest);
       return true;
     }
     return false;
@@ -3042,16 +3101,16 @@ async function installGlobalConfig(provider) {
     return false;
   }
   try {
-    await fs11.mkdir(config.configDir, { recursive: true });
+    await fs12.mkdir(config.configDir, { recursive: true });
     const { getPackageRoot: getPackageRoot2 } = await Promise.resolve().then(() => (init_version(), version_exports));
     const packageRoot = getPackageRoot2();
     const configFile = provider === "claude" ? "CLAUDE.md" : "GEMINI.md";
     const src = path11.join(packageRoot, "templates", "global", configFile);
     const dest = path11.join(config.configDir, configFile);
     if (await fileExists(src)) {
-      const content = await fs11.readFile(src, "utf-8");
+      const content = await fs12.readFile(src, "utf-8");
       if (await fileExists(dest)) {
-        const existing = await fs11.readFile(dest, "utf-8");
+        const existing = await fs12.readFile(dest, "utf-8");
         const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
         const endMarker = "<!-- prjct:end - DO NOT REMOVE THIS MARKER -->";
         if (existing.includes(startMarker) && existing.includes(endMarker)) {
@@ -3061,14 +3120,14 @@ async function installGlobalConfig(provider) {
             content.indexOf(startMarker),
             content.indexOf(endMarker) + endMarker.length
           );
-          await fs11.writeFile(dest, before + prjctSection + after);
+          await fs12.writeFile(dest, before + prjctSection + after);
         } else {
-          await fs11.writeFile(dest, `${existing}
+          await fs12.writeFile(dest, `${existing}
 
 ${content}`);
         }
       } else {
-        await fs11.writeFile(dest, content);
+        await fs12.writeFile(dest, content);
       }
       return true;
     }
@@ -3082,7 +3141,7 @@ ${content}`);
 }
 async function saveSetupConfig(providers) {
   const configDir = path11.join(os5.homedir(), ".prjct-cli", "config");
-  await fs11.mkdir(configDir, { recursive: true });
+  await fs12.mkdir(configDir, { recursive: true });
   const configPath = path11.join(configDir, "installed-editors.json");
   const config = {
     version: VERSION,
@@ -3093,7 +3152,7 @@ async function saveSetupConfig(providers) {
     lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
     path: path11.join(os5.homedir(), `.${providers[0]}`, "commands")
   };
-  await fs11.writeFile(configPath, JSON.stringify(config, null, 2));
+  await fs12.writeFile(configPath, JSON.stringify(config, null, 2));
 }
 function showCompletion(providers) {
   console.log(`
@@ -3123,7 +3182,7 @@ async function runStart() {
   showBanner();
   const configPath = path11.join(os5.homedir(), ".prjct-cli", "config", "installed-editors.json");
   if (await fileExists(configPath)) {
-    const existing = JSON.parse(await fs11.readFile(configPath, "utf-8"));
+    const existing = JSON.parse(await fs12.readFile(configPath, "utf-8"));
     if (existing.version === VERSION) {
       console.log(`  ${chalk3.yellow("\u2139")} Already configured for v${VERSION}`);
       console.log(`  ${chalk3.dim("Run with --force to reconfigure")}
@@ -3477,7 +3536,7 @@ var init_cache = __esm({
 });
 
 // core/storage/storage-manager.ts
-import fs12 from "node:fs/promises";
+import fs13 from "node:fs/promises";
 import path12 from "node:path";
 var StorageManager;
 var init_storage_manager = __esm({
@@ -3488,15 +3547,18 @@ var init_storage_manager = __esm({
     init_fs();
     init_cache();
     init_date_helper();
+    init_safe_reader();
     StorageManager = class {
       static {
         __name(this, "StorageManager");
       }
       filename;
       cache;
-      constructor(filename) {
+      schema;
+      constructor(filename, schema) {
         this.filename = filename;
         this.cache = new TTLCache({ ttl: 5e3, maxSize: 50 });
+        this.schema = schema ?? null;
       }
       /**
        * Get file path for storage JSON
@@ -3513,7 +3575,9 @@ var init_storage_manager = __esm({
         return path_manager_default.getFilePath(projectId, layer, mdFilename);
       }
       /**
-       * Read data from storage
+       * Read data from storage with optional Zod validation.
+       * When a schema is provided (via constructor), validates after JSON.parse.
+       * On corruption: creates .backup file, logs warning, returns default.
        */
       async read(projectId) {
         const cached = this.cache.get(projectId);
@@ -3521,8 +3585,16 @@ var init_storage_manager = __esm({
           return cached;
         }
         const filePath = this.getStoragePath(projectId);
+        if (this.schema) {
+          const data = await safeRead(filePath, this.schema);
+          if (data !== null) {
+            this.cache.set(projectId, data);
+            return data;
+          }
+          return this.getDefault();
+        }
         try {
-          const content = await fs12.readFile(filePath, "utf-8");
+          const content = await fs13.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
           this.cache.set(projectId, data);
           return data;
@@ -3539,13 +3611,13 @@ var init_storage_manager = __esm({
       async write(projectId, data) {
         const storagePath = this.getStoragePath(projectId);
         const contextPath = this.getContextPath(projectId, this.getMdFilename());
-        await fs12.mkdir(path12.dirname(storagePath), { recursive: true });
-        await fs12.mkdir(path12.dirname(contextPath), { recursive: true });
+        await fs13.mkdir(path12.dirname(storagePath), { recursive: true });
+        await fs13.mkdir(path12.dirname(contextPath), { recursive: true });
         const tempPath = `${storagePath}.${Date.now()}.tmp`;
-        await fs12.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-        await fs12.rename(tempPath, storagePath);
+        await fs13.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+        await fs13.rename(tempPath, storagePath);
         const md2 = this.toMarkdown(data);
-        await fs12.writeFile(contextPath, md2, "utf-8");
+        await fs13.writeFile(contextPath, md2, "utf-8");
         this.cache.set(projectId, data);
       }
       /**
@@ -3593,7 +3665,7 @@ var init_storage_manager = __esm({
       async exists(projectId) {
         const filePath = this.getStoragePath(projectId);
         try {
-          await fs12.access(filePath);
+          await fs13.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -3635,7 +3707,7 @@ var init_metrics_storage = __esm({
         __name(this, "MetricsStorage");
       }
       constructor() {
-        super("metrics.json");
+        super("metrics.json", MetricsJsonSchema);
       }
       getDefault() {
         return { ...DEFAULT_METRICS };
@@ -3855,7 +3927,7 @@ var init_metrics_storage = __esm({
 
 // core/context-tools/files-tool.ts
 import { exec as execCallback2 } from "node:child_process";
-import fs13 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import path13 from "node:path";
 import { promisify as promisify3 } from "node:util";
 async function findRelevantFiles(taskDescription, projectPath, options = {}) {
@@ -3985,7 +4057,7 @@ async function getAllCodeFiles(projectPath) {
   const files = [];
   async function walk(dir, relativePath = "") {
     try {
-      const entries = await fs13.readdir(dir, { withFileTypes: true });
+      const entries = await fs14.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path13.join(dir, entry.name);
         const relPath = path13.join(relativePath, entry.name);
@@ -4289,14 +4361,14 @@ var init_files_tool = __esm({
 
 // core/context-tools/imports-tool.ts
 import { exec as execCallback3 } from "node:child_process";
-import fs14 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import path14 from "node:path";
 import { promisify as promisify4 } from "node:util";
 async function analyzeImports(filePath, projectPath = process.cwd(), options = {}) {
   const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.join(projectPath, filePath);
   let content;
   try {
-    content = await fs14.readFile(absolutePath, "utf-8");
+    content = await fs15.readFile(absolutePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return {
@@ -4388,7 +4460,7 @@ async function tryResolve(basePath, projectPath) {
   for (const ext of extensions) {
     const fullPath = basePath + ext;
     try {
-      const stat = await fs14.stat(fullPath);
+      const stat = await fs15.stat(fullPath);
       if (stat.isFile()) {
         return path14.relative(projectPath, fullPath);
       }
@@ -4917,13 +4989,13 @@ var init_token_counter = __esm({
 });
 
 // core/context-tools/signatures-tool.ts
-import fs15 from "node:fs/promises";
+import fs16 from "node:fs/promises";
 import path15 from "node:path";
 async function extractSignatures(filePath, projectPath = process.cwd()) {
   const absolutePath = path15.isAbsolute(filePath) ? filePath : path15.join(projectPath, filePath);
   let content;
   try {
-    content = await fs15.readFile(absolutePath, "utf-8");
+    content = await fs16.readFile(absolutePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return {
@@ -4967,7 +5039,7 @@ async function extractDirectorySignatures(dirPath, projectPath = process.cwd(),
   const absolutePath = path15.isAbsolute(dirPath) ? dirPath : path15.join(projectPath, dirPath);
   const results = [];
   async function processDir(dir) {
-    const entries = await fs15.readdir(dir, { withFileTypes: true });
+    const entries = await fs16.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path15.join(dir, entry.name);
       const relativePath = path15.relative(projectPath, fullPath);
@@ -5269,13 +5341,13 @@ var init_signatures_tool = __esm({
 });
 
 // core/context-tools/summary-tool.ts
-import fs16 from "node:fs/promises";
+import fs17 from "node:fs/promises";
 import path16 from "node:path";
 async function summarizeFile(filePath, projectPath = process.cwd()) {
   const absolutePath = path16.isAbsolute(filePath) ? filePath : path16.join(projectPath, filePath);
   let content;
   try {
-    content = await fs16.readFile(absolutePath, "utf-8");
+    content = await fs17.readFile(absolutePath, "utf-8");
   } catch (error) {
     if (isNotFoundError(error)) {
       return {
@@ -5313,7 +5385,7 @@ async function summarizeDirectory(dirPath, projectPath = process.cwd(), options
   const absolutePath = path16.isAbsolute(dirPath) ? dirPath : path16.join(projectPath, dirPath);
   const results = [];
   async function processDir(dir) {
-    const entries = await fs16.readdir(dir, { withFileTypes: true });
+    const entries = await fs17.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path16.join(dir, entry.name);
       const relativePath = path16.relative(projectPath, fullPath);
@@ -5575,11 +5647,11 @@ async function runSignaturesTool(args2, projectPath) {
       }
     };
   }
-  const fs52 = await import("node:fs/promises");
+  const fs53 = await import("node:fs/promises");
   const path65 = await import("node:path");
   const fullPath = path65.isAbsolute(filePath) ? filePath : path65.join(projectPath, filePath);
   try {
-    const stat = await fs52.stat(fullPath);
+    const stat = await fs53.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await extractDirectorySignatures(filePath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5646,11 +5718,11 @@ async function runSummaryTool(args2, projectPath) {
       }
     };
   }
-  const fs52 = await import("node:fs/promises");
+  const fs53 = await import("node:fs/promises");
   const path65 = await import("node:path");
   const fullPath = path65.isAbsolute(targetPath) ? targetPath : path65.join(projectPath, targetPath);
   try {
-    const stat = await fs52.stat(fullPath);
+    const stat = await fs53.stat(fullPath);
     if (stat.isDirectory()) {
       const results = await summarizeDirectory(targetPath, projectPath, {
         recursive: args2.includes("--recursive") || args2.includes("-r")
@@ -5810,7 +5882,7 @@ var hooks_service_exports = {};
 __export(hooks_service_exports, {
   hooksService: () => hooksService
 });
-import fs17 from "node:fs/promises";
+import fs18 from "node:fs/promises";
 import path17 from "node:path";
 import chalk4 from "chalk";
 function getPostCommitScript() {
@@ -5893,7 +5965,7 @@ function selectStrategy(detected) {
 async function installLefthook(projectPath, hooks) {
   const configFile = await fileExists(path17.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
   const configPath = path17.join(projectPath, configFile);
-  let content = await fs17.readFile(configPath, "utf-8");
+  let content = await fs18.readFile(configPath, "utf-8");
   for (const hook of hooks) {
     const sectionName = hook;
     const commandName = `prjct-sync-${hook}`;
@@ -5922,7 +5994,7 @@ ${sectionName}:
 ${hookBlock}`;
     }
   }
-  await fs17.writeFile(configPath, content, "utf-8");
+  await fs18.writeFile(configPath, content, "utf-8");
   return true;
 }
 async function installHusky(projectPath, hooks) {
@@ -5931,13 +6003,13 @@ async function installHusky(projectPath, hooks) {
     const hookPath = path17.join(huskyDir, hook);
     const script = hook === "post-commit" ? getPostCommitScript() : getPostCheckoutScript();
     if (await fileExists(hookPath)) {
-      const existing = await fs17.readFile(hookPath, "utf-8");
+      const existing = await fs18.readFile(hookPath, "utf-8");
       if (existing.includes("prjct sync")) {
         continue;
       }
-      await fs17.appendFile(hookPath, "\n# prjct auto-sync\nprjct sync --quiet --yes &\n");
+      await fs18.appendFile(hookPath, "\n# prjct auto-sync\nprjct sync --quiet --yes &\n");
     } else {
-      await fs17.writeFile(hookPath, script, { mode: 493 });
+      await fs18.writeFile(hookPath, script, { mode: 493 });
     }
   }
   return true;
@@ -5945,24 +6017,24 @@ async function installHusky(projectPath, hooks) {
 async function installDirect(projectPath, hooks) {
   const hooksDir = path17.join(projectPath, ".git", "hooks");
   if (!await fileExists(hooksDir)) {
-    await fs17.mkdir(hooksDir, { recursive: true });
+    await fs18.mkdir(hooksDir, { recursive: true });
   }
   for (const hook of hooks) {
     const hookPath = path17.join(hooksDir, hook);
     const script = hook === "post-commit" ? getPostCommitScript() : getPostCheckoutScript();
     if (await fileExists(hookPath)) {
-      const existing = await fs17.readFile(hookPath, "utf-8");
+      const existing = await fs18.readFile(hookPath, "utf-8");
       if (existing.includes("prjct sync")) {
         continue;
       }
-      await fs17.appendFile(
+      await fs18.appendFile(
         hookPath,
         `
 # prjct auto-sync
 ${script.split("\n").slice(1).join("\n")}`
       );
     } else {
-      await fs17.writeFile(hookPath, script, { mode: 493 });
+      await fs18.writeFile(hookPath, script, { mode: 493 });
     }
   }
   return true;
@@ -5971,10 +6043,10 @@ async function uninstallLefthook(projectPath) {
   const configFile = await fileExists(path17.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
   const configPath = path17.join(projectPath, configFile);
   if (!await fileExists(configPath)) return false;
-  let content = await fs17.readFile(configPath, "utf-8");
+  let content = await fs18.readFile(configPath, "utf-8");
   content = content.replace(/\s*prjct-sync-[\w-]+:[\s\S]*?(?=\n\S|\n*$)/g, "");
   content = content.replace(/^(post-commit|post-checkout):\s*commands:\s*$/gm, "");
-  await fs17.writeFile(configPath, `${content.trimEnd()}
+  await fs18.writeFile(configPath, `${content.trimEnd()}
 `, "utf-8");
   return true;
 }
@@ -5983,13 +6055,13 @@ async function uninstallHusky(projectPath) {
   for (const hook of ["post-commit", "post-checkout"]) {
     const hookPath = path17.join(huskyDir, hook);
     if (!await fileExists(hookPath)) continue;
-    const content = await fs17.readFile(hookPath, "utf-8");
+    const content = await fs18.readFile(hookPath, "utf-8");
     if (!content.includes("prjct sync")) continue;
     const cleaned = content.split("\n").filter((line) => !line.includes("prjct sync") && !line.includes("prjct auto-sync")).join("\n");
     if (cleaned.trim() === "#!/bin/sh" || cleaned.trim() === "#!/usr/bin/env sh") {
-      await fs17.unlink(hookPath);
+      await fs18.unlink(hookPath);
     } else {
-      await fs17.writeFile(hookPath, cleaned, { mode: 493 });
+      await fs18.writeFile(hookPath, cleaned, { mode: 493 });
     }
   }
   return true;
@@ -5999,13 +6071,13 @@ async function uninstallDirect(projectPath) {
   for (const hook of ["post-commit", "post-checkout"]) {
     const hookPath = path17.join(hooksDir, hook);
     if (!await fileExists(hookPath)) continue;
-    const content = await fs17.readFile(hookPath, "utf-8");
+    const content = await fs18.readFile(hookPath, "utf-8");
     if (!content.includes("prjct sync")) continue;
     if (content.includes("Installed by: prjct hooks install")) {
-      await fs17.unlink(hookPath);
+      await fs18.unlink(hookPath);
     } else {
       const cleaned = content.split("\n").filter((line) => !line.includes("prjct sync") && !line.includes("prjct auto-sync")).join("\n");
-      await fs17.writeFile(hookPath, cleaned, { mode: 493 });
+      await fs18.writeFile(hookPath, cleaned, { mode: 493 });
     }
   }
   return true;
@@ -6231,17 +6303,17 @@ var init_hooks_service = __esm({
           const configFile = await fileExists(path17.join(projectPath, "lefthook.yml")) ? "lefthook.yml" : "lefthook.yaml";
           const configPath = path17.join(projectPath, configFile);
           if (!await fileExists(configPath)) return false;
-          const content = await fs17.readFile(configPath, "utf-8");
+          const content = await fs18.readFile(configPath, "utf-8");
           return content.includes(`prjct-sync-${hook}`);
         }
         if (strategy === "husky") {
           const hookPath2 = path17.join(projectPath, ".husky", hook);
           if (!await fileExists(hookPath2)) return false;
-          return (await fs17.readFile(hookPath2, "utf-8")).includes("prjct sync");
+          return (await fs18.readFile(hookPath2, "utf-8")).includes("prjct sync");
         }
         const hookPath = path17.join(projectPath, ".git", "hooks", hook);
         if (!await fileExists(hookPath)) return false;
-        return (await fs17.readFile(hookPath, "utf-8")).includes("prjct sync");
+        return (await fs18.readFile(hookPath, "utf-8")).includes("prjct sync");
       }
       async getHookPath(projectPath, hook, strategy) {
         if (strategy === "lefthook") {
@@ -6264,7 +6336,7 @@ var init_hooks_service = __esm({
             "project.json"
           );
           if (!await fileExists(projectJsonPath)) return null;
-          const project = JSON.parse(await fs17.readFile(projectJsonPath, "utf-8"));
+          const project = JSON.parse(await fs18.readFile(projectJsonPath, "utf-8"));
           return project.hooks || null;
         } catch {
           return null;
@@ -6282,9 +6354,9 @@ var init_hooks_service = __esm({
             "project.json"
           );
           if (!await fileExists(projectJsonPath)) return;
-          const project = JSON.parse(await fs17.readFile(projectJsonPath, "utf-8"));
+          const project = JSON.parse(await fs18.readFile(projectJsonPath, "utf-8"));
           project.hooks = config;
-          await fs17.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs18.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
         } catch {
         }
       }
@@ -6300,7 +6372,7 @@ __export(doctor_service_exports, {
   doctorService: () => doctorService
 });
 import { execSync } from "node:child_process";
-import fs18 from "node:fs/promises";
+import fs19 from "node:fs/promises";
 import path18 from "node:path";
 import chalk5 from "chalk";
 var DoctorService, doctorService;
@@ -6416,7 +6488,7 @@ var init_doctor_service = __esm({
       async checkPrjctConfig() {
         const configPath = path18.join(this.projectPath, ".prjct", "prjct.config.json");
         try {
-          await fs18.access(configPath);
+          await fs19.access(configPath);
           return {
             name: "prjct config",
             status: "ok",
@@ -6440,7 +6512,7 @@ var init_doctor_service = __esm({
         }
         const claudePath = path18.join(this.globalPath, "context", "CLAUDE.md");
         try {
-          const stat = await fs18.stat(claudePath);
+          const stat = await fs19.stat(claudePath);
           const ageMs = Date.now() - stat.mtimeMs;
           const ageHours = Math.floor(ageMs / (1e3 * 60 * 60));
           const ageDays = Math.floor(ageHours / 24);
@@ -6514,7 +6586,7 @@ var init_doctor_service = __esm({
         }
         const statePath = path18.join(this.globalPath, "storage", "state.json");
         try {
-          const content = await fs18.readFile(statePath, "utf-8");
+          const content = await fs19.readFile(statePath, "utf-8");
           const state = JSON.parse(content);
           if (state.currentTask) {
             return {
@@ -6611,13 +6683,13 @@ var init_doctor_service = __esm({
 });
 
 // core/infrastructure/command-installer.ts
-import fs19 from "node:fs/promises";
+import fs20 from "node:fs/promises";
 import os6 from "node:os";
 import path19 from "node:path";
 async function loadModuleConfig() {
   try {
     const configPath = path19.join(PACKAGE_ROOT, "templates/global/modules/module-config.json");
-    const content = await fs19.readFile(configPath, "utf-8");
+    const content = await fs20.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6628,7 +6700,7 @@ async function composeGlobalTemplate(profile) {
   const modulesDir = path19.join(PACKAGE_ROOT, "templates/global/modules");
   if (!config) {
     const legacyPath = path19.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-    return fs19.readFile(legacyPath, "utf-8");
+    return fs20.readFile(legacyPath, "utf-8");
   }
   const profileName = profile || config.default;
   const selectedProfile = config.profiles[profileName];
@@ -6636,7 +6708,7 @@ async function composeGlobalTemplate(profile) {
     const defaultProfile = config.profiles[config.default];
     if (!defaultProfile) {
       const legacyPath = path19.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-      return fs19.readFile(legacyPath, "utf-8");
+      return fs20.readFile(legacyPath, "utf-8");
     }
   }
   const modules = (selectedProfile || config.profiles[config.default]).modules;
@@ -6645,7 +6717,7 @@ async function composeGlobalTemplate(profile) {
   for (const moduleName of modules) {
     try {
       const modulePath = path19.join(modulesDir, moduleName);
-      const content = await fs19.readFile(modulePath, "utf-8");
+      const content = await fs20.readFile(modulePath, "utf-8");
       parts.push("");
       parts.push(content);
     } catch {
@@ -6661,14 +6733,14 @@ async function installDocs() {
   try {
     const docsDir = path19.join(os6.homedir(), ".prjct-cli", "docs");
     const templateDocsDir = path19.join(PACKAGE_ROOT, "templates/global/docs");
-    await fs19.mkdir(docsDir, { recursive: true });
-    const docFiles = await fs19.readdir(templateDocsDir);
+    await fs20.mkdir(docsDir, { recursive: true });
+    const docFiles = await fs20.readdir(templateDocsDir);
     for (const file of docFiles) {
       if (file.endsWith(".md")) {
         const srcPath = path19.join(templateDocsDir, file);
         const destPath = path19.join(docsDir, file);
-        const content = await fs19.readFile(srcPath, "utf-8");
-        await fs19.writeFile(destPath, content, "utf-8");
+        const content = await fs20.readFile(srcPath, "utf-8");
+        await fs20.writeFile(destPath, content, "utf-8");
       }
     }
     return { success: true };
@@ -6689,23 +6761,23 @@ async function installGlobalConfig2() {
     };
   }
   try {
-    await fs19.mkdir(activeProvider.configDir, { recursive: true });
+    await fs20.mkdir(activeProvider.configDir, { recursive: true });
     const globalConfigPath = path19.join(activeProvider.configDir, activeProvider.contextFile);
     const templatePath = path19.join(PACKAGE_ROOT, "templates", "global", activeProvider.contextFile);
     let templateContent = "";
     try {
-      templateContent = await fs19.readFile(templatePath, "utf-8");
+      templateContent = await fs20.readFile(templatePath, "utf-8");
     } catch (_error) {
       if (providerName === "claude") {
         try {
           templateContent = await composeGlobalTemplate("standard");
         } catch {
           const fallbackTemplatePath = path19.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-          templateContent = await fs19.readFile(fallbackTemplatePath, "utf-8");
+          templateContent = await fs20.readFile(fallbackTemplatePath, "utf-8");
         }
       } else {
         const fallbackTemplatePath = path19.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-        templateContent = await fs19.readFile(fallbackTemplatePath, "utf-8");
+        templateContent = await fs20.readFile(fallbackTemplatePath, "utf-8");
         if (providerName === "gemini") {
           templateContent = templateContent.replace(/Claude/g, "Gemini");
         }
@@ -6714,7 +6786,7 @@ async function installGlobalConfig2() {
     let existingContent = "";
     let fileExists3 = false;
     try {
-      existingContent = await fs19.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs20.readFile(globalConfigPath, "utf-8");
       fileExists3 = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -6724,7 +6796,7 @@ async function installGlobalConfig2() {
       }
     }
     if (!fileExists3) {
-      await fs19.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs20.writeFile(globalConfigPath, templateContent, "utf-8");
       return {
         success: true,
         action: "created",
@@ -6738,7 +6810,7 @@ async function installGlobalConfig2() {
         const updatedContent = `${existingContent}
 
 ${templateContent}`;
-        await fs19.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await fs20.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "appended",
@@ -6754,7 +6826,7 @@ ${templateContent}`;
           templateContent.indexOf(endMarker) + endMarker.length
         );
         const updatedContent = beforeMarker + prjctSection + afterMarker;
-        await fs19.writeFile(globalConfigPath, updatedContent, "utf-8");
+        await fs20.writeFile(globalConfigPath, updatedContent, "utf-8");
         return {
           success: true,
           action: "updated",
@@ -6826,7 +6898,7 @@ var init_command_installer = __esm({
       async detectActiveProvider() {
         await this.ensureInit();
         try {
-          await fs19.access(this.claudeConfigPath);
+          await fs20.access(this.claudeConfigPath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -6846,7 +6918,7 @@ var init_command_installer = __esm({
        */
       async getCommandFiles() {
         try {
-          const files = await fs19.readdir(this.templatesDir);
+          const files = await fs20.readdir(this.templatesDir);
           return files.filter((f) => f.endsWith(".md"));
         } catch (_error) {
           return [
@@ -6887,7 +6959,7 @@ var init_command_installer = __esm({
         }
         try {
           await this.installRouter();
-          await fs19.mkdir(this.claudeCommandsPath, { recursive: true });
+          await fs20.mkdir(this.claudeCommandsPath, { recursive: true });
           const commandFiles = await this.getCommandFiles();
           const installed = [];
           const errors = [];
@@ -6895,8 +6967,8 @@ var init_command_installer = __esm({
             try {
               const sourcePath = path19.join(this.templatesDir, file);
               const destPath = path19.join(this.claudeCommandsPath, file);
-              const content = await fs19.readFile(sourcePath, "utf-8");
-              await fs19.writeFile(destPath, content, "utf-8");
+              const content = await fs20.readFile(sourcePath, "utf-8");
+              await fs20.writeFile(destPath, content, "utf-8");
               installed.push(file.replace(".md", ""));
             } catch (error) {
               errors.push({ file, error: getErrorMessage2(error) });
@@ -6926,7 +6998,7 @@ var init_command_installer = __esm({
           for (const file of commandFiles) {
             try {
               const filePath = path19.join(this.claudeCommandsPath, file);
-              await fs19.unlink(filePath);
+              await fs20.unlink(filePath);
               uninstalled.push(file.replace(".md", ""));
             } catch (error) {
               if (error.code !== "ENOENT") {
@@ -6935,7 +7007,7 @@ var init_command_installer = __esm({
             }
           }
           try {
-            await fs19.rmdir(this.claudeCommandsPath);
+            await fs20.rmdir(this.claudeCommandsPath);
           } catch (_error) {
           }
           return {
@@ -6962,8 +7034,8 @@ var init_command_installer = __esm({
           };
         }
         try {
-          await fs19.access(this.claudeCommandsPath);
-          const files = await fs19.readdir(this.claudeCommandsPath);
+          await fs20.access(this.claudeCommandsPath);
+          const files = await fs20.readdir(this.claudeCommandsPath);
           const installedCommands = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
           return {
             installed: installedCommands.length > 0,
@@ -7012,7 +7084,7 @@ var init_command_installer = __esm({
       async verifyTemplate(commandName) {
         try {
           const templatePath = path19.join(this.templatesDir, `${commandName}.md`);
-          await fs19.access(templatePath);
+          await fs20.access(templatePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -7032,9 +7104,9 @@ var init_command_installer = __esm({
         try {
           const routerSource = path19.join(this.templatesDir, routerFile);
           const routerDest = path19.join(activeProvider.configDir, "commands", routerFile);
-          await fs19.mkdir(path19.dirname(routerDest), { recursive: true });
-          const content = await fs19.readFile(routerSource, "utf-8");
-          await fs19.writeFile(routerDest, content, "utf-8");
+          await fs20.mkdir(path19.dirname(routerDest), { recursive: true });
+          const content = await fs20.readFile(routerSource, "utf-8");
+          await fs20.writeFile(routerDest, content, "utf-8");
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -7053,11 +7125,11 @@ var init_command_installer = __esm({
         const commandsRoot = path19.join(activeProvider.configDir, "commands");
         let removed = 0;
         try {
-          const files = await fs19.readdir(commandsRoot);
+          const files = await fs20.readdir(commandsRoot);
           const legacyFiles = files.filter((f) => f.startsWith("p.") && f.endsWith(".md"));
           for (const file of legacyFiles) {
             try {
-              await fs19.unlink(path19.join(commandsRoot, file));
+              await fs20.unlink(path19.join(commandsRoot, file));
               removed++;
             } catch {
             }
@@ -7082,11 +7154,11 @@ var init_command_installer = __esm({
         }
         try {
           await this.installRouter();
-          await fs19.mkdir(this.claudeCommandsPath, { recursive: true });
+          await fs20.mkdir(this.claudeCommandsPath, { recursive: true });
           const templateFiles = await this.getCommandFiles();
           let installedFiles = [];
           try {
-            installedFiles = await fs19.readdir(this.claudeCommandsPath);
+            installedFiles = await fs20.readdir(this.claudeCommandsPath);
             installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
           } catch (error) {
             if (isNotFoundError(error)) {
@@ -7107,8 +7179,8 @@ var init_command_installer = __esm({
               const sourcePath = path19.join(this.templatesDir, file);
               const destPath = path19.join(this.claudeCommandsPath, file);
               const exists = installedFiles.includes(file);
-              const content = await fs19.readFile(sourcePath, "utf-8");
-              await fs19.writeFile(destPath, content, "utf-8");
+              const content = await fs20.readFile(sourcePath, "utf-8");
+              await fs20.writeFile(destPath, content, "utf-8");
               if (!exists) {
                 results.added++;
               } else {
@@ -7492,7 +7564,7 @@ var init_chain_of_thought = __esm({
 });
 
 // core/agentic/context-builder.ts
-import fs20 from "node:fs/promises";
+import fs21 from "node:fs/promises";
 var ContextBuilder, contextBuilder, context_builder_default;
 var init_context_builder = __esm({
   "core/agentic/context-builder.ts"() {
@@ -7571,7 +7643,7 @@ var init_context_builder = __esm({
         for (const [, filePath] of filteredEntries) {
           if (this._cache.has(filePath)) {
             try {
-              const stat = await fs20.stat(filePath);
+              const stat = await fs21.stat(filePath);
               const cachedMtime = this._mtimes.get(filePath);
               if (!cachedMtime || stat.mtimeMs > cachedMtime) {
                 this._cache.delete(filePath);
@@ -7599,8 +7671,8 @@ var init_context_builder = __esm({
           const readPromises = uncachedEntries.map(async ([key, filePath]) => {
             try {
               const [content, stat] = await Promise.all([
-                fs20.readFile(filePath, "utf-8"),
-                fs20.stat(filePath)
+                fs21.readFile(filePath, "utf-8"),
+                fs21.stat(filePath)
               ]);
               return { key, filePath, content, mtime: stat.mtimeMs };
             } catch (error) {
@@ -7674,7 +7746,7 @@ var init_context_builder = __esm({
         if (uncachedPaths.length > 0) {
           const readPromises = uncachedPaths.map(async (filePath) => {
             try {
-              const content = await fs20.readFile(filePath, "utf-8");
+              const content = await fs21.readFile(filePath, "utf-8");
               return { filePath, content };
             } catch (error) {
               if (isNotFoundError(error)) {
@@ -7708,7 +7780,7 @@ var init_context_builder = __esm({
        */
       async fileExists(filePath) {
         try {
-          await fs20.access(filePath);
+          await fs21.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -7735,7 +7807,7 @@ var init_context_builder = __esm({
 
 // core/agentic/ground-truth.ts
 import { exec as exec6 } from "node:child_process";
-import fs21 from "node:fs/promises";
+import fs22 from "node:fs/promises";
 import os7 from "node:os";
 import path20 from "node:path";
 import { promisify as promisify6 } from "node:util";
@@ -7774,7 +7846,7 @@ async function verifyDone(context2) {
   const actual = {};
   const nowPath = context2.paths.now;
   try {
-    const nowContent = await fs21.readFile(nowPath, "utf-8");
+    const nowContent = await fs22.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     actual.nowLength = nowContent.length;
@@ -7802,7 +7874,7 @@ async function verifyDone(context2) {
   }
   const nextPath = context2.paths.next;
   try {
-    const nextContent = await fs21.readFile(nextPath, "utf-8");
+    const nextContent = await fs22.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[ \]/g) || [];
     actual.pendingTasks = tasks.length;
@@ -7816,7 +7888,7 @@ async function verifyDone(context2) {
   }
   const metricsPath = context2.paths.metrics;
   try {
-    await fs21.access(path20.dirname(metricsPath), fs21.constants.W_OK);
+    await fs22.access(path20.dirname(metricsPath), fs22.constants.W_OK);
     actual.metricsWritable = true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -7852,7 +7924,7 @@ async function verifyShip(context2) {
   }
   const pkgPath = path20.join(context2.projectPath, "package.json");
   try {
-    const pkgContent = await fs21.readFile(pkgPath, "utf-8");
+    const pkgContent = await fs22.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     actual.currentVersion = pkg.version;
     actual.hasPackageJson = true;
@@ -7868,7 +7940,7 @@ async function verifyShip(context2) {
   }
   const shippedPath = context2.paths.shipped;
   try {
-    const shippedContent = await fs21.readFile(shippedPath, "utf-8");
+    const shippedContent = await fs22.readFile(shippedPath, "utf-8");
     actual.shippedExists = true;
     const featureName = context2.params.feature || context2.params.description;
     if (featureName) {
@@ -7888,7 +7960,7 @@ async function verifyShip(context2) {
   }
   if (actual.hasPackageJson) {
     try {
-      const pkgContent = await fs21.readFile(pkgPath, "utf-8");
+      const pkgContent = await fs22.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       actual.hasTestScript = !!pkg.scripts?.test;
     } catch (error) {
@@ -7912,7 +7984,7 @@ async function verifyFeature(context2) {
   const actual = {};
   const nextPath = context2.paths.next;
   try {
-    const nextContent = await fs21.readFile(nextPath, "utf-8");
+    const nextContent = await fs22.readFile(nextPath, "utf-8");
     actual.nextExists = true;
     const tasks = nextContent.match(/- \[[ x]\]/g) || [];
     actual.taskCount = tasks.length;
@@ -7931,7 +8003,7 @@ async function verifyFeature(context2) {
   }
   const roadmapPath = context2.paths.roadmap;
   try {
-    const roadmapContent = await fs21.readFile(roadmapPath, "utf-8");
+    const roadmapContent = await fs22.readFile(roadmapPath, "utf-8");
     actual.roadmapExists = true;
     const featureName = context2.params.description || context2.params.feature;
     if (featureName) {
@@ -7950,7 +8022,7 @@ async function verifyFeature(context2) {
   }
   const nowPath = context2.paths.now;
   try {
-    const nowContent = await fs21.readFile(nowPath, "utf-8");
+    const nowContent = await fs22.readFile(nowPath, "utf-8");
     actual.hasActiveTask = nowContent.trim().length > 0 && !nowContent.includes("No current task");
     if (actual.hasActiveTask) {
       recommendations.push("Consider completing current task first with /p:done");
@@ -7975,7 +8047,7 @@ async function verifyNow(context2) {
   const actual = {};
   const nowPath = context2.paths.now;
   try {
-    const nowContent = await fs21.readFile(nowPath, "utf-8");
+    const nowContent = await fs22.readFile(nowPath, "utf-8");
     actual.nowExists = true;
     actual.nowContent = nowContent.trim();
     const hasRealTask = nowContent.trim().length > 0 && !nowContent.includes("No current task") && !nowContent.match(/^#\s*NOW\s*$/m);
@@ -7995,7 +8067,7 @@ async function verifyNow(context2) {
   }
   const nextPath = context2.paths.next;
   try {
-    const nextContent = await fs21.readFile(nextPath, "utf-8");
+    const nextContent = await fs22.readFile(nextPath, "utf-8");
     const pendingTasks = (nextContent.match(/- \[ \]/g) || []).length;
     actual.pendingTasks = pendingTasks;
     if (!context2.params.task && pendingTasks > 0) {
@@ -8021,7 +8093,7 @@ async function verifyInit(context2) {
   const actual = {};
   const configPath = path20.join(context2.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs21.readFile(configPath, "utf-8");
+    const configContent = await fs22.readFile(configPath, "utf-8");
     actual.alreadyInitialized = true;
     actual.existingConfig = JSON.parse(configContent);
     warnings.push("Project already initialized");
@@ -8038,12 +8110,12 @@ async function verifyInit(context2) {
   }
   const globalPath = path20.join(os7.homedir(), ".prjct-cli");
   try {
-    await fs21.access(globalPath, fs21.constants.W_OK);
+    await fs22.access(globalPath, fs22.constants.W_OK);
     actual.globalPathWritable = true;
   } catch (error) {
     if (isNotFoundError(error)) {
       try {
-        await fs21.mkdir(globalPath, { recursive: true });
+        await fs22.mkdir(globalPath, { recursive: true });
         actual.globalPathWritable = true;
         actual.globalPathCreated = true;
       } catch (_mkdirError) {
@@ -8070,7 +8142,7 @@ async function verifySync(context2) {
   const actual = {};
   const configPath = path20.join(context2.projectPath, ".prjct/prjct.config.json");
   try {
-    const configContent = await fs21.readFile(configPath, "utf-8");
+    const configContent = await fs22.readFile(configPath, "utf-8");
     actual.hasConfig = true;
     actual.config = JSON.parse(configContent);
   } catch (error) {
@@ -8091,7 +8163,7 @@ async function verifySync(context2) {
   const projectId = actual.config?.projectId;
   const globalProjectPath = path20.join(os7.homedir(), ".prjct-cli/projects", projectId || "");
   try {
-    await fs21.access(globalProjectPath);
+    await fs22.access(globalProjectPath);
     actual.globalStorageExists = true;
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -8117,7 +8189,7 @@ async function verifyAnalyze(context2) {
   actual.detectedFiles = [];
   for (const file of files) {
     try {
-      await fs21.access(path20.join(context2.projectPath, file));
+      await fs22.access(path20.join(context2.projectPath, file));
       actual.detectedFiles.push(file);
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -8133,7 +8205,7 @@ async function verifyAnalyze(context2) {
   actual.detectedSrcDirs = [];
   for (const dir of srcDirs) {
     try {
-      const stat = await fs21.stat(path20.join(context2.projectPath, dir));
+      const stat = await fs22.stat(path20.join(context2.projectPath, dir));
       if (stat.isDirectory()) {
         ;
         actual.detectedSrcDirs.push(dir);
@@ -8158,9 +8230,9 @@ async function verifySpec(context2) {
   const actual = {};
   const specsPath = context2.paths.specs;
   try {
-    await fs21.access(specsPath);
+    await fs22.access(specsPath);
     actual.specsExists = true;
-    const files = await fs21.readdir(specsPath);
+    const files = await fs22.readdir(specsPath);
     actual.existingSpecs = files.filter((f) => f.endsWith(".md"));
     actual.specCount = actual.existingSpecs.length;
   } catch (error) {
@@ -9385,7 +9457,7 @@ var init_shipped = __esm({
       agent: z9.string().optional(),
       // "fe+be", "be", "fe"
       description: z9.string().optional(),
-      changes: z9.array(ShipChangeSchema),
+      changes: z9.array(ShipChangeSchema).optional(),
       codeSnippets: z9.array(z9.string()).optional(),
       commit: CommitInfoSchema.optional(),
       codeMetrics: CodeMetricsSchema.optional(),
@@ -9398,7 +9470,7 @@ var init_shipped = __esm({
       featureId: z9.string().optional()
     });
     ShippedJsonSchema = z9.object({
-      items: z9.array(ShippedItemSchema),
+      shipped: z9.array(ShippedItemSchema),
       lastUpdated: z9.string()
     });
   }
@@ -9592,7 +9664,7 @@ __export(jsonl_helper_exports, {
   writeJsonLines: () => writeJsonLines
 });
 import fsSync from "node:fs";
-import fs22 from "node:fs/promises";
+import fs23 from "node:fs/promises";
 import path21 from "node:path";
 import readline from "node:readline";
 function parseJsonLines(content) {
@@ -9612,7 +9684,7 @@ function stringifyJsonLines(objects) {
 }
 async function readJsonLines(filePath) {
   try {
-    const content = await fs22.readFile(filePath, "utf-8");
+    const content = await fs23.readFile(filePath, "utf-8");
     return parseJsonLines(content);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -9623,16 +9695,16 @@ async function readJsonLines(filePath) {
 }
 async function writeJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs22.writeFile(filePath, content, "utf-8");
+  await fs23.writeFile(filePath, content, "utf-8");
 }
 async function appendJsonLine(filePath, object) {
   const line = `${JSON.stringify(object)}
 `;
-  await fs22.appendFile(filePath, line, "utf-8");
+  await fs23.appendFile(filePath, line, "utf-8");
 }
 async function appendJsonLines(filePath, objects) {
   const content = stringifyJsonLines(objects);
-  await fs22.appendFile(filePath, content, "utf-8");
+  await fs23.appendFile(filePath, content, "utf-8");
 }
 async function filterJsonLines(filePath, predicate) {
   const entries = await readJsonLines(filePath);
@@ -9640,7 +9712,7 @@ async function filterJsonLines(filePath, predicate) {
 }
 async function countJsonLines(filePath) {
   try {
-    const content = await fs22.readFile(filePath, "utf-8");
+    const content = await fs23.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((line) => line.trim());
     return lines.length;
   } catch (error) {
@@ -9699,7 +9771,7 @@ async function readJsonLinesStreaming(filePath, maxLines = STORAGE_LIMITS.JSONL_
 }
 async function getFileSizeMB(filePath) {
   try {
-    const stats = await fs22.stat(filePath);
+    const stats = await fs23.stat(filePath);
     return stats.size / (1024 * 1024);
   } catch (error) {
     if (isNotFoundError(error)) {
@@ -9718,7 +9790,7 @@ async function rotateJsonLinesIfNeeded(filePath, maxSizeMB = STORAGE_LIMITS.ROTA
   const ext = path21.extname(filePath);
   const base = path21.basename(filePath, ext);
   const archivePath = path21.join(dir, `${base}-${timestamp}${ext}`);
-  await fs22.rename(filePath, archivePath);
+  await fs23.rename(filePath, archivePath);
   console.log(
     `\u{1F4E6} Rotated ${path21.basename(filePath)} (${sizeMB.toFixed(1)}MB) \u2192 ${path21.basename(archivePath)}`
   );
@@ -9798,7 +9870,7 @@ var init_memory = __esm({
 });
 
 // core/agentic/memory-system.ts
-import fs23 from "node:fs/promises";
+import fs24 from "node:fs/promises";
 import path22 from "node:path";
 var CachedStore, SessionStore, HistoryStore, PatternStore, SemanticMemories, MemorySystem, memorySystem, memory_system_default;
 var init_memory_system = __esm({
@@ -9865,7 +9937,7 @@ var init_memory_system = __esm({
         }
         const filePath = this.getPath(projectId);
         try {
-          const content = await fs23.readFile(filePath, "utf-8");
+          const content = await fs24.readFile(filePath, "utf-8");
           this._data = JSON.parse(content);
           this.afterLoad(this._data);
         } catch (error) {
@@ -9901,8 +9973,8 @@ var init_memory_system = __esm({
       async save(projectId) {
         if (!this._data) return;
         const filePath = this.getPath(projectId);
-        await fs23.mkdir(path22.dirname(filePath), { recursive: true });
-        await fs23.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
+        await fs24.mkdir(path22.dirname(filePath), { recursive: true });
+        await fs24.writeFile(filePath, JSON.stringify(this._data, null, 2), "utf-8");
       }
       /**
        * Access the cached data without triggering a disk read.
@@ -10691,6 +10763,7 @@ var init_ideas_storage = __esm({
   "core/storage/ideas-storage.ts"() {
     "use strict";
     init_schemas2();
+    init_ideas();
     init_date_helper();
     init_storage_manager();
     IdeasStorage = class extends StorageManager {
@@ -10698,7 +10771,7 @@ var init_ideas_storage = __esm({
         __name(this, "IdeasStorage");
       }
       constructor() {
-        super("ideas.json");
+        super("ideas.json", IdeasJsonSchema);
       }
       getDefault() {
         return {
@@ -10891,7 +10964,7 @@ var init_ideas_storage = __esm({
 
 // core/storage/index-storage.ts
 import crypto4 from "node:crypto";
-import fs24 from "node:fs/promises";
+import fs25 from "node:fs/promises";
 import path23 from "node:path";
 function getDefaultChecksums() {
   return {
@@ -10924,7 +10997,7 @@ var init_index_storage = __esm({
        */
       async ensureIndexDir(projectId) {
         const indexPath = this.getIndexPath(projectId);
-        await fs24.mkdir(indexPath, { recursive: true });
+        await fs25.mkdir(indexPath, { recursive: true });
         return indexPath;
       }
       // ==========================================================================
@@ -10936,7 +11009,7 @@ var init_index_storage = __esm({
       async readIndex(projectId) {
         const filePath = path23.join(this.getIndexPath(projectId), "project-index.json");
         try {
-          const content = await fs24.readFile(filePath, "utf-8");
+          const content = await fs25.readFile(filePath, "utf-8");
           const index = JSON.parse(content);
           if (index.version !== INDEX_VERSION) {
             return null;
@@ -10955,7 +11028,7 @@ var init_index_storage = __esm({
       async writeIndex(projectId, index) {
         await this.ensureIndexDir(projectId);
         const filePath = path23.join(this.getIndexPath(projectId), "project-index.json");
-        await fs24.writeFile(filePath, JSON.stringify(index, null, 2), "utf-8");
+        await fs25.writeFile(filePath, JSON.stringify(index, null, 2), "utf-8");
       }
       /**
        * Check if index exists and is valid
@@ -10973,7 +11046,7 @@ var init_index_storage = __esm({
       async readChecksums(projectId) {
         const filePath = path23.join(this.getIndexPath(projectId), "checksums.json");
         try {
-          const content = await fs24.readFile(filePath, "utf-8");
+          const content = await fs25.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -10988,14 +11061,14 @@ var init_index_storage = __esm({
       async writeChecksums(projectId, checksums) {
         await this.ensureIndexDir(projectId);
         const filePath = path23.join(this.getIndexPath(projectId), "checksums.json");
-        await fs24.writeFile(filePath, JSON.stringify(checksums, null, 2), "utf-8");
+        await fs25.writeFile(filePath, JSON.stringify(checksums, null, 2), "utf-8");
       }
       /**
        * Calculate checksum for a file
        */
       async calculateChecksum(filePath) {
         try {
-          const content = await fs24.readFile(filePath);
+          const content = await fs25.readFile(filePath);
           return crypto4.createHash("md5").update(content).digest("hex");
         } catch {
           return "";
@@ -11033,7 +11106,7 @@ var init_index_storage = __esm({
       async readScores(projectId) {
         const filePath = path23.join(this.getIndexPath(projectId), "file-scores.json");
         try {
-          const content = await fs24.readFile(filePath, "utf-8");
+          const content = await fs25.readFile(filePath, "utf-8");
           const data = JSON.parse(content);
           return data.scores || [];
         } catch (error) {
@@ -11054,7 +11127,7 @@ var init_index_storage = __esm({
           lastUpdated: getTimestamp(),
           scores
         };
-        await fs24.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs25.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
       }
       // ==========================================================================
       // UTILITY METHODS
@@ -11065,8 +11138,8 @@ var init_index_storage = __esm({
       async clearIndex(projectId) {
         const indexPath = this.getIndexPath(projectId);
         try {
-          const files = await fs24.readdir(indexPath);
-          await Promise.all(files.map((file) => fs24.unlink(path23.join(indexPath, file))));
+          const files = await fs25.readdir(indexPath);
+          await Promise.all(files.map((file) => fs25.unlink(path23.join(indexPath, file))));
         } catch (error) {
           if (!isNotFoundError(error)) {
             throw error;
@@ -11094,7 +11167,7 @@ var init_index_storage = __esm({
       async readDomains(projectId) {
         const filePath = path23.join(this.getIndexPath(projectId), "domains.json");
         try {
-          const content = await fs24.readFile(filePath, "utf-8");
+          const content = await fs25.readFile(filePath, "utf-8");
           const domains = JSON.parse(content);
           if (domains.version !== INDEX_VERSION) {
             return null;
@@ -11113,7 +11186,7 @@ var init_index_storage = __esm({
       async writeDomains(projectId, domains) {
         await this.ensureIndexDir(projectId);
         const filePath = path23.join(this.getIndexPath(projectId), "domains.json");
-        await fs24.writeFile(filePath, JSON.stringify(domains, null, 2), "utf-8");
+        await fs25.writeFile(filePath, JSON.stringify(domains, null, 2), "utf-8");
       }
       // ==========================================================================
       // CATEGORIES CACHE
@@ -11124,7 +11197,7 @@ var init_index_storage = __esm({
       async readCategories(projectId) {
         const filePath = path23.join(this.getIndexPath(projectId), "categories-cache.json");
         try {
-          const content = await fs24.readFile(filePath, "utf-8");
+          const content = await fs25.readFile(filePath, "utf-8");
           const cache2 = JSON.parse(content);
           if (cache2.version !== INDEX_VERSION) {
             return null;
@@ -11143,7 +11216,7 @@ var init_index_storage = __esm({
       async writeCategories(projectId, cache2) {
         await this.ensureIndexDir(projectId);
         const filePath = path23.join(this.getIndexPath(projectId), "categories-cache.json");
-        await fs24.writeFile(filePath, JSON.stringify(cache2, null, 2), "utf-8");
+        await fs25.writeFile(filePath, JSON.stringify(cache2, null, 2), "utf-8");
       }
       /**
        * Get file categories for specific paths
@@ -11183,6 +11256,7 @@ var init_queue_storage = __esm({
   "core/storage/queue-storage.ts"() {
     "use strict";
     init_schemas2();
+    init_state();
     init_date_helper();
     init_storage_manager();
     QueueStorage = class extends StorageManager {
@@ -11190,7 +11264,7 @@ var init_queue_storage = __esm({
         __name(this, "QueueStorage");
       }
       constructor() {
-        super("queue.json");
+        super("queue.json", QueueJsonSchema);
       }
       getDefault() {
         return {
@@ -11423,6 +11497,7 @@ var init_shipped_storage = __esm({
   "core/storage/shipped-storage.ts"() {
     "use strict";
     init_schemas2();
+    init_shipped();
     init_date_helper();
     init_storage_manager();
     ShippedStorage = class extends StorageManager {
@@ -11430,7 +11505,7 @@ var init_shipped_storage = __esm({
         __name(this, "ShippedStorage");
       }
       constructor() {
-        super("shipped.json");
+        super("shipped.json", ShippedJsonSchema);
       }
       getDefault() {
         return {
@@ -11823,6 +11898,7 @@ var init_state_storage = __esm({
   "core/storage/state-storage.ts"() {
     "use strict";
     init_schemas2();
+    init_state();
     init_date_helper();
     init_markdown_builder();
     init_storage_manager();
@@ -11831,7 +11907,7 @@ var init_state_storage = __esm({
         __name(this, "StateStorage");
       }
       constructor() {
-        super("state.json");
+        super("state.json", StateJsonSchema);
       }
       getDefault() {
         return {
@@ -12200,7 +12276,7 @@ var init_state_storage = __esm({
 });
 
 // core/storage/storage.ts
-import fs25 from "node:fs/promises";
+import fs26 from "node:fs/promises";
 import os8 from "node:os";
 import path24 from "node:path";
 function getStorage(projectId) {
@@ -12238,8 +12314,8 @@ var init_storage = __esm({
       }
       async write(pathArray, data) {
         const filePath = this.pathToFile(pathArray);
-        await fs25.mkdir(path24.dirname(filePath), { recursive: true });
-        await fs25.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        await fs26.mkdir(path24.dirname(filePath), { recursive: true });
+        await fs26.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
         eventBus.publish({
           type: inferEventType(pathArray, "write"),
           path: pathArray,
@@ -12254,7 +12330,7 @@ var init_storage = __esm({
       async read(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          const content = await fs25.readFile(filePath, "utf-8");
+          const content = await fs26.readFile(filePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -12266,7 +12342,7 @@ var init_storage = __esm({
       async list(prefix) {
         const dir = path24.join(this.basePath, `${prefix[0]}s`);
         try {
-          const files = await fs25.readdir(dir);
+          const files = await fs26.readdir(dir);
           return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => [...prefix, f.replace(".json", "")]);
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -12278,7 +12354,7 @@ var init_storage = __esm({
       async delete(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs25.unlink(filePath);
+          await fs26.unlink(filePath);
           eventBus.publish({
             type: inferEventType(pathArray, "delete"),
             path: pathArray,
@@ -12298,7 +12374,7 @@ var init_storage = __esm({
       async exists(pathArray) {
         const filePath = this.pathToFile(pathArray);
         try {
-          await fs25.access(filePath);
+          await fs26.access(filePath);
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -12314,7 +12390,7 @@ var init_storage = __esm({
         const indexPath = path24.join(this.basePath, `${collection}s`, "index.json");
         let index = { ids: [], updatedAt: "" };
         try {
-          const content = await fs25.readFile(indexPath, "utf-8");
+          const content = await fs26.readFile(indexPath, "utf-8");
           index = JSON.parse(content);
         } catch (error) {
           if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
@@ -12327,8 +12403,8 @@ var init_storage = __esm({
           index.ids = index.ids.filter((i) => i !== id);
         }
         index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        await fs25.mkdir(path24.dirname(indexPath), { recursive: true });
-        await fs25.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+        await fs26.mkdir(path24.dirname(indexPath), { recursive: true });
+        await fs26.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
       }
     };
     __name(getStorage, "getStorage");
@@ -12351,7 +12427,7 @@ var init_storage2 = __esm({
 });
 
 // core/agentic/template-loader.ts
-import fs26 from "node:fs/promises";
+import fs27 from "node:fs/promises";
 import path25 from "node:path";
 function updateLruOrder(key) {
   const index = cacheOrder.indexOf(key);
@@ -12392,7 +12468,7 @@ async function load(commandName) {
   }
   const templatePath = path25.join(TEMPLATES_DIR, `${commandName}.md`);
   try {
-    const rawContent = await fs26.readFile(templatePath, "utf-8");
+    const rawContent = await fs27.readFile(templatePath, "utf-8");
     const parsed = parseFrontmatter(rawContent);
     evictLru();
     cache.set(commandName, parsed);
@@ -12432,7 +12508,7 @@ var init_template_loader = __esm({
 
 // core/agentic/orchestrator-executor.ts
 import { exec as execCallback5 } from "node:child_process";
-import fs27 from "node:fs/promises";
+import fs28 from "node:fs/promises";
 import os9 from "node:os";
 import path26 from "node:path";
 import { promisify as promisify7 } from "node:util";
@@ -12703,7 +12779,7 @@ var init_orchestrator_executor = __esm({
       async loadRepoAnalysis(globalPath) {
         try {
           const analysisPath = path26.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs27.readFile(analysisPath, "utf-8");
+          const content = await fs28.readFile(analysisPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error)) return null;
@@ -12768,7 +12844,7 @@ var init_orchestrator_executor = __esm({
       async getAvailableAgentNames(globalPath) {
         try {
           const agentsDir = path26.join(globalPath, "agents");
-          const files = await fs27.readdir(agentsDir);
+          const files = await fs28.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
           return [];
@@ -12790,7 +12866,7 @@ var init_orchestrator_executor = __esm({
           for (const fileName of possibleNames) {
             const filePath = path26.join(agentsDir, fileName);
             try {
-              const content = await fs27.readFile(filePath, "utf-8");
+              const content = await fs28.readFile(filePath, "utf-8");
               const { frontmatter, body } = this.parseAgentFile(content);
               return {
                 name: fileName.replace(".md", ""),
@@ -12845,11 +12921,11 @@ var init_orchestrator_executor = __esm({
             const flatPath = path26.join(skillsDir, `${skillName}.md`);
             const subdirPath = path26.join(skillsDir, skillName, "SKILL.md");
             try {
-              const content = await fs27.readFile(subdirPath, "utf-8");
+              const content = await fs28.readFile(subdirPath, "utf-8");
               return { name: skillName, content, filePath: subdirPath };
             } catch {
               try {
-                const content = await fs27.readFile(flatPath, "utf-8");
+                const content = await fs28.readFile(flatPath, "utf-8");
                 return { name: skillName, content, filePath: flatPath };
               } catch {
                 const agentNames = skillToAgents.get(skillName) || [];
@@ -13772,7 +13848,7 @@ var init_outcomes2 = __esm({
 });
 
 // core/agentic/prompt-builder.ts
-import fs28 from "node:fs/promises";
+import fs29 from "node:fs/promises";
 import path28 from "node:path";
 var PromptBuilder, promptBuilder, prompt_builder_default;
 var init_prompt_builder = __esm({
@@ -13811,7 +13887,7 @@ var init_prompt_builder = __esm({
         }
         try {
           if (await fileExists(templatePath)) {
-            const content = await fs28.readFile(templatePath, "utf-8");
+            const content = await fs29.readFile(templatePath, "utf-8");
             this._templateCache.set(templatePath, { content, loadedAt: now });
             return content;
           }
@@ -13882,7 +13958,7 @@ var init_prompt_builder = __esm({
         const checklists = {};
         try {
           if (await fileExists(checklistsDir)) {
-            const files = (await fs28.readdir(checklistsDir)).filter((f) => f.endsWith(".md"));
+            const files = (await fs29.readdir(checklistsDir)).filter((f) => f.endsWith(".md"));
             for (const file of files) {
               const name = file.replace(".md", "");
               const templatePath = path28.join(checklistsDir, file);
@@ -14442,7 +14518,7 @@ Context: ${fileCount} files available. Read what you need.
 });
 
 // core/agentic/template-executor.ts
-import fs29 from "node:fs/promises";
+import fs30 from "node:fs/promises";
 import path29 from "node:path";
 var ORCHESTRATED_COMMANDS, SIMPLE_COMMANDS, TemplateExecutor, templateExecutor, template_executor_default;
 var init_template_executor = __esm({
@@ -14521,7 +14597,7 @@ var init_template_executor = __esm({
         try {
           const projectId = await this.getProjectId(projectPath);
           const agentsDir = path29.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
-          const files = await fs29.readdir(agentsDir);
+          const files = await fs30.readdir(agentsDir);
           return files.some((f) => f.endsWith(".md"));
         } catch (error) {
           if (isNotFoundError(error)) return false;
@@ -14535,7 +14611,7 @@ var init_template_executor = __esm({
         try {
           const projectId = await this.getProjectId(projectPath);
           const agentsDir = path29.join(path_manager_default.getGlobalProjectPath(projectId), "agents");
-          const files = await fs29.readdir(agentsDir);
+          const files = await fs30.readdir(agentsDir);
           return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
         } catch {
           return [];
@@ -14644,7 +14720,7 @@ When fragmenting tasks:
 
 // core/agentic/tool-registry.ts
 import { exec as exec7 } from "node:child_process";
-import fs30 from "node:fs/promises";
+import fs31 from "node:fs/promises";
 import { promisify as promisify8 } from "node:util";
 var execAsync4, toolRegistry, tool_registry_default;
 var init_tool_registry = __esm({
@@ -14688,14 +14764,14 @@ var init_tool_registry = __esm({
     };
     toolRegistry.register("Read", async (filePath) => {
       try {
-        return await fs30.readFile(filePath, "utf-8");
+        return await fs31.readFile(filePath, "utf-8");
       } catch (_error) {
         return null;
       }
     });
     toolRegistry.register("Write", async (filePath, content) => {
       try {
-        await fs30.writeFile(filePath, content, "utf-8");
+        await fs31.writeFile(filePath, content, "utf-8");
         return true;
       } catch (_error) {
         return false;
@@ -14730,23 +14806,23 @@ var init_tool_registry = __esm({
 });
 
 // core/agentic/command-executor.ts
-import fs31 from "node:fs/promises";
+import fs32 from "node:fs/promises";
 import os10 from "node:os";
 import path30 from "node:path";
 async function signalStart(commandName) {
   try {
     const dir = path30.dirname(RUNNING_FILE);
     if (!await fileExists(dir)) {
-      await fs31.mkdir(dir, { recursive: true });
+      await fs32.mkdir(dir, { recursive: true });
     }
-    await fs31.writeFile(RUNNING_FILE, `/p:${commandName}`);
+    await fs32.writeFile(RUNNING_FILE, `/p:${commandName}`);
   } catch (_error) {
   }
 }
 async function signalEnd() {
   try {
     if (await fileExists(RUNNING_FILE)) {
-      await fs31.unlink(RUNNING_FILE);
+      await fs32.unlink(RUNNING_FILE);
     }
   } catch (_error) {
   }
@@ -15079,7 +15155,7 @@ var init_command_executor = __esm({
 });
 
 // core/infrastructure/update-checker.ts
-import fs32 from "node:fs/promises";
+import fs33 from "node:fs/promises";
 import https from "node:https";
 import os11 from "node:os";
 import path31 from "node:path";
@@ -15110,7 +15186,7 @@ var init_update_checker = __esm({
       async getCurrentVersion() {
         try {
           const packageJsonPath = path31.join(__dirname, "..", "..", "package.json");
-          const packageJson = JSON.parse(await fs32.readFile(packageJsonPath, "utf8"));
+          const packageJson = JSON.parse(await fs33.readFile(packageJsonPath, "utf8"));
           return packageJson.version;
         } catch (error) {
           console.error("Error reading package version:", getErrorMessage2(error));
@@ -15180,7 +15256,7 @@ var init_update_checker = __esm({
       async readCache() {
         try {
           if (await fileExists(this.cacheFile)) {
-            const cache2 = JSON.parse(await fs32.readFile(this.cacheFile, "utf8"));
+            const cache2 = JSON.parse(await fs33.readFile(this.cacheFile, "utf8"));
             return cache2;
           }
         } catch (_error) {
@@ -15193,9 +15269,9 @@ var init_update_checker = __esm({
       async writeCache(data) {
         try {
           if (!await fileExists(this.cacheDir)) {
-            await fs32.mkdir(this.cacheDir, { recursive: true });
+            await fs33.mkdir(this.cacheDir, { recursive: true });
           }
-          await fs32.writeFile(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
+          await fs33.writeFile(this.cacheFile, JSON.stringify(data, null, 2), "utf8");
         } catch (_error) {
         }
       }
@@ -15353,7 +15429,7 @@ var init_agent_generator = __esm({
 });
 
 // core/agentic/agent-router.ts
-import fs33 from "node:fs/promises";
+import fs34 from "node:fs/promises";
 import path32 from "node:path";
 var AgentRouter, agent_router_default;
 var init_agent_router = __esm({
@@ -15383,12 +15459,12 @@ var init_agent_router = __esm({
       async loadAvailableAgents() {
         if (!this.agentsPath) return [];
         try {
-          const files = await fs33.readdir(this.agentsPath);
+          const files = await fs34.readdir(this.agentsPath);
           const agents = [];
           for (const file of files) {
             if (file.endsWith(".md")) {
               const name = file.replace(".md", "");
-              const content = await fs33.readFile(path32.join(this.agentsPath, file), "utf-8");
+              const content = await fs34.readFile(path32.join(this.agentsPath, file), "utf-8");
               agents.push({ name, content });
             }
           }
@@ -15414,7 +15490,7 @@ var init_agent_router = __esm({
         if (!this.agentsPath) return null;
         try {
           const filePath = path32.join(this.agentsPath, `${name}.md`);
-          const content = await fs33.readFile(filePath, "utf-8");
+          const content = await fs34.readFile(filePath, "utf-8");
           return { name, content };
         } catch (error) {
           if (!isNotFoundError(error)) {
@@ -15456,7 +15532,7 @@ var init_agent_router = __esm({
             projectId: this.projectId
           })}
 `;
-          await fs33.appendFile(logPath, entry);
+          await fs34.appendFile(logPath, entry);
         } catch (error) {
           if (!isNotFoundError(error)) {
             console.error(`Agent usage log error: ${getErrorMessage2(error)}`);
@@ -16935,7 +17011,7 @@ var init_memory_service = __esm({
 });
 
 // core/services/nested-context-resolver.ts
-import fs34 from "node:fs/promises";
+import fs35 from "node:fs/promises";
 import path36 from "node:path";
 var NestedContextResolver;
 var init_nested_context_resolver = __esm({
@@ -16989,7 +17065,7 @@ var init_nested_context_resolver = __esm({
        * Load a single PRJCT.md file into a NestedContext
        */
       async loadContext(filePath, parent, pkg = null) {
-        const content = await fs34.readFile(filePath, "utf-8");
+        const content = await fs35.readFile(filePath, "utf-8");
         const relativePath = path36.relative(this.rootPath, filePath);
         const depth = relativePath.split(path36.sep).length - 1;
         return {
@@ -17045,7 +17121,7 @@ var init_nested_context_resolver = __esm({
         const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
           if (depth > 5) return;
           try {
-            const entries = await fs34.readdir(currentDir, { withFileTypes: true });
+            const entries = await fs35.readdir(currentDir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
                 continue;
@@ -17212,7 +17288,7 @@ ${content}`);
        * Load a single AGENTS.md file into a NestedAgents structure
        */
       async loadAgents(filePath, parent, pkg = null) {
-        const content = await fs34.readFile(filePath, "utf-8");
+        const content = await fs35.readFile(filePath, "utf-8");
         const relativePath = path36.relative(this.rootPath, filePath);
         const depth = relativePath.split(path36.sep).length - 1;
         return {
@@ -17347,7 +17423,7 @@ ${content}`);
         const scan = /* @__PURE__ */ __name(async (currentDir, depth) => {
           if (depth > 5) return;
           try {
-            const entries = await fs34.readdir(currentDir, { withFileTypes: true });
+            const entries = await fs35.readdir(currentDir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
                 continue;
@@ -17980,16 +18056,16 @@ var init_onboarding = __esm({
        * Detect project type from file system
        */
       async detectProjectType() {
-        const fs52 = await import("node:fs/promises");
+        const fs53 = await import("node:fs/promises");
         const path65 = await import("node:path");
         try {
-          const files = await fs52.readdir(this.projectPath);
+          const files = await fs53.readdir(this.projectPath);
           if (files.includes("turbo.json") || files.includes("lerna.json") || files.includes("nx.json")) {
             return "monorepo";
           }
           if (files.includes("package.json")) {
             const pkgPath = path65.join(this.projectPath, "package.json");
-            const pkgContent = await fs52.readFile(pkgPath, "utf-8");
+            const pkgContent = await fs53.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             if (pkg.bin) return "cli-tool";
@@ -18025,32 +18101,32 @@ var init_onboarding = __esm({
        * Detect installed AI agents from config files
        */
       async detectInstalledAgents() {
-        const fs52 = await import("node:fs/promises");
+        const fs53 = await import("node:fs/promises");
         const path65 = await import("node:path");
         const os21 = await import("node:os");
         const agents = [];
         try {
-          await fs52.access(path65.join(os21.homedir(), ".claude"));
+          await fs53.access(path65.join(os21.homedir(), ".claude"));
           agents.push("claude");
         } catch {
         }
         try {
-          await fs52.access(path65.join(this.projectPath, ".cursorrules"));
+          await fs53.access(path65.join(this.projectPath, ".cursorrules"));
           agents.push("cursor");
         } catch {
         }
         try {
-          await fs52.access(path65.join(this.projectPath, ".windsurfrules"));
+          await fs53.access(path65.join(this.projectPath, ".windsurfrules"));
           agents.push("windsurf");
         } catch {
         }
         try {
-          await fs52.access(path65.join(this.projectPath, ".github", "copilot-instructions.md"));
+          await fs53.access(path65.join(this.projectPath, ".github", "copilot-instructions.md"));
           agents.push("copilot");
         } catch {
         }
         try {
-          await fs52.access(path65.join(os21.homedir(), ".gemini"));
+          await fs53.access(path65.join(os21.homedir(), ".gemini"));
           agents.push("gemini");
         } catch {
         }
@@ -18060,17 +18136,17 @@ var init_onboarding = __esm({
        * Detect tech stack from project files
        */
       async detectStack() {
-        const fs52 = await import("node:fs/promises");
+        const fs53 = await import("node:fs/promises");
         const path65 = await import("node:path");
         const stack = {
           language: "Unknown",
           technologies: []
         };
         try {
-          const files = await fs52.readdir(this.projectPath);
+          const files = await fs53.readdir(this.projectPath);
           if (files.includes("package.json")) {
             const pkgPath = path65.join(this.projectPath, "package.json");
-            const pkgContent = await fs52.readFile(pkgPath, "utf-8");
+            const pkgContent = await fs53.readFile(pkgPath, "utf-8");
             const pkg = JSON.parse(pkgContent);
             const deps = { ...pkg.dependencies, ...pkg.devDependencies };
             stack.language = deps.typescript ? "TypeScript" : "JavaScript";
@@ -18177,14 +18253,14 @@ var init_wizard = __esm({
 
 // core/context/generator.ts
 import { exec as exec10 } from "node:child_process";
-import fs35 from "node:fs/promises";
+import fs36 from "node:fs/promises";
 import path37 from "node:path";
 import { promisify as promisify11 } from "node:util";
 async function generateContext(projectId, repoPath) {
   const _globalPath = path_manager_default.getGlobalProjectPath(projectId);
   const contextPath = path_manager_default.getContextPath(projectId);
   const storage = getStorage(projectId);
-  await fs35.mkdir(contextPath, { recursive: true });
+  await fs36.mkdir(contextPath, { recursive: true });
   const project = await storage.read(["project"]) || {};
   const taskPaths = await storage.list(["task"]);
   const featurePaths = await storage.list(["feature"]);
@@ -18267,7 +18343,7 @@ async function getPackageData(repoPath) {
   };
   try {
     const pkgPath = path37.join(repoPath, "package.json");
-    const pkg = JSON.parse(await fs35.readFile(pkgPath, "utf-8"));
+    const pkg = JSON.parse(await fs36.readFile(pkgPath, "utf-8"));
     data.dependencies = pkg.dependencies || {};
     data.devDependencies = pkg.devDependencies || {};
     data.scripts = pkg.scripts || {};
@@ -18351,7 +18427,7 @@ ${agents.length > 0 ? agents.map((a) => `- **${a.name}**: ${a.role || "Specialis
     \u2514\u2500\u2500 pending.json
 \`\`\`
 `;
-  await fs35.writeFile(path37.join(contextPath, "CLAUDE.md"), content, "utf-8");
+  await fs36.writeFile(path37.join(contextPath, "CLAUDE.md"), content, "utf-8");
 }
 async function generateNowMd(contextPath, tasks) {
   const currentTask = tasks.find((t) => t.status === "in_progress");
@@ -18366,7 +18442,7 @@ async function generateNowMd(contextPath, tasks) {
 
 _No active task. Use /p:now to start._
 `;
-  await fs35.writeFile(path37.join(contextPath, "now.md"), content, "utf-8");
+  await fs36.writeFile(path37.join(contextPath, "now.md"), content, "utf-8");
 }
 async function generateQueueMd(contextPath, tasks) {
   const pendingTasks = tasks.filter((t) => t.status === "pending");
@@ -18374,7 +18450,7 @@ async function generateQueueMd(contextPath, tasks) {
 
 ${pendingTasks.length > 0 ? pendingTasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ""}`).join("\n") : "_Empty queue. Use /p:next to add tasks._"}
 `;
-  await fs35.writeFile(path37.join(contextPath, "queue.md"), content, "utf-8");
+  await fs36.writeFile(path37.join(contextPath, "queue.md"), content, "utf-8");
 }
 async function generateSummaryMd(contextPath, project, gitData, pkgData) {
   const content = `# PROJECT SUMMARY
@@ -18394,7 +18470,7 @@ async function generateSummaryMd(contextPath, project, gitData, pkgData) {
 - Production: ${Object.keys(pkgData.dependencies).length}
 - Dev: ${Object.keys(pkgData.devDependencies).length}
 `;
-  await fs35.writeFile(path37.join(contextPath, "summary.md"), content, "utf-8");
+  await fs36.writeFile(path37.join(contextPath, "summary.md"), content, "utf-8");
 }
 var execAsync7;
 var init_generator = __esm({
@@ -18415,7 +18491,7 @@ var init_generator = __esm({
 
 // core/domain/analyzer.ts
 import { exec as execCallback6 } from "node:child_process";
-import fs36 from "node:fs/promises";
+import fs37 from "node:fs/promises";
 import path38 from "node:path";
 import { promisify as promisify12 } from "node:util";
 var exec11, CodebaseAnalyzer, analyzer, analyzer_default2;
@@ -18441,7 +18517,7 @@ var init_analyzer2 = __esm({
       async readPackageJson() {
         try {
           const packagePath = path38.join(this.projectPath, "package.json");
-          const content = await fs36.readFile(packagePath, "utf-8");
+          const content = await fs37.readFile(packagePath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -18456,7 +18532,7 @@ var init_analyzer2 = __esm({
       async readCargoToml() {
         try {
           const cargoPath = path38.join(this.projectPath, "Cargo.toml");
-          return await fs36.readFile(cargoPath, "utf-8");
+          return await fs37.readFile(cargoPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18470,7 +18546,7 @@ var init_analyzer2 = __esm({
       async readRequirements() {
         try {
           const reqPath = path38.join(this.projectPath, "requirements.txt");
-          return await fs36.readFile(reqPath, "utf-8");
+          return await fs37.readFile(reqPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18484,7 +18560,7 @@ var init_analyzer2 = __esm({
       async readGoMod() {
         try {
           const goModPath = path38.join(this.projectPath, "go.mod");
-          return await fs36.readFile(goModPath, "utf-8");
+          return await fs37.readFile(goModPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18498,7 +18574,7 @@ var init_analyzer2 = __esm({
       async readGemfile() {
         try {
           const gemfilePath = path38.join(this.projectPath, "Gemfile");
-          return await fs36.readFile(gemfilePath, "utf-8");
+          return await fs37.readFile(gemfilePath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18512,7 +18588,7 @@ var init_analyzer2 = __esm({
       async readMixExs() {
         try {
           const mixPath = path38.join(this.projectPath, "mix.exs");
-          return await fs36.readFile(mixPath, "utf-8");
+          return await fs37.readFile(mixPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18526,7 +18602,7 @@ var init_analyzer2 = __esm({
       async readPomXml() {
         try {
           const pomPath = path38.join(this.projectPath, "pom.xml");
-          return await fs36.readFile(pomPath, "utf-8");
+          return await fs37.readFile(pomPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18540,7 +18616,7 @@ var init_analyzer2 = __esm({
       async readComposerJson() {
         try {
           const composerPath = path38.join(this.projectPath, "composer.json");
-          const content = await fs36.readFile(composerPath, "utf-8");
+          const content = await fs37.readFile(composerPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
           if (isNotFoundError(error) || error instanceof SyntaxError) {
@@ -18555,7 +18631,7 @@ var init_analyzer2 = __esm({
       async readPyprojectToml() {
         try {
           const pyprojectPath = path38.join(this.projectPath, "pyproject.toml");
-          return await fs36.readFile(pyprojectPath, "utf-8");
+          return await fs37.readFile(pyprojectPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18591,7 +18667,7 @@ var init_analyzer2 = __esm({
        */
       async listConfigFiles() {
         try {
-          const entries = await fs36.readdir(this.projectPath);
+          const entries = await fs37.readdir(this.projectPath);
           const configPatterns = [
             /^package\.json$/,
             /^Cargo\.toml$/,
@@ -18621,7 +18697,7 @@ var init_analyzer2 = __esm({
        */
       async listDirectories() {
         try {
-          const entries = await fs36.readdir(this.projectPath, { withFileTypes: true });
+          const entries = await fs37.readdir(this.projectPath, { withFileTypes: true });
           return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules");
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -18692,7 +18768,7 @@ var init_analyzer2 = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs36.access(path38.join(this.projectPath, filename));
+          await fs37.access(path38.join(this.projectPath, filename));
           return true;
         } catch (error) {
           if (isNotFoundError(error)) {
@@ -18707,7 +18783,7 @@ var init_analyzer2 = __esm({
       async readFile(relativePath) {
         try {
           const fullPath = path38.join(this.projectPath, relativePath);
-          return await fs36.readFile(fullPath, "utf-8");
+          return await fs37.readFile(fullPath, "utf-8");
         } catch (error) {
           if (isNotFoundError(error)) {
             return null;
@@ -18955,7 +19031,7 @@ var analysis_exports = {};
 __export(analysis_exports, {
   AnalysisCommands: () => AnalysisCommands
 });
-import fs37 from "node:fs/promises";
+import fs38 from "node:fs/promises";
 import path39 from "node:path";
 import prompts2 from "prompts";
 var AnalysisCommands;
@@ -19187,7 +19263,7 @@ var init_analysis2 = __esm({
           const claudeMdPath = path39.join(globalPath, "context", "CLAUDE.md");
           let existingContent = null;
           try {
-            existingContent = await fs37.readFile(claudeMdPath, "utf-8");
+            existingContent = await fs38.readFile(claudeMdPath, "utf-8");
           } catch {
           }
           const isNonInteractive = !process.stdin.isTTY || options.json;
@@ -19206,7 +19282,7 @@ var init_analysis2 = __esm({
             }
             let newContent;
             try {
-              newContent = await fs37.readFile(claudeMdPath, "utf-8");
+              newContent = await fs38.readFile(claudeMdPath, "utf-8");
             } catch {
               newContent = "";
             }
@@ -19230,7 +19306,7 @@ var init_analysis2 = __esm({
             }
             const restoreOriginal = /* @__PURE__ */ __name(async () => {
               if (existingContent != null) {
-                await fs37.writeFile(claudeMdPath, existingContent, "utf-8");
+                await fs38.writeFile(claudeMdPath, existingContent, "utf-8");
               }
             }, "restoreOriginal");
             if (isNonInteractive) {
@@ -19449,7 +19525,7 @@ ${formatFullDiff(diff)}`);
           let projectName = "Unknown";
           try {
             const projectJson = JSON.parse(
-              await fs37.readFile(path39.join(globalPath, "project.json"), "utf-8")
+              await fs38.readFile(path39.join(globalPath, "project.json"), "utf-8")
             );
             projectName = projectJson.name || "Unknown";
           } catch {
@@ -20204,8 +20280,8 @@ Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()}
             const globalPath2 = path_manager_default.getGlobalProjectPath(projectId);
             const specsPath2 = path40.join(globalPath2, "planning", "specs");
             try {
-              const fs52 = await import("node:fs/promises");
-              const files = await fs52.readdir(specsPath2);
+              const fs53 = await import("node:fs/promises");
+              const files = await fs53.readdir(specsPath2);
               const specs = files.filter((f) => f.endsWith(".md") && f !== ".gitkeep");
               if (specs.length === 0) {
                 output_default.warn("no specs yet");
@@ -20419,7 +20495,7 @@ var init_project_service = __esm({
 
 // core/services/staleness-checker.ts
 import { exec as exec12 } from "node:child_process";
-import fs38 from "node:fs/promises";
+import fs39 from "node:fs/promises";
 import path41 from "node:path";
 import { promisify as promisify13 } from "node:util";
 var execAsync8, DEFAULT_CONFIG, StalenessChecker, createStalenessChecker;
@@ -20473,7 +20549,7 @@ var init_staleness_checker = __esm({
           const projectJsonPath = path41.join(path_manager_default.getGlobalProjectPath(projectId), "project.json");
           let projectJson = {};
           try {
-            projectJson = JSON.parse(await fs38.readFile(projectJsonPath, "utf-8"));
+            projectJson = JSON.parse(await fs39.readFile(projectJsonPath, "utf-8"));
           } catch {
             status.isStale = true;
             status.reason = "No sync history found. Run `prjct sync` to initialize.";
@@ -21040,7 +21116,7 @@ var init_registry = __esm({
 });
 
 // core/ai-tools/generator.ts
-import fs39 from "node:fs/promises";
+import fs40 from "node:fs/promises";
 import path43 from "node:path";
 async function generateAIToolContexts(context2, globalPath, repoPath, toolIds = DEFAULT_AI_TOOLS) {
   const results = [];
@@ -21080,9 +21156,9 @@ async function generateForTool(context2, config, globalPath, repoPath) {
     } else {
       outputPath = path43.join(globalPath, "context", config.outputFile);
     }
-    await fs39.mkdir(path43.dirname(outputPath), { recursive: true });
+    await fs40.mkdir(path43.dirname(outputPath), { recursive: true });
     try {
-      const existingContent = await fs39.readFile(outputPath, "utf-8");
+      const existingContent = await fs40.readFile(outputPath, "utf-8");
       const validation = validatePreserveBlocks(existingContent);
       if (!validation.valid) {
         console.warn(`\u26A0\uFE0F  ${config.outputFile} has invalid preserve blocks:`);
@@ -21093,7 +21169,7 @@ async function generateForTool(context2, config, globalPath, repoPath) {
       content = mergePreservedSections(content, existingContent);
     } catch {
     }
-    await fs39.writeFile(outputPath, content, "utf-8");
+    await fs40.writeFile(outputPath, content, "utf-8");
     return {
       toolId: config.id,
       outputFile: config.outputFile,
@@ -21133,7 +21209,7 @@ var init_ai_tools = __esm({
 });
 
 // core/services/context-generator.ts
-import fs40 from "node:fs/promises";
+import fs41 from "node:fs/promises";
 import path44 from "node:path";
 var ContextFileGenerator;
 var init_context_generator = __esm({
@@ -21159,7 +21235,7 @@ var init_context_generator = __esm({
       async writeWithPreservation(filePath, content) {
         let finalContent = content;
         try {
-          const existingContent = await fs40.readFile(filePath, "utf-8");
+          const existingContent = await fs41.readFile(filePath, "utf-8");
           const validation = validatePreserveBlocks(existingContent);
           if (!validation.valid) {
             const filename = path44.basename(filePath);
@@ -21171,7 +21247,7 @@ var init_context_generator = __esm({
           finalContent = mergePreservedSections(content, existingContent);
         } catch {
         }
-        await fs40.writeFile(filePath, finalContent, "utf-8");
+        await fs41.writeFile(filePath, finalContent, "utf-8");
       }
       /**
        * Generate all context files in parallel
@@ -21287,7 +21363,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
         let currentTask = null;
         try {
           const statePath = path44.join(this.config.globalPath, "storage", "state.json");
-          const state = JSON.parse(await fs40.readFile(statePath, "utf-8"));
+          const state = JSON.parse(await fs41.readFile(statePath, "utf-8"));
           currentTask = state.currentTask;
         } catch {
         }
@@ -21312,7 +21388,7 @@ Use \`p. task "description"\` to start working.
         let queue = { tasks: [] };
         try {
           const queuePath = path44.join(this.config.globalPath, "storage", "queue.json");
-          queue = JSON.parse(await fs40.readFile(queuePath, "utf-8"));
+          queue = JSON.parse(await fs41.readFile(queuePath, "utf-8"));
         } catch {
         }
         const content = `# NEXT
@@ -21328,7 +21404,7 @@ ${queue.tasks.length > 0 ? queue.tasks.map((t, i) => `${i + 1}. ${t.description}
         let ideas = { ideas: [] };
         try {
           const ideasPath = path44.join(this.config.globalPath, "storage", "ideas.json");
-          ideas = JSON.parse(await fs40.readFile(ideasPath, "utf-8"));
+          ideas = JSON.parse(await fs41.readFile(ideasPath, "utf-8"));
         } catch {
         }
         const content = `# IDEAS
@@ -21346,7 +21422,7 @@ ${ideas.ideas.length > 0 ? ideas.ideas.map((i) => `- ${i.text}${i.priority ? ` [
         };
         try {
           const shippedPath = path44.join(this.config.globalPath, "storage", "shipped.json");
-          shipped = JSON.parse(await fs40.readFile(shippedPath, "utf-8"));
+          shipped = JSON.parse(await fs41.readFile(shippedPath, "utf-8"));
         } catch {
         }
         const content = `# SHIPPED \u{1F680}
@@ -21400,7 +21476,7 @@ ${shipped.shipped.length > 0 ? shipped.shipped.slice(-10).map((s) => `- **${s.na
         let pkgName = pkg.name;
         try {
           const pkgJsonPath = path44.join(pkg.path, "package.json");
-          const pkgJson = JSON.parse(await fs40.readFile(pkgJsonPath, "utf-8"));
+          const pkgJson = JSON.parse(await fs41.readFile(pkgJsonPath, "utf-8"));
           pkgVersion = pkgJson.version || stats.version;
           pkgName = pkgJson.name || pkg.name;
         } catch {
@@ -21465,7 +21541,7 @@ Load from \`~/.prjct-cli/projects/${this.config.projectId}/agents/\`:
 });
 
 // core/services/local-state-generator.ts
-import fs41 from "node:fs/promises";
+import fs42 from "node:fs/promises";
 import path45 from "node:path";
 var LOCAL_STATE_FILENAME, LocalStateGenerator, localStateGenerator;
 var init_local_state_generator = __esm({
@@ -21483,7 +21559,7 @@ var init_local_state_generator = __esm({
       async generate(projectPath, state) {
         const filePath = path45.join(projectPath, LOCAL_STATE_FILENAME);
         const content = this.toMarkdown(state);
-        await fs41.writeFile(filePath, content, "utf-8");
+        await fs42.writeFile(filePath, content, "utf-8");
       }
       /**
        * Remove local state file
@@ -21491,7 +21567,7 @@ var init_local_state_generator = __esm({
       async remove(projectPath) {
         const filePath = path45.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs41.unlink(filePath);
+          await fs42.unlink(filePath);
         } catch (error) {
           if (!isNotFoundError(error)) throw error;
         }
@@ -21502,7 +21578,7 @@ var init_local_state_generator = __esm({
       async exists(projectPath) {
         const filePath = path45.join(projectPath, LOCAL_STATE_FILENAME);
         try {
-          await fs41.access(filePath);
+          await fs42.access(filePath);
           return true;
         } catch {
           return false;
@@ -21581,7 +21657,7 @@ var init_local_state_generator = __esm({
 });
 
 // core/services/skill-lock.ts
-import fs42 from "node:fs/promises";
+import fs43 from "node:fs/promises";
 import os13 from "node:os";
 import path46 from "node:path";
 function getLockFilePath() {
@@ -21596,7 +21672,7 @@ function createEmptyLockFile() {
 }
 async function read() {
   try {
-    const content = await fs42.readFile(getLockFilePath(), "utf-8");
+    const content = await fs43.readFile(getLockFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return createEmptyLockFile();
@@ -21604,9 +21680,9 @@ async function read() {
 }
 async function write(lockFile) {
   const lockPath = getLockFilePath();
-  await fs42.mkdir(path46.dirname(lockPath), { recursive: true });
+  await fs43.mkdir(path46.dirname(lockPath), { recursive: true });
   lockFile.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs42.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
+  await fs43.writeFile(lockPath, JSON.stringify(lockFile, null, 2), "utf-8");
 }
 async function addEntry(entry) {
   const lockFile = await read();
@@ -21659,7 +21735,7 @@ var init_skill_lock = __esm({
 
 // core/services/skill-installer.ts
 import { exec as execCallback7 } from "node:child_process";
-import fs43 from "node:fs/promises";
+import fs44 from "node:fs/promises";
 import os14 from "node:os";
 import path47 from "node:path";
 import { promisify as promisify15 } from "node:util";
@@ -21705,7 +21781,7 @@ async function discoverSkills(dir) {
   const skills = [];
   try {
     const rootSkill = path47.join(dir, "SKILL.md");
-    await fs43.access(rootSkill);
+    await fs44.access(rootSkill);
     const dirName = path47.basename(dir);
     skills.push({ name: dirName, filePath: rootSkill });
   } catch {
@@ -21761,10 +21837,10 @@ async function installSkillFile(sourcePath, name, source, sha) {
   const installDir = getInstallDir();
   const targetDir = path47.join(installDir, name);
   const targetPath = path47.join(targetDir, "SKILL.md");
-  const content = await fs43.readFile(sourcePath, "utf-8");
+  const content = await fs44.readFile(sourcePath, "utf-8");
   const enrichedContent = injectSourceMetadata(content, source, sha);
-  await fs43.mkdir(targetDir, { recursive: true });
-  await fs43.writeFile(targetPath, enrichedContent, "utf-8");
+  await fs44.mkdir(targetDir, { recursive: true });
+  await fs44.writeFile(targetPath, enrichedContent, "utf-8");
   return {
     name,
     filePath: targetPath,
@@ -21825,7 +21901,7 @@ async function installFromGitHub(source) {
     }
   } finally {
     try {
-      await fs43.rm(tmpDir, { recursive: true, force: true });
+      await fs44.rm(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -21835,12 +21911,12 @@ async function installFromLocal(source) {
   const result = { installed: [], skipped: [], errors: [] };
   const localPath = source.localPath;
   try {
-    await fs43.access(localPath);
+    await fs44.access(localPath);
   } catch {
     result.errors.push(`Local path not found: ${localPath}`);
     return result;
   }
-  const stat = await fs43.stat(localPath);
+  const stat = await fs44.stat(localPath);
   if (stat.isFile()) {
     const name = path47.basename(path47.dirname(localPath));
     try {
@@ -21884,12 +21960,12 @@ async function remove(name) {
   const installDir = getInstallDir();
   const subdirPath = path47.join(installDir, name);
   try {
-    await fs43.rm(subdirPath, { recursive: true, force: true });
+    await fs44.rm(subdirPath, { recursive: true, force: true });
   } catch {
   }
   const flatPath = path47.join(installDir, `${name}.md`);
   try {
-    await fs43.rm(flatPath, { force: true });
+    await fs44.rm(flatPath, { force: true });
   } catch {
   }
   return skillLock.removeEntry(name);
@@ -21937,7 +22013,7 @@ var init_skill_installer = __esm({
 });
 
 // core/services/stack-detector.ts
-import fs44 from "node:fs/promises";
+import fs45 from "node:fs/promises";
 import path48 from "node:path";
 var StackDetector;
 var init_stack_detector = __esm({
@@ -22098,7 +22174,7 @@ var init_stack_detector = __esm({
       async readPackageJson() {
         try {
           const pkgPath = path48.join(this.projectPath, "package.json");
-          const content = await fs44.readFile(pkgPath, "utf-8");
+          const content = await fs45.readFile(pkgPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -22109,7 +22185,7 @@ var init_stack_detector = __esm({
        */
       async fileExists(filename) {
         try {
-          await fs44.access(path48.join(this.projectPath, filename));
+          await fs45.access(path48.join(this.projectPath, filename));
           return true;
         } catch {
           return false;
@@ -22121,7 +22197,7 @@ var init_stack_detector = __esm({
 
 // core/services/sync-verifier.ts
 import { exec as exec15 } from "node:child_process";
-import fs45 from "node:fs/promises";
+import fs46 from "node:fs/promises";
 import path49 from "node:path";
 import { promisify as promisify16 } from "node:util";
 var execAsync10, BUILTIN_CHECKS, SyncVerifier, syncVerifier;
@@ -22141,7 +22217,7 @@ var init_sync_verifier = __esm({
         for (const file of expected) {
           const filePath = path49.join(globalPath, file);
           try {
-            await fs45.access(filePath);
+            await fs46.access(filePath);
           } catch {
             missing.push(file);
           }
@@ -22164,7 +22240,7 @@ var init_sync_verifier = __esm({
         for (const file of jsonFiles) {
           const filePath = path49.join(globalPath, file);
           try {
-            const content = await fs45.readFile(filePath, "utf-8");
+            const content = await fs46.readFile(filePath, "utf-8");
             JSON.parse(content);
           } catch (error) {
             if (!isNotFoundError(error)) {
@@ -22193,10 +22269,10 @@ var init_sync_verifier = __esm({
         ];
         const violations = [];
         try {
-          const files = await fs45.readdir(contextDir);
+          const files = await fs46.readdir(contextDir);
           for (const file of files) {
             if (!file.endsWith(".md")) continue;
-            const content = await fs45.readFile(path49.join(contextDir, file), "utf-8");
+            const content = await fs46.readFile(path49.join(contextDir, file), "utf-8");
             for (const pattern of patterns) {
               if (pattern.test(content)) {
                 violations.push(`${file}: potential sensitive data detected`);
@@ -22317,7 +22393,7 @@ var init_sync_verifier = __esm({
 
 // core/services/sync-service.ts
 import { exec as exec16 } from "node:child_process";
-import fs46 from "node:fs/promises";
+import fs47 from "node:fs/promises";
 import os15 from "node:os";
 import path50 from "node:path";
 import { promisify as promisify17 } from "node:util";
@@ -22495,7 +22571,7 @@ var init_sync_service = __esm({
       async ensureDirectories() {
         const dirs = ["storage", "context", "agents", "memory", "analysis", "config", "sync"];
         await Promise.all(
-          dirs.map((dir) => fs46.mkdir(path50.join(this.globalPath, dir), { recursive: true }))
+          dirs.map((dir) => fs47.mkdir(path50.join(this.globalPath, dir), { recursive: true }))
         );
       }
       // ==========================================================================
@@ -22584,7 +22660,7 @@ var init_sync_service = __esm({
         }
         try {
           const pkgPath = path50.join(this.projectPath, "package.json");
-          const pkg = JSON.parse(await fs46.readFile(pkgPath, "utf-8"));
+          const pkg = JSON.parse(await fs47.readFile(pkgPath, "utf-8"));
           stats.version = pkg.version || "0.0.0";
           stats.name = pkg.name || stats.name;
           stats.ecosystem = "JavaScript";
@@ -22731,10 +22807,10 @@ var init_sync_service = __esm({
         const agents = [];
         const agentsPath = path50.join(this.globalPath, "agents");
         try {
-          const files = await fs46.readdir(agentsPath);
+          const files = await fs47.readdir(agentsPath);
           for (const file of files) {
             if (file.endsWith(".md")) {
-              await fs46.unlink(path50.join(agentsPath, file));
+              await fs47.unlink(path50.join(agentsPath, file));
             }
           }
         } catch (error) {
@@ -22792,7 +22868,7 @@ var init_sync_service = __esm({
             `${partialName}.md`
           );
           try {
-            const partialContent = await fs46.readFile(partialPath, "utf-8");
+            const partialContent = await fs47.readFile(partialPath, "utf-8");
             resolved = resolved.replace(match[0], partialContent.trim());
           } catch {
             resolved = resolved.replace(match[0], `<!-- partial "${partialName}" not found -->`);
@@ -22812,7 +22888,7 @@ var init_sync_service = __esm({
             "workflow",
             `${name}.md`
           );
-          content = await fs46.readFile(templatePath, "utf-8");
+          content = await fs47.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
         } catch (error) {
           logger_default.debug("Workflow agent template not found, generating minimal", {
@@ -22821,7 +22897,7 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalWorkflowAgent(name);
         }
-        await fs46.writeFile(path50.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs47.writeFile(path50.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       async generateDomainAgent(name, agentsPath, stats, stack) {
         let content = "";
@@ -22835,7 +22911,7 @@ var init_sync_service = __esm({
             "domain",
             `${name}.md`
           );
-          content = await fs46.readFile(templatePath, "utf-8");
+          content = await fs47.readFile(templatePath, "utf-8");
           content = await this.resolveTemplateIncludes(content);
           content = content.replace("{projectName}", stats.name);
           content = content.replace("{frameworks}", stack.frameworks.join(", ") || "None detected");
@@ -22847,7 +22923,7 @@ var init_sync_service = __esm({
           });
           content = this.generateMinimalDomainAgent(name, stats, stack);
         }
-        await fs46.writeFile(path50.join(agentsPath, `${name}.md`), content, "utf-8");
+        await fs47.writeFile(path50.join(agentsPath, `${name}.md`), content, "utf-8");
       }
       generateMinimalWorkflowAgent(name) {
         const descriptions = {
@@ -22915,7 +22991,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           })),
           agentSkillMap: Object.fromEntries(skills.map((s) => [s.agent, s.skill]))
         };
-        fs46.writeFile(
+        fs47.writeFile(
           path50.join(this.globalPath, "config", "skills.json"),
           JSON.stringify(skillsConfig, null, 2),
           "utf-8"
@@ -22942,7 +23018,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
             "config",
             "skill-mappings.json"
           );
-          const mappingsContent = await fs46.readFile(mappingsPath, "utf-8");
+          const mappingsContent = await fs47.readFile(mappingsPath, "utf-8");
           const mappings = JSON.parse(mappingsContent);
           const agentToSkillMap = mappings.agentToSkillMap || {};
           const packagesToInstall = [];
@@ -22962,11 +23038,11 @@ You are the ${name} expert for this project. Apply best practices for the detect
             const flatPath = path50.join(skillsDir, `${skillName}.md`);
             let alreadyInstalled = false;
             try {
-              await fs46.access(subdirPath);
+              await fs47.access(subdirPath);
               alreadyInstalled = true;
             } catch {
               try {
-                await fs46.access(flatPath);
+                await fs47.access(flatPath);
                 alreadyInstalled = true;
               } catch {
               }
@@ -23021,7 +23097,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
         const projectJsonPath = path50.join(this.globalPath, "project.json");
         let existing = {};
         try {
-          existing = JSON.parse(await fs46.readFile(projectJsonPath, "utf-8"));
+          existing = JSON.parse(await fs47.readFile(projectJsonPath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing project.json", {
             path: projectJsonPath,
@@ -23047,7 +23123,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           lastSyncCommit: git.recentCommits[0]?.hash || null,
           lastSyncBranch: git.branch
         };
-        await fs46.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
+        await fs47.writeFile(projectJsonPath, JSON.stringify(updated, null, 2), "utf-8");
       }
       // ==========================================================================
       // STATE.JSON UPDATE
@@ -23056,7 +23132,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
         const statePath = path50.join(this.globalPath, "storage", "state.json");
         let state = {};
         try {
-          state = JSON.parse(await fs46.readFile(statePath, "utf-8"));
+          state = JSON.parse(await fs47.readFile(statePath, "utf-8"));
         } catch (error) {
           logger_default.debug("No existing state.json", { path: statePath, error: getErrorMessage(error) });
         }
@@ -23084,7 +23160,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           lastAction: "Synced project",
           nextAction: 'Run `p. task "description"` to start working'
         };
-        await fs46.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+        await fs47.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
         try {
           await localStateGenerator.generate(
             this.projectPath,
@@ -23107,7 +23183,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
           fileCount: stats.fileCount,
           commitCount: git.commits
         };
-        await fs46.appendFile(memoryPath, `${JSON.stringify(event)}
+        await fs47.appendFile(memoryPath, `${JSON.stringify(event)}
 `, "utf-8");
       }
       // ==========================================================================
@@ -23128,7 +23204,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
         for (const file of contextFiles) {
           try {
             const filePath = path50.join(this.globalPath, file);
-            const content = await fs46.readFile(filePath, "utf-8");
+            const content = await fs47.readFile(filePath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Context file not found for metrics", { file, error: getErrorMessage(error) });
@@ -23137,7 +23213,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
         for (const agent of agents) {
           try {
             const agentPath = path50.join(this.globalPath, "agents", `${agent.name}.md`);
-            const content = await fs46.readFile(agentPath, "utf-8");
+            const content = await fs47.readFile(agentPath, "utf-8");
             filteredChars += content.length;
           } catch (error) {
             logger_default.debug("Agent file not found for metrics", {
@@ -23173,7 +23249,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       // ==========================================================================
       async fileExists(filename) {
         try {
-          await fs46.access(path50.join(this.projectPath, filename));
+          await fs47.access(path50.join(this.projectPath, filename));
           return true;
         } catch (error) {
           logger_default.debug("File not found", { filename, error: getErrorMessage(error) });
@@ -23183,7 +23259,7 @@ You are the ${name} expert for this project. Apply best practices for the detect
       async getCliVersion() {
         try {
           const pkgPath = path50.join(__dirname, "..", "..", "package.json");
-          const pkg = JSON.parse(await fs46.readFile(pkgPath, "utf-8"));
+          const pkg = JSON.parse(await fs47.readFile(pkgPath, "utf-8"));
           return pkg.version || "0.0.0";
         } catch (error) {
           logger_default.debug("Failed to read CLI version", { error: getErrorMessage(error) });
@@ -23344,7 +23420,7 @@ __export(uninstall_exports, {
   uninstall: () => uninstall
 });
 import { execSync as execSync3 } from "node:child_process";
-import fs47 from "node:fs/promises";
+import fs48 from "node:fs/promises";
 import os16 from "node:os";
 import path51 from "node:path";
 import readline2 from "node:readline";
@@ -23352,14 +23428,14 @@ import chalk12 from "chalk";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries = await fs47.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs48.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const entryPath = path51.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(entryPath);
       } else {
         try {
-          const stats = await fs47.stat(entryPath);
+          const stats = await fs48.stat(entryPath);
           totalSize += stats.size;
         } catch {
         }
@@ -23378,7 +23454,7 @@ function formatSize(bytes) {
 }
 async function countDirectoryItems(dirPath) {
   try {
-    const entries = await fs47.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs48.readdir(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).length;
   } catch {
     return 0;
@@ -23426,7 +23502,7 @@ async function gatherUninstallItems() {
   let hasPrjctSection = false;
   if (claudeMdExists) {
     try {
-      const content = await fs47.readFile(claudeMdPath, "utf-8");
+      const content = await fs48.readFile(claudeMdPath, "utf-8");
       hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -23476,7 +23552,7 @@ async function gatherUninstallItems() {
   let hasGeminiPrjctSection = false;
   if (geminiMdExists) {
     try {
-      const content = await fs47.readFile(geminiMdPath, "utf-8");
+      const content = await fs48.readFile(geminiMdPath, "utf-8");
       hasGeminiPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER);
     } catch {
     }
@@ -23493,7 +23569,7 @@ async function gatherUninstallItems() {
 }
 async function removePrjctSection(filePath) {
   try {
-    const content = await fs47.readFile(filePath, "utf-8");
+    const content = await fs48.readFile(filePath, "utf-8");
     if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
       return false;
     }
@@ -23502,9 +23578,9 @@ async function removePrjctSection(filePath) {
     let newContent = content.substring(0, startIndex) + content.substring(endIndex);
     newContent = newContent.replace(/\n{3,}/g, "\n\n").trim();
     if (!newContent || newContent.trim().length === 0) {
-      await fs47.unlink(filePath);
+      await fs48.unlink(filePath);
     } else {
-      await fs47.writeFile(filePath, `${newContent}
+      await fs48.writeFile(filePath, `${newContent}
 `, "utf-8");
     }
     return true;
@@ -23512,12 +23588,12 @@ async function removePrjctSection(filePath) {
     return false;
   }
 }
-async function createBackup() {
+async function createBackup2() {
   const homeDir = os16.homedir();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
   const backupDir = path51.join(homeDir, `.prjct-backup-${timestamp}`);
   try {
-    await fs47.mkdir(backupDir, { recursive: true });
+    await fs48.mkdir(backupDir, { recursive: true });
     const prjctCliPath = path_manager_default.getGlobalBasePath();
     if (await fileExists(prjctCliPath)) {
       await copyDirectory(prjctCliPath, path51.join(backupDir, ".prjct-cli"));
@@ -23528,15 +23604,15 @@ async function createBackup() {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs47.mkdir(dest, { recursive: true });
-  const entries = await fs47.readdir(src, { withFileTypes: true });
+  await fs48.mkdir(dest, { recursive: true });
+  const entries = await fs48.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path51.join(src, entry.name);
     const destPath = path51.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else {
-      await fs47.copyFile(srcPath, destPath);
+      await fs48.copyFile(srcPath, destPath);
     }
   }
 }
@@ -23552,10 +23628,10 @@ async function performUninstall(items, installation, options) {
           deleted.push(item.path);
         }
       } else if (item.type === "directory") {
-        await fs47.rm(item.path, { recursive: true, force: true });
+        await fs48.rm(item.path, { recursive: true, force: true });
         deleted.push(item.path);
       } else if (item.type === "file") {
-        await fs47.unlink(item.path);
+        await fs48.unlink(item.path);
         deleted.push(item.path);
       }
     } catch (error) {
@@ -23649,7 +23725,7 @@ async function uninstall(options = {}, _projectPath = process.cwd()) {
   }
   if (options.backup) {
     console.log(chalk12.blue("Creating backup..."));
-    const backupPath = await createBackup();
+    const backupPath = await createBackup2();
     if (backupPath) {
       console.log(chalk12.green(`Backup created: ${path_manager_default.getDisplayPath(backupPath)}`));
       console.log("");
@@ -23710,7 +23786,7 @@ var init_uninstall = __esm({
     __name(detectInstallation, "detectInstallation");
     __name(gatherUninstallItems, "gatherUninstallItems");
     __name(removePrjctSection, "removePrjctSection");
-    __name(createBackup, "createBackup");
+    __name(createBackup2, "createBackup");
     __name(copyDirectory, "copyDirectory");
     __name(performUninstall, "performUninstall");
     __name(promptConfirmation, "promptConfirmation");
@@ -24621,7 +24697,7 @@ __export(setup_exports, {
   run: () => run
 });
 import { execSync as execSync4 } from "node:child_process";
-import fs48 from "node:fs/promises";
+import fs49 from "node:fs/promises";
 import os17 from "node:os";
 import path53 from "node:path";
 import chalk15 from "chalk";
@@ -24765,9 +24841,9 @@ async function installGeminiRouter() {
     const geminiCommandsDir = path53.join(os17.homedir(), ".gemini", "commands");
     const routerSource = path53.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
     const routerDest = path53.join(geminiCommandsDir, "p.toml");
-    await fs48.mkdir(geminiCommandsDir, { recursive: true });
+    await fs49.mkdir(geminiCommandsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs48.copyFile(routerSource, routerDest);
+      await fs49.copyFile(routerSource, routerDest);
       return true;
     }
     return false;
@@ -24781,12 +24857,12 @@ async function installGeminiGlobalConfig() {
     const geminiDir = path53.join(os17.homedir(), ".gemini");
     const globalConfigPath = path53.join(geminiDir, "GEMINI.md");
     const templatePath = path53.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
-    await fs48.mkdir(geminiDir, { recursive: true });
-    const templateContent = await fs48.readFile(templatePath, "utf-8");
+    await fs49.mkdir(geminiDir, { recursive: true });
+    const templateContent = await fs49.readFile(templatePath, "utf-8");
     let existingContent = "";
     let configExists = false;
     try {
-      existingContent = await fs48.readFile(globalConfigPath, "utf-8");
+      existingContent = await fs49.readFile(globalConfigPath, "utf-8");
       configExists = true;
     } catch (error) {
       if (isNotFoundError(error)) {
@@ -24796,7 +24872,7 @@ async function installGeminiGlobalConfig() {
       }
     }
     if (!configExists) {
-      await fs48.writeFile(globalConfigPath, templateContent, "utf-8");
+      await fs49.writeFile(globalConfigPath, templateContent, "utf-8");
       return { success: true, action: "created" };
     }
     const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
@@ -24806,7 +24882,7 @@ async function installGeminiGlobalConfig() {
       const updatedContent2 = `${existingContent}
 
 ${templateContent}`;
-      await fs48.writeFile(globalConfigPath, updatedContent2, "utf-8");
+      await fs49.writeFile(globalConfigPath, updatedContent2, "utf-8");
       return { success: true, action: "appended" };
     }
     const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
@@ -24818,7 +24894,7 @@ ${templateContent}`;
       templateContent.indexOf(endMarker) + endMarker.length
     );
     const updatedContent = beforeMarker + prjctSection + afterMarker;
-    await fs48.writeFile(globalConfigPath, updatedContent, "utf-8");
+    await fs49.writeFile(globalConfigPath, updatedContent, "utf-8");
     return { success: true, action: "updated" };
   } catch (error) {
     logger_default.warn(`Gemini config warning: ${getErrorMessage2(error)}`);
@@ -24831,14 +24907,14 @@ async function installAntigravitySkill() {
     const prjctSkillDir = path53.join(antigravitySkillsDir, "prjct");
     const skillMdPath = path53.join(prjctSkillDir, "SKILL.md");
     const templatePath = path53.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
-    await fs48.mkdir(prjctSkillDir, { recursive: true });
+    await fs49.mkdir(prjctSkillDir, { recursive: true });
     const skillExists = await fileExists(skillMdPath);
     if (!await fileExists(templatePath)) {
       logger_default.warn("Antigravity SKILL.md template not found");
       return { success: false, action: null };
     }
-    const templateContent = await fs48.readFile(templatePath, "utf-8");
-    await fs48.writeFile(skillMdPath, templateContent, "utf-8");
+    const templateContent = await fs49.readFile(templatePath, "utf-8");
+    await fs49.writeFile(skillMdPath, templateContent, "utf-8");
     return { success: true, action: skillExists ? "updated" : "created" };
   } catch (error) {
     logger_default.warn(`Antigravity skill warning: ${getErrorMessage2(error)}`);
@@ -24863,18 +24939,18 @@ async function installCursorProject(projectRoot) {
     const routerMdcDest = path53.join(rulesDir, "prjct.mdc");
     const routerMdcSource = path53.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
     const cursorCommandsSource = path53.join(PACKAGE_ROOT, "templates", "cursor", "commands");
-    await fs48.mkdir(rulesDir, { recursive: true });
-    await fs48.mkdir(commandsDir, { recursive: true });
+    await fs49.mkdir(rulesDir, { recursive: true });
+    await fs49.mkdir(commandsDir, { recursive: true });
     if (await fileExists(routerMdcSource)) {
-      await fs48.copyFile(routerMdcSource, routerMdcDest);
+      await fs49.copyFile(routerMdcSource, routerMdcDest);
       result.rulesCreated = true;
     }
     if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await fs48.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
+      const commandFiles = (await fs49.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
       for (const file of commandFiles) {
         const src = path53.join(cursorCommandsSource, file);
         const dest = path53.join(commandsDir, file);
-        await fs48.copyFile(src, dest);
+        await fs49.copyFile(src, dest);
       }
       result.commandsCreated = commandFiles.length > 0;
     }
@@ -24903,7 +24979,7 @@ async function addCursorToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs48.readFile(gitignorePath, "utf-8");
+      content = await fs49.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -24918,7 +24994,7 @@ async function addCursorToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs48.writeFile(gitignorePath, newContent, "utf-8");
+    await fs49.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -24947,20 +25023,20 @@ async function installWindsurfProject(projectRoot) {
     const routerDest = path53.join(rulesDir, "prjct.md");
     const routerSource = path53.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
     const windsurfWorkflowsSource = path53.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
-    await fs48.mkdir(rulesDir, { recursive: true });
-    await fs48.mkdir(workflowsDir, { recursive: true });
+    await fs49.mkdir(rulesDir, { recursive: true });
+    await fs49.mkdir(workflowsDir, { recursive: true });
     if (await fileExists(routerSource)) {
-      await fs48.copyFile(routerSource, routerDest);
+      await fs49.copyFile(routerSource, routerDest);
       result.rulesCreated = true;
     }
     if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await fs48.readdir(windsurfWorkflowsSource)).filter(
+      const workflowFiles = (await fs49.readdir(windsurfWorkflowsSource)).filter(
         (f) => f.endsWith(".md")
       );
       for (const file of workflowFiles) {
         const src = path53.join(windsurfWorkflowsSource, file);
         const dest = path53.join(workflowsDir, file);
-        await fs48.copyFile(src, dest);
+        await fs49.copyFile(src, dest);
       }
       result.workflowsCreated = workflowFiles.length > 0;
     }
@@ -24989,7 +25065,7 @@ async function addWindsurfToGitignore(projectRoot) {
     let content = "";
     let configExists = false;
     try {
-      content = await fs48.readFile(gitignorePath, "utf-8");
+      content = await fs49.readFile(gitignorePath, "utf-8");
       configExists = true;
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -25004,7 +25080,7 @@ async function addWindsurfToGitignore(projectRoot) {
 ${entriesToAdd.join("\n")}
 ` : `${entriesToAdd.join("\n")}
 `;
-    await fs48.writeFile(gitignorePath, newContent, "utf-8");
+    await fs49.writeFile(gitignorePath, newContent, "utf-8");
     return true;
   } catch (error) {
     logger_default.warn(`Gitignore update warning: ${getErrorMessage2(error)}`);
@@ -25025,7 +25101,7 @@ async function migrateProjectsCliVersion() {
     if (!await fileExists(projectsDir)) {
       return;
     }
-    const projectDirs = (await fs48.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    const projectDirs = (await fs49.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
       const projectJsonPath = path53.join(projectsDir, projectId, "project.json");
@@ -25033,11 +25109,11 @@ async function migrateProjectsCliVersion() {
         continue;
       }
       try {
-        const content = await fs48.readFile(projectJsonPath, "utf8");
+        const content = await fs49.readFile(projectJsonPath, "utf8");
         const project = JSON.parse(content);
         if (project.cliVersion !== VERSION) {
           project.cliVersion = VERSION;
-          await fs48.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
+          await fs49.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
           migrated++;
         }
       } catch (error) {
@@ -25059,7 +25135,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
   let settings = {};
   if (await fileExists(settingsPath)) {
     try {
-      settings = JSON.parse(await fs48.readFile(settingsPath, "utf8"));
+      settings = JSON.parse(await fs49.readFile(settingsPath, "utf8"));
     } catch (error) {
       if (!(error instanceof SyntaxError)) {
         throw error;
@@ -25067,7 +25143,7 @@ async function ensureStatusLineSettings(settingsPath, statusLinePath) {
     }
   }
   settings.statusLine = { type: "command", command: statusLinePath };
-  await fs48.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  await fs49.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 async function installStatusLine() {
   try {
@@ -25087,22 +25163,22 @@ async function installStatusLine() {
     const sourceComponentsDir = path53.join(assetsDir, "components");
     const sourceConfigPath = path53.join(assetsDir, "default-config.json");
     if (!await fileExists(claudeDir)) {
-      await fs48.mkdir(claudeDir, { recursive: true });
+      await fs49.mkdir(claudeDir, { recursive: true });
     }
     if (!await fileExists(prjctStatusLineDir)) {
-      await fs48.mkdir(prjctStatusLineDir, { recursive: true });
+      await fs49.mkdir(prjctStatusLineDir, { recursive: true });
     }
     if (!await fileExists(prjctThemesDir)) {
-      await fs48.mkdir(prjctThemesDir, { recursive: true });
+      await fs49.mkdir(prjctThemesDir, { recursive: true });
     }
     if (!await fileExists(prjctLibDir)) {
-      await fs48.mkdir(prjctLibDir, { recursive: true });
+      await fs49.mkdir(prjctLibDir, { recursive: true });
     }
     if (!await fileExists(prjctComponentsDir)) {
-      await fs48.mkdir(prjctComponentsDir, { recursive: true });
+      await fs49.mkdir(prjctComponentsDir, { recursive: true });
     }
     if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await fs48.readFile(prjctStatusLinePath, "utf8");
+      const existingContent = await fs49.readFile(prjctStatusLinePath, "utf8");
       if (existingContent.includes("CLI_VERSION=")) {
         const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
         if (versionMatch && versionMatch[1] !== VERSION) {
@@ -25110,7 +25186,7 @@ async function installStatusLine() {
             /CLI_VERSION="[^"]*"/,
             `CLI_VERSION="${VERSION}"`
           );
-          await fs48.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
+          await fs49.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
         }
         await installStatusLineModules(sourceLibDir, prjctLibDir);
         await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
@@ -25120,21 +25196,21 @@ async function installStatusLine() {
       }
     }
     if (await fileExists(sourceScript)) {
-      let scriptContent = await fs48.readFile(sourceScript, "utf8");
+      let scriptContent = await fs49.readFile(sourceScript, "utf8");
       scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await fs48.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs49.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
       await installStatusLineModules(sourceLibDir, prjctLibDir);
       await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
       if (await fileExists(sourceThemeDir)) {
-        const themes = await fs48.readdir(sourceThemeDir);
+        const themes = await fs49.readdir(sourceThemeDir);
         for (const theme of themes) {
           const src = path53.join(sourceThemeDir, theme);
           const dest = path53.join(prjctThemesDir, theme);
-          await fs48.copyFile(src, dest);
+          await fs49.copyFile(src, dest);
         }
       }
       if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await fs48.copyFile(sourceConfigPath, prjctConfigPath);
+        await fs49.copyFile(sourceConfigPath, prjctConfigPath);
       }
     } else {
       const scriptContent = `#!/bin/bash
@@ -25169,7 +25245,7 @@ if [ -f "$CONFIG" ]; then
 fi
 echo "prjct"
 `;
-      await fs48.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
+      await fs49.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
     }
     await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
     await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
@@ -25184,7 +25260,7 @@ async function installContext7MCP() {
     const claudeDir = path53.join(os17.homedir(), ".claude");
     const mcpConfigPath = path53.join(claudeDir, "mcp.json");
     if (!await fileExists(claudeDir)) {
-      await fs48.mkdir(claudeDir, { recursive: true });
+      await fs49.mkdir(claudeDir, { recursive: true });
     }
     const context7Config = {
       mcpServers: {
@@ -25195,16 +25271,16 @@ async function installContext7MCP() {
       }
     };
     if (await fileExists(mcpConfigPath)) {
-      const existingContent = await fs48.readFile(mcpConfigPath, "utf-8");
+      const existingContent = await fs49.readFile(mcpConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingContent);
       if (existingConfig.mcpServers?.context7) {
         return;
       }
       existingConfig.mcpServers = existingConfig.mcpServers || {};
       existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      await fs48.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+      await fs49.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
     } else {
-      await fs48.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
+      await fs49.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
     }
   } catch (error) {
     logger_default.warn(`Context7 MCP setup warning: ${getErrorMessage2(error)}`);
@@ -25214,34 +25290,34 @@ async function installStatusLineModules(sourceDir, destDir) {
   if (!await fileExists(sourceDir)) {
     return;
   }
-  const files = await fs48.readdir(sourceDir);
+  const files = await fs49.readdir(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
       const src = path53.join(sourceDir, file);
       const dest = path53.join(destDir, file);
-      await fs48.copyFile(src, dest);
-      await fs48.chmod(dest, 493);
+      await fs49.copyFile(src, dest);
+      await fs49.chmod(dest, 493);
     }
   }
 }
 async function ensureStatusLineSymlink(linkPath, targetPath) {
   try {
     if (await fileExists(linkPath)) {
-      const stats = await fs48.lstat(linkPath);
+      const stats = await fs49.lstat(linkPath);
       if (stats.isSymbolicLink()) {
-        const existingTarget = await fs48.readlink(linkPath);
+        const existingTarget = await fs49.readlink(linkPath);
         if (existingTarget === targetPath) {
           return;
         }
       }
-      await fs48.unlink(linkPath);
+      await fs49.unlink(linkPath);
     }
-    await fs48.symlink(targetPath, linkPath);
+    await fs49.symlink(targetPath, linkPath);
   } catch (_error) {
     try {
       if (await fileExists(targetPath)) {
-        await fs48.copyFile(targetPath, linkPath);
-        await fs48.chmod(linkPath, 493);
+        await fs49.copyFile(targetPath, linkPath);
+        await fs49.chmod(linkPath, 493);
       }
     } catch (copyError) {
       if (!isNotFoundError(copyError)) {
@@ -25935,7 +26011,7 @@ ${"\u2550".repeat(50)}
 });
 
 // core/commands/context.ts
-import fs49 from "node:fs/promises";
+import fs50 from "node:fs/promises";
 import path55 from "node:path";
 var ContextCommands, contextCommands;
 var init_context = __esm({
@@ -26063,7 +26139,7 @@ var init_context = __esm({
       async loadRepoAnalysis(globalPath) {
         try {
           const analysisPath = path55.join(globalPath, "analysis", "repo-analysis.json");
-          const content = await fs49.readFile(analysisPath, "utf-8");
+          const content = await fs50.readFile(analysisPath, "utf-8");
           const data = JSON.parse(content);
           return {
             ecosystem: data.ecosystem || "unknown",
@@ -26560,7 +26636,7 @@ var init_maintenance = __esm({
 });
 
 // core/commands/setup.ts
-import fs50 from "node:fs/promises";
+import fs51 from "node:fs/promises";
 import path59 from "node:path";
 import chalk16 from "chalk";
 var SetupCommands;
@@ -26748,11 +26824,11 @@ fi
 # Default: show prjct branding
 echo "\u26A1 prjct"
 `;
-          await fs50.writeFile(statusLinePath, scriptContent, { mode: 493 });
+          await fs51.writeFile(statusLinePath, scriptContent, { mode: 493 });
           let settings = {};
           if (await fileExists(settingsPath)) {
             try {
-              settings = JSON.parse(await fs50.readFile(settingsPath, "utf8"));
+              settings = JSON.parse(await fs51.readFile(settingsPath, "utf8"));
             } catch (_error) {
             }
           }
@@ -26760,7 +26836,7 @@ echo "\u26A1 prjct"
             type: "command",
             command: statusLinePath
           };
-          await fs50.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+          await fs51.writeFile(settingsPath, JSON.stringify(settings, null, 2));
           return { success: true };
         } catch (error) {
           return { success: false, error: getErrorMessage2(error) };
@@ -28118,7 +28194,7 @@ var init_linear = __esm({
 });
 
 // core/utils/project-credentials.ts
-import fs51 from "node:fs/promises";
+import fs52 from "node:fs/promises";
 import os18 from "node:os";
 import path62 from "node:path";
 function getCredentialsPath(projectId) {
@@ -28130,7 +28206,7 @@ async function getProjectCredentials(projectId) {
     return {};
   }
   try {
-    return JSON.parse(await fs51.readFile(credPath, "utf-8"));
+    return JSON.parse(await fs52.readFile(credPath, "utf-8"));
   } catch (error) {
     console.error("[project-credentials] Failed to read credentials:", getErrorMessage2(error));
     return {};
@@ -28710,7 +28786,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "prjct-cli",
-      version: "1.7.0",
+      version: "1.7.1",
       description: "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
       main: "core/index.ts",
       bin: {
@@ -29185,7 +29261,7 @@ __name(isBun, "isBun");
 init_path_manager();
 init_fs();
 init_logger();
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import path8 from "node:path";
 import { Hono } from "hono";
 import * as jsonc2 from "jsonc-parser";
@@ -29198,7 +29274,7 @@ var STORAGE_PATHS = {
 };
 async function readJsonFile(filePath) {
   try {
-    const content = await fs8.readFile(filePath, "utf-8");
+    const content = await fs9.readFile(filePath, "utf-8");
     const errors = [];
     const result = jsonc2.parse(content, errors);
     return errors.length > 0 ? null : result;
@@ -29212,8 +29288,8 @@ async function readJsonFile(filePath) {
 __name(readJsonFile, "readJsonFile");
 async function writeJsonFile(filePath, data) {
   try {
-    await fs8.mkdir(path8.dirname(filePath), { recursive: true });
-    await fs8.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+    await fs9.mkdir(path8.dirname(filePath), { recursive: true });
+    await fs9.writeFile(filePath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
     return true;
   } catch (error) {
@@ -29303,7 +29379,7 @@ function createRoutes(projectId, _projectPath) {
     }
     try {
       const filePath = path8.join(dataPath, "context", `${name}.md`);
-      const content = await fs8.readFile(filePath, "utf-8");
+      const content = await fs9.readFile(filePath, "utf-8");
       return c.text(content, 200, { "Content-Type": "text/markdown" });
     } catch (error) {
       if (!isNotFoundError(error)) {
@@ -29319,7 +29395,7 @@ __name(createRoutes, "createRoutes");
 // core/server/routes-extended.ts
 init_path_manager();
 init_fs();
-import fs9 from "node:fs/promises";
+import fs10 from "node:fs/promises";
 import path9 from "node:path";
 import { Hono as Hono2 } from "hono";
 import * as jsonc3 from "jsonc-parser";
@@ -29327,7 +29403,7 @@ var GLOBAL_BASE = path_manager_default.getGlobalBasePath();
 var PROJECTS_DIR = path9.join(GLOBAL_BASE, "projects");
 async function readJsonFile2(filePath) {
   try {
-    const content = await fs9.readFile(filePath, "utf-8");
+    const content = await fs10.readFile(filePath, "utf-8");
     const errors = [];
     const result = jsonc3.parse(content, errors);
     return errors.length > 0 ? null : result;
@@ -29341,8 +29417,8 @@ async function readJsonFile2(filePath) {
 __name(readJsonFile2, "readJsonFile");
 async function writeJsonFile2(filePath, data) {
   try {
-    await fs9.mkdir(path9.dirname(filePath), { recursive: true });
-    await fs9.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+    await fs10.mkdir(path9.dirname(filePath), { recursive: true });
+    await fs10.writeFile(filePath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
     return true;
   } catch (error) {
@@ -29379,8 +29455,8 @@ function createExtendedRoutes() {
   const api = new Hono2();
   api.get("/projects", async (c) => {
     try {
-      await fs9.mkdir(PROJECTS_DIR, { recursive: true });
-      const entries = await fs9.readdir(PROJECTS_DIR, { withFileTypes: true });
+      await fs10.mkdir(PROJECTS_DIR, { recursive: true });
+      const entries = await fs10.readdir(PROJECTS_DIR, { withFileTypes: true });
       const projectIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
       const projects = await Promise.all(
         projectIds.map(async (id) => {
@@ -29639,8 +29715,8 @@ function createExtendedRoutes() {
   });
   api.get("/stats/global", async (c) => {
     try {
-      await fs9.mkdir(PROJECTS_DIR, { recursive: true });
-      const entries = await fs9.readdir(PROJECTS_DIR, { withFileTypes: true });
+      await fs10.mkdir(PROJECTS_DIR, { recursive: true });
+      const entries = await fs10.readdir(PROJECTS_DIR, { withFileTypes: true });
       const projectIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
       let totalTasks = 0;
       let totalIdeas = 0;
@@ -29674,8 +29750,8 @@ function createExtendedRoutes() {
   api.get("/status-bar/compact", async (c) => {
     try {
       const cwd = c.req.query("cwd");
-      await fs9.mkdir(PROJECTS_DIR, { recursive: true });
-      const entries = await fs9.readdir(PROJECTS_DIR, { withFileTypes: true });
+      await fs10.mkdir(PROJECTS_DIR, { recursive: true });
+      const entries = await fs10.readdir(PROJECTS_DIR, { withFileTypes: true });
       const projectIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
       let targetProjectId = null;
       if (cwd) {