flavor-code 1.4.3-beta.2 → 1.4.4-beta.2

package/dist/{chunk-IDJAHEG6.js → chunk-U4XTQ5PU.js}

@@ -17,7 +17,7 @@ import {
   rgPath,
   runDoctor,
   terminateProcessTree
-} from "./chunk-K7UGGWJV.js";
+} from "./chunk-JQM2L2YM.js";
 import {
   execFileNoThrow
 } from "./chunk-IU3UBETC.js";
@@ -49,7 +49,7 @@ import {
   normalizeMemoryContent,
   registerCrashCleanup,
   renderMemoryDocument
-} from "./chunk-FAJ6YDZK.js";
+} from "./chunk-36IDJRLQ.js";
 import {
   redactErrorText,
   redactSecrets
@@ -94,8 +94,9 @@ import {
   readRecoverableFile,
   redactConfig,
   setProjectMcpServerDisabled,
+  updatePlainTextFile,
   updateProtectedFile
-} from "./chunk-HGTCIHWA.js";
+} from "./chunk-5BDKRA6U.js";
 import {
   SESSION_VERSION,
   SessionStore,
@@ -120,14 +121,14 @@ import {
   transcriptReducer,
   updatePlanTask,
   withTimeout
-} from "./chunk-SJUIIHIA.js";
+} from "./chunk-X6U6BO5D.js";
 import {
   message
 } from "./chunk-BDX777JR.js";
 import {
   PERMISSION_MODES,
   normalizePermissionMode
-} from "./chunk-6X62CGMA.js";
+} from "./chunk-ONRY3C2L.js";
 import {
   NEVER,
   ZodIssueCode,
@@ -8288,11 +8289,11 @@ var require_ignore = __commonJS({
 });
 
 // src/production.ts
-import { readFile as readFile18 } from "fs/promises";
+import { readFile as readFile19 } from "fs/promises";
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
 import { createHash as createHash16, randomUUID as randomUUID16 } from "crypto";
 import { homedir, release as osRelease, tmpdir as tmpdir3, version as osVersion } from "os";
-import { basename as basename4, dirname as dirname13, join as join21, relative as relative16, resolve as resolve25, sep as sep16 } from "path";
+import { basename as basename4, dirname as dirname13, join as join22, relative as relative16, resolve as resolve25, sep as sep16 } from "path";
 import { performance } from "perf_hooks";
 
 // src/agent/task-tools.ts
@@ -8527,6 +8528,7 @@ var ContextManager = class _ContextManager {
   #workspaceInstructions;
   #memory;
   #userMemory;
+  #globalInstructions;
   #compactAtChars;
   #toolOutputChars;
   #recentTurns;
@@ -8571,6 +8573,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;
@@ -8610,6 +8613,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,
@@ -8691,12 +8695,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;
@@ -8716,9 +8722,15 @@ var ContextManager = class _ContextManager {
     const legacySummary = snapshot3.summary?.role === "system" && snapshot3.summary.content.startsWith("Conversation summary\n") ? snapshot3.summary.content.slice("Conversation summary\n".length) : void 0;
     this.#compact = snapshot3.compact === void 0 ? legacySummary === void 0 ? void 0 : { summary: legacySummary, compactedAt: (/* @__PURE__ */ new Date(0)).toISOString() } : { ...snapshot3.compact };
     if (snapshot3.epoch !== void 0) this.#epoch = cloneEpoch(snapshot3.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(snapshot3.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;
@@ -8934,6 +8946,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);
@@ -8942,7 +8960,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];
@@ -8956,7 +8974,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}
@@ -9112,9 +9130,122 @@ function providerValidMessages(input) {
   return output;
 }
 
