flavor-code 1.4.3-beta.2 → 1.4.3

package/dist/desktop/main.js

@@ -1,8 +1,8 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
 import { createHash as createHash29, randomUUID as randomUUID29 } from "crypto";
-import { readFile as readFile41, stat as stat20, writeFile as writeFile19 } from "fs/promises";
-import { basename as basename12, dirname as dirname23, join as join51, resolve as resolve43 } from "path";
+import { readFile as readFile42, stat as stat20, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename12, dirname as dirname23, join as join52, resolve as resolve43 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { app, BrowserWindow as BrowserWindow2, clipboard, dialog, ipcMain, Menu, nativeImage, Notification, shell } from "electron";
 
@@ -262,6 +262,9 @@ var FlavorConfigSchema = z2.object({
   skills: z2.object({
     disabled: z2.array(SkillNameSchema).max(1e3).default([])
   }).prefault({}),
+  globalInstructions: z2.object({
+    enabled: z2.boolean().default(true)
+  }).prefault({}),
   agents: z2.object({
     main: z2.object({ model: z2.string() }).optional(),
     subagent: z2.object({ model: z2.string() }).optional()
@@ -2326,6 +2329,34 @@ async function updateProtectedFile(options) {
     return next;
   }, options.lockTimeoutMs ?? LOCK_TIMEOUT_MS, options.staleLockMs ?? STALE_LOCK_MS);
 }
+async function updatePlainTextFile(path, update, maxBytes) {
+  await mkdir2(dirname(path), { recursive: true, mode: 448 });
+  return withFileLock(path, async () => {
+    const current = await readOptionalPlainText(path, maxBytes);
+    const next = await update(current);
+    if (next === void 0 || next === current) return current;
+    if (await readOptionalPlainText(path, maxBytes) !== current) {
+      throw new Error(`Text file changed while the update was prepared: ${path}`);
+    }
+    await writeAtomic(path, next, defaultFileOperations);
+    return next;
+  }, LOCK_TIMEOUT_MS, STALE_LOCK_MS);
+}
+async function readOptionalPlainText(path, maxBytes) {
+  try {
+    if (maxBytes !== void 0 && (await stat(path)).size > maxBytes) {
+      throw new Error(`Text file exceeds ${maxBytes} bytes: ${path}`);
+    }
+    const bytes = await readFile(path);
+    if (maxBytes !== void 0 && bytes.length > maxBytes) {
+      throw new Error(`Text file exceeds ${maxBytes} bytes: ${path}`);
+    }
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch (error) {
+    if (isCode2(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
 async function withFileLock(path, operation, lockTimeoutMs, staleLockMs) {
   const lockPath = `${path}.lock`;
   const token = JSON.stringify({ pid: process.pid, nonce: randomUUID3() });
@@ -7132,11 +7163,11 @@ function createElectronBrowserHost(options) {
 }
 
 // src/production.ts
-import { readFile as readFile29 } from "fs/promises";
+import { readFile as readFile30 } from "fs/promises";
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createHash as createHash22, randomUUID as randomUUID25 } from "crypto";
 import { homedir as homedir3, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename9, dirname as dirname22, join as join38, relative as relative25, resolve as resolve36, sep as sep25 } from "path";
+import { basename as basename9, dirname as dirname22, join as join39, relative as relative25, resolve as resolve36, sep as sep25 } from "path";
 import { performance } from "perf_hooks";
 
 // src/agent/subagents.ts
@@ -8267,6 +8298,7 @@ var ContextManager = class _ContextManager {
   #workspaceInstructions;
   #memory;
   #userMemory;
+  #globalInstructions;
   #compactAtChars;
   #toolOutputChars;
   #recentTurns;
@@ -8311,6 +8343,7 @@ var ContextManager = class _ContextManager {
     this.#workspaceInstructions = options.workspaceInstructions;
     this.#memory = options.memory;
     this.#userMemory = options.userMemory;
+    this.#globalInstructions = options.globalInstructions;
     this.#taskState = options.taskState;
     this.#compactAtChars = options.compactAtChars ?? Number.POSITIVE_INFINITY;
     this.#toolOutputChars = options.toolOutputChars;
@@ -8350,6 +8383,7 @@ var ContextManager = class _ContextManager {
       ...this.#memory === void 0 ? {} : { memory: this.#memory },
       ...this.#taskState === void 0 ? {} : { taskState: this.#taskState },
       ...userMemory === void 0 ? {} : { userMemory },
+      ...this.#globalInstructions === void 0 ? {} : { globalInstructions: this.#globalInstructions },
       compactAtChars: this.#compactAtChars,
       toolOutputChars: this.#toolOutputChars,
       compaction: this.#compaction,
@@ -8431,12 +8465,14 @@ var ContextManager = class _ContextManager {
     for (const key of DYNAMIC_SOURCE_ORDER) {
       const value = next[key];
       if (value === void 0 || value === this.#epoch.sources[key]) continue;
-      updates.push(contextUpdateMessage(key, deltaSourceValue(this.#epoch.sources[key], displaySourceValue(key, value))));
+      const display = key === "global-instructions" ? this.#epoch.sources[key] === void 0 ? value : `These replace all earlier global instructions.
+${value}` : deltaSourceValue(this.#epoch.sources[key], displaySourceValue(key, value));
+      updates.push(contextUpdateMessage(key, display));
       this.#epoch.sources[key] = value;
     }
     for (const key of DYNAMIC_SOURCE_ORDER) {
       if (key in next || !(key in this.#epoch.sources)) continue;
-      updates.push(contextUpdateMessage(key, "(removed)"));
+      updates.push(contextUpdateMessage(key, key === "global-instructions" ? "Global instructions were removed; disregard all earlier global instructions." : "(removed)"));
       delete this.#epoch.sources[key];
     }
     if (updates.length === 0) return false;
@@ -8456,9 +8492,15 @@ var ContextManager = class _ContextManager {
     const legacySummary = snapshot4.summary?.role === "system" && snapshot4.summary.content.startsWith("Conversation summary\n") ? snapshot4.summary.content.slice("Conversation summary\n".length) : void 0;
     this.#compact = snapshot4.compact === void 0 ? legacySummary === void 0 ? void 0 : { summary: legacySummary, compactedAt: (/* @__PURE__ */ new Date(0)).toISOString() } : { ...snapshot4.compact };
     if (snapshot4.epoch !== void 0) this.#epoch = cloneEpoch(snapshot4.epoch);
+    const globalInstructions = tryResolveOptionalSystemSections(this.#globalInstructions);
+    const globalInstructionsAbsent = globalInstructions.available && (globalInstructions.sections?.length ?? 0) === 0;
+    if (globalInstructionsAbsent) {
+      delete this.#epoch.sources["global-instructions"];
+      if (this.#epoch.pinnedSources !== void 0) delete this.#epoch.pinnedSources["global-instructions"];
+    }
     this.#visibilityLog = boundVisibilityLog(snapshot4.visibilityLog);
     this.#activeTransientSystem.clear();
-    this.#messages = messages.map((message2) => message2.role === "tool" ? { ...message2, content: truncateToolOutput(message2.content, this.#toolOutputChars) } : cloneMessage2(message2));
+    this.#messages = (globalInstructionsAbsent ? messages.filter((message2) => message2.role !== "system" || !modelContentText(message2.content).startsWith("Context update [global-instructions]\n")) : messages).map((message2) => message2.role === "tool" ? { ...message2, content: truncateToolOutput(message2.content, this.#toolOutputChars) } : cloneMessage2(message2));
     this.#lastRecordedInputTokens = void 0;
     this.#estimatedTokensAtLastRecordedUsage = void 0;
     this.#consecutiveAutoCompactFailures = 0;
@@ -8674,6 +8716,12 @@ ${userMemory}`,
   }
   #resolvedDynamicSources(previous = {}) {
     const result = {};
+    const globalInstructions = tryResolveOptionalSystemSections(this.#globalInstructions);
+    if (!globalInstructions.available && previous["global-instructions"] !== void 0) {
+      result["global-instructions"] = previous["global-instructions"];
+    } else if (globalInstructions.sections !== void 0 && globalInstructions.sections.length > 0) {
+      result["global-instructions"] = globalInstructions.sections.join("\n\n");
+    }
     if (this.#memory !== void 0) result["long-term-memory"] = this.#memory;
     if (this.#taskState !== void 0) result["task-state"] = this.#taskState;
     const volatile = tryResolveOptionalSystemSections(this.#volatileSystem);
@@ -8682,7 +8730,7 @@ ${userMemory}`,
     return result;
   }
 };
-var DYNAMIC_SOURCE_ORDER = ["long-term-memory", "task-state", "runtime"];
+var DYNAMIC_SOURCE_ORDER = ["global-instructions", "long-term-memory", "task-state", "runtime"];
 function sourceMessages(sources) {
   return DYNAMIC_SOURCE_ORDER.flatMap((key) => {
     const content = sources[key];
@@ -8696,7 +8744,7 @@ function sourceMessages(sources) {
       } catch {
       }
     }
-    const label = key === "long-term-memory" ? "Long-term memory" : key === "task-state" ? "Task state" : "Runtime";
+    const label = key === "global-instructions" ? "Global instructions" : key === "long-term-memory" ? "Long-term memory" : key === "task-state" ? "Task state" : "Runtime";
     return [{
       role: "system",
       content: `${label}
@@ -8852,9 +8900,122 @@ function providerValidMessages(input) {
   return output;
 }
 
+// src/context/global-instructions.ts
+import { lstat as lstat2, readFile as readFile6 } from "fs/promises";
+import { join as join7 } from "path";
+var GlobalInstructions = class _GlobalInstructions {
+  static MAX_BYTES = 64 * 1024;
+  static MAX_RULE_BYTES = 4 * 1024;
+  path;
+  #content;
+  constructor(home) {
+    this.path = join7(home, ".flavor-code", "GLOBAL.md");
+  }
+  get content() {
+    return this.#content;
+  }
+  async refresh() {
+    let info;
+    try {
+      info = await lstat2(this.path);
+    } catch (error) {
+      if (isMissing(error)) {
+        this.#content = void 0;
+        return;
+      }
+      throw error;
+    }
+    if (!info.isFile()) throw new Error(`Global instructions must be a regular file: ${this.path}`);
+    if (info.size > _GlobalInstructions.MAX_BYTES) {
+      throw new Error(`Global instructions exceed ${_GlobalInstructions.MAX_BYTES} bytes: ${this.path}`);
+    }
+    const bytes = await readFile6(this.path);
+    if (bytes.length > _GlobalInstructions.MAX_BYTES) {
+      throw new Error(`Global instructions exceed ${_GlobalInstructions.MAX_BYTES} bytes: ${this.path}`);
+    }
+    const content = new TextDecoder("utf-8", { fatal: true }).decode(bytes).trim();
+    this.#content = content || void 0;
+  }
+  async remember(input) {
+    const rule = input.trim();
+    if (!rule || /[\r\n]/u.test(rule)) throw new Error("Global rules must be one non-empty line.");
+    if (Buffer.byteLength(rule, "utf8") > _GlobalInstructions.MAX_RULE_BYTES) {
+      throw new Error(`Global rule exceeds ${_GlobalInstructions.MAX_RULE_BYTES} bytes.`);
+    }
+    let added = false;
+    const next = await updatePlainTextFile(this.path, async (current) => {
+      const exists4 = await regularFileExists(this.path);
+      const base = exists4 ? current ?? "" : "";
+      validateDocument(base);
+      if (ruleLines(base).some((item) => item.text.toLocaleLowerCase() === rule.toLocaleLowerCase())) return base;
+      const eol = base.includes("\r\n") ? "\r\n" : "\n";
+      const nextContent = base.length === 0 ? `# Global instructions${eol}${eol}- ${rule}${eol}` : `${base}${base.endsWith(eol) ? "" : eol}${eol}- ${rule}${eol}`;
+      validateDocument(nextContent);
+      added = true;
+      return nextContent;
+    }, _GlobalInstructions.MAX_BYTES);
+    this.#content = next?.trim() || void 0;
+    return added ? "added" : "already-present";
+  }
+  async forget(input) {
+    const query = input.trim().toLocaleLowerCase();
+    if (!query || /[\r\n]/u.test(query)) throw new Error("Specify one global rule to forget.");
+    if (!await regularFileExists(this.path)) return "not-found";
+    let result = "not-found";
+    const next = await updatePlainTextFile(this.path, async (current) => {
+      if (!await regularFileExists(this.path)) return void 0;
+      const base = current ?? "";
+      validateDocument(base);
+      const entries = ruleLines(base);
+      const exact = entries.filter((entry2) => entry2.text.toLocaleLowerCase() === query);
+      const matches = exact.length > 0 ? exact : entries.filter((entry2) => entry2.text.toLocaleLowerCase().includes(query));
+      if (matches.length === 0) return base;
+      if (matches.length > 1) {
+        result = "ambiguous";
+        return base;
+      }
+      const match = matches[0];
+      result = "removed";
+      const remaining = `${base.slice(0, match.start)}${base.slice(match.end)}`;
+      return remaining.trim() === "# Global instructions" ? "" : remaining;
+    }, _GlobalInstructions.MAX_BYTES);
+    this.#content = next?.trim() || void 0;
+    return result;
+  }
+};
+function ruleLines(content) {
+  return [...content.matchAll(/^[ \t]*[-*+][ \t]+([^\r\n]+)(?:\r?\n|$)/gmu)].map((match) => ({
+    text: match[1].trim(),
+    start: match.index,
+    end: match.index + match[0].length
+  }));
+}
+function validateDocument(content) {
+  if (Buffer.byteLength(content, "utf8") > GlobalInstructions.MAX_BYTES) {
+    throw new Error(`Global instructions exceed ${GlobalInstructions.MAX_BYTES} bytes.`);
+  }
+  return content;
+}
+async function regularFileExists(path) {
+  try {
+    const info = await lstat2(path);
+    if (!info.isFile()) throw new Error(`Global instructions must be a regular file: ${path}`);
+    if (info.size > GlobalInstructions.MAX_BYTES) {
+      throw new Error(`Global instructions exceed ${GlobalInstructions.MAX_BYTES} bytes: ${path}`);
+    }
+    return true;
+  } catch (error) {
+    if (isMissing(error)) return false;
+    throw error;
+  }
+}
+function isMissing(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
 // src/context/workspace-instructions.ts
 import { createHash as createHash5 } from "crypto";
-import { lstat as lstat2, readFile as readFile6, realpath as realpath4 } from "fs/promises";
+import { lstat as lstat3, readFile as readFile7, realpath as realpath4 } from "fs/promises";
 import { dirname as dirname5, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve5, sep as sep4 } from "path";
 var NAMES = ["AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
 var ROOT_NAMES = ["AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
@@ -8914,11 +9075,11 @@ var WorkspaceInstructions = class {
       for (const name of names) {
         const path = resolve5(directory.path, name);
         try {
-          const info = await lstat2(path);
+          const info = await lstat3(path);
           if (!info.isFile() && !info.isSymbolicLink()) continue;
           const physical = await realpath4(path);
           if (!within(physicalRoot, physical)) continue;
-          const bytes = await readFile6(path);
+          const bytes = await readFile7(path);
           const clipped = bytes.subarray(0, this.#maxFileBytes);
           const suffix = bytes.length > clipped.length ? `
 
@@ -8957,7 +9118,7 @@ ${document.content}
 };
 async function directoryForPath(path) {
   try {
-    return (await lstat2(path)).isDirectory() ? path : dirname5(path);
+    return (await lstat3(path)).isDirectory() ? path : dirname5(path);
   } catch {
     return dirname5(path);
   }
@@ -9754,6 +9915,12 @@ var AgentLoop = class {
     }
   }
   async *#runInternal(request) {
+    try {
+      await this.#options.beforeModelCall?.(request.signal);
+    } catch (error) {
+      yield { type: "error", error: normalizeProviderError(error) };
+      return;
+    }
     this.#options.context.refreshContextSources();
     this.#options.context.append(request.initialUserMessage ?? { role: "user", content: request.prompt });
     let totalInputTokens = 0;
@@ -9814,6 +9981,7 @@ var AgentLoop = class {
         return;
       }
       try {
+        await this.#options.beforeModelCall?.(request.signal);
         if (await this.#options.context.prepareForModelCall(request.signal)) yield { type: "compacted" };
       } catch (error) {
         yield { type: "error", error: normalizeProviderError(error) };
@@ -10826,7 +10994,7 @@ function redactClassifierText(value) {
 // src/tools/runtime.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir6, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename3, join as join7, resolve as resolve7 } from "path";
+import { basename as basename3, join as join8, resolve as resolve7 } from "path";
 import { z as z16 } from "zod";
 var DEFAULT_TOOL_OUTPUT_LIMITS = Object.freeze({
   perToolChars: 5e4,
@@ -11148,9 +11316,9 @@ var ToolRuntime = class {
     const reason = perToolExceeded && turnExceeded ? "per_tool_and_turn_limit" : perToolExceeded ? "per_tool_limit" : "turn_limit";
     const preview = headTailPreview(serialized, previewChars);
     this.#turnOutputChars += preview.length;
-    const directory = join7(this.#workspace, ".flavor", "tool-results");
+    const directory = join8(this.#workspace, ".flavor", "tool-results");
     const filename2 = `${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID7()}-${safeFilename(tool)}.txt`;
-    const savedTo = join7(directory, filename2);
+    const savedTo = join8(directory, filename2);
     let storage;
     try {
       await mkdir6(directory, { recursive: true });
@@ -11369,6 +11537,7 @@ var LocalHarness = class {
         ...this.#options.softLimitFactor === void 0 ? {} : { softLimitFactor: this.#options.softLimitFactor },
         ...this.#options.extendIterations === void 0 ? {} : { extendIterations: this.#options.extendIterations },
         ...isMain && this.#options.hasActiveProgress !== void 0 ? { hasActiveProgress: this.#options.hasActiveProgress } : {},
+        ...this.#options.beforeModelCall === void 0 ? {} : { beforeModelCall: this.#options.beforeModelCall },
         ...isMain && this.#options.hallucinationGuard !== void 0 ? { hallucinationGuard: this.#options.hallucinationGuard } : {},
         ...this.#options.modelJournal === void 0 ? {} : { modelJournal: this.#options.modelJournal }
       });
@@ -11398,7 +11567,7 @@ function toModelTool(tool) {
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
 import { closeSync, constants as constants2, existsSync as existsSync2, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
-import { join as join8, relative as relative6, resolve as resolve8, sep as sep6 } from "path";
+import { join as join9, relative as relative6, resolve as resolve8, sep as sep6 } from "path";
 import { z as z17 } from "zod";
 
 // src/harness/invariants.ts
@@ -11488,14 +11657,14 @@ var HarnessJournal = class {
   #records = [];
   constructor(options) {
     const workspace = resolve8(options.workspace);
-    const directory = join8(workspace, ".flavor", "sessions");
+    const directory = join9(workspace, ".flavor", "sessions");
     assertSessionId(options.sessionId);
     mkdirSync(directory, { recursive: true, mode: 448 });
     assertWithin(workspace, directory);
     const canonicalWorkspace = realpathSync2.native(workspace);
     const canonicalDirectory = realpathSync2.native(directory);
     if (!isWithin2(canonicalWorkspace, canonicalDirectory)) throw new Error("Harness journal directory escapes the workspace");
-    this.#path = join8(canonicalDirectory, `${options.sessionId}.events.jsonl`);
+    this.#path = join9(canonicalDirectory, `${options.sessionId}.events.jsonl`);
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
     this.#maxBytes = options.maxBytes ?? MAX_JOURNAL_BYTES;
     if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 1024) throw new Error("maxBytes must be an integer of at least 1024");
@@ -12300,7 +12469,7 @@ function createIncidentReporter(options) {
 import { createHash as createHash7, randomUUID as randomUUID10 } from "crypto";
 import { chmod, unlink as unlink2 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { createServer as createServer2 } from "net";
 var MAX_REQUEST_BYTES = 64 * 1024;
 var SOCKET_TIMEOUT_MS = 1e4;
@@ -12308,7 +12477,7 @@ function islandControlEndpoint(sessionId, platform = process.platform) {
   const digest = createHash7("sha256").update(`${process.pid}\0${sessionId}`).digest("hex").slice(0, 20);
   if (platform === "win32") return `\\\\.\\pipe\\flavor-island-control-${digest}`;
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  return join9(tmpdir(), `flavor-island-control-${uid}-${digest}.sock`);
+  return join10(tmpdir(), `flavor-island-control-${uid}-${digest}.sock`);
 }
 async function createIslandControlServer(options) {
   const platform = options.platform ?? process.platform;
@@ -12435,18 +12604,18 @@ function closeServer(server) {
 // src/evolve/service.ts
 import { spawn as spawn2 } from "child_process";
 import { writeFile as writeFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { z as z21 } from "zod";
 
 // src/evolve/loader.ts
 import { cp as cp2, mkdir as mkdir7, mkdtemp, readdir as readdir3, rm as rm4, stat as stat5, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join10, resolve as resolve11 } from "path";
+import { join as join11, resolve as resolve11 } from "path";
 
 // src/plugins/host.ts
 import { createHash as createHash8 } from "crypto";
 import { lstatSync, realpathSync as realpathSync3 } from "fs";
-import { lstat as lstat3, open as open4, readFile as readFile7, readdir as readdir2, realpath as realpath6, stat as stat4, writeFile as writeFile4 } from "fs/promises";
+import { lstat as lstat4, open as open4, readFile as readFile8, readdir as readdir2, realpath as realpath6, stat as stat4, writeFile as writeFile4 } from "fs/promises";
 import { isAbsolute as isAbsolute7, relative as relative7, resolve as resolve10, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { z as z20 } from "zod";
@@ -12795,7 +12964,7 @@ var PluginHost = class {
   async #readCandidate(inputRoot, source, label = inputRoot) {
     let diagnosticLabel = label;
     try {
-      const rootInfo = await lstat3(inputRoot);
+      const rootInfo = await lstat4(inputRoot);
       if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) throw new Error("Plugin root must be a static directory");
       const root = await realpath6(inputRoot);
       const rawManifest = await readManifest2(resolve10(root, MANIFEST));
@@ -12805,7 +12974,7 @@ var PluginHost = class {
       const manifest = PluginManifestSchema.parse(rawManifest);
       const entry2 = resolveContained(root, manifest.main, "Plugin entry");
       const entrySnapshot = await snapshotEntry(root, entry2);
-      const fingerprint2 = createHash8("sha256").update(JSON.stringify(manifest)).update(await readFile7(entrySnapshot.physicalPath)).digest("hex");
+      const fingerprint2 = createHash8("sha256").update(JSON.stringify(manifest)).update(await readFile8(entrySnapshot.physicalPath)).digest("hex");
       return { manifest, root, source, entry: entry2, entrySnapshot, fingerprint: fingerprint2 };
     } catch (error) {
       this.#diagnose(diagnosticLabel, error, inputRoot);
@@ -13052,7 +13221,7 @@ var PluginHost = class {
   }
 };
 async function readManifest2(path) {
-  const lexical = await lstat3(path, { bigint: true });
+  const lexical = await lstat4(path, { bigint: true });
   if (!lexical.isFile() || lexical.isSymbolicLink()) throw new Error("Plugin manifest must be a static regular file");
   const handle = await open4(path, "r");
   try {
@@ -13069,7 +13238,7 @@ async function readManifest2(path) {
     if (bytesRead > MAX_MANIFEST_BYTES) throw new Error(`Plugin manifest exceeds ${MAX_MANIFEST_BYTES} bytes`);
     const after = fromStats(await handle.stat({ bigint: true }));
     assertSnapshot(before, after, "Plugin manifest");
-    const current = fromStats(await lstat3(path, { bigint: true }));
+    const current = fromStats(await lstat4(path, { bigint: true }));
     assertSnapshot(before, current, "Plugin manifest path");
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytesRead)));
   } finally {
@@ -13077,7 +13246,7 @@ async function readManifest2(path) {
   }
 }
 async function snapshotEntry(root, entry2) {
-  const lexicalStats = await lstat3(entry2, { bigint: true });
+  const lexicalStats = await lstat4(entry2, { bigint: true });
   if (!lexicalStats.isFile() && !lexicalStats.isSymbolicLink()) throw new Error("Plugin entry must be a file");
   const physicalPath = await realpath6(entry2);
   assertContained2(root, physicalPath, "Plugin entry symlink");
@@ -13165,8 +13334,8 @@ function compare(left, right) {
 }
 
 // src/evolve/loader.ts
-var PLUGIN_DIR = join10(".flavor", "plugins");
-var VERSIONS_DIR = join10(".flavor", "plugins", ".versions");
+var PLUGIN_DIR = join11(".flavor", "plugins");
+var VERSIONS_DIR = join11(".flavor", "plugins", ".versions");
 function sanitizePluginName(tool) {
   const base = String(tool ?? "fix").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
   return base.startsWith("fix-") ? base : `fix-${base}`;
@@ -13210,8 +13379,8 @@ export function activate(ctx) {
 async function scaffoldFixPlugin(workspace, name) {
   const dir = fixPluginDir(workspace, name);
   await mkdir7(dir, { recursive: true });
-  const manifestPath = join10(dir, "flavor-plugin.json");
-  const entryPath = join10(dir, "index.js");
+  const manifestPath = join11(dir, "flavor-plugin.json");
+  const entryPath = join11(dir, "index.js");
   try {
     await writeFile5(manifestPath, SCAFFOLD_MANIFEST(name), { encoding: "utf8", flag: "wx" });
     await writeFile5(entryPath, SCAFFOLD_ENTRY(name), { encoding: "utf8", flag: "wx" });
@@ -13231,9 +13400,9 @@ async function verifyFixPlugin(workspace, name) {
     return { ok: false, provided: [], tools: [], commands: [], error: `Plugin "${name}" not found.` };
   }
   const collected = { tools: [], commands: [] };
-  const sandbox = await mkdtemp(join10(tmpdir2(), "flavor-evolve-verify-"));
+  const sandbox = await mkdtemp(join11(tmpdir2(), "flavor-evolve-verify-"));
   try {
-    await cp2(pluginRoot, join10(sandbox, name), { recursive: true });
+    await cp2(pluginRoot, join11(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
       sandbox: true,
@@ -13284,7 +13453,7 @@ async function verifyFixPlugin(workspace, name) {
 }
 async function snapshotFixPlugin(workspace, name) {
   const pluginRoot = fixPluginDir(workspace, name);
-  const snapshotRoot = join10(versionsDirFor(workspace, name), timestamp());
+  const snapshotRoot = join11(versionsDirFor(workspace, name), timestamp());
   await mkdir7(snapshotRoot, { recursive: true });
   await cp2(pluginRoot, snapshotRoot, { recursive: true });
   return snapshotRoot;
@@ -13305,7 +13474,7 @@ async function revertFixPlugin(workspace, name) {
   }
   const snapshots = entries.filter((entry2) => !entry2.startsWith(".")).sort();
   if (snapshots.length === 0) throw new Error(`Plugin "${name}" has no snapshot to restore.`);
-  const latest = join10(versionsRoot, snapshots[snapshots.length - 1]);
+  const latest = join11(versionsRoot, snapshots[snapshots.length - 1]);
   await rm4(pluginRoot, { recursive: true, force: true });
   await mkdir7(pluginRoot, { recursive: true });
   await cp2(latest, pluginRoot, { recursive: true });
@@ -13314,8 +13483,8 @@ async function revertFixPlugin(workspace, name) {
 
 // src/evolve/store.ts
 import { createHash as createHash9 } from "crypto";
-import { appendFile, mkdir as mkdir8, readFile as readFile8, rm as rm5, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname8, join as join11 } from "path";
+import { appendFile, mkdir as mkdir8, readFile as readFile9, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join12 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
@@ -13328,7 +13497,7 @@ function argKeys(args) {
 }
 async function readJsonLines(file) {
   try {
-    const text = await readFile8(file, "utf8");
+    const text = await readFile9(file, "utf8");
     const records = [];
     for (const line of text.split("\n")) {
       const trimmed = line.trim();
@@ -13351,7 +13520,7 @@ async function writeJsonLines(file, records) {
 }
 async function readJsonArray(file) {
   try {
-    const parsed = JSON.parse(await readFile8(file, "utf8"));
+    const parsed = JSON.parse(await readFile9(file, "utf8"));
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
   } catch {
     return [];
@@ -13359,7 +13528,7 @@ async function readJsonArray(file) {
 }
 async function readRules(file) {
   try {
-    const parsed = JSON.parse(await readFile8(file, "utf8"));
+    const parsed = JSON.parse(await readFile9(file, "utf8"));
     if (!Array.isArray(parsed)) return [];
     return parsed.filter((item) => item !== null && typeof item === "object").filter((item) => typeof item.id === "string" && typeof item.text === "string").map((item) => ({
       id: item.id,
@@ -13388,12 +13557,12 @@ var EvolveStore = class {
   #queue = Promise.resolve();
   constructor(options) {
     const { workspace, maxSignals = 400, maxRules = 20 } = options;
-    this.dir = join11(workspace, ".flavor", "evolve");
-    this.signalsFile = join11(this.dir, "signals.jsonl");
-    this.reflectionsFile = join11(this.dir, "reflections.jsonl");
-    this.doneFile = join11(this.dir, "done.json");
-    this.verifiedFile = join11(this.dir, "verified.json");
-    this.rulesFile = join11(this.dir, "rules.json");
+    this.dir = join12(workspace, ".flavor", "evolve");
+    this.signalsFile = join12(this.dir, "signals.jsonl");
+    this.reflectionsFile = join12(this.dir, "reflections.jsonl");
+    this.doneFile = join12(this.dir, "done.json");
+    this.verifiedFile = join12(this.dir, "verified.json");
+    this.rulesFile = join12(this.dir, "rules.json");
     this.maxSignals = maxSignals;
     this.maxRules = maxRules;
   }
@@ -13936,7 +14105,7 @@ function createEvolveService(options) {
         if (suggestion === void 0) return `No open suggestion with id "${suggestionId}". Use /evolve suggest to list them.`;
         const name = sanitizePluginName(suggestion.tool);
         const dir = await scaffoldFixPlugin(workspace, name);
-        await writeFile7(join12(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
+        await writeFile7(join13(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
         await snapshotFixPlugin(workspace, name);
         return [
           `suggestion ${suggestion.id}: ${suggestion.tool} x${suggestion.count} \u2014 ${suggestion.error}`,
@@ -14009,7 +14178,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
         name: "evolve_improve",
         description: "Implement a fix for one repeated tool failure. Default kind=plugin scaffolds the fix-<tool>/ plugin dir and writes PLAN.md with instructions for implementing, verifying, reloading, and testing it. kind=prompt_rule instead stores a concise guardrail rule (from `implementation`) that is injected into future system prompts and closes the suggestion. Use when the model proposes a concrete fix for a suggestion in the system prompt.",
         inputSchema,
-        paths: (input) => [join12(workspace, ".flavor", "evolve"), ...input.kind === "prompt_rule" ? [] : [join12(workspace, ".flavor", "plugins")]],
+        paths: (input) => [join13(workspace, ".flavor", "evolve"), ...input.kind === "prompt_rule" ? [] : [join13(workspace, ".flavor", "plugins")]],
         execute: async (input, signal) => {
           signal.throwIfAborted();
           const { suggestionId, implementation, kind } = input;
@@ -14029,7 +14198,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
           }
           const name = sanitizePluginName(suggestion.tool);
           const dir = await scaffoldFixPlugin(workspace, name);
-          await writeFile7(join12(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
+          await writeFile7(join13(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
           await snapshotFixPlugin(workspace, name);
           return [
             `Scaffolded fix plugin at ${dir} for suggestion [${suggestion.id}] (${suggestion.tool} x${suggestion.count}).`,
@@ -14052,8 +14221,8 @@ ${result.stderr.slice(-4e3)}` : ""}`;
 }
 
 // src/init/project.ts
-import { lstat as lstat4, mkdir as mkdir9, readdir as readdir4, readFile as readFile9, realpath as realpath7, writeFile as writeFile8 } from "fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute8, join as join13, relative as relative8, sep as sep8 } from "path";
+import { lstat as lstat5, mkdir as mkdir9, readdir as readdir4, readFile as readFile10, realpath as realpath7, writeFile as writeFile8 } from "fs/promises";
+import { basename as basename4, isAbsolute as isAbsolute8, join as join14, relative as relative8, sep as sep8 } from "path";
 var GENERATED_START = "<!-- flavor-code:start -->";
 var GENERATED_END = "<!-- flavor-code:end -->";
 var MAX_MANIFEST_BYTES2 = 1e6;
@@ -14106,7 +14275,7 @@ function isContainedPath(root, candidate) {
 }
 async function pathKind(path, root) {
   try {
-    const details = await lstat4(path);
+    const details = await lstat5(path);
     if (details.isSymbolicLink() || !isContainedPath(root, await realpath7(path))) return void 0;
     if (details.isFile()) return "file";
     if (details.isDirectory()) return "directory";
@@ -14120,14 +14289,14 @@ function isMissingPathError(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 async function readTextIfSmall(path, root) {
-  const details = await lstat4(path).catch((error) => {
+  const details = await lstat5(path).catch((error) => {
     if (isMissingPathError(error)) return void 0;
     throw error;
   });
   if (details === void 0 || !details.isFile() || details.isSymbolicLink() || details.size > MAX_MANIFEST_BYTES2 || !isContainedPath(root, await realpath7(path))) {
     return void 0;
   }
-  return readFile9(path, "utf8");
+  return readFile10(path, "utf8");
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14174,7 +14343,7 @@ async function sampleSourceExtensions(cwd, root, directories) {
   const extensions = /* @__PURE__ */ new Set();
   const sampleDirectories = ["", ...directories].slice(0, 12);
   for (const relativeDirectory of sampleDirectories) {
-    const absoluteDirectory = join13(cwd, relativeDirectory);
+    const absoluteDirectory = join14(cwd, relativeDirectory);
     if (!isContainedPath(root, await realpath7(absoluteDirectory))) continue;
     let entries;
     try {
@@ -14195,15 +14364,15 @@ async function inspectProject(cwd) {
   const root = await realpath7(cwd);
   const sourceDirectories = [];
   for (const directory of SOURCE_DIRECTORIES) {
-    if (await pathKind(join13(cwd, directory), root) === "directory") sourceDirectories.push(directory);
+    if (await pathKind(join14(cwd, directory), root) === "directory") sourceDirectories.push(directory);
   }
   const instructionFiles = [];
   for (const file of INSTRUCTION_FILES) {
-    if (await pathKind(join13(cwd, file), root) === "file") instructionFiles.push(file);
+    if (await pathKind(join14(cwd, file), root) === "file") instructionFiles.push(file);
   }
   const configFiles = [];
   for (const file of CONFIG_FILES) {
-    if (await pathKind(join13(cwd, file), root) === "file") configFiles.push(file);
+    if (await pathKind(join14(cwd, file), root) === "file") configFiles.push(file);
   }
   const manifestNames = [
     "package.json",
@@ -14216,7 +14385,7 @@ async function inspectProject(cwd) {
   ];
   const present = /* @__PURE__ */ new Set();
   for (const manifest of manifestNames) {
-    if (await pathKind(join13(cwd, manifest), root) === "file") present.add(manifest);
+    if (await pathKind(join14(cwd, manifest), root) === "file") present.add(manifest);
   }
   const detectedLockfiles = JAVASCRIPT_LOCKFILES.filter(({ name }) => present.has(name));
   const detectedJsManagers = [
@@ -14242,7 +14411,7 @@ async function inspectProject(cwd) {
   let projectName = sanitizeProjectName(basename4(cwd)) ?? "project";
   let declaredJsManager;
   if (present.has("package.json")) {
-    const text = await readTextIfSmall(join13(cwd, "package.json"), root);
+    const text = await readTextIfSmall(join14(cwd, "package.json"), root);
     if (text === void 0) {
       cautions.push("package.json was too large to inspect; its scripts were ignored.");
     } else {
@@ -14296,8 +14465,8 @@ async function inspectProject(cwd) {
   addScriptCommand(testCommands, scripts, jsManager, ["test"]);
   addScriptCommand(lintCommands, scripts, jsManager, ["lint"]);
   addScriptCommand(formatCommands, scripts, jsManager, ["format", "format:check"]);
-  const pyproject = present.has("pyproject.toml") ? await readTextIfSmall(join13(cwd, "pyproject.toml"), root) : void 0;
-  const requirements = present.has("requirements.txt") ? await readTextIfSmall(join13(cwd, "requirements.txt"), root) : void 0;
+  const pyproject = present.has("pyproject.toml") ? await readTextIfSmall(join14(cwd, "pyproject.toml"), root) : void 0;
+  const requirements = present.has("requirements.txt") ? await readTextIfSmall(join14(cwd, "requirements.txt"), root) : void 0;
   const pythonTools = detectPythonTools(pyproject, requirements, configFiles);
   const pythonManager = pythonManagers[0];
   const pythonPrefix = pythonManager === "uv" ? "uv run " : pythonManager === "poetry" ? "poetry run " : pythonManager === "pipenv" ? "pipenv run " : "";
@@ -14315,8 +14484,8 @@ async function inspectProject(cwd) {
   if (present.has("pyproject.toml") || present.has("requirements.txt") || extensions.has("py")) {
     languages.add("Python");
   }
-  const gitignorePath = await pathKind(join13(cwd, ".gitignore"), root) === "file" ? ".gitignore" : void 0;
-  const hasCodeGraph = await pathKind(join13(cwd, ".flavor", "astgraph", "index.db"), root) === "file";
+  const gitignorePath = await pathKind(join14(cwd, ".gitignore"), root) === "file" ? ".gitignore" : void 0;
+  const hasCodeGraph = await pathKind(join14(cwd, ".flavor", "astgraph", "index.db"), root) === "file";
   return {
     cwd,
     projectName,
@@ -14425,12 +14594,12 @@ function isEntryIgnored(lines, entry2) {
   });
 }
 async function addSessionsToGitignore(cwd) {
-  const path = join13(cwd, ".gitignore");
+  const path = join14(cwd, ".gitignore");
   const root = await realpath7(cwd);
   await assertSafeManagedPath(path, root);
   let existing;
   try {
-    existing = await readFile9(path, "utf8");
+    existing = await readFile10(path, "utf8");
   } catch (error) {
     if (!isMissingPathError(error)) throw error;
     existing = "";
@@ -14445,7 +14614,7 @@ async function addSessionsToGitignore(cwd) {
 }
 async function assertSafeManagedPath(path, root) {
   try {
-    const details = await lstat4(path);
+    const details = await lstat5(path);
     if (details.isSymbolicLink()) {
       throw new Error(`Refusing to overwrite managed file symbolic link: ${path}`);
     }
@@ -14459,9 +14628,9 @@ async function assertSafeManagedPath(path, root) {
 }
 async function ensureFlavorDirectories(cwd) {
   const root = await realpath7(cwd);
-  const sessionsDir = join13(cwd, ".flavor", "sessions");
-  const skillsDir = join13(cwd, ".flavor", "skills");
-  const pluginsDir = join13(cwd, ".flavor", "plugins");
+  const sessionsDir = join14(cwd, ".flavor", "sessions");
+  const skillsDir = join14(cwd, ".flavor", "skills");
+  const pluginsDir = join14(cwd, ".flavor", "plugins");
   await mkdir9(sessionsDir, { recursive: true, mode: 448 });
   await mkdir9(skillsDir, { recursive: true, mode: 448 });
   await mkdir9(pluginsDir, { recursive: true, mode: 448 });
@@ -14474,11 +14643,11 @@ async function ensureFlavorDirectories(cwd) {
   }
 }
 async function createExampleFlavorConfig(cwd) {
-  const configPath = join13(cwd, ".flavor", "flavor.json");
+  const configPath = join14(cwd, ".flavor", "flavor.json");
   const root = await realpath7(cwd);
   await assertSafeManagedPath(configPath, root);
   try {
-    await lstat4(configPath);
+    await lstat5(configPath);
     return;
   } catch (error) {
     if (!isMissingPathError(error)) throw error;
@@ -14509,12 +14678,12 @@ async function initializeFlavor(cwd) {
   await ensureFlavorDirectories(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
-  const path = join13(cwd, "FLAVOR.md");
+  const path = join14(cwd, "FLAVOR.md");
   const root = await realpath7(cwd);
   await assertSafeManagedPath(path, root);
   let existing;
   try {
-    existing = await readFile9(path, "utf8");
+    existing = await readFile10(path, "utf8");
   } catch (error) {
     if (!isMissingPathError(error)) throw error;
   }
@@ -14527,7 +14696,7 @@ async function initializeFlavor(cwd) {
 }
 
 // src/utils/memory-restart.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var MEMORY_RESTART_EXIT_CODE = 75;
 var MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
 var MEMORY_RESTART_WINDOW_MS = 60 * 60 * 1e3;
@@ -14544,7 +14713,7 @@ function clearMemoryRotation() {
   rotationActive = false;
 }
 function memoryRestartMarkerPath(workspace) {
-  return join14(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+  return join15(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
 }
 function nextMemoryRestartMarker(previous, sessionId, now, continuation) {
   const previousWindowStart = previous?.windowStartedAt ?? previous?.requestedAt;
@@ -15078,7 +15247,7 @@ ${cycle.verification.summary}` !== signature) break;
 // src/goal/orchestrator.ts
 import { createHash as createHash11 } from "crypto";
 import { writeFile as writeFile9, mkdir as mkdir10 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/goal/types.ts
 import { z as z23 } from "zod";
@@ -15249,8 +15418,8 @@ function extractJson(text) {
 
 // src/goal/classifier.ts
 import { createHash as createHash10 } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join16 } from "path";
 function buildSkepticPrompt(evidence, plan, index) {
   const criteriaList = plan.criteria.map((c) => `  ${c.id}. [${c.type}] ${c.description}`).join("\n");
   return [
@@ -15429,10 +15598,10 @@ function computeFingerprint(gaps) {
 }
 async function collectEvidence(workspace, objective, finalResponse, priorGaps, contractHash2 = createHash10("sha256").update(objective).digest("hex"), hostVerification) {
   const workspaceState = await collectWorkspaceState(workspace);
-  const planPath2 = join15(workspace, ".flavor", "goal-plan.md");
+  const planPath2 = join16(workspace, ".flavor", "goal-plan.md");
   let planFile = null;
   try {
-    planFile = await readFile10(planPath2, "utf8");
+    planFile = await readFile11(planPath2, "utf8");
   } catch {
   }
   return {
@@ -15801,8 +15970,8 @@ function waitForStageRetry(delayMs, signal) {
   });
 }
 async function writePlanFile(workspace, plan) {
-  const dir = join16(workspace, ".flavor");
-  const planPath2 = join16(dir, "goal-plan.md");
+  const dir = join17(workspace, ".flavor");
+  const planPath2 = join17(dir, "goal-plan.md");
   await mkdir10(dir, { recursive: true });
   const criteriaText = plan.criteria.map((c) => `- [${c.type}] AC-${c.id}: ${c.description}`).join("\n");
   const content = [
@@ -15879,8 +16048,8 @@ function formatPriorGaps(gaps) {
 // src/goal/store.ts
 import { constants as constants4 } from "fs";
 import { randomUUID as randomUUID11 } from "crypto";
-import { lstat as lstat5, mkdir as mkdir11, open as open5, readFile as readFile11, rename as rename4, rm as rm6, stat as stat6 } from "fs/promises";
-import { dirname as dirname9, join as join17, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
+import { lstat as lstat6, mkdir as mkdir11, open as open5, readFile as readFile12, rename as rename4, rm as rm6, stat as stat6 } from "fs/promises";
+import { dirname as dirname9, join as join18, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -15888,7 +16057,7 @@ var GoalStore = class {
   #maxBytes;
   constructor(options) {
     this.#workspace = resolve12(options.workspace);
-    this.#root = join17(this.#workspace, ".flavor", "goals");
+    this.#root = join18(this.#workspace, ".flavor", "goals");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   }
   async save(input) {
@@ -15896,13 +16065,13 @@ var GoalStore = class {
     await assertNoSymlink(this.#workspace, dirname9(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join17(this.#root, `${state.id}.json`);
+    const target = join18(this.#root, `${state.id}.json`);
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) {
       throw new Error(`Goal state exceeds maximum size of ${this.#maxBytes} bytes`);
     }
-    const temporary = join17(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
+    const temporary = join18(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open5(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
@@ -15923,13 +16092,13 @@ var GoalStore = class {
     }
     await assertNoSymlink(this.#workspace, dirname9(this.#root));
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join17(this.#root, `${goalId}.json`);
+    const target = join18(this.#root, `${goalId}.json`);
     try {
       const metadata = await stat6(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) {
         throw new Error("Goal state is not a bounded regular file");
       }
-      const raw = await readFile11(target, "utf8");
+      const raw = await readFile12(target, "utf8");
       return GoalStateSchema.parse(JSON.parse(raw));
     } catch (error) {
       if (isCode4(error, "ENOENT")) throw new Error(`Goal "${goalId}" was not found`);
@@ -15953,7 +16122,7 @@ async function assertNoSymlink(root, target) {
   }
   for (const path of chain.reverse()) {
     try {
-      if ((await lstat5(path)).isSymbolicLink()) throw new Error(`Goal path contains a symbolic link: ${path}`);
+      if ((await lstat6(path)).isSymbolicLink()) throw new Error(`Goal path contains a symbolic link: ${path}`);
     } catch (error) {
       if (!isCode4(error, "ENOENT")) throw error;
     }
@@ -15964,8 +16133,8 @@ function isCode4(error, code) {
 }
 
 // src/loop/isolation.ts
-import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile12 } from "fs/promises";
-import { join as join18, resolve as resolve13 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile13 } from "fs/promises";
+import { join as join19, resolve as resolve13 } from "path";
 var CODE_CHANGE = /\b(?:fix|implement|add|update|change|modify|refactor|build|create|remove|delete|write|migrate)\b|修复|实现|添加|更新|修改|重构|创建|删除|迁移/i;
 var READ_ONLY = /\b(?:review|analy[sz]e|inspect|explain|research|investigate|audit|summari[sz]e|report)\b|调研|分析|审查|检查|解释|研究|总结|报告/i;
 function inferGoalIntent(goal) {
@@ -15988,8 +16157,8 @@ async function prepareLoopWorkspace(options) {
     return { kind: "needs_human", reason: "The workspace has uncommitted changes that a new worktree would omit." };
   }
   options.signal?.throwIfAborted();
-  const worktrees = join18(root, ".worktrees");
-  const path = join18(worktrees, `loop-${options.loopId}`);
+  const worktrees = join19(root, ".worktrees");
+  const path = join19(worktrees, `loop-${options.loopId}`);
   const branch = `loop/${options.loopId}`;
   try {
     await ensureWorktreeDirectoryIgnored(root);
@@ -16019,12 +16188,12 @@ async function ensureWorktreeDirectoryIgnored(root) {
   const commonDirectory = await git(root, ["rev-parse", "--git-common-dir"]);
   if (commonDirectory.code !== 0) throw new Error(commonDirectory.stderr.trim() || "Git common directory is unavailable");
   const gitDirectory = resolve13(root, commonDirectory.stdout.trim());
-  const infoDirectory = join18(gitDirectory, "info");
-  const excludePath = join18(infoDirectory, "exclude");
+  const infoDirectory = join19(gitDirectory, "info");
+  const excludePath = join19(infoDirectory, "exclude");
   await mkdir12(infoDirectory, { recursive: true });
   let existing = "";
   try {
-    existing = await readFile12(excludePath, "utf8");
+    existing = await readFile13(excludePath, "utf8");
   } catch (error) {
     if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) throw error;
   }
@@ -16035,8 +16204,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 
 // src/loop/store.ts
 import { constants as constants5 } from "fs";
-import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile13, realpath as realpath8, rename as rename5, rm as rm7, stat as stat7 } from "fs/promises";
-import { dirname as dirname10, join as join19, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
+import { lstat as lstat7, mkdir as mkdir13, open as open6, readFile as readFile14, realpath as realpath8, rename as rename5, rm as rm7, stat as stat7 } from "fs/promises";
+import { dirname as dirname10, join as join20, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
 import { randomUUID as randomUUID12 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
@@ -16047,7 +16216,7 @@ var LoopStore = class {
   #appendTails = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#workspace = resolve14(options.workspace);
-    this.#root = join19(this.#workspace, ".flavor", "loops");
+    this.#root = join20(this.#workspace, ".flavor", "loops");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES2;
   }
   async create(state) {
@@ -16064,11 +16233,11 @@ var LoopStore = class {
     const state = LoopStateSchema.parse(input);
     await this.#assertWorkspace(state.workspace);
     const directory = await this.#prepare(state.loopId);
-    const target = join19(directory, "state.json");
+    const target = join20(directory, "state.json");
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Loop state exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join19(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
+    const temporary = join20(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
@@ -16084,11 +16253,11 @@ var LoopStore = class {
   }
   async load(loopId) {
     const directory = await this.#safeExisting(loopId);
-    const target = join19(directory, "state.json");
+    const target = join20(directory, "state.json");
     try {
       const metadata = await stat7(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) throw new Error("Loop state is not a bounded regular file");
-      const raw = await readFile13(target, "utf8");
+      const raw = await readFile14(target, "utf8");
       const state = LoopStateSchema.parse(JSON.parse(raw));
       await this.#assertWorkspace(state.workspace);
       return state;
@@ -16104,7 +16273,7 @@ var LoopStore = class {
     const previous = this.#appendTails.get(event.loopId) ?? Promise.resolve();
     const next = previous.catch(() => void 0).then(async () => {
       const directory = await this.#prepare(event.loopId);
-      const path = join19(directory, "events.jsonl");
+      const path = join20(directory, "events.jsonl");
       const handle = await open6(path, constants5.O_CREAT | constants5.O_APPEND | constants5.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
@@ -16121,7 +16290,7 @@ var LoopStore = class {
     await assertNoSymlink2(this.#workspace, dirname10(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join19(this.#root, loopId);
+    const directory = join20(this.#root, loopId);
     await mkdir13(directory, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
@@ -16129,7 +16298,7 @@ var LoopStore = class {
   async #safeExisting(loopId) {
     validateId(loopId);
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join19(this.#root, loopId);
+    const directory = join20(this.#root, loopId);
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
   }
@@ -16155,7 +16324,7 @@ async function assertNoSymlink2(root, target) {
   }
   for (const path of chain.reverse()) {
     try {
-      if ((await lstat6(path)).isSymbolicLink()) throw new Error(`Loop path contains a symbolic link: ${path}`);
+      if ((await lstat7(path)).isSymbolicLink()) throw new Error(`Loop path contains a symbolic link: ${path}`);
     } catch (error) {
       if (!isCode5(error, "ENOENT")) throw error;
     }
@@ -16177,13 +16346,13 @@ function isCode5(error, code) {
 }
 
 // src/loop/verifier.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join22 } from "path";
 
 // src/tools/shell.ts
 import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { basename as basename5, delimiter as delimiter2, isAbsolute as isAbsolute9, join as join20, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
+import { basename as basename5, delimiter as delimiter2, isAbsolute as isAbsolute9, join as join21, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
 import { z as z25 } from "zod";
 
 // src/tools/jobs.ts
@@ -16846,7 +17015,7 @@ function decodeOutput(buffer) {
   return new TextDecoder(encoding).decode(buffer);
 }
 function shellEnvironment(root, environment) {
-  const localBin = join20(root, "node_modules", ".bin");
+  const localBin = join21(root, "node_modules", ".bin");
   if (!existsSync4(localBin)) return environment;
   const pathKey = Object.keys(environment).find((key) => key.toLowerCase() === "path") ?? "PATH";
   const current = environment[pathKey] ?? "";
@@ -16950,13 +17119,13 @@ var MAX_PERSISTED_VERIFICATION_STREAM_BYTES = 1024;
 async function inferVerificationPlan(workspace) {
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
-  const packageJson = await optionalJson(join21(workspace, "package.json"));
+  const packageJson = await optionalJson(join22(workspace, "package.json"));
   const scripts = isRecord3(packageJson?.scripts) ? packageJson.scripts : {};
   for (const name of SCRIPT_PRIORITY) {
     if (typeof scripts[name] !== "string" || isUnconditionalPassThrough(scripts[name])) continue;
     add(commands, seen, npmScript(name));
   }
-  const flavor = await optionalText(join21(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join22(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -17031,7 +17200,7 @@ function isUnconditionalPassThrough(script) {
 }
 async function optionalText(path) {
   try {
-    return await readFile14(path, "utf8");
+    return await readFile15(path, "utf8");
   } catch (error) {
     if (isCode6(error, "ENOENT")) return void 0;
     throw error;
@@ -17052,7 +17221,7 @@ function isCode6(error, code) {
 
 // src/models/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 
 // src/utils/json.ts
 function safeParseJson(input) {
@@ -17101,11 +17270,11 @@ function isEnvTruthy(value) {
 
 // src/utils/log.ts
 import { appendFile as appendFile3, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname11, join as join22, resolve as resolve16 } from "path";
+import { dirname as dirname11, join as join23, resolve as resolve16 } from "path";
 var pending = Promise.resolve();
 var usagePending = Promise.resolve();
 function usageLogPath() {
-  return process.env.FLAVOR_USAGE_FILE ?? join22(process.cwd(), ".flavor", "usage.jsonl");
+  return process.env.FLAVOR_USAGE_FILE ?? join23(process.cwd(), ".flavor", "usage.jsonl");
 }
 var usageSessionId = "unknown";
 var truncateOnNextAppend = false;
@@ -17134,7 +17303,7 @@ var AuditLogger = class {
   #path;
   #closed = false;
   constructor(workspace) {
-    this.#path = join22(resolve16(workspace), ".flavor", "audit.jsonl");
+    this.#path = join23(resolve16(workspace), ".flavor", "audit.jsonl");
   }
   get path() {
     return this.#path;
@@ -17391,7 +17560,7 @@ ${modelContentText(message2.content)}
             source: {
               type: "base64",
               media_type: block.mediaType,
-              data: (await readFile15(block.source.path)).toString("base64")
+              data: (await readFile16(block.source.path)).toString("base64")
             }
           }));
           if (message2.cacheBreakpoint && Array.isArray(content) && content.length > 0) {
@@ -17613,7 +17782,7 @@ function resolveCacheProfile(input) {
 // src/models/openai.ts
 import OpenAI from "openai";
 import { createHash as createHash12 } from "crypto";
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 var DEFAULT_THINKING_EFFORT = "high";
 var EXPLICIT_CACHE_BREAKPOINT = { mode: "explicit" };
 var MAX_EXPLICIT_CACHE_BREAKPOINTS = 3;
@@ -17636,7 +17805,7 @@ async function toInput(message2, cacheBreakpoint = false) {
     prompt_cache_breakpoint: EXPLICIT_CACHE_BREAKPOINT
   }] : message2.content : await Promise.all(message2.content.map(async (block) => block.type === "text" ? { type: "input_text", text: block.text } : {
     type: "input_image",
-    image_url: `data:${block.mediaType};base64,${(await readFile16(block.source.path)).toString("base64")}`,
+    image_url: `data:${block.mediaType};base64,${(await readFile17(block.source.path)).toString("base64")}`,
     detail: "auto"
   }));
   if (cacheBreakpoint && Array.isArray(content) && content.length > 0) {
@@ -17880,16 +18049,28 @@ function selectExplicitBreakpointIndexes(messages) {
   const indexes = messages.map((message2, index) => message2.cacheBreakpoint ? index : -1).filter((index) => index >= 0);
   const tail = messages.length - 1;
   if (tail >= 0 && indexes.at(-1) !== tail) indexes.push(tail);
-  return new Set(indexes.slice(-MAX_EXPLICIT_CACHE_BREAKPOINTS));
+  const firstNonSystem = messages.findIndex((message2) => message2.role !== "system");
+  const leadingSystemEnd = firstNonSystem < 0 ? tail : firstNonSystem - 1;
+  const stable = indexes.filter((index) => index <= leadingSystemEnd).at(-1);
+  if (stable === void 0) return new Set(indexes.slice(-MAX_EXPLICIT_CACHE_BREAKPOINTS));
+  return /* @__PURE__ */ new Set([
+    stable,
+    ...indexes.filter((index) => index !== stable).slice(-(MAX_EXPLICIT_CACHE_BREAKPOINTS - 1))
+  ]);
 }
 function promptCacheKey(request, sortedTools) {
-  let stableEnd = -1;
-  request.messages.forEach((message2, index) => {
-    if (message2.cacheBreakpoint) stableEnd = index;
-  });
   const firstNonSystem = request.messages.findIndex((message2) => message2.role !== "system");
   const leadingSystemEnd = firstNonSystem < 0 ? request.messages.length - 1 : firstNonSystem - 1;
-  stableEnd = Math.max(stableEnd, leadingSystemEnd);
+  let stableEnd = -1;
+  for (let index = 0; index <= leadingSystemEnd; index += 1) {
+    if (request.messages[index]?.cacheBreakpoint) stableEnd = index;
+  }
+  if (stableEnd < 0) {
+    request.messages.forEach((message2, index) => {
+      if (message2.cacheBreakpoint) stableEnd = index;
+    });
+    stableEnd = Math.max(stableEnd, leadingSystemEnd);
+  }
   const stableMessages = stableEnd < 0 ? [] : request.messages.slice(0, stableEnd + 1);
   const digest = createHash12("sha256").update(JSON.stringify({ model: request.model, messages: stableMessages, tools: sortedTools })).digest("hex").slice(0, 56);
   return `flavor-${digest}`;
@@ -18130,7 +18311,7 @@ import {
 
 // src/utils/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname12, join as join23 } from "path";
+import { dirname as dirname12, join as join24 } from "path";
 import { fileURLToPath } from "url";
 var cached;
 function packageVersion() {
@@ -18138,7 +18319,7 @@ function packageVersion() {
   let directory = dirname12(fileURLToPath(import.meta.url));
   for (; ; ) {
     try {
-      const manifest = JSON.parse(readFileSync2(join23(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync2(join24(directory, "package.json"), "utf8"));
       if (typeof manifest.version === "string" && manifest.version.length > 0) {
         cached = manifest.version;
         return cached;
@@ -18565,8 +18746,8 @@ function isStoredToken(value) {
 }
 
 // src/permissions/policy.ts
-import { readFile as readFile17 } from "fs/promises";
-import { join as join24, resolve as resolve18 } from "path";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join25, resolve as resolve18 } from "path";
 import { z as z27 } from "zod";
 var DecisionSchema2 = z27.enum(["allow", "ask", "deny"]);
 var PrefixSchema = z27.array(z27.string().min(1).max(1024)).min(1).max(64);
@@ -18603,15 +18784,15 @@ var CompiledPermissionPolicy = class {
 async function loadPermissionPolicy(options) {
   const sources = [
     ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve18(options.managedPath) }],
-    { tier: "user", path: join24(resolve18(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join24(resolve18(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join24(resolve18(options.workspace), ".flavor", "permissions.local.json") }
+    { tier: "user", path: join25(resolve18(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join25(resolve18(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join25(resolve18(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
     let raw;
     try {
-      raw = await readFile17(source.path, "utf8");
+      raw = await readFile18(source.path, "utf8");
     } catch (error) {
       if (isCode7(error, "ENOENT")) continue;
       throw error;
@@ -18826,7 +19007,7 @@ function data(value) {
 
 // src/skills/registry.ts
 import { constants as constants6 } from "fs";
-import { lstat as lstat7, open as defaultOpen, readdir as readdir5, realpath as realpath9 } from "fs/promises";
+import { lstat as lstat8, open as defaultOpen, readdir as readdir5, realpath as realpath9 } from "fs/promises";
 import { isAbsolute as isAbsolute10, relative as relative12, resolve as resolve19, sep as sep12 } from "path";
 import { marked } from "marked";
 import { parseDocument } from "yaml";
@@ -18991,12 +19172,12 @@ var SkillRegistry = class {
       let entries;
       let physicalRoot = root;
       try {
-        const rootInfo = await lstat7(root);
+        const rootInfo = await lstat8(root);
         if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) throw new Error("Skill root must be a real directory");
         physicalRoot = await realpath9(root);
         entries = await readdir5(root, { withFileTypes: true });
       } catch (error) {
-        if (isMissing(error)) continue;
+        if (isMissing2(error)) continue;
         this.#diagnose(root, error);
         continue;
       }
@@ -19145,7 +19326,7 @@ async function openFile(path, flags) {
   return defaultOpen(path, flags);
 }
 async function openVerifiedFile(path, root, label, opener, expected) {
-  const initial = await lstat7(path, { bigint: true });
+  const initial = await lstat8(path, { bigint: true });
   if (initial.isSymbolicLink()) throw new Error(`${label} symlinks are not allowed`);
   assertRegular(initial, label);
   const canonical3 = await realpath9(path);
@@ -19212,7 +19393,7 @@ function isWithin4(root, candidate) {
   const delta = relative12(root, candidate);
   return delta === "" || delta !== ".." && !delta.startsWith(`..${sep12}`) && !isAbsolute10(delta);
 }
-function isMissing(error) {
+function isMissing2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function normalizeReference(reference) {
@@ -19377,8 +19558,8 @@ function createSkillResourceTool(registry) {
 
 // src/session/store.ts
 import { constants as constants7 } from "fs";
-import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile18, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat8 } from "fs/promises";
-import { basename as basename6, dirname as dirname14, join as join25, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
+import { lstat as lstat9, mkdir as mkdir15, open as open7, readFile as readFile19, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat8 } from "fs/promises";
+import { basename as basename6, dirname as dirname14, join as join26, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 import { z as z29 } from "zod";
 
@@ -20161,7 +20342,7 @@ var SessionStore = class {
   #maxSessions;
   constructor(options) {
     this.#workspace = resolve20(options.workspace);
-    this.#sessions = join25(this.#workspace, ".flavor", "sessions");
+    this.#sessions = join26(this.#workspace, ".flavor", "sessions");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_SESSION_BYTES;
     if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 256) throw new Error("maxBytes must be an integer of at least 256");
     this.#maxSessions = options.maxSessions ?? 50;
@@ -20193,7 +20374,7 @@ var SessionStore = class {
     const body = `${lines.join("\n")}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Session exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join25(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
+    const temporary = join26(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
@@ -20212,7 +20393,7 @@ var SessionStore = class {
   async acquireLease(sessionId) {
     SessionIdSchema.parse(sessionId);
     await this.#prepareDirectory();
-    const path = join25(this.#sessions, `.${sessionId}.lock`);
+    const path = join26(this.#sessions, `.${sessionId}.lock`);
     const token = JSON.stringify({ pid: process.pid, nonce: randomUUID13(), createdAt: (/* @__PURE__ */ new Date()).toISOString() });
     for (let attempt = 0; attempt < 3; attempt += 1) {
       let handle;
@@ -20230,7 +20411,7 @@ var SessionStore = class {
           release: async () => {
             if (released) return;
             try {
-              if (await readFile18(path, "utf8") === token) await rm8(path, { force: true });
+              if (await readFile19(path, "utf8") === token) await rm8(path, { force: true });
             } catch (error) {
               if (!isCode8(error, "ENOENT")) throw error;
             }
@@ -20346,14 +20527,14 @@ var SessionStore = class {
       if (isCode8(error, "ENOENT")) return;
       throw error;
     }
-    const owner2 = await reclaimStaleSessionLock(join25(this.#sessions, `.${sessionId}.lock`));
+    const owner2 = await reclaimStaleSessionLock(join26(this.#sessions, `.${sessionId}.lock`));
     if (owner2 !== void 0) throw new Error(`Session "${sessionId}" is active in process ${owner2} and cannot be deleted`);
     const path = this.#path(sessionId);
     try {
-      const metadata = await lstat8(path);
+      const metadata = await lstat9(path);
       if (!metadata.isFile()) throw new Error("Session path is not a regular file");
       await rm8(path);
-      await rm8(join25(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join26(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     } catch (error) {
       if (!isCode8(error, "ENOENT")) throw error;
     }
@@ -20369,14 +20550,14 @@ var SessionStore = class {
     if (entries.length <= this.#maxSessions) return;
     let retained = 0;
     for (const entry2 of entries) {
-      const owner2 = await reclaimStaleSessionLock(join25(this.#sessions, `.${entry2.sessionId}.lock`));
+      const owner2 = await reclaimStaleSessionLock(join26(this.#sessions, `.${entry2.sessionId}.lock`));
       if (owner2 !== void 0) continue;
       if (retained < this.#maxSessions) {
         retained += 1;
         continue;
       }
       await rm8(this.#path(entry2.sessionId), { force: true }).catch(() => void 0);
-      await rm8(join25(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join26(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     }
   }
   async #assertWorkspace(stored) {
@@ -20424,14 +20605,14 @@ function storedSessionVersion(raw) {
 }
 async function reclaimStaleSessionLock(path) {
   try {
-    const token = await readFile18(path, "utf8");
+    const token = await readFile19(path, "utf8");
     const metadata = await stat8(path);
     const owner2 = parseSessionLockOwner(token);
     if (owner2 !== void 0 && isProcessAlive2(owner2)) return owner2;
     if (owner2 === void 0 && Date.now() - metadata.mtimeMs <= INVALID_SESSION_LOCK_STALE_MS) {
       throw new Error(`Session writer lock ${path} is incomplete or invalid; retry after the owning process exits`);
     }
-    if (await readFile18(path, "utf8") !== token) return void 0;
+    if (await readFile19(path, "utf8") !== token) return void 0;
     const stale = `${path}.stale-${process.pid}-${randomUUID13()}`;
     try {
       await rename6(path, stale);
@@ -20467,7 +20648,7 @@ async function boundedRead(path, maxBytes) {
   const metadata = await stat8(path);
   if (!metadata.isFile()) throw new Error("Session path is not a regular file");
   if (metadata.size > maxBytes) throw new Error(`Session exceeds maximum read size of ${maxBytes} bytes`);
-  const value = await readFile18(path);
+  const value = await readFile19(path);
   if (value.byteLength > maxBytes) throw new Error(`Session exceeds maximum read size of ${maxBytes} bytes`);
   return value.toString("utf8");
 }
@@ -20619,7 +20800,7 @@ async function assertNoSymlink3(root, target) {
   }
   for (const path of chain.reverse()) {
     try {
-      if ((await lstat8(path)).isSymbolicLink()) throw new Error(`Session path contains a symbolic link: ${path}`);
+      if ((await lstat9(path)).isSymbolicLink()) throw new Error(`Session path contains a symbolic link: ${path}`);
     } catch (error) {
       if (!isCode8(error, "ENOENT")) throw error;
     }
@@ -20659,14 +20840,14 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 
 // src/session/tree.ts
 import { randomUUID as randomUUID15 } from "crypto";
-import { mkdir as mkdir17, readFile as readFile20, rename as rename8, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname16, join as join27, resolve as resolve22 } from "path";
+import { mkdir as mkdir17, readFile as readFile21, rename as rename8, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname16, join as join28, resolve as resolve22 } from "path";
 
 // src/session/checkpoint.ts
 import { createHash as createHash16, randomUUID as randomUUID14 } from "crypto";
 import { execFile as execFile2 } from "child_process";
-import { lstat as lstat9, mkdir as mkdir16, open as open8, readFile as readFile19, readdir as readdir7, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname15, join as join26, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
+import { lstat as lstat10, mkdir as mkdir16, open as open8, readFile as readFile20, readdir as readdir7, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname15, join as join27, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
 var EXCLUDED = /* @__PURE__ */ new Set([".git", ".flavor", "node_modules", "dist", "build", "release", ".worktrees"]);
 var MAX_FILE_BYTES = 16 * 1024 * 1024;
 var MAX_TOTAL_BYTES = 128 * 1024 * 1024;
@@ -20679,9 +20860,9 @@ var WorkspaceCheckpointStore = class {
   #maxTotalBytes;
   constructor(options) {
     this.#workspace = resolve21(options.workspace);
-    this.#root = join26(this.#workspace, ".flavor", "checkpoints");
-    this.#objects = join26(this.#root, "objects");
-    this.#manifests = join26(this.#root, "manifests");
+    this.#root = join27(this.#workspace, ".flavor", "checkpoints");
+    this.#objects = join27(this.#root, "objects");
+    this.#manifests = join27(this.#root, "manifests");
     this.#maxFileBytes = options.maxFileBytes ?? MAX_FILE_BYTES;
     this.#maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
   }
@@ -20693,15 +20874,15 @@ var WorkspaceCheckpointStore = class {
     await mkdir16(this.#manifests, { recursive: true });
     for (const path of paths) {
       const absolute = contained(this.#workspace, path);
-      const info = await lstat9(absolute);
+      const info = await lstat10(absolute);
       if (info.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path}`);
       if (!info.isFile()) continue;
       if (info.size > this.#maxFileBytes) throw new Error(`Checkpoint file exceeds size limit: ${path}`);
       total += info.size;
       if (total > this.#maxTotalBytes) throw new Error("Checkpoint exceeds total size limit");
-      const content = await readFile19(absolute);
+      const content = await readFile20(absolute);
       const digest = createHash16("sha256").update(content).digest("hex");
-      const objectPath = join26(this.#objects, digest);
+      const objectPath = join27(this.#objects, digest);
       try {
         const handle = await open8(objectPath, "wx");
         try {
@@ -20721,12 +20902,12 @@ var WorkspaceCheckpointStore = class {
       ...label === void 0 || label.trim().length === 0 ? {} : { label: label.trim() },
       files
     };
-    await atomicJson(join26(this.#manifests, `${checkpoint.id}.json`), checkpoint);
+    await atomicJson(join27(this.#manifests, `${checkpoint.id}.json`), checkpoint);
     return checkpoint;
   }
   async load(id) {
     if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-    const value = JSON.parse(await readFile19(join26(this.#manifests, `${id}.json`), "utf8"));
+    const value = JSON.parse(await readFile20(join27(this.#manifests, `${id}.json`), "utf8"));
     if (value.version !== 1 || value.id !== id || !Array.isArray(value.files)) throw new Error("Invalid checkpoint manifest");
     for (const file of value.files) {
       contained(this.#workspace, file.path);
@@ -20738,7 +20919,7 @@ var WorkspaceCheckpointStore = class {
     const checkpoint = await this.load(id);
     const objects = /* @__PURE__ */ new Map();
     for (const file of checkpoint.files) {
-      const object = await readFile19(join26(this.#objects, file.digest));
+      const object = await readFile20(join27(this.#objects, file.digest));
       if (object.length !== file.size || createHash16("sha256").update(object).digest("hex") !== file.digest) {
         throw new Error(`Checkpoint object is corrupt: ${file.digest}`);
       }
@@ -20761,7 +20942,7 @@ var WorkspaceCheckpointStore = class {
   }
 };
 async function discoverFiles(workspace) {
-  if (await exists2(join26(workspace, ".git"))) {
+  if (await exists2(join27(workspace, ".git"))) {
     const listed = await gitFiles(workspace);
     return listed.filter((path) => !EXCLUDED.has(path.split("/")[0] ?? "")).sort();
   }
@@ -20770,7 +20951,7 @@ async function discoverFiles(workspace) {
     const entries = await readdir7(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (EXCLUDED.has(entry2.name)) continue;
-      const absolute = join26(directory, entry2.name);
+      const absolute = join27(directory, entry2.name);
       const path = normalizeRelative(relative14(workspace, absolute));
       if (entry2.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path}`);
       if (entry2.isDirectory()) await walk(absolute);
@@ -20804,7 +20985,7 @@ async function gitFiles(workspace) {
 }
 async function exists2(path) {
   try {
-    await lstat9(path);
+    await lstat10(path);
     return true;
   } catch (error) {
     if (isCode9(error, "ENOENT")) return false;
@@ -20845,17 +21026,17 @@ var SessionHistory = class _SessionHistory {
   #leafId;
   #unrevert;
   constructor(options, document) {
-    this.#path = join27(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    this.#path = join28(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     this.#checkpoints = new WorkspaceCheckpointStore({ workspace: options.workspace });
     this.#restoreContext = options.restoreContext;
     this.#nodes = boundedNodes(document.nodes);
     this.#leafId = document.leafId !== null && this.#nodes.some((node) => node.id === document.leafId) ? document.leafId : this.#nodes.at(-1)?.id ?? null;
   }
   static async open(options) {
-    const path = join27(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    const path = join28(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     let document = { version: 1, sessionId: options.sessionId, leafId: null, nodes: [] };
     try {
-      const parsed = JSON.parse(await readFile20(path, "utf8"));
+      const parsed = JSON.parse(await readFile21(path, "utf8"));
       validate(parsed, options.sessionId);
       document = parsed;
     } catch (error) {
@@ -20988,7 +21169,7 @@ function isCode10(error, code) {
 
 // src/utils/rotation-census.ts
 import { mkdirSync as mkdirSync2, readdirSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { writeHeapSnapshot } from "v8";
 var CENSUS_PREFIX = "rotation-census-";
 var SNAPSHOT_PREFIX = "heap-";
@@ -21012,9 +21193,9 @@ function censusHeapBlock(reading) {
 }
 function writeRotationCensus(workspace, census) {
   try {
-    const directory = join28(workspace, ".flavor", "tmp");
+    const directory = join29(workspace, ".flavor", "tmp");
     mkdirSync2(directory, { recursive: true });
-    const path = join28(directory, `${CENSUS_PREFIX}${Date.now()}.json`);
+    const path = join29(directory, `${CENSUS_PREFIX}${Date.now()}.json`);
     writeFileSync(path, `${JSON.stringify(census, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     prune(directory, CENSUS_PREFIX, ".json", KEEP_CENSUS_FILES);
@@ -21025,9 +21206,9 @@ function writeRotationCensus(workspace, census) {
 }
 function writeRotationHeapSnapshot(workspace) {
   try {
-    const directory = join28(workspace, ".flavor", "tmp");
+    const directory = join29(workspace, ".flavor", "tmp");
     mkdirSync2(directory, { recursive: true });
-    const path = join28(directory, `${SNAPSHOT_PREFIX}${Date.now()}.heapsnapshot`);
+    const path = join29(directory, `${SNAPSHOT_PREFIX}${Date.now()}.heapsnapshot`);
     writeHeapSnapshot(path);
     prune(directory, SNAPSHOT_PREFIX, ".heapsnapshot", KEEP_SNAPSHOT_FILES);
     return path;
@@ -21039,7 +21220,7 @@ function prune(directory, prefix, suffix, keep) {
   const stale = readdirSync(directory).filter((name) => name.startsWith(prefix) && name.endsWith(suffix)).sort().slice(0, -keep);
   for (const name of stale) {
     try {
-      unlinkSync2(join28(directory, name));
+      unlinkSync2(join29(directory, name));
     } catch {
     }
   }
@@ -21048,8 +21229,8 @@ function prune(directory, prefix, suffix, keep) {
 // src/sleep/organizer.ts
 import { constants as constants8 } from "fs";
 import { randomUUID as randomUUID16 } from "crypto";
-import { lstat as lstat10, mkdir as mkdir18, open as open9, readdir as readdir8, realpath as realpath11, rename as rename9, rm as rm10 } from "fs/promises";
-import { isAbsolute as isAbsolute11, join as join29, relative as relative15, resolve as resolve23, sep as sep15 } from "path";
+import { lstat as lstat11, mkdir as mkdir18, open as open9, readdir as readdir8, realpath as realpath11, rename as rename9, rm as rm10 } from "fs/promises";
+import { isAbsolute as isAbsolute11, join as join30, relative as relative15, resolve as resolve23, sep as sep15 } from "path";
 import { z as z30 } from "zod";
 var DateKeySchema = z30.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z30.object({
@@ -21104,7 +21285,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve23(options.workspace);
-    this.#sleepDirectory = join29(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join30(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -21113,7 +21294,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join29(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join30(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open9(lockPath, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
@@ -21148,7 +21329,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
       }
       if (review === void 0) throw lastError;
       const filename2 = `${date}-${filenameSummary(review.title)}.md`;
-      const path = join29(this.#sleepDirectory, filename2);
+      const path = join30(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -21190,7 +21371,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join29(this.#workspace, ".flavor");
+    const flavorDirectory = join30(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir18(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -21204,7 +21385,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir8(this.#sleepDirectory, { withFileTypes: true })).some((entry2) => entry2.isFile() && entry2.name.startsWith(prefix) && entry2.name.endsWith(".md"));
   }
   async #atomicWrite(path, content) {
-    const temporary = join29(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
+    const temporary = join30(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
@@ -21520,7 +21701,7 @@ function assertDateKey(value) {
 }
 async function assertNotSymlink(path) {
   try {
-    if ((await lstat10(path)).isSymbolicLink()) throw new Error(`Refusing to use symbolic link: ${path}`);
+    if ((await lstat11(path)).isSymbolicLink()) throw new Error(`Refusing to use symbolic link: ${path}`);
   } catch (error) {
     if (!hasCode(error, "ENOENT")) throw error;
   }
@@ -21578,7 +21759,7 @@ function computeSessionStats(documents) {
 
 // src/tools/files.ts
 import { constants as constants9 } from "fs";
-import { mkdir as mkdir19, open as open10, readFile as readFile21, realpath as realpath12, rename as rename10, rm as rm11, stat as stat9 } from "fs/promises";
+import { mkdir as mkdir19, open as open10, readFile as readFile22, realpath as realpath12, rename as rename10, rm as rm11, stat as stat9 } from "fs/promises";
 import { dirname as dirname17, isAbsolute as isAbsolute12, relative as relative16, resolve as resolve24, sep as sep16 } from "path";
 import { randomUUID as randomUUID17 } from "crypto";
 import { z as z31 } from "zod";
@@ -21924,7 +22105,7 @@ function createPathGuard(workspace) {
           if (!within2(physicalRoot, physical)) throw new Error("Path escapes the workspace through a symlink");
           break;
         } catch (error) {
-          if (!isMissing2(error)) throw error;
+          if (!isMissing3(error)) throw error;
           const parent = dirname17(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
@@ -21942,7 +22123,7 @@ async function atomicWrite(path, content, signal, expectedVersion) {
   try {
     mode = (await stat9(path)).mode & 511;
   } catch (error) {
-    if (!isMissing2(error)) throw error;
+    if (!isMissing3(error)) throw error;
   }
   try {
     const handle = await open10(temporary, constants9.O_CREAT | constants9.O_EXCL | constants9.O_WRONLY, 384);
@@ -21963,7 +22144,7 @@ async function atomicWrite(path, content, signal, expectedVersion) {
   }
 }
 async function readText(path) {
-  const contents = await readFile21(path);
+  const contents = await readFile22(path);
   if (isBinary(contents)) throw new Error("Cannot edit binary file as text");
   return decodeFileText(contents);
 }
@@ -21991,7 +22172,7 @@ async function fileVersion(path) {
   try {
     return versionOfStat(await stat9(path));
   } catch (error) {
-    if (isMissing2(error)) return ABSENT_VERSION;
+    if (isMissing3(error)) return ABSENT_VERSION;
     throw error;
   }
 }
@@ -22000,10 +22181,10 @@ function versionOfStat(info) {
 }
 async function readOptionalPresentationText(path) {
   try {
-    const contents = await readFile21(path);
+    const contents = await readFile22(path);
     return isBinary(contents) ? { exists: true } : { exists: true, text: contents.toString("utf8") };
   } catch (error) {
-    return isMissing2(error) ? { exists: false } : { exists: true };
+    return isMissing3(error) ? { exists: false } : { exists: true };
   }
 }
 function isBinary(contents) {
@@ -22112,7 +22293,7 @@ function mergeRange(ranges, start, end) {
 function abortIfNeeded(signal) {
   if (signal.aborted) throw signal.reason;
 }
-function isMissing2(error) {
+function isMissing3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 var PATCH_SEARCH_RADIUS = 100;
@@ -22197,7 +22378,7 @@ async function requireAbsent(guard, path) {
   try {
     await guard.existing(path);
   } catch (error) {
-    if (isMissing2(error)) return "";
+    if (isMissing3(error)) return "";
     throw error;
   }
   throw new Error("Patch creation destination already exists");
@@ -23033,7 +23214,7 @@ async function readOptionalIgnoreFile(path, maxBytes, signal) {
   try {
     handle = await open11(path, "r");
   } catch (error) {
-    if (isMissing3(error)) return void 0;
+    if (isMissing4(error)) return void 0;
     throw error;
   }
   const buffer = Buffer.allocUnsafe(maxBytes + 1);
@@ -23051,7 +23232,7 @@ async function readOptionalIgnoreFile(path, maxBytes, signal) {
   if (offset > maxBytes) throw new Error(`Ignore file byte limit of ${maxBytes} exceeded: ${path}`);
   return buffer.subarray(0, offset);
 }
-function isMissing3(error) {
+function isMissing4(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -23385,7 +23566,7 @@ function charset(contentType) {
 // src/tools/lsp.ts
 import { spawn as spawn6 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { access as access2, constants as constants10, readFile as readFile22 } from "fs/promises";
+import { access as access2, constants as constants10, readFile as readFile23 } from "fs/promises";
 import { basename as basename7, dirname as dirname18, extname as extname3, isAbsolute as isAbsolute14, relative as relative18, resolve as resolve26, sep as sep18 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "url";
 import { z as z34 } from "zod";
@@ -23581,7 +23762,7 @@ var LspConnection = class {
     const url = new URL(uri);
     if (url.protocol !== "file:") return;
     const filePath = fileURLToPath2(url);
-    const text = await readFile22(filePath, "utf8");
+    const text = await readFile23(filePath, "utf8");
     const current = this.#documents.get(uri);
     if (current === void 0) {
       this.#documents.set(uri, { text, version: 1 });
@@ -24315,12 +24496,12 @@ ${explanation}` : "";
 // src/desktop/astgraph-service.ts
 import { stat as stat11 } from "fs/promises";
 import { createRequire as nodeCreateRequire } from "module";
-import { join as join30, resolve as resolve27 } from "path";
+import { join as join31, resolve as resolve27 } from "path";
 var FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature";
 var DesktopAstGraphService = class {
   #path;
   constructor(workspace) {
-    this.#path = join30(resolve27(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join31(resolve27(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
     if ((await stat11(this.#path).catch(() => void 0))?.isFile() !== true) {
@@ -24603,8 +24784,8 @@ function createTodoWriteTool() {
 
 // src/tools/managed.ts
 import { randomUUID as randomUUID18 } from "crypto";
-import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile23, readdir as readdir9, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname19, join as join31, resolve as resolve29 } from "path";
+import { link, lstat as lstat12, mkdir as mkdir20, readFile as readFile24, readdir as readdir9, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname19, join as join32, resolve as resolve29 } from "path";
 import { z as z39 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -24656,8 +24837,8 @@ var ManagedToolStore = class {
   #diagnostics = [];
   constructor(options) {
     this.#workspace = resolve29(options.workspace);
-    this.#projectRoot = join31(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join31(resolve29(options.home), ".flavor-code", "tools");
+    this.#projectRoot = join32(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join32(resolve29(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -24704,7 +24885,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join31(this.directory(input.scope), filename(input.name));
+    const path = join32(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record3, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record3, void 0, 2)}
 `);
@@ -24718,7 +24899,7 @@ var ManagedToolStore = class {
     if (matches.length === 0) throw new Error(`Managed tool "${input.name}" was not found`);
     if (matches.length > 1) throw new Error(`Managed tool "${input.name}" exists in multiple scopes; specify scope`);
     const entry2 = matches[0];
-    const info = await lstat11(entry2.path);
+    const info = await lstat12(entry2.path);
     if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Managed tool path is no longer a regular file: ${entry2.path}`);
     await unlink3(entry2.path);
     this.#entries.delete(scopedKey(entry2.scope, entry2.record.name));
@@ -24729,7 +24910,7 @@ var ManagedToolStore = class {
     if (!parsed.success) return [];
     const matches = this.#matching(parsed.data.name).filter((entry2) => parsed.data.scope === void 0 || entry2.scope === parsed.data.scope);
     if (matches.length > 0) return matches.map((entry2) => entry2.path);
-    return [join31(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join32(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -24737,17 +24918,17 @@ var ManagedToolStore = class {
     try {
       names = (await readdir9(root, { withFileTypes: true })).filter((entry2) => entry2.name.endsWith(".json")).sort((left, right) => compare2(left.name, right.name)).map((entry2) => entry2.name);
     } catch (error) {
-      if (isMissing4(error)) return;
+      if (isMissing5(error)) return;
       this.#diagnostics.push(`${root}: ${message(error)}`);
       return;
     }
     for (const name of names) {
-      const path = join31(root, name);
+      const path = join32(root, name);
       try {
-        const info = await lstat11(path);
+        const info = await lstat12(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
         if (info.size > MAX_RECORD_BYTES) throw new Error(`Managed tool record exceeds ${MAX_RECORD_BYTES} bytes`);
-        const record3 = ManagedToolRecordSchema.parse(JSON.parse(await readFile23(path, "utf8")));
+        const record3 = ManagedToolRecordSchema.parse(JSON.parse(await readFile24(path, "utf8")));
         if (record3.scope !== scope2) throw new Error(`Managed tool record scope must match its ${scope2} directory`);
         const key = scopedKey(scope2, record3.name);
         if (this.#entries.has(key)) throw new Error(`Duplicate managed tool name in ${scope2} scope: ${record3.name}`);
@@ -24940,7 +25121,7 @@ function compare2(left, right) {
 function compareScope(left, right) {
   return left === right ? 0 : left === "global" ? -1 : 1;
 }
-function isMissing4(error) {
+function isMissing5(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -25341,6 +25522,7 @@ var MVP_COMMANDS = [
   "remember",
   "forget",
   "forget-cold",
+  "global",
   "checkpoint",
   "tree",
   "rewind",
@@ -25439,6 +25621,13 @@ function parseSlashCommand(input, dynamicCommands = [], skillCommands = [], mana
     const query = args.join(" ").trim();
     return query.length === 0 ? { name: "invalid", command: name, message: "Use /forget <text-or-id>." } : { name, query };
   }
+  if (name === "global") {
+    const [action, ...parts] = args;
+    if (action === void 0) return { name, action: "show" };
+    const text = parts.join(" ").trim();
+    if ((action === "remember" || action === "forget") && text.length > 0) return { name, action, text };
+    return { name: "invalid", command: name, message: "Use /global [remember <rule>|forget <rule>]." };
+  }
   if (name === "checkpoint") {
     const label = args.join(" ").trim();
     return label.length === 0 ? { name } : { name, label };
@@ -25603,6 +25792,7 @@ var HELP = [
   "/logout                                 clear stored OAuth credentials",
   "/init  /config  /skills  /plugins  /hooks  /tasks  /doctor",
   "/memory  /remember [type] <text>  /forget <text-or-id>  /forget-cold  /finish",
+  "/global  /global remember <rule>  /global forget <rule>",
   "/checkpoint [label]  /tree  /rewind <node>  /unrevert  /fork <node>",
   "/compact  /clear  /paste-image  /help  /exit",
   "/loop <goal>                            run a verified autonomous loop",
@@ -26073,6 +26263,8 @@ Address this now (for example run the required verification or fix), then finish
       this.#notice(await required(this.#services.ide, "ide")());
     } else if (command2.name === "memory") {
       this.#notice(await this.#services.memory());
+    } else if (command2.name === "global") {
+      this.#notice(await required(this.#services.global, "global")(command2));
     } else if (command2.name === "remember") {
       this.#notice(await this.#services.remember(command2.type, command2.text));
     } else if (command2.name === "forget") {
@@ -26358,9 +26550,9 @@ function requiredPals(service) {
 
 // src/doctor.ts
 import { constants as constants11 } from "fs";
-import { access as access3, lstat as lstat12, readFile as readFile24, readdir as readdir10, stat as stat12 } from "fs/promises";
+import { access as access3, lstat as lstat13, readFile as readFile25, readdir as readdir10, stat as stat12 } from "fs/promises";
 import { homedir } from "os";
-import { isAbsolute as isAbsolute16, join as join32, relative as relative20, resolve as resolve30, sep as sep20 } from "path";
+import { isAbsolute as isAbsolute16, join as join33, relative as relative20, resolve as resolve30, sep as sep20 } from "path";
 import { rgPath as bundledRgPath2 } from "@vscode/ripgrep";
 
 // src/utils/semver.ts
@@ -26407,7 +26599,7 @@ async function runDoctor(options = {}, dependencies2 = {}) {
   const checks = [];
   checks.push(runtimeCheck(nodeVersion, platform, arch));
   checks.push(await directoryCheck("workspace", workspace, false));
-  checks.push(await directoryCheck("state directory", join32(home, ".flavor-code"), true, home));
+  checks.push(await directoryCheck("state directory", join33(home, ".flavor-code"), true, home));
   let loaded;
   try {
     loaded = await (dependencies2.loadConfig ?? loadConfig)({
@@ -26433,8 +26625,8 @@ async function runDoctor(options = {}, dependencies2 = {}) {
     checks.push({ name: "shell", status: "fail", message: errorMessage3(error) });
   }
   checks.push(await pluginCheck([
-    join32(home, ".flavor-code", "plugins"),
-    join32(workspace, ".flavor", "plugins")
+    join33(home, ".flavor-code", "plugins"),
+    join33(workspace, ".flavor", "plugins")
   ]));
   try {
     const latest = await (dependencies2.fetchLatestVersion ?? fetchLatestVersion)({
@@ -26549,13 +26741,13 @@ async function pluginCheck(directories) {
       if (!entry2.isDirectory() || entry2.name.startsWith(".")) continue;
       const root = resolve30(directory, entry2.name);
       try {
-        const rootInfo = await lstat12(root);
+        const rootInfo = await lstat13(root);
         if (rootInfo.isSymbolicLink()) throw new Error("plugin directory must not be a symbolic link");
-        const manifest = PluginManifestSchema.parse(JSON.parse(await readFile24(join32(root, "flavor-plugin.json"), "utf8")));
+        const manifest = PluginManifestSchema.parse(JSON.parse(await readFile25(join33(root, "flavor-plugin.json"), "utf8")));
         const main = resolve30(root, manifest.main);
         const delta = relative20(root, main);
         if (delta === ".." || delta.startsWith(`..${sep20}`) || isAbsolute16(delta)) throw new Error("plugin entry escapes its root");
-        const mainInfo = await lstat12(main);
+        const mainInfo = await lstat13(main);
         if (!mainInfo.isFile() || mainInfo.isSymbolicLink()) throw new Error("plugin entry must be a regular file");
         valid += 1;
       } catch (error) {
@@ -26619,7 +26811,7 @@ var LANG_LABELS = /* @__PURE__ */ new Map([
 
 // src/utils/crash-guard.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var installed = false;
 var crashing = false;
 var crashCleanups = /* @__PURE__ */ new Set();
@@ -26650,7 +26842,7 @@ function installCrashGuard(options = {}) {
   installed = true;
   const crashLogDir = () => {
     try {
-      return join33((options.workspace ?? process.cwd)(), ".flavor");
+      return join34((options.workspace ?? process.cwd)(), ".flavor");
     } catch {
       return process.cwd();
     }
@@ -26659,7 +26851,7 @@ function installCrashGuard(options = {}) {
     try {
       const dir = crashLogDir();
       mkdirSync3(dir, { recursive: true });
-      const path = join33(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
+      const path = join34(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
       writeFileSync2(path, [
         `kind: ${kind}`,
         `version: ${process.version}`,
@@ -27430,8 +27622,8 @@ ${total}`;
 
 // src/memory/store.ts
 import { createHash as createHash18 } from "crypto";
-import { readFile as readFile25, rm as rm12 } from "fs/promises";
-import { resolve as resolve31, join as join34, relative as relative21, sep as sep21 } from "path";
+import { readFile as readFile26, rm as rm12 } from "fs/promises";
+import { resolve as resolve31, join as join35, relative as relative21, sep as sep21 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -27534,9 +27726,9 @@ var MemoryStore = class {
     if (!Number.isSafeInteger(options.maxEntries) || options.maxEntries < 1) throw new Error("maxEntries must be an integer of at least 1");
     if (!Number.isSafeInteger(options.maxEntryChars) || options.maxEntryChars < 1) throw new Error("maxEntryChars must be an integer of at least 1");
     this.workspace = resolve31(options.workspace);
-    this.#memoryRoot = join34(this.workspace, ".flavor", "memory");
-    this.path = join34(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join34(this.#memoryRoot, "behavior.json");
+    this.#memoryRoot = join35(this.workspace, ".flavor", "memory");
+    this.path = join35(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join35(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -27754,7 +27946,7 @@ var MemoryStore = class {
     });
   }
   async #readTaskItem(reference) {
-    const document = decodeTask(await readFile25(this.#resolveContentPath(reference.contentPath), "utf8"));
+    const document = decodeTask(await readFile26(this.#resolveContentPath(reference.contentPath), "utf8"));
     return document.items.find((item) => item.id === reference.id)?.content ?? reference.summary;
   }
   #resolveContentPath(contentPath) {
@@ -28394,8 +28586,8 @@ function createExecutionEnvironment(workspace, config) {
 }
 
 // src/ide/client.ts
-import { readFile as readFile26, readdir as readdir11, stat as stat13 } from "fs/promises";
-import { basename as basename8, join as join35, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
+import { readFile as readFile27, readdir as readdir11, stat as stat13 } from "fs/promises";
+import { basename as basename8, join as join36, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -28491,7 +28683,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join35(this.#home, ".flavor-code", "ide");
+    const directory = join36(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir11(directory)).filter((name) => name.endsWith(".lock"));
@@ -28499,9 +28691,9 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join35(directory, name);
+      const path = join36(directory, name);
       try {
-        const [contents, info] = await Promise.all([readFile26(path, "utf8"), stat13(path)]);
+        const [contents, info] = await Promise.all([readFile27(path, "utf8"), stat13(path)]);
         const lock = parseLockfile(contents);
         return lock === void 0 ? void 0 : { lock, modified: info.mtimeMs };
       } catch {
@@ -29041,29 +29233,29 @@ function palSocketAddress(options) {
 import { createHash as createHash21 } from "crypto";
 import { Socket as Socket2 } from "net";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { spawn as spawn8 } from "child_process";
 
 // src/pals/broker.ts
 import { createHash as createHash20, randomUUID as randomUUID23, timingSafeEqual } from "crypto";
-import { chmod as chmod3, lstat as lstat13, mkdir as mkdir23, unlink as unlink6 } from "fs/promises";
+import { chmod as chmod3, lstat as lstat14, mkdir as mkdir23, unlink as unlink6 } from "fs/promises";
 import { createServer as createServer4, Socket } from "net";
 import { dirname as dirname21 } from "path";
 
 // src/pals/auth.ts
 import { randomBytes as randomBytes3, randomUUID as randomUUID21 } from "crypto";
-import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile27, unlink as unlink4 } from "fs/promises";
+import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile28, unlink as unlink4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var PAL_AUTH_TOKEN_BYTES = 32;
 var TOKEN_PATTERN = /^[a-f0-9]{64}$/;
 async function loadOrCreatePalAuthToken(options = {}) {
-  const directory = join36(options.home ?? homedir2(), ".flavor-code", "pals");
-  const tokenPath = join36(directory, "auth-token");
+  const directory = join37(options.home ?? homedir2(), ".flavor-code", "pals");
+  const tokenPath = join37(directory, "auth-token");
   await mkdir21(directory, { recursive: true, mode: 448 });
   await chmod2(directory, 448);
   const token = (options.random ?? randomBytes3)(PAL_AUTH_TOKEN_BYTES).toString("hex");
-  const temporaryPath = join36(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
+  const temporaryPath = join37(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
   let handle;
   try {
     handle = await open12(temporaryPath, "wx", 384);
@@ -29086,7 +29278,7 @@ async function loadOrCreatePalAuthToken(options = {}) {
       if (error.code !== "ENOENT") throw error;
     });
   }
-  const stored = (await readFile27(tokenPath, "utf8")).trim();
+  const stored = (await readFile28(tokenPath, "utf8")).trim();
   if (!TOKEN_PATTERN.test(stored)) throw new Error("Pals authentication token store is invalid");
   await chmod2(tokenPath, 384);
   return stored;
@@ -29098,7 +29290,7 @@ function validatePalAuthToken(token) {
 
 // src/pals/lifecycle.ts
 import { randomUUID as randomUUID22 } from "crypto";
-import { mkdir as mkdir22, open as open13, readFile as readFile28, rename as rename11, stat as stat14, unlink as unlink5 } from "fs/promises";
+import { mkdir as mkdir22, open as open13, readFile as readFile29, rename as rename11, stat as stat14, unlink as unlink5 } from "fs/promises";
 import { dirname as dirname20 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
@@ -29130,7 +29322,7 @@ async function acquirePalFileLock(options) {
     handle = await open13(options.path, "wx", 384);
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
-    const [contents, info] = await Promise.all([readFile28(options.path, "utf8").catch(() => ""), stat14(options.path).catch(() => void 0)]);
+    const [contents, info] = await Promise.all([readFile29(options.path, "utf8").catch(() => ""), stat14(options.path).catch(() => void 0)]);
     if (await options.endpointLive()) return void 0;
     const existing = parseMetadata(contents);
     if (existing !== void 0 && (options.processAlive ?? defaultProcessAlive)(existing.pid)) return void 0;
@@ -29160,7 +29352,7 @@ async function acquirePalFileLock(options) {
     await handle.close();
   }
   const release = async () => {
-    const current = parseMetadata(await readFile28(options.path, "utf8").catch(() => ""));
+    const current = parseMetadata(await readFile29(options.path, "utf8").catch(() => ""));
     if (current?.nonce !== nonce) return;
     await unlink5(options.path).catch((error) => {
       if (error.code !== "ENOENT") throw error;
@@ -29193,7 +29385,7 @@ function canConnect(address) {
 }
 function startupLockPath(address) {
   const digest = createHash21("sha256").update(address, "utf8").digest("hex").slice(0, 24);
-  return join37(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
+  return join38(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
 }
 async function spawnProductionBroker(address) {
   const entry2 = process.argv[1];
@@ -29900,6 +30092,8 @@ async function createProductionRuntime(options) {
   const gitRepository = detectGitRepository(workspace);
   const loaded = await loadConfig({ cwd: workspace, home, environment });
   const config = loaded.config;
+  const globalInstructions = config.globalInstructions.enabled ? new GlobalInstructions(home) : void 0;
+  await globalInstructions?.refresh();
   const mcpReady = connectMcpServers({
     servers: config.mcpServers,
     workspace,
@@ -30034,6 +30228,18 @@ async function createProductionRuntime(options) {
   );
   const registry = new ModelRegistry();
   const diagnostics = [];
+  let lastGlobalInstructionError;
+  const refreshGlobalInstructions = async () => {
+    if (globalInstructions === void 0) return;
+    try {
+      await globalInstructions.refresh();
+      lastGlobalInstructionError = void 0;
+    } catch (error) {
+      const diagnostic = `Global instructions could not be refreshed: ${message(error)}`;
+      if (diagnostic !== lastGlobalInstructionError) diagnostics.push(diagnostic);
+      lastGlobalInstructionError = diagnostic;
+    }
+  };
   const permissionPolicy = await loadPermissionPolicy({
     workspace,
     home,
@@ -30137,8 +30343,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join38(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join38(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join39(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join39(workspace, ".flavor", "plugins")],
     config,
     // Existing project plugins (including astgraph and superharness) use Node.js
     // built-ins. The Worker/vm sandbox deliberately blocks those imports, so it
@@ -30247,7 +30453,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join38(tmpdir4(), `flavor-code-pals-${createHash22("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join39(tmpdir4(), `flavor-code-pals-${createHash22("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -30358,8 +30564,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join38(home, ".flavor-code", "skills")],
-      projectRoots: [join38(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join39(home, ".flavor-code", "skills")],
+      projectRoots: [join39(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -30367,7 +30573,7 @@ async function createProductionRuntime(options) {
     skillsReady.catch(() => void 0);
     tools.push(createSkillTool(skills), createSkillResourceTool(skills));
     if (options.extraTools !== void 0) tools.push(...options.extraTools);
-    const flavor = await optionalText2(join38(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join39(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -30607,6 +30813,7 @@ async function createProductionRuntime(options) {
         ...memoryContext === void 0 ? {} : { memory: memoryContext },
         ...taskState === void 0 ? {} : { taskState },
         userMemory: () => userMemoryContext ?? "",
+        ...globalInstructions === void 0 ? {} : { globalInstructions: () => globalInstructions.content ?? "" },
         ...compactAtChars === void 0 ? {} : { compactAtChars },
         toolOutputChars,
         compaction,
@@ -30644,6 +30851,7 @@ async function createProductionRuntime(options) {
       softLimitFactor: config.maxIterations.softLimitFactor,
       extendIterations: config.maxIterations.extendBy,
       hasActiveProgress,
+      ...globalInstructions === void 0 ? {} : { beforeModelCall: refreshGlobalInstructions },
       afterToolSuccess: async (_tool, paths, _input, _output, context) => workspaceInstructions.discover(paths, context.ownerId ?? context.agent),
       toolJournal: {
         start: (tool, input, retrySafe) => harnessJournal.startTool(tool, input, retrySafe),
@@ -30964,7 +31172,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join38(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join39(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -31004,6 +31212,7 @@ async function createProductionRuntime(options) {
           ...loopInstructionBaseline === "" ? {} : { workspaceInstructions: loopInstructionBaseline },
           ...memoryContext === void 0 ? {} : { memory: memoryContext },
           userMemory: () => userMemoryContext ?? "",
+          ...globalInstructions === void 0 ? {} : { globalInstructions: () => globalInstructions.content ?? "" },
           ...compactAtChars === void 0 ? {} : { compactAtChars },
           toolOutputChars,
           compaction,
@@ -31037,6 +31246,7 @@ async function createProductionRuntime(options) {
         softLimitFactor: config.maxIterations.softLimitFactor,
         extendIterations: config.maxIterations.extendBy,
         loopMode: true,
+        ...globalInstructions === void 0 ? {} : { beforeModelCall: refreshGlobalInstructions },
         afterToolSuccess: async (_tool, paths, _input, _output, context) => loopInstructions.discover(paths, context.ownerId ?? context.agent),
         toolJournal: {
           start: (tool, input2, retrySafe) => harnessJournal.startTool(tool, input2, retrySafe),
@@ -31422,7 +31632,7 @@ async function createProductionRuntime(options) {
           const root = resolve36(workspace);
           const abs = resolve36(root, path);
           if (abs !== root && !abs.startsWith(root + sep25)) throw new Error(`path outside workspace: ${path}`);
-          return readFile29(abs, "utf8");
+          return readFile30(abs, "utf8");
         },
         history: async (path, limit) => fileHistory(workspace, path, limit),
         questions,
@@ -31434,7 +31644,7 @@ async function createProductionRuntime(options) {
       }, query, focus, signal),
       audit: async (toolFilter) => {
         try {
-          const raw = await readFile29(auditLogger.path, "utf8");
+          const raw = await readFile30(auditLogger.path, "utf8");
           const lines = raw.trim().split("\n").filter((line) => line.length > 0);
           const entries = lines.map((line) => {
             try {
@@ -31474,7 +31684,7 @@ ${summary2}`;
       doctor: async () => formatDoctorReport(await runDoctor({ workspace, home, environment })),
       usage: async () => {
         try {
-          const raw = await readFile29(usageLogPath(), "utf8");
+          const raw = await readFile30(usageLogPath(), "utf8");
           return formatUsageSummary(summarizeUsage(parseUsageEntries(raw)));
         } catch (error) {
           if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
@@ -31553,6 +31763,28 @@ ${summary2}`;
 Path: ${memoryStore.path}` : `Path: ${memoryStore.path}
 
 ${renderMemoryDocument(entries)}`;
+      },
+      global: async (command2) => {
+        const path = join39(home, ".flavor-code", "GLOBAL.md");
+        if (globalInstructions === void 0) return `Global instructions are disabled.
+Path: ${path}`;
+        if (command2.action === "show") {
+          await globalInstructions.refresh();
+          return globalInstructions.content === void 0 ? `No global instructions stored.
+Path: ${path}` : `Global instructions (enabled)
+Path: ${path}
+
+${globalInstructions.content}`;
+        }
+        if (command2.action === "remember") {
+          const result2 = await globalInstructions.remember(command2.text);
+          return result2 === "added" ? `Remembered global rule.
+Path: ${path}` : `Global rule already exists.
+Path: ${path}`;
+        }
+        const result = await globalInstructions.forget(command2.text);
+        return result === "removed" ? `Forgot global rule.
+Path: ${path}` : result === "ambiguous" ? "Multiple global rules match. Use the full text of one rule." : "No matching global rule found.";
       },
       refreshMemory: refreshMemoryState,
       remember: async (type, text) => {
@@ -31627,7 +31859,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join38(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join39(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -31675,7 +31907,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join38(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join39(home, ".flavor-code", "auth.json"));
         const tokens2 = await tokenStore.load();
         const hadCredentials = Object.keys(tokens2).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -31986,7 +32218,7 @@ async function workspaceFingerprint(workspace) {
     hash.update(name);
     if (remaining <= 0) continue;
     try {
-      const content = await readFile29(path);
+      const content = await readFile30(path);
       const slice = content.subarray(0, remaining);
       hash.update(slice);
       remaining -= slice.length;
@@ -32257,7 +32489,7 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
   const configured = { ...providers };
   if (configured.openai === void 0 && environment.OPENAI_API_KEY) configured.openai = { type: "openai", apiKey: environment.OPENAI_API_KEY };
   if (configured.anthropic === void 0 && environment.ANTHROPIC_API_KEY) configured.anthropic = { type: "anthropic", apiKey: environment.ANTHROPIC_API_KEY };
-  const oauthTokenStore = createFileTokenStore(join38(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join39(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -32566,7 +32798,7 @@ async function generateSleepReview(registry, modelId, prompt, signal) {
 }
 async function optionalText2(path) {
   try {
-    return await readFile29(path, "utf8");
+    return await readFile30(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
     throw error;
@@ -32747,13 +32979,13 @@ function createMemoryTaskId() {
 
 // src/desktop/runtime-controller.ts
 import { createHash as createHash28 } from "crypto";
-import { mkdir as mkdir27, readFile as readFile37, readdir as readdir13, rm as rm15, stat as stat17, writeFile as writeFile17 } from "fs/promises";
+import { mkdir as mkdir27, readFile as readFile38, readdir as readdir13, rm as rm15, stat as stat17, writeFile as writeFile17 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename10, join as join48, resolve as resolve39 } from "path";
+import { basename as basename10, join as join49, resolve as resolve39 } from "path";
 
 // src/d2c/workflow.ts
 import { createHash as createHash23 } from "crypto";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import { z as z44 } from "zod";
 
 // src/d2c/workflow-shared.ts
@@ -32899,7 +33131,7 @@ function reviewsFor(report, previous) {
 function implementationDirectory(report) {
   const source = report.implementation.source;
   if (!/^https?:\/\//i.test(source)) return source;
-  return join39("src", "d2c-output", report.task);
+  return join40("src", "d2c-output", report.task);
 }
 function createWorkflow(report, framework) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -33023,7 +33255,7 @@ function applyQualityIssueDecision(workflow, issueId2, decision) {
   };
 }
 function workflowPath(workspace, task) {
-  return join39(taskDir(workspace, task), "workflow.json");
+  return join40(taskDir(workspace, task), "workflow.json");
 }
 async function readWorkflow(workspace, task) {
   return (await readRecoverableFile(workflowPath(workspace, task), decodeWorkflow))?.value;
@@ -33276,8 +33508,8 @@ function confirmApiMapping(mapping, operationKey, operations) {
 }
 
 // src/d2c/modules.ts
-import { readFile as readFile30 } from "fs/promises";
-import { isAbsolute as isAbsolute18, join as join40, normalize as normalize2, posix, sep as sep26, win32 as win322 } from "path";
+import { readFile as readFile31 } from "fs/promises";
+import { isAbsolute as isAbsolute18, join as join41, normalize as normalize2, posix, sep as sep26, win32 as win322 } from "path";
 import { z as z45 } from "zod";
 var ModuleSchema = z45.object({
   id: z45.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
@@ -33296,13 +33528,13 @@ function safeSource(path) {
 }
 function d2cOutputDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error(`Invalid D2C task: ${task}`);
-  return join40(workspace, "src", "d2c-output", task);
+  return join41(workspace, "src", "d2c-output", task);
 }
 async function readD2cModules(workspace, task) {
   const project = d2cOutputDirectory(workspace, task);
   let raw;
   try {
-    raw = await readFile30(join40(project, "d2c.modules.json"), "utf8");
+    raw = await readFile31(join41(project, "d2c.modules.json"), "utf8");
   } catch {
     return [{ id: "page", label: task, sourceFiles: ["src/App.vue", "src/App.jsx"], keywords: [task] }];
   }
@@ -33322,8 +33554,8 @@ async function readD2cModules(workspace, task) {
 }
 
 // src/d2c/integration.ts
-import { mkdir as mkdir24, readFile as readFile31, writeFile as writeFile13 } from "fs/promises";
-import { join as join41 } from "path";
+import { mkdir as mkdir24, readFile as readFile32, writeFile as writeFile13 } from "fs/promises";
+import { join as join42 } from "path";
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -33459,19 +33691,19 @@ async def reset_acceptance(request: Request):
 }
 async function generateIntegrationArtifacts(projectDir, document, mappings, options = {}) {
   if (mappings.some((mapping) => mapping.status === "needs-confirmation")) throw new Error("Confirm every uncertain OpenAPI mapping before generating integration code");
-  const packagePath = join41(projectDir, "package.json");
+  const packagePath = join42(projectDir, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile31(packagePath, "utf8"));
+    pkg = JSON.parse(await readFile32(packagePath, "utf8"));
   } catch {
     throw new Error(`D2C integration requires a valid package.json at ${packagePath}`);
   }
   const scripts = options.pythonServer ? { ...record2(pkg.scripts) ?? {} } : { ...record2(pkg.scripts) ?? {}, mock: "node mock/server.mjs" };
   const dependencies2 = options.pythonServer ? { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9" } : { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9", express: "^5.2.1" };
   const selected = [...new Set(mappings.map((mapping) => mapping.operationKey))].map((key) => document.operations.find((operation) => operation.id === key)).filter((operation) => operation !== void 0);
-  const apiDir = join41(projectDir, "src", "api");
-  const mockDir = join41(projectDir, "mock");
-  const serverDir = join41(projectDir, "server");
+  const apiDir = join42(projectDir, "src", "api");
+  const mockDir = join42(projectDir, "mock");
+  const serverDir = join42(projectDir, "server");
   await Promise.all([
     mkdir24(apiDir, { recursive: true }),
     ...options.pythonServer ? [] : [mkdir24(mockDir, { recursive: true })],
@@ -33481,23 +33713,23 @@ async function generateIntegrationArtifacts(projectDir, document, mappings, opti
   if (options.pythonServer) files.push("server/main.py", "server/requirements.txt", "server/README.md", "server/flavor-runtime.json");
   else files.push("mock/server.mjs");
   await Promise.all([
-    writeFile13(join41(apiDir, "http.js"), `import axios from "axios";
+    writeFile13(join42(apiDir, "http.js"), `import axios from "axios";
 
 export const http = axios.create({ baseURL: import.meta.env.VITE_API_BASE_URL || ${JSON.stringify(document.baseUrl ?? "")}, timeout: 15000 });
 
 http.interceptors.response.use((response) => response, (error) => Promise.reject({ name: "ApiError", status: error.response?.status, message: error.response?.data?.message || error.message, cause: error }));
 `),
-    writeFile13(join41(apiDir, "d2c-api.js"), apiModule(selected)),
-    writeFile13(join41(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
+    writeFile13(join42(apiDir, "d2c-api.js"), apiModule(selected)),
+    writeFile13(join42(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
 `),
-    ...options.pythonServer ? [] : [writeFile13(join41(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
+    ...options.pythonServer ? [] : [writeFile13(join42(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
     writeFile13(packagePath, `${JSON.stringify({ ...pkg, scripts, dependencies: dependencies2 }, null, 2)}
 `),
     ...options.pythonServer ? [
-      writeFile13(join41(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
-      writeFile13(join41(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
-      writeFile13(join41(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
-      writeFile13(join41(serverDir, "flavor-runtime.json"), `${JSON.stringify({
+      writeFile13(join42(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
+      writeFile13(join42(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
+      writeFile13(join42(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
+      writeFile13(join42(serverDir, "flavor-runtime.json"), `${JSON.stringify({
         schema: 1,
         kind: "python-fastapi",
         cwd: "server",
@@ -33516,9 +33748,9 @@ http.interceptors.response.use((response) => response, (error) => Promise.reject
 
 // src/d2c/mock-runner.ts
 import { spawn as spawn9 } from "child_process";
-import { access as access4, readFile as readFile32 } from "fs/promises";
+import { access as access4, readFile as readFile33 } from "fs/promises";
 import { createServer as createServer5 } from "net";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 async function exists3(path) {
   try {
     await access4(path);
@@ -33626,7 +33858,7 @@ ${output.trim()}` : ""}`);
   }
 }
 async function runPythonBackend(projectDir, options) {
-  const serverDir = join42(projectDir, "server");
+  const serverDir = join43(projectDir, "server");
   if (options.installDependencies !== false) await installPython(serverDir, options.signal);
   const selectedPort = await port();
   const url = `http://127.0.0.1:${selectedPort}`;
@@ -33672,20 +33904,20 @@ ${managed.output().slice(-4e3)}`);
   };
 }
 async function runD2cMockServer(projectDir, options = {}) {
-  const runtimePath = join42(projectDir, "server", "flavor-runtime.json");
+  const runtimePath = join43(projectDir, "server", "flavor-runtime.json");
   if (await exists3(runtimePath)) {
     let runtime;
     try {
-      runtime = JSON.parse(await readFile32(runtimePath, "utf8"));
+      runtime = JSON.parse(await readFile33(runtimePath, "utf8"));
     } catch {
       throw new Error(`E2E backend runtime manifest is invalid at ${runtimePath}`);
     }
     if (runtime.schema !== 1 || runtime.kind !== "python-fastapi") throw new Error("Unsupported E2E backend runtime manifest");
     return runPythonBackend(projectDir, options);
   }
-  const serverPath = join42(projectDir, "mock", "server.mjs");
+  const serverPath = join43(projectDir, "mock", "server.mjs");
   if (!await exists3(serverPath)) throw new Error(`D2C mock server is not generated at ${serverPath}`);
-  if (options.installDependencies === false && !await exists3(join42(projectDir, "node_modules", "express", "package.json"))) {
+  if (options.installDependencies === false && !await exists3(join43(projectDir, "node_modules", "express", "package.json"))) {
     throw new Error("D2C mock server dependencies are not installed");
   }
   if (options.installDependencies !== false) await install(projectDir, options.signal);
@@ -33727,13 +33959,13 @@ ${managed.output().slice(-4e3)}`);
 
 // src/d2c/product.ts
 import { createHash as createHash25, randomUUID as randomUUID27 } from "crypto";
-import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile34, rename as rename13, stat as stat15, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
-import { join as join43 } from "path";
+import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile35, rename as rename13, stat as stat15, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
+import { join as join44 } from "path";
 import { z as z46 } from "zod";
 
 // src/e2e/prd-governance.ts
 import { createHash as createHash24, randomUUID as randomUUID26 } from "crypto";
-import { readFile as readFile33, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
+import { readFile as readFile34, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
 function hashPrd(markdown) {
   return createHash24("sha256").update(markdown, "utf8").digest("hex");
 }
@@ -33810,14 +34042,14 @@ function approvePrd(markdown, now = /* @__PURE__ */ new Date()) {
   return { hash: hashPrd(markdown), approvedAt: now.toISOString(), criteria };
 }
 async function assertApprovedPrd(path, approved) {
-  const current = await readFile33(path, "utf8");
+  const current = await readFile34(path, "utf8");
   if (hashPrd(current) !== approved.hash) {
     throw new Error("PRD_LOCK_VIOLATION: confirmed PRD content changed after approval");
   }
   return approved;
 }
 async function updatePrdSectionFile(path, input) {
-  const current = await readFile33(path, "utf8");
+  const current = await readFile34(path, "utf8");
   if (hashPrd(current) !== input.expectedHash) {
     throw new Error("PRD_EDIT_CONFLICT: the PRD changed; refresh before saving this section");
   }
@@ -33883,13 +34115,13 @@ var PlanSchema2 = z46.object({
 }).strict();
 function d2cProductDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error("Invalid D2C task name");
-  return join43(taskDir(workspace, task), "product");
+  return join44(taskDir(workspace, task), "product");
 }
 function d2cProductPrototypeDirectory(workspace, task) {
-  return join43(d2cProductDirectory(workspace, task), "prototype");
+  return join44(d2cProductDirectory(workspace, task), "prototype");
 }
 function planPath(workspace, task) {
-  return join43(taskDir(workspace, task), "product-plan.json");
+  return join44(taskDir(workspace, task), "product-plan.json");
 }
 function resolveD2cProductTechnology(requirement, fallbackFramework = "vue") {
   const frontendCandidates = [
@@ -33981,14 +34213,14 @@ async function fileTimestamp(path) {
   return info?.isFile() ? info.mtime.toISOString() : void 0;
 }
 async function fileHash(path) {
-  const buffer = await readFile34(path).catch((error) => {
+  const buffer = await readFile35(path).catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
   return buffer === void 0 ? void 0 : createHash25("sha256").update(buffer).digest("hex");
 }
 async function validateAndNormalizePrototypeManifest(path) {
-  const raw = await readFile34(path, "utf8").catch((error) => {
+  const raw = await readFile35(path, "utf8").catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
@@ -34064,7 +34296,7 @@ async function createD2cProductPlan(workspace, input, now = () => /* @__PURE__ *
   });
 }
 async function readD2cProductPlan(workspace, task) {
-  const raw = await readFile34(planPath(workspace, task), "utf8").catch((error) => {
+  const raw = await readFile35(planPath(workspace, task), "utf8").catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
@@ -34072,16 +34304,16 @@ async function readD2cProductPlan(workspace, task) {
 }
 async function discoverD2cProductArtifacts(workspace, plan) {
   const product = d2cProductDirectory(workspace, plan.task);
-  const prdUpdatedAt = await fileTimestamp(join43(product, "prd.md"));
-  const prdHash = await fileHash(join43(product, "prd.md"));
-  const prototypeUpdatedAt = await fileTimestamp(join43(product, "prototype", "index.html"));
-  const prototypeHash = await fileHash(join43(product, "prototype", "index.html"));
-  const expectedManifest = join43(product, "prototype", "interaction-manifest.json");
+  const prdUpdatedAt = await fileTimestamp(join44(product, "prd.md"));
+  const prdHash = await fileHash(join44(product, "prd.md"));
+  const prototypeUpdatedAt = await fileTimestamp(join44(product, "prototype", "index.html"));
+  const prototypeHash = await fileHash(join44(product, "prototype", "index.html"));
+  const expectedManifest = join44(product, "prototype", "interaction-manifest.json");
   let manifestUpdatedAt = await fileTimestamp(expectedManifest);
   if (manifestUpdatedAt === void 0) {
-    const misplacedManifest = join43(product, "interaction-manifest.json");
+    const misplacedManifest = join44(product, "interaction-manifest.json");
     if (await fileTimestamp(misplacedManifest) !== void 0) {
-      await mkdir25(join43(product, "prototype"), { recursive: true });
+      await mkdir25(join44(product, "prototype"), { recursive: true });
       await copyFile2(misplacedManifest, expectedManifest);
       manifestUpdatedAt = await fileTimestamp(expectedManifest);
     }
@@ -34114,8 +34346,8 @@ async function readD2cProductPlanView(workspace, task) {
   if (stored === void 0) return void 0;
   const plan = await discoverD2cProductArtifacts(workspace, stored);
   if (plan.revision !== stored.revision) await writeD2cProductPlan(workspace, plan);
-  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile34(join43(taskDir(workspace, task), plan.prd.path), "utf8");
-  const manifestPath = join43(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
+  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile35(join44(taskDir(workspace, task), plan.prd.path), "utf8");
+  const manifestPath = join44(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
   const validationError = plan.phase === "design-generating" && await fileTimestamp(manifestPath) !== void 0 ? await validateAndNormalizePrototypeManifest(manifestPath) : void 0;
   return {
     plan,
@@ -34205,9 +34437,9 @@ ${prdMarkdown.slice(0, 2e4)}`
 
 // src/e2e/acceptance-baseline.ts
 import { createHash as createHash26 } from "crypto";
-import { readFile as readFile35 } from "fs/promises";
+import { readFile as readFile36 } from "fs/promises";
 async function fileArtifact(path) {
-  const content = await readFile35(path);
+  const content = await readFile36(path);
   return { path, hash: createHash26("sha256").update(content).digest("hex"), bytes: content.byteLength };
 }
 async function verifyAcceptanceArtifact(path, expected, label) {
@@ -34274,7 +34506,7 @@ function createAcceptanceEvidence(coverage, run, now = /* @__PURE__ */ new Date(
 
 // src/e2e/delivery-run.ts
 import { createHash as createHash27 } from "crypto";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 import { z as z47 } from "zod";
 var DELIVERY_NODE_IDS = ["requirement", "prd", "design", "d2c", "api", "acceptance", "delivery"];
 var ArtifactSchema = z47.object({
@@ -34391,7 +34623,7 @@ function completeDeliveryNode(run, node, outputs, now = /* @__PURE__ */ new Date
   return { ...run, nodes, updatedAt: timestamp2 };
 }
 function deliveryRunPath(workspace, task) {
-  return join44(taskDir(workspace, task), "delivery-run.json");
+  return join45(taskDir(workspace, task), "delivery-run.json");
 }
 function decodeDeliveryRun(raw) {
   return DeliveryRunSchema.parse(JSON.parse(raw));
@@ -34432,9 +34664,9 @@ async function updateDeliveryRun(workspace, task, expectedRevision, mutation) {
 }
 
 // src/skills/manager.ts
-import { lstat as lstat14, mkdir as mkdir26, readFile as readFile36, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
+import { lstat as lstat15, mkdir as mkdir26, readFile as readFile37, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { isAbsolute as isAbsolute19, join as join45, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
+import { isAbsolute as isAbsolute19, join as join46, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
 import { stringify } from "yaml";
 var SkillManager = class {
   #workspace;
@@ -34457,7 +34689,7 @@ var SkillManager = class {
   async create(draft) {
     const value = parseDraft(draft);
     const projectRoot = this.#projectRoot();
-    const directory = join45(projectRoot, value.name);
+    const directory = join46(projectRoot, value.name);
     await mkdir26(projectRoot, { recursive: true, mode: 448 });
     try {
       await mkdir26(directory, { mode: 448 });
@@ -34466,7 +34698,7 @@ var SkillManager = class {
       throw error;
     }
     try {
-      await writeFile16(join45(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
+      await writeFile16(join46(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
       await this.#persistEnabled(value.name, true);
       return this.get(value.name);
     } catch (error) {
@@ -34479,13 +34711,13 @@ var SkillManager = class {
     const value = parseDraft(draft);
     if (value.name !== validName) throw new Error("Rename is not supported; create a new skill instead");
     const directory = this.#projectSkillDirectory(validName);
-    const info = await lstat14(directory).catch((error) => {
+    const info = await lstat15(directory).catch((error) => {
       if (isCode11(error, "ENOENT")) throw new Error(`Project skill not found: ${validName}`);
       throw error;
     });
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Project skill path is not a real directory: ${validName}`);
-    const skillFile = join45(directory, "SKILL.md");
-    const fileInfo = await lstat14(skillFile);
+    const skillFile = join46(directory, "SKILL.md");
+    const fileInfo = await lstat15(skillFile);
     if (!fileInfo.isFile() || fileInfo.isSymbolicLink()) throw new Error(`Project skill file is not a real file: ${validName}`);
     await writeFile16(skillFile, renderSkill(value), { encoding: "utf8", mode: 384 });
     return this.get(validName);
@@ -34493,7 +34725,7 @@ var SkillManager = class {
   async delete(name) {
     const validName = parseName(name);
     const directory = this.#projectSkillDirectory(validName);
-    const info = await lstat14(directory).catch((error) => {
+    const info = await lstat15(directory).catch((error) => {
       if (isCode11(error, "ENOENT")) throw new Error(`Project skill not found: ${validName}`);
       throw error;
     });
@@ -34516,12 +34748,12 @@ var SkillManager = class {
   async #registry() {
     const loaded = await loadConfig({ cwd: this.#workspace, home: this.#home });
     const [globalPluginRoots, projectPluginRoots] = await Promise.all([
-      discoverPluginSkillRoots(join45(this.#home, ".flavor-code", "plugins")),
-      discoverPluginSkillRoots(join45(this.#workspace, ".flavor", "plugins"))
+      discoverPluginSkillRoots(join46(this.#home, ".flavor-code", "plugins")),
+      discoverPluginSkillRoots(join46(this.#workspace, ".flavor", "plugins"))
     ]);
     return {
       registry: new SkillRegistry({
-        globalRoots: [join45(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
+        globalRoots: [join46(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
         projectRoots: [this.#projectRoot(), ...projectPluginRoots]
       }),
       disabled: new Set(loaded.config.skills.disabled)
@@ -34537,10 +34769,10 @@ var SkillManager = class {
     };
   }
   #projectRoot() {
-    return join45(this.#workspace, ".flavor", "skills");
+    return join46(this.#workspace, ".flavor", "skills");
   }
   #projectSkillDirectory(name) {
-    return join45(this.#projectRoot(), name);
+    return join46(this.#projectRoot(), name);
   }
 };
 function parseName(value) {
@@ -34581,12 +34813,12 @@ async function discoverPluginSkillRoots(directory) {
   const roots = [];
   for (const entry2 of entries) {
     if (!entry2.isDirectory() || entry2.isSymbolicLink()) continue;
-    const pluginRoot = await realpath13(join45(directory, entry2.name));
+    const pluginRoot = await realpath13(join46(directory, entry2.name));
     try {
-      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile36(join45(pluginRoot, "flavor-plugin.json"), "utf8")));
+      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile37(join46(pluginRoot, "flavor-plugin.json"), "utf8")));
       for (const contribution of manifest.contributes.skillRoots) {
         const candidate = resolve37(pluginRoot, contribution.path);
-        const info = await lstat14(candidate);
+        const info = await lstat15(candidate);
         if (!info.isDirectory() || info.isSymbolicLink()) continue;
         const physical = await realpath13(candidate);
         const relation = relative26(pluginRoot, physical);
@@ -34658,11 +34890,11 @@ async function createProjectMemoryManager(options) {
 }
 
 // src/mcp/config-manager.ts
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 var ProjectMcpConfigManager = class {
   path;
   constructor(workspace) {
-    this.path = join46(workspace, ".flavor", "flavor.json");
+    this.path = join47(workspace, ".flavor", "flavor.json");
   }
   async list() {
     const document = await readRecoverableFile(this.path, (raw) => parseDocument2(this.path, raw));
@@ -34759,7 +34991,7 @@ function isRecord7(value) {
 }
 
 // src/desktop/model-config.ts
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 var DEFAULT_DESKTOP_MODELS = [
   {
     id: "anthropic:deepseek-v4-pro",
@@ -34780,7 +35012,7 @@ var DEFAULT_DESKTOP_MODELS = [
 ];
 async function loadDesktopModels(workspace, home) {
   try {
-    const tokens2 = await createFileTokenStore(join47(home, ".flavor-code", "auth.json")).load();
+    const tokens2 = await createFileTokenStore(join48(home, ".flavor-code", "auth.json")).load();
     const pkceModels = [];
     const knownPkce = /* @__PURE__ */ new Set();
     for (const token of Object.values(tokens2)) {
@@ -34925,33 +35157,33 @@ function pngDataUrl(png) {
 }
 async function detectD2cFramework(workspace, task) {
   try {
-    const pkg = JSON.parse(await readFile37(join48(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
+    const pkg = JSON.parse(await readFile38(join49(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
     return pkg.dependencies?.react === void 0 ? "vue" : "react";
   } catch {
     return "vue";
   }
 }
 function integrationDirectory(workspace, task) {
-  return join48(workspace, ".flavor", "d2c", task, "integration");
+  return join49(workspace, ".flavor", "d2c", task, "integration");
 }
 var D2C_BACKEND_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".cfg", ".env", ".ini", ".js", ".json", ".lock", ".mjs", ".py", ".toml", ".txt", ".yaml", ".yml"]);
 var D2C_BACKEND_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".venv", "__pycache__", "data", "node_modules", "venv"]);
 async function d2cBackendSourceFingerprint(project) {
-  const runtimeManifest = join48(project, "server", "flavor-runtime.json");
+  const runtimeManifest = join49(project, "server", "flavor-runtime.json");
   const realBackend = (await stat17(runtimeManifest).catch(() => void 0))?.isFile() === true;
-  const root = realBackend ? join48(project, "server") : join48(project, "mock");
+  const root = realBackend ? join49(project, "server") : join49(project, "mock");
   if ((await stat17(root).catch(() => void 0))?.isDirectory() !== true) return void 0;
   const files = [];
   const visit = async (directory) => {
     const entries = await readdir13(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (entry2.isDirectory()) {
-        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join48(directory, entry2.name));
+        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join49(directory, entry2.name));
         continue;
       }
       if (!entry2.isFile()) continue;
       const extension2 = entry2.name.includes(".") ? `.${entry2.name.split(".").pop().toLowerCase()}` : "";
-      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join48(directory, entry2.name));
+      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join49(directory, entry2.name));
     }
   };
   await visit(root);
@@ -34959,7 +35191,7 @@ async function d2cBackendSourceFingerprint(project) {
   for (const path of files.sort()) {
     hash.update(path.slice(root.length));
     hash.update("\0");
-    hash.update(await readFile37(path));
+    hash.update(await readFile38(path));
     hash.update("\0");
   }
   return hash.digest("hex");
@@ -35507,7 +35739,7 @@ var DesktopRuntimeController = class {
     if (workflow === void 0 || !reviewProgress(workflow).complete || workflow.stage === "visual-review") {
       throw new Error("Complete visual review before importing OpenAPI");
     }
-    const moduleManifest = join48(d2cOutputDirectory(workspace, task), "d2c.modules.json");
+    const moduleManifest = join49(d2cOutputDirectory(workspace, task), "d2c.modules.json");
     const moduleManifestInfo = await stat17(moduleManifest).catch(() => void 0);
     if (moduleManifestInfo === void 0 || !moduleManifestInfo.isFile()) {
       throw new Error("D2C implementation must write d2c.modules.json before API mapping; ask the agent to split the project into modules first");
@@ -35520,8 +35752,8 @@ var DesktopRuntimeController = class {
     await mkdir27(dir, { recursive: true });
     const hash = createHash28("sha256").update(raw).digest("hex");
     await Promise.all([
-      writeFile17(join48(dir, "swagger.json"), raw),
-      writeFile17(join48(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
+      writeFile17(join49(dir, "swagger.json"), raw),
+      writeFile17(join49(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
 `)
     ]);
     const next = {
@@ -35547,7 +35779,7 @@ var DesktopRuntimeController = class {
     await this.#assertProductPrdLocked(workspace, task);
     const info = await stat17(sourcePath);
     if (!info.isFile() || info.size > 8 * 1024 * 1024) throw new Error("OpenAPI JSON must be a file no larger than 8 MiB");
-    return this.#storeD2cOpenApi(workspace, task, basename10(sourcePath), await readFile37(sourcePath, "utf8"), false);
+    return this.#storeD2cOpenApi(workspace, task, basename10(sourcePath), await readFile38(sourcePath, "utf8"), false);
   }
   async getD2cIntegration(task) {
     const workspace = this.#workspace;
@@ -35556,8 +35788,8 @@ var DesktopRuntimeController = class {
     let workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi === void 0 && workflow !== void 0 && reviewProgress(workflow).complete && await readD2cProductPlanView(workspace, task) !== void 0) {
       const modules = await readD2cModules(workspace, task);
-      const productOpenApiPath = join48(taskDir(workspace, task), "product", "openapi.json");
-      const authored = await readFile37(productOpenApiPath, "utf8").catch(() => void 0);
+      const productOpenApiPath = join49(taskDir(workspace, task), "product", "openapi.json");
+      const authored = await readFile38(productOpenApiPath, "utf8").catch(() => void 0);
       const generated = authored === void 0;
       const prepared = await this.#storeD2cOpenApi(
         workspace,
@@ -35569,7 +35801,7 @@ var DesktopRuntimeController = class {
       return prepared;
     }
     if (workflow?.openapi === void 0 || workflow.mappings === void 0) return void 0;
-    const document = JSON.parse(await readFile37(join48(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
+    const document = JSON.parse(await readFile38(join49(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
     return { workflow, document, mappings: workflow.mappings };
   }
   async confirmD2cMapping(task, moduleId, operationKey) {
@@ -35636,7 +35868,7 @@ var DesktopRuntimeController = class {
     ].join("\n");
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery?.nodes.api.status === "running") {
-      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile37(join48(project, file)))));
+      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile38(join49(project, file)))));
       const completed = await updateDeliveryRun(
         workspace,
         task,
@@ -35663,8 +35895,8 @@ var DesktopRuntimeController = class {
     try {
       const fingerprint2 = await d2cBackendSourceFingerprint(project);
       if (fingerprint2 !== void 0) this.#d2cMockSourceFingerprints.set(task, fingerprint2);
-      const environmentPath = join48(project, ".env.local");
-      const existingEnvironment = await readFile37(environmentPath, "utf8").catch(() => "");
+      const environmentPath = join49(project, ".env.local");
+      const existingEnvironment = await readFile38(environmentPath, "utf8").catch(() => "");
       const environment = `${existingEnvironment.split(/\r?\n/).filter((line) => !/^\s*VITE_API_BASE_URL\s*=/.test(line)).join("\n").trim()}
 VITE_API_BASE_URL=${running.url}
 `.replace(/^\n/, "");
@@ -35744,8 +35976,8 @@ VITE_API_BASE_URL=${running.url}
     const readyPreview = this.#d2cPreviews.get(task);
     const readyMock = this.#d2cMocks.get(task);
     if (readyPreview === void 0 || readyMock === void 0) throw new Error("D2C preview or backend service is unavailable after synchronization");
-    const manifestPath = join48(taskDir(workspace, task), "design", "interaction-manifest.json");
-    const manifest = parseInteractionManifest(await readFile37(manifestPath, "utf8"));
+    const manifestPath = join49(taskDir(workspace, task), "design", "interaction-manifest.json");
+    const manifest = parseInteractionManifest(await readFile38(manifestPath, "utf8"));
     const baseline = await this.#verifyAcceptanceBaseline(workspace, task);
     const coverage = baseline === void 0 ? void 0 : verifyRequirementCoverage(baseline.approvedPrd.criteria, manifest);
     let executableManifest = manifest;
@@ -35756,7 +35988,7 @@ VITE_API_BASE_URL=${running.url}
       await mkdir27(planDir, { recursive: true });
       try {
         const observations = await this.#observeD2cPages(manifest, readyPreview.url);
-        const prd = await readFile37(join48(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
+        const prd = await readFile38(join49(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
         const apiContext = JSON.stringify({ openapi: workflow.openapi, mappings: workflow.mappings }, null, 2);
         const plan = await this.#d2cJudge.planInteractions({ task, seed: manifest, observations, ...prd === void 0 ? {} : { prd }, apiContext });
         executableManifest = mergeInteractionManifests(manifest, plan.manifest);
@@ -35767,9 +35999,9 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: executableManifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           pageAnalyses: plan.pageAnalyses
         };
-        await writeFile17(join48(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
+        await writeFile17(join49(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-        await rm15(join48(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
+        await rm15(join49(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
       } catch (cause) {
         const detail = message(cause);
         review = {
@@ -35777,8 +36009,8 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: manifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           warning: `\u591A\u6A21\u6001\u81EA\u4E3B\u89C4\u5212\u5931\u8D25\uFF0C\u5DF2\u7EE7\u7EED\u6267\u884C\u5DF2\u786E\u8BA4\u7684\u8BBE\u8BA1\u5951\u7EA6\uFF1A${detail}`
         };
-        await rm15(join48(planDir, "autonomous-interaction-plan.json"), { force: true });
-        await writeFile17(join48(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
+        await rm15(join49(planDir, "autonomous-interaction-plan.json"), { force: true });
+        await writeFile17(join49(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
           schema: 1,
           stage: "planning",
           occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -35792,13 +36024,13 @@ VITE_API_BASE_URL=${running.url}
     let result = { ...rawResult, evidenceMode: review.mode };
     if (coverage !== void 0) {
       const evidence = createAcceptanceEvidence(coverage, result);
-      await writeFile17(join48(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
+      await writeFile17(join49(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       if (!evidence.passed) result = { ...result, passed: false, failures: Math.max(1, result.failures) };
     }
     const dir = integrationDirectory(workspace, task);
     await mkdir27(dir, { recursive: true });
-    await writeFile17(join48(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
+    await writeFile17(join49(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
 `);
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyInteractionRun(current, result));
     return { workflow: next, result, review };
@@ -35811,7 +36043,7 @@ VITE_API_BASE_URL=${running.url}
     if (mock === void 0 || !mock.exited() || result.failures === 0) return result;
     const output = mock.output().trim();
     try {
-      const dir = join48(d2cOutputDirectory(workspace, task), "mock-server.log");
+      const dir = join49(d2cOutputDirectory(workspace, task), "mock-server.log");
       await writeFile17(dir, `${output}
 `);
     } catch {
@@ -35906,7 +36138,7 @@ VITE_API_BASE_URL=${running.url}
     if (current === void 0) throw new Error("D2C product plan is unavailable");
     if (current.plan.approvedPrd !== void 0) throw new Error("The approved PRD is immutable and cannot be edited");
     if (current.plan.phase !== "prd-review") throw new Error("PRD sections can only be edited during PRD review");
-    const path = join48(taskDir(workspace, task), "product", "prd.md");
+    const path = join49(taskDir(workspace, task), "product", "prd.md");
     const updated = await updatePrdSectionFile(path, { sectionId, body, expectedHash });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await writeD2cProductPlan(workspace, {
@@ -35926,15 +36158,15 @@ VITE_API_BASE_URL=${running.url}
   async #assertProductPrdLocked(workspace, task) {
     const current = await readD2cProductPlanView(workspace, task);
     if (current?.plan.approvedPrd === void 0) return;
-    await assertApprovedPrd(join48(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
+    await assertApprovedPrd(join49(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
   }
   async #acceptancePaths(workspace, task) {
-    const product = join48(taskDir(workspace, task), "product");
-    const openapi = join48(product, "openapi.json");
+    const product = join49(taskDir(workspace, task), "product");
+    const openapi = join49(product, "openapi.json");
     return {
-      prd: join48(product, "prd.md"),
-      prototype: join48(product, "prototype", "index.html"),
-      interaction: join48(product, "prototype", "interaction-manifest.json"),
+      prd: join49(product, "prd.md"),
+      prototype: join49(product, "prototype", "index.html"),
+      interaction: join49(product, "prototype", "interaction-manifest.json"),
       ...await stat17(openapi).catch(() => void 0) === void 0 ? {} : { openapi }
     };
   }
@@ -35942,17 +36174,17 @@ VITE_API_BASE_URL=${running.url}
     const product = await readD2cProductPlanView(workspace, task);
     if (product?.plan.approvedPrd === void 0) return void 0;
     await this.#assertProductPrdLocked(workspace, task);
-    const baseline = JSON.parse(await readFile37(join48(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
+    const baseline = JSON.parse(await readFile38(join49(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
     await verifyAcceptanceBaseline(await this.#acceptancePaths(workspace, task), baseline);
-    const design = join48(taskDir(workspace, task), "design");
+    const design = join49(taskDir(workspace, task), "design");
     await Promise.all([
-      verifyAcceptanceArtifact(join48(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
-      verifyAcceptanceArtifact(join48(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
+      verifyAcceptanceArtifact(join49(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
+      verifyAcceptanceArtifact(join49(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
     ]);
     const workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi !== void 0) {
       await verifyAcceptanceArtifact(
-        join48(taskDir(workspace, task), "integration", "swagger.json"),
+        join49(taskDir(workspace, task), "integration", "swagger.json"),
         { hash: workflow.openapi.hash },
         "runtime OpenAPI contract"
       );
@@ -35973,14 +36205,14 @@ VITE_API_BASE_URL=${running.url}
       throw new Error("D2C PRD is empty and cannot be accepted");
     }
     if (stage === "design" && accepted) {
-      const manifest = join48(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
-      const normalizedManifest = parseInteractionManifest(await readFile37(manifest, "utf8"));
+      const manifest = join49(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
+      const normalizedManifest = parseInteractionManifest(await readFile38(manifest, "utf8"));
       if (current.plan.approvedPrd === void 0) throw new Error("Approve the PRD before confirming the design");
       verifyRequirementCoverage(current.plan.approvedPrd.criteria, normalizedManifest);
       await writeFile17(manifest, `${JSON.stringify(normalizedManifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       const baseline = await captureAcceptanceBaseline(await this.#acceptancePaths(workspace, task), current.plan.approvedPrd);
-      await writeFile17(join48(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
+      await writeFile17(join49(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     }
     const plan = await writeD2cProductPlan(
@@ -36014,8 +36246,8 @@ VITE_API_BASE_URL=${running.url}
     const imported = await this.importD2cDesign(task, d2cProductPrototypeDirectory(workspace, task));
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery !== void 0) {
-      const prototype = await readFile37(join48(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
-      const interaction = await readFile37(join48(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
+      const prototype = await readFile38(join49(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
+      const interaction = await readFile38(join49(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
       const completed = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "design", [
         artifactRef("product/prototype/index.html", prototype),
         artifactRef("product/prototype/interaction-manifest.json", interaction)
@@ -36099,10 +36331,10 @@ VITE_API_BASE_URL=${running.url}
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyQualityJudgment(current, judgment));
     const qualityContent = `${JSON.stringify(judgment, null, 2)}
 `;
-    await writeFile17(join48(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
+    await writeFile17(join49(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
     const delivery = await readDeliveryRun(workspace, task);
     if (next.stage === "completed" && delivery?.nodes.acceptance.status === "running") {
-      const interactionContent = await readFile37(join48(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
+      const interactionContent = await readFile38(join49(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
       const accepted = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "acceptance", [
         artifactRef("integration/interaction-results.json", interactionContent),
         artifactRef("quality-judge.json", qualityContent)
@@ -36334,7 +36566,7 @@ async function loginShellEnvironment(environment, platform = process.platform, d
 }
 
 // src/desktop/git-manager.ts
-import { readFile as readFile38, rm as rm16 } from "fs/promises";
+import { readFile as readFile39, rm as rm16 } from "fs/promises";
 import { isAbsolute as isAbsolute21, relative as relative28, resolve as resolve40 } from "path";
 function failure(action, stderr, stdout) {
   return new Error(`${action}\u5931\u8D25\uFF1A${(stderr.trim() || stdout.trim() || "\u672A\u77E5 Git \u9519\u8BEF").split("\n")[0]}`);
@@ -36366,7 +36598,7 @@ async function desktopGitDiff(workspace, path, staged = false) {
   if (file === void 0) throw new Error("\u8BE5\u6587\u4EF6\u5DF2\u4E0D\u5728\u53D8\u66F4\u5217\u8868\u4E2D");
   if (file.untracked) {
     const target = safeWorkspacePath(workspace, path);
-    const value = await readFile38(target, "utf8");
+    const value = await readFile39(target, "utf8");
     return value.length > 12e4 ? `${value.slice(0, 12e4)}
 \u2026[\u5185\u5BB9\u5DF2\u622A\u65AD]` : value;
   }
@@ -36428,13 +36660,13 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     return path.replaceAll("\\", "/");
   }));
   try {
-    const tree = JSON.parse(await readFile38(resolve40(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
+    const tree = JSON.parse(await readFile39(resolve40(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
     const leaf = tree.nodes?.find((node) => node.id === tree.leafId);
     const parent = leaf?.parentId == null ? void 0 : tree.nodes?.find((node) => node.id === leaf.parentId);
     if (leaf === void 0 || parent === void 0) return desktopGitReviewDiff(workspace, { scope: "last-turn", paths });
     const load = async (id) => {
       if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-      return JSON.parse(await readFile38(resolve40(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
+      return JSON.parse(await readFile39(resolve40(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
     };
     const [before, after] = await Promise.all([load(parent.checkpointId), load(leaf.checkpointId)]);
     const oldFiles = new Map(before.files.map((file) => [file.path, file.digest]));
@@ -36443,7 +36675,7 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     const object = async (digest) => {
       if (digest === void 0) return "";
       if (!/^[a-f0-9]{64}$/.test(digest)) throw new Error("Invalid checkpoint object");
-      const value = await readFile38(resolve40(workspace, ".flavor", "checkpoints", "objects", digest));
+      const value = await readFile39(resolve40(workspace, ".flavor", "checkpoints", "objects", digest));
       return value.includes(0) ? "[binary content]" : value.toString("utf8");
     };
     const chunks = await Promise.all(changed.map(async (path) => wholeFileDiff(path, await object(oldFiles.get(path)), await object(newFiles.get(path)))));
@@ -36482,8 +36714,8 @@ function safeGitTarget(value) {
 
 // src/desktop/worktree-manager.ts
 import { randomUUID as randomUUID28 } from "crypto";
-import { mkdir as mkdir28, readFile as readFile39, readdir as readdir14, rm as rm17, stat as stat18, writeFile as writeFile18 } from "fs/promises";
-import { basename as basename11, isAbsolute as isAbsolute22, join as join49, relative as relative29, resolve as resolve41, sep as sep29 } from "path";
+import { mkdir as mkdir28, readFile as readFile40, readdir as readdir14, rm as rm17, stat as stat18, writeFile as writeFile18 } from "fs/promises";
+import { basename as basename11, isAbsolute as isAbsolute22, join as join50, relative as relative29, resolve as resolve41, sep as sep29 } from "path";
 var DesktopWorktreeManager = class {
   #repository;
   #storage;
@@ -36529,7 +36761,7 @@ var DesktopWorktreeManager = class {
     }
     const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => {
       try {
-        const stored = validateStored(JSON.parse(await readFile39(join49(this.#storage, name), "utf8")), this.#repository, this.#storage);
+        const stored = validateStored(JSON.parse(await readFile40(join50(this.#storage, name), "utf8")), this.#repository, this.#storage);
         if ((await stat18(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
         const status = await git2(stored.path, ["status", "--porcelain"]);
         const merged = await git2(this.#repository, ["merge-base", "--is-ancestor", stored.branch, "HEAD"]);
@@ -36563,7 +36795,7 @@ var DesktopWorktreeManager = class {
   }
   async #load(id) {
     const path = this.#metadataPath(id);
-    return validateStored(JSON.parse(await readFile39(path, "utf8")), this.#repository, this.#storage);
+    return validateStored(JSON.parse(await readFile40(path, "utf8")), this.#repository, this.#storage);
   }
   #metadataPath(id) {
     if (!/^worktree-[a-z0-9._-]{1,80}$/.test(id)) throw new Error("Invalid worktree id");
@@ -36591,9 +36823,9 @@ function validateStored(value, repository, storage) {
 }
 
 // src/desktop/workbench-service.ts
-import { readFile as readFile40, readdir as readdir15, stat as stat19 } from "fs/promises";
+import { readFile as readFile41, readdir as readdir15, stat as stat19 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join50, resolve as resolve42 } from "path";
+import { join as join51, resolve as resolve42 } from "path";
 var MAX_TEXT = 128e3;
 var MAX_ITEMS = 200;
 var DesktopWorkbenchService = class {
@@ -36626,11 +36858,11 @@ var DesktopWorkbenchService = class {
     return url.toString().replace(/\/$/, input.trim().endsWith("/") ? "/" : "");
   }
   async #goals() {
-    const root = join50(this.#workspace, ".flavor", "goals");
+    const root = join51(this.#workspace, ".flavor", "goals");
     const names = await readdir15(root).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error));
     const values = await Promise.all(names.filter((name) => /^goal-[A-Za-z0-9._-]+\.json$/.test(name)).slice(0, MAX_ITEMS).map(async (name) => {
       try {
-        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join50(root, name))));
+        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join51(root, name))));
       } catch {
         return void 0;
       }
@@ -36640,7 +36872,7 @@ var DesktopWorkbenchService = class {
   async #instructions() {
     const names = ["FLAVOR.md", "AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
     const items = await Promise.all(names.map(async (name) => {
-      const path = join50(this.#workspace, name);
+      const path = join51(this.#workspace, name);
       try {
         return { name, path, content: redactErrorText(await boundedRead2(path)) };
       } catch (error) {
@@ -36653,9 +36885,9 @@ var DesktopWorkbenchService = class {
   async #permissionFiles() {
     const candidates = [
       ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve42(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
-      { tier: "user", path: join50(this.#home, ".flavor-code", "permissions.json"), content: "" },
-      { tier: "project", path: join50(this.#workspace, ".flavor", "permissions.json"), content: "" },
-      { tier: "local", path: join50(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
+      { tier: "user", path: join51(this.#home, ".flavor-code", "permissions.json"), content: "" },
+      { tier: "project", path: join51(this.#workspace, ".flavor", "permissions.json"), content: "" },
+      { tier: "local", path: join51(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
     ];
     const values = await Promise.all(candidates.map(async (item) => {
       try {
@@ -36670,7 +36902,7 @@ var DesktopWorkbenchService = class {
   async #audit() {
     let raw;
     try {
-      raw = await boundedRead2(join50(this.#workspace, ".flavor", "audit.jsonl"));
+      raw = await boundedRead2(join51(this.#workspace, ".flavor", "audit.jsonl"));
     } catch (error) {
       if (error.code === "ENOENT") return [];
       throw error;
@@ -36685,7 +36917,7 @@ var DesktopWorkbenchService = class {
     }).reverse();
   }
   async #context(sessionId) {
-    const usage = await readJsonLines2(join50(this.#workspace, ".flavor", "usage.jsonl"));
+    const usage = await readJsonLines2(join51(this.#workspace, ".flavor", "usage.jsonl"));
     if (sessionId === void 0) return { visibility: [], usage };
     try {
       const document = await new SessionStore({ workspace: this.#workspace }).load(sessionId);
@@ -36699,7 +36931,7 @@ async function boundedRead2(path) {
   const info = await stat19(path);
   if (!info.isFile()) throw new Error(`Expected a file: ${path}`);
   if (info.size > MAX_TEXT) throw new Error(`Workbench file exceeds ${MAX_TEXT} bytes: ${path}`);
-  return readFile40(path, "utf8");
+  return readFile41(path, "utf8");
 }
 async function readJsonLines2(path) {
   try {
@@ -36760,7 +36992,7 @@ function ensureBrowserUiWriteAllowed(spaceId) {
 }
 function logStartup(step, detail) {
   try {
-    const logPath = join51(dirname23(process.execPath), "flavor-code-startup.log");
+    const logPath = join52(dirname23(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -36785,7 +37017,7 @@ var d2cEmbedded = createEmbeddedD2cAutomation(() => {
   };
 });
 var d2cJudgeClient = createD2cJudgeClient();
-var judgeStore = () => createD2cJudgeConfigStore(join51(app.getPath("userData"), "d2c-judge.json"));
+var judgeStore = () => createD2cJudgeConfigStore(join52(app.getPath("userData"), "d2c-judge.json"));
 function judgeImage(png) {
   const image = nativeImage.createFromBuffer(png);
   const size = image.getSize();
@@ -36811,7 +37043,7 @@ function sessionMetaKey(workspace, sessionId) {
 }
 function worktreeManager(workspace) {
   const key = createHash29("sha256").update(resolve43(workspace)).digest("hex").slice(0, 20);
-  return new DesktopWorktreeManager({ repository: workspace, storage: join51(app.getPath("userData"), "task-worktrees", key) });
+  return new DesktopWorktreeManager({ repository: workspace, storage: join52(app.getPath("userData"), "task-worktrees", key) });
 }
 function activeWorkingDirectory() {
   if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
@@ -36956,7 +37188,7 @@ function createDesktopController(workspace, owner2) {
         alias: `desktop-${basename12(workspace ?? runtimeOptions.workspace ?? "flavor")}`.slice(0, 64),
         optional: true,
         startBroker: (address) => {
-          const entry2 = app.isPackaged ? join51(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join51(moduleDirectory, "pals-broker-entry.js");
+          const entry2 = app.isPackaged ? join52(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join52(moduleDirectory, "pals-broker-entry.js");
           return spawnPalBrokerProcess({
             address,
             executable: process.execPath,
@@ -36985,11 +37217,11 @@ function createDesktopController(workspace, owner2) {
 var detachedController = createDesktopController();
 var controller = detachedController;
 function statePath() {
-  return join51(app.getPath("userData"), "desktop-state.json");
+  return join52(app.getPath("userData"), "desktop-state.json");
 }
 async function loadPersistedProjects() {
   try {
-    const raw = await readFile41(statePath(), "utf8");
+    const raw = await readFile42(statePath(), "utf8");
     if (raw.length > 1e5) return { projects: [] };
     const parsed = JSON.parse(raw);
     Object.assign(workbench, {
@@ -37166,7 +37398,7 @@ async function chooseAndOpenWorkspace() {
 var cachedAppIconDataUrl;
 function appIconDataUrl() {
   if (cachedAppIconDataUrl !== void 0) return cachedAppIconDataUrl;
-  const icon = nativeImage.createFromPath(join51(app.getAppPath(), "assets", "icon.png"));
+  const icon = nativeImage.createFromPath(join52(app.getAppPath(), "assets", "icon.png"));
   if (icon.isEmpty()) return void 0;
   cachedAppIconDataUrl = icon.toDataURL();
   return cachedAppIconDataUrl;
@@ -37642,7 +37874,7 @@ function applicationMenu() {
   ]);
 }
 async function createWindow() {
-  const rendererPath = join51(app.getAppPath(), "dist", "desktop-renderer", "index.html");
+  const rendererPath = join52(app.getAppPath(), "dist", "desktop-renderer", "index.html");
   mainWindow = new BrowserWindow2({
     title: "Flavor Code",
     width: 1280,
@@ -37653,14 +37885,14 @@ async function createWindow() {
     show: false,
     ...desktopWindowChrome(),
     webPreferences: {
-      preload: join51(moduleDirectory, "preload.cjs"),
+      preload: join52(moduleDirectory, "preload.cjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
       webSecurity: true
     }
   });
-  const iconPath = join51(app.getAppPath(), "assets", "icon.png");
+  const iconPath = join52(app.getAppPath(), "assets", "icon.png");
   const icon = nativeImage.createFromPath(iconPath);
   if (!icon.isEmpty()) {
     mainWindow.setIcon(icon);