@cortexkit/magic-context 0.41.3 → 0.41.4

package/dist/index.js

@@ -2885,7 +2885,7 @@ class OmpAdapter {
     return { path, exists: existsSync5(path), sizeBytes: dirSizeBytes(path) };
   }
   getLogPath() {
-    return getMagicContextLogPath2("pi");
+    return getMagicContextLogPath2("omp");
   }
   getInstalledPluginVersion() {
     const omp = this.deps.detectOmpBinary();
@@ -11192,883 +11192,336 @@ var init_opencode = __esm(() => {
   import_comment_json = __toESM(require_src3(), 1);
 });
 
-// ../plugin/src/shared/jsonc-parser.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
-function stripJsonComments(content) {
-  let result = "";
-  let inString = false;
-  let escaped = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-  for (let index = 0;index < content.length; index += 1) {
-    const char = content[index];
-    const next = content[index + 1];
-    if (inLineComment) {
-      if (char === `
-`) {
-        inLineComment = false;
-        result += char;
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value = value * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value = value * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value = value * 16 + ch - 97 + 10;
+      } else {
+        break;
       }
-      continue;
+      pos++;
+      digits++;
     }
-    if (inBlockComment) {
-      if (char === "*" && next === "/") {
-        inBlockComment = false;
-        index += 1;
-      }
-      continue;
+    if (digits < count) {
+      value = -1;
     }
-    if (inString) {
-      result += char;
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === '"') {
-        inString = false;
+    return value;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
       }
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      result += char;
-      continue;
     }
-    if (char === "/" && next === "/") {
-      inLineComment = true;
-      index += 1;
-      continue;
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
     }
-    if (char === "/" && next === "*") {
-      inBlockComment = true;
-      index += 1;
-      continue;
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
     }
-    result += char;
+    return text.substring(start, end);
   }
-  return result;
-}
-function stripTrailingCommas(content) {
-  let result = "";
-  let inString = false;
-  let escaped = false;
-  for (let index = 0;index < content.length; index += 1) {
-    const char = content[index];
-    if (inString) {
-      result += char;
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === '"') {
-        inString = false;
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
       }
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      result += char;
-      continue;
-    }
-    if (char === ",") {
-      let lookahead = index + 1;
-      while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
-        lookahead += 1;
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
       }
-      const next = content[lookahead];
-      if (next === "}" || next === "]") {
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
         continue;
       }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
     }
-    result += char;
-  }
-  return result;
-}
-function isPrototypePollutionKey(key) {
-  return PROTOTYPE_POLLUTION_KEYS.has(key);
-}
-function sanitizeParsedJson(value, options = {}, path = []) {
-  if (Array.isArray(value)) {
-    return value.map((entry, index) => sanitizeParsedJson(entry, options, [...path, index]));
-  }
-  if (value === null || typeof value !== "object")
-    return value;
-  const source = value;
-  const sourcePrototype = Object.getPrototypeOf(source);
-  if (sourcePrototype !== null && sourcePrototype !== Object.prototype) {
-    options.onRejectedKey?.([...path, "__proto__"]);
+    return result;
   }
-  const sanitized = {};
-  for (const key of Object.keys(source)) {
-    if (isPrototypePollutionKey(key)) {
-      options.onRejectedKey?.([...path, key]);
-      continue;
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
     }
-    Object.defineProperty(sanitized, key, {
-      value: sanitizeParsedJson(source[key], options, [...path, key]),
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  }
-  return sanitized;
-}
-function parseJsonc2(content, options = {}) {
-  const normalized = stripTrailingCommas(stripJsonComments(content));
-  return sanitizeParsedJson(JSON.parse(normalized), options);
-}
-function readJsoncFile(filePath) {
-  try {
-    return parseJsonc2(readFileSync5(filePath, "utf-8"));
-  } catch (_error) {
-    return null;
-  }
-}
-function detectConfigFile(basePath) {
-  const jsoncPath = `${basePath}.jsonc`;
-  const jsonPath = `${basePath}.json`;
-  if (existsSync8(jsoncPath)) {
-    return { format: "jsonc", path: jsoncPath };
-  }
-  if (existsSync8(jsonPath)) {
-    return { format: "json", path: jsonPath };
-  }
-  return { format: "none", path: jsoncPath };
-}
-var PROTOTYPE_POLLUTION_KEYS;
-var init_jsonc_parser = __esm(() => {
-  PROTOTYPE_POLLUTION_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-});
-
-// src/lib/jsonc-config.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
-function parseErrorLocation(content, error) {
-  const lines = content.split(`
-`);
-  const message = error instanceof Error ? error.message : String(error);
-  if (message.includes("Unexpected end of JSON input")) {
-    return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
-  }
-  const parserLocation = error;
-  if (typeof parserLocation.line === "number" && parserLocation.line >= 1 && parserLocation.line <= lines.length && typeof parserLocation.column === "number" && parserLocation.column >= 0) {
-    return { line: parserLocation.line, column: parserLocation.column + 1 };
   }
-  const messageLine = /Line (\d+)/.exec(message)?.[1];
-  return { line: messageLine ? Number.parseInt(messageLine, 10) : 1, column: 1 };
-}
-function readJsoncConfig(path) {
-  if (!existsSync9(path))
-    return { kind: "missing" };
-  const content = readFileSync6(path, "utf-8");
-  try {
-    const rejectedKeyPaths = [];
-    const parsed = sanitizeParsedJson(import_comment_json2.parse(content), {
-      onRejectedKey: (keyPath) => rejectedKeyPaths.push(keyPath.join("."))
-    });
-    if (rejectedKeyPaths.length > 0) {
-      throw new Error(`unsafe prototype-pollution key at ${rejectedKeyPaths.join(", ")}`);
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
     }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("expected a JSON object at the document root");
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
     }
-    return { kind: "parsed", value: parsed };
-  } catch (error) {
-    return { kind: "parse-error", error: new ConfigParseError(path, content, error) };
+    return true;
   }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
 }
-function readJsoncConfigForUpdate(path) {
-  const result = readJsoncConfig(path);
-  if (result.kind === "missing")
-    return {};
-  if (result.kind === "parse-error")
-    throw result.error;
-  return result.value;
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
 }
-function assertJsoncConfigsParseable(paths) {
-  for (const path of paths) {
-    const result = readJsoncConfig(path);
-    if (result.kind === "parse-error")
-      throw result.error;
-  }
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
 }
-var import_comment_json2, ConfigParseError;
-var init_jsonc_config = __esm(() => {
-  init_jsonc_parser();
-  import_comment_json2 = __toESM(require_src3(), 1);
-  ConfigParseError = class ConfigParseError extends Error {
-    path;
-    constructor(path, content, cause) {
-      const detail = cause instanceof Error ? cause.message : String(cause);
-      const location = parseErrorLocation(content, cause);
-      super(`Refusing to overwrite unparseable config ${path} at line ${location.line}, column ${location.column}: ${detail}`, { cause });
-      this.name = "ConfigParseError";
-      this.path = path;
-    }
-  };
-});
-
-// 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 versionAt = normalized.indexOf("@", slash + 1);
-    return versionAt > 0 ? normalized.slice(0, versionAt) : 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 object = entry;
-    for (const key of ["name", "source"]) {
-      const name = getPiPackageEntryName(object[key]);
-      if (name)
-        return name;
-    }
-  }
-  return null;
-}
-function isPiMagicContextPackageEntry(entry) {
-  if (typeof entry === "string") {
-    return packageNameFromSpecifier(entry) === PI_MAGIC_CONTEXT_PACKAGE_NAME;
-  }
-  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
-    const object = entry;
-    return isPiMagicContextPackageEntry(object.name) || isPiMagicContextPackageEntry(object.source);
-  }
-  return false;
-}
-function getPiMagicContextPackageSpecifier(entry) {
-  if (typeof entry === "string") {
-    return isPiMagicContextPackageEntry(entry) ? entry.trim() : null;
-  }
-  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
-    const object = entry;
-    return getPiMagicContextPackageSpecifier(object.source) ?? getPiMagicContextPackageSpecifier(object.name);
-  }
-  return null;
-}
-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";
-
-// src/adapters/pi.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
-
-class PiAdapter {
-  kind = "pi";
-  displayName = "Pi";
-  pluginPackageName = PLUGIN_NAME;
-  isInstalled() {
-    return detectPiBinary() !== null;
-  }
-  hasPluginEntry() {
-    const settings = readPiSettings();
-    if (!settings)
-      return false;
-    const packages = settings.packages ?? [];
-    return packages.some((entry) => isPiMagicContextPackageEntry(entry));
-  }
-  getConfigPaths() {
-    const dir = getPiAgentConfigDir();
-    return {
-      configDir: dir,
-      pluginConfigPath: getPiUserExtensionsPath(),
-      magicContextConfigPath: getPiUserConfigPath(),
-      secondaryConfigPath: null
-    };
-  }
-  async ensurePluginEntry() {
-    const settingsPath = getPiUserExtensionsPath();
-    try {
-      const settings = readPiSettingsForUpdate();
-      const packages = Array.isArray(settings.packages) ? settings.packages : [];
-      const idx = packages.findIndex((entry) => isPiMagicContextPackageEntry(entry));
-      if (idx === -1) {
-        packages.push(PI_PACKAGE_SOURCE);
-        settings.packages = packages;
-        writePiSettings(settings);
-        return {
-          ok: true,
-          action: "added",
-          message: `Added ${PI_PACKAGE_SOURCE} to ${settingsPath}.`,
-          configPath: settingsPath
-        };
-      }
-      return {
-        ok: true,
-        action: "already_present",
-        message: `Plugin entry already present in ${settingsPath}.`,
-        configPath: settingsPath
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        action: "error",
-        message: `Failed to update ${settingsPath}: ${err.message}`,
-        configPath: settingsPath
-      };
-    }
-  }
-  async removePluginEntry() {
-    const settingsPath = getPiUserExtensionsPath();
-    try {
-      const settings = readPiSettingsForUpdate();
-      if (!Array.isArray(settings.packages)) {
-        return {
-          ok: true,
-          action: "already_present",
-          message: `No packages array in ${settingsPath}.`,
-          configPath: settingsPath
-        };
-      }
-      const before = settings.packages.length;
-      settings.packages = settings.packages.filter((entry) => !isPiMagicContextPackageEntry(entry));
-      if (settings.packages.length === before) {
-        return {
-          ok: true,
-          action: "already_present",
-          message: `Plugin entry not present in ${settingsPath}.`,
-          configPath: settingsPath
-        };
-      }
-      writePiSettings(settings);
-      return {
-        ok: true,
-        action: "updated",
-        message: `Removed ${PLUGIN_NAME} from ${settingsPath}.`,
-        configPath: settingsPath
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        action: "error",
-        message: `Failed to update ${settingsPath}: ${err.message}`,
-        configPath: settingsPath
-      };
-    }
-  }
-  getInstallHint() {
-    return "Install Pi: https://pi.coding/install (npm: @earendil-works/pi-coding-agent)";
-  }
-  getPluginCacheInfo() {
-    return { path: null, exists: false, sizeBytes: 0 };
-  }
-  getLogPath() {
-    return getMagicContextLogPath2("pi");
-  }
-  getInstalledPluginVersion() {
-    const piBin = detectPiBinary();
-    if (!piBin)
-      return null;
-    try {
-      const output = runPiCommand(piBin.path, ["list"], 5000);
-      if (output === null)
-        return null;
-      const re = new RegExp(`${PLUGIN_NAME.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&")}.*?(\\d+\\.\\d+\\.\\d+(?:[-+][\\w.-]+)?)`);
-      const match = re.exec(output);
-      if (match)
-        return match[1] ?? null;
-    } catch {}
-    return null;
-  }
-}
-function readPiSettings() {
-  const result = readJsoncConfig(getPiUserExtensionsPath());
-  return result.kind === "parsed" ? result.value : null;
-}
-function readPiSettingsForUpdate() {
-  return readJsoncConfigForUpdate(getPiUserExtensionsPath());
-}
-function writePiSettings(settings) {
-  const settingsPath = getPiUserExtensionsPath();
-  ensureDir2(settingsPath);
-  const text = import_comment_json3.stringify(settings, null, 2);
-  writeFileAtomic(settingsPath, `${text}
-`);
-}
-function ensureDir2(filePath) {
-  const dir = dirname5(filePath);
-  if (!existsSync10(dir)) {
-    const { mkdirSync } = __require("node:fs");
-    mkdirSync(dir, { recursive: true });
-  }
-}
-var import_comment_json3, PLUGIN_NAME = "@cortexkit/pi-magic-context";
-var init_pi = __esm(() => {
-  init_atomic_write();
-  init_jsonc_config();
-  init_paths();
-  init_pi_helpers();
-  import_comment_json3 = __toESM(require_src3(), 1);
-});
-
-// src/adapters/index.ts
-function getAdapter(kind) {
-  const found = ALL.find((a) => a.kind === kind);
-  if (!found)
-    throw new Error(`Unknown harness: ${kind}`);
-  return found;
-}
-function getInstalledAdapters() {
-  return ALL.filter((a) => a.isInstalled());
-}
-var ALL;
-var init_adapters = __esm(() => {
-  init_omp();
-  init_opencode();
-  init_pi();
-  ALL = [new OpenCodeAdapter, new PiAdapter, new OmpAdapter];
-});
-
-// src/lib/harness-select.ts
-function parseHarnessFlag(argv) {
-  const idx = argv.indexOf("--harness");
-  if (idx === -1)
-    return { kind: "absent" };
-  const value = argv[idx + 1];
-  if (!value || value.startsWith("--"))
-    return { kind: "invalid", value: null };
-  if (value === "opencode" || value === "pi" || value === "omp") {
-    return { kind: "valid", harness: value };
-  }
-  return { kind: "invalid", value };
-}
-async function resolveAdaptersForCommand(argv, options) {
-  const flag = parseHarnessFlag(argv);
-  if (flag.kind === "valid")
-    return [getAdapter(flag.harness)];
-  if (flag.kind === "invalid") {
-    throw new Error(flag.value === null ? "Missing value for --harness (expected opencode, pi, or omp)" : `Invalid --harness value: ${flag.value} (expected opencode, pi, or omp)`);
-  }
-  const installed = getInstalledAdapters();
-  if (installed.length === 0) {
-    log2.warn("No supported harness was detected on PATH (opencode, pi, omp).");
-    const pick = await selectOne(`Which harness do you want to ${options.verb}?`, [
-      {
-        label: "OpenCode",
-        value: "opencode",
-        hint: "@cortexkit/opencode-magic-context"
-      },
-      {
-        label: "Pi",
-        value: "pi",
-        hint: "@cortexkit/pi-magic-context"
-      },
-      {
-        label: "Oh My Pi (OMP)",
-        value: "omp",
-        hint: "@cortexkit/pi-magic-context"
-      }
-    ]);
-    return [getAdapter(pick)];
-  }
-  if (installed.length === 1) {
-    const only = installed[0];
-    log2.info(`Detected ${only.displayName} — using it for ${options.verb}.`);
-    return [only];
-  }
-  if (options.allowMulti) {
-    const picks = await selectMany(`Multiple harnesses detected — which to ${options.verb}?`, installed.map((a) => ({ label: a.displayName, value: a.kind })), installed.map((a) => a.kind));
-    if (picks.length === 0) {
-      log2.warn("No harness selected; nothing to do.");
-      return [];
-    }
-    return picks.map((kind) => getAdapter(kind));
-  }
-  const pick = await selectOne(`Multiple harnesses detected — which one to ${options.verb}?`, installed.map((a) => ({ label: a.displayName, value: a.kind })));
-  return [getAdapter(pick)];
-}
-var init_harness_select = __esm(() => {
-  init_adapters();
-  init_prompts();
-});
-
-// ../plugin/src/shared/harness-provider-map.ts
-function remapProviderPrefix(ref, map) {
-  if (typeof ref !== "string")
-    return ref;
-  const slash = ref.indexOf("/");
-  if (slash <= 0)
-    return ref;
-  const provider = ref.slice(0, slash);
-  if (!Object.hasOwn(map, provider))
-    return ref;
-  return `${map[provider]}${ref.slice(slash)}`;
-}
-function piModelRefToCanonical(ref) {
-  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
-}
-function ompModelRefToCanonical(ref) {
-  return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);
-}
-var PI_TO_CANONICAL_PROVIDER, OMP_TO_CANONICAL_PROVIDER;
-var init_harness_provider_map = __esm(() => {
-  PI_TO_CANONICAL_PROVIDER = {
-    "openai-codex": "openai",
-    "google-antigravity": "google"
-  };
-  OMP_TO_CANONICAL_PROVIDER = {
-    "openai-codex": "openai",
-    "google-antigravity": "google",
-    "opencode-zen": "opencode"
-  };
-});
-
-// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
-function createScanner(text, ignoreTrivia = false) {
-  const len = text.length;
-  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
-  function scanHexDigits(count, exact) {
-    let digits = 0;
-    let value = 0;
-    while (digits < count || !exact) {
-      let ch = text.charCodeAt(pos);
-      if (ch >= 48 && ch <= 57) {
-        value = value * 16 + ch - 48;
-      } else if (ch >= 65 && ch <= 70) {
-        value = value * 16 + ch - 65 + 10;
-      } else if (ch >= 97 && ch <= 102) {
-        value = value * 16 + ch - 97 + 10;
-      } else {
-        break;
-      }
-      pos++;
-      digits++;
-    }
-    if (digits < count) {
-      value = -1;
-    }
-    return value;
-  }
-  function setPosition(newPosition) {
-    pos = newPosition;
-    value = "";
-    tokenOffset = 0;
-    token = 16;
-    scanError = 0;
-  }
-  function scanNumber() {
-    let start = pos;
-    if (text.charCodeAt(pos) === 48) {
-      pos++;
-    } else {
-      pos++;
-      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-        pos++;
-      }
-    }
-    if (pos < text.length && text.charCodeAt(pos) === 46) {
-      pos++;
-      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
-        pos++;
-        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-          pos++;
-        }
-      } else {
-        scanError = 3;
-        return text.substring(start, pos);
-      }
-    }
-    let end = pos;
-    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
-      pos++;
-      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
-        pos++;
-      }
-      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
-        pos++;
-        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-          pos++;
-        }
-        end = pos;
-      } else {
-        scanError = 3;
-      }
-    }
-    return text.substring(start, end);
-  }
-  function scanString() {
-    let result = "", start = pos;
-    while (true) {
-      if (pos >= len) {
-        result += text.substring(start, pos);
-        scanError = 2;
-        break;
-      }
-      const ch = text.charCodeAt(pos);
-      if (ch === 34) {
-        result += text.substring(start, pos);
-        pos++;
-        break;
-      }
-      if (ch === 92) {
-        result += text.substring(start, pos);
-        pos++;
-        if (pos >= len) {
-          scanError = 2;
-          break;
-        }
-        const ch2 = text.charCodeAt(pos++);
-        switch (ch2) {
-          case 34:
-            result += '"';
-            break;
-          case 92:
-            result += "\\";
-            break;
-          case 47:
-            result += "/";
-            break;
-          case 98:
-            result += "\b";
-            break;
-          case 102:
-            result += "\f";
-            break;
-          case 110:
-            result += `
-`;
-            break;
-          case 114:
-            result += "\r";
-            break;
-          case 116:
-            result += "\t";
-            break;
-          case 117:
-            const ch3 = scanHexDigits(4, true);
-            if (ch3 >= 0) {
-              result += String.fromCharCode(ch3);
-            } else {
-              scanError = 4;
-            }
-            break;
-          default:
-            scanError = 5;
-        }
-        start = pos;
-        continue;
-      }
-      if (ch >= 0 && ch <= 31) {
-        if (isLineBreak(ch)) {
-          result += text.substring(start, pos);
-          scanError = 2;
-          break;
-        } else {
-          scanError = 6;
-        }
-      }
-      pos++;
-    }
-    return result;
-  }
-  function scanNext() {
-    value = "";
-    scanError = 0;
-    tokenOffset = pos;
-    lineStartOffset = lineNumber;
-    prevTokenLineStartOffset = tokenLineStartOffset;
-    if (pos >= len) {
-      tokenOffset = len;
-      return token = 17;
-    }
-    let code = text.charCodeAt(pos);
-    if (isWhiteSpace(code)) {
-      do {
-        pos++;
-        value += String.fromCharCode(code);
-        code = text.charCodeAt(pos);
-      } while (isWhiteSpace(code));
-      return token = 15;
-    }
-    if (isLineBreak(code)) {
-      pos++;
-      value += String.fromCharCode(code);
-      if (code === 13 && text.charCodeAt(pos) === 10) {
-        pos++;
-        value += `
-`;
-      }
-      lineNumber++;
-      tokenLineStartOffset = pos;
-      return token = 14;
-    }
-    switch (code) {
-      case 123:
-        pos++;
-        return token = 1;
-      case 125:
-        pos++;
-        return token = 2;
-      case 91:
-        pos++;
-        return token = 3;
-      case 93:
-        pos++;
-        return token = 4;
-      case 58:
-        pos++;
-        return token = 6;
-      case 44:
-        pos++;
-        return token = 5;
-      case 34:
-        pos++;
-        value = scanString();
-        return token = 10;
-      case 47:
-        const start = pos - 1;
-        if (text.charCodeAt(pos + 1) === 47) {
-          pos += 2;
-          while (pos < len) {
-            if (isLineBreak(text.charCodeAt(pos))) {
-              break;
-            }
-            pos++;
-          }
-          value = text.substring(start, pos);
-          return token = 12;
-        }
-        if (text.charCodeAt(pos + 1) === 42) {
-          pos += 2;
-          const safeLength = len - 1;
-          let commentClosed = false;
-          while (pos < safeLength) {
-            const ch = text.charCodeAt(pos);
-            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
-              pos += 2;
-              commentClosed = true;
-              break;
-            }
-            pos++;
-            if (isLineBreak(ch)) {
-              if (ch === 13 && text.charCodeAt(pos) === 10) {
-                pos++;
-              }
-              lineNumber++;
-              tokenLineStartOffset = pos;
-            }
-          }
-          if (!commentClosed) {
-            pos++;
-            scanError = 1;
-          }
-          value = text.substring(start, pos);
-          return token = 13;
-        }
-        value += String.fromCharCode(code);
-        pos++;
-        return token = 16;
-      case 45:
-        value += String.fromCharCode(code);
-        pos++;
-        if (pos === len || !isDigit(text.charCodeAt(pos))) {
-          return token = 16;
-        }
-      case 48:
-      case 49:
-      case 50:
-      case 51:
-      case 52:
-      case 53:
-      case 54:
-      case 55:
-      case 56:
-      case 57:
-        value += scanNumber();
-        return token = 11;
-      default:
-        while (pos < len && isUnknownContentCharacter(code)) {
-          pos++;
-          code = text.charCodeAt(pos);
-        }
-        if (tokenOffset !== pos) {
-          value = text.substring(tokenOffset, pos);
-          switch (value) {
-            case "true":
-              return token = 8;
-            case "false":
-              return token = 9;
-            case "null":
-              return token = 7;
-          }
-          return token = 16;
-        }
-        value += String.fromCharCode(code);
-        pos++;
-        return token = 16;
-    }
-  }
-  function isUnknownContentCharacter(code) {
-    if (isWhiteSpace(code) || isLineBreak(code)) {
-      return false;
-    }
-    switch (code) {
-      case 125:
-      case 93:
-      case 123:
-      case 91:
-      case 34:
-      case 58:
-      case 44:
-      case 47:
-        return false;
-    }
-    return true;
-  }
-  function scanNextNonTrivia() {
-    let result;
-    do {
-      result = scanNext();
-    } while (result >= 12 && result <= 15);
-    return result;
-  }
-  return {
-    setPosition,
-    getPosition: () => pos,
-    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
-    getToken: () => token,
-    getTokenValue: () => value,
-    getTokenOffset: () => tokenOffset,
-    getTokenLength: () => pos - tokenOffset,
-    getTokenStartLine: () => lineStartOffset,
-    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
-    getTokenError: () => scanError
-  };
-}
-function isWhiteSpace(ch) {
-  return ch === 32 || ch === 9;
-}
-function isLineBreak(ch) {
-  return ch === 10 || ch === 13;
-}
-function isDigit(ch) {
-  return ch >= 48 && ch <= 57;
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
 }
 var CharacterCodes;
 var init_scanner = __esm(() => {
@@ -12440,6 +11893,49 @@ var init_format = __esm(() => {
 });
 
 // ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
 function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
   let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
   function ensurePropertyComplete(endOffset) {
@@ -12721,346 +12217,981 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
       } else if (needsComma) {
         handleError(6, [], []);
       }
-      if (!parseProperty()) {
-        handleError(4, [], [2, 5]);
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+var ParseOptions;
+var init_parser = __esm(() => {
+  init_scanner();
+  (function(ParseOptions) {
+    ParseOptions.DEFAULT = {
+      allowTrailingComma: false
+    };
+  })(ParseOptions || (ParseOptions = {}));
+});
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path.length > 0) {
+    lastSegment = path.pop();
+    parent = findNodeAtLocation(root, path);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit = edits[i];
+    newText = applyEdit(newText, edit);
+    begin = Math.min(begin, edit.offset);
+    end = Math.max(end, edit.offset + edit.length);
+    end += edit.content.length - edit.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+var init_edit = __esm(() => {
+  init_format();
+  init_parser();
+});
+
+// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+function modify(text, path, value, options) {
+  return setProperty(text, path, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+var createScanner2, ScanError, SyntaxKind, parse2, parseTree2, findNodeAtLocation2, getNodeValue2, ParseErrorCode;
+var init_main2 = __esm(() => {
+  init_format();
+  init_edit();
+  init_scanner();
+  init_parser();
+  createScanner2 = createScanner;
+  (function(ScanError) {
+    ScanError[ScanError["None"] = 0] = "None";
+    ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+    ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+    ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+    ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+    ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+    ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+  })(ScanError || (ScanError = {}));
+  (function(SyntaxKind) {
+    SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+    SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+    SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+    SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+    SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+    SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+    SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+    SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+    SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+    SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+    SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+    SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+    SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+    SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+  })(SyntaxKind || (SyntaxKind = {}));
+  parse2 = parse;
+  parseTree2 = parseTree;
+  findNodeAtLocation2 = findNodeAtLocation;
+  getNodeValue2 = getNodeValue;
+  (function(ParseErrorCode) {
+    ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+    ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+    ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+    ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+    ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+    ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+    ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+    ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+    ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+    ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+    ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+    ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+    ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+    ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+    ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+    ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+  })(ParseErrorCode || (ParseErrorCode = {}));
+});
+
+// ../plugin/src/shared/jsonc-parser.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+function stripJsonComments(content) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const char = content[index];
+    const next = content[index + 1];
+    if (inLineComment) {
+      if (char === `
+`) {
+        inLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
       }
-      needsComma = true;
+      continue;
     }
-    onObjectEnd();
-    if (_scanner.getToken() !== 2) {
-      handleError(7, [2], []);
-    } else {
-      scanNext();
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
     }
-    return true;
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    result += char;
   }
-  function parseArray() {
-    onArrayBegin();
-    scanNext();
-    let isFirstElement = true;
-    let needsComma = false;
-    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
-      if (_scanner.getToken() === 5) {
-        if (!needsComma) {
-          handleError(4, [], []);
-        }
-        onSeparator(",");
-        scanNext();
-        if (_scanner.getToken() === 4 && allowTrailingComma) {
-          break;
-        }
-      } else if (needsComma) {
-        handleError(6, [], []);
-      }
-      if (isFirstElement) {
-        _jsonPath.push(0);
-        isFirstElement = false;
-      } else {
-        _jsonPath[_jsonPath.length - 1]++;
-      }
-      if (!parseValue()) {
-        handleError(4, [], [4, 5]);
+  return result;
+}
+function stripTrailingCommas(content) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const char = content[index];
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
       }
-      needsComma = true;
+      continue;
     }
-    onArrayEnd();
-    if (!isFirstElement) {
-      _jsonPath.pop();
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
     }
-    if (_scanner.getToken() !== 4) {
-      handleError(8, [4], []);
-    } else {
-      scanNext();
+    if (char === ",") {
+      let lookahead = index + 1;
+      while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
+        lookahead += 1;
+      }
+      const next = content[lookahead];
+      if (next === "}" || next === "]") {
+        continue;
+      }
     }
-    return true;
+    result += char;
   }
-  function parseValue() {
-    switch (_scanner.getToken()) {
-      case 3:
-        return parseArray();
-      case 1:
-        return parseObject();
-      case 10:
-        return parseString(true);
-      default:
-        return parseLiteral();
-    }
+  return result;
+}
+function isPrototypePollutionKey(key) {
+  return PROTOTYPE_POLLUTION_KEYS.has(key);
+}
+function sanitizeParsedJson(value, options = {}, path = []) {
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => sanitizeParsedJson(entry, options, [...path, index]));
   }