+// src/context/global-instructions.ts
+import { lstat, readFile } from "fs/promises";
+import { join } from "path";
+var GlobalInstructions = class _GlobalInstructions {
+  static MAX_BYTES = 64 * 1024;
+  static MAX_RULE_BYTES = 4 * 1024;
+  path;
+  #content;
+  constructor(home) {
+    this.path = join(home, ".flavor-code", "GLOBAL.md");
+  }
+  get content() {
+    return this.#content;
+  }
+  async refresh() {
+    let info;
+    try {
+      info = await lstat(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 readFile(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 exists2 = await regularFileExists(this.path);
+      const base = exists2 ? 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((entry) => entry.text.toLocaleLowerCase() === query);
+      const matches = exact.length > 0 ? exact : entries.filter((entry) => entry.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(path2) {
+  try {
+    const info = await lstat(path2);
+    if (!info.isFile()) throw new Error(`Global instructions must be a regular file: ${path2}`);
+    if (info.size > GlobalInstructions.MAX_BYTES) {
+      throw new Error(`Global instructions exceed ${GlobalInstructions.MAX_BYTES} bytes: ${path2}`);
+    }
+    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 createHash2 } from "crypto";
-import { lstat, readFile, realpath } from "fs/promises";
+import { lstat as lstat2, readFile as readFile2, realpath } from "fs/promises";
 import { dirname, isAbsolute, relative, resolve, sep } 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"];
@@ -9174,11 +9305,11 @@ var WorkspaceInstructions = class {
       for (const name of names) {
         const path2 = resolve(directory.path, name);
         try {
-          const info = await lstat(path2);
+          const info = await lstat2(path2);
           if (!info.isFile() && !info.isSymbolicLink()) continue;
           const physical = await realpath(path2);
           if (!within(physicalRoot, physical)) continue;
-          const bytes = await readFile(path2);
+          const bytes = await readFile2(path2);
           const clipped = bytes.subarray(0, this.#maxFileBytes);
           const suffix = bytes.length > clipped.length ? `
 
@@ -9217,7 +9348,7 @@ ${document.content}
 };
 async function directoryForPath(path2) {
   try {
-    return (await lstat(path2)).isDirectory() ? path2 : dirname(path2);
+    return (await lstat2(path2)).isDirectory() ? path2 : dirname(path2);
   } catch {
     return dirname(path2);
   }
@@ -10013,6 +10144,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;
@@ -10073,6 +10210,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) };
@@ -11077,7 +11215,7 @@ function redactClassifierText(value) {
 // src/tools/runtime.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir, writeFile } from "fs/promises";
-import { basename, join, resolve as resolve3 } from "path";
+import { basename, join as join2, resolve as resolve3 } from "path";
 
 // src/tools/types.ts
 var TOOL_PRESENTATION = /* @__PURE__ */ Symbol("flavor.tool-presentation");
@@ -11410,9 +11548,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 = join(this.#workspace, ".flavor", "tool-results");
+    const directory = join2(this.#workspace, ".flavor", "tool-results");
     const filename2 = `${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID2()}-${safeFilename(tool)}.txt`;
-    const savedTo = join(directory, filename2);
+    const savedTo = join2(directory, filename2);
     let storage;
     try {
       await mkdir(directory, { recursive: true });
@@ -11631,6 +11769,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 }
       });
@@ -11660,7 +11799,7 @@ function toModelTool(tool) {
 // src/harness/journal.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
-import { join as join2, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+import { join as join3, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
 
 // src/harness/invariants.ts
 function harnessInvariantViolations(records) {
@@ -11749,14 +11888,14 @@ var HarnessJournal = class {
   #records = [];
   constructor(options) {
     const workspace = resolve4(options.workspace);
-    const directory = join2(workspace, ".flavor", "sessions");
+    const directory = join3(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 = join2(canonicalDirectory, `${options.sessionId}.events.jsonl`);
+    this.#path = join3(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");
@@ -12398,7 +12537,7 @@ function createIncidentReporter(options) {
 import { createHash as createHash4, randomUUID as randomUUID5 } from "crypto";
 import { chmod, unlink } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { createServer } from "net";
 var MAX_REQUEST_BYTES = 64 * 1024;
 var SOCKET_TIMEOUT_MS = 1e4;
@@ -12406,7 +12545,7 @@ function islandControlEndpoint(sessionId, platform = process.platform) {
   const digest = createHash4("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 join3(tmpdir(), `flavor-island-control-${uid}-${digest}.sock`);
+  return join4(tmpdir(), `flavor-island-control-${uid}-${digest}.sock`);
 }
 async function createIslandControlServer(options) {
   const platform = options.platform ?? process.platform;
@@ -12533,17 +12672,17 @@ function closeServer(server) {
 // src/evolve/service.ts
 import { spawn as spawn2 } from "child_process";
 import { writeFile as writeFile5 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/evolve/loader.ts
 import { cp, mkdir as mkdir2, mkdtemp, readdir as readdir2, rm, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join4, resolve as resolve6 } from "path";
+import { join as join5, resolve as resolve6 } from "path";
 
 // src/plugins/host.ts
 import { createHash as createHash5 } from "crypto";
 import { lstatSync, realpathSync as realpathSync3 } from "fs";
-import { lstat as lstat2, open, readFile as readFile2, readdir, realpath as realpath3, stat, writeFile as writeFile2 } from "fs/promises";
+import { lstat as lstat3, open, readFile as readFile3, readdir, realpath as realpath3, stat, writeFile as writeFile2 } from "fs/promises";
 import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve5, sep as sep4 } from "path";
 import { pathToFileURL } from "url";
 
@@ -12857,7 +12996,7 @@ var PluginHost = class {
   async #readCandidate(inputRoot, source, label = inputRoot) {
     let diagnosticLabel = label;
     try {
-      const rootInfo = await lstat2(inputRoot);
+      const rootInfo = await lstat3(inputRoot);
       if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) throw new Error("Plugin root must be a static directory");
       const root = await realpath3(inputRoot);
       const rawManifest = await readManifest(resolve5(root, MANIFEST));
@@ -12867,7 +13006,7 @@ var PluginHost = class {
       const manifest = PluginManifestSchema.parse(rawManifest);
       const entry = resolveContained(root, manifest.main, "Plugin entry");
       const entrySnapshot = await snapshotEntry(root, entry);
-      const fingerprint2 = createHash5("sha256").update(JSON.stringify(manifest)).update(await readFile2(entrySnapshot.physicalPath)).digest("hex");
+      const fingerprint2 = createHash5("sha256").update(JSON.stringify(manifest)).update(await readFile3(entrySnapshot.physicalPath)).digest("hex");
       return { manifest, root, source, entry, entrySnapshot, fingerprint: fingerprint2 };
     } catch (error) {
       this.#diagnose(diagnosticLabel, error, inputRoot);
@@ -13114,7 +13253,7 @@ var PluginHost = class {
   }
 };
 async function readManifest(path2) {
-  const lexical = await lstat2(path2, { bigint: true });
+  const lexical = await lstat3(path2, { bigint: true });
   if (!lexical.isFile() || lexical.isSymbolicLink()) throw new Error("Plugin manifest must be a static regular file");
   const handle = await open(path2, "r");
   try {
@@ -13131,7 +13270,7 @@ async function readManifest(path2) {
     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 lstat2(path2, { bigint: true }));
+    const current = fromStats(await lstat3(path2, { bigint: true }));
     assertSnapshot(before, current, "Plugin manifest path");
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytesRead)));
   } finally {
@@ -13139,7 +13278,7 @@ async function readManifest(path2) {
   }
 }
 async function snapshotEntry(root, entry) {
-  const lexicalStats = await lstat2(entry, { bigint: true });
+  const lexicalStats = await lstat3(entry, { bigint: true });
   if (!lexicalStats.isFile() && !lexicalStats.isSymbolicLink()) throw new Error("Plugin entry must be a file");
   const physicalPath = await realpath3(entry);
   assertContained(root, physicalPath, "Plugin entry symlink");
@@ -13227,8 +13366,8 @@ function compare(left, right) {
 }
 
 // src/evolve/loader.ts
-var PLUGIN_DIR = join4(".flavor", "plugins");
-var VERSIONS_DIR = join4(".flavor", "plugins", ".versions");
+var PLUGIN_DIR = join5(".flavor", "plugins");
+var VERSIONS_DIR = join5(".flavor", "plugins", ".versions");
 function sanitizePluginName(tool) {
   const base = String(tool ?? "fix").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
   return base.startsWith("fix-") ? base : `fix-${base}`;
@@ -13272,8 +13411,8 @@ export function activate(ctx) {
 async function scaffoldFixPlugin(workspace, name) {
   const dir = fixPluginDir(workspace, name);
   await mkdir2(dir, { recursive: true });
-  const manifestPath = join4(dir, "flavor-plugin.json");
-  const entryPath = join4(dir, "index.js");
+  const manifestPath = join5(dir, "flavor-plugin.json");
+  const entryPath = join5(dir, "index.js");
   try {
     await writeFile3(manifestPath, SCAFFOLD_MANIFEST(name), { encoding: "utf8", flag: "wx" });
     await writeFile3(entryPath, SCAFFOLD_ENTRY(name), { encoding: "utf8", flag: "wx" });
@@ -13293,9 +13432,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(join4(tmpdir2(), "flavor-evolve-verify-"));
+  const sandbox = await mkdtemp(join5(tmpdir2(), "flavor-evolve-verify-"));
   try {
-    await cp(pluginRoot, join4(sandbox, name), { recursive: true });
+    await cp(pluginRoot, join5(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
       sandbox: true,
@@ -13346,7 +13485,7 @@ async function verifyFixPlugin(workspace, name) {
 }
 async function snapshotFixPlugin(workspace, name) {
   const pluginRoot = fixPluginDir(workspace, name);
-  const snapshotRoot = join4(versionsDirFor(workspace, name), timestamp());
+  const snapshotRoot = join5(versionsDirFor(workspace, name), timestamp());
   await mkdir2(snapshotRoot, { recursive: true });
   await cp(pluginRoot, snapshotRoot, { recursive: true });
   return snapshotRoot;
@@ -13367,7 +13506,7 @@ async function revertFixPlugin(workspace, name) {
   }
   const snapshots = entries.filter((entry) => !entry.startsWith(".")).sort();
   if (snapshots.length === 0) throw new Error(`Plugin "${name}" has no snapshot to restore.`);
-  const latest = join4(versionsRoot, snapshots[snapshots.length - 1]);
+  const latest = join5(versionsRoot, snapshots[snapshots.length - 1]);
   await rm(pluginRoot, { recursive: true, force: true });
   await mkdir2(pluginRoot, { recursive: true });
   await cp(latest, pluginRoot, { recursive: true });
@@ -13376,8 +13515,8 @@ async function revertFixPlugin(workspace, name) {
 
 // src/evolve/store.ts
 import { createHash as createHash6 } from "crypto";
-import { appendFile, mkdir as mkdir3, readFile as readFile3, rm as rm2, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4, join as join5 } from "path";
+import { appendFile, mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4, join as join6 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
@@ -13390,7 +13529,7 @@ function argKeys(args) {
 }
 async function readJsonLines(file) {
   try {
-    const text = await readFile3(file, "utf8");
+    const text = await readFile4(file, "utf8");
     const records = [];
     for (const line of text.split("\n")) {
       const trimmed = line.trim();
@@ -13413,7 +13552,7 @@ async function writeJsonLines(file, records) {
 }
 async function readJsonArray(file) {
   try {
-    const parsed = JSON.parse(await readFile3(file, "utf8"));
+    const parsed = JSON.parse(await readFile4(file, "utf8"));
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
   } catch {
     return [];
@@ -13421,7 +13560,7 @@ async function readJsonArray(file) {
 }
 async function readRules(file) {
   try {
-    const parsed = JSON.parse(await readFile3(file, "utf8"));
+    const parsed = JSON.parse(await readFile4(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,
@@ -13450,12 +13589,12 @@ var EvolveStore = class {
   #queue = Promise.resolve();
   constructor(options) {
     const { workspace, maxSignals = 400, maxRules = 20 } = options;
-    this.dir = join5(workspace, ".flavor", "evolve");
-    this.signalsFile = join5(this.dir, "signals.jsonl");
-    this.reflectionsFile = join5(this.dir, "reflections.jsonl");
-    this.doneFile = join5(this.dir, "done.json");
-    this.verifiedFile = join5(this.dir, "verified.json");
-    this.rulesFile = join5(this.dir, "rules.json");
+    this.dir = join6(workspace, ".flavor", "evolve");
+    this.signalsFile = join6(this.dir, "signals.jsonl");
+    this.reflectionsFile = join6(this.dir, "reflections.jsonl");
+    this.doneFile = join6(this.dir, "done.json");
+    this.verifiedFile = join6(this.dir, "verified.json");
+    this.rulesFile = join6(this.dir, "rules.json");
     this.maxSignals = maxSignals;
     this.maxRules = maxRules;
   }
@@ -13998,7 +14137,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 writeFile5(join6(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
+        await writeFile5(join7(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}`,
@@ -14071,7 +14210,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) => [join6(workspace, ".flavor", "evolve"), ...input.kind === "prompt_rule" ? [] : [join6(workspace, ".flavor", "plugins")]],
+        paths: (input) => [join7(workspace, ".flavor", "evolve"), ...input.kind === "prompt_rule" ? [] : [join7(workspace, ".flavor", "plugins")]],
         execute: async (input, signal) => {
           signal.throwIfAborted();
           const { suggestionId, implementation, kind } = input;
@@ -14091,7 +14230,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
           }
           const name = sanitizePluginName(suggestion.tool);
           const dir = await scaffoldFixPlugin(workspace, name);
-          await writeFile5(join6(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
+          await writeFile5(join7(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}).`,
@@ -14589,7 +14728,7 @@ ${cycle.verification.summary}` !== signature) break;
 // src/goal/orchestrator.ts
 import { createHash as createHash8 } from "crypto";
 import { writeFile as writeFile6, mkdir as mkdir4 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/goal/types.ts
 var GoalPhaseSchema = external_exports.enum([
@@ -14759,8 +14898,8 @@ function extractJson(text) {
 
 // src/goal/classifier.ts
 import { createHash as createHash7 } from "crypto";
-import { readFile as readFile4 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join8 } from "path";
 function buildSkepticPrompt(evidence, plan, index) {
   const criteriaList = plan.criteria.map((c) => `  ${c.id}. [${c.type}] ${c.description}`).join("\n");
   return [
@@ -14939,10 +15078,10 @@ function computeFingerprint(gaps) {
 }
 async function collectEvidence(workspace, objective, finalResponse, priorGaps, contractHash2 = createHash7("sha256").update(objective).digest("hex"), hostVerification) {
   const workspaceState = await collectWorkspaceState(workspace);
-  const planPath = join7(workspace, ".flavor", "goal-plan.md");
+  const planPath = join8(workspace, ".flavor", "goal-plan.md");
   let planFile = null;
   try {
-    planFile = await readFile4(planPath, "utf8");
+    planFile = await readFile5(planPath, "utf8");
   } catch {
   }
   return {
@@ -15311,8 +15450,8 @@ function waitForStageRetry(delayMs, signal) {
   });
 }
 async function writePlanFile(workspace, plan) {
-  const dir = join8(workspace, ".flavor");
-  const planPath = join8(dir, "goal-plan.md");
+  const dir = join9(workspace, ".flavor");
+  const planPath = join9(dir, "goal-plan.md");
   await mkdir4(dir, { recursive: true });
   const criteriaText = plan.criteria.map((c) => `- [${c.type}] AC-${c.id}: ${c.description}`).join("\n");
   const content = [
@@ -15389,8 +15528,8 @@ function formatPriorGaps(gaps) {
 // src/goal/store.ts
 import { constants as constants2 } from "fs";
 import { randomUUID as randomUUID6 } from "crypto";
-import { lstat as lstat3, mkdir as mkdir5, open as open2, readFile as readFile5, rename, rm as rm3, stat as stat3 } from "fs/promises";
-import { dirname as dirname5, join as join9, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
+import { lstat as lstat4, mkdir as mkdir5, open as open2, readFile as readFile6, rename, rm as rm3, stat as stat3 } from "fs/promises";
+import { dirname as dirname5, join as join10, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -15398,7 +15537,7 @@ var GoalStore = class {
   #maxBytes;
   constructor(options) {
     this.#workspace = resolve7(options.workspace);
-    this.#root = join9(this.#workspace, ".flavor", "goals");
+    this.#root = join10(this.#workspace, ".flavor", "goals");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   }
   async save(input) {
@@ -15406,13 +15545,13 @@ var GoalStore = class {
     await assertNoSymlink(this.#workspace, dirname5(this.#root));
     await mkdir5(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join9(this.#root, `${state.id}.json`);
+    const target = join10(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 = join9(this.#root, `.${state.id}.${process.pid}.${randomUUID6()}.tmp`);
+    const temporary = join10(this.#root, `.${state.id}.${process.pid}.${randomUUID6()}.tmp`);
     let handle;
     try {
       handle = await open2(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
@@ -15433,13 +15572,13 @@ var GoalStore = class {
     }
     await assertNoSymlink(this.#workspace, dirname5(this.#root));
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join9(this.#root, `${goalId}.json`);
+    const target = join10(this.#root, `${goalId}.json`);
     try {
       const metadata = await stat3(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) {
         throw new Error("Goal state is not a bounded regular file");
       }
-      const raw = await readFile5(target, "utf8");
+      const raw = await readFile6(target, "utf8");
       return GoalStateSchema.parse(JSON.parse(raw));
     } catch (error) {
       if (isCode(error, "ENOENT")) throw new Error(`Goal "${goalId}" was not found`);
@@ -15463,7 +15602,7 @@ async function assertNoSymlink(root, target) {
   }
   for (const path2 of chain.reverse()) {
     try {
-      if ((await lstat3(path2)).isSymbolicLink()) throw new Error(`Goal path contains a symbolic link: ${path2}`);
+      if ((await lstat4(path2)).isSymbolicLink()) throw new Error(`Goal path contains a symbolic link: ${path2}`);
     } catch (error) {
       if (!isCode(error, "ENOENT")) throw error;
     }
@@ -15474,8 +15613,8 @@ function isCode(error, code) {
 }
 
 // src/loop/isolation.ts
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile6 } from "fs/promises";
-import { join as join10, resolve as resolve8 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile7 } from "fs/promises";
+import { join as join11, resolve as resolve8 } 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) {
@@ -15498,8 +15637,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 = join10(root, ".worktrees");
-  const path2 = join10(worktrees, `loop-${options.loopId}`);
+  const worktrees = join11(root, ".worktrees");
+  const path2 = join11(worktrees, `loop-${options.loopId}`);
   const branch = `loop/${options.loopId}`;
   try {
     await ensureWorktreeDirectoryIgnored(root);
@@ -15529,12 +15668,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 = resolve8(root, commonDirectory.stdout.trim());
-  const infoDirectory = join10(gitDirectory, "info");
-  const excludePath = join10(infoDirectory, "exclude");
+  const infoDirectory = join11(gitDirectory, "info");
+  const excludePath = join11(infoDirectory, "exclude");
   await mkdir6(infoDirectory, { recursive: true });
   let existing = "";
   try {
-    existing = await readFile6(excludePath, "utf8");
+    existing = await readFile7(excludePath, "utf8");
   } catch (error) {
     if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) throw error;
   }
@@ -15545,8 +15684,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 
 // src/loop/store.ts
 import { constants as constants3 } from "fs";
-import { lstat as lstat4, mkdir as mkdir7, open as open3, readFile as readFile7, realpath as realpath4, rename as rename2, rm as rm4, stat as stat4 } from "fs/promises";
-import { dirname as dirname6, join as join11, relative as relative6, resolve as resolve9, sep as sep6 } from "path";
+import { lstat as lstat5, mkdir as mkdir7, open as open3, readFile as readFile8, realpath as realpath4, rename as rename2, rm as rm4, stat as stat4 } from "fs/promises";
+import { dirname as dirname6, join as join12, relative as relative6, resolve as resolve9, sep as sep6 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
@@ -15557,7 +15696,7 @@ var LoopStore = class {
   #appendTails = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#workspace = resolve9(options.workspace);
-    this.#root = join11(this.#workspace, ".flavor", "loops");
+    this.#root = join12(this.#workspace, ".flavor", "loops");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES2;
   }
   async create(state) {
@@ -15574,11 +15713,11 @@ var LoopStore = class {
     const state = LoopStateSchema.parse(input);
     await this.#assertWorkspace(state.workspace);
     const directory = await this.#prepare(state.loopId);
-    const target = join11(directory, "state.json");
+    const target = join12(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 = join11(directory, `.state.${process.pid}.${randomUUID7()}.tmp`);
+    const temporary = join12(directory, `.state.${process.pid}.${randomUUID7()}.tmp`);
     let handle;
     try {
       handle = await open3(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
@@ -15594,11 +15733,11 @@ var LoopStore = class {
   }
   async load(loopId) {
     const directory = await this.#safeExisting(loopId);
-    const target = join11(directory, "state.json");
+    const target = join12(directory, "state.json");
     try {
       const metadata = await stat4(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) throw new Error("Loop state is not a bounded regular file");
-      const raw = await readFile7(target, "utf8");
+      const raw = await readFile8(target, "utf8");
       const state = LoopStateSchema.parse(JSON.parse(raw));
       await this.#assertWorkspace(state.workspace);
       return state;
@@ -15614,7 +15753,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 path2 = join11(directory, "events.jsonl");
+      const path2 = join12(directory, "events.jsonl");
       const handle = await open3(path2, constants3.O_CREAT | constants3.O_APPEND | constants3.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
@@ -15631,7 +15770,7 @@ var LoopStore = class {
     await assertNoSymlink2(this.#workspace, dirname6(this.#root));
     await mkdir7(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join11(this.#root, loopId);
+    const directory = join12(this.#root, loopId);
     await mkdir7(directory, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
@@ -15639,7 +15778,7 @@ var LoopStore = class {
   async #safeExisting(loopId) {
     validateId(loopId);
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join11(this.#root, loopId);
+    const directory = join12(this.#root, loopId);
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
   }
@@ -15665,7 +15804,7 @@ async function assertNoSymlink2(root, target) {
   }
   for (const path2 of chain.reverse()) {
     try {
-      if ((await lstat4(path2)).isSymbolicLink()) throw new Error(`Loop path contains a symbolic link: ${path2}`);
+      if ((await lstat5(path2)).isSymbolicLink()) throw new Error(`Loop path contains a symbolic link: ${path2}`);
     } catch (error) {
       if (!isCode2(error, "ENOENT")) throw error;
     }
@@ -15687,20 +15826,20 @@ function isCode2(error, code) {
 }
 
 // src/loop/verifier.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join13 } from "path";
 var SCRIPT_PRIORITY = ["test", "typecheck", "lint", "build", "smoke:install"];
 var MAX_PERSISTED_VERIFICATION_STREAM_BYTES = 1024;
 async function inferVerificationPlan(workspace) {
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
-  const packageJson = await optionalJson(join12(workspace, "package.json"));
+  const packageJson = await optionalJson(join13(workspace, "package.json"));
   const scripts = isRecord(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(join12(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join13(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -15775,7 +15914,7 @@ function isUnconditionalPassThrough(script) {
 }
 async function optionalText(path2) {
   try {
-    return await readFile8(path2, "utf8");
+    return await readFile9(path2, "utf8");
   } catch (error) {
     if (isCode3(error, "ENOENT")) return void 0;
     throw error;
@@ -15795,7 +15934,7 @@ function isCode3(error, code) {
 }
 
 // src/models/anthropic.ts
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 
 // src/utils/json.ts
 function safeParseJson(input) {
@@ -16069,7 +16208,7 @@ ${modelContentText(message2.content)}
             source: {
               type: "base64",
               media_type: block.mediaType,
-              data: (await readFile9(block.source.path)).toString("base64")
+              data: (await readFile10(block.source.path)).toString("base64")
             }
           }));
           if (message2.cacheBreakpoint && Array.isArray(content) && content.length > 0) {
@@ -26604,7 +26743,7 @@ function isUndiciDispatcherVersionMismatchError(error) {
 
 // src/models/openai.ts
 import { createHash as createHash9 } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 var DEFAULT_THINKING_EFFORT = "high";
 var EXPLICIT_CACHE_BREAKPOINT = { mode: "explicit" };
 var MAX_EXPLICIT_CACHE_BREAKPOINTS = 3;
@@ -26627,7 +26766,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 readFile10(block.source.path)).toString("base64")}`,
+    image_url: `data:${block.mediaType};base64,${(await readFile11(block.source.path)).toString("base64")}`,
     detail: "auto"
   }));
   if (cacheBreakpoint && Array.isArray(content) && content.length > 0) {
@@ -26871,16 +27010,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 = createHash9("sha256").update(JSON.stringify({ model: request.model, messages: stableMessages, tools: sortedTools })).digest("hex").slice(0, 56);
   return `flavor-${digest}`;
@@ -32531,8 +32682,8 @@ function isStoredToken(value) {
 }
 
 // src/permissions/policy.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join13, resolve as resolve11 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join14, resolve as resolve11 } from "path";
 var DecisionSchema2 = external_exports.enum(["allow", "ask", "deny"]);
 var PrefixSchema = external_exports.array(external_exports.string().min(1).max(1024)).min(1).max(64);
 var RuleSchema = external_exports.object({
@@ -32568,15 +32719,15 @@ var CompiledPermissionPolicy = class {
 async function loadPermissionPolicy(options) {
   const sources = [
     ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve11(options.managedPath) }],
-    { tier: "user", path: join13(resolve11(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join13(resolve11(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join13(resolve11(options.workspace), ".flavor", "permissions.local.json") }
+    { tier: "user", path: join14(resolve11(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join14(resolve11(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join14(resolve11(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
     let raw;
     try {
-      raw = await readFile11(source.path, "utf8");
+      raw = await readFile12(source.path, "utf8");
     } catch (error) {
       if (isCode4(error, "ENOENT")) continue;
       throw error;
@@ -32907,14 +33058,14 @@ function createSkillResourceTool(registry) {
 
 // src/session/tree.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import { mkdir as mkdir9, readFile as readFile13, rename as rename4, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname9, join as join15, resolve as resolve13 } from "path";
+import { mkdir as mkdir9, readFile as readFile14, rename as rename4, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname9, join as join16, resolve as resolve13 } from "path";
 
 // src/session/checkpoint.ts
 import { createHash as createHash13, randomUUID as randomUUID8 } from "crypto";
 import { execFile } from "child_process";
-import { lstat as lstat5, mkdir as mkdir8, open as open4, readFile as readFile12, readdir as readdir3, rename as rename3, rm as rm5, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname8, join as join14, relative as relative7, resolve as resolve12, sep as sep7 } from "path";
+import { lstat as lstat6, mkdir as mkdir8, open as open4, readFile as readFile13, readdir as readdir3, rename as rename3, rm as rm5, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname8, join as join15, relative as relative7, resolve as resolve12, sep as sep7 } 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;
@@ -32927,9 +33078,9 @@ var WorkspaceCheckpointStore = class {
   #maxTotalBytes;
   constructor(options) {
     this.#workspace = resolve12(options.workspace);
-    this.#root = join14(this.#workspace, ".flavor", "checkpoints");
-    this.#objects = join14(this.#root, "objects");
-    this.#manifests = join14(this.#root, "manifests");
+    this.#root = join15(this.#workspace, ".flavor", "checkpoints");
+    this.#objects = join15(this.#root, "objects");
+    this.#manifests = join15(this.#root, "manifests");
     this.#maxFileBytes = options.maxFileBytes ?? MAX_FILE_BYTES;
     this.#maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
   }
@@ -32941,15 +33092,15 @@ var WorkspaceCheckpointStore = class {
     await mkdir8(this.#manifests, { recursive: true });
     for (const path2 of paths) {
       const absolute = contained(this.#workspace, path2);
-      const info = await lstat5(absolute);
+      const info = await lstat6(absolute);
       if (info.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path2}`);
       if (!info.isFile()) continue;
       if (info.size > this.#maxFileBytes) throw new Error(`Checkpoint file exceeds size limit: ${path2}`);
       total += info.size;
       if (total > this.#maxTotalBytes) throw new Error("Checkpoint exceeds total size limit");
-      const content = await readFile12(absolute);
+      const content = await readFile13(absolute);
       const digest = createHash13("sha256").update(content).digest("hex");
-      const objectPath = join14(this.#objects, digest);
+      const objectPath = join15(this.#objects, digest);
       try {
         const handle = await open4(objectPath, "wx");
         try {
@@ -32969,12 +33120,12 @@ var WorkspaceCheckpointStore = class {
       ...label === void 0 || label.trim().length === 0 ? {} : { label: label.trim() },
       files
     };
-    await atomicJson(join14(this.#manifests, `${checkpoint.id}.json`), checkpoint);
+    await atomicJson(join15(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 readFile12(join14(this.#manifests, `${id}.json`), "utf8"));
+    const value = JSON.parse(await readFile13(join15(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);
@@ -32986,7 +33137,7 @@ var WorkspaceCheckpointStore = class {
     const checkpoint = await this.load(id);
     const objects = /* @__PURE__ */ new Map();
     for (const file of checkpoint.files) {
-      const object3 = await readFile12(join14(this.#objects, file.digest));
+      const object3 = await readFile13(join15(this.#objects, file.digest));
       if (object3.length !== file.size || createHash13("sha256").update(object3).digest("hex") !== file.digest) {
         throw new Error(`Checkpoint object is corrupt: ${file.digest}`);
       }
@@ -33009,7 +33160,7 @@ var WorkspaceCheckpointStore = class {
   }
 };
 async function discoverFiles(workspace) {
-  if (await exists(join14(workspace, ".git"))) {
+  if (await exists(join15(workspace, ".git"))) {
     const listed = await gitFiles(workspace);
     return listed.filter((path2) => !EXCLUDED.has(path2.split("/")[0] ?? "")).sort();
   }
@@ -33018,7 +33169,7 @@ async function discoverFiles(workspace) {
     const entries = await readdir3(directory, { withFileTypes: true });
     for (const entry of entries) {
       if (EXCLUDED.has(entry.name)) continue;
-      const absolute = join14(directory, entry.name);
+      const absolute = join15(directory, entry.name);
       const path2 = normalizeRelative(relative7(workspace, absolute));
       if (entry.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path2}`);
       if (entry.isDirectory()) await walk(absolute);
@@ -33052,7 +33203,7 @@ async function gitFiles(workspace) {
 }
 async function exists(path2) {
   try {
-    await lstat5(path2);
+    await lstat6(path2);
     return true;
   } catch (error) {
     if (isCode5(error, "ENOENT")) return false;
@@ -33093,17 +33244,17 @@ var SessionHistory = class _SessionHistory {
   #leafId;
   #unrevert;
   constructor(options, document) {
-    this.#path = join15(resolve13(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    this.#path = join16(resolve13(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 path2 = join15(resolve13(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    const path2 = join16(resolve13(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 readFile13(path2, "utf8"));
+      const parsed = JSON.parse(await readFile14(path2, "utf8"));
       validate(parsed, options.sessionId);
       document = parsed;
     } catch (error) {
@@ -33236,7 +33387,7 @@ function isCode6(error, code) {
 
 // src/utils/rotation-census.ts
 import { mkdirSync as mkdirSync2, readdirSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { writeHeapSnapshot } from "v8";
 var CENSUS_PREFIX = "rotation-census-";
 var SNAPSHOT_PREFIX = "heap-";
@@ -33260,9 +33411,9 @@ function censusHeapBlock(reading) {
 }
 function writeRotationCensus(workspace, census) {
   try {
-    const directory = join16(workspace, ".flavor", "tmp");
+    const directory = join17(workspace, ".flavor", "tmp");
     mkdirSync2(directory, { recursive: true });
-    const path2 = join16(directory, `${CENSUS_PREFIX}${Date.now()}.json`);
+    const path2 = join17(directory, `${CENSUS_PREFIX}${Date.now()}.json`);
     writeFileSync(path2, `${JSON.stringify(census, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     prune(directory, CENSUS_PREFIX, ".json", KEEP_CENSUS_FILES);
@@ -33273,9 +33424,9 @@ function writeRotationCensus(workspace, census) {
 }
 function writeRotationHeapSnapshot(workspace) {
   try {
-    const directory = join16(workspace, ".flavor", "tmp");
+    const directory = join17(workspace, ".flavor", "tmp");
     mkdirSync2(directory, { recursive: true });
-    const path2 = join16(directory, `${SNAPSHOT_PREFIX}${Date.now()}.heapsnapshot`);
+    const path2 = join17(directory, `${SNAPSHOT_PREFIX}${Date.now()}.heapsnapshot`);
     writeHeapSnapshot(path2);
     prune(directory, SNAPSHOT_PREFIX, ".heapsnapshot", KEEP_SNAPSHOT_FILES);
     return path2;
@@ -33287,7 +33438,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(join16(directory, name));
+      unlinkSync2(join17(directory, name));
     } catch {
     }
   }
@@ -33296,8 +33447,8 @@ function prune(directory, prefix, suffix, keep) {
 // src/sleep/organizer.ts
 import { constants as constants4 } from "fs";
 import { randomUUID as randomUUID10 } from "crypto";
-import { lstat as lstat6, mkdir as mkdir10, open as open5, readdir as readdir4, realpath as realpath5, rename as rename5, rm as rm6 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join17, relative as relative8, resolve as resolve14, sep as sep8 } from "path";
+import { lstat as lstat7, mkdir as mkdir10, open as open5, readdir as readdir4, realpath as realpath5, rename as rename5, rm as rm6 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join18, relative as relative8, resolve as resolve14, sep as sep8 } from "path";
 var DateKeySchema = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = external_exports.object({
   title: external_exports.string().min(1).max(120),
@@ -33351,7 +33502,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve14(options.workspace);
-    this.#sleepDirectory = join17(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join18(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -33360,7 +33511,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join17(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join18(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open5(lockPath, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
@@ -33395,7 +33546,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 path2 = join17(this.#sleepDirectory, filename2);
+      const path2 = join18(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path2, markdown);
       return { status: "written", date, path: path2, sessionCount: documents.length };
@@ -33437,7 +33588,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join17(this.#workspace, ".flavor");
+    const flavorDirectory = join18(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir10(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -33451,7 +33602,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir4(this.#sleepDirectory, { withFileTypes: true })).some((entry) => entry.isFile() && entry.name.startsWith(prefix) && entry.name.endsWith(".md"));
   }
   async #atomicWrite(path2, content) {
-    const temporary = join17(this.#sleepDirectory, `.${randomUUID10()}.tmp`);
+    const temporary = join18(this.#sleepDirectory, `.${randomUUID10()}.tmp`);
     let handle;
     try {
       handle = await open5(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
@@ -33767,7 +33918,7 @@ function assertDateKey(value) {
 }
 async function assertNotSymlink(path2) {
   try {
-    if ((await lstat6(path2)).isSymbolicLink()) throw new Error(`Refusing to use symbolic link: ${path2}`);
+    if ((await lstat7(path2)).isSymbolicLink()) throw new Error(`Refusing to use symbolic link: ${path2}`);
   } catch (error) {
     if (!hasCode(error, "ENOENT")) throw error;
   }
@@ -33825,7 +33976,7 @@ function computeSessionStats(documents) {
 
 // src/tools/files.ts
 import { constants as constants5 } from "fs";
-import { mkdir as mkdir11, open as open6, readFile as readFile14, realpath as realpath6, rename as rename6, rm as rm7, stat as stat5 } from "fs/promises";
+import { mkdir as mkdir11, open as open6, readFile as readFile15, realpath as realpath6, rename as rename6, rm as rm7, stat as stat5 } from "fs/promises";
 import { dirname as dirname10, isAbsolute as isAbsolute5, relative as relative9, resolve as resolve15, sep as sep9 } from "path";
 import { randomUUID as randomUUID11 } from "crypto";
 
@@ -34170,7 +34321,7 @@ function createPathGuard(workspace) {
           if (!within2(physicalRoot, physical)) throw new Error("Path escapes the workspace through a symlink");
           break;
         } catch (error) {
-          if (!isMissing(error)) throw error;
+          if (!isMissing2(error)) throw error;
           const parent = dirname10(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
@@ -34188,7 +34339,7 @@ async function atomicWrite(path2, content, signal, expectedVersion) {
   try {
     mode = (await stat5(path2)).mode & 511;
   } catch (error) {
-    if (!isMissing(error)) throw error;
+    if (!isMissing2(error)) throw error;
   }
   try {
     const handle = await open6(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
@@ -34209,7 +34360,7 @@ async function atomicWrite(path2, content, signal, expectedVersion) {
   }
 }
 async function readText(path2) {
-  const contents = await readFile14(path2);
+  const contents = await readFile15(path2);
   if (isBinary(contents)) throw new Error("Cannot edit binary file as text");
   return decodeFileText(contents);
 }
@@ -34237,7 +34388,7 @@ async function fileVersion(path2) {
   try {
     return versionOfStat(await stat5(path2));
   } catch (error) {
-    if (isMissing(error)) return ABSENT_VERSION;
+    if (isMissing2(error)) return ABSENT_VERSION;
     throw error;
   }
 }
@@ -34246,10 +34397,10 @@ function versionOfStat(info) {
 }
 async function readOptionalPresentationText(path2) {
   try {
-    const contents = await readFile14(path2);
+    const contents = await readFile15(path2);
     return isBinary(contents) ? { exists: true } : { exists: true, text: contents.toString("utf8") };
   } catch (error) {
-    return isMissing(error) ? { exists: false } : { exists: true };
+    return isMissing2(error) ? { exists: false } : { exists: true };
   }
 }
 function isBinary(contents) {
@@ -34358,7 +34509,7 @@ function mergeRange(ranges, start, end) {
 function abortIfNeeded(signal) {
   if (signal.aborted) throw signal.reason;
 }
-function isMissing(error) {
+function isMissing2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 var PATCH_SEARCH_RADIUS = 100;
@@ -34443,7 +34594,7 @@ async function requireAbsent(guard, path2) {
   try {
     await guard.existing(path2);
   } catch (error) {
-    if (isMissing(error)) return "";
+    if (isMissing2(error)) return "";
     throw error;
   }
   throw new Error("Patch creation destination already exists");
@@ -35277,7 +35428,7 @@ async function readOptionalIgnoreFile(path2, maxBytes, signal) {
   try {
     handle = await open7(path2, "r");
   } catch (error) {
-    if (isMissing2(error)) return void 0;
+    if (isMissing3(error)) return void 0;
     throw error;
   }
   const buffer = Buffer.allocUnsafe(maxBytes + 1);
@@ -35295,7 +35446,7 @@ async function readOptionalIgnoreFile(path2, maxBytes, signal) {
   if (offset > maxBytes) throw new Error(`Ignore file byte limit of ${maxBytes} exceeded: ${path2}`);
   return buffer.subarray(0, offset);
 }
-function isMissing2(error) {
+function isMissing3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -35628,7 +35779,7 @@ function charset(contentType) {
 // src/tools/lsp.ts
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
-import { access, constants as constants6, readFile as readFile15 } from "fs/promises";
+import { access, constants as constants6, readFile as readFile16 } from "fs/promises";
 import { basename as basename2, dirname as dirname11, extname, isAbsolute as isAbsolute7, relative as relative11, resolve as resolve17, sep as sep11 } from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
@@ -35823,7 +35974,7 @@ var LspConnection = class {
     const url2 = new URL(uri);
     if (url2.protocol !== "file:") return;
     const filePath = fileURLToPath(url2);
-    const text = await readFile15(filePath, "utf8");
+    const text = await readFile16(filePath, "utf8");
     const current = this.#documents.get(uri);
     if (current === void 0) {
       this.#documents.set(uri, { text, version: 1 });
@@ -36556,12 +36707,12 @@ ${explanation}` : "";
 // src/desktop/astgraph-service.ts
 import { stat as stat7 } from "fs/promises";
 import { createRequire as nodeCreateRequire } from "module";
-import { join as join18, resolve as resolve18 } from "path";
+import { join as join19, resolve as resolve18 } 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 = join18(resolve18(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join19(resolve18(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
     if ((await stat7(this.#path).catch(() => void 0))?.isFile() !== true) {
@@ -36841,8 +36992,8 @@ function createTodoWriteTool() {
 
 // src/tools/managed.ts
 import { randomUUID as randomUUID12 } from "crypto";
-import { link, lstat as lstat7, mkdir as mkdir12, readFile as readFile16, readdir as readdir5, unlink as unlink2, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname12, join as join19, resolve as resolve20 } from "path";
+import { link, lstat as lstat8, mkdir as mkdir12, readFile as readFile17, readdir as readdir5, unlink as unlink2, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname12, join as join20, resolve as resolve20 } from "path";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
 var TOOL_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
@@ -36893,8 +37044,8 @@ var ManagedToolStore = class {
   #diagnostics = [];
   constructor(options) {
     this.#workspace = resolve20(options.workspace);
-    this.#projectRoot = join19(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join19(resolve20(options.home), ".flavor-code", "tools");
+    this.#projectRoot = join20(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join20(resolve20(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -36941,7 +37092,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path2 = join19(this.directory(input.scope), filename(input.name));
+    const path2 = join20(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record2, input.scope, this.#workspace);
     await writeExclusive(path2, `${JSON.stringify(record2, void 0, 2)}
 `);
@@ -36955,7 +37106,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 entry = matches[0];
-    const info = await lstat7(entry.path);
+    const info = await lstat8(entry.path);
     if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Managed tool path is no longer a regular file: ${entry.path}`);
     await unlink2(entry.path);
     this.#entries.delete(scopedKey(entry.scope, entry.record.name));
@@ -36966,7 +37117,7 @@ var ManagedToolStore = class {
     if (!parsed.success) return [];
     const matches = this.#matching(parsed.data.name).filter((entry) => parsed.data.scope === void 0 || entry.scope === parsed.data.scope);
     if (matches.length > 0) return matches.map((entry) => entry.path);
-    return [join19(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join20(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -36974,17 +37125,17 @@ var ManagedToolStore = class {
     try {
       names = (await readdir5(root, { withFileTypes: true })).filter((entry) => entry.name.endsWith(".json")).sort((left, right) => compare2(left.name, right.name)).map((entry) => entry.name);
     } catch (error) {
-      if (isMissing3(error)) return;
+      if (isMissing4(error)) return;
       this.#diagnostics.push(`${root}: ${message(error)}`);
       return;
     }
     for (const name of names) {
-      const path2 = join19(root, name);
+      const path2 = join20(root, name);
       try {
-        const info = await lstat7(path2);
+        const info = await lstat8(path2);
         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 record2 = ManagedToolRecordSchema.parse(JSON.parse(await readFile16(path2, "utf8")));
+        const record2 = ManagedToolRecordSchema.parse(JSON.parse(await readFile17(path2, "utf8")));
         if (record2.scope !== scope2) throw new Error(`Managed tool record scope must match its ${scope2} directory`);
         const key = scopedKey(scope2, record2.name);
         if (this.#entries.has(key)) throw new Error(`Duplicate managed tool name in ${scope2} scope: ${record2.name}`);
@@ -37177,7 +37328,7 @@ function compare2(left, right) {
 function compareScope(left, right) {
   return left === right ? 0 : left === "global" ? -1 : 1;
 }
-function isMissing3(error) {
+function isMissing4(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -37214,6 +37365,7 @@ var MVP_COMMANDS = [
   "remember",
   "forget",
   "forget-cold",
+  "global",
   "checkpoint",
   "tree",
   "rewind",
@@ -37256,6 +37408,7 @@ var COMMAND_DESCRIPTIONS = {
   remember: "Add a long-term memory",
   forget: "Remove matching long-term memories",
   "forget-cold": "Remove all cold long-term memories and their files",
+  global: "Show or edit global coding instructions",
   checkpoint: "Create a workspace and context checkpoint",
   tree: "Show the session history tree",
   rewind: "Restore a prior session node",
@@ -37354,6 +37507,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 };
@@ -37518,6 +37678,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",
@@ -37988,6 +38149,8 @@ Address this now (for example run the required verification or fix), then finish
       this.#notice(await required(this.#services.ide, "ide")());
     } else if (command.name === "memory") {
       this.#notice(await this.#services.memory());
+    } else if (command.name === "global") {
+      this.#notice(await required(this.#services.global, "global")(command));
     } else if (command.name === "remember") {
       this.#notice(await this.#services.remember(command.type, command.text));
     } else if (command.name === "forget") {
@@ -39333,8 +39496,8 @@ function createExecutionEnvironment(workspace, config) {
 }
 
 // src/ide/client.ts
-import { readFile as readFile17, readdir as readdir6, stat as stat8 } from "fs/promises";
-import { basename as basename3, join as join20, relative as relative14, resolve as resolve22, sep as sep14 } from "path";
+import { readFile as readFile18, readdir as readdir6, stat as stat8 } from "fs/promises";
+import { basename as basename3, join as join21, relative as relative14, resolve as resolve22, sep as sep14 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -39430,7 +39593,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join20(this.#home, ".flavor-code", "ide");
+    const directory = join21(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir6(directory)).filter((name) => name.endsWith(".lock"));
@@ -39438,9 +39601,9 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path2 = join20(directory, name);
+      const path2 = join21(directory, name);
       try {
-        const [contents, info] = await Promise.all([readFile17(path2, "utf8"), stat8(path2)]);
+        const [contents, info] = await Promise.all([readFile18(path2, "utf8"), stat8(path2)]);
         const lock = parseLockfile(contents);
         return lock === void 0 ? void 0 : { lock, modified: info.mtimeMs };
       } catch {
@@ -40633,6 +40796,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,
@@ -40749,6 +40914,7 @@ async function createProductionRuntime(options) {
       protocolVersion: 2,
       workspace,
       ...hookSessionId === void 0 ? {} : { sessionId: hookSessionId },
+      ...hookSessionId === void 0 || options.islandSessionTitle === void 0 ? {} : { sessionTitle: options.islandSessionTitle(hookSessionId) },
       ...islandControlMetadata === void 0 ? {} : {
         islandControlEndpoint: islandControlMetadata.endpoint,
         islandControlToken: islandControlMetadata.token,
@@ -40767,6 +40933,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,
@@ -40870,8 +41048,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join21(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join21(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join22(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join22(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
@@ -40980,7 +41158,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join21(tmpdir3(), `flavor-code-pals-${createHash16("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join22(tmpdir3(), `flavor-code-pals-${createHash16("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -41091,8 +41269,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join21(home, ".flavor-code", "skills")],
-      projectRoots: [join21(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join22(home, ".flavor-code", "skills")],
+      projectRoots: [join22(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -41100,7 +41278,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(join21(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join22(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -41340,6 +41518,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,
@@ -41377,6 +41556,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),
@@ -41697,7 +41877,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join21(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join22(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -41737,6 +41917,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,
@@ -41770,6 +41951,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),
@@ -42155,7 +42337,7 @@ async function createProductionRuntime(options) {
           const root = resolve25(workspace);
           const abs = resolve25(root, path2);
           if (abs !== root && !abs.startsWith(root + sep16)) throw new Error(`path outside workspace: ${path2}`);
-          return readFile18(abs, "utf8");
+          return readFile19(abs, "utf8");
         },
         history: async (path2, limit2) => fileHistory(workspace, path2, limit2),
         questions,
@@ -42167,7 +42349,7 @@ async function createProductionRuntime(options) {
       }, query, focus, signal),
       audit: async (toolFilter) => {
         try {
-          const raw = await readFile18(auditLogger.path, "utf8");
+          const raw = await readFile19(auditLogger.path, "utf8");
           const lines = raw.trim().split("\n").filter((line) => line.length > 0);
           const entries = lines.map((line) => {
             try {
@@ -42207,7 +42389,7 @@ ${summary2}`;
       doctor: async () => formatDoctorReport(await runDoctor({ workspace, home, environment })),
       usage: async () => {
         try {
-          const raw = await readFile18(usageLogPath(), "utf8");
+          const raw = await readFile19(usageLogPath(), "utf8");
           return formatUsageSummary(summarizeUsage(parseUsageEntries(raw)));
         } catch (error) {
           if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
@@ -42286,6 +42468,28 @@ ${summary2}`;
 Path: ${memoryStore.path}` : `Path: ${memoryStore.path}
 
 ${renderMemoryDocument(entries)}`;
+      },
+      global: async (command) => {
+        const path2 = join22(home, ".flavor-code", "GLOBAL.md");
+        if (globalInstructions === void 0) return `Global instructions are disabled.
+Path: ${path2}`;
+        if (command.action === "show") {
+          await globalInstructions.refresh();
+          return globalInstructions.content === void 0 ? `No global instructions stored.
+Path: ${path2}` : `Global instructions (enabled)
+Path: ${path2}
+
+${globalInstructions.content}`;
+        }
+        if (command.action === "remember") {
+          const result2 = await globalInstructions.remember(command.text);
+          return result2 === "added" ? `Remembered global rule.
+Path: ${path2}` : `Global rule already exists.
+Path: ${path2}`;
+        }
+        const result = await globalInstructions.forget(command.text);
+        return result === "removed" ? `Forgot global rule.
+Path: ${path2}` : result === "ambiguous" ? "Multiple global rules match. Use the full text of one rule." : "No matching global rule found.";
       },
       refreshMemory: refreshMemoryState,
       remember: async (type, text) => {
@@ -42360,7 +42564,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join21(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join22(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -42408,7 +42612,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join21(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join22(home, ".flavor-code", "auth.json"));
         const tokens = await tokenStore.load();
         const hadCredentials = Object.keys(tokens).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -42719,7 +42923,7 @@ async function workspaceFingerprint(workspace) {
     hash.update(name);
     if (remaining <= 0) continue;
     try {
-      const content = await readFile18(path2);
+      const content = await readFile19(path2);
       const slice = content.subarray(0, remaining);
       hash.update(slice);
       remaining -= slice.length;
@@ -42990,7 +43194,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(join21(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join22(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -43299,7 +43503,7 @@ async function generateSleepReview(registry, modelId, prompt, signal) {
 }
 async function optionalText2(path2) {
   try {
-    return await readFile18(path2, "utf8");
+    return await readFile19(path2, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
     throw error;