@cortexkit/magic-context 0.49.10 → 0.49.12

package/dist/index.js

@@ -1726,6 +1726,15 @@ var init_test_temp_dir = __esm(() => {
 });
 
 // ../plugin/src/shared/data-path.ts
+import {
+  existsSync as existsSync2,
+  lstatSync,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  readlinkSync,
+  realpathSync,
+  writeFileSync
+} from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 function getDataDir() {
@@ -1790,11 +1799,41 @@ function getMagicContextStorageResolution() {
 function getMagicContextStorageDir() {
   return getMagicContextStorageResolution().path;
 }
+function canonicalizeStoragePath(value, seen = new Set) {
+  const absolute = path.resolve(value);
+  if (seen.has(absolute))
+    return absolute;
+  seen.add(absolute);
+  try {
+    return realpathSync.native(absolute);
+  } catch {
+    try {
+      if (lstatSync(absolute).isSymbolicLink()) {
+        const target = readlinkSync(absolute);
+        const resolvedTarget = path.isAbsolute(target) ? target : path.resolve(path.dirname(absolute), target);
+        return canonicalizeStoragePath(resolvedTarget, seen);
+      }
+    } catch {}
+    const parent = path.dirname(absolute);
+    if (parent === absolute)
+      return absolute;
+    const resolvedParent = canonicalizeStoragePath(parent, seen);
+    return path.resolve(resolvedParent, path.basename(absolute));
+  }
+}
+function isMagicContextStorageOutsideEngram(storageDir = getMagicContextStorageDir(), backupDir = path.join(os.homedir(), ".local", "share", "cortexkit", "magic-context")) {
+  const resolvedStorageDir = canonicalizeStoragePath(storageDir);
+  const resolvedBackupDir = canonicalizeStoragePath(backupDir);
+  const relative2 = path.relative(resolvedBackupDir, resolvedStorageDir);
+  return path.isAbsolute(relative2) || relative2 === ".." || relative2.startsWith(`..${path.sep}`);
+}
 function getLegacyOpenCodeMagicContextStorageDir() {
   return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
 }
+var STORAGE_BACKUP_WARNING_CHECKED;
 var init_data_path = __esm(() => {
   init_test_temp_dir();
+  STORAGE_BACKUP_WARNING_CHECKED = Symbol.for("magic-context.storage-backup-warning-checked");
 });
 
 // ../plugin/src/shared/redaction.ts
@@ -2332,19 +2371,19 @@ import {
   closeSync as closeSync2,
   createWriteStream,
   fsyncSync,
-  lstatSync,
-  mkdirSync as mkdirSync2,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync3,
   openSync as openSync2,
   readdirSync,
-  readlinkSync,
+  readlinkSync as readlinkSync2,
   readSync as readSync2,
   renameSync,
   rmSync,
   symlinkSync,
-  writeFileSync,
+  writeFileSync as writeFileSync2,
   writeSync as writeSync2
 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { dirname as dirname3, join as join2 } from "node:path";
 function setStoragePrivatePermissionEnforcement(enforce) {
   enforcePrivateStoragePermissions = enforce;
 }
@@ -2353,7 +2392,7 @@ function shouldEnforcePrivateStoragePermissions() {
 }
 function ensureStorageDirectorySync(directory, forcePrivate = false, recursive = true) {
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
-  mkdirSync2(directory, {
+  mkdirSync3(directory, {
     recursive,
     ...privateMode ? { mode: 448 } : {}
   });
@@ -2361,13 +2400,13 @@ function ensureStorageDirectorySync(directory, forcePrivate = false, recursive =
 function writeStorageFileSync(filePath, content, options = {}) {
   const { forcePrivate = false, ...writeOptions } = options;
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
-  writeFileSync(filePath, content, {
+  writeFileSync2(filePath, content, {
     ...writeOptions,
     ...privateMode ? { mode: 384 } : {}
   });
 }
 function writeStorageFileAtomicSync(filePath, content, forcePrivate = false) {
-  ensureStorageDirectorySync(dirname2(filePath), forcePrivate);
+  ensureStorageDirectorySync(dirname3(filePath), forcePrivate);
   const tempPath = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   try {
     writeStorageFileSync(tempPath, content, { flag: "wx", forcePrivate });
@@ -2378,7 +2417,7 @@ function writeStorageFileAtomicSync(filePath, content, forcePrivate = false) {
   }
 }
 function copyStorageFileSync(sourcePath, destinationPath, forcePrivate = false) {
-  ensureStorageDirectorySync(dirname2(destinationPath), forcePrivate);
+  ensureStorageDirectorySync(dirname3(destinationPath), forcePrivate);
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
   const sourceFd = openSync2(sourcePath, "r");
   let destinationFd;
@@ -2405,10 +2444,10 @@ function copyStorageFileSync(sourcePath, destinationPath, forcePrivate = false)
   }
 }
 function copyStorageTreeSync(sourcePath, destinationPath, forcePrivate = false) {
-  const stat = lstatSync(sourcePath);
+  const stat = lstatSync2(sourcePath);
   if (stat.isSymbolicLink()) {
-    ensureStorageDirectorySync(dirname2(destinationPath), forcePrivate);
-    symlinkSync(readlinkSync(sourcePath), destinationPath);
+    ensureStorageDirectorySync(dirname3(destinationPath), forcePrivate);
+    symlinkSync(readlinkSync2(sourcePath), destinationPath);
     return;
   }
   if (!stat.isDirectory()) {
@@ -2421,7 +2460,7 @@ function copyStorageTreeSync(sourcePath, destinationPath, forcePrivate = false)
   }
 }
 function openStorageFileSync(filePath, flags, forcePrivate = false) {
-  ensureStorageDirectorySync(dirname2(filePath), forcePrivate);
+  ensureStorageDirectorySync(dirname3(filePath), forcePrivate);
   const privateMode = forcePrivate || shouldEnforcePrivateStoragePermissions();
   return openSync2(filePath, flags, privateMode ? 384 : 438);
 }
@@ -2434,7 +2473,7 @@ function tightenStorageTreeSync(root) {
   const visit = (entryPath) => {
     let stat;
     try {
-      stat = lstatSync(entryPath);
+      stat = lstatSync2(entryPath);
     } catch {
       failures++;
       return;
@@ -2813,9 +2852,9 @@ var init_jsonc_edit = __esm(() => {
 });
 
 // ../plugin/src/config/migrate-config-location.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, unlinkSync } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync2, unlinkSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join3 } from "node:path";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join3 } from "node:path";
 function homeDir() {
   if (process.platform === "win32") {
     return process.env.USERPROFILE || process.env.HOME || homedir3();
@@ -3039,8 +3078,8 @@ function markLegacySourcesMovedAside(sources, targetPath, logger) {
   for (const source of sources) {
     const markerPath = `${source.path}${MOVED_MARKER_SUFFIX}`;
     try {
-      const original = readFileSync2(source.path, "utf-8");
-      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename(source.path), original));
+      const original = readFileSync3(source.path, "utf-8");
+      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename2(source.path), original));
       unlinkSync(source.path);
       info?.(`Moved legacy Magic Context config ${source.path} aside to ${markerPath}; now reading ${targetPath}`);
     } catch (err) {
@@ -3057,12 +3096,12 @@ function visibleConfigMigrationWarning(scope, targetPath, paths, reason) {
 }
 function migrateConfigFile(opts) {
   const warnings = [];
-  const existingSources = opts.legacySources.filter((source) => existsSync2(source.path));
+  const existingSources = opts.legacySources.filter((source) => existsSync3(source.path));
   const info = opts.logger?.info ?? opts.logger?.log;
   if (existingSources.length === 0) {
     return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
   }
-  ensureStorageDirectorySync(dirname3(opts.targetPath), true);
+  ensureStorageDirectorySync(dirname4(opts.targetPath), true);
   const release = acquireConfigMigrationLock(`${opts.targetPath}.lock`);
   if (!release) {
     warnings.push(`Config migration for ${opts.scope} skipped this run (another instance is migrating); will retry on next start.`);
@@ -3071,10 +3110,10 @@ function migrateConfigFile(opts) {
   try {
     const sources = existingSources.map((source) => ({
       ...source,
-      content: readFileSync2(source.path, "utf-8")
+      content: readFileSync3(source.path, "utf-8")
     }));
-    if (existsSync2(opts.targetPath)) {
-      const targetContent = readFileSync2(opts.targetPath, "utf-8");
+    if (existsSync3(opts.targetPath)) {
+      const targetContent = readFileSync3(opts.targetPath, "utf-8");
       const differing = sources.filter((source) => !fileSemanticsMatch(source.content, targetContent));
       if (differing.length > 0) {
         const message = visibleConfigMigrationWarning(opts.scope, opts.targetPath, differing.map((source) => source.path), "the CortexKit target already exists with different settings");
@@ -9158,7 +9197,7 @@ var init_magic_context = __esm(() => {
       max_tokens: 12000
     })),
     "evaluate-smart-notes": DreamTaskBaseConfigSchema.default(() => DreamTaskBaseConfigSchema.parse(defaultTaskConfig("evaluate-smart-notes"))),
-    "review-user-memories": ReviewUserMemoriesTaskConfigSchema.default(() => ReviewUserMemoriesTaskConfigSchema.parse(defaultTaskConfig("review-user-memories"))),
+    "review-user-memories": ReviewUserMemoriesTaskConfigSchema.default(() => ReviewUserMemoriesTaskConfigSchema.parse(defaultTaskConfig("review-user-memories"))).describe("Promote recurring user observations into the <user-profile> block. A non-empty schedule also makes the historian collect user observations, but only while the dreamer is runnable (dreamer.disable not true); collection and review follow that one gate and do not depend on memory.enabled."),
     "promote-primers": PromotePrimersTaskConfigSchema.default(() => PromotePrimersTaskConfigSchema.parse(defaultTaskConfig("promote-primers"))),
     "refresh-primers": DreamTaskBaseConfigSchema.default(() => DreamTaskBaseConfigSchema.parse(defaultTaskConfig("refresh-primers")))
   }).describe("Harness-independent task metadata. schedule, promotion_threshold, and other task metadata remain here; execution settings live under dreamer.opencode.tasks, dreamer.pi.tasks, or dreamer.omp.tasks.");
@@ -9176,13 +9215,13 @@ var init_magic_context = __esm(() => {
     maxTokens: true
   });
   DreamerConfigSchema = AgentMetadataSchema.extend({
-    disable: boolean2().optional().describe("Disable this agent"),
+    disable: boolean2().optional().describe("Disable the dreamer: no scheduled or manual dream task runs. Also turns off smart notes (ctx_note drops surface_condition even with smart_notes.enabled true) and the historian's collection of user observations for review-user-memories. dreamer.inject_docs still applies."),
     runner: _enum(["broca", "host"]).optional().describe(`Which side runs the dreamer completions the Rust module routes (classify-memories) in Rust transform mode: "host" runs them on this process's carrier, "broca" routes them to the Broca module. When unset, historian.runner applies, and when that is unset too the harness decides the same way it does for the historian. User-level config only.`),
     opencode: DreamerOpenCodeHarnessBlockSchema.optional(),
     pi: DreamerPiHarnessBlockSchema.optional(),
     omp: DreamerOmpHarnessBlockSchema.optional(),
     tasks: DreamTasksSchema.default(() => DreamTasksSchema.parse({})),
-    inject_docs: boolean2().default(true).describe("Inject ARCHITECTURE.md and STRUCTURE.md into the m[0] `<project-docs>` block (default true)")
+    inject_docs: boolean2().default(true).describe("Inject ARCHITECTURE.md and STRUCTURE.md into the m[0] `<project-docs>` block (default true). Not a dreamer setting despite its place under dreamer: it applies on every host, also with dreamer.disable true.")
   });
   HistorianConfigSchema = AgentMetadataSchema.extend({
     expand_tools: record(string2(), union([
@@ -9313,9 +9352,9 @@ var init_magic_context = __esm(() => {
     profile: string2().trim().min(1).optional().describe("Select a named user-owned model profile. A valid project name overrides this user default; an empty string, null, or other non-string project value is ignored with a warning so the user selection still applies. Unknown names warn and use the base configuration."),
     profiles: ConfigProfilesSchema.optional().describe("User-level named model profiles. A profile may contain only historian/dreamer model, fallback_models, OpenCode variant, and Pi/OMP thinking_level fields; task execution policy (including timeout_minutes) is excluded. Project configs may select a name but cannot define profiles."),
     historian: HistorianConfigSchema.describe("Historian metadata plus independent strict OpenCode, Pi, and OMP execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode, historian.pi, or historian.omp."),
-    dreamer: DreamerConfigSchema.optional().describe("Dreamer metadata and scheduling plus independent strict OpenCode, Pi, and OMP execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block."),
+    dreamer: DreamerConfigSchema.optional().describe("Dreamer metadata and scheduling plus independent strict OpenCode, Pi, and OMP execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block. Each task follows the setting it serves: memory tasks need memory.enabled, evaluate-smart-notes needs smart_notes.enabled, review-user-memories needs its schedule, maintain-docs only a runnable dreamer."),
     smart_notes: object({
-      enabled: boolean2().default(true).describe("Enable smart-note authoring and condition evaluation. User-level only: tool definitions are process-wide. Changes require a host restart and rebuild each session's cached prompt once. Pending notes remain stored and unchecked; already-ready notes still surface."),
+      enabled: boolean2().default(true).describe("Enable smart-note authoring and condition evaluation. Needs a runnable dreamer, which evaluates the conditions: with dreamer.disable true (or no dreamer block) ctx_note offers no surface_condition whatever this says. User-level only: tool definitions are process-wide. Changes require a host restart and rebuild each session's cached prompt once. Pending notes remain stored and unchecked; already-ready notes still surface."),
       retina_handoff: boolean2().default(false).describe("When true, dreamer skips smart notes whose surface conditions compiled to retina provider configs at authoring time. Default false keeps both paths active until the retina consumer is deployed.")
     }).default({ enabled: true, retina_handoff: false }).describe("Smart-note ownership transition controls."),
     cache_ttl: union([string2(), object({ default: string2() }).catchall(string2())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard, then default). User and project settings, including an explicit "5m" or object default, apply on the next pass. Only built-in defaults are frozen per session, including across restarts: when unset, GPT-5.6 and later (including gpt-6*, through any provider prefix) use 30m, other models use 5m. /ctx-status shows the effective TTL and whether it comes from your config or a frozen built-in default. Editing the TTL does not itself rewrite prompt bytes; a lowered TTL rebuilds only after normal idle expiry. OpenAI documents at least 30 minutes since the latest write or reuse: https://developers.openai.com/api/docs/guides/prompt-caching (Cache lifetime and Summary of model differences). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
@@ -9343,11 +9382,11 @@ var init_magic_context = __esm(() => {
       object({ default: number2().int().min(0).max(1e6).optional() }).catchall(number2().int().min(0).max(1e6))
     ]).optional().describe("Reasoning tokens to keep on rebuilding passes. Number or per-model object; exact, shorter model keys, provider/*, then default. Omitted: fixed 10,000. 0 removes all eligible historical reasoning; newest and exempt steps always stay."),
     history_budget_percentage: number2().min(0.05).max(0.5).default(DEFAULT_HISTORY_BUDGET_PERCENTAGE).describe("Fraction of usable context (context_limit × execute_threshold) reserved for the session history block (default: 0.15)"),
-    historian_timeout_ms: number2().min(60000).default(DEFAULT_HISTORIAN_TIMEOUT_MS).describe("Timeout for each historian prompt call in both TypeScript and Rust transform modes, in milliseconds (default: 600000)"),
+    historian_timeout_ms: number2().min(60000).default(DEFAULT_HISTORIAN_TIMEOUT_MS).describe("Timeout for each historian prompt call in both TypeScript and Rust transform modes, in milliseconds (default: 600000). A historian setting kept at the top level for compatibility; no effect while historian.disable is true or compaction.enabled is false."),
     commit_cluster_trigger: object({
       enabled: boolean2().default(true).describe("Enable commit-cluster based historian triggering (default: true)"),
       min_clusters: number2().min(1).default(3).describe("Minimum commit clusters required to trigger historian (min: 1, default: 3)")
-    }).default({ enabled: true, min_clusters: 3 }).describe("Commit-cluster trigger: fire historian when enough commit clusters accumulate in the unsummarized tail"),
+    }).default({ enabled: true, min_clusters: 3 }).describe("Commit-cluster trigger: fire historian when enough commit clusters accumulate in the unsummarized tail. A historian setting kept at the top level for compatibility; no effect while historian.disable is true or compaction.enabled is false."),
     system_prompt_injection: object({
       enabled: boolean2().default(true).describe("When false, NO injection happens for ANY agent — global escape hatch. (default: true)"),
       skip_signatures: array(string2()).default(["<!-- magic-context: skip -->"]).describe(`Substring opt-out list. If the agent's system prompt contains any of these strings, skip ALL Magic Context injection for that call. Default "<!-- magic-context: skip -->" is meant to be added inside a user's custom agent prompt to opt that agent out.`)
@@ -9392,20 +9431,20 @@ var init_magic_context = __esm(() => {
       min_chars: number2().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
     }).default({ enabled: false, min_chars: 500 }).describe("Age-tier caveman compression for long user/assistant text parts. Active for primary sessions when enabled; never for subagents. Oldest 20% of eligible tags (outside protected tail) go to ultra, next 20% to full, next 20% to lite, newest 40% untouched. Graduated from experimental.caveman_text_compression; opt-in, default off (lossy)."),
     memory: object({
-      enabled: boolean2().default(true).describe("Enable cross-session memory (default: true). Does not affect history embedding or semantic ctx_search over session history; set embedding.provider to 'off' to stop all embedding."),
+      enabled: boolean2().default(true).describe("Enable cross-session project memory (default: true). Also gates the dreamer's project-memory tasks: while false, map-memories, verify, verify-broad, curate, compress-cues, classify-memories, retrospective, promote-primers and refresh-primers neither run on schedule nor through /ctx-dream; maintain-docs, evaluate-smart-notes and review-user-memories still run. memory.auto_search and memory.git_commit_indexing do not depend on it. Does not affect history embedding or semantic ctx_search over session history; set embedding.provider to 'off' to stop all embedding."),
       injection_budget_tokens: number2().min(500).max(20000).default(4000).describe("Token budget for memory injection on session start (min: 500, max: 20000, default: 4000)"),
-      auto_promote: boolean2().default(true).describe("Automatically promote eligible session facts into memory (default: true)"),
-      retrieval_count_promotion_threshold: number2().min(1).default(3).describe("retrieval_count threshold for promoting memory to permanent status (min: 1, default: 3)"),
+      auto_promote: boolean2().default(true).describe("Automatically promote eligible session facts into memory (default: true). No effect while memory.enabled is false."),
+      retrieval_count_promotion_threshold: number2().min(1).default(3).describe("Currently has no effect: no code reads this value, and memories are not promoted to permanent by retrieval count. Kept so existing configs stay valid (min: 1, default: 3)."),
       auto_search: object({
-        enabled: boolean2().default(true).describe("Automatically append a compact <ctx-search-hint> to eligible user messages when relevant memories, conversation, or commits are found. Graduated from experimental.auto_search; on by default (set false to opt out). Independent of memory.enabled."),
+        enabled: boolean2().default(true).describe("Automatically append a compact <ctx-search-hint> to eligible user messages when relevant memories, conversation, or commits are found. Graduated from experimental.auto_search; on by default (set false to opt out). Independent of memory.enabled despite its place under memory: with memory off it still searches past conversation and commits, only the memory source is skipped."),
         score_threshold: number2().min(0.3).max(0.95).default(0.6).describe("Top hit score must exceed this threshold for the hint to fire (min: 0.3, max: 0.95, default: 0.60)"),
         min_prompt_chars: number2().min(5).max(500).default(20).describe("Skip hint when user message is shorter than this (min: 5, max: 500, default: 20)")
-      }).default({ enabled: true, score_threshold: 0.6, min_prompt_chars: 20 }).describe("Auto-search hint: transform-time ctx_search on each new user message; when the top hit clears the threshold, append a compact <ctx-search-hint> block of vague fragments to that user message. Does NOT inject full content. Graduated from experimental.auto_search; enabled by default (set enabled: false to opt out). Independent of memory.enabled."),
+      }).default({ enabled: true, score_threshold: 0.6, min_prompt_chars: 20 }).describe("Auto-search hint: transform-time ctx_search on each new user message; when the top hit clears the threshold, append a compact <ctx-search-hint> block of vague fragments to that user message. Does NOT inject full content. Graduated from experimental.auto_search; enabled by default (set enabled: false to opt out). Independent of memory.enabled despite its place under memory: with memory off it still searches past conversation and commits."),
       git_commit_indexing: object({
-        enabled: boolean2().default(false).describe("Index HEAD git commits for ctx_search (git_commit source). Graduated from experimental.git_commit_indexing; opt-in, default off. Independent of memory.enabled."),
+        enabled: boolean2().default(false).describe("Index HEAD git commits for ctx_search (git_commit source). Graduated from experimental.git_commit_indexing; opt-in, default off. Independent of memory.enabled despite its place under memory."),
         since_days: number2().min(7).max(3650).default(365).describe("Days of HEAD history to index (min: 7, max: 3650, default: 365)"),
         max_commits: number2().min(100).max(20000).default(2000).describe("Max commits kept per project; oldest evicted (min: 100, max: 20000, default: 2000)")
-      }).default({ enabled: false, since_days: 365, max_commits: 2000 }).describe("Index git commit messages from HEAD into ctx_search. Commits become a 4th searchable source alongside memories and session history. Graduated from experimental.git_commit_indexing; opt-in, default off (per-project embedding cost). Independent of memory.enabled.")
+      }).default({ enabled: false, since_days: 365, max_commits: 2000 }).describe("Index git commit messages from HEAD into ctx_search. Commits become a 4th searchable source alongside memories and session history. Graduated from experimental.git_commit_indexing; opt-in, default off (per-project embedding cost). Independent of memory.enabled despite its place under memory.")
     }).default({
       enabled: true,
       injection_budget_tokens: 4000,
@@ -9413,7 +9452,7 @@ var init_magic_context = __esm(() => {
       retrieval_count_promotion_threshold: 3,
       auto_search: { enabled: true, score_threshold: 0.6, min_prompt_chars: 20 },
       git_commit_indexing: { enabled: false, since_days: 365, max_commits: 2000 }
-    }).describe("Cross-session memory configuration")
+    }).describe("Cross-session memory configuration. auto_search and git_commit_indexing sit here for history but work with memory.enabled false.")
   }).transform((data) => {
     return {
       ...data,
@@ -10190,17 +10229,17 @@ function pruneNestedConfigLeaf(block, relativePath) {
 // ../plugin/src/config/raw-loader.ts
 import {
   closeSync as closeSync3,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   linkSync,
   openSync as openSync3,
-  readFileSync as readFileSync3,
-  realpathSync,
+  readFileSync as readFileSync4,
+  realpathSync as realpathSync2,
   renameSync as renameSync2,
   statSync as statSync3,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { basename as basename2, dirname as dirname4, join as join4 } from "node:path";
+import { basename as basename3, dirname as dirname5, join as join4 } from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10394,7 +10433,7 @@ function writeExclusiveBackup(backupPath, bytes, mode) {
       if (error.code !== "EEXIST")
         throw error;
     }
-    const existingBytes = readFileSync3(backupPath);
+    const existingBytes = readFileSync4(backupPath);
     if (existingBytes.equals(bytes))
       return;
     if (bytes.subarray(0, existingBytes.length).equals(existingBytes)) {
@@ -10408,15 +10447,15 @@ function writeExclusiveBackup(backupPath, bytes, mode) {
   }
 }
 function writeTemporaryCandidate(configPath, bytes, mode) {
-  const directory = dirname4(configPath);
-  const stem = basename2(configPath);
+  const directory = dirname5(configPath);
+  const stem = basename3(configPath);
   for (let attempt = 0;attempt < 32; attempt++) {
     temporaryFileSequence += 1;
     const path = join4(directory, `.${stem}.per-harness-${process.pid}-${temporaryFileSequence}.tmp`);
     let descriptor;
     try {
       descriptor = openSync3(path, "wx", mode);
-      writeFileSync2(descriptor, bytes);
+      writeFileSync3(descriptor, bytes);
       closeSync3(descriptor);
       return path;
     } catch (error) {
@@ -10438,11 +10477,11 @@ function migrationWarning(diagnostic) {
   return diagnostic.message;
 }
 function loadRawConfigFile(options) {
-  if (!existsSync3(options.configPath))
+  if (!existsSync4(options.configPath))
     return null;
   let observedBytes;
   try {
-    observedBytes = readFileSync3(options.configPath);
+    observedBytes = readFileSync4(options.configPath);
   } catch (error) {
     throw new Error(`failed to read config: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -10482,12 +10521,12 @@ function loadRawConfigFile(options) {
     }
     let temporaryPath;
     try {
-      const writePath = realpathSync(options.configPath);
+      const writePath = realpathSync2(options.configPath);
       const mode = options.tier === "user" ? 384 : statSync3(writePath).mode & 511;
       writeExclusiveBackup(backupPath, observedBytes, mode);
       temporaryPath = writeTemporaryCandidate(writePath, migration.bytes, mode);
       options.afterTemporaryWrite?.();
-      const currentBytes = readFileSync3(options.configPath);
+      const currentBytes = readFileSync4(options.configPath);
       if (!hasFlatKeys(currentBytes)) {
         unlinkSync2(temporaryPath);
         return {
@@ -10597,9 +10636,9 @@ function resolveTransformMode(args) {
 var RUST_COMPACTION_OFF_WARNING = "compaction-off mode does not support rust transform mode; using the TypeScript transform.", RUST_REQUIRES_USER_SUBC_WARNING = "rust mode requires user-level subc configuration; running ts.";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute3, resolve as resolve2 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute3, resolve as resolve2 } from "node:path";
 function sensitiveFilePathReason(resolvedPath) {
   const home = homedir5();
   const sensitiveDirs = [
@@ -10646,7 +10685,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname5(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname6(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -10672,13 +10711,13 @@ function substituteConfigVariables(input) {
     if (sensitiveReason) {
       warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
     }
-    if (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync4(filePath, "utf-8").trim();
+      contents = readFileSync5(filePath, "utf-8").trim();
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -10697,7 +10736,7 @@ var init_variable = __esm(() => {
 });
 
 // ../plugin/src/config/index.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 function getUserConfigBasePath() {
   return cortexKitUserConfigBasePath();
 }
@@ -10705,10 +10744,10 @@ function getProjectConfigBasePath(directory) {
   return cortexKitProjectConfigBasePath(directory);
 }
 function resolveLegacyReadFallback(sources) {
-  return { source: sources.find((s) => existsSync5(s.path)) ?? null };
+  return { source: sources.find((s) => existsSync6(s.path)) ?? null };
 }
 function loadConfigFileDetailed(configPath, source) {
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return null;
   }
   let rawText;
@@ -11062,8 +11101,8 @@ function loadPluginConfigDetailed(directory, applyRuntimeGlobals = true) {
   const harnessLegacy = resolveLegacyConfigSourcesForHarness(directory, "opencode");
   const userLegacyFallback = userDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.user) : { source: null };
   const projectLegacyFallback = projectDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.project) : { source: null };
-  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync5(source.path));
-  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync5(source.path));
+  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync6(source.path));
+  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync6(source.path));
   const userLoaded = userDetected.format !== "none" ? loadConfigFileDetailed(userDetected.path, "user") : userLegacyFallback.source ? loadConfigFileDetailed(userLegacyFallback.source.path, "user") : null;
   const projectLoaded = projectDetected.format !== "none" ? loadConfigFileDetailed(projectDetected.path, "project") : projectLegacyFallback.source ? loadConfigFileDetailed(projectLegacyFallback.source.path, "project") : null;
   const allWarnings = [];
@@ -13724,17 +13763,17 @@ import {
   accessSync,
   chmodSync as chmodSync3,
   constants,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
   mkdtempSync,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   renameSync as renameSync3,
   rmSync as rmSync3,
   statSync as statSync5,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname6, join as join5 } from "node:path";
+import { dirname as dirname7, join as join5 } from "node:path";
 import { promisify } from "node:util";
 import { gunzipSync } from "node:zlib";
 function resolveDashboardChoice(argv, interactive) {
@@ -13883,7 +13922,7 @@ async function download(deps, asset) {
 }
 function readMacAppVersion(appPath) {
   try {
-    const plist = readFileSync5(join5(appPath, "Contents", "Info.plist"), "utf8");
+    const plist = readFileSync6(join5(appPath, "Contents", "Info.plist"), "utf8");
     const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/.exec(plist);
     return match?.[1]?.trim() ?? null;
   } catch {
@@ -13904,16 +13943,16 @@ async function detectInstalledDashboard(target, deps) {
     case "macos":
       for (const dir of macApplicationDirs(deps)) {
         const location = join5(dir, DASHBOARD_MAC_APP_NAME);
-        if (existsSync6(location))
+        if (existsSync7(location))
           return { location, version: readMacAppVersion(location) };
       }
       return null;
     case "linux": {
       const location = linuxAppImagePath(deps.homeDir);
-      if (existsSync6(location)) {
+      if (existsSync7(location)) {
         let version = null;
         try {
-          const marker = JSON.parse(readFileSync5(linuxVersionMarkerPath(deps.homeDir), "utf8"));
+          const marker = JSON.parse(readFileSync6(linuxVersionMarkerPath(deps.homeDir), "utf8"));
           if (typeof marker.version === "string")
             version = marker.version;
         } catch {
@@ -13921,7 +13960,7 @@ async function detectInstalledDashboard(target, deps) {
         }
         return { location, version };
       }
-      if (existsSync6(deps.linuxSystemBinaryPath)) {
+      if (existsSync7(deps.linuxSystemBinaryPath)) {
         return { location: deps.linuxSystemBinaryPath, version: null };
       }
       return null;
@@ -14042,7 +14081,7 @@ function findUnsafeTarEntry(tar) {
 async function installMac(data, deps, installed) {
   let destinationDir;
   if (installed) {
-    destinationDir = dirname6(installed.location);
+    destinationDir = dirname7(installed.location);
   } else if (isWritableDir(deps.macSystemApplicationsDir)) {
     destinationDir = deps.macSystemApplicationsDir;
   } else {
@@ -14052,21 +14091,21 @@ async function installMac(data, deps, installed) {
   const unsafe = findUnsafeTarEntry(gunzipSync(data));
   if (unsafe)
     throw new Error(`the app archive is unsafe to extract: ${unsafe}`);
-  mkdirSync3(destinationDir, { recursive: true });
+  mkdirSync4(destinationDir, { recursive: true });
   const staging = mkdtempSync(join5(destinationDir, ".magic-context-dashboard-"));
   try {
     const archive = join5(staging, "dashboard.app.tar.gz");
-    writeFileSync3(archive, data);
+    writeFileSync4(archive, data);
     const extractDir = join5(staging, "extracted");
-    mkdirSync3(extractDir);
+    mkdirSync4(extractDir);
     await deps.extractTarGz(archive, extractDir);
     const extracted = join5(extractDir, DASHBOARD_MAC_APP_NAME);
-    if (!existsSync6(extracted)) {
+    if (!existsSync7(extracted)) {
       throw new Error(`the archive did not contain ${DASHBOARD_MAC_APP_NAME}`);
     }
     const finalPath = join5(destinationDir, DASHBOARD_MAC_APP_NAME);
     const previous = join5(staging, "previous.app");
-    const hadPrevious = existsSync6(finalPath);
+    const hadPrevious = existsSync7(finalPath);
     if (hadPrevious)
       renameSync3(finalPath, previous);
     try {
@@ -14083,18 +14122,18 @@ async function installMac(data, deps, installed) {
 }
 function installLinux(data, version, deps) {
   const finalPath = linuxAppImagePath(deps.homeDir);
-  mkdirSync3(dirname6(finalPath), { recursive: true });
+  mkdirSync4(dirname7(finalPath), { recursive: true });
   const partial = `${finalPath}.partial-${process.pid}`;
   try {
-    writeFileSync3(partial, data, { mode: 493 });
+    writeFileSync4(partial, data, { mode: 493 });
     chmodSync3(partial, 493);
     renameSync3(partial, finalPath);
   } finally {
     rmSync3(partial, { force: true });
   }
   const marker = linuxVersionMarkerPath(deps.homeDir);
-  mkdirSync3(dirname6(marker), { recursive: true });
-  writeFileSync3(marker, `${JSON.stringify({ version, path: finalPath }, null, 2)}
+  mkdirSync4(dirname7(marker), { recursive: true });
+  writeFileSync4(marker, `${JSON.stringify({ version, path: finalPath }, null, 2)}
 `);
   return finalPath;
 }
@@ -14102,7 +14141,7 @@ async function installWindows(data, asset, deps) {
   const dir = mkdtempSync(join5(deps.tempRoot, "magic-context-dashboard-"));
   try {
     const installer = join5(dir, asset.name);
-    writeFileSync3(installer, data);
+    writeFileSync4(installer, data);
     deps.log.info("Running the dashboard installer (per-user install, no administrator rights).");
     await deps.runWindowsInstaller(installer);
   } finally {
@@ -14258,7 +14297,7 @@ var init_dashboard_install = __esm(() => {
 });
 
 // src/lib/docs-proposal-gitignore.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 import { join as join6 } from "node:path";
 function coversProposalState(line) {
   const rule = line.trim();
@@ -14268,16 +14307,16 @@ function coversProposalState(line) {
   return COVERING_PATHS.has(normalized);
 }
 function ensureDocsProposalGitignore(projectDir) {
-  if (!existsSync7(join6(projectDir, ".git")))
+  if (!existsSync8(join6(projectDir, ".git")))
     return { status: "not-a-repository" };
   const path = join6(projectDir, ".gitignore");
   try {
-    const text = existsSync7(path) ? readFileSync6(path, "utf8") : "";
+    const text = existsSync8(path) ? readFileSync7(path, "utf8") : "";
     if (text.split(/\r?\n/).some(coversProposalState))
       return { status: "covered" };
     const nestedPath = join6(projectDir, ".cortexkit", ".gitignore");
-    if (existsSync7(nestedPath)) {
-      const nested = readFileSync6(nestedPath, "utf8").split(/\r?\n/);
+    if (existsSync8(nestedPath)) {
+      const nested = readFileSync7(nestedPath, "utf8").split(/\r?\n/);
       if (nested.some((line) => /^\/?magic-context(\/(\*\*?)?)?$/.test(line.trim()))) {
         return { status: "covered" };
       }
@@ -14301,7 +14340,7 @@ var init_docs_proposal_gitignore = __esm(() => {
 });
 
 // src/lib/find-on-path.ts
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync8, statSync as statSync6 } from "node:fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync9, statSync as statSync6 } from "node:fs";
 import { delimiter, join as join7 } from "node:path";
 function findOnPath(binary) {
   const PATH = process.env.PATH;
@@ -14323,7 +14362,7 @@ function findOnPath(binary) {
 }
 function isExecutableFile(path, isWindows = process.platform === "win32") {
   try {
-    if (!existsSync8(path))
+    if (!existsSync9(path))
       return false;
     const st = statSync6(path);
     if (!st.isFile())
@@ -14340,9 +14379,9 @@ function isExecutableFile(path, isWindows = process.platform === "win32") {
 var init_find_on_path = () => {};
 
 // src/lib/paths.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync2, statSync as statSync7 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { delimiter as delimiter2, dirname as dirname7, join as join8, resolve as resolve3 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname8, join as join8, resolve as resolve3 } from "node:path";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
@@ -14361,7 +14400,7 @@ function findOmoConfig(configDir) {
     join8(configDir, "oh-my-opencode.json")
   ];
   for (const loc of locations) {
-    if (existsSync9(loc))
+    if (existsSync10(loc))
       return loc;
   }
   return null;
@@ -14374,10 +14413,10 @@ function detectConfigPaths() {
   let tuiConfigFormat;
   const jsoncPath = join8(configDir, "opencode.jsonc");
   const jsonPath = join8(configDir, "opencode.json");
-  if (existsSync9(jsoncPath)) {
+  if (existsSync10(jsoncPath)) {
     opencodeConfig = jsoncPath;
     opencodeConfigFormat = "jsonc";
-  } else if (existsSync9(jsonPath)) {
+  } else if (existsSync10(jsonPath)) {
     opencodeConfig = jsonPath;
     opencodeConfigFormat = "json";
   } else {
@@ -14386,10 +14425,10 @@ function detectConfigPaths() {
   }
   const tuiJsoncPath = join8(configDir, "tui.jsonc");
   const tuiJsonPath = join8(configDir, "tui.json");
-  if (existsSync9(tuiJsoncPath)) {
+  if (existsSync10(tuiJsoncPath)) {
     tuiConfig = tuiJsoncPath;
     tuiConfigFormat = "jsonc";
-  } else if (existsSync9(tuiJsonPath)) {
+  } else if (existsSync10(tuiJsonPath)) {
     tuiConfig = tuiJsonPath;
     tuiConfigFormat = "json";
   } else {
@@ -14423,7 +14462,7 @@ function getPiSessionsRoot() {
   return join8(getPiAgentDir(), "sessions");
 }
 function getPiCacheRoot() {
-  return join8(dirname7(getPiAgentDir()), "cache");
+  return join8(dirname8(getPiAgentDir()), "cache");
 }
 function getPiUserConfigPath() {
   return resolveCortexKitUserConfigPath();
@@ -14448,7 +14487,7 @@ function resolveOmpPaths() {
     if (xdgDataHome) {
       const appRoot = join8(xdgDataHome, "omp");
       const candidate = profile ? join8(appRoot, "profiles", profile) : appRoot;
-      if (existsSync9(candidate))
+      if (existsSync10(candidate))
         dataRoot = candidate;
     }
   }
@@ -14483,16 +14522,19 @@ function getOmpPackageDir() {
   return resolve3(value);
 }
 function getOmpNonGlobalConfigSources(cwd = process.cwd()) {
-  const sources = process.env.PI_CONFIG_FILES?.split(delimiter2).map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+  const sources = getOmpConfigOverlayPaths(cwd);
+  const projectConfig = resolve3(cwd, ".omp", "config.yml");
+  if (existsSync10(projectConfig))
+    sources.push(projectConfig);
+  return [...new Set(sources)];
+}
+function getOmpConfigOverlayPaths(cwd = process.cwd()) {
+  return process.env.PI_CONFIG_FILES?.split(delimiter2).map((entry) => entry.trim()).filter(Boolean).map((entry) => {
     if (entry === "~")
       return envFirstHomeDir();
     const expanded = entry.startsWith("~/") || entry.startsWith("~\\") ? join8(envFirstHomeDir(), entry.slice(2)) : entry;
     return resolve3(cwd, expanded);
   }) ?? [];
-  const projectConfig = resolve3(cwd, ".omp", "config.yml");
-  if (existsSync9(projectConfig))
-    sources.push(projectConfig);
-  return [...new Set(sources)];
 }
 function getOmpPluginsDir() {
   return resolveOmpPaths().pluginsDir;
@@ -14660,7 +14702,7 @@ var init_pi_helpers = __esm(() => {
 
 // src/lib/omp-helpers.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { extname as extname2, join as join10 } from "node:path";
 function detectOmpPackageCli() {
@@ -14670,11 +14712,11 @@ function detectOmpPackageCli() {
   if (!findOnPath("bun"))
     return null;
   try {
-    const manifest = JSON.parse(readFileSync7(join10(packageDir, "package.json"), "utf-8"));
+    const manifest = JSON.parse(readFileSync8(join10(packageDir, "package.json"), "utf-8"));
     if (manifest.name !== "@oh-my-pi/pi-coding-agent")
       return null;
     const cli = join10(packageDir, "dist", "cli.js");
-    return existsSync10(cli) ? cli : null;
+    return existsSync11(cli) ? cli : null;
   } catch {
     return null;
   }
@@ -14818,7 +14860,7 @@ var init_omp_helpers = __esm(() => {
 });
 
 // src/adapters/omp.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
 import { join as join11 } from "node:path";
 
 class OmpAdapter {
@@ -14920,7 +14962,7 @@ class OmpAdapter {
   }
   getPluginCacheInfo() {
     const path = join11(getOmpPluginsDir(), "cache");
-    return [{ path, exists: existsSync11(path), sizeBytes: dirSizeBytes(path) }];
+    return [{ path, exists: existsSync12(path), sizeBytes: dirSizeBytes(path) }];
   }
   getLogPath() {
     return getMagicContextLogPath2("omp");
@@ -14933,7 +14975,7 @@ class OmpAdapter {
   }
   readRuntimeEnabled(configPath) {
     try {
-      const lock = JSON.parse(readFileSync8(configPath, "utf-8"));
+      const lock = JSON.parse(readFileSync9(configPath, "utf-8"));
       const enabled = lock.plugins?.[OMP_PLUGIN_PACKAGE]?.enabled;
       return typeof enabled === "boolean" ? enabled : undefined;
     } catch {
@@ -14961,7 +15003,7 @@ var init_omp = __esm(() => {
 });
 
 // ../plugin/src/shared/opencode-db-path.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync13, readdirSync as readdirSync3, statSync as statSync8 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { isAbsolute as isAbsolute4, join as join12, resolve as resolve4 } from "node:path";
 function openCodeHostGenerationFromVersion(version) {
@@ -15060,7 +15102,7 @@ function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
   const dataDir = openCodeDataDir(env, options.dataHome);
   const channel = options.channel ?? env.OPENCODE_CHANNEL;
   const key = environmentKey(dataDir, hostGeneration, channel, env);
-  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync12(cachedResolution.resolution.path))) {
+  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync13(cachedResolution.resolution.path))) {
     if (cachedResolution.existed)
       return cachedResolution.resolution;
   }
@@ -15068,7 +15110,7 @@ function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
   cachedResolution = {
     key,
     resolution,
-    existed: resolution.path !== ":memory:" && existsSync12(resolution.path)
+    existed: resolution.path !== ":memory:" && existsSync13(resolution.path)
   };
   return resolution;
 }
@@ -15108,7 +15150,7 @@ function assertOpenCodeStoreGeneration(db, expected, path, schema = "main") {
   throw new Error(`OpenCode store generation mismatch at ${path}: expected ${expected}, found ${actual}; refusing generation-specific database access`);
 }
 function openCodeDbPathExists(resolution = resolveOpenCodeDbPath()) {
-  return resolution.path !== ":memory:" && existsSync12(resolution.path);
+  return resolution.path !== ":memory:" && existsSync13(resolution.path);
 }
 function getOpenCodeDbProbeDescriptions(resolution = resolveOpenCodeDbPath()) {
   if (resolution.source === "OPENCODE_DB")
@@ -23027,7 +23069,7 @@ var init_project_directory_key = () => {};
 
 // ../plugin/src/shared/rpc-utils.ts
 import { execFile as execFile2, execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 function isOwnRpcServerRecord(record) {
   return record.pid === process.pid && record.instance_id !== undefined && ownRpcServerInstanceIds.has(record.instance_id);
 }
@@ -23622,7 +23664,7 @@ var init_rpc_utils = __esm(() => {
     "cljs/dist",
     "dist/bundle/cli"
   ];
-  rpcIdentityReadFileSync = readFileSync9;
+  rpcIdentityReadFileSync = readFileSync10;
   rpcIdentityExecFileSync = execFileSync2;
   rpcIdentityProcessKill = process.kill;
   rpcProcessListExecFileSync = execFileSync2;
@@ -23663,7 +23705,7 @@ var init_opencode_plugin_registration = __esm(() => {
 });
 
 // src/lib/opencode-plugin-cache.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
 import { join as join13 } from "node:path";
 function getOpenCodePluginCacheRoots() {
   const cacheDir = getOpenCodePluginCacheDir();
@@ -23766,7 +23808,7 @@ function readOpenCodeV2CachedPluginVersion(slot) {
   if (!generation)
     return;
   try {
-    const pkg = JSON.parse(readFileSync10(getOpenCodePluginPackageJsonPath(generation), "utf-8"));
+    const pkg = JSON.parse(readFileSync11(getOpenCodePluginPackageJsonPath(generation), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -23780,7 +23822,7 @@ var init_opencode_plugin_cache = __esm(() => {
 });
 
 // src/commands/doctor-windows-holders.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 function assertWindowsStoresClosed(paths, processes) {
   if (processes.pi.state !== "known" || processes.pi.processIds.length > 0 || (processes.pi.inconclusivePids?.length ?? 0) > 0 || processes.processSnapshot?.source !== "cim") {
     throw new Error(`Windows process probe could not rule out OpenCode, Pi or ck-mc holders${processes.pi.processIds.length || processes.pi.inconclusivePids?.length ? ` (PID ${[...processes.pi.processIds, ...processes.pi.inconclusivePids ?? []].join(", ")})` : ""}`);
@@ -23796,7 +23838,7 @@ function assertWindowsStoresClosed(paths, processes) {
   if (blockers.length)
     throw new Error(`OpenCode, Pi or ck-mc process is running (${blockers.map(({ pid, imageName, commandLine }) => `${imageName ?? commandLine} PID ${pid}`).join(", ")})`);
   for (const path of [...new Set(paths)]) {
-    if (!existsSync13(path))
+    if (!existsSync14(path))
       continue;
     let db;
     let locked = false;
@@ -23820,7 +23862,7 @@ var init_doctor_windows_holders = __esm(async () => {
 
 // src/commands/doctor-opencode2-cache.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync14, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync15, rmSync as rmSync4 } from "node:fs";
 function runLsof(args, spawn) {
   const result = spawn("lsof", args, { encoding: "utf-8", timeout: 15000, windowsHide: true });
   if (result.error)
@@ -23835,7 +23877,7 @@ function probeHostProcessesUsing(targets, spawn = spawnSync3) {
   if (process.platform === "win32") {
     try {
       assertWindowsStoresClosed(targets.files.filter((path) => !/-(?:wal|shm)$/.test(path)), inspectWindowsProcessesSync());
-      if (targets.directories.some(existsSync14))
+      if (targets.directories.some(existsSync15))
         return {
           status: "unknown",
           reason: "Windows cannot rule out open files in plugin cache directories"
@@ -23848,8 +23890,8 @@ function probeHostProcessesUsing(targets, spawn = spawnSync3) {
       };
     }
   }
-  const files = targets.files.filter((file) => existsSync14(file));
-  const directories = targets.directories.filter((directory) => existsSync14(directory));
+  const files = targets.files.filter((file) => existsSync15(file));
+  const directories = targets.directories.filter((directory) => existsSync15(directory));
   const queries = [];
   if (files.length > 0)
     queries.push(["-w", "-t", "--", ...files]);
@@ -23944,9 +23986,9 @@ function checkOpenCodeV2PluginCache(options, deps = {}) {
   const slot = deps.slot ?? getOpenCodeV2PluginCacheSlot(undefined, distTag ?? "latest");
   const tagged = distTag ? { distTag } : {};
   if (options.referencedSpecs !== undefined && !options.referencedSpecs.has(distTag ?? "latest")) {
-    return existsSync14(slot) ? { action: "unused", slot, cached: readOpenCodeV2CachedPluginVersion(slot), ...tagged } : { action: "not_found", slot, unused: true, ...tagged };
+    return existsSync15(slot) ? { action: "unused", slot, cached: readOpenCodeV2CachedPluginVersion(slot), ...tagged } : { action: "not_found", slot, unused: true, ...tagged };
   }
-  if (!existsSync14(slot))
+  if (!existsSync15(slot))
     return { action: "not_found", slot, ...tagged };
   const cached = readOpenCodeV2CachedPluginVersion(slot);
   const latest = options.latestVersion ?? undefined;
@@ -24038,22 +24080,22 @@ var init_doctor_opencode2_cache = __esm(async () => {
 // src/lib/atomic-write.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import {
-  lstatSync as lstatSync2,
-  mkdirSync as mkdirSync4,
-  readlinkSync as readlinkSync2,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync5,
+  readlinkSync as readlinkSync3,
   renameSync as renameSync4,
   rmSync as rmSync5,
   statSync as statSync9,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname8, resolve as resolve5 } from "node:path";
+import { dirname as dirname9, resolve as resolve5 } from "node:path";
 function resolveWriteTarget(targetPath) {
   let current = resolve5(targetPath);
   for (let hop = 0;hop < MAX_SYMLINK_HOPS; hop++) {
-    const stat = lstatSync2(current, { throwIfNoEntry: false });
+    const stat = lstatSync3(current, { throwIfNoEntry: false });
     if (!stat?.isSymbolicLink())
       return current;
-    current = resolve5(dirname8(current), readlinkSync2(current));
+    current = resolve5(dirname9(current), readlinkSync3(current));
   }
   throw new Error(`Too many levels of symbolic links resolving ${targetPath}`);
 }
@@ -24063,12 +24105,12 @@ function writeFileAtomic(targetPath, data, options = {}) {
     writeStorageFileAtomicSync(finalPath, data, true);
     return;
   }
-  mkdirSync4(dirname8(finalPath), { recursive: true });
+  mkdirSync5(dirname9(finalPath), { recursive: true });
   const existing = statSync9(finalPath, { throwIfNoEntry: false });
   const mode = existing?.isFile() ? existing.mode & 511 : undefined;
   const tmpPath = `${finalPath}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
   try {
-    writeFileSync4(tmpPath, data, {
+    writeFileSync5(tmpPath, data, {
       encoding: "utf-8",
       flag: "wx",
       ...mode !== undefined ? { mode } : {}
@@ -24085,7 +24127,7 @@ var init_atomic_write = __esm(() => {
 });
 
 // src/lib/jsonc-config.ts
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
 function parseErrorLocation(content, error) {
   const lines = content.split(`
 `);
@@ -24101,9 +24143,9 @@ function parseErrorLocation(content, error) {
   return { line: messageLine ? Number.parseInt(messageLine, 10) : 1, column: 1 };
 }
 function readJsoncConfig(path) {
-  if (!existsSync15(path))
+  if (!existsSync16(path))
     return { kind: "missing" };
-  const content = readFileSync11(path, "utf-8");
+  const content = readFileSync12(path, "utf-8");
   try {
     const rejectedKeyPaths = [];
     const parsed = sanitizeParsedJson(import_comment_json.parse(content), {
@@ -24129,7 +24171,7 @@ function readJsoncConfigForUpdate(path) {
   return result.value;
 }
 function readJsoncTextForEdit(configPath) {
-  const raw = readFileSync11(configPath, "utf-8");
+  const raw = readFileSync12(configPath, "utf-8");
   return raw.startsWith(BYTE_ORDER_MARK) ? { bom: BYTE_ORDER_MARK, text: raw.slice(BYTE_ORDER_MARK.length) } : { bom: "", text: raw };
 }
 function assertJsoncConfigsParseable(paths) {
@@ -24218,13 +24260,13 @@ var init_jsonc_config = __esm(() => {
 });
 
 // src/lib/opencode-detect.ts
-import { existsSync as existsSync16, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync17, realpathSync as realpathSync3 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { join as join14 } from "node:path";
 function defaultDeps(overrides = {}) {
   const env = overrides.env ?? process.env;
   return {
-    exists: overrides.exists ?? existsSync16,
+    exists: overrides.exists ?? existsSync17,
     isExecutable: overrides.isExecutable ?? isExecutableFile,
     home: overrides.home ?? (env.HOME?.trim() || homedir11()),
     platform: overrides.platform ?? process.platform,
@@ -24275,7 +24317,7 @@ function openChamberCliCandidates(d) {
 }
 function canonicalPath(d, path) {
   try {
-    return d.realpath ? d.realpath(path) : realpathSync2(path);
+    return d.realpath ? d.realpath(path) : realpathSync3(path);
   } catch {
     return path;
   }
@@ -24438,8 +24480,8 @@ var OPENCODE_BINARY_ENV = "MAGIC_CONTEXT_OPENCODE_BINARY", OPENCODE_VERSION_PROB
 var init_opencode_helpers = () => {};
 
 // src/adapters/opencode.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12, statSync as statSync10 } from "node:fs";
-import { dirname as dirname9, isAbsolute as isAbsolute5, parse as parsePath, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync13, statSync as statSync10 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute5, parse as parsePath, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 class OpenCodeAdapter {
@@ -24470,7 +24512,7 @@ class OpenCodeAdapter {
     if (paths.opencodeConfigFormat === "none")
       return false;
     try {
-      const raw = readFileSync12(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync13(paths.opencodeConfig, "utf-8");
       const cfg = import_comment_json2.parse(raw);
       return readPluginEntries(cfg).some(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME));
     } catch {
@@ -24506,7 +24548,7 @@ class OpenCodeAdapter {
           configPath: target
         };
       }
-      const raw = readFileSync12(target, "utf-8");
+      const raw = readFileSync13(target, "utf-8");
       const cfg = import_comment_json2.parse(raw);
       if (cfg === null || typeof cfg !== "object") {
         return {
@@ -24518,7 +24560,7 @@ class OpenCodeAdapter {
       }
       const entries = readPluginEntries(cfg);
       const existing = entries.find(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME));
-      const existingDev = entries.find(({ entry }) => isDevPathPluginEntry(entry, dirname9(target)));
+      const existingDev = entries.find(({ entry }) => isDevPathPluginEntry(entry, dirname10(target)));
       if (!existing && !existingDev) {
         const list = Array.isArray(cfg[this.writeKey]) ? cfg[this.writeKey] : [];
         list.push(OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
@@ -24581,7 +24623,7 @@ class OpenCodeAdapter {
       };
     }
     try {
-      const raw = readFileSync12(target, "utf-8");
+      const raw = readFileSync13(target, "utf-8");
       const cfg = import_comment_json2.parse(raw);
       if (cfg === null || typeof cfg !== "object") {
         return {
@@ -24632,9 +24674,9 @@ class OpenCodeAdapter {
   }
   getPluginCacheInfo() {
     const legacyPath = getOpenCodePluginCacheDir();
-    const legacyExists = existsSync17(legacyPath);
+    const legacyExists = existsSync18(legacyPath);
     const slot = getOpenCodeV2PluginCacheSlot();
-    const slotExists = existsSync17(slot);
+    const slotExists = existsSync18(slot);
     const caches = [];
     if (legacyExists || !slotExists) {
       caches.push({
@@ -24692,7 +24734,7 @@ class OpenCodeAdapter {
     if (paths.opencodeConfigFormat === "none")
       return "latest";
     try {
-      const cfg = import_comment_json2.parse(readFileSync12(paths.opencodeConfig, "utf-8"));
+      const cfg = import_comment_json2.parse(readFileSync13(paths.opencodeConfig, "utf-8"));
       return readConfiguredOpenCodePluginSpec(cfg);
     } catch {
       return "latest";
@@ -24704,10 +24746,10 @@ class OpenCodeAdapter {
       return readOpenCodeV2CachedPluginVersion(slot) ?? null;
     }
     for (const candidate of getOpenCodePluginPackageJsonPaths()) {
-      if (!existsSync17(candidate))
+      if (!existsSync18(candidate))
         continue;
       try {
-        const raw = readFileSync12(candidate, "utf-8");
+        const raw = readFileSync13(candidate, "utf-8");
         const pkg = JSON.parse(raw);
         if (typeof pkg.version === "string")
           return pkg.version;
@@ -24746,15 +24788,15 @@ function isDevPathPluginEntry(entry, configDir) {
       localPath = resolve6(configDir, candidate);
     }
     if (statSync10(localPath).isFile())
-      localPath = dirname9(localPath);
+      localPath = dirname10(localPath);
     const root = parsePath(localPath).root;
     while (localPath !== root) {
       const packagePath = resolve6(localPath, "package.json");
-      if (existsSync17(packagePath)) {
-        const pkg = JSON.parse(readFileSync12(packagePath, "utf8"));
+      if (existsSync18(packagePath)) {
+        const pkg = JSON.parse(readFileSync13(packagePath, "utf8"));
         return pkg.name === OPENCODE_PLUGIN_NAME;
       }
-      localPath = dirname9(localPath);
+      localPath = dirname10(localPath);
     }
   } catch {}
   return false;
@@ -24770,8 +24812,8 @@ function matchesPluginEntry(entry, pkgName) {
   return head === pkgName;
 }
 function ensureDir2(filePath) {
-  const dir = dirname9(filePath);
-  if (!existsSync17(dir)) {
+  const dir = dirname10(filePath);
+  if (!existsSync18(dir)) {
     const { mkdirSync } = __require("node:fs");
     mkdirSync(dir, { recursive: true });
   }
@@ -24792,7 +24834,7 @@ var init_opencode = __esm(async () => {
 });
 
 // src/lib/pi-package-entry.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync14 } from "node:fs";
 import { isAbsolute as isAbsolute6, join as join15 } from "node:path";
 function stripNpmPrefix(value) {
   return value.startsWith("npm:") ? value.slice("npm:".length) : value;
@@ -24849,10 +24891,10 @@ function hasPiMagicContextPackage(entries, agentDir = getPiAgentConfigDir()) {
 }
 function isPiMagicContextPackageDir(dir) {
   const packageJson = join15(dir, "package.json");
-  if (!existsSync18(packageJson))
+  if (!existsSync19(packageJson))
     return false;
   try {
-    const pkg = JSON.parse(readFileSync13(packageJson, "utf-8"));
+    const pkg = JSON.parse(readFileSync14(packageJson, "utf-8"));
     return typeof pkg.name === "string" && pkg.name === PI_MAGIC_CONTEXT_PACKAGE_NAME;
   } catch {
     return false;
@@ -24888,8 +24930,8 @@ var init_pi_package_entry = __esm(() => {
 });
 
 // src/adapters/pi.ts
-import { existsSync as existsSync19 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
 
 class PiAdapter {
   kind = "pi";
@@ -25026,8 +25068,8 @@ function writePiSettings(settings) {
 `);
 }
 function ensureDir3(filePath) {
-  const dir = dirname10(filePath);
-  if (!existsSync19(dir)) {
+  const dir = dirname11(filePath);
+  if (!existsSync20(dir)) {
     const { mkdirSync } = __require("node:fs");
     mkdirSync(dir, { recursive: true });
   }
@@ -26609,7 +26651,7 @@ function installCompartmentHistoryVersions(db) {
 
 // ../plugin/src/features/magic-context/memory/project-identity-cache.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 import path4 from "node:path";
 function cachePath(directory, storageDir = getMagicContextStorageDir()) {
   const hash = createHash4("sha256").update(projectDirectoryKey(directory)).digest("hex");
@@ -26623,7 +26665,7 @@ function rememberGitIdentity(directory, identity) {
 }
 function readRememberedGitIdentity(directory, storageDir) {
   try {
-    const record = JSON.parse(readFileSync14(cachePath(directory, storageDir), "utf8"));
+    const record = JSON.parse(readFileSync15(cachePath(directory, storageDir), "utf8"));
     if (record.directory === projectDirectoryKey(directory) && /^git:[0-9a-f]{7,64}$/.test(record.identity))
       return record.identity;
   } catch {}
@@ -26635,12 +26677,171 @@ var init_project_identity_cache = __esm(() => {
   init_storage_permissions();
 });
 
+// ../plugin/src/features/magic-context/memory/unborn-head.ts
+import { readFileSync as readFileSync16, realpathSync as realpathSync4, statSync as statSync11 } from "node:fs";
+import path5 from "node:path";
+function errorCode(error) {
+  if (error === null || typeof error !== "object" || !("code" in error))
+    return;
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+function readText(file) {
+  try {
+    return { ok: true, text: readFileSync16(file, "utf8") };
+  } catch (error) {
+    return { ok: false, missing: errorCode(error) === "ENOENT" };
+  }
+}
+function entryKind(entry) {
+  try {
+    const stat = statSync11(entry);
+    if (stat.isFile())
+      return "file";
+    if (stat.isDirectory())
+      return "directory";
+    return "other";
+  } catch (error) {
+    return errorCode(error) === "ENOENT" ? "missing" : "error";
+  }
+}
+function stripLineEnding(text) {
+  return text.replace(/\r?\n$/u, "");
+}
+function resolveMetadataPath(baseDirectory, value) {
+  return path5.resolve(baseDirectory, value);
+}
+function isPlainBranchName(name) {
+  if (name.length === 0 || name.endsWith("/") || name.endsWith("."))
+    return false;
+  if (name.includes("..") || name.includes("//") || name.includes("@{"))
+    return false;
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    if (code <= 32 || code === 127 || "~^:?*[\\".includes(character))
+      return false;
+  }
+  return name.split("/").every((component) => !component.startsWith(".") && !component.endsWith(".lock"));
+}
+function findGitDirectory(start) {
+  let current = start;
+  while (true) {
+    const dotGit = path5.join(current, ".git");
+    const kind = entryKind(dotGit);
+    if (kind === "directory")
+      return dotGit;
+    if (kind === "file") {
+      const read = readText(dotGit);
+      if (!read.ok)
+        return;
+      const match = /^gitdir: (.+)$/u.exec(stripLineEnding(read.text));
+      if (!match?.[1] || match[1].includes(`
+`))
+        return;
+      return resolveMetadataPath(current, match[1]);
+    }
+    if (kind !== "missing")
+      return;
+    const parent = path5.dirname(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+function packedRefsList(text, ref) {
+  for (const rawLine of text.split(`
+`)) {
+    const line = rawLine.replace(/\r$/u, "");
+    if (line === "" || line.startsWith("#") || line.startsWith("^"))
+      continue;
+    const match = /^[0-9a-f]{40,64} (\S+)$/u.exec(line);
+    if (!match)
+      return;
+    if (match[1] === ref)
+      return true;
+  }
+  return false;
+}
+function isUnbornHeadInLayout(directory) {
+  const gitDirectory = findGitDirectory(directory);
+  if (gitDirectory === undefined)
+    return false;
+  let commonDirectory = gitDirectory;
+  const commondir = readText(path5.join(gitDirectory, "commondir"));
+  if (commondir.ok) {
+    const value = stripLineEnding(commondir.text);
+    if (value === "" || value.includes(`
+`))
+      return false;
+    commonDirectory = resolveMetadataPath(gitDirectory, value);
+  } else if (!commondir.missing) {
+    return false;
+  }
+  if (entryKind(path5.join(gitDirectory, "HEAD")) !== "file")
+    return false;
+  if (entryKind(path5.join(commonDirectory, "objects")) !== "directory")
+    return false;
+  if (entryKind(path5.join(commonDirectory, "refs")) !== "directory")
+    return false;
+  if (entryKind(path5.join(commonDirectory, "reftable")) !== "missing")
+    return false;
+  const config = readText(path5.join(commonDirectory, "config"));
+  if (config.ok) {
+    if (/refstorage/iu.test(config.text))
+      return false;
+  } else if (!config.missing) {
+    return false;
+  }
+  const head = readText(path5.join(gitDirectory, "HEAD"));
+  if (!head.ok)
+    return false;
+  const headMatch = /^ref: (refs\/heads\/(.+))$/u.exec(head.text.replace(/\s+$/u, ""));
+  const ref = headMatch?.[1];
+  const branch = headMatch?.[2];
+  if (!ref || branch === undefined || !isPlainBranchName(branch))
+    return false;
+  const refSegments = ref.split("/");
+  for (const base of new Set([commonDirectory, gitDirectory])) {
+    if (entryKind(path5.join(base, ...refSegments)) !== "missing")
+      return false;
+  }
+  const packed = readText(path5.join(commonDirectory, "packed-refs"));
+  if (packed.ok) {
+    if (packedRefsList(packed.text, ref) !== false)
+      return false;
+  } else if (!packed.missing) {
+    return false;
+  }
+  return true;
+}
+function isUnbornHeadOnDisk(directory, env = process.env) {
+  if (GIT_LOCATION_ENV_VARS.some((name) => env[name] !== undefined && env[name] !== "")) {
+    return false;
+  }
+  let realDirectory;
+  try {
+    realDirectory = realpathSync4.native(path5.resolve(directory));
+  } catch {
+    return false;
+  }
+  return isUnbornHeadInLayout(realDirectory);
+}
+var GIT_LOCATION_ENV_VARS;
+var init_unborn_head = __esm(() => {
+  GIT_LOCATION_ENV_VARS = [
+    "GIT_DIR",
+    "GIT_COMMON_DIR",
+    "GIT_WORK_TREE",
+    "GIT_CEILING_DIRECTORIES"
+  ];
+});
+
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync20, realpathSync as realpathSync3, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync21, realpathSync as realpathSync5, statSync as statSync12 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 function asError(error) {
   return error instanceof Error ? error : undefined;
 }
@@ -26678,7 +26879,7 @@ function getErrorStderr(error) {
   return "";
 }
 function directoryFallback(directory) {
-  const canonical = path5.resolve(directory);
+  const canonical = path6.resolve(directory);
   const hash = createHash5("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash}`;
 }
@@ -26687,7 +26888,7 @@ function rememberedIdentityOrDirectoryFallback(canonical) {
 }
 function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
   try {
-    const stat = statSync11(canonicalDirectory);
+    const stat = statSync12(canonicalDirectory);
     if (!stat.isDirectory()) {
       throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
     }
@@ -26713,7 +26914,7 @@ function hasUnbornHead(directory) {
     encoding: "utf8",
     env: { ...process.env, LC_ALL: "C", LANG: "C" },
     stdio: ["ignore", "pipe", "pipe"],
-    timeout: GIT_TIMEOUT_MS,
+    timeout: gitTimeoutMs,
     windowsHide: true
   };
   try {
@@ -26730,7 +26931,7 @@ function hasUnbornHead(directory) {
 }
 function classifyGitError(error, rawDirectory) {
   if (isGitTimeoutError(error)) {
-    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error));
+    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${gitTimeoutMs}ms`, asError(error));
   }
   const code = getErrorCode(error);
   if (code === "ENOENT") {
@@ -26750,7 +26951,7 @@ function classifyGitError(error, rawDirectory) {
 }
 function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectPermission, options = {}) {
   assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path5.resolve(directory);
+  const canonical = path6.resolve(directory);
   const cached = options.cache === false ? undefined : identityCache.get(canonical);
   if (cached !== undefined) {
     return cached;
@@ -26759,6 +26960,9 @@ function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectP
   if (!hasGitDir(canonical)) {
     throw new ProjectIdentityError("not_git_repo", directory, "Directory has no git metadata; caller may use directory fallback");
   }
+  if (isUnbornHeadOnDisk(canonical)) {
+    throw new ProjectIdentityError("no_commits", directory, "Git repository has no commits yet");
+  }
   let output;
   try {
     output = execFileSyncForIdentity("git", ["rev-list", "--max-parents=0", "HEAD"], {
@@ -26766,7 +26970,7 @@ function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectP
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C", LANG: "C" },
       stdio: ["ignore", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS,
+      timeout: gitTimeoutMs,
       windowsHide: true
     });
   } catch (error) {
@@ -26819,9 +27023,9 @@ function nearestLastKnownGitIdentity(canonical) {
       const cached = lastKnownGitIdentity(current);
       if (cached !== undefined)
         return { identity: cached, source: current };
-      if (existsSync20(path5.join(current, ".git")))
+      if (existsSync21(path6.join(current, ".git")))
         break;
-      const parent = path5.dirname(current);
+      const parent = path6.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -26832,7 +27036,7 @@ function nearestLastKnownGitIdentity(canonical) {
   if (exactOrAncestor)
     return exactOrAncestor;
   try {
-    const realCanonical = realpathSync3.native(canonical);
+    const realCanonical = realpathSync5.native(canonical);
     if (realCanonical !== canonical)
       return walk(realCanonical);
   } catch {}
@@ -26862,7 +27066,7 @@ function recordDubiousOwnershipFallback(canonical) {
 function canonicalUserHomeDirectory() {
   const homeDirectory = userHomeDirectoryForIdentity();
   try {
-    return realpathSync3.native(homeDirectory);
+    return realpathSync5.native(homeDirectory);
   } catch {
     return homeDirectory;
   }
@@ -26871,20 +27075,20 @@ function isUserHomeDirectory(directory) {
   if (projectDirectoryKey(directory) === projectDirectoryKey(userHomeDirectoryForIdentity()))
     return true;
   try {
-    return projectDirectoryKey(realpathSync3.native(path5.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
+    return projectDirectoryKey(realpathSync5.native(path6.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
   } catch {
     return false;
   }
 }
 function assertProjectAllowed(directory, allowHomeProject) {
-  const canonical = path5.resolve(directory);
+  const canonical = path6.resolve(directory);
   if (!allowHomeProject && (isUserHomeDirectory(directory) || isUserHomeDirectory(gitRootDirectory(canonical) ?? canonical))) {
     throw new ProjectIdentityError("home_project_disabled", directory, "Home project memory is disabled; set allow_home_project to opt in");
   }
 }
 function resolveProjectIdentity(directory, allowHomeProject = homeProjectPermission) {
   assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path5.resolve(directory);
+  const canonical = path6.resolve(directory);
   const cachedFallback = directoryFallbackCache.get(canonical);
   if (cachedFallback !== undefined) {
     if (!hasGitDir(canonical)) {
@@ -26933,7 +27137,7 @@ function hasGitDir(canonical) {
     return true;
   }
   try {
-    const realCanonical = realpathSync3.native(canonical);
+    const realCanonical = realpathSync5.native(canonical);
     return realCanonical !== canonical && hasGitDirInAncestorChain(realCanonical);
   } catch {
     return false;
@@ -26942,14 +27146,14 @@ function hasGitDir(canonical) {
 function gitRootInAncestorChain(startDirectory) {
   let current = startDirectory;
   while (true) {
-    if (existsSync20(path5.join(current, ".git"))) {
+    if (existsSync21(path6.join(current, ".git"))) {
       try {
-        return realpathSync3.native(current);
+        return realpathSync5.native(current);
       } catch {
-        return path5.resolve(current);
+        return path6.resolve(current);
       }
     }
-    const parent = path5.dirname(current);
+    const parent = path6.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -26964,16 +27168,17 @@ function gitRootDirectory(canonical) {
   if (direct)
     return direct;
   try {
-    const realCanonical = realpathSync3.native(canonical);
+    const realCanonical = realpathSync5.native(canonical);
     return realCanonical === canonical ? null : gitRootInAncestorChain(realCanonical);
   } catch {
     return null;
   }
 }
-var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, sessionIdentityCache, homeProjectPermission = false, pausedIdentityReasons, pausedIdentityLogged, execFileSyncForIdentity, userHomeDirectoryForIdentity = () => homedir12(), nowMs = () => Date.now(), ProjectIdentityError;
+var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, sessionIdentityCache, homeProjectPermission = false, pausedIdentityReasons, pausedIdentityLogged, execFileSyncForIdentity, gitTimeoutMs, userHomeDirectoryForIdentity = () => homedir12(), nowMs = () => Date.now(), ProjectIdentityError;
 var init_project_identity = __esm(() => {
   init_logger();
   init_project_identity_cache();
+  init_unborn_head();
   TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
   identityCache = new Map;
   linkedGitWorktreeCache = new Map;
@@ -26988,6 +27193,7 @@ var init_project_identity = __esm(() => {
   pausedIdentityReasons = new Map;
   pausedIdentityLogged = new Set;
   execFileSyncForIdentity = execFileSync4;
+  gitTimeoutMs = GIT_TIMEOUT_MS;
   ProjectIdentityError = class ProjectIdentityError extends Error {
     errorClass;
     rawDirectory;
@@ -30259,7 +30465,7 @@ var init_tool_definition_tokens = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 function resolveOpencodeDbPath() {
   return resolveOpenCodeDbPath().path;
 }
@@ -30296,7 +30502,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync21(opencodeDbPath)) {
+  if (!existsSync22(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -31156,7 +31362,7 @@ function pickNearestPriorOwner(candidates, currentMessageId, times) {
   }
   return best?.id ?? null;
 }
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, getAssignableTagNumberByMessageIdStatements, hasPiFallbackMessageTagStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, recentTagOwnerStatements, RECLAIM_HINT_EXCLUDED_TOOLS, getActiveToolTagsForAgeReclaimStatements, scopedActiveTokenTotalStatements, updateTagTokenCountStatements, updateTagInputTokenCountStatements, tagOwnerSummaries, TAG_OWNER_COLUMNS = "id, type, message_id, tool_owner_message_id, tag_number, reasoning_token_count", TAG_OWNER_APPENDED_WITH_SHAPE_SQL, inertWhitespaceStatements, inertWhitespaceByNumberStatements, foldStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, getActiveTagsBySessionStatements, getNullOwnerToolTagsBySessionStatements, getDroppedTagsBySessionStatements, getMaxDroppedTagNumberStatements, newestToolTagNumberStatements, droppedNumberStatements, tagByIdStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, getToolOwnerByTagIdStatements, deleteToolTagsByOwnerStatements;
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, getAssignableTagNumberByMessageIdStatements, hasPiFallbackMessageTagStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, recentTagOwnerStatements, RECLAIM_HINT_EXCLUDED_TOOLS, getActiveToolTagsForAgeReclaimStatements, scopedActiveTokenTotalStatements, updateTagTokenCountStatements, updateTagInputTokenCountStatements, tagOwnerSummaries, TAG_OWNER_COLUMNS = "id, type, message_id, tool_owner_message_id, tag_number, reasoning_token_count", TAG_OWNER_APPENDED_WITH_SHAPE_SQL, droppedTagStatements, inertWhitespaceStatements, inertWhitespaceByNumberStatements, foldStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, getActiveTagsBySessionStatements, getNullOwnerToolTagsBySessionStatements, getDroppedTagsBySessionStatements, getMaxDroppedTagNumberStatements, newestToolTagNumberStatements, droppedNumberStatements, tagByIdStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, getToolOwnerByTagIdStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(async () => {
   init_emergency_drop();
   init_tag_owner_id();
@@ -31197,6 +31403,7 @@ var init_storage_tags = __esm(async () => {
     UNION ALL
     SELECT NULL, NULL, NULL, NULL, NULL, NULL, 1, COUNT(*), MAX(id), (SELECT value FROM schema_migrations_meta WHERE key = ?)
     FROM tags WHERE session_id = ?`;
+  droppedTagStatements = new WeakMap;
   inertWhitespaceStatements = new WeakMap;
   inertWhitespaceByNumberStatements = new WeakMap;
   foldStatements = new WeakMap;
@@ -31538,6 +31745,7 @@ function readRawSessionMessageIdOrdinalsForRangeFromDb(db, sessionId, fromOrdina
   const to = Math.floor(toOrdinal);
   if (to < from)
     return new Map;
+  exactOrdinalScansOnThisThread += 1;
   const rows = db.prepare(`
         SELECT id, data FROM message WHERE session_id = ?
           AND CASE WHEN json_valid(data) THEN NOT (
@@ -32212,7 +32420,7 @@ function readRawSessionBoundaryEndpointsFromDb(db, sessionId, ids, blockIds = []
     return new Map(wanted.map((id) => [id, endpoints.get(id) ?? null]));
   }
 }
-var RAW_MESSAGE_PARTS_BY_ID_SQL = "SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001) ORDER BY time_created ASC, id ASC", RAW_METADATA_KEEP_CHARS = 16384, RAW_METADATA_KEPT_KEYS, RAW_PART_DATA_SQL, rawMessagePageRowsVisited = 0, RAW_SUMMARY_TEXT_MAX_CHARS = 8192, RAW_SUMMARY_ARG_MAX_CHARS = 512, RAW_SUMMARY_TOOL_INPUT_KEYS, RAW_SUMMARY_PART_DATA_SQL, ORDINAL_SUMMARY_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+var RAW_MESSAGE_PARTS_BY_ID_SQL = "SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001) ORDER BY time_created ASC, id ASC", RAW_METADATA_KEEP_CHARS = 16384, RAW_METADATA_KEPT_KEYS, RAW_PART_DATA_SQL, rawMessagePageRowsVisited = 0, RAW_SUMMARY_TEXT_MAX_CHARS = 8192, RAW_SUMMARY_ARG_MAX_CHARS = 512, RAW_SUMMARY_TOOL_INPUT_KEYS, RAW_SUMMARY_PART_DATA_SQL, exactOrdinalScansOnThisThread = 0, ORDINAL_SUMMARY_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
         THEN COALESCE(json_extract(data, '$.summary'), 0)
         ELSE 0 END = 1)`, ORDINAL_STOP_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
         THEN COALESCE(json_extract(data, '$.finish'), '')
@@ -32404,6 +32612,8 @@ function runSessionWarmupWorker(input, options) {
         finish({ inserted: reply.inserted, measurements: reply.measurements });
       else if (reply.kind === "orphan-sweep")
         finish({ orphanSweep: reply.result });
+      else if (reply.kind === "exact-ordinal-ids")
+        finish({ exactOrdinalIds: reply.ids });
       else
         finish({ failure: "worker-error", detail: reply.error });
     });
@@ -32489,19 +32699,20 @@ var init_raw_ordinal_warmup = __esm(async () => {
 function openCodeDbExists() {
   return harnessOwnsOpenCodeStore() && openCodeDbPathExists(resolveOpenCodeDbPath());
 }
-function closeCachedReadOnlyDb() {
-  if (!cachedReadOnlyDb) {
+function closeCachedReadOnlyDb(generation) {
+  const cached = cachedReadOnlyDbs[generation];
+  if (!cached) {
     return;
   }
   try {
-    closeQuietly(cachedReadOnlyDb.db);
+    closeQuietly(cached.db);
   } catch (error) {
     log("[magic-context] failed to close cached OpenCode read-only DB:", error);
   } finally {
-    cachedReadOnlyDb = null;
+    cachedReadOnlyDbs[generation] = null;
   }
 }
-function getReadOnlySessionDb() {
+function getReadOnlySessionDb(generation = "v1") {
   if (!harnessOwnsOpenCodeStore()) {
     throw new Error("OpenCode session database is not readable from a Pi-compatible process; its history lives in Pi sessions");
   }
@@ -32510,18 +32721,19 @@ function getReadOnlySessionDb() {
   if (!openCodeDbPathExists(resolution)) {
     throw new Error(`OpenCode session database is unavailable at ${dbPath} (source=${resolution.source})`);
   }
-  if (cachedReadOnlyDb?.path === dbPath) {
-    return cachedReadOnlyDb.db;
+  const cached = cachedReadOnlyDbs[generation];
+  if (cached?.path === dbPath) {
+    return cached.db;
   }
-  closeCachedReadOnlyDb();
+  closeCachedReadOnlyDb(generation);
   const db = new Database(dbPath, { readonly: true });
   try {
-    assertOpenCodeStoreGeneration(db, "v1", dbPath);
+    assertOpenCodeStoreGeneration(db, generation, dbPath);
   } catch (error) {
     closeQuietly(db);
     throw error;
   }
-  cachedReadOnlyDb = { path: dbPath, db };
+  cachedReadOnlyDbs[generation] = { path: dbPath, db };
   clearOpenCodeDbReadFailure();
   return db;
 }
@@ -32547,21 +32759,20 @@ function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
   if (messageIds.length === 0 || !harnessOwnsOpenCodeStore())
     return result;
   try {
-    withReadOnlySessionDb((db) => {
-      const placeholders = messageIds.map(() => "?").join(",");
-      const rows = db.prepare(`SELECT id, time_created FROM message WHERE +session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
-      for (const row of rows) {
-        if (typeof row.id === "string" && typeof row.time_created === "number") {
-          result.set(row.id, row.time_created);
-        }
+    const placeholders = messageIds.map(() => "?").join(",");
+    const rows = getHarness() === "opencode2" ? getReadOnlySessionDb("v2").prepare(`SELECT id, COALESCE(time_created, json_extract(data, '$.time.created')) AS time_created
+                             FROM session_message WHERE +session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds) : withReadOnlySessionDb((db) => db.prepare(`SELECT id, time_created FROM message WHERE +session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds));
+    for (const row of rows) {
+      if (typeof row.id === "string" && typeof row.time_created === "number") {
+        result.set(row.id, row.time_created);
       }
-    });
+    }
   } catch (error) {
     logProbeFailureOnce(resolveOpenCodeDbPath(), error);
   }
   return result;
 }
-var cachedReadOnlyDb = null, trackedSessions, pendingParts, probeLogObserverForTests;
+var cachedReadOnlyDbs, trackedSessions, pendingParts, probeLogObserverForTests;
 var init_read_session_db = __esm(async () => {
   init_logger();
   init_opencode_db_path();
@@ -32569,6 +32780,10 @@ var init_read_session_db = __esm(async () => {
     init_sqlite(),
     init_read_session_raw()
   ]);
+  cachedReadOnlyDbs = {
+    v1: null,
+    v2: null
+  };
   trackedSessions = new Map;
   pendingParts = new Map;
 });
@@ -34179,14 +34394,14 @@ var init_message_time_backfill = __esm(async () => {
 
 // ../plugin/src/features/magic-context/storage-db.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync17,
   rmdirSync,
-  statSync as statSync12,
+  statSync as statSync13,
   unlinkSync as unlinkSync3
 } from "node:fs";
-import { basename as basename3, dirname as dirname11, join as join16, resolve as resolve7 } from "node:path";
+import { basename as basename4, dirname as dirname12, join as join16, resolve as resolve7 } from "node:path";
 function ensureSecureStorageDir(dir) {
   ensureStorageDirectorySync(dir);
 }
@@ -34207,17 +34422,17 @@ function installBootBusyTimeout(db, dbPath, timeoutMs, report = log) {
 }
 function resolveDatabasePath(dbPathOverride) {
   if (dbPathOverride) {
-    return { dbDir: dirname11(dbPathOverride), dbPath: dbPathOverride };
+    return { dbDir: dirname12(dbPathOverride), dbPath: dbPathOverride };
   }
   const dbDir = getMagicContextStorageDir();
   return { dbDir, dbPath: join16(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync22(targetDbPath))
+  if (existsSync23(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
   const legacyDbPath = join16(legacyDir, "context.db");
-  if (!existsSync22(legacyDbPath))
+  if (!existsSync23(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   ensureSecureStorageDir(targetDbDir);
@@ -34235,7 +34450,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
     const dst = join16(targetDbDir, `context.db${suffix}`);
-    if (existsSync22(src)) {
+    if (existsSync23(src)) {
       try {
         copyStorageFileSync(src, dst);
       } catch (error) {
@@ -34245,7 +34460,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   const legacyModelsDir = join16(legacyDir, "models");
   const targetModelsDir = join16(targetDbDir, "models");
-  if (existsSync22(legacyModelsDir) && !existsSync22(targetModelsDir)) {
+  if (existsSync23(legacyModelsDir) && !existsSync23(targetModelsDir)) {
     try {
       copyStorageTreeSync(legacyModelsDir, targetModelsDir);
     } catch (error) {
@@ -34407,7 +34622,7 @@ function inspectRpcServerDiscovery(storageDir, processes, options) {
         continue;
       return unreadableDiscovery(portFile, "io");
     }
-    const filename = basename3(portFile);
+    const filename = basename4(portFile);
     const pidFromName = /^port-(\d+)/.exec(filename)?.[1];
     const fallbackPid = pidFromName ? Number(pidFromName) : 0;
     const record = parseRpcPortFile(raw, fallbackPid);
@@ -34511,8 +34726,8 @@ function removeRpcDiscoveryRecords(storageDir, files) {
   const removed = [];
   const failed = [];
   for (const file of files) {
-    const projectDir = dirname11(resolve7(file));
-    if (dirname11(projectDir) !== rpcRoot || !basename3(file).startsWith("port")) {
+    const projectDir = dirname12(resolve7(file));
+    if (dirname12(projectDir) !== rpcRoot || !basename4(file).startsWith("port")) {
       failed.push({ file, error: "not an RPC discovery record" });
       continue;
     }
@@ -34669,7 +34884,7 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
   }
   setDatabase(db);
   loadToolDefinitionMeasurements(db);
-  tightenStorageTree(dirname11(dbPath));
+  tightenStorageTree(dirname12(dbPath));
   databases.set(dbPath, db);
   pathByDatabase.set(db, dbPath);
   persistenceByDatabase.set(db, true);
@@ -35964,7 +36179,7 @@ function openDatabase(dbPathOrOptions) {
     }
     ensureSecureStorageDir(dbDir);
     tightenStorageTree(dbDir);
-    if (!existsSync22(dbPath) && shouldEnforcePrivateStoragePermissions()) {
+    if (!existsSync23(dbPath) && shouldEnforcePrivateStoragePermissions()) {
       try {
         writeStorageFileSync(dbPath, new Uint8Array, { flag: "wx" });
       } catch (error) {
@@ -36051,8 +36266,8 @@ var init_storage_db = __esm(async () => {
   RPC_DISCOVERY_PARSE_GRACE_MS = 10 * 60 * 1000;
   defaultRpcDiscoveryFs = {
     readdirSync: (path, options) => options?.withFileTypes ? readdirSync5(path, { withFileTypes: true }) : readdirSync5(path),
-    readFileSync: (path, encoding) => String(readFileSync15(path, encoding)),
-    statSync: (path) => ({ mtimeMs: statSync12(path).mtimeMs }),
+    readFileSync: (path, encoding) => String(readFileSync17(path, encoding)),
+    statSync: (path) => ({ mtimeMs: statSync13(path).mtimeMs }),
     unlinkSync: (path) => unlinkSync3(path),
     rmdirSync: (path) => rmdirSync(path)
   };
@@ -36066,14 +36281,14 @@ var init_storage_db = __esm(async () => {
 });
 
 // src/lib/database-access.ts
-import { existsSync as existsSync23, rmSync as rmSync6 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { existsSync as existsSync24, rmSync as rmSync6 } from "node:fs";
+import { dirname as dirname13 } from "node:path";
 import { pathToFileURL } from "node:url";
 function getPersistedSchemaVersion2(db) {
   return getPersistedSchemaVersion(db);
 }
 function openExistingDatabase(path, options) {
-  if (!existsSync23(path))
+  if (!existsSync24(path))
     return null;
   if (options.readonly) {
     const db = new Database(path, { readonly: true });
@@ -36122,7 +36337,7 @@ function openExistingContextDatabaseForMutation(path) {
 async function backupDatabaseSnapshot(db, sourcePath, destination) {
   const serializable = db;
   if (typeof serializable.serialize === "function") {
-    ensureStorageDirectorySync(dirname12(destination));
+    ensureStorageDirectorySync(dirname13(destination));
     writeStorageFileSync(destination, serializable.serialize(), { flag: "wx" });
     return;
   }
@@ -36131,7 +36346,7 @@ async function backupDatabaseSnapshot(db, sourcePath, destination) {
   if (typeof sqlite.backup !== "function") {
     throw new Error("The active SQLite runtime does not provide a snapshot backup API");
   }
-  if (existsSync23(destination)) {
+  if (existsSync24(destination)) {
     throw new Error(`Refusing to overwrite existing backup ${destination}`);
   }
   const reader = new Database(sourcePath, { readonly: true });
@@ -36241,7 +36456,7 @@ var init_config_location_migration = __esm(() => {
 function availableDreamTasks(smartNotesEnabled = true) {
   return CANONICAL_DREAM_TASKS.filter((task) => smartNotesEnabled || task !== "evaluate-smart-notes");
 }
-var CANONICAL_DREAM_TASKS, DREAM_TOOL_LOOP_TOKEN_BUDGETS, MEMORY_DOMAIN_TASKS, MEMORY_DOMAIN_SET;
+var CANONICAL_DREAM_TASKS, DREAM_TOOL_LOOP_TOKEN_BUDGETS, MEMORY_DOMAIN_TASKS, MEMORY_DOMAIN_SET, PROJECT_MEMORY_DREAM_TASKS, PROJECT_MEMORY_DREAM_TASK_SET;
 var init_task_registry = __esm(() => {
   CANONICAL_DREAM_TASKS = [
     "map-memories",
@@ -36278,6 +36493,18 @@ var init_task_registry = __esm(() => {
     "refresh-primers"
   ];
   MEMORY_DOMAIN_SET = new Set(MEMORY_DOMAIN_TASKS);
+  PROJECT_MEMORY_DREAM_TASKS = [
+    "map-memories",
+    "verify",
+    "verify-broad",
+    "curate",
+    "compress-cues",
+    "classify-memories",
+    "retrospective",
+    "promote-primers",
+    "refresh-primers"
+  ];
+  PROJECT_MEMORY_DREAM_TASK_SET = new Set(PROJECT_MEMORY_DREAM_TASKS);
 });
 
 // src/lib/model-picker.ts
@@ -36417,11 +36644,11 @@ var init_dreamer_setup = __esm(() => {
 });
 
 // src/commands/setup-pi.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname14 } from "node:path";
 function ensureDir4(path) {
-  if (!existsSync24(path))
-    mkdirSync5(path, { recursive: true });
+  if (!existsSync25(path))
+    mkdirSync6(path, { recursive: true });
 }
 async function getDefaultPrompts() {
   await Promise.resolve().then(() => init_prompts());
@@ -36453,7 +36680,7 @@ function comparePiVersion(a, b) {
 }
 function writePiSettingsPackage(settingsPath, packageSource = PI_PACKAGE_SOURCE) {
   const settings = readJsoncConfigForUpdate(settingsPath);
-  ensureDir4(dirname13(settingsPath));
+  ensureDir4(dirname14(settingsPath));
   if (settings.packages !== undefined && !Array.isArray(settings.packages)) {
     throw new Error(`Refusing to rewrite ${settingsPath}: "packages" is ${typeof settings.packages}, expected an array. Fix it by hand, then rerun setup.`);
   }
@@ -36484,7 +36711,7 @@ function removePiSettingsPackage(settingsPath, packageSource = PI_PACKAGE_SOURCE
 }
 function writeMagicContextConfig(configPath, options) {
   const config = readMagicContextConfigForSetup(configPath);
-  ensureDir4(dirname13(configPath));
+  ensureDir4(dirname14(configPath));
   if (!config.$schema) {
     config.$schema = "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json";
   }
@@ -37177,7 +37404,7 @@ var init_conflict_detector = __esm(() => {
 });
 
 // ../plugin/src/shared/conflict-fixer.ts
-import { existsSync as existsSync25, readFileSync as readFileSync16, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync18, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
 import { join as join19 } from "node:path";
 function isRecord3(value) {
@@ -37187,11 +37414,11 @@ function asStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function readConfig(filePath) {
-  if (!existsSync25(filePath)) {
+  if (!existsSync26(filePath)) {
     return null;
   }
   try {
-    const text = readFileSync16(filePath, "utf-8");
+    const text = readFileSync18(filePath, "utf-8");
     const parsed = import_comment_json5.parse(text);
     return isRecord3(parsed) ? { config: parsed, text } : null;
   } catch {
@@ -37199,18 +37426,18 @@ function readConfig(filePath) {
   }
 }
 function writeConfig(filePath, text) {
-  writeFileSync5(filePath, text);
+  writeFileSync6(filePath, text);
 }
 function resolveUserOpenCodeConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-  if (existsSync25(paths.configJsonc))
+  if (existsSync26(paths.configJsonc))
     return paths.configJsonc;
   return paths.configJson;
 }
 function collectOpenCodeConfigPaths(directory) {
   const paths = new Set;
   const userConfig = resolveUserOpenCodeConfigPath();
-  if (existsSync25(userConfig)) {
+  if (existsSync26(userConfig)) {
     paths.add(userConfig);
   }
   for (const filePath of [
@@ -37219,7 +37446,7 @@ function collectOpenCodeConfigPaths(directory) {
     join19(directory, "opencode.jsonc"),
     join19(directory, "opencode.json")
   ]) {
-    if (existsSync25(filePath)) {
+    if (existsSync26(filePath)) {
       paths.add(filePath);
     }
   }
@@ -37231,10 +37458,10 @@ function collectOmoConfigPaths(directory) {
   for (const fileName of OMO_CONFIG_NAMES) {
     const userPath = join19(configDir, fileName);
     const projectPath = join19(directory, fileName);
-    if (existsSync25(userPath)) {
+    if (existsSync26(userPath)) {
       paths.add(userPath);
     }
-    if (existsSync25(projectPath)) {
+    if (existsSync26(projectPath)) {
       paths.add(projectPath);
     }
   }
@@ -37242,13 +37469,13 @@ function collectOmoConfigPaths(directory) {
   const omoHomeDir = join19(homeDir, ".omo");
   for (const name of OMO_UNIFIED_NAMES) {
     const userPath = join19(omoHomeDir, name);
-    if (existsSync25(userPath)) {
+    if (existsSync26(userPath)) {
       paths.add(userPath);
     }
   }
   for (const name of OMO_UNIFIED_NAMES) {
     const projectPath = join19(directory, ".omo", name);
-    if (existsSync25(projectPath)) {
+    if (existsSync26(projectPath)) {
       paths.add(projectPath);
     }
   }
@@ -37376,8 +37603,8 @@ var init_conflict_fixer = __esm(() => {
 });
 
 // src/commands/setup-opencode.ts
-import { existsSync as existsSync26 } from "node:fs";
-import { basename as basename4, dirname as dirname14 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { basename as basename5, dirname as dirname15 } from "node:path";
 function resolveCompactionEnabledForWriter() {
   try {
     const config = loadPluginConfig(process.cwd());
@@ -37392,7 +37619,7 @@ function isPlainObject5(value) {
 }
 function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabled = true, hostGeneration = "v1") {
   const registrationKey = pluginConfigKeyFor(hostGeneration);
-  const existsAtCommit = existsSync26(configPath);
+  const existsAtCommit = existsSync27(configPath);
   const existing = existsAtCommit ? readJsoncConfigForUpdate(configPath) : {};
   if (!existsAtCommit) {
     const created = { [registrationKey]: [OPENCODE_PLUGIN_ENTRY_WITH_VERSION] };
@@ -37407,7 +37634,7 @@ function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabl
   let changed = false;
   const rawPlugins = readPluginEntries(existing).map(({ entry }) => entry);
   const retainedPlugins = removeDcp ? rawPlugins.filter((plugin) => !matchesPluginEntry(plugin, DCP_PLUGIN_NAME)) : rawPlugins;
-  if (retainedPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname14(configPath)))) {
+  if (retainedPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname15(configPath)))) {
     log3.warn("An unverifiable local OpenCode plugin path was ignored; its package name is not Magic Context.");
   }
   if (removeDcp) {
@@ -37422,7 +37649,7 @@ function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabl
     }
   }
   const hasNpmEntry = retainedPlugins.some((plugin) => matchesPluginEntry(plugin, OPENCODE_PLUGIN_NAME));
-  const hasDevEntry = retainedPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname14(configPath)));
+  const hasDevEntry = retainedPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname15(configPath)));
   if (!hasNpmEntry && !hasDevEntry) {
     text = Array.isArray(existing[registrationKey]) ? appendJsoncArrayValues(text, [registrationKey], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]) : setJsoncValue(text, [registrationKey], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]);
     changed = true;
@@ -37448,18 +37675,18 @@ function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabl
   return changed ? document.bom + text : null;
 }
 function planTuiConfigUpdate(configPath) {
-  const existsAtCommit = existsSync26(configPath);
+  const existsAtCommit = existsSync27(configPath);
   const existing = existsAtCommit ? readJsoncConfigForUpdate(configPath) : {};
   if (!existsAtCommit) {
     return `${import_comment_json6.stringify({ plugin: [OPENCODE_PLUGIN_ENTRY_WITH_VERSION] }, null, 2)}
 `;
   }
   const rawPlugins = Array.isArray(existing.plugin) ? existing.plugin : [];
-  if (rawPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname14(configPath)))) {
+  if (rawPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname15(configPath)))) {
     log3.warn("An unverifiable local TUI plugin path was ignored; its package name is not Magic Context.");
   }
   const hasNpmEntry = rawPlugins.some((plugin) => matchesPluginEntry(plugin, OPENCODE_PLUGIN_NAME));
-  const hasDevEntry = rawPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname14(configPath)));
+  const hasDevEntry = rawPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname15(configPath)));
   if (hasNpmEntry || hasDevEntry)
     return null;
   const document = readJsoncTextForEdit(configPath);
@@ -37575,7 +37802,7 @@ async function runSetup3(dryRun = false) {
     log3.warn("You can configure models manually in magic-context.jsonc later");
   }
   const paths = detectConfigPaths();
-  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync26(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
+  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync27(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
   if (!dryRun) {
     try {
       assertJsoncConfigsParseable([
@@ -37687,7 +37914,7 @@ async function runSetup3(dryRun = false) {
     }
     log3.success(`Config written to ${paths.magicContextConfig}`);
     if (hostGeneration === "v1") {
-      log3.success(`TUI sidebar plugin added to ${basename4(paths.tuiConfig)}`);
+      log3.success(`TUI sidebar plugin added to ${basename5(paths.tuiConfig)}`);
     } else {
       log3.info("TUI sidebar loads from the plugin entry on OpenCode 2 (tui.json not used)");
     }
@@ -37868,8 +38095,8 @@ var init_setup = __esm(async () => {
 });
 
 // src/lib/disk-space.ts
-import { existsSync as existsSync27, statfsSync, statSync as statSync13 } from "node:fs";
-import { dirname as dirname15, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync28, statfsSync, statSync as statSync14 } from "node:fs";
+import { dirname as dirname16, resolve as resolve9 } from "node:path";
 function availableDiskBytes(path) {
   const filesystem = statfsSync(path);
   return filesystem.bavail * filesystem.bsize;
@@ -37886,9 +38113,9 @@ function checkDiskSpace(path, bytes, freeBytes) {
 function existingDirectoryAncestor(path) {
   let current = resolve9(path);
   for (;; ) {
-    if (existsSync27(current) && statSync13(current).isDirectory())
+    if (existsSync28(current) && statSync14(current).isDirectory())
       return current;
-    const parent = dirname15(current);
+    const parent = dirname16(current);
     if (parent === current)
       throw new Error(`No existing directory for ${path}`);
     current = parent;
@@ -37939,14 +38166,14 @@ var init_types = __esm(() => {
 // ../plugin/src/hooks/auto-update-checker/checker.ts
 import {
   accessSync as accessSync3,
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   constants as fsConstants,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync19,
   renameSync as renameSync5,
-  statSync as statSync14,
-  writeFileSync as writeFileSync6
+  statSync as statSync15,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname16, isAbsolute as isAbsolute7, join as join21, resolve as resolve10 } from "node:path";
+import { dirname as dirname17, isAbsolute as isAbsolute7, join as join21, resolve as resolve10 } from "node:path";
 function warn(message) {
   log(`WARN: ${message}`);
 }
@@ -37972,7 +38199,7 @@ function parseJsonConfig(content) {
 }
 function getSurfaceConfigPaths(directory, surface) {
   const name = surface === "server" ? "opencode" : "tui";
-  const globalDir = dirname16(USER_OPENCODE_CONFIG);
+  const globalDir = dirname17(USER_OPENCODE_CONFIG);
   const dirs = [
     globalDir,
     directory,
@@ -37993,9 +38220,9 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync28(path))
+      if (!existsSync29(path))
         continue;
-      const parsed = parseJsonConfig(readFileSync17(path, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync19(path, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -38032,14 +38259,14 @@ var init_checker = __esm(async () => {
 });
 
 // src/lib/opencode-plugin-schema-fence.ts
-import { existsSync as existsSync29, readdirSync as readdirSync6, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync30, readdirSync as readdirSync6, readFileSync as readFileSync20 } from "node:fs";
 import { join as join22 } from "node:path";
 import { gunzipSync as gunzipSync2 } from "node:zlib";
 function readPackageVersion(packageJsonPath) {
   try {
-    if (!existsSync29(packageJsonPath))
+    if (!existsSync30(packageJsonPath))
       return null;
-    const packageJson = JSON.parse(readFileSync18(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
     if (packageJson.name !== OPENCODE_PLUGIN_NAME || typeof packageJson.version !== "string") {
       return null;
     }
@@ -38059,7 +38286,7 @@ function readFenceValue(text) {
 }
 function readFenceFromDist(packageDirectory) {
   const distDirectory = join22(packageDirectory, "dist");
-  if (!existsSync29(distDirectory))
+  if (!existsSync30(distDirectory))
     return null;
   const pending = [distDirectory];
   const fenceValues = new Set;
@@ -38076,7 +38303,7 @@ function readFenceFromDist(packageDirectory) {
         }
         if (!entry.isFile() || !/\.(?:[cm]?js|ts)$/.test(entry.name))
           continue;
-        const fence = readFenceValue(readFileSync18(path, "utf-8"));
+        const fence = readFenceValue(readFileSync20(path, "utf-8"));
         if (fence !== null)
           fenceValues.add(fence);
       }
@@ -38245,13 +38472,13 @@ var init_opencode_plugin_schema_fence = __esm(async () => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync30, readFileSync as readFileSync19, rmSync as rmSync7 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync21, rmSync as rmSync7 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync30(installedPkgPath))
+    if (!existsSync31(installedPkgPath))
       return;
-    const pkg = JSON.parse(readFileSync19(installedPkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync21(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -38278,7 +38505,7 @@ function readOpenCodePluginConfigUse(config, configDir) {
 async function clearPluginCache(options = {}, deps = {}) {
   const remove = deps.remove ?? ((path) => rmSync7(path, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync30(root));
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync31(root));
   if (existingRoots.length === 0) {
     return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
   }
@@ -38375,8 +38602,8 @@ var init_doctor_opencode_cache = __esm(async () => {
 });
 
 // src/commands/doctor-cached-plugin-fence.ts
-import { existsSync as existsSync31 } from "node:fs";
-import { dirname as dirname17 } from "node:path";
+import { existsSync as existsSync32 } from "node:fs";
+import { dirname as dirname18 } from "node:path";
 function isReferenced(sources, host, spec) {
   const specs = sources.referencedSpecs?.[host];
   return specs === undefined || specs.has(spec);
@@ -38386,13 +38613,13 @@ function listCachedOpenCodePluginFences(sources = {}) {
   const v1Referenced = isReferenced(sources, "opencode1", "latest");
   for (const root of v1Referenced ? sources.openCodeV1Roots ?? getOpenCodePluginCacheRoots() : []) {
     const packageJson = getOpenCodePluginPackageJsonPath(root);
-    if (!existsSync31(packageJson))
+    if (!existsSync32(packageJson))
       continue;
     fences.push({
       host: "opencode1",
       directory: root,
       version: readCachedPluginVersion(root),
-      supportedVersion: readFenceFromDist(dirname17(packageJson))
+      supportedVersion: readFenceFromDist(dirname18(packageJson))
     });
   }
   for (const slot of listOpenCodeV2PluginCacheSlots(sources.openCodeV2NpmCacheDir)) {
@@ -38408,7 +38635,7 @@ function listCachedOpenCodePluginFences(sources = {}) {
       directory: slot.slot,
       spec: slot.spec,
       version: slot.version,
-      supportedVersion: readFenceFromDist(dirname17(getOpenCodePluginPackageJsonPath(generation)))
+      supportedVersion: readFenceFromDist(dirname18(getOpenCodePluginPackageJsonPath(generation)))
     });
   }
   return fences;
@@ -38591,11 +38818,11 @@ var init_doctor_prune_discovery = __esm(async () => {
 
 // src/commands/doctor-storage-holders.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { readFileSync as readFileSync20, realpathSync as realpathSync4 } from "node:fs";
+import { readFileSync as readFileSync22, realpathSync as realpathSync6 } from "node:fs";
 import { join as join23, resolve as resolve11 } from "node:path";
 function canonicalStoragePath(path) {
   try {
-    return realpathSync4(path);
+    return realpathSync6(path);
   } catch {
     return resolve11(path);
   }
@@ -38619,7 +38846,7 @@ function processReferencesStorage(pid, storageDir) {
   if (process.platform === "linux") {
     for (const name of ["cmdline", "environ"]) {
       try {
-        texts.push(readFileSync20(`/proc/${pid}/${name}`, "utf8"));
+        texts.push(readFileSync22(`/proc/${pid}/${name}`, "utf8"));
       } catch {}
     }
   } else {
@@ -38641,9 +38868,9 @@ var init_doctor_storage_holders = () => {};
 
 // src/commands/doctor-repair-db.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync32, openSync as openSync4, renameSync as renameSync6, rmSync as rmSync8, statSync as statSync15 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync33, openSync as openSync4, renameSync as renameSync6, rmSync as rmSync8, statSync as statSync16 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
-import { dirname as dirname18, join as join24 } from "node:path";
+import { dirname as dirname19, join as join24 } from "node:path";
 function defaultInspectHolders(storageDir, overrides = {}) {
   const deps = {
     defaultStorageDir: join24(homedir17(), ".local", "share", "cortexkit", "magic-context"),
@@ -38709,11 +38936,11 @@ function timestamp(date) {
   return date.toISOString().replaceAll("-", "").replaceAll(":", "").replace(".", "");
 }
 function uniqueBase(preferred) {
-  if (!DATABASE_SUFFIXES.some((suffix) => existsSync32(`${preferred}${suffix}`)))
+  if (!DATABASE_SUFFIXES.some((suffix) => existsSync33(`${preferred}${suffix}`)))
     return preferred;
   for (let attempt = 1;attempt < 1e4; attempt++) {
     const candidate = `${preferred}-${attempt}`;
-    if (!DATABASE_SUFFIXES.some((suffix) => existsSync32(`${candidate}${suffix}`)))
+    if (!DATABASE_SUFFIXES.some((suffix) => existsSync33(`${candidate}${suffix}`)))
       return candidate;
   }
   throw new Error(`Could not allocate a unique recovery path beside ${preferred}`);
@@ -38727,8 +38954,8 @@ function databaseBundleSizeBytes(sourceBase) {
   let size = 0;
   for (const suffix of DATABASE_SUFFIXES) {
     const source = `${sourceBase}${suffix}`;
-    if (existsSync32(source))
-      size += statSync15(source).size;
+    if (existsSync33(source))
+      size += statSync16(source).size;
   }
   return size;
 }
@@ -38736,7 +38963,7 @@ function copyDatabaseBundle(sourceBase, destinationBase, forcePrivate = false) {
   const copiedPaths = [];
   for (const suffix of DATABASE_SUFFIXES) {
     const source = `${sourceBase}${suffix}`;
-    if (!existsSync32(source))
+    if (!existsSync33(source))
       continue;
     const destination = `${destinationBase}${suffix}`;
     copyStorageFileSync(source, destination, forcePrivate);
@@ -38958,7 +39185,7 @@ function activateReplacement(dbPath, replacementPath, originalAsidePath) {
   try {
     for (const suffix of DATABASE_SUFFIXES) {
       const from = `${dbPath}${suffix}`;
-      if (!existsSync32(from))
+      if (!existsSync33(from))
         continue;
       const to = `${originalAsidePath}${suffix}`;
       renameSync6(from, to);
@@ -38968,7 +39195,7 @@ function activateReplacement(dbPath, replacementPath, originalAsidePath) {
     return movedOriginals.map(({ to }) => to);
   } catch (error) {
     for (const moved of movedOriginals.reverse()) {
-      if (existsSync32(moved.to) && !existsSync32(moved.from))
+      if (existsSync33(moved.to) && !existsSync33(moved.from))
         renameSync6(moved.to, moved.from);
     }
     throw error;
@@ -38999,12 +39226,12 @@ function printHelp() {
 async function runRepairDb(options = {}) {
   const prompts = options.prompts ?? promptIO;
   const deps = { ...DEFAULT_DEPS3, ...options.deps };
-  const storageDir = options.storageDir ?? dirname18(options.dbPath ?? join24(getMagicContextStorageDir(), "context.db"));
+  const storageDir = options.storageDir ?? dirname19(options.dbPath ?? join24(getMagicContextStorageDir(), "context.db"));
   const dbPath = options.dbPath ?? join24(storageDir, "context.db");
   const stamp = timestamp(deps.now());
   prompts.intro("Magic Context — Repair shared database");
   prompts.log.info(`Database: ${dbPath}`);
-  if (!existsSync32(dbPath)) {
+  if (!existsSync33(dbPath)) {
     prompts.log.error(`Database not found: ${dbPath}`);
     prompts.log.info("Backup: not created (database does not exist)");
     prompts.outro("Database repair failed");
@@ -39214,13 +39441,13 @@ var init_doctor_repair_db = __esm(async () => {
 
 // src/commands/doctor-single-store-repair.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync33, statfsSync as statfsSync2, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync34, statfsSync as statfsSync2, statSync as statSync17 } from "node:fs";
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname19, join as join25, resolve as resolve12 } from "node:path";
+import { dirname as dirname20, join as join25, resolve as resolve12 } from "node:path";
 function existingAncestor(path) {
   let current = resolve12(path);
-  while (!existsSync33(current))
-    current = dirname19(current);
+  while (!existsSync34(current))
+    current = dirname20(current);
   return current;
 }
 function describe2(plan, print) {
@@ -39256,13 +39483,13 @@ function runDoctorSingleStoreRepair(options, overrides = {}) {
   try {
     const { dbPath: context, dbDir: data } = resolveDatabasePath();
     const store = join25(data, "store.db");
-    if (!existsSync33(context) || !existsSync33(store))
+    if (!existsSync34(context) || !existsSync34(store))
       return refuse("repair_missing_database", `Both ${context} and ${store} must exist.`);
     if (!options.fromBackup)
       return refuse("repair_usage", "--from-backup <dir> is required");
     const fromBackup = resolve12(options.fromBackup);
     for (const name of ["context.db", "store.db"])
-      if (!existsSync33(join25(fromBackup, name)))
+      if (!existsSync34(join25(fromBackup, name)))
         return refuse("repair_backup_missing", `${join25(fromBackup, name)} does not exist`);
     const sessions = options.sessions ?? [];
     if (options.live && sessions.length === 0)
@@ -39291,7 +39518,7 @@ function runDoctorSingleStoreRepair(options, overrides = {}) {
         deps.print(`Repairing while hosts hold the stores (--live): ${blockers.join("; ") || "holders unknown"}`);
       }
       const backupRoot = resolve12(options.backupRoot ?? join25(data, "backups"));
-      const need = Math.ceil((statSync16(context).size + statSync16(store).size) * 1.1);
+      const need = Math.ceil((statSync17(context).size + statSync17(store).size) * 1.1);
       const volume = existingAncestor(backupRoot);
       const have = deps.freeBytes(volume);
       if (have < need)
@@ -39387,7 +39614,7 @@ var init_doctor_single_store_repair = __esm(async () => {
 
 // src/commands/doctor-single-store.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync34, realpathSync as realpathSync5, statSync as statSync17 } from "node:fs";
+import { existsSync as existsSync35, realpathSync as realpathSync7, statSync as statSync18 } from "node:fs";
 import { homedir as homedir19 } from "node:os";
 import { join as join26, resolve as resolve13 } from "node:path";
 function engineContextPath() {
@@ -39421,7 +39648,7 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
   try {
     const { dbPath: context, dbDir: data } = resolveDatabasePath();
     const store = join26(data, "store.db");
-    if (!existsSync34(context) || !existsSync34(store))
+    if (!existsSync35(context) || !existsSync35(store))
       return refuse("single_store_missing_database", `Both ${context} and ${store} must exist.`);
     const probe = probeHostProcessesUsing({ files: [context, store].flatMap((p) => SUFFIXES2.map((s) => p + s)), directories: [] }, deps.lsofSpawn);
     const holders = deps.inspectHolders(data);
@@ -39436,7 +39663,7 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
       return refuse("single_store_files_in_use", [...lines, STOP].join(`
 `));
     }
-    if (!existsSync34(engineContextPath()) || realpathSync5(context) !== realpathSync5(engineContextPath()))
+    if (!existsSync35(engineContextPath()) || realpathSync7(context) !== realpathSync7(engineContextPath()))
       return refuse("single_store_path_mismatch", `CLI ${context}; engine ${engineContextPath()}`);
     const backupRoot = resolve13(options.backupRoot ?? join26(data, "backups"));
     const contextDb = new Database(context, { readonly: true });
@@ -39465,10 +39692,10 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
     }
     if (contextVersion > LATEST_SUPPORTED_VERSION || storeVersion !== 60)
       return refuse("single_store_version_mismatch", `context.db v${contextVersion}; store.db v${storeVersion}; need context.db v${LATEST_SUPPORTED_VERSION} and store.db v60 (apply current plugin migrations to context.db; upgrade store.db with ck-mc first)`);
-    const backupBytes = statSync17(context).size + statSync17(store).size;
-    const workingBytes = 2 * statSync17(store).size;
+    const backupBytes = statSync18(context).size + statSync18(store).size;
+    const workingBytes = 2 * statSync18(store).size;
     const backupVolume = existingDirectoryAncestor(backupRoot);
-    const sameVolume = statSync17(data).dev === statSync17(backupVolume).dev;
+    const sameVolume = statSync18(data).dev === statSync18(backupVolume).dev;
     const dataSpace = checkDiskSpace(data, workingBytes + (sameVolume ? backupBytes : 0), deps.freeBytes);
     if (!dataSpace.sufficient)
       return refuse("single_store_disk_space", `need ${dataSpace.requiredBytes} bytes; have ${dataSpace.availableBytes} bytes on ${data}`);
@@ -39979,17 +40206,17 @@ var init_storage_identity_merge = __esm(() => {
 // src/commands/doctor-identity-splits.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync35, readdirSync as readdirSync7, realpathSync as realpathSync6, statSync as statSync18 } from "node:fs";
-import { dirname as dirname20, join as join27, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync36, readdirSync as readdirSync7, realpathSync as realpathSync8, statSync as statSync19 } from "node:fs";
+import { dirname as dirname21, join as join27, resolve as resolve14 } from "node:path";
 function tableExists5(db, table) {
   return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
 }
 function hasGitMetadataInAncestors(directory) {
   let current = resolve14(directory);
   while (true) {
-    if (existsSync35(join27(current, ".git")))
+    if (existsSync36(join27(current, ".git")))
       return true;
-    const parent = dirname20(current);
+    const parent = dirname21(current);
     if (parent === current)
       return false;
     current = parent;
@@ -39998,7 +40225,7 @@ function hasGitMetadataInAncestors(directory) {
 function orphanedPathReason(directory) {
   let entries;
   try {
-    if (!statSync18(directory).isDirectory())
+    if (!statSync19(directory).isDirectory())
       return "path is no longer a directory";
     entries = readdirSync7(directory);
   } catch (error) {
@@ -40020,7 +40247,7 @@ function findIdentitySplits(db, host, includeSingles = false) {
       return cached;
     let canonical = directory;
     try {
-      canonical = realpathSync6.native(directory);
+      canonical = realpathSync8.native(directory);
     } catch {}
     canonicalDirectories.set(directory, canonical);
     return canonical;
@@ -40168,8 +40395,8 @@ var init_doctor_identity_splits = __esm(async () => {
 // src/commands/doctor-merge-identity.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync36, mkdtempSync as mkdtempSync2, readdirSync as readdirSync8, readFileSync as readFileSync21, statSync as statSync19 } from "node:fs";
-import { dirname as dirname21, join as join28, resolve as resolve15 } from "node:path";
+import { existsSync as existsSync37, mkdtempSync as mkdtempSync2, readdirSync as readdirSync8, readFileSync as readFileSync23, statSync as statSync20 } from "node:fs";
+import { dirname as dirname22, join as join28, resolve as resolve15 } from "node:path";
 function parseMergeIdentityArgs(args) {
   const values = {};
   const switches = new Set(["--apply", "--force", "--dry-run", "--yes", "--verbose"]);
@@ -40219,7 +40446,7 @@ function printReport(report) {
     console.log("  No writes. Review this preview, then repeat with --apply to confirm.");
 }
 function resolveReadOnly(directory) {
-  if (!existsSync36(directory))
+  if (!existsSync37(directory))
     return;
   try {
     const roots = execFileSync7("git", ["rev-list", "--max-parents=0", "HEAD"], {
@@ -40253,7 +40480,7 @@ function canonicalIdentity(directory, storageDir) {
 }
 function directoryDoesNotExist(directory) {
   try {
-    statSync19(directory);
+    statSync20(directory);
   } catch (error) {
     return error.code === "ENOENT";
   }
@@ -40376,12 +40603,12 @@ function observations(db, hostPath, storageDir) {
       row.identities.push({ identity, sessions: 0, memories: 0, notes: 0, dreamer: 0 });
   };
   const sidecars = join28(storageDir, "project-identities");
-  if (existsSync36(sidecars))
+  if (existsSync37(sidecars))
     for (const file of readdirSync8(sidecars)) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const record = JSON.parse(readFileSync21(join28(sidecars, file), "utf8"));
+        const record = JSON.parse(readFileSync23(join28(sidecars, file), "utf8"));
         if (typeof record.directory === "string" && typeof record.identity === "string")
           add(record.directory, record.identity);
       } catch {}
@@ -40393,7 +40620,7 @@ function observations(db, hostPath, storageDir) {
 function runMergeIdentityCli(args, deps = {}) {
   const options = parseMergeIdentityArgs(args);
   const dbPath = options.dbPath ?? join28(getMagicContextStorageDir(), "context.db");
-  const storageDir = dirname21(dbPath);
+  const storageDir = dirname22(dbPath);
   const hostPath = options.hostPath ?? (options.dbPath ? join28(storageDir, "host.db") : resolveOpenCodeDbPath().path);
   let db = openExistingContextDatabase(dbPath, {
     readonly: true,
@@ -40448,8 +40675,8 @@ function runMergeIdentityCli(args, deps = {}) {
   const backupRoot = resolve15(options.backupRoot ?? storageDir);
   const backupVolume = existingDirectoryAncestor(backupRoot);
   const sidecarRoot = join28(storageDir, "project-identities");
-  const sidecarEntries = existsSync36(sidecarRoot) ? readdirSync8(sidecarRoot).filter((entry) => entry.endsWith(".json")) : [];
-  const sidecarBytes = sidecarEntries.reduce((size, entry) => size + statSync19(join28(sidecarRoot, entry)).size, 0);
+  const sidecarEntries = existsSync37(sidecarRoot) ? readdirSync8(sidecarRoot).filter((entry) => entry.endsWith(".json")) : [];
+  const sidecarBytes = sidecarEntries.reduce((size, entry) => size + statSync20(join28(sidecarRoot, entry)).size, 0);
   const diskSpace = checkDiskSpace(backupVolume, databaseBundleSizeBytes(dbPath) + sidecarBytes, deps.freeBytes ?? availableDiskBytes);
   if (!diskSpace.sufficient)
     throw new Error(`merge_identity_disk_space: refusing identity merge: backup needs ${diskSpace.requiredBytes} bytes; have ${diskSpace.availableBytes} bytes on ${backupVolume}. Use --backup-root <dir> to choose a volume with enough free space.`);
@@ -40462,13 +40689,13 @@ function runMergeIdentityCli(args, deps = {}) {
   ensureStorageDirectorySync(sidecarBackup, true);
   let backupBytes = 0;
   for (const entry of sidecarEntries) {
-    const content = readFileSync21(join28(sidecarRoot, entry));
+    const content = readFileSync23(join28(sidecarRoot, entry));
     writeStorageFileAtomicSync(join28(sidecarBackup, entry), content, true);
     backupBytes += content.byteLength;
   }
   console.log(`Restore identity sidecars too: rm -rf ${quote(sidecarRoot)}; cp -R ${quote(sidecarBackup)} ${quote(sidecarRoot)}`);
   const copiedDatabaseFiles = copyDatabaseBundle(dbPath, join28(backup, "context.db"), true);
-  backupBytes += copiedDatabaseFiles.reduce((size, path) => size + statSync19(path).size, 0);
+  backupBytes += copiedDatabaseFiles.reduce((size, path) => size + statSync20(path).size, 0);
   db = openExistingDatabase(dbPath, { readonly: false });
   if (!db)
     throw new Error(`Context database disappeared: ${dbPath}`);
@@ -40512,7 +40739,7 @@ var init_doctor_merge_identity = __esm(async () => {
 });
 
 // src/commands/doctor-git-fts-map.ts
-import { existsSync as existsSync37, mkdtempSync as mkdtempSync3, statSync as statSync20 } from "node:fs";
+import { existsSync as existsSync38, mkdtempSync as mkdtempSync3, statSync as statSync21 } from "node:fs";
 import { join as join29, resolve as resolve16 } from "node:path";
 function inspectGitFtsMap(db) {
   const has = (name) => Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE name=? AND type='table'").get(name));
@@ -40589,9 +40816,9 @@ function runDoctorGitFtsMap(options = {}, overrides = {}) {
         deps.print(`Stop every host, then run \`${GIT_FTS_MAP_REPAIR_COMMAND}\`. The repair backs up context.db and store.db first.`);
       return damaged ? 1 : 0;
     }
-    if (!existsSync37(context) || !existsSync37(store))
+    if (!existsSync38(context) || !existsSync38(store))
       throw new Error("Both context.db and store.db must exist before paired-backup repair; no replacement store will be created");
-    const cstat = statSync20(context), sstat = statSync20(store);
+    const cstat = statSync21(context), sstat = statSync21(store);
     if (cstat.dev === sstat.dev && cstat.ino === sstat.ino)
       throw new Error("context.db and store.db must be distinct files");
     const holders = deps.inspectHolders(deps.storageDir);
@@ -40792,8 +41019,8 @@ var SINGLE_STORE_REQUIRED = "Magic Context's Rust mode needs a one-time migratio
 
 // src/commands/migrate.ts
 import { createHash as createHash8, randomBytes as randomBytes3 } from "node:crypto";
-import { existsSync as existsSync38, mkdirSync as mkdirSync6, renameSync as renameSync7, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname22, join as join30 } from "node:path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync7, renameSync as renameSync7, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname23, join as join30 } from "node:path";
 function defaultOpenCodeDbPath() {
   return getOpenCodeDatabasePath();
 }
@@ -40804,7 +41031,7 @@ function defaultPiSessionsRoot() {
   return getPiSessionsRoot();
 }
 function defaultFs() {
-  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync38, renameSync: renameSync7, mkdirSync: mkdirSync6 };
+  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync39, renameSync: renameSync7, mkdirSync: mkdirSync7 };
 }
 function stmt(db, sql) {
   return db.prepare(sql);
@@ -40858,7 +41085,7 @@ function sweepPendingMigrations(db, fs = defaultFs()) {
     }
     if (row.phase === "db_committed") {
       if (fs.existsSync(row.stage_path)) {
-        fs.mkdirSync(dirname22(row.final_path), { recursive: true });
+        fs.mkdirSync(dirname23(row.final_path), { recursive: true });
         fs.renameSync(row.stage_path, row.final_path);
         stmt(db, "DELETE FROM migration_pending WHERE migration_key = ?").run(row.migration_key);
         report.rolledForward += 1;
@@ -41424,7 +41651,7 @@ function migrateOpenCodeSessionToPi(opts) {
         sourceSessionId: session.id,
         targetHarness,
         finalPathFor: (id) => join30(outputDir, `${formatPiFilenameTimestamp(now)}_${id}.jsonl`),
-        stageDir: join30(dirname22(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
+        stageDir: join30(dirname23(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
         now: now.getTime()
       });
       piSessionId = claimed.row.pi_session_id;
@@ -41476,7 +41703,7 @@ function migrateOpenCodeSessionToPi(opts) {
         commitStagedChecksum(cortexkitDb, migrationKey, contentSha256);
         fs.writeFileAtomic(stagePath, jsonl);
         plan.commit(migrationKey);
-        fs.mkdirSync(dirname22(finalPath), { recursive: true });
+        fs.mkdirSync(dirname23(finalPath), { recursive: true });
         fs.renameSync(stagePath, finalPath);
         stmt(cortexkitDb, "DELETE FROM migration_pending WHERE migration_key = ?").run(migrationKey);
       } else {
@@ -43151,15 +43378,15 @@ class SubcClient {
     }
   }
   notSentCallError(message, cause) {
-    return new SubcCallError("not_sent", `${message}${causeMessage(cause)}`, errorCode(cause), cause);
+    return new SubcCallError("not_sent", `${message}${causeMessage(cause)}`, errorCode2(cause), cause);
   }
   outcomeUnknownCallError(message, cause) {
-    return new SubcCallError("outcome_unknown", `${message}${causeMessage(cause)}`, errorCode(cause), cause);
+    return new SubcCallError("outcome_unknown", `${message}${causeMessage(cause)}`, errorCode2(cause), cause);
   }
   terminalCallError(message, cause) {
     if (cause instanceof SubcCallError)
       return cause;
-    return new SubcCallError("terminal", `${message}${causeMessage(cause)}`, errorCode(cause), cause);
+    return new SubcCallError("terminal", `${message}${causeMessage(cause)}`, errorCode2(cause), cause);
   }
   notSentRecoveryError(message, cause) {
     if (cause instanceof SubcCallError)
@@ -43228,7 +43455,7 @@ function isConsumerReconnectTransient(err) {
     return true;
   if (err instanceof SubcError || err instanceof ConnectionFileError)
     return false;
-  const code = errorCode(err);
+  const code = errorCode2(err);
   return code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" || code === "ENOENT";
 }
 function isRouteOpenRefusal(err) {
@@ -43293,7 +43520,7 @@ function routeOpenConsumerIdentity(opts = {}) {
     return;
   return { module_id: moduleId, launch_nonce: launchNonce };
 }
-function errorCode(err) {
+function errorCode2(err) {
   if (typeof err === "object" && err !== null && "code" in err) {
     const code = err.code;
     if (typeof code === "string")
@@ -43781,7 +44008,7 @@ var init_store_ahead_refusal = __esm(() => {
 });
 
 // ../plugin/src/hooks/magic-context/module-transport.ts
-import { realpathSync as realpathSync7 } from "node:fs";
+import { realpathSync as realpathSync9 } from "node:fs";
 import { join as join31 } from "node:path";
 function monotonicNow() {
   return monotonicClockForTests?.() ?? performance.now();
@@ -44283,7 +44510,7 @@ class SubcModuleTransport {
     }
     let resolved = root;
     try {
-      resolved = realpathSync7.native(root);
+      resolved = realpathSync9.native(root);
     } catch {}
     this.canonicalRootCache.set(root, resolved);
     while (this.canonicalRootCache.size > CANONICAL_ROOT_CACHE_MAX_ENTRIES) {
@@ -44396,9 +44623,9 @@ var init_module_transport = __esm(async () => {
 });
 
 // src/commands/migrate-session.ts
-import { existsSync as existsSync39, realpathSync as realpathSync8 } from "node:fs";
+import { existsSync as existsSync40, realpathSync as realpathSync10 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
-import path6, { join as join32 } from "node:path";
+import path7, { join as join32 } from "node:path";
 function existingSessionColumns(db) {
   const rows = db.prepare("PRAGMA table_info(session)").all();
   return new Set(rows.map((r) => r.name).filter((n) => typeof n === "string"));
@@ -44453,7 +44680,7 @@ function planMigrateSession(sessionId, rawTargetDirectory, deps) {
     ocProjectId = "global";
     ocWorktree = globalRow.worktree || "/";
   }
-  const sessionPath = path6.relative(ocWorktree, targetDirectory);
+  const sessionPath = path7.relative(ocWorktree, targetDirectory);
   const ownershipRow = deps.contextDb.prepare("SELECT project_path FROM session_projects WHERE session_id = ? AND harness = 'opencode'").get(sessionId);
   const fromMcIdentity = ownershipRow?.project_path ?? (sessionRow.directory ? deps.resolveIdentity(sessionRow.directory) : "");
   const toMcIdentity = deps.resolveIdentity(targetDirectory);
@@ -44586,8 +44813,8 @@ function realDeps(opencodeDb, contextDb) {
     opencodeDb,
     contextDb,
     resolveIdentity: resolveProjectIdentity,
-    hasGitDir: (dir) => existsSync39(join32(dir, ".git")),
-    realpath: (p) => realpathSync8(p)
+    hasGitDir: (dir) => existsSync40(join32(dir, ".git")),
+    realpath: (p) => realpathSync10(p)
   };
 }
 function valueAfter(args, flag) {
@@ -44665,7 +44892,7 @@ async function runMigrateSessionCli(args) {
     return 1;
   }
   const expandedTo = toDir.startsWith("~") ? join32(homedir20(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
-  if (!existsSync39(expandedTo)) {
+  if (!existsSync40(expandedTo)) {
     console.error(`Target directory does not exist: ${expandedTo}`);
     return 1;
   }
@@ -44819,8 +45046,8 @@ var init_migrate_session = __esm(async () => {
 
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
 import { createHash as createHash10 } from "node:crypto";
-import { realpathSync as realpathSync9 } from "node:fs";
-import path7 from "node:path";
+import { realpathSync as realpathSync11 } from "node:fs";
+import path8 from "node:path";
 function readMeta(db, key) {
   const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(key);
   return row?.value ?? null;
@@ -44863,9 +45090,9 @@ function resolveBackfillIdentity(rawProjectPath) {
 function computeLegacyRustDirIdentity(rawProjectPath) {
   let canonical;
   try {
-    canonical = realpathSync9(rawProjectPath);
+    canonical = realpathSync11(rawProjectPath);
   } catch {
-    canonical = path7.isAbsolute(rawProjectPath) ? rawProjectPath : path7.join(process.cwd(), rawProjectPath);
+    canonical = path8.isAbsolute(rawProjectPath) ? rawProjectPath : path8.join(process.cwd(), rawProjectPath);
   }
   return `dir:${createHash10("sha256").update(canonical, "utf8").digest("hex")}`;
 }
@@ -45088,7 +45315,7 @@ var init_tick_failure = __esm(() => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync40 } from "node:fs";
+import { existsSync as existsSync41 } from "node:fs";
 function getProjectConfigPaths(cwd) {
   const basePath = cortexKitProjectConfigBasePath(cwd);
   return [`${basePath}.jsonc`, `${basePath}.json`];
@@ -45098,10 +45325,10 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path) => existsSync40(path));
+  return paths.find((path) => existsSync41(path));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync40(source.path)) ?? null;
+  return sources.find((source) => existsSync41(source.path)) ?? null;
 }
 function loadConfigFile(path, scope) {
   let raw;
@@ -45412,7 +45639,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync40(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync41(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -45421,7 +45648,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync40(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync41(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -45559,7 +45786,7 @@ var DATABASE_REPAIR_COMMAND = "bunx @cortexkit/magic-context@latest doctor repai
 
 // src/lib/github-issue.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 function runGhCommand(args) {
   try {
     const result = spawnSync7("gh", args, {
@@ -45586,7 +45813,7 @@ function failed(result) {
 function submitGithubIssue(title, bodyPath, runner = runGhCommand) {
   let body;
   try {
-    body = readFileSync22(bodyPath, "utf-8");
+    body = readFileSync24(bodyPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -45644,7 +45871,7 @@ var MAX_GITHUB_ISSUE_BODY_CHARS = 65536;
 var init_github_issue = () => {};
 
 // src/lib/log-lines.ts
-import { existsSync as existsSync41, readFileSync as readFileSync23, statSync as statSync21 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync25, statSync as statSync22 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join33 } from "node:path";
 function tokenize(input, limit = Number.POSITIVE_INFINITY) {
@@ -45941,11 +46168,11 @@ function getMagicContextLogPaths(harness, options = {}) {
   ].filter((path, index, paths) => paths.indexOf(path) === index);
 }
 function inspectLogFile(path) {
-  if (!existsSync41(path)) {
+  if (!existsSync42(path)) {
     return { path, exists: false, sizeKb: 0, lineCount: 0, grammar: "unknown" };
   }
   try {
-    const content = readFileSync23(path, "utf8");
+    const content = readFileSync25(path, "utf8");
     const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
     const grammars = new Set(lines.flatMap((line) => {
       const parsed = parseLogLine(line);
@@ -45955,7 +46182,7 @@ function inspectLogFile(path) {
     return {
       path,
       exists: true,
-      sizeKb: Math.round(statSync21(path).size / 1024),
+      sizeKb: Math.round(statSync22(path).size / 1024),
       lineCount: lines.length,
       grammar
     };
@@ -45972,7 +46199,7 @@ function readLogLines(files) {
       return [];
     try {
       let precedingTimestamp = "";
-      return readFileSync23(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
+      return readFileSync25(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
         precedingTimestamp = parseLogLine(line)?.ts ?? precedingTimestamp;
         return { line, timestamp: precedingTimestamp, fileIndex, lineIndex };
       });
@@ -46137,6 +46364,7 @@ class IssuePrivacy {
       "plugin",
       "manifest",
       "Shared storage",
+      "Magic Context storage",
       "context DB",
       "SQLite integrity_check",
       "Background maintenance",
@@ -46478,11 +46706,235 @@ var init_issue_body = __esm(() => {
   ];
 });
 
+// src/lib/omp-hide-secrets.ts
+import { existsSync as existsSync43, readdirSync as readdirSync9, readFileSync as readFileSync26, statSync as statSync23 } from "node:fs";
+import { join as join34, resolve as resolve17 } from "node:path";
+function stripYamlComment(line) {
+  let quote = null;
+  for (let index = 0;index < line.length; index += 1) {
+    const char = line[index];
+    if (quote) {
+      if (char === quote)
+        quote = null;
+    } else if (char === '"' || char === "'") {
+      quote = char;
+    } else if (char === "#" && (index === 0 || /\s/.test(line[index - 1] ?? ""))) {
+      return line.slice(0, index).trimEnd();
+    }
+  }
+  return line.trimEnd();
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function yamlBoolean(raw) {
+  const value = raw.trim();
+  if (value === "true" || value === "True" || value === "TRUE")
+    return { kind: "on" };
+  if (value === "false" || value === "False" || value === "FALSE")
+    return { kind: "off" };
+  if (value === "" || value === "~" || value === "null" || value === "Null" || value === "NULL")
+    return { kind: "absent" };
+  return UNRECOGNIZED;
+}
+function keyPattern(key) {
+  return new RegExp(`^(?:${key}|"${key}"|'${key}')\\s*:(?:\\s+(.*))?$`);
+}
+function flowMapEnabled(flow) {
+  if (!flow.endsWith("}"))
+    return UNRECOGNIZED;
+  const body = flow.slice(1, -1);
+  if (/[{}[\]&*!]/.test(body))
+    return UNRECOGNIZED;
+  const matches = body.split(",").map((entry) => entry.trim().match(/^(?:enabled|"enabled"|'enabled')\s*:\s*(.*)$/)).filter((match) => match !== null);
+  if (matches.length > 1)
+    return UNRECOGNIZED;
+  return matches.length === 0 ? { kind: "absent" } : yamlBoolean(matches[0]?.[1] ?? "");
+}
+function readHideSecretsFromYaml(text) {
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/).map(stripYamlComment);
+  const content = lines.filter((line) => line.trim() !== "");
+  const first = content[0]?.trim();
+  if (first?.startsWith("{") || first?.startsWith("["))
+    return UNRECOGNIZED;
+  if (content.some((line) => /^\s*\t/.test(line)))
+    return UNRECOGNIZED;
+  const starts = lines.flatMap((line, index) => indentOf(line) === 0 && SECRETS_KEY.test(line) ? [index] : []);
+  if (starts.length === 0)
+    return { kind: "absent" };
+  if (starts.length > 1)
+    return UNRECOGNIZED;
+  const start = starts[0];
+  const inline = (lines[start]?.match(SECRETS_KEY)?.[1] ?? "").trim();
+  if (inline.startsWith("{"))
+    return flowMapEnabled(inline);
+  if (inline === "~" || inline === "null" || inline === "Null" || inline === "NULL")
+    return { kind: "absent" };
+  if (inline !== "")
+    return UNRECOGNIZED;
+  const children = [];
+  for (const line of lines.slice(start + 1)) {
+    if (line.trim() === "")
+      continue;
+    if (indentOf(line) === 0)
+      break;
+    children.push(line);
+  }
+  if (children.length === 0)
+    return { kind: "absent" };
+  const childIndent = indentOf(children[0]);
+  if (children[0]?.trimStart().startsWith("-"))
+    return UNRECOGNIZED;
+  let found = null;
+  for (let index = 0;index < children.length; index += 1) {
+    const line = children[index];
+    const indent = indentOf(line);
+    if (indent < childIndent)
+      return UNRECOGNIZED;
+    if (indent > childIndent)
+      continue;
+    const match = line.trim().match(ENABLED_KEY);
+    if (!match)
+      continue;
+    if (found)
+      return UNRECOGNIZED;
+    const nextIndent = children[index + 1] ? indentOf(children[index + 1]) : 0;
+    if ((match[1] ?? "").trim() === "" && nextIndent > childIndent)
+      return UNRECOGNIZED;
+    found = yamlBoolean(match[1] ?? "");
+  }
+  return found ?? { kind: "absent" };
+}
+function readHideSecretsFromJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { kind: "unreadable", reason: "file is not valid JSON" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return { kind: "absent" };
+  const secrets = parsed.secrets;
+  if (secrets === undefined || secrets === null)
+    return { kind: "absent" };
+  if (typeof secrets !== "object" || Array.isArray(secrets))
+    return UNRECOGNIZED;
+  const enabled = secrets.enabled;
+  if (enabled === true)
+    return { kind: "on" };
+  if (enabled === false)
+    return { kind: "off" };
+  if (enabled === undefined || enabled === null)
+    return { kind: "absent" };
+  return UNRECOGNIZED;
+}
+function readSource(layer, path, format) {
+  let text;
+  try {
+    text = readFileSync26(path, "utf-8");
+  } catch (error) {
+    const code = error.code;
+    return {
+      layer,
+      path,
+      value: {
+        kind: "unreadable",
+        reason: `file could not be read${code ? ` (${code})` : ""}`
+      }
+    };
+  }
+  return {
+    layer,
+    path,
+    value: format === "json" ? readHideSecretsFromJson(text) : readHideSecretsFromYaml(text)
+  };
+}
+function isNonEmptyDirectory(path) {
+  try {
+    return statSync23(path).isDirectory() && readdirSync9(path).length > 0;
+  } catch {
+    return false;
+  }
+}
+function collectHideSecretsSources(cwd, home = envFirstHomeDir()) {
+  const sources = [];
+  const agentDir = getOmpAgentDir();
+  const mainConfig = ["config.yml", "config.yaml"].map((name) => join34(agentDir, name)).find((path) => existsSync43(path));
+  if (mainConfig)
+    sources.push(readSource("user", mainConfig, "yaml"));
+  const projectDir = join34(cwd, ".omp");
+  if (resolve17(cwd) !== resolve17(home) && isNonEmptyDirectory(projectDir)) {
+    for (const [name, format] of [
+      ["settings.json", "json"],
+      ["config.yml", "yaml"]
+    ]) {
+      const path = join34(projectDir, name);
+      if (existsSync43(path))
+        sources.push(readSource("project", path, format));
+    }
+  }
+  for (const path of getOmpConfigOverlayPaths(cwd)) {
+    if (existsSync43(path))
+      sources.push(readSource("overlay", path, "yaml"));
+  }
+  return sources;
+}
+function checkOmpHideSecrets(sources) {
+  let effective = null;
+  let effectiveIndex = -1;
+  for (const [index, source] of sources.entries()) {
+    if (source.value.kind === "on" || source.value.kind === "off") {
+      effective = source;
+      effectiveIndex = index;
+    }
+  }
+  if (effective?.value.kind === "on") {
+    const explain = `OMP masks secrets after Magic Context prepares a turn, so some turns are refused; turn it off for Magic Context sessions, see ${OMP_HIDE_SECRETS_DOCS_URL} (${UNDETECTABLE})`;
+    const label = LAYER_LABEL[effective.layer];
+    return [
+      {
+        status: "warn",
+        message: `${SETTING} is on in ${label} (${effective.path}): ${explain}`,
+        issueMessage: `${SETTING} is on in ${label}: ${explain}`
+      }
+    ];
+  }
+  const unreadable = sources.flatMap((source, index) => index > effectiveIndex && source.value.kind === "unreadable" ? [{ source, reason: source.value.reason }] : []);
+  if (unreadable.length > 0) {
+    return unreadable.map(({ source, reason }) => {
+      const tail = `${reason}; if Hide Secrets is on, see ${OMP_HIDE_SECRETS_DOCS_URL} (${UNDETECTABLE})`;
+      const label = LAYER_LABEL[source.layer];
+      return {
+        status: "warn",
+        message: `Could not check ${SETTING} in ${label} (${source.path}): ${tail}`,
+        issueMessage: `Could not check ${SETTING} in ${label}: ${tail}`
+      };
+    });
+  }
+  const message = effective?.value.kind === "off" ? `${SETTING} is off in OMP settings files (${UNDETECTABLE})` : `${SETTING} is not set in OMP settings files; OMP's default is off (${UNDETECTABLE})`;
+  return [{ status: "pass", message, issueMessage: message }];
+}
+var OMP_HIDE_SECRETS_DOCS_URL = "https://docs.cortexkit.io/magic-context/help/compatibility/#omp-hide-secrets", LAYER_LABEL, UNDETECTABLE = "CLI flags and live settings toggles can't be detected", SETTING = "OMP Hide Secrets (secrets.enabled)", UNRECOGNIZED, SECRETS_KEY, ENABLED_KEY;
+var init_omp_hide_secrets = __esm(() => {
+  init_paths();
+  LAYER_LABEL = {
+    user: "OMP user settings",
+    project: "OMP project settings",
+    overlay: "an OMP config overlay (PI_CONFIG_FILES)"
+  };
+  UNRECOGNIZED = {
+    kind: "unreadable",
+    reason: "secrets.enabled could not be interpreted"
+  };
+  SECRETS_KEY = keyPattern("secrets");
+  ENABLED_KEY = keyPattern("enabled");
+});
+
 // src/commands/doctor-omp.ts
 import { execFileSync as execFileSync8, spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync42, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync44, readFileSync as readFileSync27 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { isAbsolute as isAbsolute8, join as join34, resolve as resolve17 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join35, resolve as resolve18 } from "node:path";
 function parseSemver(value) {
   const match = value?.match(/(\d+)\.(\d+)\.(\d+)/);
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
@@ -46524,10 +46976,10 @@ function selfVersion() {
   return "unknown";
 }
 function readConfig2(path) {
-  if (!existsSync42(path))
+  if (!existsSync44(path))
     return {};
   try {
-    const parsed = import_comment_json8.parse(readFileSync24(path, "utf-8"));
+    const parsed = import_comment_json8.parse(readFileSync27(path, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? {} : { error: "top level is not an object" };
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
@@ -46537,7 +46989,7 @@ function pluginDeclaresOmp(path) {
   if (!path)
     return null;
   try {
-    const pkg = JSON.parse(readFileSync24(join34(path, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync27(join35(path, "package.json"), "utf-8"));
     return Array.isArray(pkg.omp?.extensions) || Array.isArray(pkg.pi?.extensions);
   } catch {
     return null;
@@ -46604,6 +47056,8 @@ async function runHealthChecks(options) {
           repairPlan.disableMemory = true;
         } else
           add(results, "fail", "Could not read OMP memory.backend");
+        for (const check of checkOmpHideSecrets(collectHideSecretsSources(options.cwd)))
+          results.push(check);
         const nonGlobalSources = getOmpNonGlobalConfigSources(options.cwd);
         if (nonGlobalSources.length > 0 && (repairPlan.disableCompaction || repairPlan.disableMemory)) {
           add(results, "warn", "OMP project/overlay config owns effective conflicting settings; automatic global repair is disabled: " + nonGlobalSources.join(", "));
@@ -46612,8 +47066,8 @@ async function runHealthChecks(options) {
         if (!reportedAgentDir.ok) {
           add(results, "warn", "Could not verify OMP active agent directory");
         } else {
-          const reportedPath = resolve17(reportedAgentDir.stdout);
-          const expectedPath = resolve17(getOmpAgentDir());
+          const reportedPath = resolve18(reportedAgentDir.stdout);
+          const expectedPath = resolve18(getOmpAgentDir());
           if (reportedPath === expectedPath) {
             add(results, "pass", `OMP agent directory resolved to ${getOmpAgentDir()}`);
           } else {
@@ -46624,7 +47078,7 @@ async function runHealthChecks(options) {
     }
   }
   const userConfigPath = getOmpUserConfigPath();
-  if (!existsSync42(userConfigPath)) {
+  if (!existsSync44(userConfigPath)) {
     add(results, "warn", `No Magic Context user config at ${userConfigPath}`);
     repairPlan.writeUserConfig = true;
   } else {
@@ -46641,9 +47095,12 @@ async function runHealthChecks(options) {
     for (const warning of loaded.warnings.slice(0, 5))
       add(results, "warn", warning);
   const storage = getMagicContextStorageResolution();
-  const dbPath = join34(storage.path, "context.db");
+  const dbPath = join35(storage.path, "context.db");
+  if (isMagicContextStorageOutsideEngram(storage.path)) {
+    add(results, "warn", `Magic Context storage is at ${storage.path}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.`);
+  }
   add(results, "info", `Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync42(dbPath))
+  if (!existsSync44(dbPath))
     add(results, "info", `Shared context DB will be created at ${dbPath}`);
   else {
     let db = null;
@@ -46708,7 +47165,7 @@ function writeDefaultConfig(path) {
 }
 async function repair(plan, deps, prompts, cwd) {
   let fixed = 0;
-  if (plan.writeUserConfig && !existsSync42(getOmpUserConfigPath())) {
+  if (plan.writeUserConfig && !existsSync44(getOmpUserConfigPath())) {
     writeDefaultConfig(getOmpUserConfigPath());
     prompts.log.success(`Wrote default Magic Context config to ${getOmpUserConfigPath()}`);
     fixed += 1;
@@ -46764,7 +47221,7 @@ function ompIssueBody(description, report, logLines, sessionFilter, cwd) {
     "",
     "## OMP diagnostics",
     `- Magic Context CLI: v${selfVersion()}`,
-    ...report.results.map((result) => `- ${result.status.toUpperCase()}: ${privacy.healthMessage(result.message)}`),
+    ...report.results.map((result) => `- ${result.status.toUpperCase()}: ${result.issueMessage ?? privacy.healthMessage(result.message)}`),
     "",
     "## Recent errors (last 20, sanitized)",
     recentErrorLines.length === 0 ? "_No error-shaped log lines found in recent history._" : ["```", recentErrorLines.join(`
@@ -46821,7 +47278,7 @@ function runGhCommandWithDeps(deps, args) {
 async function runIssueFlow(options) {
   if (options.reportPath) {
     const report = await runHealthChecks({ ...options, quiet: true });
-    const path = isAbsolute8(options.reportPath) ? options.reportPath : join34(options.cwd, options.reportPath);
+    const path = isAbsolute8(options.reportPath) ? options.reportPath : join35(options.cwd, options.reportPath);
     const bundle = writeOmpIssueReport(path, ompIssueBody("Generated non-interactively by `doctor --issue --report`.", report, readLogLines(report.logFiles), null, options.cwd));
     options.prompts.log.success(bundle.fullPath ? `Sanitized report written to ${bundle.path}; full report at ${bundle.fullPath}` : `Sanitized report written to ${bundle.path}`);
     return 0;
@@ -46848,7 +47305,7 @@ async function runIssueFlow(options) {
     ]);
     sessionFilter = choice === "__all__" ? null : choice;
   }
-  const path = join34(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
+  const path = join35(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
   const bundle = writeOmpIssueReport(path, ompIssueBody(description, report, logLines, sessionFilter, options.cwd));
   options.prompts.log.success(bundle.fullPath ? `Sanitized report written to ${bundle.path}; full report at ${bundle.fullPath}` : `Sanitized report written to ${bundle.path}`);
   if (await options.prompts.confirm("Submit this issue on GitHub now?", false)) {
@@ -46903,6 +47360,7 @@ var init_doctor_omp = __esm(async () => {
   init_issue_body();
   init_log_lines();
   init_omp_helpers();
+  init_omp_hide_secrets();
   init_paths();
   init_prompts();
   await init_database_access();
@@ -47819,12 +48277,12 @@ function listShadowBackfillStalls(db, projectIdentity) {
 var SHADOW_BACKFILL_PROVENANCE_KEY = "_magicContextShadowBackfill";
 
 // ../plugin/src/shared/auto-update-provenance.ts
-import { existsSync as existsSync43, readFileSync as readFileSync25 } from "node:fs";
+import { existsSync as existsSync45, readFileSync as readFileSync28 } from "node:fs";
 function readAutoUpdateCheckState(path) {
-  if (!existsSync43(path))
+  if (!existsSync45(path))
     return null;
   try {
-    const value = JSON.parse(readFileSync25(path, "utf-8"));
+    const value = JSON.parse(readFileSync28(path, "utf-8"));
     if (!value || typeof value !== "object" || Array.isArray(value))
       return null;
     const raw = value;
@@ -47852,14 +48310,14 @@ var init_auto_update_provenance = () => {};
 // ../plugin/src/shared/tui-config.ts
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync44,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync26,
+  existsSync as existsSync46,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync29,
   renameSync as renameSync8,
-  statSync as statSync22,
-  writeFileSync as writeFileSync7
+  statSync as statSync24,
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname23, join as join35 } from "node:path";
+import { dirname as dirname24, join as join36 } from "node:path";
 function pluginEntryId(entry) {
   if (typeof entry === "string")
     return entry;
@@ -47890,21 +48348,21 @@ function writeTuiConfigAtomic(configPath, config) {
   const body = `${import_comment_json9.stringify(config, null, 2)}
 `;
   const tmpPath = `${configPath}.tmp`;
-  writeFileSync7(tmpPath, body);
+  writeFileSync8(tmpPath, body);
   try {
-    if (statSync22(configPath, { throwIfNoEntry: false })?.isFile()) {
-      chmodSync4(tmpPath, statSync22(configPath).mode & 511);
+    if (statSync24(configPath, { throwIfNoEntry: false })?.isFile()) {
+      chmodSync4(tmpPath, statSync24(configPath).mode & 511);
     }
   } catch {}
   renameSync8(tmpPath, configPath);
 }
 function resolveTuiConfigPath(configDirOverride) {
   const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join35(configDir, "tui.jsonc");
-  const jsonPath = join35(configDir, "tui.json");
-  if (existsSync44(jsoncPath))
+  const jsoncPath = join36(configDir, "tui.jsonc");
+  const jsonPath = join36(configDir, "tui.json");
+  if (existsSync46(jsoncPath))
     return jsoncPath;
-  if (existsSync44(jsonPath))
+  if (existsSync46(jsonPath))
     return jsonPath;
   return jsoncPath;
 }
@@ -47912,8 +48370,8 @@ function ensureTuiPluginEntry(options = {}) {
   try {
     const configPath = resolveTuiConfigPath(options.configDir);
     let config = {};
-    if (existsSync44(configPath)) {
-      const raw = readFileSync26(configPath, "utf-8");
+    if (existsSync46(configPath)) {
+      const raw = readFileSync29(configPath, "utf-8");
       config = import_comment_json9.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? [...config.plugin] : [];
@@ -47947,7 +48405,7 @@ function ensureTuiPluginEntry(options = {}) {
       }
     }
     config.plugin = plugins;
-    mkdirSync7(dirname23(configPath), { recursive: true });
+    mkdirSync8(dirname24(configPath), { recursive: true });
     writeTuiConfigAtomic(configPath, config);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -47965,9 +48423,9 @@ var init_tui_config = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync45, readdirSync as readdirSync9, readFileSync as readFileSync27, statSync as statSync23 } from "node:fs";
+import { existsSync as existsSync47, readdirSync as readdirSync10, readFileSync as readFileSync30, statSync as statSync25 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function getSelfVersion() {
   const require2 = createRequire4(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -47982,7 +48440,7 @@ function getSelfVersion() {
 }
 function readLegacyCachedVersion(root) {
   try {
-    const pkg = JSON.parse(readFileSync27(getOpenCodePluginPackageJsonPath(root), "utf-8"));
+    const pkg = JSON.parse(readFileSync30(getOpenCodePluginPackageJsonPath(root), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -47991,7 +48449,7 @@ function readLegacyCachedVersion(root) {
 function collectOpenCodePluginCacheReport(hostGeneration, opencodeConfig) {
   const installs = [];
   for (const root of getOpenCodePluginCacheRoots()) {
-    if (!existsSync45(root))
+    if (!existsSync47(root))
       continue;
     const spec = root.endsWith("@latest") ? "latest" : "(bare)";
     installs.push({
@@ -48025,7 +48483,7 @@ function getStorageResolution() {
 }
 function fileSize(path) {
   try {
-    return existsSync45(path) ? statSync23(path).size : 0;
+    return existsSync47(path) ? statSync25(path).size : 0;
   } catch {
     return 0;
   }
@@ -48037,10 +48495,10 @@ function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
 function readConfig3(path) {
-  if (!existsSync45(path))
+  if (!existsSync47(path))
     return { value: null };
   try {
-    const raw = readFileSync27(path, "utf-8");
+    const raw = readFileSync30(path, "utf-8");
     const value = import_comment_json10.parse(raw);
     return { value };
   } catch (error) {
@@ -48065,7 +48523,7 @@ function configHasPluginEntry(config) {
 }
 function parseHistorianDumpMeta(path) {
   try {
-    const xml = readFileSync27(path, "utf-8");
+    const xml = readFileSync30(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -48098,11 +48556,11 @@ function parseHistorianDumpMeta(path) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync45(dir))
+  if (!existsSync47(dir))
     return { count: 0, recent: [] };
   try {
-    const entries = readdirSync9(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync23(join36(dir, name));
+    const entries = readdirSync10(dir).filter((name) => name.endsWith(".xml")).map((name) => {
+      const stat = statSync25(join37(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -48111,7 +48569,7 @@ function listDumpsInDir(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta(join36(dir, entry.name));
+      const meta = parseHistorianDumpMeta(join37(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -48222,7 +48680,7 @@ function collectRecentSessionsFromDatabase(database) {
   });
 }
 async function collectDatabaseRows(path, read) {
-  if (!existsSync45(path))
+  if (!existsSync47(path))
     return { available: false, reason: "path missing" };
   let backend;
   try {
@@ -48254,7 +48712,7 @@ async function collectRecentSessions(resolution, hostGeneration) {
   });
 }
 async function collectHistorianFailures(storageDirPath) {
-  return collectDatabaseRows(join36(storageDirPath, "context.db"), (db) => {
+  return collectDatabaseRows(join37(storageDirPath, "context.db"), (db) => {
     const rows = db.prepare("SELECT session_id, historian_failure_count, historian_last_error, historian_last_failure_at FROM session_meta WHERE historian_failure_count > 0 ORDER BY historian_last_failure_at DESC LIMIT 10").all();
     return rows.map((row) => {
       const sessionId = typeof row.session_id === "string" ? row.session_id : "<unknown>";
@@ -48267,7 +48725,7 @@ async function collectHistorianFailures(storageDirPath) {
   });
 }
 async function collectHistorianRuns(storageDirPath) {
-  return collectDatabaseRows(join36(storageDirPath, "context.db"), (db) => {
+  return collectDatabaseRows(join37(storageDirPath, "context.db"), (db) => {
     const aggRows = db.prepare(`SELECT session_id,
                     COUNT(*) AS total,
                     SUM(CASE WHEN status='success' THEN 1 ELSE 0 END) AS success,
@@ -48322,7 +48780,7 @@ async function collectDiagnostics() {
   const magicContextConfig = readConfig3(configPaths.magicContextConfig);
   const storageResolution = getStorageResolution();
   const storageDirPath = storageResolution.path;
-  const contextDbPath = join36(storageDirPath, "context.db");
+  const contextDbPath = join37(storageDirPath, "context.db");
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -48354,7 +48812,7 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync45(configPaths.magicContextConfig),
+      exists: existsSync47(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
@@ -48362,7 +48820,7 @@ async function collectDiagnostics() {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync45(storageDirPath),
+      exists: existsSync47(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     openCodeDatabase: {
@@ -48422,6 +48880,7 @@ function renderDiagnosticsMarkdown(report) {
     exists: report.storageDir.exists,
     context_db_size: formatBytes(report.storageDir.contextDbSizeBytes)
   };
+  const storageBackupWarning = isMagicContextStorageOutsideEngram(report.storageDir.path) ? `- Warning: Magic Context storage is at ${sanitizeString(report.storageDir.path)}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.` : null;
   const openCodeInstallations = report.opencodeInstallations ?? [];
   const openCodeInstallationTable = openCodeInstallations.length > 1 ? [
     "",
@@ -48484,6 +48943,7 @@ function renderDiagnosticsMarkdown(report) {
     "```",
     "",
     "### Storage",
+    ...storageBackupWarning ? [storageBackupWarning] : [],
     "```json",
     JSON.stringify(storage, null, 2),
     "```",
@@ -48616,9 +49076,9 @@ var init_embedding_local = __esm(async () => {
 
 // src/lib/embedding-runtime.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync46, readFileSync as readFileSync28 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync31 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname24, join as join37, sep } from "node:path";
+import { dirname as dirname25, join as join38, sep as sep2 } from "node:path";
 function describeError(error) {
   const message = error instanceof Error ? error.message : String(error ?? "unknown error");
   const code = error?.code;
@@ -48760,11 +49220,11 @@ function expectedBinaryRelPath(platform, arch) {
   const supportedArch = arch === "x64" || arch === "arm64";
   if (!supportedPlatform || !supportedArch)
     return null;
-  return join37("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
+  return join38("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
 }
 function onnxRuntimeNodeVersion(packageDir) {
   try {
-    const parsed = JSON.parse(readFileSync28(join37(packageDir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync31(join38(packageDir, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : undefined;
   } catch {
     return;
@@ -48813,7 +49273,7 @@ function formatLocalEmbeddingRuntimeWasmSelected(status) {
 function requireNodeWasmBundle(probe, candidates) {
   if (probe.state === "failed")
     return probe;
-  const bundlePath = candidates.find((candidate) => existsSync46(candidate));
+  const bundlePath = candidates.find((candidate) => existsSync48(candidate));
   return bundlePath ? probe : {
     state: "failed",
     reason: `functional Node WASM Transformers bundle is missing (checked ${candidates.join(", ")})`
@@ -48821,13 +49281,13 @@ function requireNodeWasmBundle(probe, candidates) {
 }
 function nodeWasmBundleCandidates(installRoot) {
   return [
-    join37(installRoot, "dist", "transformers-node-wasm.js"),
-    join37(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
-    join37(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
+    join38(installRoot, "dist", "transformers-node-wasm.js"),
+    join38(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
+    join38(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
   ];
 }
 function probeWasmRuntimeAt(installRoot) {
-  const requireFn = createRequire5(join37(installRoot, "package.json"));
+  const requireFn = createRequire5(join38(installRoot, "package.json"));
   return requireNodeWasmBundle(probeWasmRuntimeFromRequire(requireFn), nodeWasmBundleCandidates(installRoot));
 }
 function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
@@ -48836,9 +49296,9 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
     const wasm = probeWasmRuntimeAt(installRoot);
     return wasm.state === "ok" ? { state: "wasm-selected", wasmPath: wasm.wasmPath } : { state: "wasm-broken", wasmReason: wasm.reason };
   }
-  const packageDir = join37(installRoot, "node_modules", "onnxruntime-node");
+  const packageDir = join38(installRoot, "node_modules", "onnxruntime-node");
   let native;
-  if (!existsSync46(join37(packageDir, "package.json"))) {
+  if (!existsSync48(join38(packageDir, "package.json"))) {
     native = { state: "package-missing", packageDir };
   } else {
     const rel = expectedBinaryRelPath(platform, arch);
@@ -48848,8 +49308,8 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
         binaryPath: packageDir
       };
     } else {
-      const binaryPath = join37(packageDir, rel);
-      native = existsSync46(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
+      const binaryPath = join38(packageDir, rel);
+      native = existsSync48(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
         state: "binary-missing",
         packageDir,
         expectedBinary: binaryPath,
@@ -48860,7 +49320,7 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
   return withWasmFallback(native, () => probeWasmRuntimeAt(installRoot));
 }
 function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  const existing = installRoots.filter((root) => existsSync46(root));
+  const existing = installRoots.filter((root) => existsSync48(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -48884,21 +49344,21 @@ function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, a
   return firstFallback ?? firstFailure ?? { state: "unknown", reason: "no candidate roots" };
 }
 function packageDirFromResolved(resolvedPath, packageName) {
-  const marker = `node_modules${sep}${packageName.split("/").join(sep)}`;
+  const marker = `node_modules${sep2}${packageName.split("/").join(sep2)}`;
   const idx = resolvedPath.indexOf(marker);
-  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname24(resolvedPath);
+  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname25(resolvedPath);
 }
 function probeWasmRuntimeByResolution(pluginDir) {
   try {
-    const reqPlugin = createRequire5(join37(pluginDir, "package.json"));
+    const reqPlugin = createRequire5(join38(pluginDir, "package.json"));
     const direct = probeWasmRuntimeFromRequire(reqPlugin);
     let probe = direct;
     if (direct.state === "failed" && direct.reason.startsWith("onnxruntime-web is not resolvable")) {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      probe = probeWasmRuntimeFromRequire(createRequire5(join37(tfDir, "package.json")));
+      probe = probeWasmRuntimeFromRequire(createRequire5(join38(tfDir, "package.json")));
     }
-    return requireNodeWasmBundle(probe, [join37(pluginDir, "dist", "transformers-node-wasm.js")]);
+    return requireNodeWasmBundle(probe, [join38(pluginDir, "dist", "transformers-node-wasm.js")]);
   } catch (error) {
     return {
       state: "failed",
@@ -48907,7 +49367,7 @@ function probeWasmRuntimeByResolution(pluginDir) {
   }
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  if (!existsSync46(join37(pluginDir, "package.json"))) {
+  if (!existsSync48(join38(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   const selectedRuntime = resolveLocalEmbeddingWorkerRuntime(runtimePreference, host);
@@ -48918,13 +49378,13 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   let onnxDir = null;
   let resolveError;
   try {
-    const reqPlugin = createRequire5(join37(pluginDir, "package.json"));
+    const reqPlugin = createRequire5(join38(pluginDir, "package.json"));
     try {
       onnxDir = packageDirFromResolved(reqPlugin.resolve("onnxruntime-node"), "onnxruntime-node");
     } catch {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      const reqTf = createRequire5(join37(tfDir, "package.json"));
+      const reqTf = createRequire5(join38(tfDir, "package.json"));
       onnxDir = packageDirFromResolved(reqTf.resolve("onnxruntime-node"), "onnxruntime-node");
     }
   } catch (error) {
@@ -48932,7 +49392,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     if (resolveError === "ERR_MODULE_NOT_FOUND" || resolveError === "MODULE_NOT_FOUND") {
       return withWasmFallback({
         state: "package-missing",
-        packageDir: join37(pluginDir, "node_modules", "onnxruntime-node")
+        packageDir: join38(pluginDir, "node_modules", "onnxruntime-node")
       }, () => probeWasmRuntimeByResolution(pluginDir));
     }
     return {
@@ -48948,8 +49408,8 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   if (rel === null) {
     native = probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   } else {
-    const binaryPath = join37(onnxDir, rel);
-    native = existsSync46(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
+    const binaryPath = join38(onnxDir, rel);
+    native = existsSync48(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
       state: "binary-missing",
       packageDir: onnxDir,
       expectedBinary: binaryPath,
@@ -48984,8 +49444,8 @@ var init_embedding_runtime = __esm(async () => {
 });
 
 // src/lib/logs-opencode.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname25, join as join38 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname26, join as join39 } from "node:path";
 function formatTimestamp(date) {
   const pad = (value) => String(value).padStart(2, "0");
   return [
@@ -49074,13 +49534,13 @@ async function bundleIssueReport(report, description, title, sessionFilter = nul
   const bodyMarkdown = capBodyToGithubLimit(rawBodyMarkdown);
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const timestamp = formatTimestamp(new Date);
-  const path = options.outputPath ?? join38(process.cwd(), `magic-context-issue-${timestamp}.md`);
-  mkdirSync8(dirname25(path), { recursive: true });
-  writeFileSync8(path, `${bodyMarkdown}
+  const path = options.outputPath ?? join39(process.cwd(), `magic-context-issue-${timestamp}.md`);
+  mkdirSync9(dirname26(path), { recursive: true });
+  writeFileSync9(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join38(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join39(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
-    writeFileSync8(fullPath, `${rawBodyMarkdown}
+    writeFileSync9(fullPath, `${rawBodyMarkdown}
 `);
   return { path, bodyMarkdown, ...fullPath ? { fullPath } : {}, truncated };
 }
@@ -49891,10 +50351,10 @@ function removeDeprecatedReasoningAge(config) {
 
 // src/commands/doctor-opencode.ts
 import { spawnSync as spawnSync10 } from "node:child_process";
-import { existsSync as existsSync47, mkdtempSync as mkdtempSync4, readFileSync as readFileSync29, rmSync as rmSync9 } from "node:fs";
+import { existsSync as existsSync49, mkdtempSync as mkdtempSync4, readFileSync as readFileSync32, rmSync as rmSync9 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { homedir as homedir21, tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname26, join as join39, resolve as resolve18 } from "node:path";
+import { dirname as dirname27, join as join40, resolve as resolve19 } from "node:path";
 function formatSharedDbRowCounts(db) {
   return SHARED_DB_ROW_COUNT_TABLES.map((table) => {
     try {
@@ -49965,7 +50425,7 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
   }
   if (models.length === 0)
     return;
-  const tempRoot = mkdtempSync4(join39(tmpdir4(), "magic-context-opencode-catalog-"));
+  const tempRoot = mkdtempSync4(join40(tmpdir4(), "magic-context-opencode-catalog-"));
   try {
     const command = hostGeneration === "v2" ? ["api", "model.list", "--param", `directory=${projectDir}`] : ["models", "--verbose"];
     const guidance = `opencode ${command.join(" ")}`;
@@ -50141,7 +50601,7 @@ function getSelfVersion2() {
 function describeAutoUpdateStall(specifier, autoUpdateEnabled, storageDir = getMagicContextStorageDir()) {
   if (!autoUpdateEnabled || !isPinnedOpenCodePluginSpecifier(specifier))
     return null;
-  const state = readAutoUpdateCheckState(join39(storageDir, AUTO_UPDATE_CHECK_STATE_FILENAME));
+  const state = readAutoUpdateCheckState(join40(storageDir, AUTO_UPDATE_CHECK_STATE_FILENAME));
   const owner = isUpdaterPinnedSpec(state, specifier) ? "updater" : "you";
   return `auto-update: stalled — config pinned to ${specifier} (by ${owner})`;
 }
@@ -50150,15 +50610,15 @@ function getUserNpmrcPath() {
   if (custom)
     return custom;
   const home = process.env.HOME?.trim();
-  return join39(home || homedir21(), ".npmrc");
+  return join40(home || homedir21(), ".npmrc");
 }
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync47(npmrcPath))
+  if (!existsSync49(npmrcPath))
     return ageWarnings;
   try {
-    const npmrc = readFileSync29(npmrcPath, "utf-8");
+    const npmrc = readFileSync32(npmrcPath, "utf-8");
     for (const line of npmrc.split(`
 `)) {
       const trimmed = line.trim();
@@ -50199,7 +50659,7 @@ async function runIssueFlow2(options = {}, deps = { collectDiagnostics }) {
   if (options.reportPath) {
     try {
       const report = await deps.collectDiagnostics();
-      const bundled = await bundleIssueReport(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", null, { outputPath: resolve18(process.cwd(), options.reportPath) });
+      const bundled = await bundleIssueReport(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", null, { outputPath: resolve19(process.cwd(), options.reportPath) });
       log3.info(bundled.fullPath ? `Report written to ${bundled.path}; full bundle at ${bundled.fullPath}` : `Report written to ${bundled.path}`);
       return 0;
     } catch (error) {
@@ -50293,7 +50753,7 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync47(magicContextConfigPath)) {
+  if (!existsSync49(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -50468,7 +50928,7 @@ async function runDoctor2(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "OpenCode",
     openDatabase: (readonly = true) => {
-      const dbPath = join39(getMagicContextStorageDir(), "context.db");
+      const dbPath = join40(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -50500,7 +50960,11 @@ async function runDoctor2(options = {}) {
     failCount++;
     issues++;
   };
-  const authorityDbPath = join39(getMagicContextStorageDir(), "context.db");
+  const storageDir = getMagicContextStorageDir();
+  if (isMagicContextStorageOutsideEngram(storageDir)) {
+    warn(`Magic Context storage is at ${storageDir}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.`);
+  }
+  const authorityDbPath = join40(getMagicContextStorageDir(), "context.db");
   let authorityDb = null;
   try {
     authorityDb = openExistingContextDatabase(authorityDbPath, { readonly: true });
@@ -50539,8 +51003,8 @@ async function runDoctor2(options = {}) {
   let magicContextStatusKnown = paths.opencodeConfigFormat === "none";
   if (!magicContextStatusKnown) {
     try {
-      const config = import_comment_json11.parse(readFileSync29(paths.opencodeConfig, "utf-8"));
-      magicContextInstalled = isOpenCodePluginRegistered(config, dirname26(paths.opencodeConfig));
+      const config = import_comment_json11.parse(readFileSync32(paths.opencodeConfig, "utf-8"));
+      magicContextInstalled = isOpenCodePluginRegistered(config, dirname27(paths.opencodeConfig));
       magicContextStatusKnown = true;
     } catch {}
   }
@@ -50675,7 +51139,7 @@ async function runDoctor2(options = {}) {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
   let autoUpdateEnabled = true;
-  if (existsSync47(paths.magicContextConfig)) {
+  if (existsSync49(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
@@ -50711,7 +51175,7 @@ async function runDoctor2(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log3.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync47(paths.magicContextConfig)) {
+  if (existsSync49(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -50851,10 +51315,10 @@ async function runDoctor2(options = {}) {
   };
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync29(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync32(paths.opencodeConfig, "utf-8");
       const config = import_comment_json11.parse(raw);
       const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
-      const configDir = dirname26(paths.opencodeConfig);
+      const configDir = dirname27(paths.opencodeConfig);
       magicContextInstalled = isOpenCodePluginRegistered(config, configDir);
       magicContextStatusKnown = true;
       if (magicContextInstalled) {
@@ -50944,11 +51408,11 @@ async function runDoctor2(options = {}) {
       pass("Added TUI sidebar plugin to tui.json");
       warn("Restart OpenCode to see the sidebar");
       fixed++;
-    } else if (existsSync47(paths.tuiConfig)) {
+    } else if (existsSync49(paths.tuiConfig)) {
       try {
-        const tuiRaw = readFileSync29(paths.tuiConfig, "utf-8");
+        const tuiRaw = readFileSync32(paths.tuiConfig, "utf-8");
         const tuiConfig = import_comment_json11.parse(tuiRaw);
-        const tuiConfigDir = dirname26(paths.tuiConfig);
+        const tuiConfigDir = dirname27(paths.tuiConfig);
         const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
         const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry, tuiConfigDir));
         if (tuiRawPlugins.some((entry) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry, tuiConfigDir))) {
@@ -50985,7 +51449,7 @@ async function runDoctor2(options = {}) {
       fail("Could not create or verify the TUI sidebar config");
     }
   }
-  if (existsSync47(paths.magicContextConfig)) {
+  if (existsSync49(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -51007,9 +51471,9 @@ async function runDoctor2(options = {}) {
   else
     passCount++;
   const storage = getMagicContextStorageResolution();
-  const dbPath = join39(storage.path, "context.db");
+  const dbPath = join40(storage.path, "context.db");
   log3.info(`Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync47(dbPath)) {
+  if (!existsSync49(dbPath)) {
     log3.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     log3.info(`Shared context DB exists at ${dbPath}`);
@@ -51092,7 +51556,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     let pluginConfigUse;
     if (paths.opencodeConfigFormat !== "none") {
       try {
-        pluginConfigUse = readOpenCodePluginConfigUse(import_comment_json11.parse(readFileSync29(paths.opencodeConfig, "utf-8")), dirname26(paths.opencodeConfig));
+        pluginConfigUse = readOpenCodePluginConfigUse(import_comment_json11.parse(readFileSync32(paths.opencodeConfig, "utf-8")), dirname27(paths.opencodeConfig));
       } catch {}
     }
     const cacheResult = await clearPluginCache({
@@ -51144,7 +51608,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     let v2DistTag;
     if (paths.opencodeConfigFormat !== "none") {
       try {
-        v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync29(paths.opencodeConfig, "utf-8")));
+        v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync32(paths.opencodeConfig, "utf-8")));
       } catch {}
     }
     const v2Cache = reportOpenCodeV2PluginCache(checkOpenCodeV2PluginCache({
@@ -51413,6 +51877,7 @@ function buildDreamTaskRuntimeConfigs(dreamer, harness, language, smartNotesEnab
   });
 }
 var init_task_config = __esm(() => {
+  init_agent_disable();
   init_task_registry();
 });
 
@@ -51525,9 +51990,9 @@ var init_model_chain_health = __esm(() => {
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync48, readdirSync as readdirSync10, readFileSync as readFileSync30, statSync as statSync24 } from "node:fs";
+import { existsSync as existsSync50, readdirSync as readdirSync11, readFileSync as readFileSync33, statSync as statSync26 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire7(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -51542,7 +52007,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path) {
   try {
-    return existsSync48(path) ? statSync24(path).size : 0;
+    return existsSync50(path) ? statSync26(path).size : 0;
   } catch {
     return 0;
   }
@@ -51554,11 +52019,11 @@ function sanitizeValue2(value) {
   return sanitizeConfigValue(value);
 }
 function readJsonc(path) {
-  if (!existsSync48(path))
+  if (!existsSync50(path))
     return { value: {} };
   try {
     return {
-      value: import_comment_json12.parse(readFileSync30(path, "utf-8"))
+      value: import_comment_json12.parse(readFileSync33(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -51574,7 +52039,7 @@ function readConfigDiagnostic(path) {
   const parsed = readJsonc(path);
   return {
     path,
-    exists: existsSync48(path),
+    exists: existsSync50(path),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -51592,25 +52057,25 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync48(sessionsRoot))
+  if (!existsSync50(sessionsRoot))
     return [];
   try {
-    const slugs = readdirSync10(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    const slugs = readdirSync11(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     const candidates = [];
     for (const slug of slugs) {
       const directory = reverseSlugToDirectory(slug);
       if (!directory)
         continue;
-      const slugDir = join40(sessionsRoot, slug);
+      const slugDir = join41(sessionsRoot, slug);
       let files;
       try {
-        files = readdirSync10(slugDir).filter((name) => name.endsWith(".jsonl"));
+        files = readdirSync11(slugDir).filter((name) => name.endsWith(".jsonl"));
       } catch {
         continue;
       }
       for (const file of files) {
         try {
-          const mtime = statSync24(join40(slugDir, file)).mtimeMs;
+          const mtime = statSync26(join41(slugDir, file)).mtimeMs;
           const sessionId = file.replace(/\.jsonl$/, "");
           candidates.push({ sessionId, directory, mtime });
         } catch {}
@@ -51628,7 +52093,7 @@ function collectPiRecentSessions() {
 }
 function parseHistorianDumpMeta2(path) {
   try {
-    const xml = readFileSync30(path, "utf-8");
+    const xml = readFileSync33(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -51661,11 +52126,11 @@ function parseHistorianDumpMeta2(path) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync48(dir))
+  if (!existsSync50(dir))
     return { count: 0, recent: [] };
   try {
-    const entries = readdirSync10(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync24(join40(dir, name));
+    const entries = readdirSync11(dir).filter((name) => name.endsWith(".xml")).map((name) => {
+      const stat = statSync26(join41(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -51674,7 +52139,7 @@ function listDumpsInDir2(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta2(join40(dir, entry.name));
+      const meta = parseHistorianDumpMeta2(join41(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -51738,7 +52203,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const loaded = loadPiConfig({ cwd });
   const storageResolution = getMagicContextStorageResolution();
   const storageDirPath = storageResolution.path;
-  const dbPath = join40(storageDirPath, "context.db");
+  const dbPath = join41(storageDirPath, "context.db");
   const logFiles = inspectMagicContextLogs("pi");
   const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
@@ -51755,7 +52220,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync48(settingsPath),
+      exists: existsSync50(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -51772,7 +52237,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync48(storageDirPath),
+      exists: existsSync50(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -51807,6 +52272,7 @@ function renderDiagnosticsMarkdown2(report) {
     exists: report.storageDir.exists,
     context_db_size: formatBytes2(report.storageDir.contextDbSizeBytes)
   };
+  const storageBackupWarning = isMagicContextStorageOutsideEngram(report.storageDir.path) ? `- Warning: Magic Context storage is at ${sanitizeString2(report.storageDir.path)}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.` : null;
   return [
     `- Timestamp: ${report.timestamp}`,
     `- Pi plugin: v${report.pluginVersion}`,
@@ -51847,6 +52313,7 @@ function renderDiagnosticsMarkdown2(report) {
 `),
     "",
     "### Shared storage",
+    ...storageBackupWarning ? [storageBackupWarning] : [],
     "```json",
     JSON.stringify(storage, null, 2),
     "```",
@@ -51877,8 +52344,8 @@ var init_diagnostics_pi = __esm(() => {
 });
 
 // src/lib/logs-pi.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname27, join as join41 } from "node:path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname28, join as join42 } from "node:path";
 function formatTimestamp2(date) {
   const pad = (value) => String(value).padStart(2, "0");
   return [
@@ -51932,13 +52399,13 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const cwd = options.cwd ?? process.cwd();
   const timestamp = formatTimestamp2(options.now ?? new Date);
-  const path = options.outputPath ?? join41(cwd, `magic-context-pi-issue-${timestamp}.md`);
-  mkdirSync9(dirname27(path), { recursive: true });
-  writeFileSync9(path, `${bodyMarkdown}
+  const path = options.outputPath ?? join42(cwd, `magic-context-pi-issue-${timestamp}.md`);
+  mkdirSync10(dirname28(path), { recursive: true });
+  writeFileSync10(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join41(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join42(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
-    writeFileSync9(fullPath, `${rawBodyMarkdown}
+    writeFileSync10(fullPath, `${rawBodyMarkdown}
 `);
   return { path, bodyMarkdown, ...fullPath ? { fullPath } : {}, truncated };
 }
@@ -51950,10 +52417,10 @@ var init_logs_pi = __esm(() => {
 
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync9, spawnSync as spawnSync11 } from "node:child_process";
-import { existsSync as existsSync49, readdirSync as readdirSync11, readFileSync as readFileSync31, rmSync as rmSync10, statSync as statSync25 } from "node:fs";
+import { existsSync as existsSync51, readdirSync as readdirSync12, readFileSync as readFileSync34, rmSync as rmSync10, statSync as statSync27 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
 import { homedir as homedir22 } from "node:os";
-import { isAbsolute as isAbsolute9, join as join42 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join43 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS5,
@@ -52045,7 +52512,7 @@ function summarize(results) {
 function readJsonc2(path) {
   try {
     return {
-      value: import_comment_json13.parse(readFileSync31(path, "utf-8"))
+      value: import_comment_json13.parse(readFileSync34(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -52095,15 +52562,15 @@ function piPluginDirCandidates(packages, cwd) {
     if (resolved)
       dirs.push(resolved);
   }
-  dirs.push(join42(agentDir, "npm", "node_modules", PACKAGE_NAME2));
-  dirs.push(join42(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
-  return dirs.filter((dir) => existsSync49(join42(dir, "package.json")));
+  dirs.push(join43(agentDir, "npm", "node_modules", PACKAGE_NAME2));
+  dirs.push(join43(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
+  return dirs.filter((dir) => existsSync51(join43(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path, isProjectConfig) {
-  if (!existsSync49(path))
+  if (!existsSync51(path))
     return null;
   try {
     const raw = loadRawConfigFile({
@@ -52189,35 +52656,35 @@ function pinnedVersionFromPackageSpecifier(specifier) {
 }
 function cacheRoots(cwd) {
   const home = process.env.HOME?.trim();
-  const cacheHome = process.env.XDG_CACHE_HOME || join42(home || homedir22(), ".cache");
+  const cacheHome = process.env.XDG_CACHE_HOME || join43(home || homedir22(), ".cache");
   const piCacheRoot = getPiCacheRoot();
   return [
-    join42(piCacheRoot, "extensions"),
-    join42(piCacheRoot, "packages"),
-    join42(cacheHome, "pi", "extensions"),
-    join42(cacheHome, "pi", "packages"),
-    join42(getPiAgentConfigDir(), "cache", "extensions"),
-    join42(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
-    join42(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
+    join43(piCacheRoot, "extensions"),
+    join43(piCacheRoot, "packages"),
+    join43(cacheHome, "pi", "extensions"),
+    join43(cacheHome, "pi", "packages"),
+    join43(getPiAgentConfigDir(), "cache", "extensions"),
+    join43(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
+    join43(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
   ];
 }
 function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
   const found = new Map;
   const visit = (path, depth) => {
-    if (depth < 0 || !existsSync49(path))
+    if (depth < 0 || !existsSync51(path))
       return;
     let stat;
     try {
-      stat = statSync25(path);
+      stat = statSync27(path);
     } catch {
       return;
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join42(path, "package.json");
-    if (existsSync49(packageJson)) {
+    const packageJson = join43(path, "package.json");
+    if (existsSync51(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync31(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync34(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
         const version = typeof pkg.version === "string" ? pkg.version : undefined;
         if (name === PACKAGE_NAME2) {
@@ -52232,12 +52699,12 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     }
     let entries = [];
     try {
-      entries = readdirSync11(path);
+      entries = readdirSync12(path);
     } catch {
       return;
     }
     for (const entry of entries)
-      visit(join42(path, entry), depth - 1);
+      visit(join43(path, entry), depth - 1);
   };
   for (const root of cacheRoots(cwd))
     visit(root, 5);
@@ -52298,7 +52765,7 @@ async function runHealthChecks2(options) {
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
   let piPluginInstalled = false;
-  if (!existsSync49(settingsPath)) {
+  if (!existsSync51(settingsPath)) {
     if (pi) {
       add2(results, "info", `${piVersion ? `Pi ${piVersion}` : "Pi"} found; Magic Context is not installed there (run setup to add it)`);
     }
@@ -52340,7 +52807,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync49(path)) {
+    if (!existsSync51(path)) {
       if (required) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path}`);
         if (userConfigMigrationRefused) {
@@ -52386,9 +52853,12 @@ async function runHealthChecks2(options) {
     checkPiModelChains(results, pi, loadedConfig.config, options.deps);
   const storage = getMagicContextStorageResolution();
   const storageDir = storage.path;
-  const dbPath = join42(storageDir, "context.db");
+  const dbPath = join43(storageDir, "context.db");
+  if (isMagicContextStorageOutsideEngram(storageDir)) {
+    add2(results, "warn", `Magic Context storage is at ${storageDir}, outside the folder Engram backs up (~/.local/share/cortexkit/magic-context). It is not included in CortexKit backups.`);
+  }
   add2(results, "info", `Shared storage: ${storageDir} (source: ${storage.source})`);
-  const existedBeforeOpen = existsSync49(dbPath);
+  const existedBeforeOpen = existsSync51(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -52617,7 +53087,7 @@ function writeDefaultMagicContextConfig(path) {
 function repair2(plan, prompts) {
   let fixed = 0;
   for (const path of plan.reasoningAgeConfigPaths) {
-    const content = readFileSync31(path, "utf8");
+    const content = readFileSync34(path, "utf8");
     const parsed = readJsonc2(path);
     if (parsed.error)
       continue;
@@ -52643,7 +53113,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync49(configPath)) {
+    if (!existsSync51(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -52697,7 +53167,7 @@ async function runIssueFlow3(options) {
   if (options.reportPath) {
     try {
       const report = await options.deps.collectDiagnostics(options.cwd);
-      const outputPath = isAbsolute9(options.reportPath) ? options.reportPath : join42(options.cwd, options.reportPath);
+      const outputPath = isAbsolute9(options.reportPath) ? options.reportPath : join43(options.cwd, options.reportPath);
       const bundled = await bundleIssueReport2(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", { cwd: options.cwd, now: options.deps.now(), outputPath });
       options.prompts.log.info(`Report written to ${bundled.path}`);
       return 0;
@@ -52781,7 +53251,7 @@ async function runDoctor3(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "Pi",
     openDatabase: (readonly = true) => {
-      const dbPath = join42(getMagicContextStorageDir(), "context.db");
+      const dbPath = join43(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -52899,8 +53369,8 @@ var init_doctor_pi = __esm(async () => {
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync50, rmSync as rmSync11 } from "node:fs";
-import { join as join43 } from "node:path";
+import { existsSync as existsSync52, rmSync as rmSync11 } from "node:fs";
+import { join as join44 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
     return runClear();
@@ -52918,7 +53388,7 @@ async function runDoctor4(options) {
     const result = await runV22BackfillCommands({
       name: "Magic Context",
       openDatabase: (readonly = true) => {
-        const dbPath = join43(getMagicContextStorageDir(), "context.db");
+        const dbPath = join44(getMagicContextStorageDir(), "context.db");
         v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
         return v22Db;
       },
@@ -52938,7 +53408,7 @@ async function runDoctor4(options) {
     log3.warn(`Identity split check unavailable: ${error instanceof Error ? error.message : String(error)}`);
   }
   await init_migrate();
-  const sweepDbPath = join43(getMagicContextStorageDir(), "context.db");
+  const sweepDbPath = join44(getMagicContextStorageDir(), "context.db");
   let sweepDb = null;
   try {
     sweepDb = openExistingContextDatabaseForMutation(sweepDbPath);
@@ -53055,7 +53525,7 @@ async function runClear() {
           failed += 1;
           continue;
         }
-      } else if (existsSync50(item.path)) {
+      } else if (existsSync52(item.path)) {
         rmSync11(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);