@wrongstack/core 0.307.0 → 0.307.1

package/dist/index.js

@@ -1529,9 +1529,9 @@ __export(review_finding_store_exports, {
 });
 import { randomUUID as randomUUID40 } from "node:crypto";
 import * as fsp48 from "node:fs/promises";
-import * as path104 from "node:path";
+import * as path105 from "node:path";
 function resolveFindingStorePath(projectDir) {
-  return path104.join(projectDir, FINDING_STORE_FILE);
+  return path105.join(projectDir, FINDING_STORE_FILE);
 }
 var FINDING_RESOLVED_RETENTION_MS, FINDING_IGNORED_RETENTION_MS, FINDING_DEFAULT_PAGE_SIZE, NL2, LINE_SEPARATOR, FINDING_STORE_FILE, JsonlFindingStore;
 var init_review_finding_store = __esm({
@@ -10252,6 +10252,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
       "codebase-skeleton",
       "codebase-repo-map",
       "codebase-impact-analysis",
+      "codebase-invariant-check",
       "dead-code-scan",
       "diff",
       "json",
@@ -23864,13 +23865,50 @@ var HEAVY_BUDGET = {
   maxIterations: 8e3,
   maxToolCalls: 2e4
 };
+var INDEX_READ = [
+  "codebase-stats",
+  "codebase-search",
+  "codebase-skeleton",
+  "codebase-repo-map",
+  "codebase-incoming-calls",
+  "codebase-outgoing-calls"
+];
 var TOOLS = {
+  /** Index-backed code discovery. Spread onto code-facing presets, not browser. */
+  index: INDEX_READ,
   /** Pure read/inspect — safe for analysis and review agents. */
   read: ["read", "grep", "glob", "search", "tree", "mailbox"],
   /** Read + structured inspection (logs, diffs, json, dependency audit). */
-  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
+  inspect: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    ...INDEX_READ,
+    "json",
+    "diff",
+    "logs",
+    "audit",
+    "mailbox"
+  ],
   /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
+  write: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    ...INDEX_READ,
+    "codebase-impact-analysis",
+    "codebase-ast-replace",
+    "codebase-invariant-check",
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "mailbox"
+  ],
   /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
   build: [
     "read",
@@ -23878,6 +23916,11 @@ var TOOLS = {
     "glob",
     "search",
     "tree",
+    ...INDEX_READ,
+    "codebase-impact-analysis",
+    "codebase-ast-replace",
+    "codebase-invariant-check",
+    "codebase-targeted-test",
     "diff",
     "write",
     "edit",
@@ -23904,7 +23947,18 @@ var TOOLS = {
   /** Dependency management + CVE audit. */
   deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
-  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
+  docs: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    ...INDEX_READ,
+    "write",
+    "edit",
+    "document",
+    "mailbox"
+  ],
   /** Web research. */
   research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
@@ -23921,7 +23975,7 @@ var DISCOVERY_AGENTS = [
       id: "explore",
       name: "Explore",
       role: "explore",
-      tools: [...TOOLS.read],
+      tools: [...TOOLS.read, ...TOOLS.index],
       prompt: agentPrompt("explore")
     },
     budget: MEDIUM_BUDGET,
@@ -23949,7 +24003,7 @@ var DISCOVERY_AGENTS = [
       id: "search",
       name: "Search",
       role: "search",
-      tools: [...TOOLS.read, "codebase-search"],
+      tools: [...TOOLS.read, ...TOOLS.index],
       prompt: agentPrompt("search")
     },
     budget: MEDIUM_BUDGET,
@@ -24000,7 +24054,7 @@ var DISCOVERY_AGENTS = [
 ];
 
 // src/coordination/agents/phase2-planning.ts
-var PLAN_TOOLS = [...TOOLS.read, "plan", "todo"];
+var PLAN_TOOLS = [...TOOLS.read, ...TOOLS.index, "plan", "todo"];
 var PLANNING_AGENTS = [
   {
     config: {
@@ -53753,6 +53807,274 @@ function requestLimitExtension(opts) {
   });
 }
 
+// src/prompts/prompt-journal.ts
+import * as fs31 from "node:fs/promises";
+import * as path77 from "node:path";
+var PROMPT_JOURNAL_RAW_MARKER = "promptJournal.raw";
+async function ensureGitignore(projectRoot) {
+  const gitignorePath = path77.join(projectRoot, ".gitignore");
+  try {
+    let content = "";
+    try {
+      content = await fs31.readFile(gitignorePath, "utf8");
+    } catch {
+      content = "";
+    }
+    if (!content.includes(".wrongstack") && !content.includes(".wrongstack/")) {
+      const addition = content.endsWith("\n") || content.length === 0 ? ".wrongstack/\n" : "\n.wrongstack/\n";
+      await fs31.writeFile(gitignorePath, content + addition, "utf8");
+    }
+  } catch {
+  }
+}
+function sessionFileId(sessionId) {
+  const leaf = sessionId.split(/[\\/]/u).pop();
+  return leaf && leaf.trim().length > 0 ? leaf : "general";
+}
+async function recordPromptJournalEntry(opts) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString();
+  const dateStr = timestamp.slice(0, 10);
+  const monthStr = dateStr.slice(0, 7);
+  const sessionId = opts.sessionId && opts.sessionId.trim() ? opts.sessionId.trim() : "general";
+  const id = `pmt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  const content = opts.content ?? "";
+  const lines = content.split("\n");
+  const characterCount = content.length;
+  const lineCount2 = lines.length;
+  const tokenEstimate = Math.ceil(characterCount / 4);
+  const entry = {
+    id,
+    timestamp,
+    sessionId,
+    projectRoot: opts.projectRoot,
+    role: opts.role ?? (opts.category === "system_prompt" ? "system" : "user"),
+    category: opts.category,
+    content,
+    rawContent: opts.rawContent,
+    metadata: {
+      model: opts.model,
+      provider: opts.provider,
+      iterationIndex: opts.iterationIndex,
+      tokenEstimate,
+      characterCount,
+      lineCount: lineCount2,
+      activeTools: opts.activeTools,
+      contextFiles: opts.contextFiles,
+      durationMs: opts.durationMs,
+      decisionReason: opts.decisionReason,
+      tags: opts.tags
+    }
+  };
+  const basePromptsDir = path77.join(opts.projectRoot, ".wrongstack", "prompts");
+  const dayDir = path77.join(basePromptsDir, monthStr, dateStr);
+  try {
+    await fs31.mkdir(dayDir, { recursive: true });
+    await ensureGitignore(opts.projectRoot);
+    const sessionJsonlFile = path77.join(dayDir, `session-${sessionFileId(sessionId)}.jsonl`);
+    await fs31.appendFile(sessionJsonlFile, JSON.stringify(entry) + "\n", "utf8");
+    const sessionMdFile = path77.join(dayDir, `session-${sessionFileId(sessionId)}.md`);
+    const mdSection = formatEntryMarkdown(entry);
+    await fs31.appendFile(sessionMdFile, mdSection, "utf8");
+    const dailySummaryFile = path77.join(dayDir, "daily-summary.md");
+    await updateDailySummary(dailySummaryFile, dateStr, entry);
+    await updateRootCatalog(basePromptsDir, monthStr, dateStr, sessionId, entry);
+  } catch (err) {
+    console.error?.(`Failed to write hierarchical prompt journal: ${err}`);
+  }
+  return entry;
+}
+function formatEntryMarkdown(entry) {
+  const tagList = [
+    `**Category:** \`${entry.category}\``,
+    `**Role:** \`${entry.role}\``,
+    entry.metadata.model ? `**Model:** \`${entry.metadata.model}\`` : null,
+    `**Tokens (est):** ~${entry.metadata.tokenEstimate}`,
+    entry.metadata.iterationIndex !== void 0 ? `**Iteration:** #${entry.metadata.iterationIndex}` : null,
+    `**Session:** \`${entry.sessionId}\``
+  ].filter(Boolean).join(" | ");
+  let md = `
+### \u{1F4DD} [${entry.timestamp}] \`${entry.id}\`
+${tagList}
+
+`;
+  if (entry.metadata.decisionReason) {
+    md += `> **Rationale:** ${entry.metadata.decisionReason}
+
+`;
+  }
+  if (entry.metadata.activeTools && entry.metadata.activeTools.length > 0) {
+    md += `*Active Tools:* \`${entry.metadata.activeTools.join("`, `")}\`
+
+`;
+  }
+  if (entry.rawContent && entry.rawContent !== entry.content) {
+    md += `**Raw Input:**
+\`\`\`text
+${entry.rawContent.trim()}
+\`\`\`
+
+`;
+    md += `**Refined / Injected Prompt:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  } else {
+    md += `**Prompt Content:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  }
+  md += `---
+`;
+  return md;
+}
+async function updateDailySummary(summaryFile, dateStr, entry) {
+  try {
+    let content = "";
+    try {
+      content = await fs31.readFile(summaryFile, "utf8");
+    } catch {
+      content = `# \u{1F4C5} Daily Prompt Summary \u2014 ${dateStr}
+
+| Time | ID | Session | Category | Model | Tokens | Rationale |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    }
+    const time = entry.timestamp.slice(11, 19);
+    const model = entry.metadata.model ?? "-";
+    const reason = entry.metadata.decisionReason ? entry.metadata.decisionReason.slice(0, 40) : "-";
+    const row = `| ${time} | [\`${entry.id}\`](session-${sessionFileId(entry.sessionId)}.md) | \`${entry.sessionId}\` | \`${entry.category}\` | ${model} | ~${entry.metadata.tokenEstimate} | ${reason} |
+`;
+    await fs31.writeFile(summaryFile, content + row, "utf8");
+  } catch {
+  }
+}
+async function updateRootCatalog(baseDir2, monthStr, dateStr, sessionId, entry) {
+  const indexJsonFile = path77.join(baseDir2, "index.json");
+  const indexMdFile = path77.join(baseDir2, "index.md");
+  let catalog;
+  try {
+    const raw = await fs31.readFile(indexJsonFile, "utf8");
+    catalog = JSON.parse(raw);
+  } catch {
+    catalog = {
+      updatedAt: entry.timestamp,
+      totalPrompts: 0,
+      totalTokensEstimated: 0,
+      months: {}
+    };
+  }
+  catalog.updatedAt = entry.timestamp;
+  catalog.totalPrompts += 1;
+  catalog.totalTokensEstimated += entry.metadata.tokenEstimate;
+  if (!catalog.months[monthStr]) {
+    catalog.months[monthStr] = { days: {} };
+  }
+  const monthData = catalog.months[monthStr];
+  if (!monthData.days[dateStr]) {
+    monthData.days[dateStr] = { sessions: {} };
+  }
+  const dayData = monthData.days[dateStr];
+  if (!dayData.sessions[sessionId]) {
+    dayData.sessions[sessionId] = {
+      promptCount: 0,
+      tokenEstimate: 0,
+      lastTimestamp: entry.timestamp,
+      categories: {}
+    };
+  }
+  const sessionData = dayData.sessions[sessionId];
+  sessionData.promptCount += 1;
+  sessionData.tokenEstimate += entry.metadata.tokenEstimate;
+  sessionData.lastTimestamp = entry.timestamp;
+  sessionData.categories[entry.category] = (sessionData.categories[entry.category] ?? 0) + 1;
+  try {
+    await fs31.writeFile(indexJsonFile, JSON.stringify(catalog, null, 2), "utf8");
+    let md = `# \u{1F5C2}\uFE0F Prompt Journal Navigation Index
+
+`;
+    md += `* **Total Prompts Logged:** ${catalog.totalPrompts}
+`;
+    md += `* **Total Tokens (est):** ~${catalog.totalTokensEstimated.toLocaleString()}
+`;
+    md += `* **Last Recorded Activity:** ${catalog.updatedAt}
+
+`;
+    md += `## \u{1F4C5} Recorded Dates & Sessions
+
+`;
+    md += `| Date | Session | Prompts | Tokens (est) | Daily Log | Session Log |
+`;
+    md += `| :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    for (const [m, mObj] of Object.entries(catalog.months).sort().reverse()) {
+      for (const [d, dObj] of Object.entries(mObj.days).sort().reverse()) {
+        for (const [sId, sData] of Object.entries(dObj.sessions)) {
+          const dailyLink = `[daily-summary.md](./${m}/${d}/daily-summary.md)`;
+          const sessionLink = `[session-${sessionFileId(sId)}.md](./${m}/${d}/session-${sessionFileId(sId)}.md)`;
+          md += `| **${d}** | \`${sId}\` | ${sData.promptCount} | ~${sData.tokenEstimate.toLocaleString()} | ${dailyLink} | ${sessionLink} |
+`;
+        }
+      }
+    }
+    await fs31.writeFile(indexMdFile, md, "utf8");
+  } catch {
+  }
+}
+async function getPromptJournalEntries(projectRoot, filter = {}) {
+  const basePromptsDir = path77.join(projectRoot, ".wrongstack", "prompts");
+  const results = [];
+  try {
+    const months = await fs31.readdir(basePromptsDir);
+    for (const month of months) {
+      if (!/^\d{4}-\d{2}$/.test(month)) continue;
+      if (filter.month && filter.month !== month) continue;
+      const monthDir = path77.join(basePromptsDir, month);
+      const days = await fs31.readdir(monthDir);
+      for (const day of days) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+        if (filter.date && filter.date !== day) continue;
+        const dayDir = path77.join(monthDir, day);
+        const files = await fs31.readdir(dayDir);
+        const jsonlFiles = files.filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"));
+        for (const jsonlFile of jsonlFiles) {
+          const sessionMatch = jsonlFile.match(/^session-(.+)\.jsonl$/);
+          const sId = sessionMatch ? sessionMatch[1] : void 0;
+          if (filter.sessionId && sId !== sessionFileId(filter.sessionId)) continue;
+          const filePath = path77.join(dayDir, jsonlFile);
+          const content = await fs31.readFile(filePath, "utf8");
+          const lines = content.split("\n");
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const entry = JSON.parse(line);
+              if (filter.sessionId && sessionFileId(entry.sessionId) !== sessionFileId(filter.sessionId)) {
+                continue;
+              }
+              if (filter.category && entry.category !== filter.category) continue;
+              if (filter.since && entry.timestamp < filter.since) continue;
+              results.push(entry);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  results.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  if (filter.limit && results.length > filter.limit) {
+    return results.slice(-filter.limit);
+  }
+  return results;
+}
+
 // src/core/provider-runner.ts
 init_errors();
 
@@ -54471,6 +54793,36 @@ function buildQueuedMessagesBlock(items) {
 function toError(err) {
   return err instanceof Error ? err : new Error(String(err));
 }
+function recordSelfHealingRetry(a, err, reason) {
+  const projectRoot = a.ctx.projectRoot;
+  if (!projectRoot) return;
+  void recordPromptJournalEntry({
+    projectRoot,
+    sessionId: resolveEventSessionId(a.ctx),
+    category: "self_healing_retry",
+    content: toErrorMessage(err),
+    decisionReason: reason,
+    model: a.ctx.model,
+    provider: a.ctx.provider?.id,
+    activeTools: a.ctx.tools?.map((tool) => tool.name) ?? []
+  }).catch(() => {
+  });
+}
+function recordAutonomousContinue(a, text2) {
+  const projectRoot = a.ctx.projectRoot;
+  if (!projectRoot) return;
+  void recordPromptJournalEntry({
+    projectRoot,
+    sessionId: resolveEventSessionId(a.ctx),
+    category: "autonomous_next_step",
+    content: text2,
+    decisionReason: "text-marker autonomous continue",
+    model: a.ctx.model,
+    provider: a.ctx.provider?.id,
+    activeTools: a.ctx.tools?.map((tool) => tool.name) ?? []
+  }).catch(() => {
+  });
+}
 function signalAbortReason(signal) {
   const r = signal.reason;
   if (r instanceof Error) return r.message || r.name;
@@ -54761,6 +55113,7 @@ ${text2}` : text2;
               }
               if (extDecision.model) a.ctx.model = extDecision.model;
               a.logger.info("Extension requested retry; retrying turn");
+              recordSelfHealingRetry(a, err, "extension-requested provider retry");
               continue;
             }
           }
@@ -54790,6 +55143,7 @@ ${text2}` : text2;
             }
             if (recovered.model) a.ctx.model = recovered.model;
             a.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
+            recordSelfHealingRetry(a, err, recovered.reason);
             continue;
           }
           recoveryRetries = 0;
@@ -54849,6 +55203,7 @@ ${text2}` : text2;
             continue;
           }
           if (autonomousContinue && responseResult.directive === "continue") {
+            recordAutonomousContinue(a, finalText);
             await a.extensions.runAfterIteration(a.ctx, i);
             continue;
           }
@@ -58463,8 +58818,8 @@ var KNOWN_TOKEN_NAMES = Object.values(KNOWN_TOKEN_GROUPS).flat();
 
 // src/execution/design-kit-loader.ts
 import { existsSync as existsSync10 } from "node:fs";
-import * as fs31 from "node:fs/promises";
-import * as path77 from "node:path";
+import * as fs32 from "node:fs/promises";
+import * as path78 from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 var KIT_FILE = "KIT.md";
 var TOKENS_FILE = "tokens.json";
@@ -58564,15 +58919,15 @@ var DefaultDesignKitLoader = class {
     for (const { dir, source } of this.dirs) {
       let entries;
       try {
-        entries = await fs31.readdir(dir, { withFileTypes: true });
+        entries = await fs32.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
         if (!e.isDirectory()) continue;
-        const kitFile = path77.join(dir, e.name, KIT_FILE);
+        const kitFile = path78.join(dir, e.name, KIT_FILE);
         try {
-          const raw = await fs31.readFile(kitFile, "utf8");
+          const raw = await fs32.readFile(kitFile, "utf8");
           const fm = parseKitFrontmatter(raw);
           const id = fm.id ?? e.name;
           if (!fm.name) continue;
@@ -58633,7 +58988,7 @@ var DefaultDesignKitLoader = class {
     if (cached2 !== void 0) return cached2;
     const m = await this.find(id);
     if (!m) throw new Error(`Design kit "${id}" not found`);
-    const raw = await fs31.readFile(m.path, "utf8");
+    const raw = await fs32.readFile(m.path, "utf8");
     const body = narrowStackSections(stripFrontmatter(raw), stack);
     this.bodyCache.set(key, body);
     return body;
@@ -58645,9 +59000,9 @@ var DefaultDesignKitLoader = class {
     const m = await this.find(id);
     let tokens;
     if (m) {
-      const tokensPath = path77.join(path77.dirname(m.path), TOKENS_FILE);
+      const tokensPath = path78.join(path78.dirname(m.path), TOKENS_FILE);
       try {
-        const raw = await fs31.readFile(tokensPath, "utf8");
+        const raw = await fs32.readFile(tokensPath, "utf8");
         tokens = JSON.parse(raw);
       } catch {
         tokens = void 0;
@@ -58707,12 +59062,12 @@ function mergeKitTokens(base, own) {
 }
 function resolveBundledDesignKitsDir() {
   try {
-    const here = path77.dirname(fileURLToPath8(import.meta.url));
+    const here = path78.dirname(fileURLToPath8(import.meta.url));
     const candidates = [
-      path77.join(here, "design-kits"),
-      path77.join(here, "..", "design-kits"),
-      path77.join(here, "..", "..", "design-kits"),
-      path77.join(here, "..", "..", "..", "design-kits")
+      path78.join(here, "design-kits"),
+      path78.join(here, "..", "design-kits"),
+      path78.join(here, "..", "..", "design-kits"),
+      path78.join(here, "..", "..", "..", "design-kits")
     ];
     for (const c of candidates) {
       if (existsSync10(c)) return c;
@@ -58750,11 +59105,11 @@ function _resetDesignKitLoaderMemo() {
 
 // src/execution/design-project-store.ts
 import { existsSync as existsSync11 } from "node:fs";
-import * as fs32 from "node:fs/promises";
-import * as path78 from "node:path";
+import * as fs33 from "node:fs/promises";
+import * as path79 from "node:path";
 var DESIGN_DIR = ".design";
 function designProjectDir(projectRoot) {
-  return path78.join(projectRoot, DESIGN_DIR);
+  return path79.join(projectRoot, DESIGN_DIR);
 }
 var RULE_FILES = ["rules.md", "RULES.md", "design.md"];
 var rulesCache = /* @__PURE__ */ new Map();
@@ -58769,7 +59124,7 @@ async function loadProjectDesignRules(projectRoot) {
   let rules;
   for (const name of RULE_FILES) {
     try {
-      const txt = await fs32.readFile(path78.join(designProjectDir(projectRoot), name), "utf8");
+      const txt = await fs33.readFile(path79.join(designProjectDir(projectRoot), name), "utf8");
       if (txt.trim()) {
         rules = txt.trim();
         break;
@@ -58795,7 +59150,7 @@ function parseOverrides(value) {
 }
 async function loadActiveKit(projectRoot) {
   try {
-    const raw = await fs32.readFile(path78.join(designProjectDir(projectRoot), "active.json"), "utf8");
+    const raw = await fs33.readFile(path79.join(designProjectDir(projectRoot), "active.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.kit === "string") {
       return {
@@ -58828,11 +59183,11 @@ function applyTokenOverrides(tokens, overrides) {
 }
 async function ensureDesignDir(projectRoot) {
   const dir = designProjectDir(projectRoot);
-  await fs32.mkdir(dir, { recursive: true });
-  const gi = path78.join(dir, ".gitignore");
+  await fs33.mkdir(dir, { recursive: true });
+  const gi = path79.join(dir, ".gitignore");
   if (!existsSync11(gi)) {
     try {
-      await fs32.writeFile(gi, "*\n");
+      await fs33.writeFile(gi, "*\n");
     } catch {
     }
   }
@@ -58843,11 +59198,11 @@ async function recordKitChoice(projectRoot, kit, stack, source, isoTime, overrid
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit, stack: stack ?? null };
     if (overrides && Object.keys(overrides).length > 0) record.overrides = overrides;
-    await fs32.writeFile(path78.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs33.writeFile(path79.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const line = `- ${isoTime} \xB7 kit=${kit}${stack ? ` stack=${stack}` : ""} \xB7 via=${source}
 `;
-    await fs32.appendFile(path78.join(dir, "decisions.md"), line);
+    await fs33.appendFile(path79.join(dir, "decisions.md"), line);
   } catch {
   }
 }
@@ -58863,11 +59218,11 @@ async function recordOverrides(projectRoot, patch, isoTime) {
     const dir = await ensureDesignDir(projectRoot);
     const record = { kit: active.kit, stack: active.stack ?? null };
     if (Object.keys(merged).length > 0) record.overrides = merged;
-    await fs32.writeFile(path78.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
+    await fs33.writeFile(path79.join(dir, "active.json"), `${JSON.stringify(record, null, 2)}
 `);
     const keys = Object.keys(patch).join(",");
-    await fs32.appendFile(
-      path78.join(dir, "decisions.md"),
+    await fs33.appendFile(
+      path79.join(dir, "decisions.md"),
       `- ${isoTime} \xB7 kit=${active.kit} \xB7 override=${keys} \xB7 via=set
 `
     );
@@ -58877,7 +59232,7 @@ async function recordOverrides(projectRoot, patch, isoTime) {
 }
 async function clearPersistedActiveKit(projectRoot) {
   try {
-    await fs32.rm(path78.join(designProjectDir(projectRoot), "active.json"), { force: true });
+    await fs33.rm(path79.join(designProjectDir(projectRoot), "active.json"), { force: true });
   } catch {
   }
 }
@@ -62712,8 +63067,8 @@ Summarize the following message range:`;
 };
 
 // src/execution/skill-loader.ts
-import * as fs33 from "node:fs/promises";
-import * as path79 from "node:path";
+import * as fs34 from "node:fs/promises";
+import * as path80 from "node:path";
 
 // src/skills/foreign-sources.ts
 var FOREIGN_SKILL_TOOLS = [
@@ -62783,7 +63138,7 @@ async function entryIsDirectory(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs33.stat(path79.join(dir, entry.name))).isDirectory();
+      return (await fs34.stat(path80.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -62807,7 +63162,7 @@ var DefaultSkillLoader = class {
       for (const tool of FOREIGN_SKILL_TOOLS) {
         if (!foreignIds.includes(tool.id)) continue;
         dirs.push({
-          dir: path79.join(root, "." + tool.id, tool.subdir),
+          dir: path80.join(root, "." + tool.id, tool.subdir),
           source: "foreign",
           originTool: tool.id
         });
@@ -62832,15 +63187,15 @@ var DefaultSkillLoader = class {
     this.shadowed = [];
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = (await fs33.readdir(dir, { withFileTypes: true })).sort(
+        const entries = (await fs34.readdir(dir, { withFileTypes: true })).sort(
           (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
         );
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
-          const skillFile = path79.join(dir, e.name, "SKILL.md");
+          const skillFile = path80.join(dir, e.name, "SKILL.md");
           let raw;
           try {
-            raw = await fs33.readFile(skillFile, "utf8");
+            raw = await fs34.readFile(skillFile, "utf8");
           } catch {
             continue;
           }
@@ -62959,7 +63314,7 @@ var DefaultSkillLoader = class {
     if (cached2 !== void 0) return cached2;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const body = await fs33.readFile(m.path, "utf8");
+    const body = await fs34.readFile(m.path, "utf8");
     this.bodyCache.set(key, body);
     return body;
   }
@@ -62969,12 +63324,12 @@ var DefaultSkillLoader = class {
     if (cached2 !== void 0) return cached2;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const savePath = path79.join(path79.dirname(m.path), "SKILL.save.md");
+    const savePath = path80.join(path80.dirname(m.path), "SKILL.save.md");
     let result;
     try {
-      result = await fs33.readFile(savePath, "utf8");
+      result = await fs34.readFile(savePath, "utf8");
     } catch {
-      const full = await fs33.readFile(m.path, "utf8");
+      const full = await fs34.readFile(m.path, "utf8");
       const body = stripFrontmatter(full);
       const compact = compactSkillBody(body);
       if (compact) {
@@ -63002,14 +63357,14 @@ function parseDescriptionFromText(desc) {
 }
 
 // src/execution/prompt-loader.ts
-import * as fs35 from "node:fs/promises";
-import * as path81 from "node:path";
+import * as fs36 from "node:fs/promises";
+import * as path82 from "node:path";
 
 // src/storage/prompt-store.ts
 init_atomic_write();
 import { createHash as createHash28 } from "node:crypto";
-import * as fs34 from "node:fs/promises";
-import * as path80 from "node:path";
+import * as fs35 from "node:fs/promises";
+import * as path81 from "node:path";
 var SCHEMA_VERSION3 = 2;
 function promptChecksum(content) {
   return createHash28("sha256").update(content, "utf8").digest("hex");
@@ -63073,12 +63428,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fs34.readdir(this.dir);
+      const files = await fs35.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fs34.readFile(path80.join(this.dir, file), "utf8")
+            await fs35.readFile(path81.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -63092,9 +63447,9 @@ var DefaultPromptStore = class {
     );
   }
   async get(id) {
-    const file = path80.join(this.dir, `${id}.json`);
+    const file = path81.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fs34.readFile(file, "utf8"));
+      const raw = JSON.parse(await fs35.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -63102,14 +63457,14 @@ var DefaultPromptStore = class {
   }
   async save(entry) {
     await ensureDir(this.dir);
-    const file = path80.join(this.dir, `${entry.id}.json`);
+    const file = path81.join(this.dir, `${entry.id}.json`);
     const raw = { version: SCHEMA_VERSION3, entry };
     await atomicWrite(file, JSON.stringify(raw, null, 2));
   }
   async delete(id) {
-    const file = path80.join(this.dir, `${id}.json`);
+    const file = path81.join(this.dir, `${id}.json`);
     try {
-      await fs34.unlink(file);
+      await fs35.unlink(file);
       return true;
     } catch {
       return false;
@@ -63196,7 +63551,7 @@ var DefaultPromptLoader = class {
   constructor(opts) {
     this.projectStore = typeof opts.paths.inProjectPrompts === "string" ? new DefaultPromptStore(opts.paths.inProjectPrompts) : void 0;
     this.userStore = typeof opts.paths.globalPrompts === "string" ? new DefaultPromptStore(opts.paths.globalPrompts) : void 0;
-    this.builtinDir = opts.bundledDir ? path81.join(opts.bundledDir, "prompts") : void 0;
+    this.builtinDir = opts.bundledDir ? path82.join(opts.bundledDir, "prompts") : void 0;
   }
   async list() {
     if (this.cache) return this.cache;
@@ -63309,7 +63664,7 @@ var DefaultPromptLoader = class {
     const files = await walkJson(dir);
     for (const file of files) {
       try {
-        const parsed = JSON.parse(await fs35.readFile(file, "utf8"));
+        const parsed = JSON.parse(await fs36.readFile(file, "utf8"));
         const migrated = migratePromptEntry(parsed);
         if (migrated) out.push({ ...migrated, source: "builtin" });
       } catch {
@@ -63323,12 +63678,12 @@ async function walkJson(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs35.readdir(dir, { withFileTypes: true });
+    entries = await fs36.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const e of entries) {
-    const full = path81.join(dir, e.name);
+    const full = path82.join(dir, e.name);
     if (e.isDirectory()) {
       out.push(...await walkJson(full));
     } else if (e.name.endsWith(".json") && e.name !== "index.json" && e.name !== "schema.json") {
@@ -63516,8 +63871,8 @@ function readPolicy(ctx) {
 
 // src/execution/tool-executor.ts
 import { randomUUID as randomUUID37 } from "node:crypto";
-import * as fs37 from "node:fs/promises";
-import * as path84 from "node:path";
+import * as fs38 from "node:fs/promises";
+import * as path85 from "node:path";
 init_errors();
 
 // src/types/tool-executor.ts
@@ -63538,8 +63893,8 @@ var ToolErrorCategory = /* @__PURE__ */ ((ToolErrorCategory2) => {
 
 // src/execution/tool-executor-support.ts
 import { createHash as createHash29, randomUUID as randomUUID35 } from "node:crypto";
-import * as fs36 from "node:fs/promises";
-import * as path82 from "node:path";
+import * as fs37 from "node:fs/promises";
+import * as path83 from "node:path";
 init_errors();
 
 // src/types/tool-markers.ts
@@ -63665,12 +64020,12 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path82.join(wstackGlobalRoot(), "tool-output");
-    await fs36.mkdir(dir, { recursive: true });
+    const dir = path83.join(wstackGlobalRoot(), "tool-output");
+    await fs37.mkdir(dir, { recursive: true });
     const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const filePath = path82.join(dir, `${stamp}-${safeTool}-${randomUUID35()}.log`);
-    await fs36.writeFile(filePath, content, "utf8");
+    const filePath = path83.join(dir, `${stamp}-${safeTool}-${randomUUID35()}.log`);
+    await fs37.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
     const previewBytes = Math.min(
@@ -63874,7 +64229,7 @@ import { isDeepStrictEqual } from "node:util";
 
 // src/security/kanban-boundary.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import * as path83 from "node:path";
+import * as path84 from "node:path";
 import {
   evaluateContractGraphReadiness,
   evaluateKanbanBoundaryOpaque,
@@ -64029,10 +64384,10 @@ function resolveKanbanIdentity(ctx) {
 async function extractCandidatePaths(toolName, input, ctx) {
   if (toolName === "patch" && typeof input["patch"] === "string") {
     const directoryInput = stringValue(input["directory"]) ?? ctx.workingDir;
-    const directory = path83.isAbsolute(directoryInput) ? directoryInput : path83.resolve(ctx.workingDir, directoryInput);
+    const directory = path84.isAbsolute(directoryInput) ? directoryInput : path84.resolve(ctx.workingDir, directoryInput);
     const strip = Math.max(1, numericValue(input["strip"]) ?? 1);
     const targets = extractPatchTargets(input["patch"], strip).map(
-      (target) => relativeToProject(path83.resolve(directory, target), ctx.projectRoot)
+      (target) => relativeToProject(path84.resolve(directory, target), ctx.projectRoot)
     );
     return Promise.all(targets.map((target) => canonicalizeCandidatePath(target, ctx)));
   }
@@ -64042,7 +64397,7 @@ async function extractCandidatePaths(toolName, input, ctx) {
   collectPathValues(input, values, pathKeys);
   if (toolName === "scaffold" && typeof input["name"] === "string") {
     const cwd = stringValue(input["cwd"]) ?? ctx.workingDir;
-    values.push(path83.join(cwd, input["name"]));
+    values.push(path84.join(cwd, input["name"]));
   }
   const candidates = [
     ...new Set(values.flatMap(splitPathList).map((value) => resolveInputPath(value, ctx)))
@@ -64050,21 +64405,21 @@ async function extractCandidatePaths(toolName, input, ctx) {
   return Promise.all(candidates.map((candidate) => canonicalizeCandidatePath(candidate, ctx)));
 }
 async function canonicalizeCandidatePath(candidate, ctx) {
-  if (path83.isAbsolute(candidate)) return candidate;
-  const absolute = path83.resolve(ctx.projectRoot, candidate);
+  if (path84.isAbsolute(candidate)) return candidate;
+  const absolute = path84.resolve(ctx.projectRoot, candidate);
   const canonicalRoot = await realpath3(ctx.projectRoot).catch(() => ctx.projectRoot);
   let probe2 = absolute;
   const missingSegments = [];
   while (true) {
     try {
-      const canonical = path83.join(await realpath3(probe2), ...missingSegments);
+      const canonical = path84.join(await realpath3(probe2), ...missingSegments);
       return relativeToProject(canonical, canonicalRoot);
     } catch (cause) {
       const code = cause.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return absolute;
-      const parent = path83.dirname(probe2);
+      const parent = path84.dirname(probe2);
       if (parent === probe2) return absolute;
-      missingSegments.unshift(path83.basename(probe2));
+      missingSegments.unshift(path84.basename(probe2));
       probe2 = parent;
     }
   }
@@ -64087,12 +64442,12 @@ function splitPathList(value) {
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
 function resolveInputPath(value, ctx) {
-  const absolute = path83.isAbsolute(value) ? value : path83.resolve(ctx.workingDir, value);
+  const absolute = path84.isAbsolute(value) ? value : path84.resolve(ctx.workingDir, value);
   return relativeToProject(absolute, ctx.projectRoot);
 }
 function relativeToProject(absolute, projectRoot) {
-  const relative21 = path83.relative(projectRoot, absolute).replace(/\\/g, "/");
-  return relative21.startsWith("../") || path83.isAbsolute(relative21) ? absolute : relative21 || ".";
+  const relative21 = path84.relative(projectRoot, absolute).replace(/\\/g, "/");
+  return relative21.startsWith("../") || path84.isAbsolute(relative21) ? absolute : relative21 || ".";
 }
 function extractPatchTargets(patchText, strip) {
   const targets = [];
@@ -64677,10 +65032,10 @@ var ToolExecutor = class _ToolExecutor {
         const inputPath = use.input && typeof use.input === "object" ? use.input.path : void 0;
         const caps = tool.capabilities ?? [];
         const hasFileCapability = caps.includes("fs.read") || caps.includes("fs.write");
-        const absPath = hasFileCapability && typeof inputPath === "string" ? path84.isAbsolute(inputPath) ? inputPath : path84.resolve(ctx.projectRoot, inputPath) : void 0;
+        const absPath = hasFileCapability && typeof inputPath === "string" ? path85.isAbsolute(inputPath) ? inputPath : path85.resolve(ctx.projectRoot, inputPath) : void 0;
         let writeTargetExisted;
         if (tool.name === "write" && caps.includes("fs.write") && absPath) {
-          writeTargetExisted = await fs37.stat(absPath).then(
+          writeTargetExisted = await fs38.stat(absPath).then(
             (stat40) => stat40.isFile(),
             (error2) => error2.code === "ENOENT" ? false : void 0
           );
@@ -65437,28 +65792,28 @@ function codexModelMeta(id) {
 
 // src/models/mode-store.ts
 init_atomic_write();
-import * as fs38 from "node:fs/promises";
-import * as path86 from "node:path";
+import * as fs39 from "node:fs/promises";
+import * as path87 from "node:path";
 
 // src/types/mode-prompts.ts
 import { readFileSync as readFileSync23, statSync as statSync9 } from "node:fs";
-import * as path85 from "node:path";
+import * as path86 from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
 function modePrompt(id) {
   for (const dir of modePromptDirCandidates()) {
     try {
-      return readFileSync23(path85.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync23(path86.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
   return "";
 }
 function modePromptDirCandidates() {
-  const here = path85.dirname(fileURLToPath9(import.meta.url));
+  const here = path86.dirname(fileURLToPath9(import.meta.url));
   const candidates = [
-    path85.resolve(here, "../../instructions/modes"),
-    path85.resolve(here, "../instructions/modes"),
-    path85.resolve(here, "instructions/modes")
+    path86.resolve(here, "../../instructions/modes"),
+    path86.resolve(here, "../instructions/modes"),
+    path86.resolve(here, "instructions/modes")
   ];
   return candidates.sort((a, b) => Number(!isDirectory4(a)) - Number(!isDirectory4(b)));
 }
@@ -65690,8 +66045,8 @@ var DefaultModeStore = class {
   }
   async loadActiveMode() {
     try {
-      const configPath = path86.join(this.configDir, "mode.json");
-      const content = await fs38.readFile(configPath, "utf8");
+      const configPath = path87.join(this.configDir, "mode.json");
+      const content = await fs39.readFile(configPath, "utf8");
       const data = JSON.parse(content);
       this.activeModeId = data.activeMode ?? null;
     } catch {
@@ -65700,8 +66055,8 @@ var DefaultModeStore = class {
   }
   async saveActiveMode() {
     try {
-      await fs38.mkdir(this.configDir, { recursive: true });
-      const configPath = path86.join(this.configDir, "mode.json");
+      await fs39.mkdir(this.configDir, { recursive: true });
+      const configPath = path87.join(this.configDir, "mode.json");
       await atomicWrite(
         configPath,
         JSON.stringify({ activeMode: this.activeModeId }, null, 2)
@@ -65713,14 +66068,14 @@ var DefaultModeStore = class {
 async function loadProjectModes(modesDir) {
   const modes = [];
   try {
-    const entries = await fs38.readdir(modesDir);
+    const entries = await fs39.readdir(modesDir);
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
-      const filePath = path86.join(modesDir, entry);
-      const stat40 = await fs38.stat(filePath);
+      const filePath = path87.join(modesDir, entry);
+      const stat40 = await fs39.stat(filePath);
       if (!stat40.isFile()) continue;
-      const content = await fs38.readFile(filePath, "utf8");
-      const id = path86.basename(entry, path86.extname(entry));
+      const content = await fs39.readFile(filePath, "utf8");
+      const id = path87.basename(entry, path87.extname(entry));
       modes.push({
         id,
         name: id.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
@@ -65736,8 +66091,8 @@ async function loadProjectModes(modesDir) {
 async function loadUserModes(modesDir) {
   const modes = [];
   try {
-    const manifestPath = path86.join(modesDir, "modes.json");
-    const content = await fs38.readFile(manifestPath, "utf8");
+    const manifestPath = path87.join(modesDir, "modes.json");
+    const content = await fs39.readFile(manifestPath, "utf8");
     const manifest = JSON.parse(content);
     for (const mode of manifest.modes) {
       modes.push(mode);
@@ -65748,8 +66103,8 @@ async function loadUserModes(modesDir) {
 }
 
 // src/models/models-registry.ts
-import * as fs39 from "node:fs/promises";
-import * as path87 from "node:path";
+import * as fs40 from "node:fs/promises";
+import * as path88 from "node:path";
 init_atomic_write();
 init_error();
 init_errors();
@@ -65829,7 +66184,7 @@ var DefaultModelsRegistry = class {
     this.overlay = opts.overlay;
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
-    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path87.join(path87.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path88.join(path88.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
     this.logger = opts.logger ?? noOpLogger;
   }
   async load(opts = {}) {
@@ -66017,7 +66372,7 @@ var DefaultModelsRegistry = class {
   async readOverlayFile() {
     if (!this.overlayFile) return void 0;
     try {
-      const raw = await fs39.readFile(this.overlayFile, "utf8");
+      const raw = await fs40.readFile(this.overlayFile, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -66096,7 +66451,7 @@ var DefaultModelsRegistry = class {
   }
   async readCacheAt(file) {
     try {
-      const raw = await fs39.readFile(file, "utf8");
+      const raw = await fs40.readFile(file, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -66104,7 +66459,7 @@ var DefaultModelsRegistry = class {
   }
   /** Used by `wstack models refresh` to expose where the cache lives. */
   cacheLocation() {
-    return path87.resolve(this.cacheFile);
+    return path88.resolve(this.cacheFile);
   }
 };
 var REASONING_EFFORTS = /* @__PURE__ */ new Set([
@@ -67017,16 +67372,16 @@ function startOtlpTraceExporter(opts) {
 
 // src/security/permission-policy.ts
 init_atomic_write();
-import * as fs40 from "node:fs/promises";
-import * as path90 from "node:path";
+import * as fs41 from "node:fs/promises";
+import * as path91 from "node:path";
 
 // src/security/permission-helpers.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import * as path89 from "node:path";
+import * as path90 from "node:path";
 
 // src/security/yolo-risk.ts
 import * as os11 from "node:os";
-import * as path88 from "node:path";
+import * as path89 from "node:path";
 var PROTECTED_STATE_BASENAMES = /^(?:config\.json|config\.local\.json|trust\.json|auth\.json|\.key)$/i;
 var CATASTROPHIC_PATTERNS = [
   /\b(?:mkfs(?:\.[a-z0-9]+)?|mke2fs|newfs)\b/i,
@@ -67087,9 +67442,9 @@ function getInputString(input, key) {
 function pathLooksInsideProject(rawPath, projectRoot) {
   if (!projectRoot) return false;
   if (rawPath === "~" || rawPath.startsWith("~/") || rawPath.startsWith("~\\")) return false;
-  const resolved = path88.resolve(projectRoot, rawPath);
-  const relative21 = path88.relative(projectRoot, resolved);
-  return !!relative21 && !relative21.startsWith("..") && !path88.isAbsolute(relative21);
+  const resolved = path89.resolve(projectRoot, rawPath);
+  const relative21 = path89.relative(projectRoot, resolved);
+  return !!relative21 && !relative21.startsWith("..") && !path89.isAbsolute(relative21);
 }
 function tokenizeShell(command) {
   return command.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
@@ -67296,14 +67651,14 @@ function hasWriteToAgentStateRoot(command) {
 }
 function looksLikeAgentStateTarget(rawPath) {
   const expanded = rawPath.replace(/^~([\\/])/, (_, sep10) => `${os11.homedir()}${sep10}`);
-  const resolved = path88.resolve(expanded);
+  const resolved = path89.resolve(expanded);
   const rootStr = wstackGlobalRoot();
   const resolvedNorm = resolved.replace(/\\/g, "/").toLowerCase();
-  const rootNorm = path88.resolve(rootStr).replace(/\\/g, "/").toLowerCase();
+  const rootNorm = path89.resolve(rootStr).replace(/\\/g, "/").toLowerCase();
   if (!resolvedNorm.startsWith(rootNorm) && !resolvedNorm.includes(".wrongstack")) {
     return false;
   }
-  return PROTECTED_STATE_BASENAMES.test(path88.basename(resolved));
+  return PROTECTED_STATE_BASENAMES.test(path89.basename(resolved));
 }
 function isClearlyDestructiveBashCommand(command, projectRoot) {
   const trimmed = command.trim();
@@ -67403,24 +67758,24 @@ function realpathOfNearestExisting(p) {
   const tail = [];
   for (; ; ) {
     try {
-      return tail.length === 0 ? realpathSync3(probe2) : path89.join(realpathSync3(probe2), ...tail);
+      return tail.length === 0 ? realpathSync3(probe2) : path90.join(realpathSync3(probe2), ...tail);
     } catch {
-      const parent = path89.dirname(probe2);
+      const parent = path90.dirname(probe2);
       if (parent === probe2) return p;
-      tail.unshift(path89.basename(probe2));
+      tail.unshift(path90.basename(probe2));
       probe2 = parent;
     }
   }
 }
 var agentStateRootRealCache = /* @__PURE__ */ new Map();
 function isInsideAgentStateRoot(absPath) {
-  const lexicalRoot = normalizeForCompare(path89.resolve(wstackGlobalRoot()));
+  const lexicalRoot = normalizeForCompare(path90.resolve(wstackGlobalRoot()));
   if (!lexicalRoot) return false;
   const target = normalizeForCompare(absPath);
   if (target === lexicalRoot || target.startsWith(`${lexicalRoot}/`)) return true;
   let realRoot = agentStateRootRealCache.get(lexicalRoot);
   if (realRoot === void 0) {
-    realRoot = normalizeForCompare(realpathOfNearestExisting(path89.resolve(wstackGlobalRoot())));
+    realRoot = normalizeForCompare(realpathOfNearestExisting(path90.resolve(wstackGlobalRoot())));
     agentStateRootRealCache.set(lexicalRoot, realRoot);
   }
   if (!realRoot || realRoot === lexicalRoot) return false;
@@ -67429,7 +67784,7 @@ function isInsideAgentStateRoot(absPath) {
 }
 function isProtectedAgentStatePath(absPath) {
   if (!isInsideAgentStateRoot(absPath)) return false;
-  return AGENT_STATE_SENSITIVE_BASENAMES.test(path89.basename(normalizeForCompare(absPath)));
+  return AGENT_STATE_SENSITIVE_BASENAMES.test(path90.basename(normalizeForCompare(absPath)));
 }
 function pathLooksSensitive(rawPath) {
   const normalized = stripShellQuotes(rawPath).replace(/\\/g, "/");
@@ -68066,7 +68421,7 @@ var DefaultPermissionPolicy = class {
     if (!hasCapability(tool, ToolCapabilities.FS_WRITE)) return false;
     for (const targetPath of fsWriteTargetPaths(input)) {
       const base = ctx.workingDir ?? ctx.cwd;
-      const resolved = base ? path90.resolve(base, targetPath) : path90.resolve(targetPath);
+      const resolved = base ? path91.resolve(base, targetPath) : path91.resolve(targetPath);
       if (isInsideAgentStateRoot(resolved)) return true;
     }
     return false;
@@ -68097,7 +68452,7 @@ var DefaultPermissionPolicy = class {
     this.policyDiagnostics = [];
     this.policyInvalid = false;
     try {
-      const raw = await fs40.readFile(this.trustFile, "utf8");
+      const raw = await fs41.readFile(this.trustFile, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok) {
         this.policy = {};
@@ -68417,7 +68772,7 @@ var DefaultPermissionPolicy = class {
 init_atomic_write();
 import { randomBytes as randomBytes6 } from "node:crypto";
 import * as fsp37 from "node:fs/promises";
-import * as path91 from "node:path";
+import * as path92 from "node:path";
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE2 = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
@@ -68438,7 +68793,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp37.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path91.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path92.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -69027,7 +69382,7 @@ ${cat}:`);
 init_atomic_write();
 init_error();
 import * as fsp39 from "node:fs/promises";
-import * as path92 from "node:path";
+import * as path93 from "node:path";
 var QUEUE_MAX_ITEMS = 100;
 var QUEUE_MAX_BYTES = 16 * 1024 * 1024;
 var QUEUE_MAX_ITEM_BYTES = 8 * 1024 * 1024;
@@ -69060,7 +69415,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path92.join(opts.dir, "queue.json");
+    this.file = path93.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -69277,7 +69632,7 @@ function isPersistedQueueItem(v) {
 init_atomic_write();
 import * as fsp40 from "node:fs/promises";
 import * as os12 from "node:os";
-import * as path93 from "node:path";
+import * as path94 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -69288,7 +69643,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path93.join(opts.dir, LOCK_FILE);
+    this.file = path94.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os12.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -69362,7 +69717,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path93.dirname(this.file));
+    await ensureDir(path94.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -75718,7 +76073,7 @@ var PHASE_EVENT_NAMES = [
 // src/goal/phase-store.ts
 init_atomic_write();
 import * as fsp42 from "node:fs/promises";
-import * as path94 from "node:path";
+import * as path95 from "node:path";
 var PHASE_STORE_VERSION = 1;
 var PhaseStore = class {
   baseDir;
@@ -75726,7 +76081,7 @@ var PhaseStore = class {
   constructor(opts) {
     this.baseDir = opts.baseDir;
     this.legacyBaseDirs = (opts.legacyBaseDirs ?? []).filter(
-      (dir) => path94.resolve(dir) !== path94.resolve(this.baseDir)
+      (dir) => path95.resolve(dir) !== path95.resolve(this.baseDir)
     );
   }
   async save(graph) {
@@ -75741,7 +76096,7 @@ var PhaseStore = class {
     const current = await this.loadFromPath(filePath);
     if (current) return current;
     for (const legacyDir of this.legacyBaseDirs) {
-      const legacyPath = path94.join(legacyDir, `${graphId}.json`);
+      const legacyPath = path95.join(legacyDir, `${graphId}.json`);
       const legacy = await this.loadFromPath(legacyPath);
       if (!legacy) continue;
       try {
@@ -75757,7 +76112,7 @@ var PhaseStore = class {
   async delete(graphId) {
     const paths = [
       this.getFilePath(graphId),
-      ...this.legacyBaseDirs.map((dir) => path94.join(dir, `${graphId}.json`))
+      ...this.legacyBaseDirs.map((dir) => path95.join(dir, `${graphId}.json`))
     ];
     await Promise.all(paths.map((filePath) => fsp42.unlink(filePath).catch(() => void 0)));
   }
@@ -75769,7 +76124,7 @@ var PhaseStore = class {
       for (const entry of entries) {
         if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
         try {
-          const raw = await fsp42.readFile(path94.join(this.baseDir, entry.name), "utf8");
+          const raw = await fsp42.readFile(path95.join(this.baseDir, entry.name), "utf8");
           const serialized = JSON.parse(raw);
           const done = serialized.completedPhaseIds.length;
           const total = serialized.phases.length;
@@ -75788,7 +76143,7 @@ var PhaseStore = class {
     }
   }
   getFilePath(graphId) {
-    return path94.join(this.baseDir, `${graphId}.json`);
+    return path95.join(this.baseDir, `${graphId}.json`);
   }
   async loadFromPath(filePath) {
     try {
@@ -75804,8 +76159,8 @@ var PhaseStore = class {
       const entries = await fsp42.readdir(legacyDir, { withFileTypes: true }).catch(() => []);
       for (const entry of entries) {
         if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-        const legacyPath = path94.join(legacyDir, entry.name);
-        const currentPath = this.getFilePath(path94.basename(entry.name, ".json"));
+        const legacyPath = path95.join(legacyDir, entry.name);
+        const currentPath = this.getFilePath(path95.basename(entry.name, ".json"));
         if (await this.pathExists(currentPath)) {
           await this.removeMigratedLegacyFile(legacyDir, legacyPath);
           continue;
@@ -75956,7 +76311,7 @@ var PhaseStore = class {
 // src/goal/checkpoint.ts
 init_atomic_write();
 import * as fsp43 from "node:fs/promises";
-import * as path95 from "node:path";
+import * as path96 from "node:path";
 var CheckpointManager = class {
   store;
   maxCheckpoints;
@@ -75967,7 +76322,7 @@ var CheckpointManager = class {
     this.store = opts.store;
     this.maxCheckpoints = opts.maxCheckpoints ?? 10;
     this.maxCheckpointAgeMs = opts.maxCheckpointAgeMs ?? 7 * 24 * 60 * 60 * 1e3;
-    this.baseDir = opts.baseDir ?? path95.join(opts.store.baseDir, ".checkpoints");
+    this.baseDir = opts.baseDir ?? path96.join(opts.store.baseDir, ".checkpoints");
   }
   async initialize() {
     await fsp43.mkdir(this.baseDir, { recursive: true });
@@ -76033,7 +76388,7 @@ var CheckpointManager = class {
     return true;
   }
   async saveToDisk(checkpoint) {
-    const filePath = path95.join(this.baseDir, `${checkpoint.graphId}.json`);
+    const filePath = path96.join(this.baseDir, `${checkpoint.graphId}.json`);
     const serialized = {
       ...checkpoint
     };
@@ -76060,7 +76415,7 @@ var CheckpointManager = class {
     }
     for (const filename of entries) {
       if (!filename.endsWith(".json")) continue;
-      const filePath = path95.join(this.baseDir, filename);
+      const filePath = path96.join(this.baseDir, filename);
       try {
         await withFileLock(filePath, async () => {
           const raw = await fsp43.readFile(filePath, "utf8");
@@ -76089,7 +76444,7 @@ var CheckpointManager = class {
     }
     for (const filename of entries) {
       if (!filename.endsWith(".json")) continue;
-      const filePath = path95.join(this.baseDir, filename);
+      const filePath = path96.join(this.baseDir, filename);
       try {
         const raw = await fsp43.readFile(filePath, "utf8");
         const parsed = JSON.parse(raw);
@@ -77012,7 +77367,7 @@ function countShellHooks(hooks) {
 }
 
 // src/hq/session-bridge.ts
-import * as fs41 from "node:fs";
+import * as fs42 from "node:fs";
 import * as fsp44 from "node:fs/promises";
 
 // src/types/session-markers.ts
@@ -77456,7 +77811,7 @@ function startSessionTelemetryBridge(opts) {
     let setupWatcher2 = function() {
       if (disposed || watcher) return;
       try {
-        const nextWatcher = fs41.watch(sessionFile, () => {
+        const nextWatcher = fs42.watch(sessionFile, () => {
           if (watchPending || disposed) return;
           watchPending = true;
           setTimeout(() => {
@@ -77934,8 +78289,8 @@ function startCostTelemetryBridge(opts) {
 // src/hq/kanban-store.ts
 init_atomic_write();
 import { createHash as createHash31 } from "node:crypto";
-import * as fs42 from "node:fs/promises";
-import * as path96 from "node:path";
+import * as fs43 from "node:fs/promises";
+import * as path97 from "node:path";
 
 // src/hq/write-queues.ts
 var BestEffortBatchQueue = class _BestEffortBatchQueue {
@@ -78030,7 +78385,7 @@ var HqKanbanStore = class {
   writers = /* @__PURE__ */ new Map();
   mergeChains = /* @__PURE__ */ new Map();
   constructor(dataDir) {
-    this.dirPath = path96.join(dataDir, "kanban");
+    this.dirPath = path97.join(dataDir, "kanban");
   }
   async load(projectId) {
     const cached2 = this.cache.get(projectId);
@@ -78040,7 +78395,7 @@ var HqKanbanStore = class {
       return structuredClone(cached2);
     }
     try {
-      const content = await fs42.readFile(this.filePath(projectId), "utf8");
+      const content = await fs43.readFile(this.filePath(projectId), "utf8");
       const snapshot = JSON.parse(content);
       if (!isHqKanbanSnapshotPayload(snapshot) || snapshot.projectId !== projectId) {
         return emptyKanbanSnapshot(projectId);
@@ -78114,7 +78469,7 @@ var HqKanbanStore = class {
     let writer = this.writers.get(projectId);
     if (writer === void 0) {
       writer = new BestEffortLatestQueue(async (snapshot) => {
-        await fs42.mkdir(this.dirPath, { recursive: true });
+        await fs43.mkdir(this.dirPath, { recursive: true });
         await atomicWrite(this.filePath(projectId), JSON.stringify(snapshot), { mode: 384 });
       });
       this.writers.set(projectId, writer);
@@ -78138,7 +78493,7 @@ var HqKanbanStore = class {
   }
   filePath(projectId) {
     const safe = createHash31("sha256").update(projectId).digest("hex");
-    return path96.join(this.dirPath, `${safe}.json`);
+    return path97.join(this.dirPath, `${safe}.json`);
   }
 };
 function emptyKanbanSnapshot(projectId) {
@@ -78156,17 +78511,17 @@ function compareKanbanRecord(a, b) {
 // src/hq/persistence/event-log.ts
 init_file_permissions();
 init_atomic_write();
-import * as fs44 from "node:fs/promises";
-import * as path97 from "node:path";
+import * as fs45 from "node:fs/promises";
+import * as path98 from "node:path";
 
 // src/hq/persistence/jsonl-io.ts
-import * as fs43 from "node:fs/promises";
+import * as fs44 from "node:fs/promises";
 import { StringDecoder } from "node:string_decoder";
 var RECENT_READ_CHUNK_BYTES = 64 * 1024;
 var LINE_COUNT_CHUNK_BYTES = 256 * 1024;
 async function readTailNonEmptyLines(filePath, limit, estimatedLineCount) {
   if (!(limit > 0)) return [];
-  const handle = await fs43.open(filePath, "r");
+  const handle = await fs44.open(filePath, "r");
   try {
     const size = (await handle.stat()).size;
     let position = size;
@@ -78213,7 +78568,7 @@ async function readTailNonEmptyLines(filePath, limit, estimatedLineCount) {
   }
 }
 async function findTailStartOffset(filePath, keepLines, maxBytes) {
-  const handle = await fs43.open(filePath, "r");
+  const handle = await fs44.open(filePath, "r");
   try {
     const size = (await handle.stat()).size;
     if (size === 0) return { offset: 0, size };
@@ -78253,7 +78608,7 @@ async function findTailStartOffset(filePath, keepLines, maxBytes) {
   }
 }
 async function copyTailToHandle(sourcePath, offset, destination) {
-  const handle = await fs43.open(sourcePath, "r");
+  const handle = await fs44.open(sourcePath, "r");
   try {
     const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
     let position = offset;
@@ -78283,7 +78638,7 @@ async function copyTailToHandle(sourcePath, offset, destination) {
   }
 }
 async function* readJsonlLines(filePath) {
-  const handle = await fs43.open(filePath, "r");
+  const handle = await fs44.open(filePath, "r");
   try {
     const buffer = Buffer.allocUnsafe(LINE_COUNT_CHUNK_BYTES);
     const decoder = new StringDecoder("utf8");
@@ -78313,7 +78668,7 @@ async function* readJsonlLines(filePath) {
 async function countNonEmptyLines(filePath) {
   let handle;
   try {
-    handle = await fs43.open(filePath, "r");
+    handle = await fs44.open(filePath, "r");
   } catch {
     return 0;
   }
@@ -78379,7 +78734,7 @@ var HqEventLog = class {
   counted = false;
   hydration;
   constructor(opts) {
-    this.filePath = path97.join(opts.dataDir, "events.jsonl");
+    this.filePath = path98.join(opts.dataDir, "events.jsonl");
     this.maxLines = opts.maxLines ?? DEFAULT_EVENT_LOG_MAX_LINES;
     this.rotateKeep = opts.rotateKeep ?? DEFAULT_EVENT_LOG_ROTATE_KEEP;
     this.maxBytes = opts.maxBytes ?? DEFAULT_EVENT_LOG_MAX_BYTES;
@@ -78397,7 +78752,7 @@ var HqEventLog = class {
   async appendInternal(events) {
     await this.ensureLineCount();
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
-    await fs44.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+    await fs45.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
     this.lineCount += events.length;
     this.byteCount += Buffer.byteLength(lines, "utf8");
     if (this.lineCount >= this.maxLines || this.byteCount >= this.maxBytes) {
@@ -78443,7 +78798,7 @@ var HqEventLog = class {
   async countLines() {
     let handle;
     try {
-      handle = await fs44.open(this.filePath, "r");
+      handle = await fs45.open(this.filePath, "r");
     } catch {
       return 0;
     }
@@ -78485,7 +78840,7 @@ var HqEventLog = class {
     if (this.counted) return;
     this.hydration ??= Promise.all([
       this.countLines(),
-      fs44.stat(this.filePath).then(
+      fs45.stat(this.filePath).then(
         (stat40) => stat40.size,
         () => 0
       )
@@ -78523,7 +78878,7 @@ async function readRecentEvents(filePath, limit, typeFilter) {
   if (!(limit > 0)) return [];
   let handle;
   try {
-    handle = await fs44.open(filePath, "r");
+    handle = await fs45.open(filePath, "r");
   } catch {
     return [];
   }
@@ -78604,8 +78959,8 @@ async function readRecentEvents(filePath, limit, typeFilter) {
 
 // src/hq/persistence/simple-log.ts
 init_atomic_write();
-import * as fs45 from "node:fs/promises";
-import * as path98 from "node:path";
+import * as fs46 from "node:fs/promises";
+import * as path99 from "node:path";
 var HqSimpleLog = class {
   filePath;
   maxLines;
@@ -78616,7 +78971,7 @@ var HqSimpleLog = class {
   counted = false;
   hydration;
   constructor(opts) {
-    this.filePath = path98.join(opts.dataDir, opts.filename);
+    this.filePath = path99.join(opts.dataDir, opts.filename);
     this.maxLines = opts.maxLines ?? Infinity;
     this.rotateKeep = opts.rotateKeep ?? this.maxLines;
     this.readLimit = opts.readLimit ?? Infinity;
@@ -78632,7 +78987,7 @@ var HqSimpleLog = class {
   }
   async appendInternal(records) {
     if (Number.isFinite(this.maxLines)) await this.ensureLineCount();
-    await fs45.appendFile(
+    await fs46.appendFile(
       this.filePath,
       records.map((record) => JSON.stringify(record)).join("\n") + "\n",
       { encoding: "utf8" }
@@ -78686,13 +79041,13 @@ var HqSimpleLog = class {
 
 // src/hq/persistence/snapshot-store.ts
 init_atomic_write();
-import * as fs46 from "node:fs/promises";
-import * as path99 from "node:path";
+import * as fs47 from "node:fs/promises";
+import * as path100 from "node:path";
 var HqSnapshotStore = class {
   filePath;
   writer;
   constructor(opts) {
-    this.filePath = path99.join(opts.dataDir, "snapshot.json");
+    this.filePath = path100.join(opts.dataDir, "snapshot.json");
     this.writer = new BestEffortLatestQueue(
       (snapshot) => atomicWrite(this.filePath, JSON.stringify(snapshot), { mode: 384 })
     );
@@ -78708,7 +79063,7 @@ var HqSnapshotStore = class {
   /** Read the last persisted snapshot, or `null` if none. */
   async load() {
     try {
-      const content = await fs46.readFile(this.filePath, "utf8");
+      const content = await fs47.readFile(this.filePath, "utf8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -78719,8 +79074,8 @@ var HqSnapshotStore = class {
 // src/hq/persistence/timeseries-store.ts
 init_file_permissions();
 init_atomic_write();
-import * as fs47 from "node:fs/promises";
-import * as path100 from "node:path";
+import * as fs48 from "node:fs/promises";
+import * as path101 from "node:path";
 var HqTimeseriesStore = class {
   filePath;
   bucketMs;
@@ -78733,7 +79088,7 @@ var HqTimeseriesStore = class {
   loaded = false;
   loadPromise;
   constructor(opts) {
-    this.filePath = path100.join(opts.dataDir, "timeseries.jsonl");
+    this.filePath = path101.join(opts.dataDir, "timeseries.jsonl");
     this.bucketMs = opts.bucketMs ?? 5 * 60 * 1e3;
     this.maxBuckets = opts.maxBuckets ?? 2016;
     this.writer = new BestEffortLatestQueue((snapshot) => this.flushInternal(snapshot));
@@ -78820,7 +79175,7 @@ var HqTimeseriesStore = class {
     const lines = snapshot.samples.map((bucket) => JSON.stringify(bucket)).join("\n") + "\n";
     await withFileLock(this.filePath, async () => {
       this.diskLineCount ??= await countNonEmptyLines(this.filePath);
-      await fs47.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      await fs48.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
       this.diskLineCount += snapshot.samples.length;
       const compactAt = Math.max(this.maxBuckets + 1, this.maxBuckets * 4);
       if (this.diskLineCount >= compactAt) {
@@ -81051,7 +81406,7 @@ function definePlugin(metadata, factory) {
 // src/plugins/auto-review-plugin.ts
 init_error();
 import * as fsp47 from "node:fs/promises";
-import * as path103 from "node:path";
+import * as path104 from "node:path";
 
 // src/plugins/auto-review-config.ts
 var DEFAULT_DEBOUNCE_MS = 15e3;
@@ -81228,7 +81583,7 @@ function shouldCascade(cascadeOn, severities) {
 import { spawn as spawn9 } from "node:child_process";
 import { createHash as createHash32 } from "node:crypto";
 import * as fsp45 from "node:fs/promises";
-import * as path101 from "node:path";
+import * as path102 from "node:path";
 var MAX_SNAPSHOT_FILE_BYTES = 256 * 1024;
 var MAX_SNAPSHOT_TOTAL_BYTES = 8 * 1024 * 1024;
 async function runGit2(args, cwd) {
@@ -81286,9 +81641,9 @@ async function snapshotChangedFiles(cwd) {
     if (file.path.startsWith(".wrongstack/")) continue;
     if (budget <= 0) break;
     try {
-      const stat40 = await fsp45.stat(path101.join(cwd, file.path));
+      const stat40 = await fsp45.stat(path102.join(cwd, file.path));
       if (!stat40.isFile() || stat40.size > MAX_SNAPSHOT_FILE_BYTES) continue;
-      const content = await fsp45.readFile(path101.join(cwd, file.path), "utf8");
+      const content = await fsp45.readFile(path102.join(cwd, file.path), "utf8");
       budget -= content.length;
       snapshots.push({
         ...file,
@@ -81305,7 +81660,7 @@ async function snapshotChangedFiles(cwd) {
 import { createHash as createHash33, randomUUID as randomUUID39 } from "node:crypto";
 import * as fsp46 from "node:fs/promises";
 import { hostname as hostname5 } from "node:os";
-import * as path102 from "node:path";
+import * as path103 from "node:path";
 var CLAIMS_FILE = "review-claims.jsonl";
 var DEFAULT_CLAIM_TTL_MS = 30 * 60 * 1e3;
 var LOCK_WAIT_MS = 5e3;
@@ -81441,16 +81796,16 @@ function claimKey(cwd, filePath) {
 }
 function resolveStore(opts, cwd) {
   return {
-    storeDir: opts?.storeDir ?? path102.join(cwd, ".wrongstack"),
+    storeDir: opts?.storeDir ?? path103.join(cwd, ".wrongstack"),
     ttlMs: opts?.ttlMs ?? DEFAULT_CLAIM_TTL_MS,
     maxLedgerLines: opts?.maxLedgerLines ?? MAX_LEDGER_LINES
   };
 }
 function claimsFilePath(storeDir) {
-  return path102.join(storeDir, CLAIMS_FILE);
+  return path103.join(storeDir, CLAIMS_FILE);
 }
 function lockFilePath(storeDir) {
-  return path102.join(storeDir, `${CLAIMS_FILE}.lock`);
+  return path103.join(storeDir, `${CLAIMS_FILE}.lock`);
 }
 async function readLedger(storeDir, now) {
   const active = /* @__PURE__ */ new Map();
@@ -82306,7 +82661,7 @@ function createAutoReviewPlugin() {
             for (const f of allChanged) {
               if (f.path.startsWith(".wrongstack/")) continue;
               try {
-                await fsp47.access(path103.join(cwd, f.path));
+                await fsp47.access(path104.join(cwd, f.path));
                 existing.push(f);
               } catch {
               }
@@ -82316,7 +82671,7 @@ function createAutoReviewPlugin() {
             const filesWithContent = [];
             for (const f of toReview) {
               try {
-                const absPath = path103.join(cwd, f.path);
+                const absPath = path104.join(cwd, f.path);
                 const content = await fsp47.readFile(absPath, "utf8");
                 filesWithContent.push({ path: f.path, status: f.status, content });
               } catch {
@@ -82428,7 +82783,7 @@ init_error();
 import { spawn as spawn11 } from "node:child_process";
 import * as fsp49 from "node:fs/promises";
 import * as os13 from "node:os";
-import * as path105 from "node:path";
+import * as path106 from "node:path";
 
 // src/plugins/review-finding-commands.ts
 init_review_finding_store();
@@ -83423,8 +83778,8 @@ function buildReviewCommand(_getConfig) {
     async run(args) {
       const cwd = process.cwd();
       const slug = projectSlug(cwd);
-      const globalRoot = path105.join(os13.homedir(), ".wrongstack");
-      const projectDir = path105.join(globalRoot, "projects", slug);
+      const globalRoot = path106.join(os13.homedir(), ".wrongstack");
+      const projectDir = path106.join(globalRoot, "projects", slug);
       const trimmed = (args ?? "").trim();
       const parts = trimmed.split(/\s+/).filter(Boolean);
       return {
@@ -83486,7 +83841,7 @@ function createChimeraPlugin() {
             for (const f of allChanged) {
               if (f.path.startsWith(".wrongstack/")) continue;
               try {
-                await fsp49.access(path105.join(cwd, f.path));
+                await fsp49.access(path106.join(cwd, f.path));
                 existing.push(f);
               } catch {
               }
@@ -83504,7 +83859,7 @@ function createChimeraPlugin() {
             const filesWithContent = [];
             for (const f of toReview) {
               try {
-                const absPath = path105.join(cwd, f.path);
+                const absPath = path106.join(cwd, f.path);
                 const content = await fsp49.readFile(absPath, "utf8");
                 filesWithContent.push({ path: f.path, status: f.status, content });
               } catch {
@@ -83549,13 +83904,13 @@ function createChimeraPlugin() {
 }
 
 // src/plugins/cloud-config-sync-plugin.ts
-import * as path107 from "node:path";
+import * as path108 from "node:path";
 
 // src/storage/cloud-config-sync.ts
 init_atomic_write();
 import { createHash as createHash35, randomUUID as nodeRandomUUID } from "node:crypto";
-import * as fs48 from "node:fs/promises";
-import * as path106 from "node:path";
+import * as fs49 from "node:fs/promises";
+import * as path107 from "node:path";
 
 // src/storage/cloud-config-sync/sanitize.ts
 var SAGE_TREE = {
@@ -84276,7 +84631,7 @@ var CloudConfigSync = class {
   async loadState() {
     if (this.state) return this.state;
     try {
-      const raw = await fs48.readFile(this.deps.statePath, "utf8");
+      const raw = await fs49.readFile(this.deps.statePath, "utf8");
       const parsed = JSON.parse(raw);
       this.state = {
         ...structuredClone(EMPTY_STATE),
@@ -84290,7 +84645,7 @@ var CloudConfigSync = class {
   }
   async saveState(state) {
     this.state = state;
-    await fs48.mkdir(path106.dirname(this.deps.statePath), { recursive: true });
+    await fs49.mkdir(path107.dirname(this.deps.statePath), { recursive: true });
     await atomicWrite(this.deps.statePath, `${JSON.stringify(state, null, 2)}
 `, {
       mode: 384
@@ -84337,8 +84692,8 @@ function createCloudConfigSyncPlugin(opts) {
         );
         return;
       }
-      const profileConfigPath = path107.join(paths.configDir, "config.json");
-      const statePath = path107.join(paths.configDir, "cloud-sync-state.json");
+      const profileConfigPath = path108.join(paths.configDir, "config.json");
+      const statePath = path108.join(paths.configDir, "cloud-sync-state.json");
       const warn = (msg) => api.log.warn(msg);
       const readLocalConfig = async () => {
         const raw = await readJsonObjectFile(profileConfigPath).catch(() => ({}));
@@ -84512,12 +84867,12 @@ ${first}` };
 }
 
 // src/plugins/prompts-plugin.ts
-import * as fs50 from "node:fs/promises";
-import * as path108 from "node:path";
+import * as fs51 from "node:fs/promises";
+import * as path109 from "node:path";
 
 // src/storage/prompt-usage-store.ts
 init_atomic_write();
-import * as fs49 from "node:fs/promises";
+import * as fs50 from "node:fs/promises";
 var PromptUsageStore = class {
   constructor(file) {
     this.file = file;
@@ -84537,7 +84892,7 @@ var PromptUsageStore = class {
       return this.cachedUsage;
     }
     try {
-      const raw = JSON.parse(await fs49.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fs50.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && raw.usage && typeof raw.usage === "object") {
         this.cachedUsage = raw.usage;
         this.cachedSignature = signature;
@@ -84617,7 +84972,7 @@ var PromptUsageStore = class {
   }
   async fileSignature() {
     try {
-      const stat40 = await fs49.stat(this.file);
+      const stat40 = await fs50.stat(this.file);
       return { size: stat40.size, mtimeMs: stat40.mtimeMs, ctimeMs: stat40.ctimeMs };
     } catch {
       return null;
@@ -84804,7 +85159,7 @@ ${exact.content}` };
             2
           );
           try {
-            await fs50.writeFile(target, payload, "utf8");
+            await fs51.writeFile(target, payload, "utf8");
             return { message: `Exported ${own.length} prompt(s) \u2192 ${target}` };
           } catch (err) {
             return { message: `Export failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -84816,7 +85171,7 @@ ${exact.content}` };
           const src = resolveIoPath(restJoined, ctx);
           let raw;
           try {
-            raw = JSON.parse(await fs50.readFile(src, "utf8"));
+            raw = JSON.parse(await fs51.readFile(src, "utf8"));
           } catch (err) {
             return { message: `Import failed: ${err instanceof Error ? err.message : String(err)}` };
           }
@@ -85022,9 +85377,9 @@ ${dim(`slug: ${entry.slug} | category: ${entry.category} | source: ${entry.sourc
 }
 function resolveIoPath(p, ctx) {
   const cleaned = p.trim().replace(/^["']|["']$/g, "");
-  if (path108.isAbsolute(cleaned)) return cleaned;
+  if (path109.isAbsolute(cleaned)) return cleaned;
   const base = ctx.projectRoot ?? process.cwd();
-  return path108.resolve(base, cleaned);
+  return path109.resolve(base, cleaned);
 }
 function sourceGlyph(e) {
   return e.source === "project" ? "\u{1F4C1}" : e.source === "user" ? "\u{1F464}" : e.source === "synced" ? "\u2601" : "\u{1F4E6}";
@@ -85107,7 +85462,7 @@ init_review_report_store();
 
 // src/plugins/skills-plugin.ts
 import * as os15 from "node:os";
-import * as path113 from "node:path";
+import * as path114 from "node:path";
 
 // src/skills/registry/github-direct-adapter.ts
 var githubDirectAdapter = {
@@ -85264,8 +85619,8 @@ function numField(rec, key) {
 // src/skills/skill-generator.ts
 init_errors();
 import { spawn as spawn12 } from "node:child_process";
-import * as fs51 from "node:fs/promises";
-import * as path109 from "node:path";
+import * as fs52 from "node:fs/promises";
+import * as path110 from "node:path";
 async function validateSkillNameAvailable(name, loader) {
   const formatViolations = validateSkillName(name);
   const conflicts = loader ? (await loader.listEntries()).filter((e) => e.name === name) : [];
@@ -85389,11 +85744,11 @@ async function writeSkeletonSkill(skillsDir, body, opts = {}) {
       subsystem: "general"
     });
   }
-  const skillDir = path109.join(skillsDir, name);
-  const skillFile = path109.join(skillDir, "SKILL.md");
+  const skillDir = path110.join(skillsDir, name);
+  const skillFile = path110.join(skillDir, "SKILL.md");
   if (!opts.overwrite) {
     try {
-      await fs51.access(skillFile);
+      await fs52.access(skillFile);
       throw new WrongStackError({
         message: `A skill already exists at ${skillFile}. Use --force to overwrite.`,
         code: ERROR_CODES.VALIDATION_ERROR,
@@ -85404,8 +85759,8 @@ async function writeSkeletonSkill(skillsDir, body, opts = {}) {
       if (err instanceof WrongStackError) throw err;
     }
   }
-  await fs51.mkdir(skillDir, { recursive: true });
-  await fs51.writeFile(skillFile, body, "utf8");
+  await fs52.mkdir(skillDir, { recursive: true });
+  await fs52.writeFile(skillFile, body, "utf8");
   return skillFile;
 }
 function bodyLineAdvisory(body) {
@@ -85448,15 +85803,15 @@ function defaultEditor() {
 // src/skills/skill-installer.ts
 init_errors();
 init_error();
-import * as fs54 from "node:fs/promises";
-import * as path112 from "node:path";
+import * as fs55 from "node:fs/promises";
+import * as path113 from "node:path";
 
 // src/skills/github-fetcher.ts
 init_errors();
 import { createWriteStream } from "node:fs";
-import * as fs52 from "node:fs/promises";
+import * as fs53 from "node:fs/promises";
 import * as os14 from "node:os";
-import * as path110 from "node:path";
+import * as path111 from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
@@ -85598,7 +85953,7 @@ async function downloadGitHubTarball(parsed) {
       }
     });
   }
-  const tempDir = await fs52.mkdtemp(path110.join(os14.tmpdir(), "wskill-"));
+  const tempDir = await fs53.mkdtemp(path111.join(os14.tmpdir(), "wskill-"));
   try {
     if (!response.body) {
       throw new WrongStackError({
@@ -85609,17 +85964,17 @@ async function downloadGitHubTarball(parsed) {
       });
     }
     const nodeStream = Readable.fromWeb(response.body);
-    const tarPath = path110.join(tempDir, ".wrongstack-download.tar");
+    const tarPath = path111.join(tempDir, ".wrongstack-download.tar");
     await writeBoundedGzipStream(nodeStream, tarPath, SKILL_LIMITS.MAX_UNCOMPRESSED_TARBALL_SIZE);
-    const tarBuf = await fs52.readFile(tarPath);
+    const tarBuf = await fs53.readFile(tarPath);
     try {
       await extractTar(tarBuf, tempDir);
     } finally {
-      await fs52.rm(tarPath, { force: true });
+      await fs53.rm(tarPath, { force: true });
     }
     return { tempDir };
   } catch (err) {
-    await fs52.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    await fs53.rm(tempDir, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   }
@@ -85674,25 +86029,25 @@ async function extractTar(buf, destDir) {
     const fullPath = prefix ? `${prefix}/${name}` : name;
     const relPath = stripTopDir(fullPath);
     if (relPath && relPath !== "." && relPath !== "..") {
-      const destPath = path110.join(destDir, relPath);
-      const resolvedDest = path110.resolve(destPath);
-      const resolvedRoot = path110.resolve(destDir);
-      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path110.sep)) {
+      const destPath = path111.join(destDir, relPath);
+      const resolvedDest = path111.resolve(destPath);
+      const resolvedRoot = path111.resolve(destDir);
+      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path111.sep)) {
         offset += 512 + Math.ceil(size / 512) * 512;
         continue;
       }
       if (typeflag === 53 || typeflag === 0) {
         if (relPath.endsWith("/") || typeflag === 53) {
-          await fs52.mkdir(destPath, { recursive: true });
+          await fs53.mkdir(destPath, { recursive: true });
         }
       }
       if ((typeflag === 48 || typeflag === 0 || typeflag === 0) && size > 0) {
-        const dir = path110.dirname(destPath);
-        await fs52.mkdir(dir, { recursive: true });
+        const dir = path111.dirname(destPath);
+        await fs53.mkdir(dir, { recursive: true });
         const dataStart = offset + 512;
         const dataEnd = dataStart + size;
         if (dataEnd > buf.length) break;
-        await fs52.writeFile(destPath, buf.subarray(dataStart, dataEnd));
+        await fs53.writeFile(destPath, buf.subarray(dataStart, dataEnd));
       }
     }
     offset += 512 + Math.ceil(size / 512) * 512;
@@ -85701,8 +86056,8 @@ async function extractTar(buf, destDir) {
 
 // src/skills/manifest-store.ts
 init_atomic_write();
-import * as fs53 from "node:fs/promises";
-import * as path111 from "node:path";
+import * as fs54 from "node:fs/promises";
+import * as path112 from "node:path";
 var SkillManifestStore = class {
   manifestPath;
   cache;
@@ -85712,7 +86067,7 @@ var SkillManifestStore = class {
   async read() {
     if (this.cache) return this.cache;
     try {
-      const raw = await fs53.readFile(this.manifestPath, "utf8");
+      const raw = await fs54.readFile(this.manifestPath, "utf8");
       const data = JSON.parse(raw);
       if (!Array.isArray(data.skills)) {
         this.cache = { skills: [] };
@@ -85725,8 +86080,8 @@ var SkillManifestStore = class {
     return this.cache;
   }
   async write(data) {
-    const dir = path111.dirname(this.manifestPath);
-    await fs53.mkdir(dir, { recursive: true });
+    const dir = path112.dirname(this.manifestPath);
+    await fs54.mkdir(dir, { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2) + "\n");
     this.cache = data;
   }
@@ -85764,8 +86119,8 @@ var SkillManifestStore = class {
 
 // src/skills/skill-installer.ts
 function isInside3(resolved, destDir) {
-  const root = path112.resolve(destDir);
-  return resolved === root || resolved.startsWith(root + path112.sep);
+  const root = path113.resolve(destDir);
+  return resolved === root || resolved.startsWith(root + path113.sep);
 }
 var MAX_SKILL_FILE_SIZE = SKILL_LIMITS.MAX_SKILL_FILE_SIZE;
 var SkillInstaller = class {
@@ -85820,13 +86175,13 @@ var SkillInstaller = class {
           this.opts.log?.(`Overwriting existing skill "${skill.name}" (${scope})...`);
           await this.removeSkillFiles(skill.name, scope);
         }
-        const destDir = path112.join(targetDir, skill.name);
-        await fs54.mkdir(destDir, { recursive: true });
+        const destDir = path113.join(targetDir, skill.name);
+        await fs55.mkdir(destDir, { recursive: true });
         const copiedFiles = [];
         for (const file of skill.files) {
-          const srcPath = path112.join(skill.baseDir, file);
-          const destPath = path112.join(destDir, file);
-          const resolved2 = path112.resolve(destPath);
+          const srcPath = path113.join(skill.baseDir, file);
+          const destPath = path113.join(destDir, file);
+          const resolved2 = path113.resolve(destPath);
           if (!isInside3(resolved2, destDir)) {
             throw new FsError({
               message: `Path traversal detected in skill file: ${file}`,
@@ -85835,7 +86190,7 @@ var SkillInstaller = class {
               context: { reason: "path_traversal", skillName: skill.name }
             });
           }
-          const stat40 = await fs54.stat(srcPath);
+          const stat40 = await fs55.stat(srcPath);
           if (stat40.size > MAX_SKILL_FILE_SIZE) {
             throw new FsError({
               message: `Skill file "${file}" is too large (${(stat40.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`,
@@ -85844,8 +86199,8 @@ var SkillInstaller = class {
               context: { skillName: skill.name, fileSize: stat40.size, maxSize: MAX_SKILL_FILE_SIZE }
             });
           }
-          await fs54.mkdir(path112.dirname(destPath), { recursive: true });
-          await fs54.copyFile(srcPath, destPath);
+          await fs55.mkdir(path113.dirname(destPath), { recursive: true });
+          await fs55.copyFile(srcPath, destPath);
           copiedFiles.push(file);
         }
         const entry = {
@@ -85875,7 +86230,7 @@ var SkillInstaller = class {
       this.invalidateLoaderCache();
       return results;
     } finally {
-      await fs54.rm(tempDir, { recursive: true, force: true }).catch(() => {
+      await fs55.rm(tempDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -85890,7 +86245,7 @@ var SkillInstaller = class {
     const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
     let entries;
     try {
-      entries = await fs54.readdir(srcDir, { withFileTypes: true });
+      entries = await fs55.readdir(srcDir, { withFileTypes: true });
     } catch {
       throw new WrongStackError({
         message: `Source directory not found or not readable: ${srcDir}`,
@@ -85902,10 +86257,10 @@ var SkillInstaller = class {
     const results = [];
     for (const e of entries) {
       if (!await entryIsDirectory2(srcDir, e)) continue;
-      const skillMdPath = path112.join(srcDir, e.name, "SKILL.md");
+      const skillMdPath = path113.join(srcDir, e.name, "SKILL.md");
       let content;
       try {
-        content = await fs54.readFile(skillMdPath, "utf8");
+        content = await fs55.readFile(skillMdPath, "utf8");
       } catch {
         continue;
       }
@@ -85915,15 +86270,15 @@ var SkillInstaller = class {
       if (existing.find((x) => x.scope === scope)) {
         await this.removeSkillFiles(fm.name, scope);
       }
-      const destDir = path112.join(targetDir, fm.name);
-      await fs54.mkdir(destDir, { recursive: true });
-      const srcSkillDir = path112.join(srcDir, e.name);
+      const destDir = path113.join(targetDir, fm.name);
+      await fs55.mkdir(destDir, { recursive: true });
+      const srcSkillDir = path113.join(srcDir, e.name);
       const files = await collectFiles(srcSkillDir, srcSkillDir);
       const copiedFiles = [];
       for (const file of files) {
-        const srcPath = path112.join(srcSkillDir, file);
-        const destPath = path112.join(destDir, file);
-        const resolved = path112.resolve(destPath);
+        const srcPath = path113.join(srcSkillDir, file);
+        const destPath = path113.join(destDir, file);
+        const resolved = path113.resolve(destPath);
         if (!isInside3(resolved, destDir)) {
           throw new FsError({
             message: `Path traversal detected in skill file: ${file}`,
@@ -85932,16 +86287,16 @@ var SkillInstaller = class {
             context: { reason: "path_traversal", skillName: fm.name }
           });
         }
-        await fs54.mkdir(path112.dirname(destPath), { recursive: true });
+        await fs55.mkdir(path113.dirname(destPath), { recursive: true });
         if (opts?.link) {
           try {
-            await fs54.symlink(srcPath, destPath);
+            await fs55.symlink(srcPath, destPath);
           } catch (err) {
-            await fs54.copyFile(srcPath, destPath);
+            await fs55.copyFile(srcPath, destPath);
             this.opts.log?.(`symlink failed for ${file} (${toErrorMessage(err)}); copied instead`);
           }
         } else {
-          await fs54.copyFile(srcPath, destPath);
+          await fs55.copyFile(srcPath, destPath);
         }
         copiedFiles.push(file);
       }
@@ -86095,10 +86450,10 @@ var SkillInstaller = class {
    */
   async detectSkills(baseDir2) {
     const results = [];
-    const rootSkillMd = path112.join(baseDir2, "SKILL.md");
+    const rootSkillMd = path113.join(baseDir2, "SKILL.md");
     try {
-      await fs54.access(rootSkillMd);
-      const content = await fs54.readFile(rootSkillMd, "utf8");
+      await fs55.access(rootSkillMd);
+      const content = await fs55.readFile(rootSkillMd, "utf8");
       const fm = parseSkillFrontmatter(content);
       if (fm.name && fm.description && isValidSkillNameFormat(fm.name)) {
         results.push({
@@ -86110,17 +86465,17 @@ var SkillInstaller = class {
       }
     } catch {
     }
-    const skillsDir = path112.join(baseDir2, "skills");
+    const skillsDir = path113.join(baseDir2, "skills");
     try {
-      const entries = await fs54.readdir(skillsDir, { withFileTypes: true });
+      const entries = await fs55.readdir(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const skillFile = path112.join(skillsDir, entry.name, "SKILL.md");
+        const skillFile = path113.join(skillsDir, entry.name, "SKILL.md");
         try {
-          const content = await fs54.readFile(skillFile, "utf8");
+          const content = await fs55.readFile(skillFile, "utf8");
           const fm = parseSkillFrontmatter(content);
           if (fm.name && fm.description && isValidSkillNameFormat(fm.name)) {
-            const skillDir = path112.join(skillsDir, entry.name);
+            const skillDir = path113.join(skillsDir, entry.name);
             const files = await collectFiles(skillDir, skillDir);
             results.push({
               name: fm.name,
@@ -86153,8 +86508,8 @@ var SkillInstaller = class {
    */
   async removeSkillFiles(name, scope) {
     const targetDir = scope === "project" ? this.opts.projectSkillsDir : this.opts.globalSkillsDir;
-    const root = path112.resolve(targetDir);
-    const skillDir = path112.resolve(path112.join(targetDir, name));
+    const root = path113.resolve(targetDir);
+    const skillDir = path113.resolve(path113.join(targetDir, name));
     if (skillDir === root || !isInside3(skillDir, root)) {
       throw new FsError({
         message: `Refusing to delete skill files outside the skills directory: ${name}`,
@@ -86163,7 +86518,7 @@ var SkillInstaller = class {
         context: { reason: "path_traversal", skillName: name, scope }
       });
     }
-    await fs54.rm(skillDir, { recursive: true, force: true });
+    await fs55.rm(skillDir, { recursive: true, force: true });
   }
   /**
    * Invalidate the skill loader's cache so newly installed skills appear.
@@ -86198,7 +86553,7 @@ async function entryIsDirectory2(dir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
     try {
-      return (await fs54.stat(path112.join(dir, entry.name))).isDirectory();
+      return (await fs55.stat(path113.join(dir, entry.name))).isDirectory();
     } catch {
       return false;
     }
@@ -86207,10 +86562,10 @@ async function entryIsDirectory2(dir, entry) {
 }
 async function collectFiles(dir, baseDir2) {
   const results = [];
-  const entries = await fs54.readdir(dir, { withFileTypes: true });
+  const entries = await fs55.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path112.join(dir, entry.name);
-    const relPath = path112.relative(baseDir2, fullPath);
+    const fullPath = path113.join(dir, entry.name);
+    const relPath = path113.relative(baseDir2, fullPath);
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
       results.push(...await collectFiles(fullPath, baseDir2));
@@ -86289,7 +86644,7 @@ function createSkillsPlugin(opts) {
 function makeInstaller(skillLoader, projectRoot, registryAdapters) {
   const paths = resolveWstackPaths({ projectRoot });
   return new SkillInstaller({
-    manifestPath: path113.join(paths.configDir, "installed-skills.json"),
+    manifestPath: path114.join(paths.configDir, "installed-skills.json"),
     projectSkillsDir: paths.inProjectSkills,
     globalSkillsDir: paths.globalSkills,
     projectHash: paths.projectHash,
@@ -86668,7 +87023,7 @@ function resolveImportSourceDir(tool, opts) {
   const entry = IMPORT_SOURCE_TOOLS.find((t2) => t2.id === tool);
   if (!entry) return void 0;
   const base = opts.global ? opts.homeDir ?? os15.homedir() : opts.projectRoot;
-  return path113.join(base, "." + entry.id, entry.subdir);
+  return path114.join(base, "." + entry.id, entry.subdir);
 }
 function buildSkillImportCommand(skillLoader) {
   return {
@@ -86709,7 +87064,7 @@ function buildSkillImportCommand(skillLoader) {
           };
         }
       } else if (positional) {
-        srcDir = path113.resolve(ctx.projectRoot, positional);
+        srcDir = path114.resolve(ctx.projectRoot, positional);
       } else {
         return {
           message: "Usage: /skill-import <src-dir> | --from <tool> | --from-claude [--global] [--link]"
@@ -86836,14 +87191,14 @@ function truncate5(s, max) {
 }
 
 // src/plugins/sync-plugin.ts
-import * as path115 from "node:path";
+import * as path116 from "node:path";
 init_error();
 
 // src/storage/cloud-sync.ts
 init_atomic_write();
 init_errors();
-import * as fs55 from "node:fs/promises";
-import * as path114 from "node:path";
+import * as fs56 from "node:fs/promises";
+import * as path115 from "node:path";
 import { createHash as createHash36 } from "node:crypto";
 var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
 var CloudSync = class {
@@ -86851,8 +87206,8 @@ var CloudSync = class {
     this.paths = paths;
     this.getConfig = getConfig;
     this.setConfig = setConfig;
-    this.statePath = path114.join(paths.configDir, "sync-state.json");
-    this.getSettingsConfigPath = getSettingsConfigPath ?? (() => path114.join(this.paths.configDir, "config.json"));
+    this.statePath = path115.join(paths.configDir, "sync-state.json");
+    this.getSettingsConfigPath = getSettingsConfigPath ?? (() => path115.join(this.paths.configDir, "config.json"));
   }
   paths;
   getConfig;
@@ -87007,7 +87362,7 @@ var CloudSync = class {
   }
   async loadState() {
     try {
-      const raw = await fs55.readFile(this.statePath, "utf8");
+      const raw = await fs56.readFile(this.statePath, "utf8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = null;
@@ -87132,18 +87487,18 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat40 = await fs55.lstat(localPath);
+        const stat40 = await fs56.lstat(localPath);
         if (stat40.isSymbolicLink()) continue;
         if (stat40.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs55.readFile(file, "utf8");
-            const rel = path114.relative(localPath, file).replace(/\\/g, "/");
+            const content = await fs56.readFile(file, "utf8");
+            const rel = path115.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(`${cat}/${rel}\0${content}`);
           }
         } else {
-          const content = await fs55.readFile(localPath, "utf8");
+          const content = await fs56.readFile(localPath, "utf8");
           entries.push({ path: `data/${cat}`, content, mode: "100644" });
           hashes.push(`${cat}\0${content}`);
         }
@@ -87159,17 +87514,17 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat40 = await fs55.lstat(localPath);
+        const stat40 = await fs56.lstat(localPath);
         if (stat40.isSymbolicLink()) continue;
         if (stat40.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fs55.readFile(file, "utf8");
-            const rel = path114.relative(localPath, file).replace(/\\/g, "/");
+            const content = await fs56.readFile(file, "utf8");
+            const rel = path115.relative(localPath, file).replace(/\\/g, "/");
             hashes.push(`${cat}/${rel}\0${content}`);
           }
         } else {
-          const content = await fs55.readFile(localPath, "utf8");
+          const content = await fs56.readFile(localPath, "utf8");
           hashes.push(`${cat}\0${content}`);
         }
       } catch {
@@ -87196,10 +87551,10 @@ var CloudSync = class {
   }
   async walkDir(dir, base) {
     const results = [];
-    const entries = await fs55.readdir(dir, { withFileTypes: true });
+    const entries = await fs56.readdir(dir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = path114.join(dir, entry.name);
+      const full = path115.join(dir, entry.name);
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
         results.push(...await this.walkDir(full, base));
@@ -87212,17 +87567,17 @@ var CloudSync = class {
 };
 async function preparePulledDestination(cat, localPath, destPath, remotePath) {
   const directoryBacked = cat === "skills" || cat === "prompts";
-  const rootPath = directoryBacked ? localPath : path114.dirname(localPath);
+  const rootPath = directoryBacked ? localPath : path115.dirname(localPath);
   const rootStat = await lstatIfExists(rootPath);
   if (rootStat?.isSymbolicLink()) {
     throw unsafePulledSymlinkError(remotePath, rootPath);
   }
   if (directoryBacked) {
-    const relativeParent = path114.relative(rootPath, path114.dirname(destPath));
+    const relativeParent = path115.relative(rootPath, path115.dirname(destPath));
     let cursor = rootPath;
     if (relativeParent) {
-      for (const segment of relativeParent.split(path114.sep)) {
-        cursor = path114.join(cursor, segment);
+      for (const segment of relativeParent.split(path115.sep)) {
+        cursor = path115.join(cursor, segment);
         const stat40 = await lstatIfExists(cursor);
         if (stat40?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, cursor);
       }
@@ -87230,11 +87585,11 @@ async function preparePulledDestination(cat, localPath, destPath, remotePath) {
   }
   const destStat = await lstatIfExists(destPath);
   if (destStat?.isSymbolicLink()) throw unsafePulledSymlinkError(remotePath, destPath);
-  await fs55.mkdir(path114.dirname(destPath), { recursive: true });
+  await fs56.mkdir(path115.dirname(destPath), { recursive: true });
 }
 async function lstatIfExists(filePath) {
   try {
-    return await fs55.lstat(filePath);
+    return await fs56.lstat(filePath);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -87260,9 +87615,9 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
     return localPath;
   }
   if (!rel) return localPath;
-  const normalizedRel = path114.normalize(rel);
-  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path114.sep}`);
-  if (path114.isAbsolute(normalizedRel) || traversesUp) {
+  const normalizedRel = path115.normalize(rel);
+  const traversesUp = normalizedRel === ".." || normalizedRel.startsWith(`..${path115.sep}`);
+  if (path115.isAbsolute(normalizedRel) || traversesUp) {
     throw new FsError({
       message: `Refusing CloudSync path traversal: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -87270,10 +87625,10 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
       context: { reason: "path_traversal", normalizedRel }
     });
   }
-  const dest = path114.resolve(localPath, normalizedRel);
-  const root = path114.resolve(localPath);
-  const relative21 = path114.relative(root, dest);
-  if (relative21.startsWith("..") || path114.isAbsolute(relative21)) {
+  const dest = path115.resolve(localPath, normalizedRel);
+  const root = path115.resolve(localPath);
+  const relative21 = path115.relative(root, dest);
+  if (relative21.startsWith("..") || path115.isAbsolute(relative21)) {
     throw new FsError({
       message: `Refusing CloudSync path outside category root: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -87316,7 +87671,7 @@ function createSyncPlugin(opts) {
         api.log.warn("[sync] paths, configStore, or configDir not available \u2014 /sync disabled");
         return;
       }
-      const syncConfigPath = paths.syncConfig ?? path115.join(paths.configDir, "sync.json");
+      const syncConfigPath = paths.syncConfig ?? path116.join(paths.configDir, "sync.json");
       cloud = new CloudSync(
         paths,
         () => {
@@ -87327,7 +87682,7 @@ function createSyncPlugin(opts) {
           await persistSyncConfig(syncConfigPath, cfg, vault);
           configStore?.update({ sync: cfg });
         },
-        () => path115.join(paths.configDir, "config.json")
+        () => path116.join(paths.configDir, "config.json")
       );
       void cloud.loadState();
       api.slashCommands.register(buildSyncCommand(cloud, configStore, vault, syncConfigPath));
@@ -87651,8 +88006,8 @@ var PromptInstaller = class {
 
 // src/prompts/prompt-manifest-store.ts
 init_atomic_write();
-import * as fs56 from "node:fs/promises";
-import * as path116 from "node:path";
+import * as fs57 from "node:fs/promises";
+import * as path117 from "node:path";
 var PromptManifestStore = class {
   constructor(manifestPath) {
     this.manifestPath = manifestPath;
@@ -87660,7 +88015,7 @@ var PromptManifestStore = class {
   manifestPath;
   async load() {
     try {
-      const raw = JSON.parse(await fs56.readFile(this.manifestPath, "utf8"));
+      const raw = JSON.parse(await fs57.readFile(this.manifestPath, "utf8"));
       if (raw && typeof raw === "object" && Array.isArray(raw.entries)) {
         return { version: 1, entries: raw.entries };
       }
@@ -87669,7 +88024,7 @@ var PromptManifestStore = class {
     return { version: 1, entries: [] };
   }
   async save(data) {
-    await ensureDir(path116.dirname(this.manifestPath));
+    await ensureDir(path117.dirname(this.manifestPath));
     await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2));
   }
   /** Upsert one entry keyed by slug. */
@@ -87692,267 +88047,6 @@ var PromptManifestStore = class {
   }
 };
 
-// src/prompts/prompt-journal.ts
-import * as fs57 from "node:fs/promises";
-import * as path117 from "node:path";
-async function ensureGitignore(projectRoot) {
-  const gitignorePath = path117.join(projectRoot, ".gitignore");
-  try {
-    let content = "";
-    try {
-      content = await fs57.readFile(gitignorePath, "utf8");
-    } catch {
-      content = "";
-    }
-    if (!content.includes(".wrongstack") && !content.includes(".wrongstack/")) {
-      const addition = content.endsWith("\n") || content.length === 0 ? ".wrongstack/\n" : "\n.wrongstack/\n";
-      await fs57.writeFile(gitignorePath, content + addition, "utf8");
-    }
-  } catch {
-  }
-}
-async function recordPromptJournalEntry(opts) {
-  const now = /* @__PURE__ */ new Date();
-  const timestamp = now.toISOString();
-  const dateStr = timestamp.slice(0, 10);
-  const monthStr = dateStr.slice(0, 7);
-  const sessionId = opts.sessionId && opts.sessionId.trim() ? opts.sessionId.trim() : "general";
-  const id = `pmt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-  const content = opts.content ?? "";
-  const lines = content.split("\n");
-  const characterCount = content.length;
-  const lineCount2 = lines.length;
-  const tokenEstimate = Math.ceil(characterCount / 4);
-  const entry = {
-    id,
-    timestamp,
-    sessionId,
-    projectRoot: opts.projectRoot,
-    role: opts.role ?? (opts.category === "system_prompt" ? "system" : "user"),
-    category: opts.category,
-    content,
-    rawContent: opts.rawContent,
-    metadata: {
-      model: opts.model,
-      provider: opts.provider,
-      iterationIndex: opts.iterationIndex,
-      tokenEstimate,
-      characterCount,
-      lineCount: lineCount2,
-      activeTools: opts.activeTools,
-      contextFiles: opts.contextFiles,
-      durationMs: opts.durationMs,
-      decisionReason: opts.decisionReason,
-      tags: opts.tags
-    }
-  };
-  const basePromptsDir = path117.join(opts.projectRoot, ".wrongstack", "prompts");
-  const dayDir = path117.join(basePromptsDir, monthStr, dateStr);
-  try {
-    await fs57.mkdir(dayDir, { recursive: true });
-    await ensureGitignore(opts.projectRoot);
-    const sessionJsonlFile = path117.join(dayDir, `session-${sessionId}.jsonl`);
-    await fs57.appendFile(sessionJsonlFile, JSON.stringify(entry) + "\n", "utf8");
-    const sessionMdFile = path117.join(dayDir, `session-${sessionId}.md`);
-    const mdSection = formatEntryMarkdown(entry);
-    await fs57.appendFile(sessionMdFile, mdSection, "utf8");
-    const dailySummaryFile = path117.join(dayDir, "daily-summary.md");
-    await updateDailySummary(dailySummaryFile, dateStr, entry);
-    await updateRootCatalog(basePromptsDir, monthStr, dateStr, sessionId, entry);
-  } catch (err) {
-    console.error?.(`Failed to write hierarchical prompt journal: ${err}`);
-  }
-  return entry;
-}
-function formatEntryMarkdown(entry) {
-  const tagList = [
-    `**Category:** \`${entry.category}\``,
-    `**Role:** \`${entry.role}\``,
-    entry.metadata.model ? `**Model:** \`${entry.metadata.model}\`` : null,
-    `**Tokens (est):** ~${entry.metadata.tokenEstimate}`,
-    entry.metadata.iterationIndex !== void 0 ? `**Iteration:** #${entry.metadata.iterationIndex}` : null,
-    `**Session:** \`${entry.sessionId}\``
-  ].filter(Boolean).join(" | ");
-  let md = `
-### \u{1F4DD} [${entry.timestamp}] \`${entry.id}\`
-${tagList}
-
-`;
-  if (entry.metadata.decisionReason) {
-    md += `> **Rationale:** ${entry.metadata.decisionReason}
-
-`;
-  }
-  if (entry.metadata.activeTools && entry.metadata.activeTools.length > 0) {
-    md += `*Active Tools:* \`${entry.metadata.activeTools.join("`, `")}\`
-
-`;
-  }
-  if (entry.rawContent && entry.rawContent !== entry.content) {
-    md += `**Raw Input:**
-\`\`\`text
-${entry.rawContent.trim()}
-\`\`\`
-
-`;
-    md += `**Refined / Injected Prompt:**
-\`\`\`text
-${entry.content.trim()}
-\`\`\`
-
-`;
-  } else {
-    md += `**Prompt Content:**
-\`\`\`text
-${entry.content.trim()}
-\`\`\`
-
-`;
-  }
-  md += `---
-`;
-  return md;
-}
-async function updateDailySummary(summaryFile, dateStr, entry) {
-  try {
-    let content = "";
-    try {
-      content = await fs57.readFile(summaryFile, "utf8");
-    } catch {
-      content = `# \u{1F4C5} Daily Prompt Summary \u2014 ${dateStr}
-
-| Time | ID | Session | Category | Model | Tokens | Rationale |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-`;
-    }
-    const time = entry.timestamp.slice(11, 19);
-    const model = entry.metadata.model ?? "-";
-    const reason = entry.metadata.decisionReason ? entry.metadata.decisionReason.slice(0, 40) : "-";
-    const row = `| ${time} | [\`${entry.id}\`](session-${entry.sessionId}.md) | \`${entry.sessionId}\` | \`${entry.category}\` | ${model} | ~${entry.metadata.tokenEstimate} | ${reason} |
-`;
-    await fs57.writeFile(summaryFile, content + row, "utf8");
-  } catch {
-  }
-}
-async function updateRootCatalog(baseDir2, monthStr, dateStr, sessionId, entry) {
-  const indexJsonFile = path117.join(baseDir2, "index.json");
-  const indexMdFile = path117.join(baseDir2, "index.md");
-  let catalog;
-  try {
-    const raw = await fs57.readFile(indexJsonFile, "utf8");
-    catalog = JSON.parse(raw);
-  } catch {
-    catalog = {
-      updatedAt: entry.timestamp,
-      totalPrompts: 0,
-      totalTokensEstimated: 0,
-      months: {}
-    };
-  }
-  catalog.updatedAt = entry.timestamp;
-  catalog.totalPrompts += 1;
-  catalog.totalTokensEstimated += entry.metadata.tokenEstimate;
-  if (!catalog.months[monthStr]) {
-    catalog.months[monthStr] = { days: {} };
-  }
-  const monthData = catalog.months[monthStr];
-  if (!monthData.days[dateStr]) {
-    monthData.days[dateStr] = { sessions: {} };
-  }
-  const dayData = monthData.days[dateStr];
-  if (!dayData.sessions[sessionId]) {
-    dayData.sessions[sessionId] = {
-      promptCount: 0,
-      tokenEstimate: 0,
-      lastTimestamp: entry.timestamp,
-      categories: {}
-    };
-  }
-  const sessionData = dayData.sessions[sessionId];
-  sessionData.promptCount += 1;
-  sessionData.tokenEstimate += entry.metadata.tokenEstimate;
-  sessionData.lastTimestamp = entry.timestamp;
-  sessionData.categories[entry.category] = (sessionData.categories[entry.category] ?? 0) + 1;
-  try {
-    await fs57.writeFile(indexJsonFile, JSON.stringify(catalog, null, 2), "utf8");
-    let md = `# \u{1F5C2}\uFE0F Prompt Journal Navigation Index
-
-`;
-    md += `* **Total Prompts Logged:** ${catalog.totalPrompts}
-`;
-    md += `* **Total Tokens (est):** ~${catalog.totalTokensEstimated.toLocaleString()}
-`;
-    md += `* **Last Recorded Activity:** ${catalog.updatedAt}
-
-`;
-    md += `## \u{1F4C5} Recorded Dates & Sessions
-
-`;
-    md += `| Date | Session | Prompts | Tokens (est) | Daily Log | Session Log |
-`;
-    md += `| :--- | :--- | :--- | :--- | :--- | :--- |
-`;
-    for (const [m, mObj] of Object.entries(catalog.months).sort().reverse()) {
-      for (const [d, dObj] of Object.entries(mObj.days).sort().reverse()) {
-        for (const [sId, sData] of Object.entries(dObj.sessions)) {
-          const dailyLink = `[daily-summary.md](./${m}/${d}/daily-summary.md)`;
-          const sessionLink = `[session-${sId}.md](./${m}/${d}/session-${sId}.md)`;
-          md += `| **${d}** | \`${sId}\` | ${sData.promptCount} | ~${sData.tokenEstimate.toLocaleString()} | ${dailyLink} | ${sessionLink} |
-`;
-        }
-      }
-    }
-    await fs57.writeFile(indexMdFile, md, "utf8");
-  } catch {
-  }
-}
-async function getPromptJournalEntries(projectRoot, filter = {}) {
-  const basePromptsDir = path117.join(projectRoot, ".wrongstack", "prompts");
-  const results = [];
-  try {
-    const months = await fs57.readdir(basePromptsDir);
-    for (const month of months) {
-      if (!/^\d{4}-\d{2}$/.test(month)) continue;
-      if (filter.month && filter.month !== month) continue;
-      const monthDir = path117.join(basePromptsDir, month);
-      const days = await fs57.readdir(monthDir);
-      for (const day of days) {
-        if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
-        if (filter.date && filter.date !== day) continue;
-        const dayDir = path117.join(monthDir, day);
-        const files = await fs57.readdir(dayDir);
-        const jsonlFiles = files.filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"));
-        for (const jsonlFile of jsonlFiles) {
-          const sessionMatch = jsonlFile.match(/^session-(.+)\.jsonl$/);
-          const sId = sessionMatch ? sessionMatch[1] : void 0;
-          if (filter.sessionId && sId !== filter.sessionId) continue;
-          const filePath = path117.join(dayDir, jsonlFile);
-          const content = await fs57.readFile(filePath, "utf8");
-          const lines = content.split("\n");
-          for (const line of lines) {
-            if (!line.trim()) continue;
-            try {
-              const entry = JSON.parse(line);
-              if (filter.sessionId && entry.sessionId !== filter.sessionId) continue;
-              if (filter.category && entry.category !== filter.category) continue;
-              if (filter.since && entry.timestamp < filter.since) continue;
-              results.push(entry);
-            } catch {
-            }
-          }
-        }
-      }
-    }
-  } catch {
-    return [];
-  }
-  results.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-  if (filter.limit && results.length > filter.limit) {
-    return results.slice(-filter.limit);
-  }
-  return results;
-}
-
 // src/registry/provider-registry.ts
 var ProviderRegistry = class {
   factories = /* @__PURE__ */ new Map();
@@ -97238,6 +97332,7 @@ export {
   PROJECT_ID_PREFIX,
   PROMETHEUS_CONTENT_TYPE,
   PROMPT_CATEGORY_LABELS,
+  PROMPT_JOURNAL_RAW_MARKER,
   PROVIDER_KEY_SET_TOOL_NAME,
   PROVIDER_MANAGE_TOOL_NAME,
   ParallelEternalEngine,