@cortexkit/magic-context 0.18.0 → 0.20.0

package/dist/index.js

@@ -7805,26 +7805,70 @@ var require_src2 = __commonJS((exports, module) => {
   };
 });
 
+// ../plugin/src/shared/harness.ts
+function getHarness() {
+  return currentHarness;
+}
+var currentHarness = "opencode";
+
+// ../plugin/src/shared/data-path.ts
+import * as os from "node:os";
+import * as path from "node:path";
+function getDataDir() {
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+function getMagicContextTempDir(harness = getHarness()) {
+  return path.join(os.tmpdir(), harness, "magic-context");
+}
+function getMagicContextLogPath(harness = getHarness()) {
+  return path.join(getMagicContextTempDir(harness), "magic-context.log");
+}
+function getMagicContextHistorianDir(harness = getHarness()) {
+  return path.join(getMagicContextTempDir(harness), "historian");
+}
+function getProjectMagicContextDir(directory) {
+  return path.join(directory, ".opencode", "magic-context");
+}
+function getProjectMagicContextHistorianDir(directory) {
+  return path.join(getProjectMagicContextDir(directory), "historian");
+}
+function getOpenCodeStorageDir() {
+  return path.join(getDataDir(), "opencode", "storage");
+}
+function getMagicContextStorageDir() {
+  return path.join(getDataDir(), "cortexkit", "magic-context");
+}
+function getLegacyOpenCodeMagicContextStorageDir() {
+  return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+}
+function getCacheDir() {
+  return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+}
+function getOpenCodeCacheDir() {
+  return path.join(getCacheDir(), "opencode");
+}
+var init_data_path = () => {};
+
 // src/lib/paths.ts
 import { existsSync, readdirSync, statSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return envDir;
   if (process.platform === "win32") {
-    return join(homedir(), ".config", "opencode");
+    return join2(homedir2(), ".config", "opencode");
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir2(), ".config");
+  return join2(xdgConfig, "opencode");
 }
 function findOmoConfig(configDir) {
   const locations = [
-    join(configDir, "oh-my-openagent.jsonc"),
-    join(configDir, "oh-my-openagent.json"),
-    join(configDir, "oh-my-opencode.jsonc"),
-    join(configDir, "oh-my-opencode.json")
+    join2(configDir, "oh-my-openagent.jsonc"),
+    join2(configDir, "oh-my-openagent.json"),
+    join2(configDir, "oh-my-opencode.jsonc"),
+    join2(configDir, "oh-my-opencode.json")
   ];
   for (const loc of locations) {
     if (existsSync(loc))
@@ -7838,8 +7882,8 @@ function detectConfigPaths() {
   let opencodeConfigFormat;
   let tuiConfig;
   let tuiConfigFormat;
-  const jsoncPath = join(configDir, "opencode.jsonc");
-  const jsonPath = join(configDir, "opencode.json");
+  const jsoncPath = join2(configDir, "opencode.jsonc");
+  const jsonPath = join2(configDir, "opencode.json");
   if (existsSync(jsoncPath)) {
     opencodeConfig = jsoncPath;
     opencodeConfigFormat = "jsonc";
@@ -7850,8 +7894,8 @@ function detectConfigPaths() {
     opencodeConfig = jsonPath;
     opencodeConfigFormat = "none";
   }
-  const tuiJsoncPath = join(configDir, "tui.jsonc");
-  const tuiJsonPath = join(configDir, "tui.json");
+  const tuiJsoncPath = join2(configDir, "tui.jsonc");
+  const tuiJsonPath = join2(configDir, "tui.json");
   if (existsSync(tuiJsoncPath)) {
     tuiConfig = tuiJsoncPath;
     tuiConfigFormat = "jsonc";
@@ -7866,7 +7910,7 @@ function detectConfigPaths() {
     configDir,
     opencodeConfig,
     opencodeConfigFormat,
-    magicContextConfig: join(configDir, "magic-context.jsonc"),
+    magicContextConfig: join2(configDir, "magic-context.jsonc"),
     omoConfig: findOmoConfig(configDir),
     tuiConfig,
     tuiConfigFormat
@@ -7876,33 +7920,36 @@ function getPiAgentConfigDir() {
   const envDir = process.env.PI_CODING_AGENT_DIR?.trim();
   if (envDir)
     return envDir;
-  return join(homedir(), ".pi", "agent");
+  return join2(homedir2(), ".pi", "agent");
 }
 function getPiUserConfigPath() {
-  return join(getPiAgentConfigDir(), "magic-context.jsonc");
+  return join2(getPiAgentConfigDir(), "magic-context.jsonc");
 }
 function getPiUserExtensionsPath() {
-  return join(getPiAgentConfigDir(), "settings.json");
+  return join2(getPiAgentConfigDir(), "settings.json");
+}
+function getMagicContextLogPath2(harness) {
+  return getMagicContextLogPath(harness);
 }
-function getMagicContextLogPath() {
-  return join(tmpdir(), "magic-context.log");
+function getMagicContextHistorianDir2(harness) {
+  return getMagicContextHistorianDir(harness);
 }
 function getOpenCodePluginCacheDir() {
-  const xdg = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
-  return join(xdg, "opencode", "packages");
+  const xdg = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
+  return join2(xdg, "opencode", "packages");
 }
-function isDir(path) {
+function isDir(path2) {
   try {
-    return statSync(path).isDirectory();
+    return statSync(path2).isDirectory();
   } catch {
     return false;
   }
 }
-function dirSizeBytes(path) {
-  if (!isDir(path))
+function dirSizeBytes(path2) {
+  if (!isDir(path2))
     return 0;
   let total = 0;
-  const stack = [path];
+  const stack = [path2];
   while (stack.length > 0) {
     const cur = stack.pop();
     if (cur === undefined)
@@ -7910,7 +7957,7 @@ function dirSizeBytes(path) {
     try {
       const entries = readdirSync(cur, { withFileTypes: true });
       for (const entry of entries) {
-        const child = join(cur, entry.name);
+        const child = join2(cur, entry.name);
         if (entry.isDirectory()) {
           stack.push(child);
         } else if (entry.isFile()) {
@@ -7923,13 +7970,15 @@ function dirSizeBytes(path) {
   }
   return total;
 }
-var init_paths = () => {};
+var init_paths = __esm(() => {
+  init_data_path();
+});
 
 // src/adapters/opencode.ts
 import { execFileSync } from "node:child_process";
 import { existsSync as existsSync2, readFileSync, writeFileSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join as join3 } from "node:path";
 
 class OpenCodeAdapter {
   kind = "opencode";
@@ -7937,7 +7986,7 @@ class OpenCodeAdapter {
   pluginPackageName = PLUGIN_NAME;
   isInstalled() {
     const isWindows = process.platform === "win32";
-    const stockBin = isWindows ? join2(homedir2(), ".opencode", "bin", "opencode.exe") : join2(homedir2(), ".opencode", "bin", "opencode");
+    const stockBin = isWindows ? join3(homedir3(), ".opencode", "bin", "opencode.exe") : join3(homedir3(), ".opencode", "bin", "opencode");
     if (existsSync2(stockBin))
       return true;
     const probe = isWindows ? { cmd: "where", args: ["opencode"] } : { cmd: "command", args: ["-v", "opencode"] };
@@ -8112,15 +8161,15 @@ class OpenCodeAdapter {
     return "Install OpenCode: curl -fsSL https://opencode.ai/install | bash";
   }
   getPluginCacheInfo() {
-    const path = getOpenCodePluginCacheDir();
+    const path2 = getOpenCodePluginCacheDir();
     return {
-      path,
-      exists: existsSync2(path),
-      sizeBytes: dirSizeBytes(path)
+      path: path2,
+      exists: existsSync2(path2),
+      sizeBytes: dirSizeBytes(path2)
     };
   }
   getLogPath() {
-    return getMagicContextLogPath();
+    return getMagicContextLogPath2("opencode");
   }
   getInstalledPluginVersion() {
     const cacheDir = getOpenCodePluginCacheDir();
@@ -8185,8 +8234,8 @@ var init_opencode = __esm(() => {
 // src/lib/pi-helpers.ts
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 function getStaticModels() {
   return [...STATIC_MODELS];
 }
@@ -8208,7 +8257,7 @@ function detectPiBinary() {
     if (first)
       return { path: first, source: "path" };
   }
-  const homeCandidate = process.platform === "win32" ? join3(homedir3(), ".pi", "bin", "pi.cmd") : join3(homedir3(), ".pi", "bin", "pi");
+  const homeCandidate = process.platform === "win32" ? join4(homedir4(), ".pi", "bin", "pi.cmd") : join4(homedir4(), ".pi", "bin", "pi");
   if (existsSync3(homeCandidate))
     return { path: homeCandidate, source: "home" };
   return null;
@@ -8251,7 +8300,7 @@ function parseModelListOutput(output) {
     if (!line || line.toLowerCase().includes("usage:"))
       continue;
     const token = line.split(/\s+/)[0]?.trim().replace(/,$/, "");
-    if (!token || !token.includes("/"))
+    if (!token?.includes("/"))
       continue;
     if (/^https?:\/\//.test(token))
       continue;
@@ -8457,13 +8506,13 @@ class PiAdapter {
     }
   }
   getInstallHint() {
-    return "Install Pi: https://pi.coding/install (npm: @mariozechner/pi-coding-agent)";
+    return "Install Pi: https://pi.coding/install (npm: @earendil-works/pi-coding-agent)";
   }
   getPluginCacheInfo() {
     return { path: null, exists: false, sizeBytes: 0 };
   }
   getLogPath() {
-    return getMagicContextLogPath();
+    return getMagicContextLogPath2("pi");
   }
   getInstalledPluginVersion() {
     const piBin = detectPiBinary();
@@ -10327,17 +10376,17 @@ function detectConfigFile(basePath) {
 var init_jsonc_parser = () => {};
 
 // ../plugin/src/shared/opencode-config-dir.ts
-import { homedir as homedir4 } from "node:os";
-import { join as join4, resolve } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { join as join5, resolve } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
     return resolve(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join4(homedir4(), ".config", "opencode");
+    return join5(homedir5(), ".config", "opencode");
   }
-  return join4(process.env.XDG_CONFIG_HOME || join4(homedir4(), ".config"), "opencode");
+  return join5(process.env.XDG_CONFIG_HOME || join5(homedir5(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -10346,16 +10395,16 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir2(options);
   return {
     configDir,
-    configJson: join4(configDir, "opencode.json"),
-    configJsonc: join4(configDir, "opencode.jsonc"),
-    packageJson: join4(configDir, "package.json"),
-    omoConfig: join4(configDir, "magic-context.jsonc")
+    configJson: join5(configDir, "opencode.json"),
+    configJsonc: join5(configDir, "opencode.jsonc"),
+    packageJson: join5(configDir, "package.json"),
+    omoConfig: join5(configDir, "magic-context.jsonc")
   };
 }
 var init_opencode_config_dir = () => {};
 
 // ../plugin/src/shared/conflict-detector.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function detectConflicts(directory) {
   const conflicts = {
     compactionAuto: false,
@@ -10412,8 +10461,8 @@ function checkCompaction(directory) {
   return { auto: true, prune: false };
 }
 function readProjectCompaction(directory) {
-  const dotOcJsonc = join5(directory, ".opencode", "opencode.jsonc");
-  const dotOcJson = join5(directory, ".opencode", "opencode.json");
+  const dotOcJsonc = join6(directory, ".opencode", "opencode.jsonc");
+  const dotOcJson = join6(directory, ".opencode", "opencode.json");
   const dotOcConfig = readJsoncFile(dotOcJsonc) ?? readJsoncFile(dotOcJson);
   if (dotOcConfig?.compaction) {
     const c2 = dotOcConfig.compaction;
@@ -10421,8 +10470,8 @@ function readProjectCompaction(directory) {
       return { auto: c2.auto === true, prune: c2.prune === true, resolved: true };
     }
   }
-  const rootJsonc = join5(directory, "opencode.jsonc");
-  const rootJson = join5(directory, "opencode.json");
+  const rootJsonc = join6(directory, "opencode.jsonc");
+  const rootJson = join6(directory, "opencode.json");
   const rootConfig = readJsoncFile(rootJsonc) ?? readJsoncFile(rootJson);
   if (rootConfig?.compaction) {
     const c2 = rootConfig.compaction;
@@ -10476,10 +10525,10 @@ function collectPluginEntries(directory) {
     }
   };
   for (const configPath of [
-    join5(directory, ".opencode", "opencode.jsonc"),
-    join5(directory, ".opencode", "opencode.json"),
-    join5(directory, "opencode.jsonc"),
-    join5(directory, "opencode.json")
+    join6(directory, ".opencode", "opencode.jsonc"),
+    join6(directory, ".opencode", "opencode.json"),
+    join6(directory, "opencode.jsonc"),
+    join6(directory, "opencode.json")
   ]) {
     const config = readJsoncFile(configPath);
     pushFrom(config?.plugin);
@@ -10520,7 +10569,7 @@ function readOmoDisabledHooks(directory) {
   try {
     const paths = getOpenCodeConfigPaths({ binary: "opencode" });
     for (const name of configNames) {
-      const configPath = join5(paths.configDir, name);
+      const configPath = join6(paths.configDir, name);
       const config = readJsoncFile(configPath);
       if (config?.disabled_hooks) {
         for (const hook of config.disabled_hooks) {
@@ -10530,7 +10579,7 @@ function readOmoDisabledHooks(directory) {
     }
   } catch {}
   for (const name of configNames) {
-    const config = readJsoncFile(join5(directory, name));
+    const config = readJsoncFile(join6(directory, name));
     if (config?.disabled_hooks) {
       for (const hook of config.disabled_hooks) {
         disabled.add(hook);
@@ -10548,11 +10597,8 @@ var init_conflict_detector = __esm(() => {
 });
 
 // ../plugin/src/shared/conflict-fixer.ts
-import { existsSync as existsSync6, mkdirSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join6 } from "node:path";
-function ensureParentDir(filePath) {
-  mkdirSync(dirname3(filePath), { recursive: true });
-}
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10561,13 +10607,17 @@ function asStringArray(value) {
 }
 function readConfig(filePath) {
   if (!existsSync6(filePath)) {
-    return {};
+    return null;
+  }
+  try {
+    const parsed = import_comment_json3.parse(readFileSync4(filePath, "utf-8"));
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
   }
-  return readJsoncFile(filePath);
 }
 function writeConfig(filePath, config) {
-  ensureParentDir(filePath);
-  writeFileSync3(filePath, `${JSON.stringify(config, null, 2)}
+  writeFileSync3(filePath, `${import_comment_json3.stringify(config, null, 2)}
 `);
 }
 function resolveUserOpenCodeConfigPath() {
@@ -10579,12 +10629,14 @@ function resolveUserOpenCodeConfigPath() {
 function collectOpenCodeConfigPaths(directory) {
   const paths = new Set;
   const userConfig = resolveUserOpenCodeConfigPath();
-  paths.add(userConfig);
+  if (existsSync6(userConfig)) {
+    paths.add(userConfig);
+  }
   for (const filePath of [
-    join6(directory, ".opencode", "opencode.jsonc"),
-    join6(directory, ".opencode", "opencode.json"),
-    join6(directory, "opencode.jsonc"),
-    join6(directory, "opencode.json")
+    join7(directory, ".opencode", "opencode.jsonc"),
+    join7(directory, ".opencode", "opencode.json"),
+    join7(directory, "opencode.jsonc"),
+    join7(directory, "opencode.json")
   ]) {
     if (existsSync6(filePath)) {
       paths.add(filePath);
@@ -10596,8 +10648,8 @@ function collectOmoConfigPaths(directory) {
   const paths = new Set;
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   for (const fileName of OMO_CONFIG_NAMES) {
-    const userPath = join6(configDir, fileName);
-    const projectPath = join6(directory, fileName);
+    const userPath = join7(configDir, fileName);
+    const projectPath = join7(directory, fileName);
     if (existsSync6(userPath)) {
       paths.add(userPath);
     }
@@ -10605,11 +10657,15 @@ function collectOmoConfigPaths(directory) {
       paths.add(projectPath);
     }
   }
-  if (paths.size === 0) {
-    paths.add(join6(configDir, "oh-my-openagent.json"));
-  }
   return [...paths];
 }
+function filterDcpPluginEntries(entries) {
+  const plugins = entries.filter((entry) => {
+    const name = extractPluginName(entry);
+    return name ? !matchesPackageName(name, DCP_PACKAGE_NAMES) : true;
+  });
+  return { plugins, removed: plugins.length !== entries.length };
+}
 function fixConflicts(directory, conflicts) {
   const actions = [];
   let updatedCompaction = false;
@@ -10623,7 +10679,7 @@ function fixConflicts(directory, conflicts) {
       }
       let changed = false;
       if (conflicts.compactionAuto || conflicts.compactionPrune) {
-        const compaction = isRecord(config.compaction) ? { ...config.compaction } : {};
+        const compaction = isRecord(config.compaction) ? config.compaction : {};
         if (compaction.auto !== false) {
           compaction.auto = false;
           changed = true;
@@ -10637,10 +10693,10 @@ function fixConflicts(directory, conflicts) {
         config.compaction = compaction;
       }
       if (conflicts.dcpPlugin) {
-        const plugins = asStringArray(config.plugin);
-        const filteredPlugins = plugins.filter((plugin) => !plugin.includes("opencode-dcp"));
-        if (filteredPlugins.length !== plugins.length) {
-          config.plugin = filteredPlugins;
+        const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+        const filtered = filterDcpPluginEntries(plugins);
+        if (filtered.removed) {
+          config.plugin = filtered.plugins;
           changed = true;
           removedDcpPlugin = true;
         }
@@ -10695,10 +10751,11 @@ function fixConflicts(directory, conflicts) {
   }
   return actions;
 }
-var CONFLICTING_OMO_HOOKS, OMO_CONFIG_NAMES;
+var import_comment_json3, CONFLICTING_OMO_HOOKS, OMO_CONFIG_NAMES;
 var init_conflict_fixer = __esm(() => {
-  init_jsonc_parser();
+  init_conflict_detector();
   init_opencode_config_dir();
+  import_comment_json3 = __toESM(require_src2(), 1);
   CONFLICTING_OMO_HOOKS = [
     "context-window-monitor",
     "preemptive-compaction",
@@ -10790,30 +10847,30 @@ function buildModelSelection2(allModels, role) {
 var init_opencode_helpers = () => {};
 
 // src/commands/setup-opencode.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 function ensureDir3(dir) {
   if (!existsSync7(dir)) {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync(dir, { recursive: true });
   }
 }
-function readJsonc(path) {
-  const content = readFileSync4(path, "utf-8");
+function readJsonc(path2) {
+  const content = readFileSync5(path2, "utf-8");
   try {
-    return import_comment_json3.parse(content);
+    return import_comment_json4.parse(content);
   } catch (err) {
-    console.error(`  ⚠ Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
+    console.error(`  ⚠ Failed to parse ${path2}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
 function addPluginToOpenCodeConfig(configPath, format) {
-  ensureDir3(dirname4(configPath));
+  ensureDir3(dirname3(configPath));
   if (format === "none") {
     const config = {
       plugin: [PLUGIN_ENTRY2],
       compaction: { auto: false, prune: false }
     };
-    writeFileSync4(configPath, `${import_comment_json3.stringify(config, null, 2)}
+    writeFileSync4(configPath, `${import_comment_json4.stringify(config, null, 2)}
 `);
     return;
   }
@@ -10833,13 +10890,13 @@ function addPluginToOpenCodeConfig(configPath, format) {
   compaction.auto = false;
   compaction.prune = false;
   existing.compaction = compaction;
-  writeFileSync4(configPath, `${import_comment_json3.stringify(existing, null, 2)}
+  writeFileSync4(configPath, `${import_comment_json4.stringify(existing, null, 2)}
 `);
 }
 function addPluginToTuiConfig(configPath, format) {
-  ensureDir3(dirname4(configPath));
+  ensureDir3(dirname3(configPath));
   if (format === "none") {
-    writeFileSync4(configPath, `${import_comment_json3.stringify({ plugin: [PLUGIN_ENTRY2] }, null, 2)}
+    writeFileSync4(configPath, `${import_comment_json4.stringify({ plugin: [PLUGIN_ENTRY2] }, null, 2)}
 `);
     return;
   }
@@ -10855,9 +10912,42 @@ function addPluginToTuiConfig(configPath, format) {
     rawPlugins.push(PLUGIN_ENTRY2);
   }
   existing.plugin = rawPlugins;
-  writeFileSync4(configPath, `${import_comment_json3.stringify(existing, null, 2)}
+  writeFileSync4(configPath, `${import_comment_json4.stringify(existing, null, 2)}
 `);
 }
+function findDcpPluginIndexes(plugins) {
+  return plugins.map((plugin, index) => matchesPluginEntry(plugin, DCP_PLUGIN_NAME) ? index : -1).filter((index) => index >= 0);
+}
+function pluginEntryName(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string")
+    return entry[0];
+  return String(entry);
+}
+async function resolveDcpConflictBeforeSetup(configPath, format) {
+  if (format === "none")
+    return;
+  const ocConfig = readJsonc(configPath);
+  if (!ocConfig)
+    return;
+  const plugins = Array.isArray(ocConfig.plugin) ? ocConfig.plugin : [];
+  const dcpIndexes = findDcpPluginIndexes(plugins);
+  if (dcpIndexes.length === 0)
+    return;
+  log.warn(`Found conflicting plugin: ${pluginEntryName(plugins[dcpIndexes[0]])}`);
+  log.message(`opencode-dcp (Dynamic Context Pruning) and Magic Context both manage context.
+` + "Running both simultaneously will cause unpredictable behavior.");
+  const shouldRemove = await confirm("Remove opencode-dcp from your config?", true);
+  if (shouldRemove) {
+    ocConfig.plugin = plugins.filter((_plugin, index) => !dcpIndexes.includes(index));
+    writeFileSync4(configPath, `${import_comment_json4.stringify(ocConfig, null, 2)}
+`);
+    log.success("Removed opencode-dcp from plugin list");
+  } else {
+    log.warn("Skipped — you may experience context management conflicts");
+  }
+}
 function writeMagicContextConfig(configPath, options) {
   const config = (existsSync7(configPath) ? readJsonc(configPath) : null) ?? {};
   if (!config.$schema) {
@@ -10896,7 +10986,7 @@ function writeMagicContextConfig(configPath, options) {
     cacheTtl["anthropic/claude-opus-4-6"] = "59m";
     config.cache_ttl = cacheTtl;
   }
-  writeFileSync4(configPath, `${import_comment_json3.stringify(config, null, 2)}
+  writeFileSync4(configPath, `${import_comment_json4.stringify(config, null, 2)}
 `);
 }
 async function runSetup() {
@@ -10926,32 +11016,11 @@ async function runSetup() {
   }
   const paths = detectConfigPaths();
   const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync7(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
+  await resolveDcpConflictBeforeSetup(paths.opencodeConfig, paths.opencodeConfigFormat);
   addPluginToOpenCodeConfig(paths.opencodeConfig, paths.opencodeConfigFormat);
   log.success(`Plugin added to ${paths.opencodeConfig}`);
   log.info("Disabled built-in compaction (auto=false, prune=false)");
   log.message("Magic Context handles context management — built-in compaction would interfere");
-  if (paths.opencodeConfigFormat !== "none") {
-    const ocConfig = readJsonc(paths.opencodeConfig);
-    if (ocConfig) {
-      const plugins = ocConfig.plugin ?? [];
-      const dcpIndex = plugins.findIndex((p2) => p2.startsWith("@tarquinen/opencode-dcp"));
-      if (dcpIndex !== -1) {
-        log.warn(`Found conflicting plugin: ${plugins[dcpIndex]}`);
-        log.message(`opencode-dcp (Dynamic Context Pruning) and Magic Context both manage context.
-` + "Running both simultaneously will cause unpredictable behavior.");
-        const shouldRemove = await confirm("Remove opencode-dcp from your config?", true);
-        if (shouldRemove) {
-          plugins.splice(dcpIndex, 1);
-          ocConfig.plugin = plugins;
-          writeFileSync4(paths.opencodeConfig, `${import_comment_json3.stringify(ocConfig, null, 2)}
-`);
-          log.success("Removed opencode-dcp from plugin list");
-        } else {
-          log.warn("Skipped — you may experience context management conflicts");
-        }
-      }
-    }
-  }
   if (hadExistingSetup) {
     const conflicts = detectConflicts(process.cwd());
     if (conflicts.hasConflict) {
@@ -11084,7 +11153,7 @@ async function runSetup() {
   outro("Run 'opencode' to start!");
   return 0;
 }
-var import_comment_json3, PLUGIN_NAME3 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY2 = "@cortexkit/opencode-magic-context@latest";
+var import_comment_json4, PLUGIN_NAME3 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY2 = "@cortexkit/opencode-magic-context@latest", DCP_PLUGIN_NAME = "@tarquinen/opencode-dcp";
 var init_setup_opencode = __esm(() => {
   init_conflict_detector();
   init_conflict_fixer();
@@ -11092,26 +11161,77 @@ var init_setup_opencode = __esm(() => {
   init_opencode_helpers();
   init_paths();
   init_prompts();
-  import_comment_json3 = __toESM(require_src2(), 1);
+  import_comment_json4 = __toESM(require_src2(), 1);
+});
+
+// src/lib/pi-package-entry.ts
+function stripNpmPrefix(value) {
+  return value.startsWith("npm:") ? value.slice("npm:".length) : value;
+}
+function packageNameFromSpecifier(value) {
+  const normalized = stripNpmPrefix(value.trim());
+  if (!normalized)
+    return normalized;
+  if (normalized.startsWith("@")) {
+    const slash = normalized.indexOf("/");
+    if (slash < 0)
+      return normalized;
+    const versionAt2 = normalized.indexOf("@", slash + 1);
+    return versionAt2 > 0 ? normalized.slice(0, versionAt2) : normalized;
+  }
+  const versionAt = normalized.indexOf("@");
+  return versionAt > 0 ? normalized.slice(0, versionAt) : normalized;
+}
+function getPiPackageEntryName(entry) {
+  if (typeof entry === "string")
+    return packageNameFromSpecifier(entry);
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const name = entry.name;
+    if (typeof name === "string")
+      return packageNameFromSpecifier(name);
+  }
+  return null;
+}
+function isPiMagicContextPackageEntry(entry) {
+  return getPiPackageEntryName(entry) === PI_MAGIC_CONTEXT_PACKAGE_NAME;
+}
+function hasPiMagicContextPackage(entries) {
+  return entries.some(isPiMagicContextPackageEntry);
+}
+function describePiPackageEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  const name = getPiPackageEntryName(entry);
+  if (name)
+    return name;
+  try {
+    return JSON.stringify(entry);
+  } catch {
+    return String(entry);
+  }
+}
+var PI_MAGIC_CONTEXT_PACKAGE_NAME = "@cortexkit/pi-magic-context";
+var init_pi_package_entry = __esm(() => {
+  init_pi_helpers();
 });
 
 // src/commands/setup-pi.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
-function ensureDir4(path) {
-  if (!existsSync8(path))
-    mkdirSync3(path, { recursive: true });
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+function ensureDir4(path2) {
+  if (!existsSync8(path2))
+    mkdirSync2(path2, { recursive: true });
 }
 async function getDefaultPrompts() {
   const { promptIO: promptIO2 } = await Promise.resolve().then(() => (init_prompts(), exports_prompts));
   return promptIO2;
 }
-function readJsonc2(path) {
+function readJsonc2(path2) {
   try {
-    return import_comment_json4.parse(readFileSync5(path, "utf-8"));
+    return import_comment_json5.parse(readFileSync6(path2, "utf-8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.warn(`Could not parse ${path}: ${message}`);
+    console.warn(`Could not parse ${path2}: ${message}`);
     return null;
   }
 }
@@ -11123,12 +11243,12 @@ function compactObject(obj) {
   return obj;
 }
 function comparePiVersion(a, b2) {
-  const parse = (v2) => {
+  const parse2 = (v2) => {
     const match = v2.match(/(\d+)\.(\d+)\.(\d+)/);
     return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
   };
-  const left = parse(a);
-  const right = parse(b2);
+  const left = parse2(a);
+  const right = parse2(b2);
   if (!left || !right)
     return 0;
   for (let i = 0;i < 3; i += 1) {
@@ -11140,19 +11260,19 @@ function comparePiVersion(a, b2) {
   return 0;
 }
 function writePiSettingsPackage(settingsPath, packageSource = PI_PACKAGE_SOURCE) {
-  ensureDir4(dirname5(settingsPath));
+  ensureDir4(dirname4(settingsPath));
   const settings = existsSync8(settingsPath) ? readJsonc2(settingsPath) ?? {} : {};
-  const packages = Array.isArray(settings.packages) ? settings.packages.filter((value) => typeof value === "string") : [];
-  const hasPackage = packages.some((source) => source === packageSource || source === packageSource.replace(/^npm:/, "") || source.includes("pi-magic-context"));
+  const packages = Array.isArray(settings.packages) ? settings.packages : [];
+  const hasPackage = hasPiMagicContextPackage(packages);
   if (!hasPackage)
     packages.push(packageSource);
   settings.packages = packages;
-  writeFileSync5(settingsPath, `${import_comment_json4.stringify(settings, null, 2)}
+  writeFileSync5(settingsPath, `${import_comment_json5.stringify(settings, null, 2)}
 `);
   return !hasPackage;
 }
 function writeMagicContextConfig2(configPath, options) {
-  ensureDir4(dirname5(configPath));
+  ensureDir4(dirname4(configPath));
   const config = existsSync8(configPath) ? readJsonc2(configPath) ?? {} : {};
   if (!config.$schema) {
     config.$schema = "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json";
@@ -11180,7 +11300,7 @@ function writeMagicContextConfig2(configPath, options) {
     };
   }
   config.embedding = options.embedding;
-  writeFileSync5(configPath, `${import_comment_json4.stringify(config, null, 2)}
+  writeFileSync5(configPath, `${import_comment_json5.stringify(config, null, 2)}
 `);
 }
 async function chooseModel(prompts, allModels, role, message) {
@@ -11233,11 +11353,11 @@ async function runSetup2(options = {}) {
   }
   const version = env.getPiVersion(pi.path);
   spinner2.stop(version ? `Pi ${version} detected at ${pi.path}` : `Pi detected at ${pi.path}`);
-  const MIN_PI_VERSION = "0.71.0";
+  const MIN_PI_VERSION = "0.74.0";
   if (version && comparePiVersion(version, MIN_PI_VERSION) < 0) {
     prompts.log.warn(`Pi ${version} is older than the required ${MIN_PI_VERSION}.
-Magic Context spawns subagents with \`--extension <path>\` (long form), which Pi 0.71.0 introduced. Older Pi versions hard-fail with "Unknown option" when historian/dreamer/sidekick tries to run.
-Run \`pi update\` (or \`npm install -g @mariozechner/pi-coding-agent@latest\`) before continuing.`);
+Pi 0.74.0 renamed the npm package from \`@mariozechner/pi-coding-agent\` to \`@earendil-works/pi-coding-agent\`. Magic Context's peer dependency targets the new scope, so older Pi installs cannot load this extension.
+Run \`pi update --self\` (or \`npm install -g @earendil-works/pi-coding-agent@latest\`) before continuing.`);
     const proceed = await prompts.confirm("Continue with setup anyway? (subagents will fail at runtime)", false);
     if (!proceed) {
       prompts.outro("Setup cancelled — upgrade Pi and try again.");
@@ -11306,11 +11426,12 @@ Run \`pi update\` (or \`npm install -g @mariozechner/pi-coding-agent@latest\`) b
   prompts.outro("Start a Pi session and try /ctx-aug");
   return 0;
 }
-var import_comment_json4, DEFAULT_ENV;
+var import_comment_json5, DEFAULT_ENV;
 var init_setup_pi = __esm(() => {
   init_paths();
   init_pi_helpers();
-  import_comment_json4 = __toESM(require_src2(), 1);
+  init_pi_package_entry();
+  import_comment_json5 = __toESM(require_src2(), 1);
   DEFAULT_ENV = {
     detectPiBinary,
     getPiVersion,
@@ -11390,29 +11511,6 @@ var init_setup = __esm(() => {
   init_setup_pi();
 });
 
-// ../plugin/src/shared/data-path.ts
-import * as os from "node:os";
-import * as path from "node:path";
-function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
-}
-function getOpenCodeStorageDir() {
-  return path.join(getDataDir(), "opencode", "storage");
-}
-function getMagicContextStorageDir() {
-  return path.join(getDataDir(), "cortexkit", "magic-context");
-}
-function getLegacyOpenCodeMagicContextStorageDir() {
-  return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
-}
-function getCacheDir() {
-  return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
-}
-function getOpenCodeCacheDir() {
-  return path.join(getCacheDir(), "opencode");
-}
-var init_data_path = () => {};
-
 // ../../node_modules/.bun/nanotar@0.3.0/node_modules/nanotar/dist/index.mjs
 function parseTar(data, opts) {
   const buffer = data.buffer || data;
@@ -11591,8 +11689,16 @@ var init_dist5 = __esm(() => {
 
 // ../plugin/src/shared/logger.ts
 import * as fs from "node:fs";
-import * as os2 from "node:os";
 import * as path2 from "node:path";
+function ensureDir5(filePath) {
+  const dir = path2.dirname(filePath);
+  if (dir === lastEnsuredDir)
+    return;
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    lastEnsuredDir = dir;
+  } catch {}
+}
 function flush() {
   if (flushTimer) {
     clearTimeout(flushTimer);
@@ -11603,6 +11709,8 @@ function flush() {
   const data = buffer.join("");
   buffer = [];
   try {
+    const logFile = getMagicContextLogPath();
+    ensureDir5(logFile);
     fs.appendFileSync(logFile, data);
   } catch {}
 }
@@ -11630,9 +11738,9 @@ ${data.stack}` : ""}` : ` ${JSON.stringify(data)}`;
     }
   } catch {}
 }
-var logFile, isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
+var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, lastEnsuredDir = null;
 var init_logger = __esm(() => {
-  logFile = path2.join(os2.tmpdir(), "magic-context.log");
+  init_data_path();
   buffer = [];
   if (!isTestEnv) {
     process.on("exit", flush);
@@ -11808,15 +11916,15 @@ __export(exports_migrate, {
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join9 } from "node:path";
 function defaultOpenCodeDbPath() {
-  return join10(homedir6(), ".local", "share", "opencode", "opencode.db");
+  return join9(homedir6(), ".local", "share", "opencode", "opencode.db");
 }
 function defaultCortexkitDbPath() {
-  return join10(getMagicContextStorageDir(), "context.db");
+  return join9(getMagicContextStorageDir(), "context.db");
 }
 function defaultPiSessionsRoot() {
-  return join10(homedir6(), ".pi", "agent", "sessions");
+  return join9(homedir6(), ".pi", "agent", "sessions");
 }
 function defaultFs() {
   return { existsSync: existsSync10, mkdirSync: mkdirSync5, writeFileSync: writeFileSync7 };
@@ -12242,7 +12350,7 @@ function migrateOpenCodeSessionToPi(opts) {
     const provider = opts.provider ?? model.provider;
     const modelId = opts.modelId ?? model.modelId;
     const cwd = session.directory ?? session.path ?? process.cwd();
-    const outputDir = join10(piSessionsRoot, projectPathToPiDirSlug(cwd));
+    const outputDir = join9(piSessionsRoot, projectPathToPiDirSlug(cwd));
     const buildResult = buildPiEntries({
       session,
       messages,
@@ -12268,7 +12376,7 @@ function migrateOpenCodeSessionToPi(opts) {
       });
     }
     const compactionMarker = insertCompactionMarker(buildResult.entries, copyResult.lastCompartmentEndPiEntryId);
-    const outputPath = join10(outputDir, `${formatPiFilenameTimestamp(now)}_${buildResult.piSessionId}.jsonl`);
+    const outputPath = join9(outputDir, `${formatPiFilenameTimestamp(now)}_${buildResult.piSessionId}.jsonl`);
     const jsonl = `${buildResult.entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `;
@@ -13326,7 +13434,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
     throw e2;
   }
   return result.value;
-}, parse, _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+}, parse2, _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
   if (result instanceof Promise)
@@ -13381,7 +13489,7 @@ var init_parse = __esm(() => {
   init_core();
   init_errors();
   init_util();
-  parse = /* @__PURE__ */ _parse($ZodRealError);
+  parse2 = /* @__PURE__ */ _parse($ZodRealError);
   parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
   safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
   safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
@@ -16140,10 +16248,10 @@ var init_schemas = __esm(() => {
         throw new Error("implement() must be called with a function");
       }
       return function(...args) {
-        const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
+        const parsedArgs = inst._def.input ? parse2(inst._def.input, args) : args;
         const result = Reflect.apply(func, this, parsedArgs);
         if (inst._def.output) {
-          return parse(inst._def.output, result);
+          return parse2(inst._def.output, result);
         }
         return result;
       };
@@ -23628,7 +23736,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -23889,7 +23997,7 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -24336,7 +24444,7 @@ __export(exports_core2, {
   process: () => process2,
   prettifyError: () => prettifyError,
   parseAsync: () => parseAsync,
-  parse: () => parse,
+  parse: () => parse2,
   meta: () => meta,
   locales: () => exports_locales,
   isValidJWT: () => isValidJWT,
@@ -24737,11 +24845,11 @@ var init_errors2 = __esm(() => {
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/parse.js
-var parse3, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
+var parse4, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
 var init_parse2 = __esm(() => {
   init_core2();
   init_errors2();
-  parse3 = /* @__PURE__ */ _parse(ZodRealError);
+  parse4 = /* @__PURE__ */ _parse(ZodRealError);
   parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
   safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
   safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -25461,7 +25569,7 @@ var init_schemas2 = __esm(() => {
     inst.def = def;
     inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
-    inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
+    inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
     inst.safeParse = (data, params) => safeParse2(inst, data, params);
     inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
     inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -26813,7 +26921,7 @@ __export(exports_external, {
   pipe: () => pipe,
   partialRecord: () => partialRecord,
   parseAsync: () => parseAsync2,
-  parse: () => parse3,
+  parse: () => parse4,
   overwrite: () => _overwrite,
   optional: () => optional,
   object: () => object,
@@ -27236,7 +27344,7 @@ var init_magic_context = __esm(() => {
 });
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync11, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { dirname as dirname7, isAbsolute, resolve as resolve2 } from "node:path";
 function substituteConfigVariables(input) {
@@ -27283,7 +27391,7 @@ function substituteConfigVariables(input) {
     }
     let contents;
     try {
-      contents = readFileSync6(filePath, "utf-8").trim();
+      contents = readFileSync7(filePath, "utf-8").trim();
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -27301,22 +27409,22 @@ var init_variable = __esm(() => {
 });
 
 // ../plugin/src/config/index.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 function getUserConfigBasePath() {
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join11(homedir8(), ".config");
-  return join11(configRoot, "opencode", CONFIG_FILE_BASENAME);
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join10(homedir8(), ".config");
+  return join10(configRoot, "opencode", CONFIG_FILE_BASENAME);
 }
 function getProjectConfigBasePath(directory) {
-  return join11(directory, ".opencode", CONFIG_FILE_BASENAME);
+  return join10(directory, ".opencode", CONFIG_FILE_BASENAME);
 }
 function loadConfigFile(configPath) {
   try {
     if (!existsSync12(configPath)) {
       return null;
     }
-    const rawText = readFileSync7(configPath, "utf-8");
+    const rawText = readFileSync8(configPath, "utf-8");
     const substituted = substituteConfigVariables({ text: rawText, configPath });
     return {
       config: parseJsonc3(substituted.text),
@@ -27327,34 +27435,20 @@ function loadConfigFile(configPath) {
     return null;
   }
 }
-function mergeConfigs(base, override, options = {}) {
-  const config2 = {
-    ...base,
-    ...override,
-    auto_update: options.allowUserOnlyFields ? override.auto_update : base.auto_update,
-    memory: {
-      ...base.memory ?? {},
-      ...override.memory ?? {}
-    },
-    embedding: override.embedding ?? base.embedding,
-    historian: override.historian ?? base.historian,
-    dreamer: override.dreamer ? {
-      ...base.dreamer ?? {},
-      ...override.dreamer
-    } : base.dreamer,
-    sidekick: override.sidekick ? {
-      ...base.sidekick ?? {},
-      ...override.sidekick
-    } : base.sidekick,
-    disabled_hooks: [
-      ...new Set([...base.disabled_hooks ?? [], ...override.disabled_hooks ?? []])
-    ],
-    command: {
-      ...base.command ?? {},
-      ...override.command ?? {}
+function deepMergeRawConfig(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal) && overrideVal !== null && typeof overrideVal === "object" && !Array.isArray(overrideVal)) {
+      result[key] = deepMergeRawConfig(baseVal, overrideVal);
+    } else if (key === "disabled_hooks" && Array.isArray(baseVal) && Array.isArray(overrideVal)) {
+      result[key] = [...new Set([...baseVal, ...overrideVal])];
+    } else {
+      result[key] = overrideVal;
     }
-  };
-  return config2;
+  }
+  return result;
 }
 function getProjectUserOnlyFields(config2) {
   return "auto_update" in config2 ? ["auto_update"] : [];
@@ -27490,35 +27584,43 @@ function parsePluginConfig(rawConfig) {
 }
 function loadPluginConfig(directory) {
   const userDetected = detectConfigFile(getUserConfigBasePath());
-  const rootDetected = detectConfigFile(join11(directory, CONFIG_FILE_BASENAME));
+  const rootDetected = detectConfigFile(join10(directory, CONFIG_FILE_BASENAME));
   const dotOpenCodeDetected = detectConfigFile(getProjectConfigBasePath(directory));
   const projectDetected = rootDetected.format !== "none" ? rootDetected : dotOpenCodeDetected;
   const userLoaded = userDetected.format === "none" ? null : loadConfigFile(userDetected.path);
   const projectLoaded = projectDetected.format === "none" ? null : loadConfigFile(projectDetected.path);
-  let config2 = parsePluginConfig({});
   const allWarnings = [];
+  let mergedRaw = {};
   if (userLoaded) {
     allWarnings.push(...userLoaded.warnings.map((w3) => `[user config] ${w3}`));
-    const parsed = parsePluginConfig(userLoaded.config);
-    if (parsed.configWarnings?.length) {
-      allWarnings.push(...parsed.configWarnings.map((w3) => `[user config] ${w3}`));
-    }
-    config2 = mergeConfigs(config2, parsed, { allowUserOnlyFields: true });
+    mergedRaw = deepMergeRawConfig(mergedRaw, userLoaded.config);
   }
   if (projectLoaded) {
     allWarnings.push(...projectLoaded.warnings.map((w3) => `[project config] ${w3}`));
-    const parsed = parsePluginConfig(projectLoaded.config);
-    if (parsed.configWarnings?.length) {
-      allWarnings.push(...parsed.configWarnings.map((w3) => `[project config] ${w3}`));
-    }
-    const strippedUserOnlyFields = getProjectUserOnlyFields(projectLoaded.config);
+    const projectRaw = { ...projectLoaded.config };
+    const strippedUserOnlyFields = getProjectUserOnlyFields(projectRaw);
     if (strippedUserOnlyFields.length > 0) {
+      for (const key of strippedUserOnlyFields) {
+        delete projectRaw[key];
+      }
       allWarnings.push(`[project config] Ignoring ${strippedUserOnlyFields.join(", ")} from project config (security: these settings only honor user-level config)`);
     }
-    config2 = mergeConfigs(config2, parsed);
+    mergedRaw = deepMergeRawConfig(mergedRaw, projectRaw);
+  }
+  const config2 = parsePluginConfig(mergedRaw);
+  if (config2.configWarnings?.length) {
+    allWarnings.push(...config2.configWarnings.map((w3) => {
+      if (userLoaded && projectLoaded)
+        return `[config] ${w3}`;
+      if (userLoaded)
+        return `[user config] ${w3}`;
+      return `[project config] ${w3}`;
+    }));
   }
   if (allWarnings.length > 0) {
     config2.configWarnings = allWarnings;
+  } else if ("configWarnings" in config2) {
+    config2.configWarnings = undefined;
   }
   return config2;
 }
@@ -27529,6 +27631,78 @@ var init_config = __esm(() => {
   init_variable();
 });
 
+// ../plugin/src/features/magic-context/key-files/aft-availability.ts
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join11 } from "node:path";
+function parseConfig(path4) {
+  if (!existsSync13(path4))
+    return null;
+  return import_comment_json6.parse(readFileSync9(path4, "utf-8"));
+}
+function entryMatchesAft(entry) {
+  const value = Array.isArray(entry) ? entry[0] : entry;
+  return typeof value === "string" && (value.includes("@cortexkit/aft") || value.includes("aft-opencode") || value.includes("aft-pi"));
+}
+function hasAftInArray(value) {
+  return Array.isArray(value) && value.some(entryMatchesAft);
+}
+function hasAftAtKeys(value, keys) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record2 = value;
+  for (const key of keys) {
+    if (hasAftInArray(record2[key]))
+      return true;
+  }
+  return false;
+}
+function getAftAvailability() {
+  const home = process.env.HOME || homedir9();
+  const opencodePaths = [
+    join11(home, ".config", "opencode", "opencode.jsonc"),
+    join11(home, ".config", "opencode", "opencode.json")
+  ];
+  const piPaths = [join11(home, ".pi", "agent", "settings.json")];
+  const checkedPaths = [...opencodePaths, ...piPaths];
+  let opencode = false;
+  for (const path4 of opencodePaths) {
+    try {
+      const config2 = parseConfig(path4);
+      if (hasAftAtKeys(config2, ["plugin", "plugins", "mcp", "mcp_servers"])) {
+        opencode = true;
+        break;
+      }
+    } catch {}
+  }
+  let pi = false;
+  for (const path4 of piPaths) {
+    try {
+      const config2 = parseConfig(path4);
+      if (hasAftAtKeys(config2, ["packages", "extensions"])) {
+        pi = true;
+        break;
+      }
+      const agent = config2?.agent;
+      if (hasAftAtKeys(agent, ["packages", "extensions"])) {
+        pi = true;
+        break;
+      }
+    } catch {}
+  }
+  const detected = opencode || pi;
+  return {
+    available: overrideAvailability ?? detected,
+    opencode,
+    pi,
+    checkedPaths
+  };
+}
+var import_comment_json6, overrideAvailability = null;
+var init_aft_availability = __esm(() => {
+  import_comment_json6 = __toESM(require_src2(), 1);
+});
+
 // ../plugin/src/features/magic-context/memory/embedding-probe.ts
 async function probeEmbeddingEndpoint(options) {
   const endpoint = options.endpoint.trim().replace(/\/+$/, "");
@@ -27634,7 +27808,7 @@ function truncate(text2) {
 var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 
 // ../plugin/src/shared/tui-config.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname8, join as join12 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
@@ -27651,9 +27825,9 @@ function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join12(configDir, "tui.jsonc");
   const jsonPath = join12(configDir, "tui.json");
-  if (existsSync13(jsoncPath))
+  if (existsSync14(jsoncPath))
     return jsoncPath;
-  if (existsSync13(jsonPath))
+  if (existsSync14(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -27661,9 +27835,9 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync13(configPath)) {
-      const raw = readFileSync8(configPath, "utf-8");
-      config2 = import_comment_json5.parse(raw) ?? {};
+    if (existsSync14(configPath)) {
+      const raw = readFileSync10(configPath, "utf-8");
+      config2 = import_comment_json7.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((p2) => typeof p2 === "string") : [];
     const existingIdx = plugins.findIndex(isMagicContextEntry);
@@ -27682,7 +27856,7 @@ function ensureTuiPluginEntry() {
     }
     config2.plugin = plugins;
     mkdirSync6(dirname8(configPath), { recursive: true });
-    writeFileSync8(configPath, `${import_comment_json5.stringify(config2, null, 2)}
+    writeFileSync8(configPath, `${import_comment_json7.stringify(config2, null, 2)}
 `);
     log2(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -27691,11 +27865,11 @@ function ensureTuiPluginEntry() {
     return false;
   }
 }
-var import_comment_json5, PLUGIN_NAME4 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY3;
+var import_comment_json7, PLUGIN_NAME4 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY3;
 var init_tui_config = __esm(() => {
   init_logger();
   init_opencode_config_dir();
-  import_comment_json5 = __toESM(require_src2(), 1);
+  import_comment_json7 = __toESM(require_src2(), 1);
   PLUGIN_ENTRY3 = `${PLUGIN_NAME4}@latest`;
 });
 
@@ -27749,10 +27923,125 @@ var init_compartment_parser = __esm(() => {
   USER_OBS_ITEM_REGEX = /^\s*\*\s*(.+)$/gm;
 });
 
+// src/lib/redaction.ts
+import { homedir as homedir10, userInfo } from "node:os";
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function redactionTypeForKey(key) {
+  const normalized = key.trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "_");
+  const suffix = normalized.split(".").filter(Boolean).at(-1) ?? normalized;
+  return suffix || "secret";
+}
+function isSecretKey(key) {
+  return SECRET_KEY_PATTERN.test(key);
+}
+function sanitizePathString(value) {
+  const home = homedir10();
+  const username = userInfo().username;
+  let sanitized = value;
+  if (home) {
+    sanitized = sanitized.replace(new RegExp(escapeRegex2(home), "g"), "~");
+  }
+  sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
+  sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
+  sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
+  if (username) {
+    sanitized = sanitized.replace(new RegExp(escapeRegex2(username), "g"), "<USER>");
+  }
+  return sanitized;
+}
+function redactSecretText(value) {
+  let redacted = value;
+  for (const { pattern, replacement } of SECRET_TEXT_PATTERNS) {
+    if (typeof replacement === "string") {
+      redacted = redacted.replace(pattern, replacement);
+    } else {
+      redacted = redacted.replace(pattern, replacement);
+    }
+  }
+  return redacted;
+}
+function sanitizeDiagnosticText(value) {
+  return redactSecretText(sanitizePathString(value));
+}
+function sanitizeConfigValue(value, keyPath = []) {
+  const key = keyPath.at(-1) ?? "";
+  if (key && isSecretKey(key)) {
+    return `<REDACTED:${redactionTypeForKey(key)}>`;
+  }
+  if (typeof value === "string")
+    return sanitizeDiagnosticText(value);
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => sanitizeConfigValue(entry, [...keyPath, String(index)]));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entry]) => [
+      entryKey,
+      sanitizeConfigValue(entry, [...keyPath, entryKey])
+    ]));
+  }
+  return value;
+}
+var SECRET_KEY_PATTERN, SECRET_TEXT_PATTERNS;
+var init_redaction = __esm(() => {
+  SECRET_KEY_PATTERN = /(?:key|token|secret|password|auth|bearer|credential)/i;
+  SECRET_TEXT_PATTERNS = [
+    {
+      pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
+      replacement: "<ANTHROPIC_API_KEY_REDACTED>"
+    },
+    {
+      pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}/g,
+      replacement: "<OPENAI_API_KEY_REDACTED>"
+    },
+    {
+      pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+      replacement: "<GITHUB_PAT_REDACTED>"
+    },
+    {
+      pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
+      replacement: "<GITHUB_TOKEN_REDACTED>"
+    },
+    {
+      pattern: /\bhf_[A-Za-z0-9]{30,}/g,
+      replacement: "<HUGGINGFACE_TOKEN_REDACTED>"
+    },
+    {
+      pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+      replacement: "<AWS_ACCESS_KEY_ID_REDACTED>"
+    },
+    {
+      pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
+      replacement: "<SLACK_TOKEN_REDACTED>"
+    },
+    {
+      pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
+      replacement: "<GOOGLE_API_KEY_REDACTED>"
+    },
+    {
+      pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{8,})/gi,
+      replacement: (_full, prefix) => `${prefix}<REDACTED:bearer>`
+    },
+    {
+      pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
+      replacement: "<JWT_REDACTED>"
+    },
+    {
+      pattern: /(["'])([^"']*(?:key|token|secret|password|auth|bearer|credential)[^"']*)\1(\s*:\s*)(["'])([^"']*)\4/gi,
+      replacement: (_full, quote, key, separator, valueQuote) => `${quote}${key}${quote}${separator}${valueQuote}<REDACTED:${redactionTypeForKey(key)}>${valueQuote}`
+    },
+    {
+      pattern: /\b([A-Za-z0-9_.-]*(?:key|token|secret|password|auth|bearer|credential)[A-Za-z0-9_.-]*)\s*=\s*([^\s'"`]+)/gi,
+      replacement: (_full, key) => `${key}=<REDACTED:${redactionTypeForKey(key)}>`
+    }
+  ];
+});
+
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync2, readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir9, tmpdir as tmpdir3, userInfo } from "node:os";
+import { homedir as homedir11 } from "node:os";
 import { join as join13 } from "node:path";
 function getSelfVersion() {
   const require2 = createRequire3(import.meta.url);
@@ -27771,8 +28060,8 @@ function getPluginCacheInfo() {
   let cached2;
   try {
     const installedPkgPath = join13(path4, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync14(installedPkgPath)) {
-      const pkg = JSON.parse(readFileSync9(installedPkgPath, "utf-8"));
+    if (existsSync15(installedPkgPath)) {
+      const pkg = JSON.parse(readFileSync11(installedPkgPath, "utf-8"));
       cached2 = typeof pkg.version === "string" ? pkg.version : undefined;
     }
   } catch {
@@ -27781,50 +28070,28 @@ function getPluginCacheInfo() {
   return { path: path4, cached: cached2, latest: getSelfVersion() };
 }
 function getStorageDir() {
-  const dataHome = process.env.XDG_DATA_HOME || join13(homedir9(), ".local", "share");
+  const dataHome = process.env.XDG_DATA_HOME || join13(homedir11(), ".local", "share");
   return join13(dataHome, "cortexkit", "magic-context");
 }
 function fileSize(path4) {
   try {
-    return existsSync14(path4) ? statSync2(path4).size : 0;
+    return existsSync15(path4) ? statSync2(path4).size : 0;
   } catch {
     return 0;
   }
 }
-function escapeRegex2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function sanitizeString(value) {
-  const home = homedir9();
-  const username = userInfo().username;
-  let sanitized = value;
-  if (home) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex2(home), "g"), "~");
-  }
-  sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
-  sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
-  sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
-  if (username) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex2(username), "g"), "<USER>");
-  }
-  return sanitized;
+  return sanitizePathString(value);
 }
 function sanitizeValue(value) {
-  if (typeof value === "string")
-    return sanitizeString(value);
-  if (Array.isArray(value))
-    return value.map(sanitizeValue);
-  if (value && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, sanitizeValue(entry)]));
-  }
-  return value;
+  return sanitizeConfigValue(value);
 }
 function readConfig2(path4) {
-  if (!existsSync14(path4))
+  if (!existsSync15(path4))
     return { value: null };
   try {
-    const raw = readFileSync9(path4, "utf-8");
-    const value = import_comment_json6.parse(raw);
+    const raw = readFileSync11(path4, "utf-8");
+    const value = import_comment_json8.parse(raw);
     return { value };
   } catch (error51) {
     return { value: null, error: error51 instanceof Error ? error51.message : String(error51) };
@@ -27846,7 +28113,7 @@ function configHasPluginEntry(config2) {
 }
 function parseHistorianDumpMeta(path4) {
   try {
-    const xml = readFileSync9(path4, "utf-8");
+    const xml = readFileSync11(path4, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -27878,11 +28145,9 @@ function parseHistorianDumpMeta(path4) {
     return { error: error51 instanceof Error ? error51.message : String(error51) };
   }
 }
-function collectHistorianDumps() {
-  const dir = join13(tmpdir3(), "magic-context-historian");
-  if (!existsSync14(dir)) {
-    return { dir, count: 0, recent: [] };
-  }
+function listDumpsInDir(dir, limit) {
+  if (!existsSync15(dir))
+    return { count: 0, recent: [] };
   try {
     const entries = readdirSync2(dir).filter((name) => name.endsWith(".xml")).map((name) => {
       const stat = statSync2(join13(dir, name));
@@ -27893,7 +28158,7 @@ function collectHistorianDumps() {
       };
     }).sort((a, b2) => b2.mtime - a.mtime);
     const now = Date.now();
-    const recent = entries.slice(0, 5).map((entry) => {
+    const recent = entries.slice(0, limit).map((entry) => {
       const meta3 = parseHistorianDumpMeta(join13(dir, entry.name));
       const summary = {
         name: entry.name,
@@ -27907,14 +28172,85 @@ function collectHistorianDumps() {
       }
       return summary;
     });
-    return { dir, count: entries.length, recent };
+    return { count: entries.length, recent };
+  } catch {
+    return { count: 0, recent: [] };
+  }
+}
+function collectHistorianDumps(recentSessions) {
+  const buckets = new Map;
+  for (const session of recentSessions) {
+    const dir = session.directory;
+    if (!dir)
+      continue;
+    const projectHistorianDir = getProjectMagicContextHistorianDir(dir);
+    const listing = listDumpsInDir(projectHistorianDir, 5);
+    const existing = buckets.get(dir);
+    if (existing) {
+      if (!existing.sessionIds.includes(session.sessionId)) {
+        existing.sessionIds.push(session.sessionId);
+      }
+      continue;
+    }
+    if (listing.count === 0)
+      continue;
+    buckets.set(dir, {
+      directory: dir,
+      primarySessionId: session.sessionId,
+      sessionIds: [session.sessionId],
+      count: listing.count,
+      recent: listing.recent
+    });
+  }
+  const legacyDir = getMagicContextHistorianDir2("opencode");
+  const legacyListing = listDumpsInDir(legacyDir, 5);
+  return {
+    byProject: [...buckets.values()],
+    legacyDumps: {
+      dir: legacyDir,
+      count: legacyListing.count,
+      recent: legacyListing.recent
+    }
+  };
+}
+async function collectRecentSessions() {
+  const opencodeDbPath = join13(homedir11(), ".local", "share", "opencode", "opencode.db");
+  if (!existsSync15(opencodeDbPath))
+    return [];
+  if (typeof globalThis.Bun === "undefined") {
+    return [];
+  }
+  let DatabaseClass;
+  try {
+    const mod = await new Function("p", "return import(p)")("bun:sqlite");
+    DatabaseClass = mod.Database;
+  } catch {
+    return [];
+  }
+  let db = null;
+  try {
+    db = new DatabaseClass(opencodeDbPath, { readonly: true });
+    const rows = db.prepare("SELECT id, directory, title, time_updated FROM session " + "WHERE time_archived IS NULL AND parent_id IS NULL " + "ORDER BY time_updated DESC LIMIT 5").all();
+    return rows.flatMap((row) => {
+      const sessionId = typeof row.id === "string" ? row.id : null;
+      const directory = typeof row.directory === "string" ? row.directory : null;
+      if (!sessionId || !directory)
+        return [];
+      const title = typeof row.title === "string" ? row.title : "";
+      const lastActiveAt = typeof row.time_updated === "number" ? new Date(row.time_updated).toISOString() : "";
+      return [{ sessionId, title, directory, lastActiveAt }];
+    });
   } catch {
-    return { dir, count: 0, recent: [] };
+    return [];
+  } finally {
+    try {
+      db?.close();
+    } catch {}
   }
 }
 async function collectHistorianFailures(storageDirPath) {
   const contextDbPath = join13(storageDirPath, "context.db");
-  if (!existsSync14(contextDbPath))
+  if (!existsSync15(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -27935,7 +28271,7 @@ async function collectHistorianFailures(storageDirPath) {
       const failureCount = typeof row.historian_failure_count === "number" ? row.historian_failure_count : 0;
       const rawError = typeof row.historian_last_error === "string" ? row.historian_last_error : "";
       const lastAt = typeof row.historian_last_failure_at === "number" ? new Date(row.historian_last_failure_at).toISOString() : "";
-      const lastError = sanitizeString(rawError.replace(/\s+/g, " ").trim().slice(0, 400));
+      const lastError = sanitizeDiagnosticText(rawError.replace(/\s+/g, " ").trim().slice(0, 400));
       return { sessionId, failureCount, lastError, lastFailureAt: lastAt };
     });
   } catch {
@@ -27954,9 +28290,10 @@ async function collectDiagnostics() {
   const magicContextConfig = readConfig2(configPaths.magicContextConfig);
   const storageDirPath = getStorageDir();
   const contextDbPath = join13(storageDirPath, "context.db");
-  const logPath = join13(tmpdir3(), "magic-context.log");
-  const logFileSize = existsSync14(logPath) ? statSync2(logPath).size : 0;
+  const logPath = getMagicContextLogPath2("opencode");
+  const logFileSize = existsSync15(logPath) ? statSync2(logPath).size : 0;
   const conflictResult = detectConflicts(process.cwd());
+  const recentSessions = await collectRecentSessions();
   return {
     timestamp: new Date().toISOString(),
     platform: process.platform,
@@ -27969,14 +28306,15 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync14(configPaths.magicContextConfig),
+      exists: existsSync15(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
+    aft: getAftAvailability(),
     pluginCache: getPluginCacheInfo(),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync14(storageDirPath),
+      exists: existsSync15(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     conflicts: {
@@ -27985,10 +28323,11 @@ async function collectDiagnostics() {
     },
     logFile: {
       path: logPath,
-      exists: existsSync14(logPath),
+      exists: existsSync15(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
-    historianDumps: collectHistorianDumps(),
+    recentSessions,
+    historianDumps: collectHistorianDumps(recentSessions),
     historianFailures: await collectHistorianFailures(storageDirPath)
   };
 }
@@ -28022,10 +28361,25 @@ function renderDiagnosticsMarkdown(report) {
     context_db_size: formatBytes(report.storageDir.contextDbSizeBytes)
   };
   const historianDumps = {
-    dir: sanitizeString(report.historianDumps.dir),
-    count: report.historianDumps.count,
-    recent: report.historianDumps.recent
+    byProject: report.historianDumps.byProject.map((bucket) => ({
+      directory: sanitizeString(bucket.directory),
+      primarySessionId: bucket.primarySessionId,
+      sessionIds: bucket.sessionIds,
+      count: bucket.count,
+      recent: bucket.recent
+    })),
+    legacyDumps: {
+      dir: sanitizeString(report.historianDumps.legacyDumps.dir),
+      count: report.historianDumps.legacyDumps.count,
+      recent: report.historianDumps.legacyDumps.recent
+    }
   };
+  const recentSessions = report.recentSessions.map((session) => ({
+    sessionId: session.sessionId,
+    title: session.title,
+    directory: sanitizeString(session.directory),
+    lastActiveAt: session.lastActiveAt
+  }));
   return [
     `- Timestamp: ${report.timestamp}`,
     `- Plugin: v${report.pluginVersion}`,
@@ -28035,6 +28389,7 @@ function renderDiagnosticsMarkdown(report) {
     `- Plugin registered in opencode config: ${report.opencodeConfigHasPlugin}`,
     `- Plugin registered in tui config: ${report.tuiConfigHasPlugin}`,
     `- magic-context.jsonc parse error: ${report.magicContextConfig.parseError ?? "none"}`,
+    `- AFT available: ${report.aft?.available ?? false} (opencode=${report.aft?.opencode ?? false}, pi=${report.aft?.pi ?? false})`,
     `- Conflicts detected: ${report.conflicts.hasConflict ? report.conflicts.reasons.join("; ") : "none"}`,
     "",
     "### Config paths",
@@ -28044,7 +28399,7 @@ function renderDiagnosticsMarkdown(report) {
     "",
     "### magic-context.jsonc flags",
     "```jsonc",
-    JSON.stringify(report.magicContextConfig.flags, null, 2),
+    JSON.stringify(sanitizeConfigValue(report.magicContextConfig.flags), null, 2),
     "```",
     "",
     "### Plugin cache",
@@ -28056,15 +28411,24 @@ function renderDiagnosticsMarkdown(report) {
     "```json",
     JSON.stringify(storage, null, 2),
     "```",
+    "",
+    "### Recent sessions",
+    recentSessions.length === 0 ? "_No recent OpenCode sessions found (or OpenCode DB unavailable on this runtime)._" : ["```json", JSON.stringify(recentSessions, null, 2), "```"].join(`
+`),
     "",
     "### Historian dumps",
     "(Metadata only — XML content is not included in this report.)",
+    "Dumps are stored per-project under `<project>/.opencode/magic-context/historian/`.",
     "```json",
     JSON.stringify(historianDumps, null, 2),
     "```",
     "",
     "### Historian failures (session_meta)",
-    report.historianFailures.length === 0 ? "_No sessions with historian failures._" : ["```json", JSON.stringify(report.historianFailures, null, 2), "```"].join(`
+    report.historianFailures.length === 0 ? "_No sessions with historian failures._" : [
+      "```json",
+      JSON.stringify(sanitizeConfigValue(report.historianFailures), null, 2),
+      "```"
+    ].join(`
 `),
     "",
     "### Log file",
@@ -28074,45 +28438,25 @@ function renderDiagnosticsMarkdown(report) {
   ].join(`
 `);
 }
-var import_comment_json6, PLUGIN_NAME5 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY_WITH_VERSION;
+var import_comment_json8, PLUGIN_NAME5 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY_WITH_VERSION;
 var init_diagnostics_opencode = __esm(() => {
+  init_aft_availability();
   init_compartment_parser();
   init_conflict_detector();
   init_data_path();
   init_opencode_helpers();
   init_paths();
-  import_comment_json6 = __toESM(require_src2(), 1);
+  init_redaction();
+  import_comment_json8 = __toESM(require_src2(), 1);
   PLUGIN_ENTRY_WITH_VERSION = `${PLUGIN_NAME5}@latest`;
 });
 
 // src/lib/logs-opencode.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir10, userInfo as userInfo2 } from "node:os";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
 import { join as join14 } from "node:path";
-function escapeRegex3(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function sanitizeLogContent(content) {
-  const home = homedir10();
-  const username = userInfo2().username;
-  let sanitized = content;
-  if (home) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex3(home), "g"), "~");
-  }
-  sanitized = sanitized.replace(/\/Users\/[^/]+\//g, "/Users/<USER>/");
-  sanitized = sanitized.replace(/\/home\/[^/]+\//g, "/home/<USER>/");
-  sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, "C:\\Users\\<USER>\\");
-  if (username) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex3(username), "g"), "<USER>");
-  }
-  for (const { pattern, replacement } of SECRET_PATTERNS) {
-    if (typeof replacement === "string") {
-      sanitized = sanitized.replace(pattern, replacement);
-    } else {
-      sanitized = sanitized.replace(pattern, replacement);
-    }
-  }
-  return sanitized;
+  return sanitizeDiagnosticText(content);
 }
 function formatTimestamp(date5) {
   const pad = (value) => String(value).padStart(2, "0");
@@ -28139,16 +28483,28 @@ function extractHistorianFailureLines(sanitized, limit = 30) {
   }
   return matches.reverse();
 }
-async function bundleIssueReport(report, description, _title) {
+function filterLogLinesBySession(lines, sessionId) {
+  if (!sessionId)
+    return lines;
+  const otherSessionPattern = /\bses_[A-Za-z0-9]{8,32}\b/g;
+  return lines.filter((line) => {
+    const matches = line.match(otherSessionPattern);
+    if (!matches)
+      return true;
+    return matches.every((id) => id === sessionId);
+  });
+}
+async function bundleIssueReport(report, description, _title, sessionFilter = null) {
   const LOG_TAIL_LINES = 400;
-  const logLines = report.logFile.exists ? readFileSync10(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const allLogLines = report.logFile.exists ? readFileSync12(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const logLines = filterLogLinesBySession(allLogLines, sessionFilter);
   const recentLog = sanitizeLogContent(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
   const historianScanWindow = sanitizeLogContent(logLines.slice(-4000).join(`
 `));
   const historianFailureLines = extractHistorianFailureLines(historianScanWindow, 30);
-  const configBody = JSON.stringify(report.magicContextConfig.flags, null, 2);
-  const sanitizedConfigPath = report.configPaths.magicContextConfig.replace(homedir10(), "~");
+  const configBody = JSON.stringify(sanitizeConfigValue(report.magicContextConfig.flags), null, 2);
+  const sanitizedConfigPath = report.configPaths.magicContextConfig.replace(homedir12(), "~");
   const bodyMarkdown = [
     "## Description",
     description,
@@ -28184,76 +28540,10 @@ async function bundleIssueReport(report, description, _title) {
 `);
   return { path: path4, bodyMarkdown };
 }
-var SECRET_PATTERNS, HISTORIAN_LOG_PATTERNS;
+var HISTORIAN_LOG_PATTERNS;
 var init_logs_opencode = __esm(() => {
   init_diagnostics_opencode();
-  SECRET_PATTERNS = [
-    {
-      name: "anthropic_api_key",
-      pattern: /\bsk-ant-(?:api03-)?[A-Za-z0-9_-]{32,}/g,
-      replacement: "<ANTHROPIC_API_KEY_REDACTED>"
-    },
-    {
-      name: "openai_api_key",
-      pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}/g,
-      replacement: "<OPENAI_API_KEY_REDACTED>"
-    },
-    {
-      name: "github_pat_fine_grained",
-      pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
-      replacement: "<GITHUB_PAT_REDACTED>"
-    },
-    {
-      name: "github_token_classic",
-      pattern: /\b(?:gh[opsu]|ghr)_[A-Za-z0-9]{30,}/g,
-      replacement: "<GITHUB_TOKEN_REDACTED>"
-    },
-    {
-      name: "huggingface_token",
-      pattern: /\bhf_[A-Za-z0-9]{30,}/g,
-      replacement: "<HUGGINGFACE_TOKEN_REDACTED>"
-    },
-    {
-      name: "aws_access_key_id",
-      pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
-      replacement: "<AWS_ACCESS_KEY_ID_REDACTED>"
-    },
-    {
-      name: "aws_secret_access_key",
-      pattern: /\b(aws[_-]?secret[_-]?access[_-]?key\s*[=:]\s*)([A-Za-z0-9/+=]{40})\b/gi,
-      replacement: (_full, prefix) => `${prefix}<AWS_SECRET_REDACTED>`
-    },
-    {
-      name: "slack_token",
-      pattern: /\bxox[abprsuvc]-[A-Za-z0-9-]{10,}/g,
-      replacement: "<SLACK_TOKEN_REDACTED>"
-    },
-    {
-      name: "google_api_key",
-      pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g,
-      replacement: "<GOOGLE_API_KEY_REDACTED>"
-    },
-    {
-      name: "secret_env_assignment",
-      pattern: /\b([A-Z][A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|PRIVATE[_-]?KEY))\s*=\s*([^\s'"]+)/g,
-      replacement: (_full, key) => `${key}=<REDACTED>`
-    },
-    {
-      name: "secret_json_assignment",
-      pattern: /("(?:api[_-]?key|access[_-]?token|auth[_-]?token|bearer[_-]?token|client[_-]?secret|password|private[_-]?key|secret[_-]?key)"\s*:\s*)"([^"]+)"/gi,
-      replacement: (_full, prefix) => `${prefix}"<REDACTED>"`
-    },
-    {
-      name: "bearer_token",
-      pattern: /\b(Authorization\s*:\s*Bearer\s+)([A-Za-z0-9._~+/=-]{16,})/gi,
-      replacement: (_full, prefix) => `${prefix}<BEARER_TOKEN_REDACTED>`
-    },
-    {
-      name: "jwt_token",
-      pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g,
-      replacement: "<JWT_REDACTED>"
-    }
-  ];
+  init_redaction();
   HISTORIAN_LOG_PATTERNS = [
     /historian failure:/,
     /historian failure recorded:/,
@@ -28267,9 +28557,9 @@ var init_logs_opencode = __esm(() => {
 
 // src/commands/doctor-opencode.ts
 import { execSync as execSync2, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync11, rmSync, statSync as statSync3, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync13, rmSync, statSync as statSync3, writeFileSync as writeFileSync10 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { homedir as homedir11, tmpdir as tmpdir4 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 import { join as join15 } from "node:path";
 async function fetchNpmLatest(pkg, timeoutMs = 5000) {
   try {
@@ -28321,14 +28611,14 @@ function compareVersions(a, b2) {
 async function clearPluginCache(force = false) {
   const cacheDir = getOpenCodeCacheDir();
   const pluginCacheDir = join15(cacheDir, "packages", PLUGIN_ENTRY_WITH_VERSION2);
-  if (!existsSync15(pluginCacheDir)) {
+  if (!existsSync16(pluginCacheDir)) {
     return { action: "not_found", path: pluginCacheDir };
   }
   let cachedVersion;
   try {
     const installedPkgPath = join15(pluginCacheDir, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync15(installedPkgPath)) {
-      const pkg = JSON.parse(readFileSync11(installedPkgPath, "utf-8"));
+    if (existsSync16(installedPkgPath)) {
+      const pkg = JSON.parse(readFileSync13(installedPkgPath, "utf-8"));
       if (typeof pkg?.version === "string") {
         cachedVersion = pkg.version;
       }
@@ -28403,7 +28693,27 @@ async function runIssueFlow() {
   s.start("Collecting diagnostics");
   try {
     const report = await collectDiagnostics();
-    const bundled = await bundleIssueReport(report, description, title);
+    s.stop("Diagnostics collected");
+    let sessionFilter = null;
+    if (report.recentSessions.length > 1) {
+      const choice = await selectOne("Which session is this issue about? (filters log lines from other sessions)", [
+        ...report.recentSessions.map((session, index) => {
+          const displayTitle = session.title.trim() || "(no title)";
+          const truncatedTitle = displayTitle.length > 50 ? `${displayTitle.slice(0, 47)}...` : displayTitle;
+          return {
+            label: `${truncatedTitle} — ${session.sessionId}${index === 0 ? " (most recent)" : ""}`,
+            value: session.sessionId
+          };
+        }),
+        {
+          label: "All sessions (no filtering)",
+          value: "__all__"
+        }
+      ]);
+      sessionFilter = choice === "__all__" ? null : choice;
+    }
+    s.start("Bundling issue report");
+    const bundled = await bundleIssueReport(report, description, title, sessionFilter);
     s.stop(`Report written to ${bundled.path}`);
     const shouldSubmit = await confirm("Submit this issue on GitHub now?", true);
     if (shouldSubmit && isGhInstalled()) {
@@ -28440,12 +28750,12 @@ async function runIssueFlow() {
   }
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync15(magicContextConfigPath)) {
+  if (!existsSync16(magicContextConfigPath)) {
     return { issues: 0 };
   }
   let rawText;
   try {
-    rawText = readFileSync11(magicContextConfigPath, "utf-8");
+    rawText = readFileSync13(magicContextConfigPath, "utf-8");
   } catch {
     log.warn("Could not read magic-context.jsonc for embedding check");
     return { issues: 1 };
@@ -28456,7 +28766,7 @@ async function checkEmbeddingConfig(magicContextConfigPath) {
   });
   let parsedConfig;
   try {
-    parsedConfig = import_comment_json7.parse(substituted.text);
+    parsedConfig = import_comment_json9.parse(substituted.text);
   } catch (error51) {
     log.warn(`Embedding check skipped — could not parse magic-context.jsonc: ${error51 instanceof Error ? error51.message : String(error51)}`);
     return { issues: 1 };
@@ -28593,15 +28903,15 @@ async function runDoctor(options = {}) {
   } else {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
-  if (existsSync15(paths.magicContextConfig)) {
+  if (existsSync16(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
-      const raw = readFileSync11(paths.magicContextConfig, "utf-8");
+      const raw = readFileSync13(paths.magicContextConfig, "utf-8");
       const substituted = substituteConfigVariables({
         text: raw,
         configPath: paths.magicContextConfig
       }).text;
-      import_comment_json7.parse(substituted);
+      import_comment_json9.parse(substituted);
       pass("magic-context.jsonc parses as valid JSONC");
     } catch (err) {
       fail(`magic-context.jsonc parse failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -28621,10 +28931,10 @@ async function runDoctor(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync15(paths.magicContextConfig)) {
+  if (existsSync16(paths.magicContextConfig)) {
     try {
-      const mcRaw = readFileSync11(paths.magicContextConfig, "utf-8");
-      const mcConfig = import_comment_json7.parse(mcRaw);
+      const mcRaw = readFileSync13(paths.magicContextConfig, "utf-8");
+      const mcConfig = import_comment_json9.parse(mcRaw);
       let mcChanged = false;
       const experimental = mcConfig.experimental;
       if (experimental && "compaction_markers" in experimental) {
@@ -28699,7 +29009,7 @@ async function runDoctor(options = {}) {
         fixed++;
       }
       if (mcChanged) {
-        writeFileSync10(paths.magicContextConfig, `${import_comment_json7.stringify(mcConfig, null, 2)}
+        writeFileSync10(paths.magicContextConfig, `${import_comment_json9.stringify(mcConfig, null, 2)}
 `);
       }
     } catch {
@@ -28708,8 +29018,8 @@ async function runDoctor(options = {}) {
   }
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync11(paths.opencodeConfig, "utf-8");
-      const config2 = import_comment_json7.parse(raw);
+      const raw = readFileSync13(paths.opencodeConfig, "utf-8");
+      const config2 = import_comment_json9.parse(raw);
       const rawPlugins = Array.isArray(config2?.plugin) ? config2.plugin : [];
       const existingIdx = rawPlugins.findIndex((entry) => matchesPluginEntry(entry, PLUGIN_NAME6) || isDevPathPluginEntry(entry));
       const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
@@ -28740,7 +29050,7 @@ async function runDoctor(options = {}) {
               rawPlugins[existingIdx] = PLUGIN_ENTRY_WITH_VERSION2;
             }
             config2.plugin = rawPlugins;
-            writeFileSync10(paths.opencodeConfig, `${import_comment_json7.stringify(config2, null, 2)}
+            writeFileSync10(paths.opencodeConfig, `${import_comment_json9.stringify(config2, null, 2)}
 `);
             pass(`Upgraded plugin entry in ${configName}: ${oldEntryStr} → ${PLUGIN_ENTRY_WITH_VERSION2}`);
             fixed++;
@@ -28749,7 +29059,7 @@ async function runDoctor(options = {}) {
       } else {
         rawPlugins.push(PLUGIN_ENTRY_WITH_VERSION2);
         config2.plugin = rawPlugins;
-        writeFileSync10(paths.opencodeConfig, `${import_comment_json7.stringify(config2, null, 2)}
+        writeFileSync10(paths.opencodeConfig, `${import_comment_json9.stringify(config2, null, 2)}
 `);
         pass(`Added plugin to ${configName}`);
         fixed++;
@@ -28780,10 +29090,10 @@ async function runDoctor(options = {}) {
     pass("Added TUI sidebar plugin to tui.json");
     warn("Restart OpenCode to see the sidebar");
     fixed++;
-  } else if (existsSync15(paths.tuiConfig)) {
+  } else if (existsSync16(paths.tuiConfig)) {
     try {
-      const tuiRaw = readFileSync11(paths.tuiConfig, "utf-8");
-      const tuiConfig = import_comment_json7.parse(tuiRaw);
+      const tuiRaw = readFileSync13(paths.tuiConfig, "utf-8");
+      const tuiConfig = import_comment_json9.parse(tuiRaw);
       const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
       const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, PLUGIN_NAME6) || isDevPathPluginEntry(entry));
       const tuiEntryAsString = (entry) => {
@@ -28811,7 +29121,7 @@ async function runDoctor(options = {}) {
               tuiRawPlugins[tuiIdx] = PLUGIN_ENTRY_WITH_VERSION2;
             }
             tuiConfig.plugin = tuiRawPlugins;
-            writeFileSync10(paths.tuiConfig, `${import_comment_json7.stringify(tuiConfig, null, 2)}
+            writeFileSync10(paths.tuiConfig, `${import_comment_json9.stringify(tuiConfig, null, 2)}
 `);
             pass(`Upgraded TUI plugin: ${tuiEntryStr} → ${PLUGIN_ENTRY_WITH_VERSION2}`);
             fixed++;
@@ -28828,10 +29138,10 @@ async function runDoctor(options = {}) {
   } else {
     pass("TUI sidebar plugin configured (tui.json created)");
   }
-  if (existsSync15(paths.magicContextConfig)) {
+  if (existsSync16(paths.magicContextConfig)) {
     try {
-      const mcRaw = readFileSync11(paths.magicContextConfig, "utf-8");
-      const mcConfig = import_comment_json7.parse(mcRaw);
+      const mcRaw = readFileSync13(paths.magicContextConfig, "utf-8");
+      const mcConfig = import_comment_json9.parse(mcRaw);
       const dreamerObj = mcConfig?.dreamer;
       const dreamerEnabled = dreamerObj?.enabled === true;
       const userMemObj = dreamerObj?.user_memories;
@@ -28840,6 +29150,15 @@ async function runDoctor(options = {}) {
         log.warn("dreamer.user_memories is enabled (default) but dreamer itself is disabled — user memory candidates will be collected but never promoted to stable memories. Enable `dreamer.enabled: true` or set `dreamer.user_memories.enabled: false` to silence this.");
         issues++;
       }
+      const pinKeyFilesObj = dreamerObj?.pin_key_files;
+      if (pinKeyFilesObj?.enabled === true) {
+        const aft = getAftAvailability();
+        if (aft.available) {
+          pass("AFT detected for dreamer.pin_key_files");
+        } else {
+          fail(`dreamer.pin_key_files is enabled but AFT is not configured. Install/register AFT (checked: ${aft.checkedPaths.join(", ")})`);
+        }
+      }
     } catch {}
   }
   const embeddingCheck = await checkEmbeddingConfig(paths.magicContextConfig);
@@ -28849,7 +29168,7 @@ async function runDoctor(options = {}) {
   else
     passCount++;
   const dbPath = join15(getMagicContextStorageDir(), "context.db");
-  if (!existsSync15(dbPath)) {
+  if (!existsSync16(dbPath)) {
     log.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     pass(`Shared context DB exists at ${dbPath}`);
@@ -28910,10 +29229,10 @@ async function runDoctor(options = {}) {
   }
   {
     const ageWarnings = [];
-    const npmrcPath = join15(homedir11(), ".npmrc");
-    if (existsSync15(npmrcPath)) {
+    const npmrcPath = join15(homedir13(), ".npmrc");
+    if (existsSync16(npmrcPath)) {
       try {
-        const npmrc = readFileSync11(npmrcPath, "utf-8");
+        const npmrc = readFileSync13(npmrcPath, "utf-8");
         for (const line of npmrc.split(`
 `)) {
           const trimmed = line.trim();
@@ -28936,33 +29255,35 @@ async function runDoctor(options = {}) {
       issues++;
     }
   }
-  const logPath = join15(tmpdir4(), "magic-context.log");
-  if (existsSync15(logPath)) {
+  const logPath = getMagicContextLogPath2("opencode");
+  if (existsSync16(logPath)) {
     const logStat = statSync3(logPath);
     const sizeKb = (logStat.size / 1024).toFixed(0);
     log.info(`Log file: ${logPath} (${sizeKb} KB)`);
   } else {
     log.info(`Log file: ${logPath} (not yet created)`);
   }
-  const historianDumpDir = join15(tmpdir4(), "magic-context-historian");
-  if (existsSync15(historianDumpDir)) {
-    try {
-      const dumps = readdirSync3(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({
-        name: f,
-        mtime: statSync3(join15(historianDumpDir, f)).mtimeMs
-      })).sort((a, b2) => b2.mtime - a.mtime);
-      if (dumps.length > 0) {
-        warn(`Historian debug dumps: ${dumps.length} file(s) in ${historianDumpDir}`);
-        for (const dump of dumps.slice(0, 3)) {
-          const age = Math.round((Date.now() - dump.mtime) / 60000);
-          const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
-          log.info(`  ${dump.name} (${ageStr})`);
-        }
-        if (dumps.length > 3) {
-          log.info(`  ... and ${dumps.length - 3} more`);
-        }
+  const diagnostics = await collectDiagnostics();
+  const dumpBuckets = diagnostics.historianDumps.byProject;
+  if (dumpBuckets.length > 0) {
+    const totalCount = dumpBuckets.reduce((sum, b2) => sum + b2.count, 0);
+    const sessionCount = dumpBuckets.length;
+    warn(`Historian debug dumps: ${totalCount} file(s) across ${sessionCount} project(s)`);
+    for (const bucket of dumpBuckets) {
+      log.info(`  [${bucket.directory}] ${bucket.count} file(s)`);
+      for (const dump of bucket.recent.slice(0, 3)) {
+        const age = dump.ageMinutes;
+        const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+        log.info(`    ${dump.name} (${ageStr})`);
       }
-    } catch {}
+      if (bucket.count > 3) {
+        log.info(`    ... and ${bucket.count - 3} more`);
+      }
+    }
+  }
+  const legacy = diagnostics.historianDumps.legacyDumps;
+  if (legacy.count > 0) {
+    log.info(`Legacy historian dumps (pre-v0.18.x): ${legacy.count} file(s) in ${legacy.dir}`);
   }
   if (paths.omoConfig) {
     log.info(`OMO config found: ${paths.omoConfig}`);
@@ -28981,10 +29302,11 @@ async function runDoctor(options = {}) {
   }
   return 0;
 }
-var import_comment_json7, PLUGIN_NAME6 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY_WITH_VERSION2, CLI_PACKAGE_NAME = "@cortexkit/magic-context";
+var import_comment_json9, PLUGIN_NAME6 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY_WITH_VERSION2, CLI_PACKAGE_NAME = "@cortexkit/magic-context";
 var init_doctor_opencode = __esm(async () => {
   init_config();
   init_variable();
+  init_aft_availability();
   init_conflict_detector();
   init_conflict_fixer();
   init_data_path();
@@ -28996,9 +29318,10 @@ var init_doctor_opencode = __esm(async () => {
   init_paths();
   init_prompts();
   await init_sqlite();
-  import_comment_json7 = __toESM(require_src2(), 1);
+  import_comment_json9 = __toESM(require_src2(), 1);
   PLUGIN_ENTRY_WITH_VERSION2 = `${PLUGIN_NAME6}@latest`;
 });
+
 // ../plugin/src/features/magic-context/compartment-storage.ts
 var insertCompartmentStatements, insertFactStatements;
 var init_compartment_storage = __esm(() => {
@@ -29138,7 +29461,7 @@ function binarySearchBytes(sortedArray, key) {
   }
   return -1;
 }
-function escapeRegex4(str) {
+function escapeRegex3(str) {
   return str.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
 }
 function bytePairMerge(piece, stringRanks, binaryFirstByteIndex) {
@@ -29248,7 +29571,7 @@ var Tokenizer = class {
     };
     this.specialTokenKeys = Object.keys(this.specialTokens);
     this.hasSpecialTokens = this.specialTokenKeys.length > 0;
-    this.specialTokensRegex = this.hasSpecialTokens ? new RegExp(this.specialTokenKeys.map(escapeRegex4).join("|"), "g") : null;
+    this.specialTokensRegex = this.hasSpecialTokens ? new RegExp(this.specialTokenKeys.map(escapeRegex3).join("|"), "g") : null;
     this.inverseSpecialTokens = {};
     for (const [text2, rank] of Object.entries(this.specialTokens))
       this.inverseSpecialTokens[rank] = textEncoder.encode(text2);
@@ -29278,7 +29601,7 @@ var Tokenizer = class {
     const allowedSet = new Set(allowedSpecial === "all" ? this.specialTokenKeys : allowedSpecial);
     const disallowedSet = new Set(disallowedSpecial === "all" ? this.specialTokenKeys.filter((x2) => !allowedSet.has(x2)) : disallowedSpecial);
     if (disallowedSet.size > 0) {
-      const disallowedRegex = new RegExp([...disallowedSet].map(escapeRegex4).join("|"), "g");
+      const disallowedRegex = new RegExp([...disallowedSet].map(escapeRegex3).join("|"), "g");
       const match = text2.match(disallowedRegex);
       if (match)
         throw new Error(`Text contains disallowed special token: ${match[0]}`);
@@ -161582,6 +161905,34 @@ function getErrorMessage(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
 
+// ../plugin/src/features/magic-context/key-files/project-key-files.ts
+import { existsSync as existsSync17, readFileSync as readFileSync14, realpathSync } from "node:fs";
+function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
+  const cutoff = now - ORPHAN_GRACE_MS;
+  const rows = db.prepare(`SELECT project_path AS projectPath, MAX(generated_at) AS lastGen
+               FROM project_key_files
+              GROUP BY project_path
+             HAVING lastGen < ?`).all(cutoff);
+  let deletedProjects = 0;
+  for (const row of rows) {
+    if (existsSync17(row.projectPath))
+      continue;
+    try {
+      db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(row.projectPath);
+      db.prepare("DELETE FROM project_key_files_version WHERE project_path = ?").run(row.projectPath);
+      deletedProjects++;
+    } catch (error51) {
+      log2(`[key-files] orphan GC failed for ${row.projectPath}:`, error51);
+    }
+  }
+  return deletedProjects;
+}
+var ORPHAN_GRACE_MS;
+var init_project_key_files = __esm(() => {
+  init_logger();
+  ORPHAN_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
+});
+
 // ../plugin/src/features/magic-context/migrations.ts
 function ensureMigrationsTable(db) {
   db.exec(`
@@ -161784,6 +162135,9 @@ var init_migrations = __esm(async () => {
                     embedding BLOB NOT NULL,
                     model_id TEXT NOT NULL,
                     created_at INTEGER NOT NULL,
+                    -- FK-cascade audit (v12): git_commit_embeddings.sha -> git_commits.sha
+                    -- uses ON DELETE CASCADE, so SQLite PRAGMA foreign_keys must be ON on
+                    -- every connection and v12 cleans historical orphan rows.
                     FOREIGN KEY(sha) REFERENCES git_commits(sha) ON DELETE CASCADE
                 );
 
@@ -161923,10 +162277,72 @@ var init_migrations = __esm(async () => {
           db.exec("ALTER TABLE session_meta ADD COLUMN todo_synthetic_state_json TEXT DEFAULT ''");
         }
       }
+    },
+    {
+      version: 12,
+      description: "Clean orphan rows from FK-cascade embedding tables",
+      up: (db) => {
+        const hasTable = (name2) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name2));
+        const memoryEmbeddings = hasTable("memory_embeddings") ? db.prepare(`DELETE FROM memory_embeddings
+                           WHERE memory_id NOT IN (SELECT id FROM memories)`).run().changes : 0;
+        log2(`[migrations] v12 cleaned ${memoryEmbeddings} orphan memory_embeddings row(s)`);
+        const gitCommitEmbeddings = hasTable("git_commit_embeddings") ? db.prepare(`DELETE FROM git_commit_embeddings
+                           WHERE sha NOT IN (SELECT sha FROM git_commits)`).run().changes : 0;
+        log2(`[migrations] v12 cleaned ${gitCommitEmbeddings} orphan git_commit_embeddings row(s)`);
+      }
+    },
+    {
+      version: 13,
+      description: "Add pending_compaction_marker_state column for deferred marker drain",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+        if (!cols.some((c2) => c2.name === "pending_compaction_marker_state")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN pending_compaction_marker_state TEXT");
+        }
+      }
+    },
+    {
+      version: 14,
+      description: "Add project-scoped key files and version counter",
+      up: (db) => {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS project_key_files (
+                    project_path           TEXT    NOT NULL,
+                    path                   TEXT    NOT NULL,
+                    content                TEXT    NOT NULL,
+                    content_hash           TEXT    NOT NULL,
+                    local_token_estimate   INTEGER NOT NULL,
+                    generated_at           INTEGER NOT NULL,
+                    generated_by_model     TEXT,
+                    generation_config_hash TEXT    NOT NULL,
+                    stale_reason           TEXT,
+                    PRIMARY KEY (project_path, path)
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_project_key_files_project
+                    ON project_key_files(project_path);
+                CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at
+                    ON project_key_files(project_path, generated_at);
+
+                CREATE TABLE IF NOT EXISTS project_key_files_version (
+                    project_path TEXT    PRIMARY KEY,
+                    version      INTEGER NOT NULL DEFAULT 0
+                );
+            `);
+      }
+    },
+    {
+      version: 15,
+      description: "Add deferred_execute_state column for boundary execution drain",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+        if (!cols.some((c2) => c2.name === "deferred_execute_state")) {
+          db.exec("ALTER TABLE session_meta ADD COLUMN deferred_execute_state TEXT");
+        }
+      }
     }
   ];
 });
-
 // ../plugin/src/features/magic-context/tool-definition-tokens.ts
 function keyFor(providerID, modelID, agentName) {
   const agent = agentName && agentName.length > 0 ? agentName : "default";
@@ -161961,7 +162377,7 @@ var init_tool_definition_tokens = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { join as join16 } from "node:path";
 function resolveOpencodeDbPath() {
   return join16(getDataDir(), "opencode", "opencode.db");
@@ -161999,7 +162415,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync16(opencodeDbPath)) {
+  if (!existsSync18(opencodeDbPath)) {
     log2(`[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");
@@ -162209,25 +162625,25 @@ var init_tool_owner_backfill = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync17, mkdirSync as mkdirSync7 } from "node:fs";
+import { copyFileSync, cpSync, existsSync as existsSync19, mkdirSync as mkdirSync7 } from "node:fs";
 import { join as join17 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
   return { dbDir, dbPath: join17(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync17(targetDbPath))
+  if (existsSync19(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
   const legacyDbPath = join17(legacyDir, "context.db");
-  if (!existsSync17(legacyDbPath))
+  if (!existsSync19(legacyDbPath))
     return;
   log2(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   mkdirSync7(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
     const dst = join17(targetDbDir, `context.db${suffix}`);
-    if (existsSync17(src)) {
+    if (existsSync19(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -162237,7 +162653,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   const legacyModelsDir = join17(legacyDir, "models");
   const targetModelsDir = join17(targetDbDir, "models");
-  if (existsSync17(legacyModelsDir) && !existsSync17(targetModelsDir)) {
+  if (existsSync19(legacyModelsDir) && !existsSync19(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -162246,9 +162662,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
 }
 function initializeDatabase(db) {
+  db.exec("PRAGMA foreign_keys=ON");
   db.exec("PRAGMA journal_mode=WAL");
   db.exec("PRAGMA busy_timeout=5000");
-  db.exec("PRAGMA foreign_keys=ON");
   db.exec(`
     CREATE TABLE IF NOT EXISTS tags (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -162346,6 +162762,9 @@ function initializeDatabase(db) {
     );
 
     CREATE TABLE IF NOT EXISTS memory_embeddings (
+      -- FK-cascade audit (v12): memory_embeddings.memory_id -> memories.id
+      -- uses ON DELETE CASCADE, so SQLite PRAGMA foreign_keys must be ON on
+      -- every connection and v12 cleans historical orphan rows.
       memory_id INTEGER PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
       embedding BLOB NOT NULL,
       model_id TEXT
@@ -162382,6 +162801,26 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     );
     CREATE INDEX IF NOT EXISTS idx_dream_runs_project ON dream_runs(project_path, finished_at DESC);
 
+    CREATE TABLE IF NOT EXISTS project_key_files (
+      project_path           TEXT    NOT NULL,
+      path                   TEXT    NOT NULL,
+      content                TEXT    NOT NULL,
+      content_hash           TEXT    NOT NULL,
+      local_token_estimate   INTEGER NOT NULL,
+      generated_at           INTEGER NOT NULL,
+      generated_by_model     TEXT,
+      generation_config_hash TEXT    NOT NULL,
+      stale_reason           TEXT,
+      PRIMARY KEY (project_path, path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_project ON project_key_files(project_path);
+    CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at ON project_key_files(project_path, generated_at);
+
+    CREATE TABLE IF NOT EXISTS project_key_files_version (
+      project_path TEXT    PRIMARY KEY,
+      version      INTEGER NOT NULL DEFAULT 0
+    );
+
     -- (smart_notes: see note above; merged into unified notes table by migration v1)
 
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
@@ -162453,7 +162892,17 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       system_prompt_hash TEXT DEFAULT '',
       memory_block_cache TEXT DEFAULT '',
       memory_block_count INTEGER DEFAULT 0,
-      memory_block_ids TEXT DEFAULT ''
+      memory_block_ids TEXT DEFAULT '',
+      -- pending_compaction_marker_state: intentionally NULLABLE without a
+      -- default. Absence of a deferred marker is SQL NULL; presence is a
+      -- valid JSON blob written via setPendingCompactionMarkerState.
+      -- Excluded from healNullTextColumns. Readers filter IS NOT NULL AND
+      -- != empty-string defensively. Plan v6 section 3.
+      pending_compaction_marker_state TEXT,
+      -- deferred_execute_state: intentionally NULLABLE without a default.
+      -- Absence is SQL NULL; presence is a JSON blob written via
+      -- setDeferredExecutePendingIfAbsent. Excluded from healNullTextColumns.
+      deferred_execute_state TEXT
     );
 
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
@@ -162541,6 +162990,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "recomp_partial_range_end", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "detected_context_limit", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "needs_emergency_recovery", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "pending_compaction_marker_state", "TEXT");
+  ensureColumn(db, "session_meta", "deferred_execute_state", "TEXT");
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "source_contents", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -162617,7 +163068,15 @@ function ensureColumn(db, table, column, definition) {
   if (rows.some((row) => row.name === column)) {
     return;
   }
-  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  } catch (err) {
+    const recheck = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (recheck.some((row) => row.name === column)) {
+      return;
+    }
+    throw err;
+  }
 }
 function openDatabase() {
   const { dbDir, dbPath } = resolveDatabasePath();
@@ -162634,6 +163093,11 @@ function openDatabase() {
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
+    try {
+      deleteOrphanProjectKeyFiles(db);
+    } catch (error51) {
+      log2(`[magic-context] key-files orphan GC failed: ${getErrorMessage(error51)}`);
+    }
     try {
       runToolOwnerBackfill(db);
     } catch (error51) {
@@ -162669,6 +163133,7 @@ var databases, persistenceByDatabase, persistenceErrorByDatabase;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
+  init_project_key_files();
   init_tool_definition_tokens();
   init_tool_owner_backfill();
   await __promiseAll([
@@ -162772,24 +163237,24 @@ var init_storage = __esm(async () => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
+import { existsSync as existsSync20, readFileSync as readFileSync15 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
 import { join as join18 } from "node:path";
 function getProjectConfigPaths(cwd) {
   const basePath = join18(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
-  const home = process.env.HOME ?? homedir12();
+  const home = process.env.HOME ?? homedir14();
   const basePath = join18(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path4) => existsSync18(path4));
+  return paths.find((path4) => existsSync20(path4));
 }
 function loadConfigFile2(path4, scope) {
   try {
-    const rawText = readFileSync12(path4, "utf-8");
+    const rawText = readFileSync15(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
       configPath: path4
@@ -162797,7 +163262,7 @@ function loadConfigFile2(path4, scope) {
     return {
       path: path4,
       scope,
-      config: import_comment_json8.parse(substituted.text),
+      config: import_comment_json10.parse(substituted.text),
       warnings: substituted.warnings.map((warning) => `${path4}: ${warning}`)
     };
   } catch (error51) {
@@ -162910,18 +163375,18 @@ function loadPiConfig(opts = {}) {
     loadedFromPaths: loadedFiles.map((loaded) => loaded.path)
   };
 }
-var import_comment_json8, CONFIG_FILE_NAME = "magic-context";
+var import_comment_json10, CONFIG_FILE_NAME = "magic-context";
 var init_config2 = __esm(() => {
   init_magic_context();
   init_variable();
-  import_comment_json8 = __toESM(require_src2(), 1);
+  import_comment_json10 = __toESM(require_src2(), 1);
 });
 
 // src/lib/diagnostics-pi.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync19, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync21, readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { homedir as homedir13, tmpdir as tmpdir5, userInfo as userInfo3 } from "node:os";
+import { homedir as homedir15, userInfo as userInfo2 } from "node:os";
 import { join as join19 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire5(import.meta.url);
@@ -162937,34 +163402,34 @@ function getSelfVersion3() {
 }
 function fileSize2(path4) {
   try {
-    return existsSync19(path4) ? statSync4(path4).size : 0;
+    return existsSync21(path4) ? statSync4(path4).size : 0;
   } catch {
     return 0;
   }
 }
-function escapeRegex5(value) {
+function escapeRegex4(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function currentUserHash() {
-  const username = userInfo3().username || "unknown";
+  const username = userInfo2().username || "unknown";
   return createHash("sha256").update(username).digest("hex").slice(0, 12);
 }
 function redactSecretString(value) {
   return value.replace(/Bearer\s+[A-Za-z0-9._~+\-/=]+/g, "Bearer <REDACTED>").replace(/sk-[A-Za-z0-9_-]{12,}/g, "sk-<REDACTED>").replace(/api[_-]?key=([^\s&]+)/gi, "api_key=<REDACTED>").replace(/token=([^\s&]+)/gi, "token=<REDACTED>");
 }
 function sanitizeString2(value) {
-  const home = process.env.HOME || homedir13();
-  const username = userInfo3().username;
+  const home = process.env.HOME || homedir15();
+  const username = userInfo2().username;
   const userHash = `<USER:${currentUserHash()}>`;
   let sanitized = redactSecretString(value);
   if (home) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex5(home), "g"), "<HOME>");
+    sanitized = sanitized.replace(new RegExp(escapeRegex4(home), "g"), "<HOME>");
   }
   sanitized = sanitized.replace(/\/Users\/[^/]+\//g, `/Users/${userHash}/`);
   sanitized = sanitized.replace(/\/home\/[^/]+\//g, `/home/${userHash}/`);
   sanitized = sanitized.replace(/C:\\Users\\[^\\]+\\/g, `C:\\Users\\${userHash}\\`);
   if (username) {
-    sanitized = sanitized.replace(new RegExp(escapeRegex5(username), "g"), userHash);
+    sanitized = sanitized.replace(new RegExp(escapeRegex4(username), "g"), userHash);
   }
   return sanitized;
 }
@@ -162987,11 +163452,11 @@ function sanitizeValue2(value, key = "") {
   return value;
 }
 function readJsonc3(path4) {
-  if (!existsSync19(path4))
+  if (!existsSync21(path4))
     return { value: {} };
   try {
     return {
-      value: import_comment_json9.parse(readFileSync13(path4, "utf-8"))
+      value: import_comment_json11.parse(readFileSync16(path4, "utf-8"))
     };
   } catch (error51) {
     return {
@@ -163007,16 +163472,159 @@ function readConfigDiagnostic(path4) {
   const parsed = readJsonc3(path4);
   return {
     path: path4,
-    exists: existsSync19(path4),
+    exists: existsSync21(path4),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
 }
 function packageEntries(settings) {
-  return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
+  return Array.isArray(settings.packages) ? settings.packages : [];
+}
+function reverseSlugToDirectory(slug) {
+  if (!slug.startsWith("--") || !slug.endsWith("--"))
+    return null;
+  const inner = slug.slice(2, -2);
+  if (!inner)
+    return null;
+  return `/${inner.replace(/-/g, "/")}`;
+}
+function collectPiRecentSessions() {
+  const sessionsRoot = join19(homedir15(), ".pi", "agent", "sessions");
+  if (!existsSync21(sessionsRoot))
+    return [];
+  try {
+    const slugs = readdirSync3(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 = join19(sessionsRoot, slug);
+      let files;
+      try {
+        files = readdirSync3(slugDir).filter((name2) => name2.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const file2 of files) {
+        try {
+          const mtime = statSync4(join19(slugDir, file2)).mtimeMs;
+          const sessionId = file2.replace(/\.jsonl$/, "");
+          candidates.push({ sessionId, directory, mtime });
+        } catch {}
+      }
+    }
+    candidates.sort((a, b2) => b2.mtime - a.mtime);
+    return candidates.slice(0, 5).map((entry) => ({
+      sessionId: entry.sessionId,
+      directory: entry.directory,
+      lastActiveAt: new Date(entry.mtime).toISOString()
+    }));
+  } catch {
+    return [];
+  }
+}
+function parseHistorianDumpMeta2(path4) {
+  try {
+    const xml = readFileSync16(path4, "utf-8");
+    const parsed = parseCompartmentOutput(xml);
+    const factCountByCategory = {};
+    for (const fact of parsed.facts) {
+      factCountByCategory[fact.category] = (factCountByCategory[fact.category] ?? 0) + 1;
+    }
+    const starts = parsed.compartments.map((c2) => c2.startMessage);
+    const ends = parsed.compartments.map((c2) => c2.endMessage);
+    let gaps = 0;
+    let overlaps = 0;
+    for (let i = 1;i < parsed.compartments.length; i++) {
+      const prev = parsed.compartments[i - 1];
+      const curr = parsed.compartments[i];
+      if (curr.startMessage > prev.endMessage + 1)
+        gaps += 1;
+      else if (curr.startMessage <= prev.endMessage)
+        overlaps += 1;
+    }
+    return {
+      compartmentCount: parsed.compartments.length,
+      minStart: starts.length > 0 ? Math.min(...starts) : null,
+      maxEnd: ends.length > 0 ? Math.max(...ends) : null,
+      unprocessedFrom: parsed.unprocessedFrom,
+      factCountByCategory,
+      userObservationCount: parsed.userObservations.length,
+      ordinalGapCount: gaps,
+      ordinalOverlapCount: overlaps
+    };
+  } catch (error51) {
+    return { error: error51 instanceof Error ? error51.message : String(error51) };
+  }
 }
-function hasMagicContextPackage(packages) {
-  return packages.some((entry) => entry === PI_PACKAGE_SOURCE || entry === PACKAGE_NAME || entry.includes("pi-magic-context"));
+function listDumpsInDir2(dir, limit) {
+  if (!existsSync21(dir))
+    return { count: 0, recent: [] };
+  try {
+    const entries = readdirSync3(dir).filter((name2) => name2.endsWith(".xml")).map((name2) => {
+      const stat = statSync4(join19(dir, name2));
+      return {
+        name: name2,
+        mtime: stat.mtimeMs,
+        sizeKb: Math.round(stat.size / 1024)
+      };
+    }).sort((a, b2) => b2.mtime - a.mtime);
+    const now = Date.now();
+    const recent = entries.slice(0, limit).map((entry) => {
+      const meta3 = parseHistorianDumpMeta2(join19(dir, entry.name));
+      const summary = {
+        name: entry.name,
+        ageMinutes: Math.round((now - entry.mtime) / 60000),
+        sizeKb: entry.sizeKb
+      };
+      if ("error" in meta3) {
+        summary.parseError = meta3.error;
+      } else {
+        summary.meta = meta3;
+      }
+      return summary;
+    });
+    return { count: entries.length, recent };
+  } catch {
+    return { count: 0, recent: [] };
+  }
+}
+function collectPiHistorianDumps(recentSessions) {
+  const buckets = new Map;
+  for (const session of recentSessions) {
+    const dir = session.directory;
+    if (!dir)
+      continue;
+    const projectHistorianDir = getProjectMagicContextHistorianDir(dir);
+    const listing = listDumpsInDir2(projectHistorianDir, 5);
+    const existing = buckets.get(dir);
+    if (existing) {
+      if (!existing.sessionIds.includes(session.sessionId)) {
+        existing.sessionIds.push(session.sessionId);
+      }
+      continue;
+    }
+    if (listing.count === 0)
+      continue;
+    buckets.set(dir, {
+      directory: dir,
+      primarySessionId: session.sessionId,
+      sessionIds: [session.sessionId],
+      count: listing.count,
+      recent: listing.recent
+    });
+  }
+  const legacyDir = getMagicContextHistorianDir2("pi");
+  const legacyListing = listDumpsInDir2(legacyDir, 5);
+  return {
+    byProject: [...buckets.values()],
+    legacyDumps: {
+      dir: legacyDir,
+      count: legacyListing.count,
+      recent: legacyListing.recent
+    }
+  };
 }
 async function collectDiagnostics2(cwd = process.cwd()) {
   const pi = detectPiBinary();
@@ -163028,9 +163636,11 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const loaded = loadPiConfig({ cwd });
   const storageDirPath = getMagicContextStorageDir();
   const dbPath = join19(storageDirPath, "context.db");
-  const logPath = join19(tmpdir5(), "magic-context.log");
-  const logFileSize = existsSync19(logPath) ? statSync4(logPath).size : 0;
-  const otherPiExtensions = packages.filter((entry) => !hasMagicContextPackage([entry]));
+  const logPath = getMagicContextLogPath2("pi");
+  const logFileSize = existsSync21(logPath) ? statSync4(logPath).size : 0;
+  const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
+  const recentSessions = collectPiRecentSessions();
+  const historianDumps = collectPiHistorianDumps(recentSessions);
   return {
     timestamp: new Date().toISOString(),
     platform: process.platform,
@@ -163042,10 +163652,10 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync19(settingsPath),
+      exists: existsSync21(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
-      hasMagicContextPackage: hasMagicContextPackage(packages),
-      packages: packages.map(sanitizeString2)
+      hasMagicContextPackage: hasPiMagicContextPackage(packages),
+      packages: sanitizeValue2(packages)
     },
     configPaths: {
       agentDir: getPiAgentConfigDir(),
@@ -163058,7 +163668,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     loadWarnings: loaded.warnings.map(sanitizeString2),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync19(storageDirPath),
+      exists: existsSync21(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -163067,9 +163677,11 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync19(logPath),
+      exists: existsSync21(logPath),
       sizeKb: Math.round(logFileSize / 1024)
-    }
+    },
+    recentSessions,
+    historianDumps
   };
 }
 function formatBytes2(bytes) {
@@ -163146,17 +163758,19 @@ function renderDiagnosticsMarkdown2(report) {
   ].join(`
 `);
 }
-var import_comment_json9, PACKAGE_NAME = "@cortexkit/pi-magic-context";
+var import_comment_json11;
 var init_diagnostics_pi = __esm(() => {
+  init_compartment_parser();
   init_data_path();
   init_config2();
   init_paths();
   init_pi_helpers();
-  import_comment_json9 = __toESM(require_src2(), 1);
+  init_pi_package_entry();
+  import_comment_json11 = __toESM(require_src2(), 1);
 });
 
 // src/lib/logs-pi.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync11 } from "node:fs";
 import { join as join20 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
@@ -163173,9 +163787,21 @@ function formatTimestamp2(date5) {
     pad(date5.getSeconds())
   ].join("");
 }
+function filterLogLinesBySession2(lines, sessionId) {
+  if (!sessionId)
+    return lines;
+  const otherSessionPattern = /\bses_[A-Za-z0-9]{8,32}\b/g;
+  return lines.filter((line) => {
+    const matches = line.match(otherSessionPattern);
+    if (!matches)
+      return true;
+    return matches.every((id) => id === sessionId);
+  });
+}
 async function bundleIssueReport2(report, description, title, options = {}) {
   const LOG_TAIL_LINES = 400;
-  const logLines = report.logFile.exists ? readFileSync14(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const allLogLines = report.logFile.exists ? readFileSync17(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const logLines = filterLogLinesBySession2(allLogLines, options.sessionFilter ?? null);
   const recentLog = sanitizeLogContent2(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
   const bodyMarkdown = [
@@ -163213,16 +163839,16 @@ var init_logs_pi = __esm(() => {
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync4, spawnSync as spawnSync3 } from "node:child_process";
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync18,
   rmSync as rmSync2,
   statSync as statSync5,
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { homedir as homedir14, tmpdir as tmpdir6 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 import { dirname as dirname9, join as join21 } from "node:path";
 function depsFrom(options) {
   return {
@@ -163310,7 +163936,7 @@ function summarize(results) {
 function readJsonc4(path4) {
   try {
     return {
-      value: import_comment_json10.parse(readFileSync15(path4, "utf-8"))
+      value: import_comment_json12.parse(readFileSync18(path4, "utf-8"))
     };
   } catch (error51) {
     return {
@@ -163320,24 +163946,21 @@ function readJsonc4(path4) {
   }
 }
 function packagesFrom(settings) {
-  return Array.isArray(settings.packages) ? settings.packages.filter((entry) => typeof entry === "string") : [];
-}
-function hasPiPackage(packages) {
-  return packages.some((entry) => entry === PI_PACKAGE_SOURCE || entry === PACKAGE_NAME2 || entry.includes("pi-magic-context"));
+  return Array.isArray(settings.packages) ? settings.packages : [];
 }
 function projectConfigPath(cwd) {
   return join21(cwd, ".pi", "magic-context.jsonc");
 }
 function readConfigForEmbedding(path4) {
-  if (!existsSync20(path4))
+  if (!existsSync22(path4))
     return null;
   try {
-    const rawText = readFileSync15(path4, "utf-8");
+    const rawText = readFileSync18(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
       configPath: path4
     });
-    return import_comment_json10.parse(substituted.text);
+    return import_comment_json12.parse(substituted.text);
   } catch {
     return null;
   }
@@ -163390,7 +164013,7 @@ function countTable(db, table) {
   }
 }
 function cacheRoots() {
-  const home = homedir14();
+  const home = homedir16();
   const cacheHome = process.env.XDG_CACHE_HOME || join21(home, ".cache");
   return [
     join21(home, ".pi", "cache", "extensions"),
@@ -163403,7 +164026,7 @@ function cacheRoots() {
 function findPiMagicContextCacheDirs(self, force = false) {
   const found = new Map;
   const visit = (path4, depth) => {
-    if (depth < 0 || !existsSync20(path4))
+    if (depth < 0 || !existsSync22(path4))
       return;
     let stat;
     try {
@@ -163414,12 +164037,12 @@ function findPiMagicContextCacheDirs(self, force = false) {
     if (!stat.isDirectory())
       return;
     const packageJson = join21(path4, "package.json");
-    if (existsSync20(packageJson)) {
+    if (existsSync22(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync15(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync18(packageJson, "utf-8"));
         const name2 = typeof pkg.name === "string" ? pkg.name : "";
         const version2 = typeof pkg.version === "string" ? pkg.version : undefined;
-        if (name2 === PACKAGE_NAME2 || path4.includes("pi-magic-context")) {
+        if (name2 === PACKAGE_NAME || path4.includes("pi-magic-context")) {
           if (force || !version2 || version2 !== self)
             found.set(path4, { path: path4, version: version2 });
         }
@@ -163457,7 +164080,7 @@ async function runHealthChecks(options) {
     add(results, "pass", version2 ? `Pi ${version2} detected at ${pi.path}` : `Pi detected at ${pi.path}`);
     const compare = compareSemver(version2, MIN_PI_VERSION);
     if (compare !== null && compare < 0) {
-      add(results, "fail", `Pi ${version2} is older than required ${MIN_PI_VERSION}. Subagents (historian/dreamer/sidekick) use the long-form \`--extension\` flag introduced in Pi 0.71.0; older versions hard-fail with "Unknown option". Run \`pi update\` (or \`npm install -g @mariozechner/pi-coding-agent@latest\`).`);
+      add(results, "fail", `Pi ${version2} is older than required ${MIN_PI_VERSION}. Subagents (historian/dreamer/sidekick) use the long-form \`--extension\` flag introduced in Pi 0.71.0; older versions hard-fail with "Unknown option". Run \`pi update\` (or \`npm install -g @earendil-works/pi-coding-agent@latest\`).`);
     } else if (version2) {
       add(results, "pass", `Pi version meets minimum ${MIN_PI_VERSION} requirement`);
     }
@@ -163472,7 +164095,7 @@ async function runHealthChecks(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync20(settingsPath)) {
+  if (!existsSync22(settingsPath)) {
     add(results, "warn", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -163482,7 +164105,7 @@ async function runHealthChecks(options) {
     } else {
       packages = packagesFrom(parsed.value);
       add(results, "pass", `Pi settings found at ${settingsPath}`);
-      if (hasPiPackage(packages)) {
+      if (hasPiMagicContextPackage(packages)) {
         add(results, "pass", `${PI_PACKAGE_SOURCE} is registered in packages[]`);
       } else {
         add(results, "warn", `${PI_PACKAGE_SOURCE} is missing from packages[]`);
@@ -163496,7 +164119,7 @@ async function runHealthChecks(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync20(path4)) {
+    if (!existsSync22(path4)) {
       if (required2) {
         add(results, "warn", `No ${label} magic-context.jsonc found at ${path4}`);
         repairPlan.writeUserConfig = true;
@@ -163530,7 +164153,7 @@ async function runHealthChecks(options) {
   }
   const storageDir = getMagicContextStorageDir();
   const dbPath = join21(storageDir, "context.db");
-  const existedBeforeOpen = existsSync20(dbPath);
+  const existedBeforeOpen = existsSync22(dbPath);
   if (existedBeforeOpen)
     add(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -163587,13 +164210,13 @@ async function runHealthChecks(options) {
   } else {
     add(results, "pass", `Embedding provider: ${loadedConfig.config.embedding.provider}`);
   }
-  const piEntries = packages.filter((entry) => hasPiPackage([entry]));
+  const piEntries = packages.filter(isPiMagicContextPackageEntry).map(describePiPackageEntry);
   if (piEntries.length > 1) {
     add(results, "fail", `Multiple magic-context entries in Pi packages[] — this loads the plugin twice: ${piEntries.join(", ")}`);
   } else {
     add(results, "pass", "No conflicting magic-context entries in Pi packages[]");
   }
-  const otherExtensions = packages.filter((entry) => !hasPiPackage([entry]));
+  const otherExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
   if (otherExtensions.length > 0) {
     add(results, "info", `Other Pi extensions registered: ${otherExtensions.join(", ")}`);
   } else {
@@ -163606,32 +164229,36 @@ async function runHealthChecks(options) {
   } else {
     add(results, "pass", "Pi extension cache clean (no stale cached package found)");
   }
-  const logPath = join21(tmpdir6(), "magic-context.log");
-  if (existsSync20(logPath)) {
+  const logPath = getMagicContextLogPath2("pi");
+  if (existsSync22(logPath)) {
     const stat = statSync5(logPath);
     const sizeKb = (stat.size / 1024).toFixed(0);
-    const lines = readFileSync15(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const lines = readFileSync18(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     add(results, "info", `Log file: ${logPath} (${sizeKb} KB)`);
     add(results, "info", `Last plugin log line: ${lines.at(-1) ?? "<empty log>"}`);
   } else {
     add(results, "info", `No plugin log file yet at ${logPath}`);
   }
-  const historianDumpDir = join21(tmpdir6(), "magic-context-historian");
-  if (existsSync20(historianDumpDir)) {
-    try {
-      const dumps = readdirSync4(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({ name: f, mtime: statSync5(join21(historianDumpDir, f)).mtimeMs })).sort((a, b2) => b2.mtime - a.mtime);
-      if (dumps.length > 0) {
-        add(results, "warn", `Historian debug dumps: ${dumps.length} file(s) in ${historianDumpDir}`);
-        for (const dump of dumps.slice(0, 3)) {
-          const age = Math.round((Date.now() - dump.mtime) / 60000);
-          const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
-          add(results, "info", `  ${dump.name} (${ageStr})`);
-        }
-        if (dumps.length > 3) {
-          add(results, "info", `  ... and ${dumps.length - 3} more`);
-        }
+  const diagnosticsForDumps = await collectDiagnostics2(options.cwd);
+  const dumpBuckets = diagnosticsForDumps.historianDumps.byProject;
+  if (dumpBuckets.length > 0) {
+    const totalCount = dumpBuckets.reduce((sum, b2) => sum + b2.count, 0);
+    add(results, "warn", `Historian debug dumps: ${totalCount} file(s) across ${dumpBuckets.length} project(s)`);
+    for (const bucket of dumpBuckets) {
+      add(results, "info", `  [${bucket.directory}] ${bucket.count} file(s)`);
+      for (const dump of bucket.recent.slice(0, 3)) {
+        const age = dump.ageMinutes;
+        const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+        add(results, "info", `    ${dump.name} (${ageStr})`);
       }
-    } catch {}
+      if (bucket.count > 3) {
+        add(results, "info", `    ... and ${bucket.count - 3} more`);
+      }
+    }
+  }
+  const legacyDumps = diagnosticsForDumps.historianDumps.legacyDumps;
+  if (legacyDumps.count > 0) {
+    add(results, "info", `Legacy historian dumps (pre-v0.18.x): ${legacyDumps.count} file(s) in ${legacyDumps.dir}`);
   }
   if (!options.quiet) {
     for (const result of results)
@@ -163645,7 +164272,7 @@ function writeDefaultMagicContextConfig(path4) {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
   };
-  writeFileSync12(path4, `${import_comment_json10.stringify(config2, null, 2)}
+  writeFileSync12(path4, `${import_comment_json12.stringify(config2, null, 2)}
 `);
 }
 function repair(plan, prompts) {
@@ -163662,7 +164289,7 @@ function repair(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync20(configPath)) {
+    if (!existsSync22(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -163710,9 +164337,26 @@ async function runIssueFlow2(options) {
   spinner2.start("Collecting sanitized Pi diagnostics");
   try {
     const report = await options.deps.collectDiagnostics(options.cwd);
+    spinner2.stop("Diagnostics collected");
+    let sessionFilter = null;
+    if (report.recentSessions.length > 1) {
+      const choice = await options.prompts.selectOne("Which Pi session is this issue about? (filters log lines from other sessions)", [
+        ...report.recentSessions.map((session, index) => ({
+          label: `${session.directory} — ${session.sessionId}${index === 0 ? " (most recent)" : ""}`,
+          value: session.sessionId
+        })),
+        {
+          label: "All sessions (no filtering)",
+          value: "__all__"
+        }
+      ]);
+      sessionFilter = choice === "__all__" ? null : choice;
+    }
+    spinner2.start("Bundling Pi issue report");
     const bundled = await bundleIssueReport2(report, description, title, {
       cwd: options.cwd,
-      now: options.deps.now()
+      now: options.deps.now(),
+      sessionFilter
     });
     spinner2.stop(`Report written to ${bundled.path}`);
     if (ghAvailableAndAuthed(options.deps)) {
@@ -163787,7 +164431,7 @@ function parseDoctorArgs(args) {
 function doctor(args = []) {
   return runDoctor2(parseDoctorArgs(args));
 }
-var import_comment_json10, PACKAGE_NAME2 = "@cortexkit/pi-magic-context", MIN_PI_VERSION = "0.71.0", ROW_COUNT_TABLES, DEFAULT_DEPS;
+var import_comment_json12, PACKAGE_NAME = "@cortexkit/pi-magic-context", MIN_PI_VERSION = "0.74.0", ROW_COUNT_TABLES, DEFAULT_DEPS;
 var init_doctor_pi = __esm(async () => {
   init_magic_context();
   init_variable();
@@ -163797,17 +164441,18 @@ var init_doctor_pi = __esm(async () => {
   init_logs_pi();
   init_paths();
   init_pi_helpers();
+  init_pi_package_entry();
   init_prompts();
   init_setup_pi();
   await init_storage();
-  import_comment_json10 = __toESM(require_src2(), 1);
+  import_comment_json12 = __toESM(require_src2(), 1);
   ROW_COUNT_TABLES = ["tags", "compartments", "memories", "notes", "dream_runs"];
   DEFAULT_DEPS = {
     prompts: promptIO,
     collectDiagnostics: collectDiagnostics2,
     detectPiBinary,
     getPiVersion,
-    getLatestNpmVersion: () => getLatestNpmVersion(PACKAGE_NAME2),
+    getLatestNpmVersion: () => getLatestNpmVersion(PACKAGE_NAME),
     probeEmbeddingEndpoint,
     openDatabase,
     isDatabasePersisted,
@@ -163823,7 +164468,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor3
 });
-import { existsSync as existsSync21, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync23, rmSync as rmSync3 } from "node:fs";
 async function runDoctor3(options) {
   if (options.clear)
     return runClear();
@@ -163907,7 +164552,7 @@ async function runClear() {
     const s = spinner();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync21(item.path)) {
+      if (existsSync23(item.path)) {
         rmSync3(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);