-  scanNext();
-  if (_scanner.getToken() === 17) {
-    if (options.allowEmptyContent) {
-      return true;
+  if (value === null || typeof value !== "object")
+    return value;
+  const source = value;
+  const sourcePrototype = Object.getPrototypeOf(source);
+  if (sourcePrototype !== null && sourcePrototype !== Object.prototype) {
+    options.onRejectedKey?.([...path, "__proto__"]);
+  }
+  const sanitized = {};
+  for (const key of Object.keys(source)) {
+    if (isPrototypePollutionKey(key)) {
+      options.onRejectedKey?.([...path, key]);
+      continue;
     }
-    handleError(4, [], []);
-    return false;
+    Object.defineProperty(sanitized, key, {
+      value: sanitizeParsedJson(source[key], options, [...path, key]),
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
   }
-  if (!parseValue()) {
-    handleError(4, [], []);
-    return false;
+  return sanitized;
+}
+function lineAndColumnAt(content, offset) {
+  const before = content.slice(0, Math.max(0, offset));
+  const lines = before.split(/\r?\n/);
+  return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
+}
+function parseIssue(content, error) {
+  const location = lineAndColumnAt(content, error.offset);
+  const code = printParseErrorCode(error.error);
+  const message = code.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  return {
+    ...location,
+    offset: error.offset,
+    length: error.length,
+    message
+  };
+}
+function normalizeJsoncParserObjects(value, options, path = []) {
+  if (Array.isArray(value)) {
+    return value.map((entry, index) => normalizeJsoncParserObjects(entry, options, [...path, String(index)]));
   }
-  if (_scanner.getToken() !== 17) {
-    handleError(9, [], []);
+  if (value === null || typeof value !== "object")
+    return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    options.onRejectedKey?.([...path, "__proto__"]);
   }
-  return true;
+  const normalized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    Object.defineProperty(normalized, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: normalizeJsoncParserObjects(entry, options, [...path, key])
+    });
+  }
+  return normalized;
 }
-function getNodeType(value) {
-  switch (typeof value) {
-    case "boolean":
-      return "boolean";
-    case "number":
-      return "number";
-    case "string":
-      return "string";
-    case "object": {
-      if (!value) {
-        return "null";
-      } else if (Array.isArray(value)) {
-        return "array";
-      }
-      return "object";
-    }
-    default:
-      return "null";
+function parseJsoncRecovering(content, options = {}) {
+  const errors = [];
+  const parsed = parse2(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+    allowEmptyContent: false
+  });
+  return {
+    value: sanitizeParsedJson(normalizeJsoncParserObjects(parsed, options), options),
+    issues: errors.map((error) => parseIssue(content, error))
+  };
+}
+function parseJsonc2(content, options = {}) {
+  const normalized = stripTrailingCommas(stripJsonComments(content));
+  return sanitizeParsedJson(JSON.parse(normalized), options);
+}
+function readJsoncFile(filePath) {
+  try {
+    return parseJsonc2(readFileSync5(filePath, "utf-8"));
+  } catch (_error) {
+    return null;
   }
 }
-var ParseOptions;
-var init_parser = __esm(() => {
-  init_scanner();
-  (function(ParseOptions) {
-    ParseOptions.DEFAULT = {
-      allowTrailingComma: false
-    };
-  })(ParseOptions || (ParseOptions = {}));
+function detectConfigFile(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (existsSync8(jsoncPath)) {
+    return { format: "jsonc", path: jsoncPath };
+  }
+  if (existsSync8(jsonPath)) {
+    return { format: "json", path: jsonPath };
+  }
+  return { format: "none", path: jsoncPath };
+}
+var PROTOTYPE_POLLUTION_KEYS;
+var init_jsonc_parser = __esm(() => {
+  init_main2();
+  PROTOTYPE_POLLUTION_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 });
 
-// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
-function setProperty(text, originalPath, value, options) {
-  const path = originalPath.slice();
-  const errors = [];
-  const root = parseTree(text, errors);
-  let parent = undefined;
-  let lastSegment = undefined;
-  while (path.length > 0) {
-    lastSegment = path.pop();
-    parent = findNodeAtLocation(root, path);
-    if (parent === undefined && value !== undefined) {
-      if (typeof lastSegment === "string") {
-        value = { [lastSegment]: value };
-      } else {
-        value = [value];
-      }
-    } else {
-      break;
+// src/lib/jsonc-config.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+function parseErrorLocation(content, error) {
+  const lines = content.split(`
+`);
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("Unexpected end of JSON input")) {
+    return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
+  }
+  const parserLocation = error;
+  if (typeof parserLocation.line === "number" && parserLocation.line >= 1 && parserLocation.line <= lines.length && typeof parserLocation.column === "number" && parserLocation.column >= 0) {
+    return { line: parserLocation.line, column: parserLocation.column + 1 };
+  }
+  const messageLine = /Line (\d+)/.exec(message)?.[1];
+  return { line: messageLine ? Number.parseInt(messageLine, 10) : 1, column: 1 };
+}
+function readJsoncConfig(path) {
+  if (!existsSync9(path))
+    return { kind: "missing" };
+  const content = readFileSync6(path, "utf-8");
+  try {
+    const rejectedKeyPaths = [];
+    const parsed = sanitizeParsedJson(import_comment_json2.parse(content), {
+      onRejectedKey: (keyPath) => rejectedKeyPaths.push(keyPath.join("."))
+    });
+    if (rejectedKeyPaths.length > 0) {
+      throw new Error(`unsafe prototype-pollution key at ${rejectedKeyPaths.join(", ")}`);
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("expected a JSON object at the document root");
     }
+    return { kind: "parsed", value: parsed };
+  } catch (error) {
+    return { kind: "parse-error", error: new ConfigParseError(path, content, error) };
   }
-  if (!parent) {
-    if (value === undefined) {
-      throw new Error("Can not delete in empty document");
+}
+function readJsoncConfigForUpdate(path) {
+  const result = readJsoncConfig(path);
+  if (result.kind === "missing")
+    return {};
+  if (result.kind === "parse-error")
+    throw result.error;
+  return result.value;
+}
+function assertJsoncConfigsParseable(paths) {
+  for (const path of paths) {
+    const result = readJsoncConfig(path);
+    if (result.kind === "parse-error")
+      throw result.error;
+  }
+}
+var import_comment_json2, ConfigParseError;
+var init_jsonc_config = __esm(() => {
+  init_jsonc_parser();
+  import_comment_json2 = __toESM(require_src3(), 1);
+  ConfigParseError = class ConfigParseError extends Error {
+    path;
+    constructor(path, content, cause) {
+      const detail = cause instanceof Error ? cause.message : String(cause);
+      const location = parseErrorLocation(content, cause);
+      super(`Refusing to overwrite unparseable config ${path} at line ${location.line}, column ${location.column}: ${detail}`, { cause });
+      this.name = "ConfigParseError";
+      this.path = path;
     }
-    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
-  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
-    const existing = findNodeAtLocation(parent, [lastSegment]);
-    if (existing !== undefined) {
-      if (value === undefined) {
-        if (!existing.parent) {
-          throw new Error("Malformed AST");
-        }
-        const propertyIndex = parent.children.indexOf(existing.parent);
-        let removeBegin;
-        let removeEnd = existing.parent.offset + existing.parent.length;
-        if (propertyIndex > 0) {
-          let previous = parent.children[propertyIndex - 1];
-          removeBegin = previous.offset + previous.length;
-        } else {
-          removeBegin = parent.offset + 1;
-          if (parent.children.length > 1) {
-            let next = parent.children[1];
-            removeEnd = next.offset;
-          }
-        }
-        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
-      } else {
-        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
-      }
-    } else {
-      if (value === undefined) {
-        return [];
-      }
-      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
-      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
-      let edit;
-      if (index > 0) {
-        let previous = parent.children[index - 1];
-        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
-      } else if (parent.children.length === 0) {
-        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
-      } else {
-        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
-      }
-      return withFormatting(text, edit, options);
+  };
+});
+
+// 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 versionAt = normalized.indexOf("@", slash + 1);
+    return versionAt > 0 ? normalized.slice(0, versionAt) : 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 object = entry;
+    for (const key of ["name", "source"]) {
+      const name = getPiPackageEntryName(object[key]);
+      if (name)
+        return name;
     }
-  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
-    const insertIndex = lastSegment;
-    if (insertIndex === -1) {
-      const newProperty = `${JSON.stringify(value)}`;
-      let edit;
-      if (parent.children.length === 0) {
-        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
-      } else {
-        const previous = parent.children[parent.children.length - 1];
-        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+  }
+  return null;
+}
+function isPiMagicContextPackageEntry(entry) {
+  if (typeof entry === "string") {
+    return packageNameFromSpecifier(entry) === PI_MAGIC_CONTEXT_PACKAGE_NAME;
+  }
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const object = entry;
+    return isPiMagicContextPackageEntry(object.name) || isPiMagicContextPackageEntry(object.source);
+  }
+  return false;
+}
+function getPiMagicContextPackageSpecifier(entry) {
+  if (typeof entry === "string") {
+    return isPiMagicContextPackageEntry(entry) ? entry.trim() : null;
+  }
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const object = entry;
+    return getPiMagicContextPackageSpecifier(object.source) ?? getPiMagicContextPackageSpecifier(object.name);
+  }
+  return null;
+}
+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";
+
+// src/adapters/pi.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+
+class PiAdapter {
+  kind = "pi";
+  displayName = "Pi";
+  pluginPackageName = PLUGIN_NAME;
+  isInstalled() {
+    return detectPiBinary() !== null;
+  }
+  hasPluginEntry() {
+    const settings = readPiSettings();
+    if (!settings)
+      return false;
+    const packages = settings.packages ?? [];
+    return packages.some((entry) => isPiMagicContextPackageEntry(entry));
+  }
+  getConfigPaths() {
+    const dir = getPiAgentConfigDir();
+    return {
+      configDir: dir,
+      pluginConfigPath: getPiUserExtensionsPath(),
+      magicContextConfigPath: getPiUserConfigPath(),
+      secondaryConfigPath: null
+    };
+  }
+  async ensurePluginEntry() {
+    const settingsPath = getPiUserExtensionsPath();
+    try {
+      const settings = readPiSettingsForUpdate();
+      const packages = Array.isArray(settings.packages) ? settings.packages : [];
+      const idx = packages.findIndex((entry) => isPiMagicContextPackageEntry(entry));
+      if (idx === -1) {
+        packages.push(PI_PACKAGE_SOURCE);
+        settings.packages = packages;
+        writePiSettings(settings);
+        return {
+          ok: true,
+          action: "added",
+          message: `Added ${PI_PACKAGE_SOURCE} to ${settingsPath}.`,
+          configPath: settingsPath
+        };
       }
-      return withFormatting(text, edit, options);
-    } else if (value === undefined && parent.children.length >= 0) {
-      const removalIndex = lastSegment;
-      const toRemove = parent.children[removalIndex];
-      let edit;
-      if (parent.children.length === 1) {
-        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
-      } else if (parent.children.length - 1 === removalIndex) {
-        let previous = parent.children[removalIndex - 1];
-        let offset = previous.offset + previous.length;
-        let parentEndOffset = parent.offset + parent.length;
-        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
-      } else {
-        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      return {
+        ok: true,
+        action: "already_present",
+        message: `Plugin entry already present in ${settingsPath}.`,
+        configPath: settingsPath
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        action: "error",
+        message: `Failed to update ${settingsPath}: ${err.message}`,
+        configPath: settingsPath
+      };
+    }
+  }
+  async removePluginEntry() {
+    const settingsPath = getPiUserExtensionsPath();
+    try {
+      const settings = readPiSettingsForUpdate();
+      if (!Array.isArray(settings.packages)) {
+        return {
+          ok: true,
+          action: "already_present",
+          message: `No packages array in ${settingsPath}.`,
+          configPath: settingsPath
+        };
       }
-      return withFormatting(text, edit, options);
-    } else if (value !== undefined) {
-      let edit;
-      const newProperty = `${JSON.stringify(value)}`;
-      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
-        const toModify = parent.children[lastSegment];
-        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
-      } else if (parent.children.length === 0 || lastSegment === 0) {
-        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
-      } else {
-        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
-        const previous = parent.children[index - 1];
-        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      const before = settings.packages.length;
+      settings.packages = settings.packages.filter((entry) => !isPiMagicContextPackageEntry(entry));
+      if (settings.packages.length === before) {
+        return {
+          ok: true,
+          action: "already_present",
+          message: `Plugin entry not present in ${settingsPath}.`,
+          configPath: settingsPath
+        };
       }
-      return withFormatting(text, edit, options);
-    } else {
-      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+      writePiSettings(settings);
+      return {
+        ok: true,
+        action: "updated",
+        message: `Removed ${PLUGIN_NAME} from ${settingsPath}.`,
+        configPath: settingsPath
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        action: "error",
+        message: `Failed to update ${settingsPath}: ${err.message}`,
+        configPath: settingsPath
+      };
     }
-  } else {
-    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
   }
-}
-function withFormatting(text, edit, options) {
-  if (!options.formattingOptions) {
-    return [edit];
+  getInstallHint() {
+    return "Install Pi: https://pi.coding/install (npm: @earendil-works/pi-coding-agent)";
   }
-  let newText = applyEdit(text, edit);
-  let begin = edit.offset;
-  let end = edit.offset + edit.content.length;
-  if (edit.length === 0 || edit.content.length === 0) {
-    while (begin > 0 && !isEOL(newText, begin - 1)) {
-      begin--;
-    }
-    while (end < newText.length && !isEOL(newText, end)) {
-      end++;
-    }
+  getPluginCacheInfo() {
+    return { path: null, exists: false, sizeBytes: 0 };
   }
-  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
-  for (let i = edits.length - 1;i >= 0; i--) {
-    const edit = edits[i];
-    newText = applyEdit(newText, edit);
-    begin = Math.min(begin, edit.offset);
-    end = Math.max(end, edit.offset + edit.length);
-    end += edit.content.length - edit.length;
+  getLogPath() {
+    return getMagicContextLogPath2("pi");
+  }
+  getInstalledPluginVersion() {
+    const piBin = detectPiBinary();
+    if (!piBin)
+      return null;
+    try {
+      const output = runPiCommand(piBin.path, ["list"], 5000);
+      if (output === null)
+        return null;
+      const re = new RegExp(`${PLUGIN_NAME.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&")}.*?(\\d+\\.\\d+\\.\\d+(?:[-+][\\w.-]+)?)`);
+      const match = re.exec(output);
+      if (match)
+        return match[1] ?? null;
+    } catch {}
+    return null;
   }
-  const editLength = text.length - (newText.length - end) - begin;
-  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
 }
-function applyEdit(text, edit) {
-  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+function readPiSettings() {
+  const result = readJsoncConfig(getPiUserExtensionsPath());
+  return result.kind === "parsed" ? result.value : null;
 }
-var init_edit = __esm(() => {
-  init_format();
-  init_parser();
+function readPiSettingsForUpdate() {
+  return readJsoncConfigForUpdate(getPiUserExtensionsPath());
+}
+function writePiSettings(settings) {
+  const settingsPath = getPiUserExtensionsPath();
+  ensureDir2(settingsPath);
+  const text = import_comment_json3.stringify(settings, null, 2);
+  writeFileAtomic(settingsPath, `${text}
+`);
+}
+function ensureDir2(filePath) {
+  const dir = dirname5(filePath);
+  if (!existsSync10(dir)) {
+    const { mkdirSync } = __require("node:fs");
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var import_comment_json3, PLUGIN_NAME = "@cortexkit/pi-magic-context";
+var init_pi = __esm(() => {
+  init_atomic_write();
+  init_jsonc_config();
+  init_paths();
+  init_pi_helpers();
+  import_comment_json3 = __toESM(require_src3(), 1);
 });
 
-// ../../node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
-function modify(text, path, value, options) {
-  return setProperty(text, path, value, options);
+// src/adapters/index.ts
+function getAdapter(kind) {
+  const found = ALL.find((a) => a.kind === kind);
+  if (!found)
+    throw new Error(`Unknown harness: ${kind}`);
+  return found;
 }
-function applyEdits(text, edits) {
-  let sortedEdits = edits.slice(0).sort((a, b) => {
-    const diff = a.offset - b.offset;
-    if (diff === 0) {
-      return a.length - b.length;
-    }
-    return diff;
-  });
-  let lastModifiedOffset = text.length;
-  for (let i = sortedEdits.length - 1;i >= 0; i--) {
-    let e = sortedEdits[i];
-    if (e.offset + e.length <= lastModifiedOffset) {
-      text = applyEdit(text, e);
-    } else {
-      throw new Error("Overlapping edit");
+function getInstalledAdapters() {
+  return ALL.filter((a) => a.isInstalled());
+}
+var ALL;
+var init_adapters = __esm(() => {
+  init_omp();
+  init_opencode();
+  init_pi();
+  ALL = [new OpenCodeAdapter, new PiAdapter, new OmpAdapter];
+});
+
+// src/lib/harness-select.ts
+function parseHarnessFlag(argv) {
+  const idx = argv.indexOf("--harness");
+  if (idx === -1)
+    return { kind: "absent" };
+  const value = argv[idx + 1];
+  if (!value || value.startsWith("--"))
+    return { kind: "invalid", value: null };
+  if (value === "opencode" || value === "pi" || value === "omp") {
+    return { kind: "valid", harness: value };
+  }
+  return { kind: "invalid", value };
+}
+async function resolveAdaptersForCommand(argv, options) {
+  const flag = parseHarnessFlag(argv);
+  if (flag.kind === "valid")
+    return [getAdapter(flag.harness)];
+  if (flag.kind === "invalid") {
+    throw new Error(flag.value === null ? "Missing value for --harness (expected opencode, pi, or omp)" : `Invalid --harness value: ${flag.value} (expected opencode, pi, or omp)`);
+  }
+  const installed = getInstalledAdapters();
+  if (installed.length === 0) {
+    log2.warn("No supported harness was detected on PATH (opencode, pi, omp).");
+    const pick = await selectOne(`Which harness do you want to ${options.verb}?`, [
+      {
+        label: "OpenCode",
+        value: "opencode",
+        hint: "@cortexkit/opencode-magic-context"
+      },
+      {
+        label: "Pi",
+        value: "pi",
+        hint: "@cortexkit/pi-magic-context"
+      },
+      {
+        label: "Oh My Pi (OMP)",
+        value: "omp",
+        hint: "@cortexkit/pi-magic-context"
+      }
+    ]);
+    return [getAdapter(pick)];
+  }
+  if (installed.length === 1) {
+    const only = installed[0];
+    log2.info(`Detected ${only.displayName} — using it for ${options.verb}.`);
+    return [only];
+  }
+  if (options.allowMulti) {
+    const picks = await selectMany(`Multiple harnesses detected — which to ${options.verb}?`, installed.map((a) => ({ label: a.displayName, value: a.kind })), installed.map((a) => a.kind));
+    if (picks.length === 0) {
+      log2.warn("No harness selected; nothing to do.");
+      return [];
     }
-    lastModifiedOffset = e.offset;
+    return picks.map((kind) => getAdapter(kind));
   }
-  return text;
+  const pick = await selectOne(`Multiple harnesses detected — which one to ${options.verb}?`, installed.map((a) => ({ label: a.displayName, value: a.kind })));
+  return [getAdapter(pick)];
 }
-var createScanner2, ScanError, SyntaxKind, parseTree2, findNodeAtLocation2, getNodeValue2, ParseErrorCode;
-var init_main2 = __esm(() => {
-  init_format();
-  init_edit();
-  init_scanner();
-  init_parser();
-  createScanner2 = createScanner;
-  (function(ScanError) {
-    ScanError[ScanError["None"] = 0] = "None";
-    ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
-    ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
-    ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
-    ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
-    ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
-    ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
-  })(ScanError || (ScanError = {}));
-  (function(SyntaxKind) {
-    SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
-    SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
-    SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
-    SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
-    SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
-    SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
-    SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
-    SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
-    SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
-    SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
-    SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
-    SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
-    SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
-    SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
-    SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
-    SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
-    SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
-  })(SyntaxKind || (SyntaxKind = {}));
-  parseTree2 = parseTree;
-  findNodeAtLocation2 = findNodeAtLocation;
-  getNodeValue2 = getNodeValue;
-  (function(ParseErrorCode) {
-    ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
-    ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
-    ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
-    ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
-    ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
-    ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
-    ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
-    ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
-    ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
-    ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
-    ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
-    ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
-    ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
-    ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
-    ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
-    ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
-  })(ParseErrorCode || (ParseErrorCode = {}));
+var init_harness_select = __esm(() => {
+  init_adapters();
+  init_prompts();
+});
+
+// ../plugin/src/shared/harness-provider-map.ts
+function remapProviderPrefix(ref, map) {
+  if (typeof ref !== "string")
+    return ref;
+  const slash = ref.indexOf("/");
+  if (slash <= 0)
+    return ref;
+  const provider = ref.slice(0, slash);
+  if (!Object.hasOwn(map, provider))
+    return ref;
+  return `${map[provider]}${ref.slice(slash)}`;
+}
+function piModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+function ompModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);
+}
+var PI_TO_CANONICAL_PROVIDER, OMP_TO_CANONICAL_PROVIDER;
+var init_harness_provider_map = __esm(() => {
+  PI_TO_CANONICAL_PROVIDER = {
+    "openai-codex": "openai",
+    "google-antigravity": "google"
+  };
+  OMP_TO_CANONICAL_PROVIDER = {
+    "openai-codex": "openai",
+    "google-antigravity": "google",
+    "opencode-zen": "opencode"
+  };
 });
 
 // ../plugin/src/shared/jsonc-edit.ts
@@ -14458,6 +14589,17 @@ var init_setup_omp = __esm(() => {
   OMP_HOST = createOmpHost(DEFAULT_DEPS2);
 });
 
+// ../plugin/src/shared/config-diagnostics.ts
+var CONFIG_WARNING_CLASS, claimedFailures;
+var init_config_diagnostics = __esm(() => {
+  CONFIG_WARNING_CLASS = {
+    FILE_PARSE: "file-parse",
+    FILE_IO: "file-io",
+    INVALID_LEAF: "invalid-leaf"
+  };
+  claimedFailures = new Set;
+});
+
 // ../plugin/src/shared/redaction.ts
 import { homedir as homedir7, userInfo } from "node:os";
 function escapeRegex(value) {
@@ -19223,11 +19365,11 @@ var init_errors2 = __esm(() => {
 });
 
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/parse.js
-var parse4, parseAsync2, safeParse2, safeParseAsync2, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync;
+var parse5, parseAsync2, safeParse2, safeParseAsync2, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync;
 var init_parse2 = __esm(() => {
   init_core2();
   init_errors2();
-  parse4 = /* @__PURE__ */ _parse(ZodRealError);
+  parse5 = /* @__PURE__ */ _parse(ZodRealError);
   parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
   safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
   safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -19453,7 +19595,7 @@ var init_schemas2 = __esm(() => {
     inst.def = def;
     inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
-    inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
+    inst.parse = (data, params) => parse5(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);
@@ -21317,10 +21459,13 @@ function loadConfigFileDetailed(configPath, source) {
     rawText = raw.text;
     rawWarnings = raw.warnings;
   } catch (error) {
+    const message = `failed to read config: ${error instanceof Error ? error.message : String(error)}`;
     return {
       config: {},
-      warnings: [
-        `${configPath}: failed to read config: ${error instanceof Error ? error.message : String(error)}`
+      warnings: [`${configPath}: ${message}`],
+      parseFailures: [],
+      warningDetails: [
+        { warningClass: CONFIG_WARNING_CLASS.FILE_IO, source, path: configPath, message }
       ],
       outcome: "project-file-io-error",
       source
@@ -21333,22 +21478,56 @@ function loadConfigFileDetailed(configPath, source) {
       isProjectConfig: source === "project"
     });
     const rejectedKeyPaths = [];
-    const config = parseJsonc2(substituted.text, {
+    const parsed = parseJsoncRecovering(substituted.text, {
       onRejectedKey: (path) => rejectedKeyPaths.push(path.join("."))
     });
+    const config = parsed.value && typeof parsed.value === "object" && !Array.isArray(parsed.value) ? parsed.value : {};
     const unsafeKeyWarnings = rejectedKeyPaths.map((path) => `Ignored unsafe config key "${path}" (security: prototype-pollution keys are not allowed).`);
+    const firstIssue = parsed.issues[0];
+    const recovered = firstIssue !== undefined && Object.keys(config).length > 0;
+    const parseFailures = firstIssue ? [
+      {
+        warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+        source,
+        path: configPath,
+        line: firstIssue.line,
+        column: firstIssue.column,
+        message: firstIssue.message,
+        recovered,
+        warning: `${configPath}:${firstIssue.line}:${firstIssue.column}: ${firstIssue.message}; ${recovered ? "recovered values were applied, but the file must be fixed." : "using defaults for this file."}`
+      }
+    ] : [];
     return {
       config,
-      warnings: [...rawWarnings, ...substituted.warnings, ...unsafeKeyWarnings].map((warning) => `${configPath}: ${warning}`),
-      outcome: rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok",
+      warnings: [
+        ...parseFailures.map((failure) => failure.warning),
+        ...rawWarnings.map((warning) => `${configPath}: ${warning}`),
+        ...substituted.warnings.map((warning) => `${configPath}: ${warning}`),
+        ...unsafeKeyWarnings.map((warning) => `${configPath}: ${warning}`)
+      ],
+      parseFailures,
+      warningDetails: parseFailures,
+      outcome: parseFailures.length > 0 ? "project-file-parse-error" : rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok",
       source
     };
   } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const warning = `${configPath}:1:1: ${message}; using defaults for this file.`;
+    const failure = {
+      warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+      source,
+      path: configPath,
+      line: 1,
+      column: 1,
+      message,
+      recovered: false,
+      warning
+    };
     return {
       config: {},
-      warnings: [
-        `${configPath}: failed to load config: ${error instanceof Error ? error.message : String(error)}`
-      ],
+      warnings: [warning],
+      parseFailures: [failure],
+      warningDetails: [failure],
       outcome: "project-file-parse-error",
       source
     };
@@ -21610,11 +21789,13 @@ function loadPluginConfigDetailed(directory) {
     }
   }
   const recoveredTopLevelKeys = [];
+  const cacheTtlConfigured = Object.hasOwn(mergedRaw, "cache_ttl");
   const config = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
   if (profileResolution.activeProfile)
     config.profile = profileResolution.activeProfile;
   setOutputReserveConfig(config.output_reserve);
   setWindowOverlayPath(config.models?.window_overlay_path);
+  const leafValidationWarnings = [...config.configWarnings ?? []];
   if (config.configWarnings?.length) {
     allWarnings.push(...config.configWarnings.map((w) => {
       if (userLoaded && projectLoaded)
@@ -21640,6 +21821,21 @@ function loadPluginConfigDetailed(directory) {
     ...bindSubstitutionFailures(userLoaded),
     ...bindSubstitutionFailures(projectLoaded)
   ];
+  const configParseFailures = [
+    ...userLoaded?.parseFailures ?? [],
+    ...projectLoaded?.parseFailures ?? []
+  ];
+  const warningDetails = [
+    ...userLoaded?.warningDetails ?? [],
+    ...projectLoaded?.warningDetails ?? [],
+    ...leafValidationWarnings.map((message) => ({
+      warningClass: CONFIG_WARNING_CLASS.INVALID_LEAF,
+      message
+    }))
+  ];
+  config.configParseFailures = configParseFailures;
+  config.configWarningDetails = warningDetails;
+  config.cacheTtlConfigured = cacheTtlConfigured;
   const sources = {
     userConfig: userLoaded?.outcome ?? (legacyUserUnmigrated ? "legacy-config-unmigrated" : "ok"),
     projectConfig: projectLoaded?.outcome ?? (legacyProjectUnmigrated ? "legacy-config-unmigrated" : "ok")
@@ -21650,10 +21846,14 @@ function loadPluginConfigDetailed(directory) {
     loadOutcome: combinedOutcome({ sources, substitutionFailures, recoveredTopLevelKeys }),
     sources,
     substitutionFailures,
-    recoveredTopLevelKeys
+    recoveredTopLevelKeys,
+    configParseFailures,
+    warningDetails,
+    cacheTtlConfigured
   };
 }
 var init_config = __esm(() => {
+  init_config_diagnostics();
   init_jsonc_parser();
   init_models_dev_cache();
   init_window_geometry();
@@ -25904,6 +26104,18 @@ var init_module_transport = __esm(() => {
   init_dist5();
   init_data_path();
 });
+// ../plugin/src/shared/pi-executable.ts
+function piHarnessKindFromExecutable(value) {
+  const executable = (value ?? "").trim().replace(/^['"]|['"]$/g, "").replaceAll("\\", "/").split("/").at(-1)?.toLowerCase().replace(/\.(?:exe|cmd)$/, "");
+  if (!executable || !PI_IMAGE_NAMES.has(executable))
+    return;
+  return executable === "pi" ? "pi" : "omp";
+}
+var PI_IMAGE_NAMES;
+var init_pi_executable = __esm(() => {
+  PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
+});
+
 // ../plugin/src/shared/rpc-utils.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { readFileSync as readFileSync11 } from "node:fs";
@@ -26089,7 +26301,7 @@ function commandHasOpenCodeExecutable(tokens) {
 function commandHasPiExecutable(tokens) {
   for (let index = 0;index < tokens.length; index += 1) {
     const executable = executableName(tokens[index]).replace(/\.(?:exe|cmd)$/, "");
-    if (["pi", "omp", "oh-my-pi"].includes(executable))
+    if (piHarnessKindFromExecutable(executable) !== undefined)
       return true;
     if (["node", "bun", "deno"].includes(executable)) {
       const script = executableName(tokens[index + 1]).replace(/\.(?:exe|cmd)$/, "");
@@ -26429,9 +26641,10 @@ function parseRpcPortFile(content, fallbackPid = 0) {
 function isValidPort(port) {
   return Number.isInteger(port) && port > 0 && port <= 65535;
 }
-var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, WINDOWS_CIM_PROBE_TIMEOUT_MS = 5000, MAX_ANCESTOR_WALK_DEPTH = 16, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, WINDOWS_CIM_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress", PI_HARNESS_ARC_MARKERS, PI_IMAGE_NAMES, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null;
+var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, WINDOWS_CIM_PROBE_TIMEOUT_MS = 5000, MAX_ANCESTOR_WALK_DEPTH = 16, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, WINDOWS_CIM_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress", PI_HARNESS_ARC_MARKERS, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null;
 var init_rpc_utils = __esm(() => {
   init_logger();
+  init_pi_executable();
   OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
   TASKLIST_NO_TASKS_PATTERN = /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
   PI_HARNESS_ARC_MARKERS = [
@@ -26441,7 +26654,6 @@ var init_rpc_utils = __esm(() => {
     "cljs/dist",
     "dist/bundle/cli"
   ];
-  PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
   rpcIdentityReadFileSync = readFileSync11;
   rpcIdentityExecFileSync = execFileSync4;
   rpcIdentityProcessKill = process.kill;
@@ -33455,39 +33667,91 @@ function resolvePiLegacyFallback(sources) {
   return sources.find((source) => existsSync23(source.path)) ?? null;
 }
 function loadConfigFile(path, scope) {
+  let raw;
   try {
-    const raw = loadRawConfigFile({ configPath: path, tier: scope });
+    raw = loadRawConfigFile({ configPath: path, tier: scope });
     if (!raw)
       return null;
+  } catch (error) {
+    const message = `failed to read config: ${error instanceof Error ? error.message : String(error)}`;
+    return {
+      path,
+      scope,
+      config: {},
+      warnings: [`${path}: ${message}`],
+      parseFailures: [],
+      warningDetails: [
+        {
+          warningClass: CONFIG_WARNING_CLASS.FILE_IO,
+          source: scope,
+          path,
+          message
+        }
+      ],
+      loadOutcome: "project-file-io-error"
+    };
+  }
+  try {
     const substituted = substituteConfigVariables({
       text: raw.text,
       configPath: path,
       isProjectConfig: scope === "project"
     });
     const rejectedKeyPaths = [];
-    const config = sanitizeParsedJson(import_comment_json7.parse(substituted.text), { onRejectedKey: (keyPath) => rejectedKeyPaths.push(keyPath.join(".")) });
+    const parsed = parseJsoncRecovering(substituted.text, {
+      onRejectedKey: (keyPath) => rejectedKeyPaths.push(keyPath.join("."))
+    });
+    const config = parsed.value && typeof parsed.value === "object" && !Array.isArray(parsed.value) ? parsed.value : {};
     const unsafeKeyWarnings = rejectedKeyPaths.map((keyPath) => `Ignored unsafe config key "${keyPath}" (security: prototype-pollution keys are not allowed).`);
+    const firstIssue = parsed.issues[0];
+    const recovered = firstIssue !== undefined && Object.keys(config).length > 0;
+    const parseFailures = firstIssue ? [
+      {
+        warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+        source: scope,
+        path,
+        line: firstIssue.line,
+        column: firstIssue.column,
+        message: firstIssue.message,
+        recovered,
+        warning: `${path}:${firstIssue.line}:${firstIssue.column}: ${firstIssue.message}; ${recovered ? "recovered values were applied, but the file must be fixed." : "using defaults for this file."}`
+      }
+    ] : [];
     return {
       path,
       scope,
       config,
       warnings: [
-        ...raw.warnings,
-        ...substituted.warnings,
-        ...unsafeKeyWarnings
-      ].map((warning) => `${path}: ${warning}`),
-      loadOutcome: rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok"
+        ...parseFailures.map((failure) => failure.warning),
+        ...raw.warnings.map((warning) => `${path}: ${warning}`),
+        ...substituted.warnings.map((warning) => `${path}: ${warning}`),
+        ...unsafeKeyWarnings.map((warning) => `${path}: ${warning}`)
+      ],
+      parseFailures,
+      warningDetails: parseFailures,
+      loadOutcome: parseFailures.length > 0 ? "project-file-parse-error" : rejectedKeyPaths.length > 0 ? "schema-recovery" : substituted.warnings.length > 0 ? "substitution-failure" : "ok"
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    const warning = `${path}:1:1: ${message}; using defaults for this file.`;
+    const failure = {
+      warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+      source: scope,
+      path,
+      line: 1,
+      column: 1,
+      message,
+      recovered: false,
+      warning
+    };
     return {
       path,
       scope,
       config: {},
-      warnings: [
-        `${path}: failed to load config: ${message}; using defaults for this file.`
-      ],
-      loadOutcome: typeof error.code === "string" ? "project-file-io-error" : "project-file-parse-error"
+      warnings: [warning],
+      parseFailures: [failure],
+      warningDetails: [failure],
+      loadOutcome: "project-file-parse-error"
     };
   }
 }
@@ -33610,6 +33874,63 @@ function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
   return { config: defaults, warnings };
 }
 function loadPiConfig(opts = {}) {
+  const detailed = loadPiConfigDetailed(opts);
+  return {
+    config: detailed.config,
+    registrationPromptSurface: detailed.registrationPromptSurface,
+    warnings: detailed.warnings,
+    loadedFromPaths: detailed.loadedFromPaths,
+    configParseFailures: detailed.configParseFailures,
+    warningDetails: detailed.warningDetails,
+    cacheTtlConfigured: detailed.cacheTtlConfigured
+  };
+}
+function collectEmptyStringPaths2(value, prefix = "") {
+  if (typeof value === "string") {
+    return value === "" && prefix ? [prefix] : [];
+  }
+  if (Array.isArray(value) || value === null || typeof value !== "object") {
+    return [];
+  }
+  const paths = [];
+  for (const [key, child] of Object.entries(value)) {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    paths.push(...collectEmptyStringPaths2(child, nextPrefix));
+  }
+  return paths;
+}
+function bindSubstitutionFailures2(loaded) {
+  if (loaded.warnings.length === 0 || loaded.loadOutcome !== "substitution-failure") {
+    return [];
+  }
+  const emptyPaths = collectEmptyStringPaths2(loaded.config);
+  return loaded.warnings.map((message) => {
+    const matchedPath = emptyPaths.find((path) => {
+      const tail = path.split(".").at(-1) ?? path;
+      return message.includes(path) || message.toLowerCase().includes(tail.toLowerCase());
+    });
+    return {
+      keyPath: matchedPath ?? "<unknown>",
+      source: loaded.scope,
+      message
+    };
+  });
+}
+function combinedOutcome2(args) {
+  const sourceOutcomes = Object.values(args.sources);
+  if (sourceOutcomes.includes("project-file-parse-error"))
+    return "project-file-parse-error";
+  if (sourceOutcomes.includes("project-file-io-error"))
+    return "project-file-io-error";
+  if (sourceOutcomes.includes("legacy-config-unmigrated"))
+    return "legacy-config-unmigrated";
+  if (args.recoveredTopLevelKeys.length > 0)
+    return "schema-recovery";
+  if (args.substitutionFailures.length > 0)
+    return "substitution-failure";
+  return "ok";
+}
+function loadPiConfigDetailed(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const loadedFiles = [];
   const warnings = [];
@@ -33649,7 +33970,7 @@ function loadPiConfig(opts = {}) {
     return a.scope === "user" ? -1 : 1;
   });
   const userRaw = mergeFiles.find((f) => f.scope === "user")?.config ?? {};
-  const projectLoaded = mergeFiles.find((f) => f.scope === "project");
+  const projectLayer = mergeFiles.find((f) => f.scope === "project");
   let projectRaw = {};
   for (const loaded of mergeFiles) {
     const prefix = loaded.scope === "user" ? "[user config]" : "[project config]";
@@ -33666,7 +33987,7 @@ function loadPiConfig(opts = {}) {
   const trustedProfiledRaw = mergeRawConfigs(profileResolution.userBase, profileResolution.overlay);
   let rawConfig = trustedProfiledRaw;
   const trustedBaseConfig = parsePiConfig(trustedProfiledRaw).config;
-  if (projectLoaded) {
+  if (projectLayer) {
     rawConfig = mergeRawConfigs(rawConfig, profileResolution.projectBase);
     for (const warning of dropInheritedEmbeddingKeyOnRedirect(projectRaw, rawConfig, profileResolution.userBase)) {
       warnings.push(`[project config] ${warning}`);
@@ -33679,20 +34000,47 @@ function loadPiConfig(opts = {}) {
       warnings.push(`[project config] ${warning}`);
     }
   }
-  const parsed = parsePiConfig(rawConfig);
+  const recoveredTopLevelKeys = [];
+  const cacheTtlConfigured = Object.hasOwn(rawConfig, "cache_ttl");
+  const parsed = parsePiConfig(rawConfig, recoveredTopLevelKeys);
   if (profileResolution.activeProfile)
     parsed.config.profile = profileResolution.activeProfile;
   setOutputReserveConfig(parsed.config.output_reserve);
   setWindowOverlayPath(parsed.config.models?.window_overlay_path);
   warnings.push(...parsed.warnings.map((warning) => `[merged config] ${warning}`));
+  const substitutionFailures = loadedFiles.flatMap(bindSubstitutionFailures2);
+  const userLoaded = loadedFiles.find((loaded) => loaded.scope === "user");
+  const projectLoaded = loadedFiles.find((loaded) => loaded.scope === "project");
+  const configParseFailures = loadedFiles.flatMap((loaded) => loaded.parseFailures);
+  const warningDetails = [
+    ...loadedFiles.flatMap((loaded) => loaded.warningDetails),
+    ...parsed.warnings.map((message) => ({
+      warningClass: CONFIG_WARNING_CLASS.INVALID_LEAF,
+      message
+    }))
+  ];
+  const sources = {
+    userConfig: userLoaded?.loadOutcome ?? (legacyUserUnmigrated ? "legacy-config-unmigrated" : "ok"),
+    projectConfig: projectLoaded?.loadOutcome ?? (legacyProjectUnmigrated ? "legacy-config-unmigrated" : "ok")
+  };
   return {
     config: parsed.config,
     registrationPromptSurface: trustedBaseConfig.prompt_surface,
     warnings,
-    loadedFromPaths: loadedFiles.map((loaded) => loaded.path)
+    loadedFromPaths: loadedFiles.map((loaded) => loaded.path),
+    loadOutcome: combinedOutcome2({
+      sources,
+      substitutionFailures,
+      recoveredTopLevelKeys
+    }),
+    sources,
+    substitutionFailures,
+    recoveredTopLevelKeys,
+    configParseFailures,
+    warningDetails,
+    cacheTtlConfigured
   };
 }
-var import_comment_json7;
 var init_config2 = __esm(() => {
   init_migrate_config_location();
   init_agent_disable();
@@ -33702,10 +34050,10 @@ var init_config2 = __esm(() => {
   init_raw_loader();
   init_magic_context();
   init_variable();
+  init_config_diagnostics();
   init_jsonc_parser();
   init_models_dev_cache();
   init_window_geometry();
-  import_comment_json7 = __toESM(require_src3(), 1);
 });
 
 // src/lib/database-repair-guidance.ts
@@ -33799,6 +34147,243 @@ function formatGithubIssueFallback(submission, fallbackPath) {
 var MAX_GITHUB_ISSUE_BODY_CHARS = 65536;
 var init_github_issue = () => {};
 
+// src/lib/log-lines.ts
+import { existsSync as existsSync24, readFileSync as readFileSync14, statSync as statSync11 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join21 } from "node:path";
+function tokenize(input, limit) {
+  const tokens = [];
+  let index = 0;
+  while (index < input.length && tokens.length < limit) {
+    while (input[index] === " ")
+      index += 1;
+    if (index >= input.length)
+      break;
+    const start = index;
+    let quoted = false;
+    let escaped = false;
+    while (index < input.length) {
+      const char = input[index];
+      if (escaped) {
+        escaped = false;
+      } else if (quoted && char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        quoted = !quoted;
+      } else if (!quoted && char === " ") {
+        break;
+      }
+      index += 1;
+    }
+    if (quoted || escaped)
+      return null;
+    tokens.push({ raw: input.slice(start, index), start });
+  }
+  return tokens;
+}
+function decodeEscapes(value) {
+  let decoded = "";
+  for (let index = 0;index < value.length; index += 1) {
+    const char = value[index];
+    if (char !== "\\") {
+      decoded += char;
+      continue;
+    }
+    const next = value[index + 1];
+    if (next === undefined)
+      return null;
+    if (next === "n")
+      decoded += `
+`;
+    else if (next === '"')
+      decoded += '"';
+    else if (next === "\\")
+      decoded += "\\";
+    else
+      return null;
+    index += 1;
+  }
+  return decoded;
+}
+function parseField2(token) {
+  const equals = token.indexOf("=");
+  if (equals <= 0)
+    return null;
+  const key = token.slice(0, equals);
+  if (!FIELD_NAME.test(key))
+    return null;
+  const rawValue = token.slice(equals + 1);
+  if (rawValue.startsWith('"')) {
+    if (rawValue.length < 2 || !rawValue.endsWith('"'))
+      return null;
+    const value = decodeEscapes(rawValue.slice(1, -1));
+    return value === null ? null : [key, value];
+  }
+  if (rawValue.length === 0 || rawValue.includes('"'))
+    return null;
+  return [key, rawValue];
+}
+function trailingToken(input, end) {
+  let index = end;
+  let quoted = false;
+  while (index > 0) {
+    const char = input[index - 1];
+    if (char === '"') {
+      let slashStart = index - 1;
+      while (input[slashStart - 1] === "\\")
+        slashStart -= 1;
+      if ((index - 1 - slashStart) % 2 === 0)
+        quoted = !quoted;
+      index = slashStart;
+    } else if (char === " " && !quoted) {
+      break;
+    } else {
+      index -= 1;
+    }
+  }
+  return quoted ? null : { raw: input.slice(index, end), start: index };
+}
+function splitMessageAndFields(input, decodeMessage = true) {
+  let messageEnd = input.trimEnd().length;
+  const fields = [];
+  while (messageEnd > 0) {
+    const token = trailingToken(input, messageEnd);
+    const field = token && parseField2(token.raw);
+    if (!token || !field || token.start === 0)
+      break;
+    fields.push(field);
+    messageEnd = token.start;
+    while (messageEnd > 0 && input[messageEnd - 1] === " ")
+      messageEnd -= 1;
+  }
+  const rawMessage = fields.length > 0 ? input.slice(0, messageEnd) : input;
+  const message = decodeMessage ? decodeEscapes(rawMessage) ?? rawMessage : rawMessage;
+  const kv = {};
+  for (const [key, value] of fields.reverse())
+    kv[key] = value;
+  return { message, kv };
+}
+function rawSessionId(value) {
+  if (!value || value === "global")
+    return null;
+  const colon = value.indexOf(":");
+  if (colon <= 0 || colon === value.length - 1)
+    return null;
+  return value.slice(colon + 1);
+}
+function parseLogLine(line) {
+  const fleet = FLEET_PREFIX.exec(line);
+  if (fleet) {
+    const ts = fleet[1];
+    if (Number.isNaN(Date.parse(ts)) || new Date(ts).toISOString() !== ts)
+      return null;
+    const level = fleet[2].trim();
+    let remaining = fleet[3].trimStart();
+    let session = null;
+    const tags = [];
+    if (remaining.startsWith("session=")) {
+      const token = tokenize(remaining, 1)?.[0];
+      if (!token || token.raw.includes("\x1B"))
+        return null;
+      const sessionField = parseField2(token.raw);
+      if (!sessionField)
+        return null;
+      session = rawSessionId(sessionField[1]);
+      if (!session)
+        return null;
+      remaining = remaining.slice(token.raw.length).trimStart();
+    }
+    while (remaining.startsWith("tag=")) {
+      const token = tokenize(remaining, 1)?.[0];
+      if (!token || token.raw.includes("\x1B"))
+        return null;
+      const tagField = parseField2(token.raw);
+      if (!tagField?.[1])
+        return null;
+      tags.push(tagField[1]);
+      remaining = remaining.slice(token.raw.length).trimStart();
+    }
+    const body = splitMessageAndFields(remaining);
+    return { ts, level, session, tags, ...body, grammar: "fleet" };
+  }
+  const legacy = LEGACY_LINE.exec(line);
+  if (!legacy || legacy[2].includes("\x1B") || Number.isNaN(Date.parse(legacy[1])))
+    return null;
+  const body = splitMessageAndFields(legacy[3], false);
+  const legacySession = legacy[2].trim();
+  return {
+    ts: legacy[1],
+    level: null,
+    session: legacySession && legacySession !== "global" ? legacySession : null,
+    tags: [],
+    ...body,
+    grammar: "legacy"
+  };
+}
+function getMagicContextLogPaths(harness, options = {}) {
+  const override = options.override === undefined ? process.env.MAGIC_CONTEXT_LOG_PATH?.trim() : options.override?.trim();
+  const storageLogs = join21(options.storageDir ?? getMagicContextStorageDir(), "logs");
+  return [
+    ...override ? [override] : [],
+    join21(options.tempDir ?? tmpdir2(), harness, "magic-context", "magic-context.log"),
+    join21(storageLogs, `magic-context.${harness}.log`),
+    join21(storageLogs, "magic-context.log")
+  ].filter((path, index, paths) => paths.indexOf(path) === index);
+}
+function inspectLogFile(path) {
+  if (!existsSync24(path)) {
+    return { path, exists: false, sizeKb: 0, lineCount: 0, grammar: "unknown" };
+  }
+  try {
+    const content = readFileSync14(path, "utf8");
+    const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
+    const grammars = new Set(lines.flatMap((line) => {
+      const parsed = parseLogLine(line);
+      return parsed ? [parsed.grammar] : [];
+    }));
+    const grammar = grammars.size > 1 ? "mixed" : grammars.values().next().value ?? "unknown";
+    return {
+      path,
+      exists: true,
+      sizeKb: Math.round(statSync11(path).size / 1024),
+      lineCount: lines.length,
+      grammar
+    };
+  } catch {
+    return { path, exists: true, sizeKb: 0, lineCount: 0, grammar: "unknown" };
+  }
+}
+function inspectMagicContextLogs(harness, options = {}) {
+  return getMagicContextLogPaths(harness, options).map(inspectLogFile);
+}
+function readLogLines(files) {
+  const lines = files.flatMap((file, fileIndex) => {
+    if (!file.exists)
+      return [];
+    try {
+      let precedingTimestamp = "";
+      return readFileSync14(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
+        precedingTimestamp = parseLogLine(line)?.ts ?? precedingTimestamp;
+        return { line, timestamp: precedingTimestamp, fileIndex, lineIndex };
+      });
+    } catch {
+      return [];
+    }
+  });
+  lines.sort((left, right) => left.timestamp.localeCompare(right.timestamp) || left.fileIndex - right.fileIndex || left.lineIndex - right.lineIndex);
+  return lines.map(({ line }) => line);
+}
+function formatLogFileInspection(file) {
+  return `${file.path} (grammar=${file.grammar}, lines=${file.lineCount}, ${file.sizeKb} KB)`;
+}
+var FLEET_PREFIX, LEGACY_LINE, FIELD_NAME;
+var init_log_lines = __esm(() => {
+  init_data_path();
+  FLEET_PREFIX = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z) (TRACE|DEBUG|INFO |WARN |ERROR) magic-context (.*)$/;
+  LEGACY_LINE = /^\[([^\]]+)\] \[magic-context\]\[([^\]]*)\]\s+(.*)$/;
+  FIELD_NAME = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+});
+
 // src/lib/redaction.ts
 function sanitizeDiagnosticEndpoint(value) {
   const trimmed = value.trim();
@@ -33823,9 +34408,9 @@ var init_redaction2 = __esm(() => {
 
 // src/commands/doctor-omp.ts
 import { execFileSync as execFileSync5, spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync8, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync8, readFileSync as readFileSync15 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname14, join as join21, resolve as resolve7 } from "node:path";
+import { dirname as dirname14, join as join22, resolve as resolve7 } from "node:path";
 function parseSemver(value) {
   const match = value?.match(/(\d+)\.(\d+)\.(\d+)/);
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
@@ -33867,10 +34452,10 @@ function selfVersion() {
   return "unknown";
 }
 function readConfig2(path) {
-  if (!existsSync24(path))
+  if (!existsSync25(path))
     return {};
   try {
-    const parsed = import_comment_json8.parse(readFileSync14(path, "utf-8"));
+    const parsed = import_comment_json7.parse(readFileSync15(path, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? {} : { error: "top level is not an object" };
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
@@ -33880,7 +34465,7 @@ function pluginDeclaresOmp(path) {
   if (!path)
     return null;
   try {
-    const pkg = JSON.parse(readFileSync14(join21(path, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync15(join22(path, "package.json"), "utf-8"));
     return Array.isArray(pkg.omp?.extensions) || Array.isArray(pkg.pi?.extensions);
   } catch {
     return null;
@@ -33961,7 +34546,7 @@ async function runHealthChecks(options) {
     }
   }
   const userConfigPath = getOmpUserConfigPath();
-  if (!existsSync24(userConfigPath)) {
+  if (!existsSync25(userConfigPath)) {
     add(results, "warn", `No Magic Context user config at ${userConfigPath}`);
     repairPlan.writeUserConfig = true;
   } else {
@@ -33978,9 +34563,9 @@ async function runHealthChecks(options) {
     for (const warning of loaded.warnings.slice(0, 5))
       add(results, "warn", warning);
   const storage = getMagicContextStorageResolution();
-  const dbPath = join21(storage.path, "context.db");
+  const dbPath = join22(storage.path, "context.db");
   add(results, "info", `Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync24(dbPath))
+  if (!existsSync25(dbPath))
     add(results, "info", `Shared context DB will be created at ${dbPath}`);
   else {
     let db = null;
@@ -34008,8 +34593,15 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   for (const source of getOmpNonGlobalConfigSources(options.cwd)) {
     add(results, "info", `OMP non-global config: ${source}`);
   }
-  const logPath = getMagicContextLogPath2("pi");
-  add(results, "info", `Pi-compatible runtime log: ${logPath}${existsSync24(logPath) ? "" : " (not created yet)"}`);
+  const logFiles = options.deps.inspectMagicContextLogs("omp");
+  const existingLogFiles = logFiles.filter((file) => file.exists);
+  if (existingLogFiles.length === 0) {
+    add(results, "info", `No OMP runtime log yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
+  } else {
+    for (const file of existingLogFiles) {
+      add(results, "info", `OMP runtime log read: ${formatLogFileInspection(file)}`);
+    }
+  }
   if (!options.quiet)
     for (const result of results)
       printResult(options.prompts, result);
@@ -34027,12 +34619,12 @@ function writeDefaultConfig(path) {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
   };
-  writeFileAtomic(path, `${import_comment_json8.stringify(config, null, 2)}
+  writeFileAtomic(path, `${import_comment_json7.stringify(config, null, 2)}
 `);
 }
 async function repair(plan, deps, prompts, cwd) {
   let fixed = 0;
-  if (plan.writeUserConfig && !existsSync24(getOmpUserConfigPath())) {
+  if (plan.writeUserConfig && !existsSync25(getOmpUserConfigPath())) {
     writeDefaultConfig(getOmpUserConfigPath());
     prompts.log.success(`Wrote default Magic Context config to ${getOmpUserConfigPath()}`);
     fixed += 1;
@@ -34117,7 +34709,7 @@ async function runIssueFlow(options) {
     ...report.results.map((result) => `- ${result.status.toUpperCase()}: ${sanitizeDiagnosticText(result.message)}`)
   ].join(`
 `);
-  const path = join21(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
+  const path = join22(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
   writeFileAtomic(path, `${body}
 `);
   options.prompts.log.success(`Sanitized report written to ${path}`);
@@ -34161,7 +34753,7 @@ async function runDoctor(options = {}) {
   prompts.log.message(`Summary: PASS ${second.pass} / WARN ${second.warn} / FAIL ${second.fail}`);
   return second.fail === 0 ? 0 : 1;
 }
-var import_comment_json8, MIN_OMP_VERSION = "17.1.7", DEFAULT_DEPS4;
+var import_comment_json7, MIN_OMP_VERSION = "17.1.7", DEFAULT_DEPS4;
 var init_doctor_omp = __esm(async () => {
   init_magic_context();
   init_data_path();
@@ -34170,12 +34762,13 @@ var init_doctor_omp = __esm(async () => {
   init_atomic_write();
   init_config_location_migration();
   init_github_issue();
+  init_log_lines();
   init_omp_helpers();
   init_paths();
   init_prompts();
   init_redaction2();
   await init_database_access();
-  import_comment_json8 = __toESM(require_src3(), 1);
+  import_comment_json7 = __toESM(require_src3(), 1);
   DEFAULT_DEPS4 = {
     prompts: promptIO,
     detectOmpBinary,
@@ -34185,6 +34778,7 @@ var init_doctor_omp = __esm(async () => {
     runOmpCommand,
     openExistingContextDatabase,
     now: () => new Date,
+    inspectMagicContextLogs,
     execFileSync: execFileSync5,
     spawnSync: spawnSync5
   };
@@ -34304,14 +34898,14 @@ var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 // ../plugin/src/shared/tui-config.ts
 import {
   chmodSync as chmodSync5,
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   renameSync as renameSync6,
-  statSync as statSync11,
+  statSync as statSync12,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname15, join as join22 } from "node:path";
+import { dirname as dirname15, join as join23 } from "node:path";
 function pluginEntryId(entry) {
   if (typeof entry === "string")
     return entry;
@@ -34339,24 +34933,24 @@ function isMagicContextPluginEntry(entry) {
   return isLocalMagicContextDevEntry(entry);
 }
 function writeTuiConfigAtomic(configPath, config) {
-  const body = `${import_comment_json9.stringify(config, null, 2)}
+  const body = `${import_comment_json8.stringify(config, null, 2)}
 `;
   const tmpPath = `${configPath}.tmp`;
   writeFileSync6(tmpPath, body);
   try {
-    if (statSync11(configPath, { throwIfNoEntry: false })?.isFile()) {
-      chmodSync5(tmpPath, statSync11(configPath).mode & 511);
+    if (statSync12(configPath, { throwIfNoEntry: false })?.isFile()) {
+      chmodSync5(tmpPath, statSync12(configPath).mode & 511);
     }
   } catch {}
   renameSync6(tmpPath, configPath);
 }
 function resolveTuiConfigPath(configDirOverride) {
   const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join22(configDir, "tui.jsonc");
-  const jsonPath = join22(configDir, "tui.json");
-  if (existsSync25(jsoncPath))
+  const jsoncPath = join23(configDir, "tui.jsonc");
+  const jsonPath = join23(configDir, "tui.json");
+  if (existsSync26(jsoncPath))
     return jsoncPath;
-  if (existsSync25(jsonPath))
+  if (existsSync26(jsonPath))
     return jsonPath;
   return jsoncPath;
 }
@@ -34364,9 +34958,9 @@ function ensureTuiPluginEntry(options = {}) {
   try {
     const configPath = resolveTuiConfigPath(options.configDir);
     let config = {};
-    if (existsSync25(configPath)) {
-      const raw = readFileSync15(configPath, "utf-8");
-      config = import_comment_json9.parse(raw) ?? {};
+    if (existsSync26(configPath)) {
+      const raw = readFileSync16(configPath, "utf-8");
+      config = import_comment_json8.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? [...config.plugin] : [];
     const existingIdx = plugins.findIndex(isMagicContextPluginEntry);
@@ -34408,19 +35002,19 @@ function ensureTuiPluginEntry(options = {}) {
     return false;
   }
 }
-var import_comment_json9, PLUGIN_NAME2 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY;
+var import_comment_json8, PLUGIN_NAME2 = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY;
 var init_tui_config = __esm(() => {
   init_logger();
   init_opencode_config_dir();
-  import_comment_json9 = __toESM(require_src3(), 1);
+  import_comment_json8 = __toESM(require_src3(), 1);
   PLUGIN_ENTRY = `${PLUGIN_NAME2}@latest`;
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync26, readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync27, readdirSync as readdirSync3, readFileSync as readFileSync17, statSync as statSync13 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir15 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function getSelfVersion() {
   const require2 = createRequire3(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -34438,8 +35032,8 @@ function getPluginCacheInfo() {
   let cached;
   for (const installedPkgPath of getOpenCodePluginPackageJsonPaths()) {
     try {
-      if (existsSync26(installedPkgPath)) {
-        const pkg = JSON.parse(readFileSync16(installedPkgPath, "utf-8"));
+      if (existsSync27(installedPkgPath)) {
+        const pkg = JSON.parse(readFileSync17(installedPkgPath, "utf-8"));
         cached = typeof pkg.version === "string" ? pkg.version : undefined;
         if (cached)
           break;
@@ -34455,7 +35049,7 @@ function getStorageResolution() {
 }
 function fileSize(path) {
   try {
-    return existsSync26(path) ? statSync12(path).size : 0;
+    return existsSync27(path) ? statSync13(path).size : 0;
   } catch {
     return 0;
   }
@@ -34467,11 +35061,11 @@ function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
 function readConfig3(path) {
-  if (!existsSync26(path))
+  if (!existsSync27(path))
     return { value: null };
   try {
-    const raw = readFileSync16(path, "utf-8");
-    const value = import_comment_json10.parse(raw);
+    const raw = readFileSync17(path, "utf-8");
+    const value = import_comment_json9.parse(raw);
     return { value };
   } catch (error) {
     return { value: null, error: error instanceof Error ? error.message : String(error) };
@@ -34495,7 +35089,7 @@ function configHasPluginEntry(config) {
 }
 function parseHistorianDumpMeta(path) {
   try {
-    const xml = readFileSync16(path, "utf-8");
+    const xml = readFileSync17(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -34528,11 +35122,11 @@ function parseHistorianDumpMeta(path) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync26(dir))
+  if (!existsSync27(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync3(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync12(join23(dir, name));
+      const stat = statSync13(join24(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -34541,7 +35135,7 @@ function listDumpsInDir(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta(join23(dir, entry.name));
+      const meta = parseHistorianDumpMeta(join24(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -34652,9 +35246,9 @@ function collectRecentSessionsFromDatabase(database) {
   });
 }
 async function collectRecentSessions() {
-  const dataHome = process.env.XDG_DATA_HOME || join23(process.env.HOME || homedir15(), ".local", "share");
-  const opencodeDbPath = join23(dataHome, "opencode", "opencode.db");
-  if (!existsSync26(opencodeDbPath))
+  const dataHome = process.env.XDG_DATA_HOME || join24(process.env.HOME || homedir15(), ".local", "share");
+  const opencodeDbPath = join24(dataHome, "opencode", "opencode.db");
+  if (!existsSync27(opencodeDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -34679,8 +35273,8 @@ async function collectRecentSessions() {
   }
 }
 async function collectHistorianFailures(storageDirPath) {
-  const contextDbPath = join23(storageDirPath, "context.db");
-  if (!existsSync26(contextDbPath))
+  const contextDbPath = join24(storageDirPath, "context.db");
+  if (!existsSync27(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -34713,8 +35307,8 @@ async function collectHistorianFailures(storageDirPath) {
   }
 }
 async function collectHistorianRuns(storageDirPath) {
-  const contextDbPath = join23(storageDirPath, "context.db");
-  if (!existsSync26(contextDbPath))
+  const contextDbPath = join24(storageDirPath, "context.db");
+  if (!existsSync27(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined")
     return [];
@@ -34784,9 +35378,9 @@ async function collectDiagnostics() {
   const magicContextConfig = readConfig3(configPaths.magicContextConfig);
   const storageResolution = getStorageResolution();
   const storageDirPath = storageResolution.path;
-  const contextDbPath = join23(storageDirPath, "context.db");
-  const logPath = getMagicContextLogPath2("opencode");
-  const logFileSize = existsSync26(logPath) ? statSync12(logPath).size : 0;
+  const contextDbPath = join24(storageDirPath, "context.db");
+  const logFiles = inspectMagicContextLogs("opencode");
+  const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -34814,7 +35408,7 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync26(configPaths.magicContextConfig),
+      exists: existsSync27(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
@@ -34822,7 +35416,7 @@ async function collectDiagnostics() {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync26(storageDirPath),
+      exists: existsSync27(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     conflicts: {
@@ -34832,10 +35426,11 @@ async function collectDiagnostics() {
       nativeCompaction: conflictResult.nativeCompaction
     },
     logFile: {
-      path: logPath,
-      exists: existsSync26(logPath),
-      sizeKb: Math.round(logFileSize / 1024)
+      path: primaryLog.path,
+      exists: primaryLog.exists,
+      sizeKb: primaryLog.sizeKb
     },
+    logFiles,
     recentSessions,
     historianDumps: collectHistorianDumps(recentSessions),
     historianFailures: await collectHistorianFailures(storageDirPath),
@@ -34964,26 +35559,25 @@ function renderDiagnosticsMarkdown(report) {
     ].join(`
 `),
     "",
-    "### Log file",
-    `- Path: ${sanitizeString(report.logFile.path)}`,
-    `- Exists: ${report.logFile.exists}`,
-    `- Size: ${report.logFile.sizeKb} KB`
+    "### Log files",
+    ...(report.logFiles ?? [report.logFile]).map((file) => `- ${sanitizeString(file.path)}: exists=${file.exists}, grammar=${"grammar" in file ? file.grammar : "unknown"}, lines=${"lineCount" in file ? file.lineCount : 0}, size=${file.sizeKb} KB`)
   ].join(`
 `);
 }
-var import_comment_json10, RECENT_SESSION_GROUP_LIMIT = 5, CHILD_SESSIONS_PER_PARENT_LIMIT = 3;
+var import_comment_json9, RECENT_SESSION_GROUP_LIMIT = 5, CHILD_SESSIONS_PER_PARENT_LIMIT = 3;
 var init_diagnostics_opencode = __esm(() => {
   init_config();
   init_agent_disable();
   init_compartment_parser();
   init_conflict_detector();
   init_data_path();
+  init_log_lines();
   init_opencode_detect();
   init_opencode_helpers();
   init_opencode_plugin_cache();
   init_paths();
   init_redaction2();
-  import_comment_json10 = __toESM(require_src3(), 1);
+  import_comment_json9 = __toESM(require_src3(), 1);
 });
 // ../plugin/src/features/magic-context/memory/embedding-synapse.ts
 var SYNAPSE_CERTIFICATION_REFUSAL_REASONS, factoryClients;
@@ -35049,9 +35643,9 @@ var init_embedding_local = __esm(() => {
 
 // src/lib/embedding-runtime.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync27, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync18 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname16, join as join24, sep } from "node:path";
+import { dirname as dirname16, join as join25, sep } from "node:path";
 function describeError(error) {
   const message = error instanceof Error ? error.message : String(error ?? "unknown error");
   const code = error?.code;
@@ -35192,11 +35786,11 @@ function expectedBinaryRelPath(platform, arch) {
   const supportedArch = arch === "x64" || arch === "arm64";
   if (!supportedPlatform || !supportedArch)
     return null;
-  return join24("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
+  return join25("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
 }
 function onnxRuntimeNodeVersion(packageDir) {
   try {
-    const parsed = JSON.parse(readFileSync17(join24(packageDir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync18(join25(packageDir, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : undefined;
   } catch {
     return;
@@ -35245,7 +35839,7 @@ function formatLocalEmbeddingRuntimeWasmSelected(status) {
 function requireNodeWasmBundle(probe, candidates) {
   if (probe.state === "failed")
     return probe;
-  const bundlePath = candidates.find((candidate) => existsSync27(candidate));
+  const bundlePath = candidates.find((candidate) => existsSync28(candidate));
   return bundlePath ? probe : {
     state: "failed",
     reason: `functional Node WASM Transformers bundle is missing (checked ${candidates.join(", ")})`
@@ -35253,13 +35847,13 @@ function requireNodeWasmBundle(probe, candidates) {
 }
 function nodeWasmBundleCandidates(installRoot) {
   return [
-    join24(installRoot, "dist", "transformers-node-wasm.js"),
-    join24(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
-    join24(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
+    join25(installRoot, "dist", "transformers-node-wasm.js"),
+    join25(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
+    join25(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
   ];
 }
 function probeWasmRuntimeAt(installRoot) {
-  const requireFn = createRequire4(join24(installRoot, "package.json"));
+  const requireFn = createRequire4(join25(installRoot, "package.json"));
   return requireNodeWasmBundle(probeWasmRuntimeFromRequire(requireFn), nodeWasmBundleCandidates(installRoot));
 }
 function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
@@ -35268,9 +35862,9 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
     const wasm = probeWasmRuntimeAt(installRoot);
     return wasm.state === "ok" ? { state: "wasm-selected", wasmPath: wasm.wasmPath } : { state: "wasm-broken", wasmReason: wasm.reason };
   }
-  const packageDir = join24(installRoot, "node_modules", "onnxruntime-node");
+  const packageDir = join25(installRoot, "node_modules", "onnxruntime-node");
   let native;
-  if (!existsSync27(join24(packageDir, "package.json"))) {
+  if (!existsSync28(join25(packageDir, "package.json"))) {
     native = { state: "package-missing", packageDir };
   } else {
     const rel = expectedBinaryRelPath(platform, arch);
@@ -35280,8 +35874,8 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
         binaryPath: packageDir
       };
     } else {
-      const binaryPath = join24(packageDir, rel);
-      native = existsSync27(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
+      const binaryPath = join25(packageDir, rel);
+      native = existsSync28(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
         state: "binary-missing",
         packageDir,
         expectedBinary: binaryPath,
@@ -35292,7 +35886,7 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
   return withWasmFallback(native, () => probeWasmRuntimeAt(installRoot));
 }
 function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  const existing = installRoots.filter((root) => existsSync27(root));
+  const existing = installRoots.filter((root) => existsSync28(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -35322,15 +35916,15 @@ function packageDirFromResolved(resolvedPath, packageName) {
 }
 function probeWasmRuntimeByResolution(pluginDir) {
   try {
-    const reqPlugin = createRequire4(join24(pluginDir, "package.json"));
+    const reqPlugin = createRequire4(join25(pluginDir, "package.json"));
     const direct = probeWasmRuntimeFromRequire(reqPlugin);
     let probe = direct;
     if (direct.state === "failed" && direct.reason.startsWith("onnxruntime-web is not resolvable")) {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      probe = probeWasmRuntimeFromRequire(createRequire4(join24(tfDir, "package.json")));
+      probe = probeWasmRuntimeFromRequire(createRequire4(join25(tfDir, "package.json")));
     }
-    return requireNodeWasmBundle(probe, [join24(pluginDir, "dist", "transformers-node-wasm.js")]);
+    return requireNodeWasmBundle(probe, [join25(pluginDir, "dist", "transformers-node-wasm.js")]);
   } catch (error) {
     return {
       state: "failed",
@@ -35339,7 +35933,7 @@ function probeWasmRuntimeByResolution(pluginDir) {
   }
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  if (!existsSync27(join24(pluginDir, "package.json"))) {
+  if (!existsSync28(join25(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   const selectedRuntime = resolveLocalEmbeddingRuntime(runtimePreference, host);
@@ -35350,13 +35944,13 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   let onnxDir = null;
   let resolveError;
   try {
-    const reqPlugin = createRequire4(join24(pluginDir, "package.json"));
+    const reqPlugin = createRequire4(join25(pluginDir, "package.json"));
     try {
       onnxDir = packageDirFromResolved(reqPlugin.resolve("onnxruntime-node"), "onnxruntime-node");
     } catch {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      const reqTf = createRequire4(join24(tfDir, "package.json"));
+      const reqTf = createRequire4(join25(tfDir, "package.json"));
       onnxDir = packageDirFromResolved(reqTf.resolve("onnxruntime-node"), "onnxruntime-node");
     }
   } catch (error) {
@@ -35364,7 +35958,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     if (resolveError === "ERR_MODULE_NOT_FOUND" || resolveError === "MODULE_NOT_FOUND") {
       return withWasmFallback({
         state: "package-missing",
-        packageDir: join24(pluginDir, "node_modules", "onnxruntime-node")
+        packageDir: join25(pluginDir, "node_modules", "onnxruntime-node")
       }, () => probeWasmRuntimeByResolution(pluginDir));
     }
     return {
@@ -35380,8 +35974,8 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   if (rel === null) {
     native = probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   } else {
-    const binaryPath = join24(onnxDir, rel);
-    native = existsSync27(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
+    const binaryPath = join25(onnxDir, rel);
+    native = existsSync28(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
       state: "binary-missing",
       packageDir: onnxDir,
       expectedBinary: binaryPath,
@@ -35417,7 +36011,14 @@ var init_embedding_runtime = __esm(() => {
 
 // src/lib/issue-body.ts
 function isErrorLogLine(line) {
-  return ERROR_LOG_PATTERNS.some((rx) => rx.test(line));
+  const parsed = parseLogLine(line);
+  if (parsed?.level !== null && parsed?.level !== undefined) {
+    return parsed.level === "ERROR" || parsed.level === "WARN";
+  }
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(line))
+    return false;
+  const message = parsed?.message ?? line;
+  return ERROR_LOG_PATTERNS.some((rx) => rx.test(message));
 }
 function extractRecentErrors(sanitized, limit = 20) {
   const matches = [];
@@ -35504,6 +36105,7 @@ var MAX_GITHUB_BODY_BYTES = 60000, LOG_TRUNCATION_MARKER = `[truncated for GitHu
 [truncated for GitHub 64KB limit]
 `, ERROR_LOG_PATTERNS;
 var init_issue_body = __esm(() => {
+  init_log_lines();
   ERROR_LOG_PATTERNS = [
     /\bfailed:/i,
     /\b(?:[A-Z][a-zA-Z]*)?Error:\s/,
@@ -35515,8 +36117,8 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/logs-opencode.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join25 } from "node:path";
+import { writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join26 } from "node:path";
 function sanitizeLogContent(content) {
   return sanitizeDiagnosticText(content);
 }
@@ -35539,7 +36141,8 @@ function extractHistorianFailureLines(sanitized, limit = 30) {
   const matches = [];
   const lines = sanitized.split(/\r?\n/);
   for (let i = lines.length - 1;i >= 0 && matches.length < limit; i -= 1) {
-    if (isHistorianLogLine(lines[i])) {
+    const parsed = parseLogLine(lines[i]);
+    if (parsed && isHistorianLogLine(parsed.message)) {
       matches.push(lines[i]);
     }
   }
@@ -35548,9 +36151,12 @@ function extractHistorianFailureLines(sanitized, limit = 30) {
 function filterLogLinesBySession(lines, sessionId) {
   if (!sessionId)
     return lines;
-  const otherSessionPattern = /\bses_[A-Za-z0-9]{8,32}\b/g;
+  const otherSessionPattern = /\bses_[A-Za-z0-9]{3,64}\b/g;
   return lines.filter((line) => {
-    const matches = line.match(otherSessionPattern);
+    const parsed = parseLogLine(line);
+    if (parsed?.session && parsed.session !== sessionId)
+      return false;
+    const matches = parsed?.message.match(otherSessionPattern) ?? line.match(otherSessionPattern);
     if (!matches)
       return true;
     return matches.every((id) => id === sessionId);
@@ -35558,7 +36164,7 @@ function filterLogLinesBySession(lines, sessionId) {
 }
 async function bundleIssueReport(report, description, title, sessionFilter = null) {
   const LOG_TAIL_LINES = 400;
-  const allLogLines = report.logFile.exists ? readFileSync18(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const allLogLines = readLogLines(report.logFiles ?? [report.logFile]);
   const logLines = filterLogLinesBySession(allLogLines, sessionFilter);
   const recentLog = sanitizeLogContent(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
@@ -35619,10 +36225,10 @@ async function bundleIssueReport(report, description, title, sessionFilter = nul
   const bodyMarkdown = capBodyToGithubLimit(rawBodyMarkdown);
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const timestamp = formatTimestamp(new Date);
-  const path = join25(process.cwd(), `magic-context-issue-${timestamp}.md`);
+  const path = join26(process.cwd(), `magic-context-issue-${timestamp}.md`);
   writeFileSync7(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? join25(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? join26(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
     writeFileSync7(fullPath, `${rawBodyMarkdown}
 `);
@@ -35632,6 +36238,7 @@ var HISTORIAN_LOG_PATTERNS;
 var init_logs_opencode = __esm(() => {
   init_diagnostics_opencode();
   init_issue_body();
+  init_log_lines();
   init_redaction2();
   HISTORIAN_LOG_PATTERNS = [
     /historian failure:/,
@@ -35888,24 +36495,24 @@ function migrateExperimentalPinKeyFilesForDoctor(mcConfig) {
 
 // ../plugin/src/hooks/auto-update-checker/constants.ts
 import { homedir as homedir16, platform } from "node:os";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join26(process.env.LOCALAPPDATA ?? homedir16(), "opencode");
+    return join27(process.env.LOCALAPPDATA ?? homedir16(), "opencode");
   }
-  return join26(homedir16(), ".cache", "opencode");
+  return join27(homedir16(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join26(process.env.APPDATA ?? join26(homedir16(), "AppData", "Roaming"), "opencode");
+    return join27(process.env.APPDATA ?? join27(homedir16(), "AppData", "Roaming"), "opencode");
   }
-  return join26(process.env.XDG_CONFIG_HOME ?? join26(homedir16(), ".config"), "opencode");
+  return join27(process.env.XDG_CONFIG_HOME ?? join27(homedir16(), ".config"), "opencode");
 }
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context", CACHE_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC;
 var init_constants2 = __esm(() => {
-  CACHE_DIR = join26(getOpenCodeCacheRoot(), "packages");
-  USER_OPENCODE_CONFIG = join26(getOpenCodeConfigRoot(), "opencode.json");
-  USER_OPENCODE_CONFIG_JSONC = join26(getOpenCodeConfigRoot(), "opencode.jsonc");
+  CACHE_DIR = join27(getOpenCodeCacheRoot(), "packages");
+  USER_OPENCODE_CONFIG = join27(getOpenCodeConfigRoot(), "opencode.json");
+  USER_OPENCODE_CONFIG_JSONC = join27(getOpenCodeConfigRoot(), "opencode.jsonc");
 });
 // ../plugin/src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema, OpencodePluginTupleSchema, OpencodeConfigSchema, PackageJsonSchema;
@@ -35928,14 +36535,14 @@ var init_types = __esm(() => {
 // ../plugin/src/hooks/auto-update-checker/checker.ts
 import {
   accessSync as accessSync2,
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   constants as fsConstants,
   readFileSync as readFileSync19,
   renameSync as renameSync7,
-  statSync as statSync13,
+  statSync as statSync14,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname17, isAbsolute as isAbsolute5, join as join27, resolve as resolve8 } from "node:path";
+import { dirname as dirname17, isAbsolute as isAbsolute5, join as join28, resolve as resolve8 } from "node:path";
 function warn(message) {
   log3(`WARN: ${message}`);
 }
@@ -35953,7 +36560,7 @@ function getPluginEntries(config) {
 }
 function parseJsonConfig(content) {
   try {
-    return import_comment_json11.parse(content);
+    return import_comment_json10.parse(content);
   } catch (err) {
     warn(`[auto-update-checker] Failed to parse OpenCode config: ${String(err)}`);
     return null;
@@ -35965,13 +36572,13 @@ function getSurfaceConfigPaths(directory, surface) {
   const dirs = [
     globalDir,
     directory,
-    join27(directory, ".opencode"),
+    join28(directory, ".opencode"),
     process.env.OPENCODE_CONFIG_DIR
   ].filter((value) => Boolean(value));
   const paths = [];
   for (const dir of dirs) {
     for (const extension of ["json", "jsonc"]) {
-      const path = join27(dir, `${name}.${extension}`);
+      const path = join28(dir, `${name}.${extension}`);
       if (!paths.includes(path))
         paths.push(path);
     }
@@ -35982,7 +36589,7 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync28(path))
+      if (!existsSync29(path))
         continue;
       const parsed = parseJsonConfig(readFileSync19(path, "utf-8"));
       const entries = getPluginEntries(parsed);
@@ -36011,21 +36618,21 @@ function findPluginEntry(directory, surface = "server") {
     configPath: winner.path
   };
 }
-var import_comment_json11;
+var import_comment_json10;
 var init_checker = __esm(() => {
   init_logger();
   init_constants2();
   init_types();
-  import_comment_json11 = __toESM(require_src3(), 1);
+  import_comment_json10 = __toESM(require_src3(), 1);
 });
 
 // src/lib/opencode-plugin-schema-fence.ts
-import { existsSync as existsSync29, readdirSync as readdirSync4, readFileSync as readFileSync20 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync30, readdirSync as readdirSync4, readFileSync as readFileSync20 } from "node:fs";
+import { join as join29 } from "node:path";
 import { gunzipSync } from "node:zlib";
 function readPackageVersion(packageJsonPath) {
   try {
-    if (!existsSync29(packageJsonPath))
+    if (!existsSync30(packageJsonPath))
       return null;
     const packageJson = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
     if (packageJson.name !== OPENCODE_PLUGIN_NAME || typeof packageJson.version !== "string") {
@@ -36046,8 +36653,8 @@ function readFenceValue(text) {
   return values.size === 1 ? [...values][0] ?? null : null;
 }
 function readFenceFromDist(packageDirectory) {
-  const distDirectory = join28(packageDirectory, "dist");
-  if (!existsSync29(distDirectory))
+  const distDirectory = join29(packageDirectory, "dist");
+  if (!existsSync30(distDirectory))
     return null;
   const pending = [distDirectory];
   const fenceValues = new Set;
@@ -36057,7 +36664,7 @@ function readFenceFromDist(packageDirectory) {
       continue;
     try {
       for (const entry of readdirSync4(directory, { withFileTypes: true })) {
-        const path = join28(directory, entry.name);
+        const path = join29(directory, entry.name);
         if (entry.isDirectory()) {
           pending.push(path);
           continue;
@@ -36075,20 +36682,20 @@ function readFenceFromDist(packageDirectory) {
   return fenceValues.size === 1 ? [...fenceValues][0] ?? null : null;
 }
 function findInstalledPluginPackage(cacheDirectory, specifier, requestedVersion) {
-  const directCacheRoot = join28(cacheDirectory, specifier);
+  const directCacheRoot = join29(cacheDirectory, specifier);
   const candidates = [directCacheRoot];
   try {
     for (const entry of readdirSync4(cacheDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const candidate = join28(cacheDirectory, entry.name);
+      const candidate = join29(cacheDirectory, entry.name);
       if (!candidates.includes(candidate))
         candidates.push(candidate);
     }
   } catch {}
   for (const cacheRoot of candidates) {
-    const directory = join28(cacheRoot, "node_modules", ...PACKAGE_PATH_SEGMENTS);
-    const version = readPackageVersion(join28(directory, "package.json"));
+    const directory = join29(cacheRoot, "node_modules", ...PACKAGE_PATH_SEGMENTS);
+    const version = readPackageVersion(join29(directory, "package.json"));
     if (!version)
       continue;
     if (cacheRoot === directCacheRoot || EXACT_VERSION_PATTERN.test(requestedVersion) && version === requestedVersion) {
@@ -36282,11 +36889,11 @@ var init_storage_versions = __esm(async () => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync30, readFileSync as readFileSync21, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync21, rmSync as rmSync3 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync30(installedPkgPath))
+    if (!existsSync31(installedPkgPath))
       return;
     const pkg = JSON.parse(readFileSync21(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
@@ -36297,7 +36904,7 @@ function readCachedPluginVersion(pluginCacheDir) {
 async function clearPluginCache(options = {}, deps = {}) {
   const remove = deps.remove ?? ((path) => rmSync3(path, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync30(root));
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync31(root));
   if (existingRoots.length === 0) {
     return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
   }
@@ -36365,10 +36972,10 @@ var init_doctor_opencode_cache = __esm(() => {
 
 // src/commands/doctor-opencode.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync31, readFileSync as readFileSync22, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync32, readFileSync as readFileSync22 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir17 } from "node:os";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function resolveCompactionEnabledForDoctor() {
   try {
     const config = loadPluginConfig(process.cwd());
@@ -36467,12 +37074,12 @@ function getUserNpmrcPath() {
   if (custom)
     return custom;
   const home = process.env.HOME?.trim();
-  return join29(home || homedir17(), ".npmrc");
+  return join30(home || homedir17(), ".npmrc");
 }
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync31(npmrcPath))
+  if (!existsSync32(npmrcPath))
     return ageWarnings;
   try {
     const npmrc = readFileSync22(npmrcPath, "utf-8");
@@ -36609,7 +37216,7 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync31(magicContextConfigPath)) {
+  if (!existsSync32(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -36628,7 +37235,7 @@ async function checkEmbeddingConfig(magicContextConfigPath) {
   });
   let parsedConfig;
   try {
-    parsedConfig = import_comment_json12.parse(substituted.text);
+    parsedConfig = import_comment_json11.parse(substituted.text);
   } catch (error) {
     log2.warn(`Embedding check skipped — could not parse magic-context.jsonc: ${error instanceof Error ? error.message : String(error)}`);
     return { issues: 1 };
@@ -36741,7 +37348,7 @@ async function runDoctor2(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "OpenCode",
     openDatabase: (readonly = true) => {
-      const dbPath = join29(getMagicContextStorageDir(), "context.db");
+      const dbPath = join30(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -36773,7 +37380,7 @@ async function runDoctor2(options = {}) {
     failCount++;
     issues++;
   };
-  const authorityDbPath = join29(getMagicContextStorageDir(), "context.db");
+  const authorityDbPath = join30(getMagicContextStorageDir(), "context.db");
   let authorityDb = null;
   try {
     authorityDb = openExistingContextDatabase(authorityDbPath, { readonly: true });
@@ -36824,7 +37431,7 @@ async function runDoctor2(options = {}) {
   } else {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
-  if (existsSync31(paths.magicContextConfig)) {
+  if (existsSync32(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
@@ -36834,7 +37441,11 @@ async function runDoctor2(options = {}) {
         text: raw.text,
         configPath: paths.magicContextConfig
       }).text;
-      import_comment_json12.parse(substituted);
+      const parsed = parseJsoncRecovering(substituted);
+      const issue = parsed.issues[0];
+      if (issue) {
+        throw new Error(`${paths.magicContextConfig}:${issue.line}:${issue.column}: ${issue.message} (runtime recovery does not make the file valid)`);
+      }
       pass("magic-context.jsonc parses as valid JSONC");
     } catch (err) {
       fail(`magic-context.jsonc parse failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -36854,12 +37465,12 @@ async function runDoctor2(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log2.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync31(paths.magicContextConfig)) {
+  if (existsSync32(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
         throw new Error("Magic Context config disappeared while doctor was reading it");
-      const mcConfig = import_comment_json12.parse(raw.text);
+      const mcConfig = import_comment_json11.parse(raw.text);
       let mcChanged = false;
       const experimental = mcConfig.experimental;
       if (experimental && "compaction_markers" in experimental) {
@@ -36967,7 +37578,7 @@ async function runDoctor2(options = {}) {
         fixed++;
       }
       if (mcChanged) {
-        writeFileAtomic(paths.magicContextConfig, `${import_comment_json12.stringify(mcConfig, null, 2)}
+        writeFileAtomic(paths.magicContextConfig, `${import_comment_json11.stringify(mcConfig, null, 2)}
 `);
       }
     } catch {
@@ -36977,7 +37588,7 @@ async function runDoctor2(options = {}) {
   if (paths.opencodeConfigFormat !== "none") {
     try {
       const raw = readFileSync22(paths.opencodeConfig, "utf-8");
-      const config = import_comment_json12.parse(raw);
+      const config = import_comment_json11.parse(raw);
       const rawPlugins = Array.isArray(config?.plugin) ? config.plugin : [];
       const existingIdx = rawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
       if (rawPlugins.some((entry) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry))) {
@@ -37011,7 +37622,7 @@ async function runDoctor2(options = {}) {
               rawPlugins[existingIdx] = OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
             }
             config.plugin = rawPlugins;
-            writeFileAtomic(paths.opencodeConfig, `${import_comment_json12.stringify(config, null, 2)}
+            writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
 `);
             pass(`Upgraded plugin entry in ${configName}: ${oldEntryStr} → ${OPENCODE_PLUGIN_ENTRY_WITH_VERSION}`);
             fixed++;
@@ -37020,7 +37631,7 @@ async function runDoctor2(options = {}) {
       } else {
         rawPlugins.push(OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
         config.plugin = rawPlugins;
-        writeFileAtomic(paths.opencodeConfig, `${import_comment_json12.stringify(config, null, 2)}
+        writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
 `);
         pass(`Added plugin to ${configName}`);
         fixed++;
@@ -37061,10 +37672,10 @@ async function runDoctor2(options = {}) {
     pass("Added TUI sidebar plugin to tui.json");
     warn("Restart OpenCode to see the sidebar");
     fixed++;
-  } else if (existsSync31(paths.tuiConfig)) {
+  } else if (existsSync32(paths.tuiConfig)) {
     try {
       const tuiRaw = readFileSync22(paths.tuiConfig, "utf-8");
-      const tuiConfig = import_comment_json12.parse(tuiRaw);
+      const tuiConfig = import_comment_json11.parse(tuiRaw);
       const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
       const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
       if (tuiRawPlugins.some((entry) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry))) {
@@ -37095,7 +37706,7 @@ async function runDoctor2(options = {}) {
               tuiRawPlugins[tuiIdx] = OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
             }
             tuiConfig.plugin = tuiRawPlugins;
-            writeFileAtomic(paths.tuiConfig, `${import_comment_json12.stringify(tuiConfig, null, 2)}
+            writeFileAtomic(paths.tuiConfig, `${import_comment_json11.stringify(tuiConfig, null, 2)}
 `);
             pass(`Upgraded TUI plugin: ${tuiEntryStr} → ${OPENCODE_PLUGIN_ENTRY_WITH_VERSION}`);
             fixed++;
@@ -37112,12 +37723,12 @@ async function runDoctor2(options = {}) {
   } else {
     fail("Could not create or verify the TUI sidebar config");
   }
-  if (existsSync31(paths.magicContextConfig)) {
+  if (existsSync32(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
         throw new Error("Magic Context config disappeared while doctor was reading it");
-      const mcConfig = import_comment_json12.parse(raw.text);
+      const mcConfig = import_comment_json11.parse(raw.text);
       const warning = checkUserMemoriesDreamerCompatibility(mcConfig);
       if (warning) {
         log2.warn(warning);
@@ -37134,9 +37745,9 @@ async function runDoctor2(options = {}) {
   else
     passCount++;
   const storage = getMagicContextStorageResolution();
-  const dbPath = join29(storage.path, "context.db");
+  const dbPath = join30(storage.path, "context.db");
   log2.info(`Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync31(dbPath)) {
+  if (!existsSync32(dbPath)) {
     log2.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     log2.info(`Shared context DB exists at ${dbPath}`);
@@ -37257,13 +37868,14 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
       issues++;
     }
   }
-  const logPath = getMagicContextLogPath2("opencode");
-  if (existsSync31(logPath)) {
-    const logStat = statSync14(logPath);
-    const sizeKb = (logStat.size / 1024).toFixed(0);
-    log2.info(`Log file: ${logPath} (${sizeKb} KB)`);
+  const logFiles = inspectMagicContextLogs("opencode");
+  const existingLogFiles = logFiles.filter((file) => file.exists);
+  if (existingLogFiles.length === 0) {
+    log2.info(`No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
   } else {
-    log2.info(`Log file: ${logPath} (not yet created)`);
+    for (const file of existingLogFiles) {
+      log2.info(`Log file read: ${formatLogFileInspection(file)}`);
+    }
   }
   const diagnostics = await collectDiagnostics();
   const dumpBuckets = diagnostics.historianDumps.byProject;
@@ -37304,7 +37916,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   }
   return 0;
 }
-var import_comment_json12, CLI_PACKAGE_NAME = "@cortexkit/magic-context";
+var import_comment_json11, CLI_PACKAGE_NAME = "@cortexkit/magic-context";
 var init_doctor_opencode = __esm(async () => {
   init_config();
   init_agent_disable();
@@ -37313,6 +37925,7 @@ var init_doctor_opencode = __esm(async () => {
   init_conflict_detector();
   init_conflict_fixer();
   init_data_path();
+  init_jsonc_parser();
   init_tui_config();
   init_opencode();
   init_atomic_write();
@@ -37320,6 +37933,7 @@ var init_doctor_opencode = __esm(async () => {
   init_diagnostics_opencode();
   init_embedding_runtime();
   init_github_issue();
+  init_log_lines();
   init_logs_opencode();
   init_migrate_dreamer_v2_doctor();
   init_opencode_detect();
@@ -37337,13 +37951,13 @@ var init_doctor_opencode = __esm(async () => {
     init_v22_backfill_commands(),
     init_doctor_authority()
   ]);
-  import_comment_json12 = __toESM(require_src3(), 1);
+  import_comment_json11 = __toESM(require_src3(), 1);
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync32, readdirSync as readdirSync5, readFileSync as readFileSync23, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync33, readdirSync as readdirSync5, readFileSync as readFileSync23, statSync as statSync15 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire6(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -37358,7 +37972,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path) {
   try {
-    return existsSync32(path) ? statSync15(path).size : 0;
+    return existsSync33(path) ? statSync15(path).size : 0;
   } catch {
     return 0;
   }
@@ -37370,11 +37984,11 @@ function sanitizeValue2(value) {
   return sanitizeConfigValue(value);
 }
 function readJsonc(path) {
-  if (!existsSync32(path))
+  if (!existsSync33(path))
     return { value: {} };
   try {
     return {
-      value: import_comment_json13.parse(readFileSync23(path, "utf-8"))
+      value: import_comment_json12.parse(readFileSync23(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -37390,7 +38004,7 @@ function readConfigDiagnostic(path) {
   const parsed = readJsonc(path);
   return {
     path,
-    exists: existsSync32(path),
+    exists: existsSync33(path),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -37408,7 +38022,7 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync32(sessionsRoot))
+  if (!existsSync33(sessionsRoot))
     return [];
   try {
     const slugs = readdirSync5(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -37417,7 +38031,7 @@ function collectPiRecentSessions() {
       const directory = reverseSlugToDirectory(slug);
       if (!directory)
         continue;
-      const slugDir = join30(sessionsRoot, slug);
+      const slugDir = join31(sessionsRoot, slug);
       let files;
       try {
         files = readdirSync5(slugDir).filter((name) => name.endsWith(".jsonl"));
@@ -37426,7 +38040,7 @@ function collectPiRecentSessions() {
       }
       for (const file of files) {
         try {
-          const mtime = statSync15(join30(slugDir, file)).mtimeMs;
+          const mtime = statSync15(join31(slugDir, file)).mtimeMs;
           const sessionId = file.replace(/\.jsonl$/, "");
           candidates.push({ sessionId, directory, mtime });
         } catch {}
@@ -37477,11 +38091,11 @@ function parseHistorianDumpMeta2(path) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync32(dir))
+  if (!existsSync33(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync5(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync15(join30(dir, name));
+      const stat = statSync15(join31(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -37490,7 +38104,7 @@ function listDumpsInDir2(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta2(join30(dir, entry.name));
+      const meta = parseHistorianDumpMeta2(join31(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -37554,9 +38168,9 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const loaded = loadPiConfig({ cwd });
   const storageResolution = getMagicContextStorageResolution();
   const storageDirPath = storageResolution.path;
-  const dbPath = join30(storageDirPath, "context.db");
-  const logPath = getMagicContextLogPath2("pi");
-  const logFileSize = existsSync32(logPath) ? statSync15(logPath).size : 0;
+  const dbPath = join31(storageDirPath, "context.db");
+  const logFiles = inspectMagicContextLogs("pi");
+  const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
   const recentSessions = collectPiRecentSessions();
   const historianDumps = collectPiHistorianDumps(recentSessions);
@@ -37571,7 +38185,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync32(settingsPath),
+      exists: existsSync33(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -37588,7 +38202,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync32(storageDirPath),
+      exists: existsSync33(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -37596,10 +38210,11 @@ async function collectDiagnostics2(cwd = process.cwd()) {
       otherPiExtensions: otherPiExtensions.map(sanitizeString2)
     },
     logFile: {
-      path: logPath,
-      exists: existsSync32(logPath),
-      sizeKb: Math.round(logFileSize / 1024)
+      path: primaryLog.path,
+      exists: primaryLog.exists,
+      sizeKb: primaryLog.sizeKb
     },
+    logFiles,
     recentSessions,
     historianDumps
   };
@@ -37672,28 +38287,27 @@ function renderDiagnosticsMarkdown2(report) {
     JSON.stringify(report.conflicts, null, 2),
     "```",
     "",
-    "### Log file",
-    `- Path: ${sanitizeString2(report.logFile.path)}`,
-    `- Exists: ${report.logFile.exists}`,
-    `- Size: ${report.logFile.sizeKb} KB`
+    "### Log files",
+    ...(report.logFiles ?? [report.logFile]).map((file) => `- ${sanitizeString2(file.path)}: exists=${file.exists}, grammar=${"grammar" in file ? file.grammar : "unknown"}, lines=${"lineCount" in file ? file.lineCount : 0}, size=${file.sizeKb} KB`)
   ].join(`
 `);
 }
-var import_comment_json13;
+var import_comment_json12;
 var init_diagnostics_pi = __esm(() => {
   init_migrate_config_location();
   init_compartment_parser();
   init_data_path();
   init_config2();
+  init_log_lines();
   init_paths();
   init_pi_helpers();
   init_redaction2();
-  import_comment_json13 = __toESM(require_src3(), 1);
+  import_comment_json12 = __toESM(require_src3(), 1);
 });
 
 // src/lib/logs-pi.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join31 } from "node:path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname18, join as join32 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -37712,9 +38326,12 @@ function formatTimestamp2(date) {
 function filterLogLinesBySession2(lines, sessionId) {
   if (!sessionId)
     return lines;
-  const otherSessionPattern = /\bses_[A-Za-z0-9]{8,32}\b/g;
+  const otherSessionPattern = /\bses_[A-Za-z0-9]{3,64}\b/g;
   return lines.filter((line) => {
-    const matches = line.match(otherSessionPattern);
+    const parsed = parseLogLine(line);
+    if (parsed?.session && parsed.session !== sessionId)
+      return false;
+    const matches = parsed?.message.match(otherSessionPattern) ?? line.match(otherSessionPattern);
     if (!matches)
       return true;
     return matches.every((id) => id === sessionId);
@@ -37722,7 +38339,7 @@ function filterLogLinesBySession2(lines, sessionId) {
 }
 async function bundleIssueReport2(report, description, title, options = {}) {
   const LOG_TAIL_LINES = 400;
-  const allLogLines = report.logFile.exists ? readFileSync24(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const allLogLines = readLogLines(report.logFiles ?? [report.logFile]);
   const logLines = filterLogLinesBySession2(allLogLines, options.sessionFilter ?? null);
   const recentLog = sanitizeLogContent2(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
@@ -37760,10 +38377,11 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const cwd = options.cwd ?? process.cwd();
   const timestamp = formatTimestamp2(options.now ?? new Date);
-  const path = join31(cwd, `magic-context-pi-issue-${timestamp}.md`);
+  const path = options.outputPath ?? join32(cwd, `magic-context-pi-issue-${timestamp}.md`);
+  mkdirSync10(dirname18(path), { recursive: true });
   writeFileSync9(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? join31(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join32(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
     writeFileSync9(fullPath, `${rawBodyMarkdown}
 `);
@@ -37772,14 +38390,15 @@ async function bundleIssueReport2(report, description, title, options = {}) {
 var init_logs_pi = __esm(() => {
   init_diagnostics_pi();
   init_issue_body();
+  init_log_lines();
 });
 
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync6, spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync10, readdirSync as readdirSync6, readFileSync as readFileSync25, rmSync as rmSync4, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync11, readdirSync as readdirSync6, readFileSync as readFileSync24, rmSync as rmSync4, statSync as statSync16 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname18, isAbsolute as isAbsolute6, join as join32 } from "node:path";
+import { dirname as dirname19, isAbsolute as isAbsolute6, join as join33 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS5,
@@ -37796,6 +38415,7 @@ function printDoctorHelp() {
   console.log("    magic-context-pi doctor          Run health checks");
   console.log("    magic-context-pi doctor --force  Repair safe issues, then re-check");
   console.log("    magic-context-pi doctor --issue  Create a sanitized bug report");
+  console.log("    magic-context-pi doctor --issue --report <path>  Write a report without prompting");
   console.log("    magic-context-pi doctor --check-v22-backfill  Show v22 memory backfill status");
   console.log("    magic-context-pi doctor --retry-v22-backfill  Retry failed v22 memory backfill rows");
   console.log("    magic-context-pi doctor --rekey-v22-dir-identity <path>  Re-key legacy dir identity rows");
@@ -37869,7 +38489,7 @@ function summarize(results) {
 function readJsonc2(path) {
   try {
     return {
-      value: import_comment_json14.parse(readFileSync25(path, "utf-8"))
+      value: import_comment_json13.parse(readFileSync24(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -37883,7 +38503,18 @@ function readMagicContextJsonc(path, tier) {
     const raw = loadRawConfigFile({ configPath: path, tier });
     if (!raw)
       return { value: {}, error: "config file disappeared while doctor was reading it" };
-    return { value: import_comment_json14.parse(raw.text) };
+    const substituted = substituteConfigVariables({
+      text: raw.text,
+      configPath: path,
+      isProjectConfig: tier === "project"
+    });
+    const parsed = parseJsoncRecovering(substituted.text);
+    const value = parsed.value && typeof parsed.value === "object" && !Array.isArray(parsed.value) ? parsed.value : {};
+    const issue = parsed.issues[0];
+    return issue ? {
+      value,
+      error: `${path}:${issue.line}:${issue.column}: ${issue.message} (runtime recovery does not make the file valid)`
+    } : { value };
   } catch (error) {
     return {
       value: {},
@@ -37901,18 +38532,18 @@ function piPluginDirCandidates(packages, cwd) {
     const spec = typeof entry === "string" ? entry.trim() : "";
     if (!spec || spec.startsWith("npm:"))
       continue;
-    const resolved = isAbsolute6(spec) ? spec : join32(agentDir, spec);
+    const resolved = isAbsolute6(spec) ? spec : join33(agentDir, spec);
     dirs.push(resolved);
   }
-  dirs.push(join32(agentDir, "npm", "node_modules", PACKAGE_NAME2));
-  dirs.push(join32(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
-  return dirs.filter((dir) => existsSync33(join32(dir, "package.json")));
+  dirs.push(join33(agentDir, "npm", "node_modules", PACKAGE_NAME2));
+  dirs.push(join33(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
+  return dirs.filter((dir) => existsSync34(join33(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path, isProjectConfig) {
-  if (!existsSync33(path))
+  if (!existsSync34(path))
     return null;
   try {
     const raw = loadRawConfigFile({
@@ -37927,7 +38558,7 @@ function readConfigForEmbedding(path, isProjectConfig) {
       isProjectConfig
     });
     const rejectedKeyPaths = [];
-    const parsed = sanitizeParsedJson(import_comment_json14.parse(substituted.text), {
+    const parsed = sanitizeParsedJson(import_comment_json13.parse(substituted.text), {
       onRejectedKey: (keyPath) => rejectedKeyPaths.push(keyPath.join("."))
     });
     if (rejectedKeyPaths.length > 0) {
@@ -37998,22 +38629,22 @@ function pinnedVersionFromPackageSpecifier(specifier) {
 }
 function cacheRoots(cwd) {
   const home = process.env.HOME?.trim();
-  const cacheHome = process.env.XDG_CACHE_HOME || join32(home || homedir18(), ".cache");
+  const cacheHome = process.env.XDG_CACHE_HOME || join33(home || homedir18(), ".cache");
   const piCacheRoot = getPiCacheRoot();
   return [
-    join32(piCacheRoot, "extensions"),
-    join32(piCacheRoot, "packages"),
-    join32(cacheHome, "pi", "extensions"),
-    join32(cacheHome, "pi", "packages"),
-    join32(getPiAgentConfigDir(), "cache", "extensions"),
-    join32(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
-    join32(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
+    join33(piCacheRoot, "extensions"),
+    join33(piCacheRoot, "packages"),
+    join33(cacheHome, "pi", "extensions"),
+    join33(cacheHome, "pi", "packages"),
+    join33(getPiAgentConfigDir(), "cache", "extensions"),
+    join33(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
+    join33(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
   ];
 }
 function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
   const found = new Map;
   const visit = (path, depth) => {
-    if (depth < 0 || !existsSync33(path))
+    if (depth < 0 || !existsSync34(path))
       return;
     let stat;
     try {
@@ -38023,10 +38654,10 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join32(path, "package.json");
-    if (existsSync33(packageJson)) {
+    const packageJson = join33(path, "package.json");
+    if (existsSync34(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync25(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync24(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
         const version = typeof pkg.version === "string" ? pkg.version : undefined;
         if (name === PACKAGE_NAME2) {
@@ -38046,7 +38677,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
       return;
     }
     for (const entry of entries)
-      visit(join32(path, entry), depth - 1);
+      visit(join33(path, entry), depth - 1);
   };
   for (const root of cacheRoots(cwd))
     visit(root, 5);
@@ -38091,7 +38722,7 @@ async function runHealthChecks2(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync33(settingsPath)) {
+  if (!existsSync34(settingsPath)) {
     add2(results, "fail", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -38115,7 +38746,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync33(path)) {
+    if (!existsSync34(path)) {
       if (required) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path}`);
         if (userConfigMigrationRefused) {
@@ -38155,9 +38786,9 @@ async function runHealthChecks2(options) {
   }
   const storage = getMagicContextStorageResolution();
   const storageDir = storage.path;
-  const dbPath = join32(storageDir, "context.db");
+  const dbPath = join33(storageDir, "context.db");
   add2(results, "info", `Shared storage: ${storageDir} (source: ${storage.source})`);
-  const existedBeforeOpen = existsSync33(dbPath);
+  const existedBeforeOpen = existsSync34(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -38303,16 +38934,16 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   } else {
     add2(results, "pass", "Pi extension cache clean (no stale cached package found)");
   }
-  const logPath = getMagicContextLogPath2("pi");
-  if (existsSync33(logPath)) {
-    const stat = statSync16(logPath);
-    const sizeKb = (stat.size / 1024).toFixed(0);
-    const lines = readFileSync25(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    add2(results, "info", `Log file: ${logPath} (${sizeKb} KB)`);
-    const lastLine = lines.at(-1);
-    add2(results, "info", `Last plugin log line: ${lastLine ? sanitizeDiagnosticText(lastLine) : "<empty log>"}`);
+  const logFiles = inspectMagicContextLogs("pi");
+  const existingLogFiles = logFiles.filter((file) => file.exists);
+  if (existingLogFiles.length === 0) {
+    add2(results, "info", `No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
   } else {
-    add2(results, "info", `No plugin log file yet at ${logPath}`);
+    for (const file of existingLogFiles) {
+      add2(results, "info", `Log file read: ${formatLogFileInspection(file)}`);
+    }
+    const lastLine = readLogLines(existingLogFiles).at(-1);
+    add2(results, "info", `Last plugin log line: ${lastLine ? sanitizeDiagnosticText(lastLine) : "<empty log>"}`);
   }
   const diagnosticsForDumps = await collectDiagnostics2(options.cwd);
   const dumpBuckets = diagnosticsForDumps.historianDumps.byProject;
@@ -38342,12 +38973,12 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   return { results, repairPlan, ...summarize(results) };
 }
 function writeDefaultMagicContextConfig(path) {
-  mkdirSync10(dirname18(path), { recursive: true });
+  mkdirSync11(dirname19(path), { recursive: true });
   const config = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
   };
-  writeFileAtomic(path, `${import_comment_json14.stringify(config, null, 2)}
+  writeFileAtomic(path, `${import_comment_json13.stringify(config, null, 2)}
 `);
 }
 function repair2(plan, prompts) {
@@ -38364,7 +38995,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync33(configPath)) {
+    if (!existsSync34(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -38413,6 +39044,18 @@ function runGhCommandWithDeps2(deps, args) {
   }
 }
 async function runIssueFlow3(options) {
+  if (options.reportPath) {
+    try {
+      const report = await options.deps.collectDiagnostics(options.cwd);
+      const outputPath = isAbsolute6(options.reportPath) ? options.reportPath : join33(options.cwd, options.reportPath);
+      const bundled = await bundleIssueReport2(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", { cwd: options.cwd, now: options.deps.now(), outputPath });
+      options.prompts.log.info(`Report written to ${bundled.path}`);
+      return 0;
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+  }
   options.prompts.intro("Magic Context for Pi Issue Report");
   const title = await options.prompts.text("Issue title", {
     placeholder: "Short summary of the Pi problem",
@@ -38482,13 +39125,13 @@ async function runDoctor3(options = {}) {
   }
   const configMigrationWarnings = migrateConfigLocationsForCli(cwd, prompts.log);
   if (options.issue) {
-    return runIssueFlow3({ cwd, prompts, deps });
+    return runIssueFlow3({ cwd, prompts, deps, reportPath: options.report });
   }
   let v22Db = null;
   const v22Result = await runV22BackfillCommands({
     name: "Pi",
     openDatabase: (readonly = true) => {
-      const dbPath = join32(getMagicContextStorageDir(), "context.db");
+      const dbPath = join33(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -38541,9 +39184,11 @@ function valueAfter3(args, flag) {
 }
 function parseDoctorArgs(args) {
   const rekeyV22DirIdentity = valueAfter3(args, "--rekey-v22-dir-identity");
+  const report = valueAfter3(args, "--report");
   return {
     force: args.includes("--force"),
-    issue: args.includes("--issue"),
+    issue: args.includes("--issue") || report !== null,
+    ...report !== null ? { report } : {},
     help: args.includes("--help") || args.includes("-h"),
     checkV22Backfill: args.includes("--check-v22-backfill"),
     retryV22Backfill: args.includes("--retry-v22-backfill"),
@@ -38553,7 +39198,7 @@ function parseDoctorArgs(args) {
 function doctor(args = []) {
   return runDoctor3(parseDoctorArgs(args));
 }
-var import_comment_json14, PACKAGE_NAME2 = "@cortexkit/pi-magic-context", MIN_PI_VERSION = "0.74.0", ROW_COUNT_TABLES2, DEFAULT_DEPS5;
+var import_comment_json13, PACKAGE_NAME2 = "@cortexkit/pi-magic-context", MIN_PI_VERSION = "0.74.0", ROW_COUNT_TABLES2, DEFAULT_DEPS5;
 var init_doctor_pi = __esm(async () => {
   init_migrate_config_location();
   init_project_security();
@@ -38568,6 +39213,7 @@ var init_doctor_pi = __esm(async () => {
   init_diagnostics_pi();
   init_embedding_runtime();
   init_github_issue();
+  init_log_lines();
   init_logs_pi();
   init_paths();
   init_pi_helpers();
@@ -38580,7 +39226,7 @@ var init_doctor_pi = __esm(async () => {
     init_storage_versions(),
     init_v22_backfill_commands()
   ]);
-  import_comment_json14 = __toESM(require_src3(), 1);
+  import_comment_json13 = __toESM(require_src3(), 1);
   ROW_COUNT_TABLES2 = ["tags", "compartments", "memories", "notes", "dream_runs"];
   DEFAULT_DEPS5 = {
     prompts: promptIO,
@@ -38598,8 +39244,8 @@ var init_doctor_pi = __esm(async () => {
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync34, rmSync as rmSync5 } from "node:fs";
-import { join as join33 } from "node:path";
+import { existsSync as existsSync35, rmSync as rmSync5 } from "node:fs";
+import { join as join34 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
     return runClear();
@@ -38617,7 +39263,7 @@ async function runDoctor4(options) {
     const result = await runV22BackfillCommands({
       name: "Magic Context",
       openDatabase: (readonly = true) => {
-        const dbPath = join33(getMagicContextStorageDir(), "context.db");
+        const dbPath = join34(getMagicContextStorageDir(), "context.db");
         v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
         return v22Db;
       },
@@ -38631,7 +39277,7 @@ async function runDoctor4(options) {
       return result.exitCode;
   }
   await init_migrate();
-  const sweepDbPath = join33(getMagicContextStorageDir(), "context.db");
+  const sweepDbPath = join34(getMagicContextStorageDir(), "context.db");
   let sweepDb = null;
   try {
     sweepDb = openExistingContextDatabaseForMutation(sweepDbPath);
@@ -38674,6 +39320,8 @@ async function dispatchDoctor(adapter, options) {
         piArgs.push("--force");
       if (options.issue)
         piArgs.push("--issue");
+      if (options.report)
+        piArgs.push("--report", options.report);
       return doctor(piArgs);
     }
     case "omp":
@@ -38727,7 +39375,7 @@ async function runClear() {
     const s = spinner2();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync34(item.path)) {
+      if (existsSync35(item.path)) {
         rmSync5(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
@@ -38823,6 +39471,7 @@ function printUsage() {
   console.log("    doctor           Check and fix configuration issues");
   console.log("    doctor --force   Force-clear plugin cache");
   console.log("    doctor --issue   Collect diagnostics and open a GitHub issue");
+  console.log("    doctor --issue --report <path>  Write diagnostics without prompting");
   console.log("    doctor --clear   Interactive cache cleanup picker");
   console.log("    doctor --check-v22-backfill       Show v22 memory backfill status");
   console.log("    doctor --retry-v22-backfill       Retry failed v22 memory backfill rows");
@@ -38898,9 +39547,11 @@ async function main(argv = process.argv.slice(2)) {
       }
       await init_doctor();
       const rekeyV22DirIdentity = valueAfter4(rest, "--rekey-v22-dir-identity");
+      const report = valueAfter4(rest, "--report");
       return runDoctor4({
         force: rest.includes("--force"),
-        issue: rest.includes("--issue"),
+        issue: rest.includes("--issue") || report !== null,
+        ...report !== null ? { report } : {},
         clear: rest.includes("--clear"),
         checkV22Backfill: rest.includes("--check-v22-backfill"),
         retryV22Backfill: rest.includes("--retry-v22-backfill"),