@cortexkit/pi-magic-context 0.16.2 → 0.17.0

package/dist/index.js

@@ -15043,14 +15043,334 @@ var init_embedding = __esm(() => {
   SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
 });
 
+// ../../node_modules/.bun/nanotar@0.3.0/node_modules/nanotar/dist/index.mjs
+function parseTar(data, opts) {
+  const buffer2 = data.buffer || data;
+  const files = [];
+  let offset = 0;
+  let nextExtendedHeader;
+  let globalExtendedHeader;
+  while (offset < buffer2.byteLength - 512) {
+    let name = _readString(buffer2, offset, 100);
+    if (name.length === 0) {
+      break;
+    }
+    if (nextExtendedHeader) {
+      const longName = nextExtendedHeader.path || nextExtendedHeader.linkpath;
+      if (longName) {
+        name = longName;
+      }
+    }
+    const mode = _readString(buffer2, offset + 100, 8).trim();
+    const uid = Number.parseInt(_readString(buffer2, offset + 108, 8));
+    const gid = Number.parseInt(_readString(buffer2, offset + 116, 8));
+    const size = _readNumber(buffer2, offset + 124, 12);
+    const seek = 512 + 512 * Math.trunc(size / 512) + (size % 512 ? 512 : 0);
+    const mtime = _readNumber(buffer2, offset + 136, 12);
+    const _type = _readString(buffer2, offset + 156, 1) || "0";
+    const type = tarItemTypeMap[_type] || _type;
+    switch (type) {
+      case "extendedHeader":
+      case "globalExtendedHeader": {
+        const headers = _parseExtendedHeaders(new Uint8Array(buffer2, offset + 512, size));
+        if (type === "extendedHeader") {
+          nextExtendedHeader = headers;
+        } else {
+          nextExtendedHeader = undefined;
+          globalExtendedHeader = {
+            ...globalExtendedHeader,
+            ...headers
+          };
+        }
+        offset += seek;
+        continue;
+      }
+      case "gnuLongFileName":
+      case "gnuOldLongFileName":
+      case "gnuLongLinkName": {
+        nextExtendedHeader = { path: _readString(buffer2, offset + 512, size) };
+        offset += seek;
+        continue;
+      }
+    }
+    const user = _readString(buffer2, offset + 265, 32);
+    const group = _readString(buffer2, offset + 297, 32);
+    name = _sanitizePath(name);
+    const meta3 = {
+      name,
+      type,
+      size,
+      attrs: {
+        ...globalExtendedHeader,
+        ...nextExtendedHeader,
+        mode,
+        uid,
+        gid,
+        mtime,
+        user,
+        group
+      }
+    };
+    nextExtendedHeader = undefined;
+    if (opts?.filter && !opts.filter(meta3)) {
+      offset += seek;
+      continue;
+    }
+    if (opts?.metaOnly) {
+      files.push(meta3);
+      offset += seek;
+      continue;
+    }
+    const data2 = size === 0 ? undefined : new Uint8Array(buffer2, offset + 512, size);
+    files.push({
+      ...meta3,
+      data: data2,
+      get text() {
+        return new TextDecoder().decode(this.data);
+      }
+    });
+    offset += seek;
+  }
+  return files;
+}
+async function parseTarGzip(data, opts = {}) {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array(data));
+      controller.close();
+    }
+  }).pipeThrough(new DecompressionStream(opts.compression ?? "gzip"));
+  const decompressedData = await new Response(stream).arrayBuffer();
+  return parseTar(decompressedData, opts);
+}
+function _sanitizePath(path4) {
+  let normalized = path4.replace(/\\/g, "/");
+  normalized = normalized.replace(/^[a-zA-Z]:\//, "");
+  normalized = normalized.replace(/^\/+/, "");
+  const hasLeadingDotSlash = normalized.startsWith("./");
+  const parts = normalized.split("/");
+  const resolved = [];
+  for (const part of parts) {
+    if (part === "..") {
+      resolved.pop();
+    } else if (part !== "." && part !== "") {
+      resolved.push(part);
+    }
+  }
+  let result = resolved.join("/");
+  if (hasLeadingDotSlash && !result.startsWith("./")) {
+    result = "./" + result;
+  }
+  if (path4.endsWith("/") && !result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function _readString(buffer2, offset, size) {
+  const view = new Uint8Array(buffer2, offset, size);
+  const i = view.indexOf(0);
+  const td = new TextDecoder;
+  return td.decode(i === -1 ? view : view.slice(0, i));
+}
+function _readNumber(buffer2, offset, size) {
+  const view = new Uint8Array(buffer2, offset, size);
+  let str = "";
+  for (let i = 0;i < size; i++) {
+    str += String.fromCodePoint(view[i]);
+  }
+  return Number.parseInt(str, 8);
+}
+function _parseExtendedHeaders(data) {
+  const dataStr = new TextDecoder().decode(data);
+  const headers = {};
+  for (const line of dataStr.split(`
+`)) {
+    const s = line.split(" ")[1]?.split("=");
+    if (s) {
+      headers[s[0]] = s[1];
+    }
+  }
+  return headers;
+}
+var tarItemTypeMap;
+var init_dist = __esm(() => {
+  tarItemTypeMap = {
+    "0": "file",
+    "1": "hardLink",
+    "2": "symbolicLink",
+    "3": "characterDevice",
+    "4": "blockDevice",
+    "5": "directory",
+    "6": "fifo",
+    "7": "contiguousFile",
+    g: "globalExtendedHeader",
+    x: "extendedHeader",
+    D: "gnuDirectory",
+    I: "gnuInodeMetadata",
+    K: "gnuLongLinkName",
+    L: "gnuLongFileName",
+    N: "gnuOldLongFileName",
+    M: "gnuMultiVolume",
+    S: "gnuSparseFile",
+    E: "gnuExtendedSparse",
+    A: "solarisAcl",
+    V: "solarisVolumeLabel",
+    X: "solarisOldExtendedHeader"
+  };
+});
+
+// ../plugin/src/shared/native-binding.ts
+var exports_native_binding = {};
+__export(exports_native_binding, {
+  resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
+});
+import { existsSync, mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import * as path4 from "node:path";
+function logInfo(message) {
+  log(`${PREFIX} ${message}`);
+}
+function logWarn(message) {
+  log(`${PREFIX} WARN ${message}`);
+}
+function probeAbi(binaryPath) {
+  const expected = process.versions.modules;
+  try {
+    const sandbox = { exports: {} };
+    process.dlopen(sandbox, binaryPath);
+    return { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const pair = message.match(/NODE_MODULE_VERSION (\d+).*NODE_MODULE_VERSION (\d+)/s);
+    if (pair?.[1] && pair[2]) {
+      return { ok: false, expected: pair[2], actual: pair[1] };
+    }
+    const single = message.match(/NODE_MODULE_VERSION[ =:]+(\d+)/);
+    if (single?.[1]) {
+      return { ok: false, expected, actual: single[1] };
+    }
+    logWarn(`could not parse ABI from dlopen error: ${message}`);
+    return { ok: false, expected, actual: null };
+  }
+}
+function resolveBetterSqlite3OnDisk(requireFn) {
+  try {
+    const pkgJsonPath = requireFn.resolve("better-sqlite3/package.json");
+    const pkgDir = path4.dirname(pkgJsonPath);
+    const pkgJson = requireFn(pkgJsonPath);
+    const binaryPath = path4.join(pkgDir, "build", "Release", "better_sqlite3.node");
+    return { binaryPath, pkgVersion: pkgJson.version };
+  } catch (err) {
+    logWarn(`could not resolve better-sqlite3 in node_modules: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function getCachedBinaryPath(pkgVersion, abi) {
+  return path4.join(getCacheDir(), "cortexkit", "native-bindings", "better-sqlite3", `v${pkgVersion}`, `electron-v${abi}-${process.platform}-${process.arch}`, "better_sqlite3.node");
+}
+async function downloadElectronPrebuild(pkgVersion, abi) {
+  const filename = `better-sqlite3-v${pkgVersion}-electron-v${abi}-${process.platform}-${process.arch}.tar.gz`;
+  const url2 = `https://github.com/WiseLibs/better-sqlite3/releases/download/v${pkgVersion}/${filename}`;
+  logInfo(`downloading ${url2}`);
+  const response = await fetch(url2, {
+    redirect: "follow",
+    headers: { "User-Agent": "magic-context-plugin/native-binding" }
+  });
+  if (!response.ok) {
+    throw new Error(`failed to download Electron prebuild (HTTP ${response.status} ${response.statusText}) from ${url2}`);
+  }
+  const tarballBytes = new Uint8Array(await response.arrayBuffer());
+  logInfo(`downloaded ${(tarballBytes.length / 1024).toFixed(1)} KB; extracting`);
+  const files = await parseTarGzip(tarballBytes);
+  const nodeFile = files.find((f) => f.name.endsWith("better_sqlite3.node"));
+  if (!nodeFile?.data) {
+    const names = files.map((f) => f.name).join(", ");
+    throw new Error(`Electron prebuild tarball did not contain better_sqlite3.node; got: [${names}]`);
+  }
+  return nodeFile.data instanceof Uint8Array ? nodeFile.data : new Uint8Array(nodeFile.data);
+}
+async function resolveBetterSqliteNativeBinding() {
+  if (!process.versions.electron) {
+    return null;
+  }
+  if (inFlight) {
+    return inFlight;
+  }
+  const promise2 = (async () => {
+    const expected = process.versions.modules;
+    logInfo(`Electron detected (v${process.versions.electron}, NODE_MODULE_VERSION ${expected}); verifying better-sqlite3 binding`);
+    const requireFn = createRequire(import.meta.url);
+    const resolved = resolveBetterSqlite3OnDisk(requireFn);
+    if (!resolved) {
+      return null;
+    }
+    const { binaryPath: diskPath, pkgVersion } = resolved;
+    if (existsSync(diskPath)) {
+      const diskProbe = probeAbi(diskPath);
+      if (diskProbe.ok) {
+        logInfo(`on-disk binary already matches Electron ABI v${expected}; using default bindings() lookup`);
+        return null;
+      }
+      logInfo(`on-disk binary ABI ${diskProbe.actual ?? "unknown"} != required ${expected}; will use Electron prebuild`);
+    } else {
+      logWarn(`expected better-sqlite3 binary not found at ${diskPath}; will fetch Electron prebuild anyway`);
+    }
+    const cachedPath = getCachedBinaryPath(pkgVersion, expected);
+    if (existsSync(cachedPath)) {
+      const cachedProbe = probeAbi(cachedPath);
+      if (cachedProbe.ok) {
+        logInfo(`using cached Electron prebuild at ${cachedPath}`);
+        return cachedPath;
+      }
+      logWarn(`cached binary at ${cachedPath} has wrong ABI (${cachedProbe.actual ?? "unknown"} != ${expected}); refetching`);
+    }
+    mkdirSync2(path4.dirname(cachedPath), { recursive: true });
+    const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
+    writeFileSync(cachedPath, nodeFileBytes);
+    logInfo(`cached Electron prebuild at ${cachedPath} (${(nodeFileBytes.length / 1024).toFixed(1)} KB)`);
+    const finalProbe = probeAbi(cachedPath);
+    if (!finalProbe.ok) {
+      throw new Error(`downloaded Electron prebuild has wrong ABI (${finalProbe.actual ?? "unknown"} != ${expected}); refusing to use`);
+    }
+    return cachedPath;
+  })();
+  inFlight = promise2;
+  try {
+    return await promise2;
+  } finally {
+    if (inFlight === promise2) {
+      inFlight = null;
+    }
+  }
+}
+var PREFIX = "[native-binding]", inFlight = null;
+var init_native_binding = __esm(() => {
+  init_dist();
+  init_data_path();
+  init_logger();
+});
+
 // ../plugin/src/shared/sqlite.ts
-var isBun, bunSpec, betterSpec, sqliteModule, DatabaseImpl, Database;
+var isBun, bunSpec, betterSpec, electronNativeBinding, sqliteModule, RawDatabaseImpl, DatabaseImpl, Database;
 var init_sqlite = __esm(async () => {
   isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
   bunSpec = "bun:" + "sqlite";
   betterSpec = "better-" + "sqlite3";
+  electronNativeBinding = isBun ? null : await (async () => {
+    const mod = await Promise.resolve().then(() => (init_native_binding(), exports_native_binding));
+    return mod.resolveBetterSqliteNativeBinding();
+  })();
   sqliteModule = isBun ? await import(bunSpec) : await import(betterSpec);
-  DatabaseImpl = isBun ? sqliteModule.Database : sqliteModule.default;
+  RawDatabaseImpl = isBun ? sqliteModule.Database : sqliteModule.default;
+  DatabaseImpl = electronNativeBinding == null ? RawDatabaseImpl : class DatabaseWithElectronBinding extends RawDatabaseImpl {
+    constructor(filename, options) {
+      const fallback = electronNativeBinding;
+      super(filename, {
+        ...options,
+        nativeBinding: options?.nativeBinding ?? fallback
+      });
+    }
+  };
   Database = DatabaseImpl;
 });
 
@@ -15072,9 +15392,9 @@ __export(exports_read_session_db, {
   findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
   closeReadOnlySessionDb: () => closeReadOnlySessionDb
 });
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function getOpenCodeDbPath() {
-  return join4(getDataDir(), "opencode", "opencode.db");
+  return join5(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -15133,7 +15453,8 @@ function findLastAssistantModelFromOpenCodeDb(sessionId) {
   try {
     return withReadOnlySessionDb((db) => {
       const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
-                            json_extract(data, '$.modelID') as modelID
+                            json_extract(data, '$.modelID') as modelID,
+                            json_extract(data, '$.agent') as agent
                      FROM message
                      WHERE session_id = ?
                        AND json_extract(data, '$.role') = 'assistant'
@@ -15144,7 +15465,12 @@ function findLastAssistantModelFromOpenCodeDb(sessionId) {
       if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
         return null;
       }
-      return { providerID: row.providerID, modelID: row.modelID };
+      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
+      return {
+        providerID: row.providerID,
+        modelID: row.modelID,
+        ...agent ? { agent } : {}
+      };
     });
   } catch (error48) {
     log("[magic-context] failed to recover live model from OpenCode DB:", error48);
@@ -22792,10 +23118,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join11 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join13 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join11(comment, inside, gap);
+    return join13(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -22817,13 +23143,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join11(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join13(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join11(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -22844,13 +23170,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join11(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join13(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join11(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -22944,8 +23270,8 @@ var require_src2 = __commonJS((exports, module) => {
 
 // src/index.ts
 init_embedding();
-import { createRequire } from "node:module";
-import { join as join13 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import { join as join15 } from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
@@ -22985,422 +23311,9 @@ function resolveProjectIdentity(directory) {
   return identity;
 }
 
-// ../plugin/src/features/magic-context/overflow-detection.ts
-var OVERFLOW_PATTERNS = [
-  /prompt is too long/i,
-  /input is too long for requested model/i,
-  /exceeds the context window/i,
-  /input token count.*exceeds the maximum/i,
-  /maximum prompt length is \d+/i,
-  /reduce the length of the messages/i,
-  /maximum context length is \d+ tokens/i,
-  /exceeds the limit of \d+/i,
-  /exceeds the available context size/i,
-  /greater than the context length/i,
-  /context window exceeds limit/i,
-  /exceeded model token limit/i,
-  /context[_ ]length[_ ]exceeded/i,
-  /request entity too large/i,
-  /context length is only \d+ tokens/i,
-  /input length.*exceeds.*context length/i,
-  /prompt too long; exceeded (?:max )?context length/i,
-  /too large for model with \d+ maximum context length/i,
-  /model_context_window_exceeded/i,
-  /context size has been exceeded/i
-];
-var LIMIT_EXTRACTION_PATTERNS = [
-  /maximum prompt length is (\d+)/i,
-  /maximum context length is (\d+) tokens?/i,
-  /context length is only (\d+) tokens?/i,
-  /exceeds the limit of (\d+)/i,
-  /too large for model with (\d+) maximum context length/i,
-  /context size.*(\d+) tokens?/i,
-  /exceeds? the context length of (\d+)/i,
-  /max(?:imum)?.*context.*?(\d+)/i
-];
-var MIN_PLAUSIBLE_LIMIT = 1024;
-var MAX_PLAUSIBLE_LIMIT = 1e7;
-function extractErrorMessage(error48) {
-  if (!error48)
-    return "";
-  if (typeof error48 === "string")
-    return error48;
-  if (typeof error48 === "object") {
-    const obj = error48;
-    const nested = obj.error;
-    if (nested && typeof nested.message === "string" && nested.message.length > 0) {
-      return nested.message;
-    }
-  }
-  if (error48 instanceof Error)
-    return error48.message;
-  if (typeof error48 === "object") {
-    const obj = error48;
-    if (typeof obj.message === "string")
-      return obj.message;
-    if (typeof obj.responseBody === "string")
-      return obj.responseBody;
-    try {
-      return JSON.stringify(error48);
-    } catch {
-      return String(error48);
-    }
-  }
-  return String(error48);
-}
-function detectOverflow(error48) {
-  const message = extractErrorMessage(error48);
-  if (!message) {
-    return { isOverflow: false };
-  }
-  const hasStatus413 = /\b413\b/.test(message) && /(entity|payload|context|prompt)/i.test(message);
-  let matched;
-  for (const pattern of OVERFLOW_PATTERNS) {
-    if (pattern.test(message)) {
-      matched = pattern;
-      break;
-    }
-  }
-  if (!matched && !hasStatus413) {
-    return { isOverflow: false };
-  }
-  const reportedLimit = parseReportedLimit(message);
-  return {
-    isOverflow: true,
-    reportedLimit,
-    matchedPattern: matched?.source
-  };
-}
-function parseReportedLimit(message) {
-  if (!message)
-    return;
-  for (const pattern of LIMIT_EXTRACTION_PATTERNS) {
-    const match = message.match(pattern);
-    if (!match)
-      continue;
-    const raw = match[1];
-    if (!raw)
-      continue;
-    const value = Number.parseInt(raw, 10);
-    if (!Number.isFinite(value))
-      continue;
-    if (value < MIN_PLAUSIBLE_LIMIT || value > MAX_PLAUSIBLE_LIMIT)
-      continue;
-    return value;
-  }
-  return;
-}
-
-// ../plugin/src/shared/harness.ts
-var currentHarness = "opencode";
-var harnessLocked = false;
-function setHarness(value) {
-  if (harnessLocked && currentHarness !== value) {
-    throw new Error(`Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`);
-  }
-  currentHarness = value;
-  harnessLocked = true;
-}
-function getHarness() {
-  return currentHarness;
-}
+// ../plugin/src/features/magic-context/message-index-async.ts
+init_logger();
 
-// ../plugin/src/features/magic-context/compartment-storage.ts
-var insertCompartmentStatements = new WeakMap;
-var insertFactStatements = new WeakMap;
-function getInsertCompartmentStatement(db) {
-  let stmt = insertCompartmentStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, created_at, harness) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    insertCompartmentStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getInsertFactStatement(db) {
-  let stmt = insertFactStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO session_facts (session_id, category, content, created_at, updated_at, harness) VALUES (?, ?, ?, ?, ?, ?)");
-    insertFactStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function isCompartmentRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.sequence === "number" && typeof candidate.start_message === "number" && typeof candidate.end_message === "number" && typeof candidate.start_message_id === "string" && typeof candidate.end_message_id === "string" && typeof candidate.title === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number";
-}
-function isSessionFactRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.category === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number" && typeof candidate.updated_at === "number";
-}
-function insertCompartmentRows(db, sessionId, compartments, now) {
-  const stmt = getInsertCompartmentStatement(db);
-  for (const compartment of compartments) {
-    stmt.run(sessionId, compartment.sequence, compartment.startMessage, compartment.endMessage, compartment.startMessageId, compartment.endMessageId, compartment.title, compartment.content, now, getHarness());
-  }
-}
-function insertFactRows(db, sessionId, facts, now) {
-  const stmt = getInsertFactStatement(db);
-  for (const fact of facts) {
-    stmt.run(sessionId, fact.category, fact.content, now, now, getHarness());
-  }
-}
-function toCompartment(row) {
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    sequence: row.sequence,
-    startMessage: row.start_message,
-    endMessage: row.end_message,
-    startMessageId: row.start_message_id,
-    endMessageId: row.end_message_id,
-    title: row.title,
-    content: row.content,
-    createdAt: row.created_at
-  };
-}
-function toSessionFact(row) {
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    category: row.category,
-    content: row.content,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
-function getCompartments(db, sessionId) {
-  const rows = db.prepare("SELECT * FROM compartments WHERE session_id = ? ORDER BY sequence ASC").all(sessionId).filter(isCompartmentRow);
-  return rows.map(toCompartment);
-}
-function getLastCompartmentEndMessage(db, sessionId) {
-  const row = db.prepare("SELECT MAX(end_message) as max_end FROM compartments WHERE session_id = ?").get(sessionId);
-  return row?.max_end ?? -1;
-}
-function appendCompartments(db, sessionId, compartments) {
-  if (compartments.length === 0)
-    return;
-  const now = Date.now();
-  db.transaction(() => {
-    insertCompartmentRows(db, sessionId, compartments, now);
-  })();
-}
-function replaceSessionFacts(db, sessionId, facts) {
-  const now = Date.now();
-  db.transaction(() => {
-    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    insertFactRows(db, sessionId, facts, now);
-    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
-  })();
-}
-function getSessionFacts(db, sessionId) {
-  const rows = db.prepare("SELECT * FROM session_facts WHERE session_id = ? ORDER BY category ASC, id ASC").all(sessionId).filter(isSessionFactRow);
-  return rows.map(toSessionFact);
-}
-function replaceAllCompartmentState(db, sessionId, compartments, facts) {
-  const now = Date.now();
-  db.transaction(() => {
-    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    insertCompartmentRows(db, sessionId, compartments, now);
-    insertFactRows(db, sessionId, facts, now);
-    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
-  })();
-}
-function buildCompartmentBlock(compartments, facts, memoryBlock, dateRanges) {
-  const lines = [];
-  if (memoryBlock) {
-    lines.push(memoryBlock);
-    lines.push("");
-  }
-  for (const c of compartments) {
-    const dates = dateRanges?.byId.get(c.id);
-    const dateAttr = dates ? ` start-date="${dates.start}" end-date="${dates.end}"` : "";
-    lines.push(`<compartment start="${c.startMessage}" end="${c.endMessage}"${dateAttr} title="${escapeXmlAttr(c.title)}">`);
-    lines.push(escapeXmlContent(c.content));
-    lines.push("</compartment>");
-    lines.push("");
-  }
-  const factsByCategory = new Map;
-  for (const f of facts) {
-    const existing = factsByCategory.get(f.category) ?? [];
-    existing.push(f.content);
-    factsByCategory.set(f.category, existing);
-  }
-  for (const [category, items] of factsByCategory) {
-    lines.push(`${category}:`);
-    for (const item of items) {
-      lines.push(`* ${escapeXmlContent(item)}`);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`).trimEnd();
-}
-function saveRecompStagingPass(db, sessionId, passNumber, compartments, facts) {
-  const now = Date.now();
-  db.transaction(() => {
-    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
-    const compartmentStmt = db.prepare("INSERT OR REPLACE INTO recomp_compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, pass_number, created_at, harness) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    for (const c of compartments) {
-      compartmentStmt.run(sessionId, c.sequence, c.startMessage, c.endMessage, c.startMessageId, c.endMessageId, c.title, c.content, passNumber, now, getHarness());
-    }
-    const factStmt = db.prepare("INSERT INTO recomp_facts (session_id, category, content, pass_number, created_at, harness) VALUES (?, ?, ?, ?, ?, ?)");
-    for (const f of facts) {
-      factStmt.run(sessionId, f.category, f.content, passNumber, now, getHarness());
-    }
-  })();
-}
-function getRecompStaging(db, sessionId) {
-  const compartmentRows = db.prepare("SELECT * FROM recomp_compartments WHERE session_id = ? ORDER BY sequence ASC").all(sessionId).filter(isRecompCompartmentRow);
-  if (compartmentRows.length === 0)
-    return null;
-  const compartments = compartmentRows.map((row) => ({
-    sequence: row.sequence,
-    startMessage: row.start_message,
-    endMessage: row.end_message,
-    startMessageId: row.start_message_id,
-    endMessageId: row.end_message_id,
-    title: row.title,
-    content: row.content
-  }));
-  const factRows = db.prepare("SELECT category, content FROM recomp_facts WHERE session_id = ?").all(sessionId).filter(isRecompFactRow);
-  const maxPass = compartmentRows.reduce((m, r) => Math.max(m, r.pass_number), 0);
-  const lastEnd = compartmentRows[compartmentRows.length - 1]?.end_message ?? 0;
-  return {
-    compartments,
-    facts: factRows,
-    passCount: maxPass,
-    lastEndMessage: lastEnd
-  };
-}
-function promoteRecompStaging(db, sessionId) {
-  const now = Date.now();
-  return db.transaction(() => {
-    const staging = getRecompStaging(db, sessionId);
-    if (!staging || staging.compartments.length === 0)
-      return null;
-    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    insertCompartmentRows(db, sessionId, staging.compartments, now);
-    insertFactRows(db, sessionId, staging.facts, now);
-    db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
-    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE session_id = ?").run(sessionId);
-    return { compartments: staging.compartments, facts: staging.facts };
-  })();
-}
-function invalidateAllMemoryBlockCaches(db) {
-  try {
-    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE memory_block_cache != '' OR memory_block_ids != ''").run();
-  } catch {}
-}
-function clearRecompStaging(db, sessionId) {
-  db.transaction(() => {
-    db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
-    try {
-      db.prepare("UPDATE session_meta SET recomp_partial_range_start = 0, recomp_partial_range_end = 0 WHERE session_id = ?").run(sessionId);
-    } catch {}
-  })();
-}
-function getRecompPartialRange(db, sessionId) {
-  try {
-    const row = db.prepare("SELECT recomp_partial_range_start AS start, recomp_partial_range_end AS end FROM session_meta WHERE session_id = ?").get(sessionId);
-    const start = typeof row?.start === "number" ? row.start : 0;
-    const end = typeof row?.end === "number" ? row.end : 0;
-    if (start <= 0 || end <= 0)
-      return null;
-    return { start, end };
-  } catch {
-    return null;
-  }
-}
-function setRecompPartialRange(db, sessionId, range) {
-  const start = range ? range.start : 0;
-  const end = range ? range.end : 0;
-  db.prepare("INSERT OR IGNORE INTO session_meta (session_id) VALUES (?)").run(sessionId);
-  db.prepare("UPDATE session_meta SET recomp_partial_range_start = ?, recomp_partial_range_end = ? WHERE session_id = ?").run(start, end, sessionId);
-}
-function isRecompCompartmentRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.sequence === "number" && typeof candidate.start_message === "number" && typeof candidate.end_message === "number" && typeof candidate.start_message_id === "string" && typeof candidate.end_message_id === "string" && typeof candidate.title === "string" && typeof candidate.content === "string" && typeof candidate.pass_number === "number" && typeof candidate.created_at === "number";
-}
-function isRecompFactRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.category === "string" && typeof candidate.content === "string";
-}
-function escapeXmlAttr(s) {
-  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeXmlContent(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-// ../plugin/src/features/magic-context/compression-depth-storage.ts
-var incrementDepthStatements = new WeakMap;
-var totalDepthStatements = new WeakMap;
-var maxDepthStatements = new WeakMap;
-var clearDepthStatements = new WeakMap;
-function getIncrementDepthStatement(db) {
-  let stmt = incrementDepthStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO compression_depth (session_id, message_ordinal, depth, harness) VALUES (?, ?, 1, ?) ON CONFLICT(session_id, message_ordinal) DO UPDATE SET depth = depth + 1");
-    incrementDepthStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getTotalDepthStatement(db) {
-  let stmt = totalDepthStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT COALESCE(SUM(depth), 0) AS total_depth FROM compression_depth WHERE session_id = ? AND message_ordinal BETWEEN ? AND ?");
-    totalDepthStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getClearDepthStatement(db) {
-  let stmt = clearDepthStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM compression_depth WHERE session_id = ?");
-    clearDepthStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function incrementCompressionDepth(db, sessionId, startOrdinal, endOrdinal) {
-  if (endOrdinal < startOrdinal) {
-    return;
-  }
-  db.transaction(() => {
-    const stmt = getIncrementDepthStatement(db);
-    for (let ordinal = startOrdinal;ordinal <= endOrdinal; ordinal += 1) {
-      stmt.run(sessionId, ordinal, getHarness());
-    }
-  })();
-}
-function getAverageCompressionDepth(db, sessionId, startOrdinal, endOrdinal) {
-  if (endOrdinal < startOrdinal) {
-    return 0;
-  }
-  const row = getTotalDepthStatement(db).get(sessionId, startOrdinal, endOrdinal);
-  const totalDepth = typeof row?.total_depth === "number" ? row.total_depth : 0;
-  const messageCount = endOrdinal - startOrdinal + 1;
-  return totalDepth / messageCount;
-}
-function clearCompressionDepth(db, sessionId) {
-  getClearDepthStatement(db).run(sessionId);
-}
-function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
-  if (endOrdinal < startOrdinal) {
-    return;
-  }
-  db.prepare("DELETE FROM compression_depth WHERE session_id = ? AND message_ordinal BETWEEN ? AND ?").run(sessionId, startOrdinal, endOrdinal);
-}
 // ../plugin/src/shared/internal-initiator-marker.ts
 var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
 
@@ -156078,21 +155991,85 @@ function isTextPart(part) {
   const p = part;
   return p.type === "text" && typeof p.text === "string";
 }
-function isToolPartWithOutput(part) {
+function isFilePart(part) {
   if (part === null || typeof part !== "object")
     return false;
   const p = part;
-  if (p.type !== "tool" || typeof p.callID !== "string")
+  return p.type === "file" && typeof p.url === "string";
+}
+
+// ../plugin/src/shared/record-type-guard.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../plugin/src/hooks/magic-context/tool-drop-target.ts
+var IGNORE_PART_TYPES = new Set([
+  "thinking",
+  "reasoning",
+  "redacted_thinking",
+  "meta",
+  "step-start",
+  "step-finish"
+]);
+function isToolCallId(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function hasMeaningfulPart(part) {
+  if (!isRecord(part))
     return false;
-  if (p.state === null || typeof p.state !== "object")
+  const type = part.type;
+  if (type === "text") {
+    return typeof part.text === "string" && part.text.trim().length > 0;
+  }
+  if (typeof type !== "string")
     return false;
-  return typeof p.state.output === "string";
-}
-function isFilePart(part) {
-  if (part === null || typeof part !== "object")
+  if (IGNORE_PART_TYPES.has(type))
     return false;
-  const p = part;
-  return p.type === "file" && typeof p.url === "string";
+  return true;
+}
+function extractToolCallObservation(part) {
+  if (!isRecord(part))
+    return null;
+  if (part.type === "tool" && isToolCallId(part.callID)) {
+    return { callId: part.callID, kind: "result" };
+  }
+  if (part.type === "tool-invocation" && isToolCallId(part.callID)) {
+    return { callId: part.callID, kind: "invocation" };
+  }
+  if (part.type === "tool_use" && isToolCallId(part.id)) {
+    return { callId: part.id, kind: "invocation" };
+  }
+  if (part.type === "tool_result" && isToolCallId(part.tool_use_id)) {
+    return { callId: part.tool_use_id, kind: "result" };
+  }
+  return null;
+}
+class ToolMutationBatch {
+  partsToRemove = new Set;
+  affectedMessages = new Set;
+  messages;
+  constructor(messages) {
+    this.messages = messages;
+  }
+  markForRemoval(occurrence) {
+    this.partsToRemove.add(occurrence.part);
+    this.affectedMessages.add(occurrence.message);
+  }
+  finalize() {
+    if (this.partsToRemove.size === 0)
+      return;
+    for (const message of this.affectedMessages) {
+      message.parts = message.parts.filter((p) => !this.partsToRemove.has(p));
+    }
+    for (let i = this.messages.length - 1;i >= 0; i -= 1) {
+      if (!this.messages[i].parts.some(hasMeaningfulPart)) {
+        this.messages.splice(i, 1);
+      }
+    }
+    this.partsToRemove.clear();
+    this.affectedMessages.clear();
+  }
 }
 
 // ../plugin/src/hooks/magic-context/read-session-chunk.ts
@@ -156159,23 +156136,47 @@ function getRawSessionMessageCount(sessionId) {
 }
 function getRawSessionTagKeysThrough(sessionId, upToMessageIndex) {
   const messages = readRawSessionMessages(sessionId);
-  const keys = [];
+  const messageFileKeys = new Set;
+  const toolObservations = new Map;
+  const unpairedInvocations = new Map;
   for (const message of messages) {
     if (message.ordinal > upToMessageIndex)
       break;
     for (const [partIndex, part] of message.parts.entries()) {
       if (isTextPart(part)) {
-        keys.push(`${message.id}:p${partIndex}`);
+        messageFileKeys.add(`${message.id}:p${partIndex}`);
+        continue;
       }
       if (isFilePart(part)) {
-        keys.push(`${message.id}:file${partIndex}`);
+        messageFileKeys.add(`${message.id}:file${partIndex}`);
+        continue;
       }
-      if (isToolPartWithOutput(part)) {
-        keys.push(part.callID);
+      const obs = extractToolCallObservation(part);
+      if (!obs)
+        continue;
+      let ownerMsgId;
+      if (obs.kind === "invocation") {
+        ownerMsgId = message.id;
+        const queue = unpairedInvocations.get(obs.callId) ?? [];
+        queue.push(message.id);
+        unpairedInvocations.set(obs.callId, queue);
+      } else {
+        const queue = unpairedInvocations.get(obs.callId);
+        if (queue && queue.length > 0) {
+          const popped = queue.shift();
+          if (queue.length === 0)
+            unpairedInvocations.delete(obs.callId);
+          ownerMsgId = popped ?? message.id;
+        } else {
+          ownerMsgId = message.id;
+        }
       }
+      const owners = toolObservations.get(obs.callId) ?? new Set;
+      owners.add(ownerMsgId);
+      toolObservations.set(obs.callId, owners);
     }
   }
-  return keys;
+  return { messageFileKeys, toolObservations };
 }
 var PROTECTED_TAIL_USER_TURNS = 5;
 function getProtectedTailStartOrdinal(sessionId) {
@@ -156324,6 +156325,79 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
   };
 }
 
+// ../plugin/src/shared/harness.ts
+var currentHarness = "opencode";
+var harnessLocked = false;
+function setHarness(value) {
+  if (harnessLocked && currentHarness !== value) {
+    throw new Error(`Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`);
+  }
+  currentHarness = value;
+  harnessLocked = true;
+}
+function getHarness() {
+  return currentHarness;
+}
+
+// ../plugin/src/features/magic-context/compression-depth-storage.ts
+var incrementDepthStatements = new WeakMap;
+var totalDepthStatements = new WeakMap;
+var maxDepthStatements = new WeakMap;
+var clearDepthStatements = new WeakMap;
+function getIncrementDepthStatement(db) {
+  let stmt = incrementDepthStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO compression_depth (session_id, message_ordinal, depth, harness) VALUES (?, ?, 1, ?) ON CONFLICT(session_id, message_ordinal) DO UPDATE SET depth = depth + 1");
+    incrementDepthStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getTotalDepthStatement(db) {
+  let stmt = totalDepthStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COALESCE(SUM(depth), 0) AS total_depth FROM compression_depth WHERE session_id = ? AND message_ordinal BETWEEN ? AND ?");
+    totalDepthStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearDepthStatement(db) {
+  let stmt = clearDepthStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compression_depth WHERE session_id = ?");
+    clearDepthStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function incrementCompressionDepth(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal) {
+    return;
+  }
+  db.transaction(() => {
+    const stmt = getIncrementDepthStatement(db);
+    for (let ordinal = startOrdinal;ordinal <= endOrdinal; ordinal += 1) {
+      stmt.run(sessionId, ordinal, getHarness());
+    }
+  })();
+}
+function getAverageCompressionDepth(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal) {
+    return 0;
+  }
+  const row = getTotalDepthStatement(db).get(sessionId, startOrdinal, endOrdinal);
+  const totalDepth = typeof row?.total_depth === "number" ? row.total_depth : 0;
+  const messageCount = endOrdinal - startOrdinal + 1;
+  return totalDepth / messageCount;
+}
+function clearCompressionDepth(db, sessionId) {
+  getClearDepthStatement(db).run(sessionId);
+}
+function clearCompressionDepthRange(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal) {
+    return;
+  }
+  db.prepare("DELETE FROM compression_depth WHERE session_id = ? AND message_ordinal BETWEEN ? AND ?").run(sessionId, startOrdinal, endOrdinal);
+}
+
 // ../plugin/src/features/magic-context/message-index.ts
 var lastIndexedStatements = new WeakMap;
 var insertMessageStatements = new WeakMap;
@@ -156331,6 +156405,7 @@ var upsertIndexStatements = new WeakMap;
 var deleteFtsStatements = new WeakMap;
 var deleteIndexStatements = new WeakMap;
 var countIndexedMessageStatements = new WeakMap;
+var indexedMessageIdStatements = new WeakMap;
 function normalizeIndexText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
@@ -156374,10 +156449,34 @@ function getDeleteIndexStatement(db) {
   }
   return stmt;
 }
+function getCountIndexedMessageStatement(db) {
+  let stmt = countIndexedMessageStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COUNT(*) AS count FROM message_history_fts WHERE session_id = ? AND message_id = ?");
+    countIndexedMessageStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getIndexedMessageIdStatement(db) {
+  let stmt = indexedMessageIdStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT message_id AS messageId FROM message_history_fts WHERE session_id = ?");
+    indexedMessageIdStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function getLastIndexedOrdinal(db, sessionId) {
   const row = getLastIndexedStatement(db).get(sessionId);
   return typeof row?.last_indexed_ordinal === "number" ? row.last_indexed_ordinal : 0;
 }
+function isMessageAlreadyIndexed(db, sessionId, messageId) {
+  const row = getCountIndexedMessageStatement(db).get(sessionId, messageId);
+  return (typeof row?.count === "number" ? row.count : 0) > 0;
+}
+function advanceIndexWatermark(db, sessionId, ordinal, now) {
+  const current = getLastIndexedOrdinal(db, sessionId);
+  getUpsertIndexStatement(db).run(sessionId, Math.max(current, ordinal), now, getHarness());
+}
 function clearIndexedMessages(db, sessionId) {
   db.transaction(() => {
     getDeleteFtsStatement(db).run(sessionId);
@@ -156397,39 +156496,510 @@ function getIndexableContent(role, parts) {
   }
   return "";
 }
-function ensureMessagesIndexed(db, sessionId, readMessages) {
-  const messages = readMessages(sessionId);
-  if (messages.length === 0) {
-    db.transaction(() => clearIndexedMessages(db, sessionId))();
+function indexSingleMessageInTransaction(db, sessionId, message, now) {
+  if (message.role !== "user" && message.role !== "assistant") {
+    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+    return false;
+  }
+  const content = getIndexableContent(message.role, message.parts);
+  if (content.length === 0) {
+    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+    return false;
+  }
+  if (isMessageAlreadyIndexed(db, sessionId, message.id)) {
+    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+    return false;
+  }
+  getInsertMessageStatement(db).run(sessionId, message.ordinal, message.id, message.role, content);
+  advanceIndexWatermark(db, sessionId, message.ordinal, now);
+  return true;
+}
+function indexSingleMessage(db, sessionId, message) {
+  return db.transaction(() => indexSingleMessageInTransaction(db, sessionId, message, Date.now()))();
+}
+function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal, finalWatermark = messages.length) {
+  const now = Date.now();
+  let inserted = 0;
+  db.transaction(() => {
+    const existingMessageIds = new Set(getIndexedMessageIdStatement(db).all(sessionId).map((row) => row.messageId).filter((messageId) => typeof messageId === "string"));
+    const insertMessage = getInsertMessageStatement(db);
+    for (const message of messages) {
+      if (message.ordinal <= lastIndexedOrdinal) {
+        continue;
+      }
+      if (message.role !== "user" && message.role !== "assistant") {
+        continue;
+      }
+      const content = getIndexableContent(message.role, message.parts);
+      if (content.length === 0 || existingMessageIds.has(message.id)) {
+        continue;
+      }
+      insertMessage.run(sessionId, message.ordinal, message.id, message.role, content);
+      existingMessageIds.add(message.id);
+      inserted++;
+    }
+    getUpsertIndexStatement(db).run(sessionId, finalWatermark, now, getHarness());
+  })();
+  return inserted;
+}
+
+// ../plugin/src/features/magic-context/message-index-async.ts
+var INCREMENTAL_DEBOUNCE_MS = 100;
+var reconciledSessions = new Set;
+var reconciliationScheduledSessions = new Set;
+var sessionLocks = new Map;
+var incrementalTimers = new Map;
+var pendingIncrementalKeys = new Set;
+function defer(fn) {
+  const immediate = globalThis.setImmediate;
+  if (typeof immediate === "function") {
+    immediate(fn);
     return;
   }
-  let lastIndexedOrdinal = getLastIndexedOrdinal(db, sessionId);
-  if (lastIndexedOrdinal > messages.length) {
-    db.transaction(() => clearIndexedMessages(db, sessionId))();
-    lastIndexedOrdinal = 0;
+  setTimeout(fn, 0);
+}
+function runWithSessionLock(sessionId, operation) {
+  const previous = sessionLocks.get(sessionId) ?? Promise.resolve();
+  const run = previous.catch(() => {
+    return;
+  }).then(async () => {
+    await operation();
+  });
+  sessionLocks.set(sessionId, run);
+  run.finally(() => {
+    if (sessionLocks.get(sessionId) === run) {
+      sessionLocks.delete(sessionId);
+    }
+  }).catch(() => {
+    return;
+  });
+  return run;
+}
+function logIndexingError(sessionId, action, error48) {
+  sessionLog(sessionId, `message FTS async ${action} failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+  log(`[message-index-async] ${action} failed for ${sessionId}:`, error48);
+}
+async function reconcileSessionIndex(db, sessionId, readMessages) {
+  await runWithSessionLock(sessionId, () => {
+    if (reconciledSessions.has(sessionId)) {
+      return;
+    }
+    const messages = readMessages(sessionId);
+    if (messages.length === 0) {
+      clearIndexedMessages(db, sessionId);
+      reconciledSessions.add(sessionId);
+      return;
+    }
+    let lastIndexedOrdinal = getLastIndexedOrdinal(db, sessionId);
+    if (lastIndexedOrdinal > messages.length) {
+      clearIndexedMessages(db, sessionId);
+      lastIndexedOrdinal = 0;
+    }
+    const watermark = Math.min(lastIndexedOrdinal, messages.length);
+    indexMessagesAfterOrdinal(db, sessionId, messages, watermark, messages.length);
+    reconciledSessions.add(sessionId);
+  });
+}
+function scheduleReconciliation(db, sessionId, readMessages) {
+  if (reconciledSessions.has(sessionId) || reconciliationScheduledSessions.has(sessionId)) {
+    return;
   }
-  if (lastIndexedOrdinal >= messages.length) {
+  reconciliationScheduledSessions.add(sessionId);
+  defer(() => {
+    reconcileSessionIndex(db, sessionId, readMessages).catch((error48) => {
+      reconciliationScheduledSessions.delete(sessionId);
+      logIndexingError(sessionId, "reconciliation", error48);
+    });
+  });
+}
+function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
+  const key = `${sessionId}\x00${messageId}`;
+  if (incrementalTimers.has(key) || pendingIncrementalKeys.has(key)) {
     return;
   }
-  const messagesToInsert = messages.filter((message) => message.ordinal > lastIndexedOrdinal).filter((message) => message.role === "user" || message.role === "assistant").map((message) => ({
-    ordinal: message.ordinal,
-    id: message.id,
-    role: message.role,
-    content: getIndexableContent(message.role, message.parts)
-  })).filter((message) => message.content.length > 0);
+  const timer = setTimeout(() => {
+    incrementalTimers.delete(key);
+    pendingIncrementalKeys.add(key);
+    runWithSessionLock(sessionId, () => {
+      const message = readSingleMessage(sessionId, messageId);
+      if (!message) {
+        return;
+      }
+      indexSingleMessage(db, sessionId, message);
+    }).catch((error48) => {
+      logIndexingError(sessionId, `incremental index for ${messageId}`, error48);
+    }).finally(() => {
+      pendingIncrementalKeys.delete(key);
+    });
+  }, INCREMENTAL_DEBOUNCE_MS);
+  incrementalTimers.set(key, timer);
+}
+function clearSessionTracking(sessionId) {
+  reconciledSessions.delete(sessionId);
+  reconciliationScheduledSessions.delete(sessionId);
+  sessionLocks.delete(sessionId);
+  const prefix = `${sessionId}\x00`;
+  for (const [key, timer] of incrementalTimers) {
+    if (key.startsWith(prefix)) {
+      clearTimeout(timer);
+      incrementalTimers.delete(key);
+    }
+  }
+  for (const key of pendingIncrementalKeys) {
+    if (key.startsWith(prefix)) {
+      pendingIncrementalKeys.delete(key);
+    }
+  }
+}
+
+// ../plugin/src/features/magic-context/overflow-detection.ts
+var OVERFLOW_PATTERNS = [
+  /prompt is too long/i,
+  /input is too long for requested model/i,
+  /exceeds the context window/i,
+  /input token count.*exceeds the maximum/i,
+  /maximum prompt length is \d+/i,
+  /reduce the length of the messages/i,
+  /maximum context length is \d+ tokens/i,
+  /exceeds the limit of \d+/i,
+  /exceeds the available context size/i,
+  /greater than the context length/i,
+  /context window exceeds limit/i,
+  /exceeded model token limit/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /request entity too large/i,
+  /context length is only \d+ tokens/i,
+  /input length.*exceeds.*context length/i,
+  /prompt too long; exceeded (?:max )?context length/i,
+  /too large for model with \d+ maximum context length/i,
+  /model_context_window_exceeded/i,
+  /context size has been exceeded/i
+];
+var LIMIT_EXTRACTION_PATTERNS = [
+  /maximum prompt length is (\d+)/i,
+  /maximum context length is (\d+) tokens?/i,
+  /context length is only (\d+) tokens?/i,
+  /exceeds the limit of (\d+)/i,
+  /too large for model with (\d+) maximum context length/i,
+  /context size.*(\d+) tokens?/i,
+  /exceeds? the context length of (\d+)/i,
+  /max(?:imum)?.*context.*?(\d+)/i
+];
+var MIN_PLAUSIBLE_LIMIT = 1024;
+var MAX_PLAUSIBLE_LIMIT = 1e7;
+function extractErrorMessage(error48) {
+  if (!error48)
+    return "";
+  if (typeof error48 === "string")
+    return error48;
+  if (typeof error48 === "object") {
+    const obj = error48;
+    const nested = obj.error;
+    if (nested && typeof nested.message === "string" && nested.message.length > 0) {
+      return nested.message;
+    }
+  }
+  if (error48 instanceof Error)
+    return error48.message;
+  if (typeof error48 === "object") {
+    const obj = error48;
+    if (typeof obj.message === "string")
+      return obj.message;
+    if (typeof obj.responseBody === "string")
+      return obj.responseBody;
+    try {
+      return JSON.stringify(error48);
+    } catch {
+      return String(error48);
+    }
+  }
+  return String(error48);
+}
+function detectOverflow(error48) {
+  const message = extractErrorMessage(error48);
+  if (!message) {
+    return { isOverflow: false };
+  }
+  const hasStatus413 = /\b413\b/.test(message) && /(entity|payload|context|prompt)/i.test(message);
+  let matched;
+  for (const pattern of OVERFLOW_PATTERNS) {
+    if (pattern.test(message)) {
+      matched = pattern;
+      break;
+    }
+  }
+  if (!matched && !hasStatus413) {
+    return { isOverflow: false };
+  }
+  const reportedLimit = parseReportedLimit(message);
+  return {
+    isOverflow: true,
+    reportedLimit,
+    matchedPattern: matched?.source
+  };
+}
+function parseReportedLimit(message) {
+  if (!message)
+    return;
+  for (const pattern of LIMIT_EXTRACTION_PATTERNS) {
+    const match = message.match(pattern);
+    if (!match)
+      continue;
+    const raw = match[1];
+    if (!raw)
+      continue;
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isFinite(value))
+      continue;
+    if (value < MIN_PLAUSIBLE_LIMIT || value > MAX_PLAUSIBLE_LIMIT)
+      continue;
+    return value;
+  }
+  return;
+}
+
+// ../plugin/src/features/magic-context/compartment-storage.ts
+var insertCompartmentStatements = new WeakMap;
+var insertFactStatements = new WeakMap;
+function getInsertCompartmentStatement(db) {
+  let stmt = insertCompartmentStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, created_at, harness) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    insertCompartmentStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getInsertFactStatement(db) {
+  let stmt = insertFactStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO session_facts (session_id, category, content, created_at, updated_at, harness) VALUES (?, ?, ?, ?, ?, ?)");
+    insertFactStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function isCompartmentRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.sequence === "number" && typeof candidate.start_message === "number" && typeof candidate.end_message === "number" && typeof candidate.start_message_id === "string" && typeof candidate.end_message_id === "string" && typeof candidate.title === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number";
+}
+function isSessionFactRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.category === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number" && typeof candidate.updated_at === "number";
+}
+function insertCompartmentRows(db, sessionId, compartments, now) {
+  const stmt = getInsertCompartmentStatement(db);
+  for (const compartment of compartments) {
+    stmt.run(sessionId, compartment.sequence, compartment.startMessage, compartment.endMessage, compartment.startMessageId, compartment.endMessageId, compartment.title, compartment.content, now, getHarness());
+  }
+}
+function insertFactRows(db, sessionId, facts, now) {
+  const stmt = getInsertFactStatement(db);
+  for (const fact of facts) {
+    stmt.run(sessionId, fact.category, fact.content, now, now, getHarness());
+  }
+}
+function toCompartment(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    sequence: row.sequence,
+    startMessage: row.start_message,
+    endMessage: row.end_message,
+    startMessageId: row.start_message_id,
+    endMessageId: row.end_message_id,
+    title: row.title,
+    content: row.content,
+    createdAt: row.created_at
+  };
+}
+function toSessionFact(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    category: row.category,
+    content: row.content,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function getCompartments(db, sessionId) {
+  const rows = db.prepare("SELECT * FROM compartments WHERE session_id = ? ORDER BY sequence ASC").all(sessionId).filter(isCompartmentRow);
+  return rows.map(toCompartment);
+}
+function getLastCompartmentEndMessage(db, sessionId) {
+  const row = db.prepare("SELECT MAX(end_message) as max_end FROM compartments WHERE session_id = ?").get(sessionId);
+  return row?.max_end ?? -1;
+}
+function appendCompartments(db, sessionId, compartments) {
+  if (compartments.length === 0)
+    return;
   const now = Date.now();
   db.transaction(() => {
-    const insertMessage = getInsertMessageStatement(db);
-    for (const message of messagesToInsert) {
-      insertMessage.run(sessionId, message.ordinal, message.id, message.role, message.content);
+    insertCompartmentRows(db, sessionId, compartments, now);
+  })();
+}
+function replaceSessionFacts(db, sessionId, facts) {
+  const now = Date.now();
+  db.transaction(() => {
+    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
+    insertFactRows(db, sessionId, facts, now);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
+  })();
+}
+function getSessionFacts(db, sessionId) {
+  const rows = db.prepare("SELECT * FROM session_facts WHERE session_id = ? ORDER BY category ASC, id ASC").all(sessionId).filter(isSessionFactRow);
+  return rows.map(toSessionFact);
+}
+function replaceAllCompartmentState(db, sessionId, compartments, facts) {
+  const now = Date.now();
+  db.transaction(() => {
+    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
+    insertCompartmentRows(db, sessionId, compartments, now);
+    insertFactRows(db, sessionId, facts, now);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
+  })();
+}
+function buildCompartmentBlock(compartments, facts, memoryBlock, dateRanges) {
+  const lines = [];
+  if (memoryBlock) {
+    lines.push(memoryBlock);
+    lines.push("");
+  }
+  for (const c of compartments) {
+    const dates = dateRanges?.byId.get(c.id);
+    const dateAttr = dates ? ` start-date="${dates.start}" end-date="${dates.end}"` : "";
+    lines.push(`<compartment start="${c.startMessage}" end="${c.endMessage}"${dateAttr} title="${escapeXmlAttr(c.title)}">`);
+    lines.push(escapeXmlContent(c.content));
+    lines.push("</compartment>");
+    lines.push("");
+  }
+  const factsByCategory = new Map;
+  for (const f of facts) {
+    const existing = factsByCategory.get(f.category) ?? [];
+    existing.push(f.content);
+    factsByCategory.set(f.category, existing);
+  }
+  for (const [category, items] of factsByCategory) {
+    lines.push(`${category}:`);
+    for (const item of items) {
+      lines.push(`* ${escapeXmlContent(item)}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`).trimEnd();
+}
+function saveRecompStagingPass(db, sessionId, passNumber, compartments, facts) {
+  const now = Date.now();
+  db.transaction(() => {
+    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
+    const compartmentStmt = db.prepare("INSERT OR REPLACE INTO recomp_compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, pass_number, created_at, harness) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    for (const c of compartments) {
+      compartmentStmt.run(sessionId, c.sequence, c.startMessage, c.endMessage, c.startMessageId, c.endMessageId, c.title, c.content, passNumber, now, getHarness());
+    }
+    const factStmt = db.prepare("INSERT INTO recomp_facts (session_id, category, content, pass_number, created_at, harness) VALUES (?, ?, ?, ?, ?, ?)");
+    for (const f of facts) {
+      factStmt.run(sessionId, f.category, f.content, passNumber, now, getHarness());
     }
-    getUpsertIndexStatement(db).run(sessionId, messages.length, now, getHarness());
   })();
 }
+function getRecompStaging(db, sessionId) {
+  const compartmentRows = db.prepare("SELECT * FROM recomp_compartments WHERE session_id = ? ORDER BY sequence ASC").all(sessionId).filter(isRecompCompartmentRow);
+  if (compartmentRows.length === 0)
+    return null;
+  const compartments = compartmentRows.map((row) => ({
+    sequence: row.sequence,
+    startMessage: row.start_message,
+    endMessage: row.end_message,
+    startMessageId: row.start_message_id,
+    endMessageId: row.end_message_id,
+    title: row.title,
+    content: row.content
+  }));
+  const factRows = db.prepare("SELECT category, content FROM recomp_facts WHERE session_id = ?").all(sessionId).filter(isRecompFactRow);
+  const maxPass = compartmentRows.reduce((m, r) => Math.max(m, r.pass_number), 0);
+  const lastEnd = compartmentRows[compartmentRows.length - 1]?.end_message ?? 0;
+  return {
+    compartments,
+    facts: factRows,
+    passCount: maxPass,
+    lastEndMessage: lastEnd
+  };
+}
+function promoteRecompStaging(db, sessionId) {
+  const now = Date.now();
+  return db.transaction(() => {
+    const staging = getRecompStaging(db, sessionId);
+    if (!staging || staging.compartments.length === 0)
+      return null;
+    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
+    insertCompartmentRows(db, sessionId, staging.compartments, now);
+    insertFactRows(db, sessionId, staging.facts, now);
+    db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE session_id = ?").run(sessionId);
+    return { compartments: staging.compartments, facts: staging.facts };
+  })();
+}
+function invalidateAllMemoryBlockCaches(db) {
+  try {
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE memory_block_cache != '' OR memory_block_ids != ''").run();
+  } catch {}
+}
+function clearRecompStaging(db, sessionId) {
+  db.transaction(() => {
+    db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
+    try {
+      db.prepare("UPDATE session_meta SET recomp_partial_range_start = 0, recomp_partial_range_end = 0 WHERE session_id = ?").run(sessionId);
+    } catch {}
+  })();
+}
+function getRecompPartialRange(db, sessionId) {
+  try {
+    const row = db.prepare("SELECT recomp_partial_range_start AS start, recomp_partial_range_end AS end FROM session_meta WHERE session_id = ?").get(sessionId);
+    const start = typeof row?.start === "number" ? row.start : 0;
+    const end = typeof row?.end === "number" ? row.end : 0;
+    if (start <= 0 || end <= 0)
+      return null;
+    return { start, end };
+  } catch {
+    return null;
+  }
+}
+function setRecompPartialRange(db, sessionId, range) {
+  const start = range ? range.start : 0;
+  const end = range ? range.end : 0;
+  db.prepare("INSERT OR IGNORE INTO session_meta (session_id) VALUES (?)").run(sessionId);
+  db.prepare("UPDATE session_meta SET recomp_partial_range_start = ?, recomp_partial_range_end = ? WHERE session_id = ?").run(start, end, sessionId);
+}
+function isRecompCompartmentRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.sequence === "number" && typeof candidate.start_message === "number" && typeof candidate.end_message === "number" && typeof candidate.start_message_id === "string" && typeof candidate.end_message_id === "string" && typeof candidate.title === "string" && typeof candidate.content === "string" && typeof candidate.pass_number === "number" && typeof candidate.created_at === "number";
+}
+function isRecompFactRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.category === "string" && typeof candidate.content === "string";
+}
+function escapeXmlAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlContent(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 // ../plugin/src/features/magic-context/storage-db.ts
 init_data_path();
-import { copyFileSync, cpSync, existsSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
 function getErrorMessage(error48) {
@@ -156714,6 +157284,58 @@ var MIGRATIONS = [
         db.exec("ALTER TABLE notes ADD COLUMN harness TEXT NOT NULL DEFAULT 'opencode'");
       }
     }
+  },
+  {
+    version: 8,
+    description: "Add partial indexes on tags(session_id, tag_number) for active and dropped",
+    up: (db) => {
+      db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_tags_active_session_tag_number
+                ON tags(session_id, tag_number)
+                WHERE status = 'active';
+
+                CREATE INDEX IF NOT EXISTS idx_tags_dropped_session_tag_number
+                ON tags(session_id, tag_number)
+                WHERE status = 'dropped';
+            `);
+      db.exec("ANALYZE tags;");
+    }
+  },
+  {
+    version: 9,
+    description: "Persist tool_definition_measurements across plugin restarts",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS tool_definition_measurements (
+                    provider_id TEXT NOT NULL,
+                    model_id TEXT NOT NULL,
+                    agent_name TEXT NOT NULL,
+                    tool_id TEXT NOT NULL,
+                    token_count INTEGER NOT NULL,
+                    recorded_at INTEGER NOT NULL,
+                    PRIMARY KEY (provider_id, model_id, agent_name, tool_id)
+                );
+            `);
+    }
+  },
+  {
+    version: 10,
+    description: "Add tool_owner_message_id column to tags + composite identity indexes",
+    up: (db) => {
+      const cols = db.prepare("PRAGMA table_info(tags)").all();
+      if (!cols.some((c) => c.name === "tool_owner_message_id")) {
+        db.exec("ALTER TABLE tags ADD COLUMN tool_owner_message_id TEXT DEFAULT NULL");
+      }
+      db.exec(`
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_tool_composite
+                ON tags(session_id, message_id, tool_owner_message_id)
+                WHERE type = 'tool' AND tool_owner_message_id IS NOT NULL;
+
+                CREATE INDEX IF NOT EXISTS idx_tags_tool_null_owner
+                ON tags(session_id, message_id)
+                WHERE type = 'tool' AND tool_owner_message_id IS NULL;
+            `);
+    }
   }
 ];
 function ensureMigrationsTable(db) {
@@ -156729,22 +157351,51 @@ function getCurrentVersion(db) {
   const row = db.prepare("SELECT MAX(version) as version FROM schema_migrations").get();
   return row?.version ?? 0;
 }
+function isSiblingMigrationConflict(error48, version2) {
+  if (!(error48 instanceof Error))
+    return false;
+  const code = error48.code;
+  if (code !== "SQLITE_CONSTRAINT_PRIMARYKEY" && code !== "SQLITE_CONSTRAINT_UNIQUE") {
+    return false;
+  }
+  const msg = error48.message;
+  if (!msg.includes("schema_migrations"))
+    return false;
+  if (!msg.toLowerCase().includes("version"))
+    return false;
+  return true;
+}
 function runMigrations(db) {
   ensureMigrationsTable(db);
-  const currentVersion = getCurrentVersion(db);
-  const pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+  let currentVersion = getCurrentVersion(db);
+  let pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
   if (pendingMigrations.length === 0) {
     return;
   }
   log(`[migrations] current schema version: ${currentVersion}, applying ${pendingMigrations.length} migration(s)`);
-  for (const migration of pendingMigrations) {
+  let migrationIndex = 0;
+  while (migrationIndex < pendingMigrations.length) {
+    const migration = pendingMigrations[migrationIndex];
     try {
       db.transaction(() => {
         migration.up(db);
         db.prepare("INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.description, Date.now());
       })();
       log(`[migrations] applied v${migration.version}: ${migration.description}`);
+      migrationIndex += 1;
     } catch (error48) {
+      if (isSiblingMigrationConflict(error48, migration.version)) {
+        log(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
+        const reReadVersion = getCurrentVersion(db);
+        if (reReadVersion <= currentVersion) {
+          log(`[migrations] FAILED v${migration.version}: sibling-conflict shape but version not advanced (${reReadVersion} <= ${currentVersion}) — failing closed`);
+          throw new Error(`Migration v${migration.version} failed: sibling conflict reported but version did not advance. Database may need manual repair.`);
+        }
+        currentVersion = reReadVersion;
+        pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+        migrationIndex = 0;
+        continue;
+      }
       log(`[migrations] FAILED v${migration.version}: ${migration.description} — ${error48 instanceof Error ? error48.message : String(error48)}`);
       throw new Error(`Migration v${migration.version} failed: ${error48 instanceof Error ? error48.message : String(error48)}. Database may need manual repair.`);
     }
@@ -156752,27 +157403,300 @@ function runMigrations(db) {
   log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
 }
 
+// ../plugin/src/features/magic-context/tool-definition-tokens.ts
+var measurements = new Map;
+var persistenceDb = null;
+function keyFor(providerID, modelID, agentName) {
+  const agent = agentName && agentName.length > 0 ? agentName : "default";
+  return `${providerID}/${modelID}/${agent}`;
+}
+function setDatabase(db) {
+  persistenceDb = db;
+}
+function loadToolDefinitionMeasurements(db) {
+  let rows = [];
+  try {
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
+    let inner = measurements.get(key);
+    if (!inner) {
+      inner = new Map;
+      measurements.set(key, inner);
+    }
+    inner.set(row.tool_id, row.token_count);
+  }
+}
+
+// ../plugin/src/features/magic-context/tool-owner-backfill.ts
+init_data_path();
+init_logger();
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join6 } from "node:path";
+var LEASE_DURATION_MS = 5 * 60 * 1000;
+var LEASE_RENEWAL_MS = 60 * 1000;
+function resolveOpencodeDbPath() {
+  return join6(getDataDir(), "opencode", "opencode.db");
+}
+function ensureBackfillStateTable(db) {
+  db.exec(`
+        CREATE TABLE IF NOT EXISTS tool_owner_backfill_state (
+            session_id TEXT PRIMARY KEY,
+            status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'skipped')),
+            started_at INTEGER,
+            lease_expires_at INTEGER,
+            completed_at INTEGER,
+            last_error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_tool_owner_backfill_state_status
+        ON tool_owner_backfill_state(status);
+    `);
+}
+function runToolOwnerBackfill(db) {
+  const startedAt = performance.now();
+  ensureBackfillStateTable(db);
+  const result = {
+    sessionsProcessed: 0,
+    sessionsSkippedNoOcDb: 0,
+    sessionsSkippedNoMatches: 0,
+    sessionsCompleted: 0,
+    sessionsBlockedByLease: 0,
+    sessionsErrored: 0,
+    rowsUpdated: 0,
+    rowsLeftNull: 0,
+    durationMs: 0
+  };
+  if (!isToolOwnerBackfillNeeded(db)) {
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  const opencodeDbPath = resolveOpencodeDbPath();
+  if (!existsSync2(opencodeDbPath)) {
+    log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
+    markAllUnbackfilledSessionsSkipped(db);
+    result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  db.exec(`ATTACH '${opencodeDbPath}' AS oc_backfill`);
+  try {
+    backfillToolOwnersInChunks(db, result);
+  } finally {
+    try {
+      db.exec("DETACH DATABASE oc_backfill");
+    } catch (error48) {
+      log(`[backfill] failed to detach oc_backfill database: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+  }
+  result.durationMs = performance.now() - startedAt;
+  log(`[backfill] sessions=${result.sessionsProcessed} completed=${result.sessionsCompleted} skipped_no_oc=${result.sessionsSkippedNoOcDb} skipped_no_matches=${result.sessionsSkippedNoMatches} blocked_by_lease=${result.sessionsBlockedByLease} errored=${result.sessionsErrored} rows_updated=${result.rowsUpdated} rows_left_null=${result.rowsLeftNull} duration_ms=${Math.round(result.durationMs)}`);
+  return result;
+}
+function isToolOwnerBackfillNeeded(db) {
+  ensureBackfillStateTable(db);
+  const row = db.prepare(`SELECT 1 AS hit
+             FROM tags
+             WHERE type = 'tool' AND tool_owner_message_id IS NULL
+               AND NOT EXISTS (
+                   SELECT 1 FROM tool_owner_backfill_state s
+                   WHERE s.session_id = tags.session_id
+                     AND s.status IN ('completed', 'skipped')
+               )
+             LIMIT 1`).get();
+  return row !== null && row !== undefined;
+}
+function markAllUnbackfilledSessionsSkipped(db) {
+  const now = Date.now();
+  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, completed_at, last_error)
+         SELECT DISTINCT session_id, 'skipped', NULL, ?, NULL
+         FROM tags
+         WHERE type = 'tool' AND tool_owner_message_id IS NULL
+         ON CONFLICT(session_id) DO UPDATE SET
+             status = 'skipped',
+             completed_at = excluded.completed_at,
+             last_error = NULL
+         WHERE tool_owner_backfill_state.status NOT IN ('completed', 'running')`).run(now);
+}
+function countSessionsByStatus(db, status) {
+  const row = db.prepare("SELECT COUNT(*) AS c FROM tool_owner_backfill_state WHERE status = ?").get(status);
+  return row.c;
+}
+function acquireSessionLease(db, sessionId, now) {
+  const expiresAt = now + LEASE_DURATION_MS;
+  const result = db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, lease_expires_at)
+             VALUES (?, 'running', ?, ?)
+             ON CONFLICT(session_id) DO UPDATE SET
+                 status = 'running',
+                 started_at = excluded.started_at,
+                 lease_expires_at = excluded.lease_expires_at,
+                 last_error = NULL
+             WHERE tool_owner_backfill_state.status IN ('pending', 'skipped')
+                OR (tool_owner_backfill_state.status = 'running'
+                    AND tool_owner_backfill_state.lease_expires_at < ?)`).run(sessionId, now, expiresAt, now);
+  return (result.changes ?? 0) === 1;
+}
+function renewSessionLease(db, sessionId, now) {
+  const expiresAt = now + LEASE_DURATION_MS;
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET lease_expires_at = ?
+         WHERE session_id = ? AND status = 'running'`).run(expiresAt, sessionId);
+}
+function markSessionCompleted(db, sessionId, now) {
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET status = 'completed', completed_at = ?, lease_expires_at = NULL, last_error = NULL
+         WHERE session_id = ?`).run(now, sessionId);
+}
+function markSessionSkipped(db, sessionId, now, reason) {
+  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, completed_at, last_error)
+         VALUES (?, 'skipped', ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET
+             status = 'skipped',
+             completed_at = excluded.completed_at,
+             last_error = excluded.last_error,
+             lease_expires_at = NULL`).run(sessionId, now, reason);
+}
+function markSessionErrored(db, sessionId, error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48);
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET last_error = ?, lease_expires_at = NULL
+         WHERE session_id = ?`).run(message, sessionId);
+}
+function getSessionsNeedingBackfill(db) {
+  const rows = db.prepare(`SELECT DISTINCT t.session_id
+             FROM tags t
+             LEFT JOIN tool_owner_backfill_state s ON s.session_id = t.session_id
+             WHERE t.type = 'tool' AND t.tool_owner_message_id IS NULL
+               AND (s.status IS NULL OR s.status NOT IN ('completed', 'skipped'))
+             ORDER BY t.session_id ASC`).all();
+  return rows.map((r) => r.session_id);
+}
+function buildSessionOwnerMap(db, sessionId) {
+  const rows = db.prepare(`SELECT
+                COALESCE(
+                    CASE WHEN json_extract(p.data, '$.type') = 'tool_use'
+                        THEN json_extract(p.data, '$.id')
+                    END,
+                    json_extract(p.data, '$.callID')
+                ) AS callid,
+                m.id AS owner_id,
+                m.time_created AS owner_t_created,
+                p.id AS part_id,
+                p.time_created AS part_t_created
+             FROM oc_backfill.message m
+             INNER JOIN oc_backfill.part p ON p.message_id = m.id
+             WHERE m.session_id = ?
+               AND json_extract(m.data, '$.role') = 'assistant'
+               AND (
+                   (json_extract(p.data, '$.type') IN ('tool', 'tool-invocation')
+                       AND json_extract(p.data, '$.callID') IS NOT NULL)
+                   OR (json_extract(p.data, '$.type') = 'tool_use'
+                       AND json_extract(p.data, '$.id') IS NOT NULL)
+               )
+             ORDER BY
+                 m.time_created ASC,
+                 m.id ASC,
+                 p.time_created ASC,
+                 p.id ASC`).all(sessionId);
+  const oldestByCallId = new Map;
+  for (const r of rows) {
+    if (typeof r.callid !== "string" || r.callid.length === 0)
+      continue;
+    if (!oldestByCallId.has(r.callid)) {
+      oldestByCallId.set(r.callid, r.owner_id);
+    }
+  }
+  return oldestByCallId;
+}
+function applyOwnersForSession(db, sessionId, ownersByCallId) {
+  if (ownersByCallId.size === 0) {
+    const leftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
+                     WHERE session_id = ? AND type = 'tool'
+                       AND tool_owner_message_id IS NULL`).get(sessionId).c;
+    return { rowsUpdated: 0, rowsLeftNull: leftNull };
+  }
+  const findOrphanStmt = db.prepare(`SELECT id FROM tags
+         WHERE session_id = ? AND message_id = ? AND type = 'tool'
+           AND tool_owner_message_id IS NULL
+         ORDER BY tag_number ASC
+         LIMIT 1`);
+  const updateRowStmt = db.prepare(`UPDATE tags
+         SET tool_owner_message_id = ?
+         WHERE id = ? AND tool_owner_message_id IS NULL`);
+  let rowsUpdated = 0;
+  db.transaction(() => {
+    for (const [callId, ownerId] of ownersByCallId) {
+      const orphan = findOrphanStmt.get(sessionId, callId);
+      if (!orphan)
+        continue;
+      const result = updateRowStmt.run(ownerId, orphan.id);
+      rowsUpdated += result.changes ?? 0;
+    }
+  })();
+  const rowsLeftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
+                 WHERE session_id = ? AND type = 'tool'
+                   AND tool_owner_message_id IS NULL`).get(sessionId).c;
+  return { rowsUpdated, rowsLeftNull };
+}
+function backfillToolOwnersInChunks(db, result) {
+  const sessionIds = getSessionsNeedingBackfill(db);
+  let lastRenewedAt = Date.now();
+  for (const sessionId of sessionIds) {
+    const now = Date.now();
+    result.sessionsProcessed += 1;
+    const acquired = acquireSessionLease(db, sessionId, now);
+    if (!acquired) {
+      result.sessionsBlockedByLease += 1;
+      continue;
+    }
+    try {
+      const owners = buildSessionOwnerMap(db, sessionId);
+      const { rowsUpdated, rowsLeftNull } = applyOwnersForSession(db, sessionId, owners);
+      result.rowsUpdated += rowsUpdated;
+      result.rowsLeftNull += rowsLeftNull;
+      if (owners.size === 0) {
+        markSessionSkipped(db, sessionId, Date.now(), "no_oc_matches");
+        result.sessionsSkippedNoMatches += 1;
+      } else {
+        markSessionCompleted(db, sessionId, Date.now());
+        result.sessionsCompleted += 1;
+      }
+    } catch (error48) {
+      log(`[backfill] session=${sessionId} errored: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      markSessionErrored(db, sessionId, error48);
+      result.sessionsErrored += 1;
+    }
+    const sinceRenew = Date.now() - lastRenewedAt;
+    if (sinceRenew > LEASE_RENEWAL_MS) {
+      renewSessionLease(db, sessionId, Date.now());
+      lastRenewedAt = Date.now();
+    }
+  }
+}
+
 // ../plugin/src/features/magic-context/storage-db.ts
 var databases = new Map;
 var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join5(dbDir, "context.db") };
+  return { dbDir, dbPath: join7(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync(targetDbPath))
+  if (existsSync3(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join5(legacyDir, "context.db");
-  if (!existsSync(legacyDbPath))
+  const legacyDbPath = join7(legacyDir, "context.db");
+  if (!existsSync3(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
-  mkdirSync2(targetDbDir, { recursive: true });
+  mkdirSync3(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join5(targetDbDir, `context.db${suffix}`);
-    if (existsSync(src)) {
+    const dst = join7(targetDbDir, `context.db${suffix}`);
+    if (existsSync3(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -156780,9 +157704,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join5(legacyDir, "models");
-  const targetModelsDir = join5(targetDbDir, "models");
-  if (existsSync(legacyModelsDir) && !existsSync(targetModelsDir)) {
+  const legacyModelsDir = join7(legacyDir, "models");
+  const targetModelsDir = join7(targetDbDir, "models");
+  if (existsSync3(legacyModelsDir) && !existsSync3(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -157068,6 +157992,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "tags", "tool_name", "TEXT");
   ensureColumn(db, "tags", "input_byte_size", "INTEGER DEFAULT 0");
   ensureColumn(db, "tags", "caveman_depth", "INTEGER DEFAULT 0");
+  ensureColumn(db, "tags", "tool_owner_message_id", "TEXT DEFAULT NULL");
   ensureColumn(db, "session_meta", "system_prompt_tokens", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compaction_marker_state", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "key_files", "TEXT DEFAULT ''");
@@ -157162,10 +158087,17 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync2(dbDir, { recursive: true });
+    mkdirSync3(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
+    try {
+      runToolOwnerBackfill(db);
+    } catch (error48) {
+      log(`[magic-context] tool-owner backfill failed (continuing with lazy adoption fallback): ${getErrorMessage(error48)}`);
+    }
+    setDatabase(db);
+    loadToolDefinitionMeasurements(db);
     databases.set(dbPath, db);
     persistenceByDatabase.set(db, true);
     persistenceErrorByDatabase.delete(db);
@@ -157773,7 +158705,7 @@ var getTagNumberByMessageIdStatements = new WeakMap;
 function getInsertTagStatement(db) {
   let stmt = insertTagStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("INSERT INTO tags (session_id, message_id, type, byte_size, reasoning_byte_size, tag_number, tool_name, input_byte_size, harness) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    stmt = db.prepare("INSERT INTO tags (session_id, message_id, type, byte_size, reasoning_byte_size, tag_number, tool_name, input_byte_size, harness, tool_owner_message_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     insertTagStatements.set(db, stmt);
   }
   return stmt;
@@ -157854,7 +158786,8 @@ function toTagEntry(row) {
     byteSize: row.byte_size,
     reasoningByteSize: row.reasoning_byte_size ?? 0,
     sessionId: row.session_id,
-    cavemanDepth: typeof row.caveman_depth === "number" && Number.isFinite(row.caveman_depth) ? row.caveman_depth : 0
+    cavemanDepth: typeof row.caveman_depth === "number" && Number.isFinite(row.caveman_depth) ? row.caveman_depth : 0,
+    toolOwnerMessageId: typeof row.tool_owner_message_id === "string" ? row.tool_owner_message_id : null
   };
 }
 function isTagNumberRow(row) {
@@ -157869,8 +158802,8 @@ function isMaxTagNumberRow(row) {
   const r = row;
   return typeof r.max_tag_number === "number";
 }
-function insertTag(db, sessionId, messageId, type, byteSize2, tagNumber, reasoningByteSize = 0, toolName = null, inputByteSize = 0) {
-  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize2, reasoningByteSize, tagNumber, toolName, inputByteSize, getHarness());
+function insertTag(db, sessionId, messageId, type, byteSize2, tagNumber, reasoningByteSize = 0, toolName = null, inputByteSize = 0, toolOwnerMessageId = null) {
+  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize2, reasoningByteSize, tagNumber, toolName, inputByteSize, getHarness(), toolOwnerMessageId);
   return tagNumber;
 }
 function updateTagStatus(db, sessionId, tagId, status) {
@@ -157882,6 +158815,7 @@ function updateTagDropMode(db, sessionId, tagNumber, dropMode) {
 function updateCavemanDepth(db, sessionId, tagNumber, depth) {
   db.prepare("UPDATE tags SET caveman_depth = ? WHERE session_id = ? AND tag_number = ?").run(depth, sessionId, tagNumber);
 }
+var getOwnerScopedToolTagNumbersStatements = new WeakMap;
 function getMaxTagNumberBySession(db, sessionId) {
   const row = getMaxTagNumberBySessionStatement(db).get(sessionId);
   return isMaxTagNumberRow(row) ? row.max_tag_number : 0;
@@ -157890,17 +158824,103 @@ function getTagNumberByMessageId(db, sessionId, messageId) {
   const row = getTagNumberByMessageIdStatement(db).get(sessionId, messageId);
   return isTagNumberRow(row) ? row.tag_number : null;
 }
+var TAG_SELECT_COLUMNS = "id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth, tool_owner_message_id";
 function getTagsBySession(db, sessionId) {
-  const rows = db.prepare("SELECT id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC").all(sessionId).filter(isTagRow);
+  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC`).all(sessionId).filter(isTagRow);
+  return rows.map(toTagEntry);
+}
+var getActiveTagsBySessionStatements = new WeakMap;
+var getMaxDroppedTagNumberStatements = new WeakMap;
+function getActiveTagsBySessionStatement(db) {
+  let stmt = getActiveTagsBySessionStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND status = 'active' ORDER BY tag_number ASC, id ASC`);
+    getActiveTagsBySessionStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getActiveTagsBySession(db, sessionId) {
+  const rows = getActiveTagsBySessionStatement(db).all(sessionId).filter(isTagRow);
+  return rows.map(toTagEntry);
+}
+function getTagsByNumbers(db, sessionId, tagNumbers) {
+  if (tagNumbers.length === 0)
+    return [];
+  if (tagNumbers.length > 900) {
+    const all = [];
+    for (let i = 0;i < tagNumbers.length; i += 900) {
+      all.push(...getTagsByNumbers(db, sessionId, tagNumbers.slice(i, i + 900)));
+    }
+    return all;
+  }
+  const placeholders = tagNumbers.map(() => "?").join(",");
+  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders}) ORDER BY tag_number ASC, id ASC`).all(sessionId, ...tagNumbers).filter(isTagRow);
   return rows.map(toTagEntry);
 }
 function getTopNBySize(db, sessionId, n) {
   if (n <= 0) {
     return [];
   }
-  const rows = db.prepare("SELECT id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?").all(sessionId, n).filter(isTagRow);
+  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?`).all(sessionId, n).filter(isTagRow);
   return rows.map(toTagEntry);
 }
+var getToolTagNumberByOwnerStatements = new WeakMap;
+var getNullOwnerToolTagStatements = new WeakMap;
+var adoptNullOwnerToolTagStatements = new WeakMap;
+var deleteToolTagsByOwnerStatements = new WeakMap;
+function getGetToolTagNumberByOwnerStatement(db) {
+  let stmt = getToolTagNumberByOwnerStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT tag_number FROM tags
+             WHERE session_id = ? AND message_id = ?
+               AND type = 'tool' AND tool_owner_message_id = ?
+             LIMIT 1`);
+    getToolTagNumberByOwnerStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getToolTagNumberByOwner(db, sessionId, callId, ownerMsgId) {
+  const row = getGetToolTagNumberByOwnerStatement(db).get(sessionId, callId, ownerMsgId);
+  return isTagNumberRow(row) ? row.tag_number : null;
+}
+function isNullOwnerToolTagRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.id === "number" && typeof r.tag_number === "number";
+}
+function getGetNullOwnerToolTagStatement(db) {
+  let stmt = getNullOwnerToolTagStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT id, tag_number FROM tags
+             WHERE session_id = ? AND message_id = ?
+               AND type = 'tool' AND tool_owner_message_id IS NULL
+             ORDER BY tag_number ASC
+             LIMIT 1`);
+    getNullOwnerToolTagStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getNullOwnerToolTag(db, sessionId, callId) {
+  const row = getGetNullOwnerToolTagStatement(db).get(sessionId, callId);
+  if (!isNullOwnerToolTagRow(row))
+    return null;
+  return { id: row.id, tagNumber: row.tag_number };
+}
+function getAdoptNullOwnerToolTagStatement(db) {
+  let stmt = adoptNullOwnerToolTagStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE tags
+             SET tool_owner_message_id = ?
+             WHERE id = ? AND tool_owner_message_id IS NULL`);
+    adoptNullOwnerToolTagStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function adoptNullOwnerToolTag(db, rowId, ownerMsgId) {
+  const result = getAdoptNullOwnerToolTagStatement(db).run(ownerMsgId, rowId);
+  return (result.changes ?? 0) === 1;
+}
 // ../plugin/src/agents/historian.ts
 var HISTORIAN_AGENT = "historian";
 var HISTORIAN_EDITOR_AGENT = "historian-editor";
@@ -157958,11 +158978,12 @@ function expandFallbackChain(chain) {
 init_data_path();
 init_logger();
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 var RELOAD_INTERVAL_MS = 5 * 60 * 1000;
 var apiCache = null;
+var recentlySeenApiSizes = new Set;
 var fileCache = null;
 var fileLastAttempt = 0;
 function hashFast(input) {
@@ -157975,16 +158996,16 @@ function getModelsJsonPath() {
   const cacheBase = getCacheDir();
   const source = process.env.OPENCODE_MODELS_URL?.trim();
   const filename = source && source !== "https://models.dev" ? `models-${hashFast(source)}.json` : "models.json";
-  return join6(cacheBase, "opencode", filename);
+  return join8(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform() === "win32" ? join6(homedir2(), ".config", "opencode") : join6(process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config"), "opencode");
-  const jsonc = join6(configDir, "opencode.jsonc");
-  if (existsSync2(jsonc))
+  const configDir = envDir ? envDir : platform() === "win32" ? join8(homedir2(), ".config", "opencode") : join8(process.env.XDG_CONFIG_HOME || join8(homedir2(), ".config"), "opencode");
+  const jsonc = join8(configDir, "opencode.jsonc");
+  if (existsSync4(jsonc))
     return jsonc;
-  const json2 = join6(configDir, "opencode.json");
-  if (existsSync2(json2))
+  const json2 = join8(configDir, "opencode.json");
+  if (existsSync4(json2))
     return json2;
   return null;
 }
@@ -157997,23 +159018,12 @@ function resolveLimit(limit) {
     return limit.context;
   return;
 }
-function resolveInterleavedField(interleaved) {
-  if (interleaved && typeof interleaved === "object" && typeof interleaved.field === "string" && interleaved.field.length > 0) {
-    return interleaved.field;
-  }
-  return;
-}
 function setCachedModelMetadata(cache, key, model) {
   const limit = resolveLimit(model?.limit);
-  const interleavedField = resolveInterleavedField(model?.capabilities?.interleaved) ?? resolveInterleavedField(model?.interleaved);
-  if (limit === undefined && interleavedField === undefined) {
+  if (limit === undefined) {
     return;
   }
-  const value = {};
-  if (limit !== undefined)
-    value.limit = limit;
-  if (interleavedField !== undefined)
-    value.interleavedField = interleavedField;
+  const value = { limit };
   cache.set(key, value);
   const modes = model?.experimental?.modes;
   if (modes && typeof modes === "object") {
@@ -158027,7 +159037,7 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync2(modelsJsonPath)) {
+    if (existsSync4(modelsJsonPath)) {
       fileFound = true;
       const raw = readFileSync(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
@@ -158044,7 +159054,7 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync2(configPath)) {
+    if (configPath && existsSync4(configPath)) {
       let raw = readFileSync(configPath, "utf-8");
       raw = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/.*$/gm, (match) => match.startsWith('"') ? match : "");
       const config2 = JSON.parse(raw);
@@ -158078,22 +159088,6 @@ function getModelsDevContextLimit(providerID, modelID) {
   }
   return fileCache.get(key)?.limit;
 }
-function getModelsDevInterleavedField(providerID, modelID) {
-  const key = `${providerID}/${modelID}`;
-  if (apiCache) {
-    const fromApi = apiCache.get(key)?.interleavedField;
-    if (typeof fromApi === "string" && fromApi.length > 0) {
-      return fromApi;
-    }
-  }
-  const now = Date.now();
-  if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
-    fileLastAttempt = now;
-    fileCache = loadModelsDevMetadataFromFile();
-  }
-  const fromFile = fileCache.get(key)?.interleavedField;
-  return typeof fromFile === "string" && fromFile.length > 0 ? fromFile : undefined;
-}
 
 // ../plugin/src/hooks/magic-context/derive-budgets.ts
 var TRIGGER_BUDGET_PERCENTAGE = 0.05;
@@ -158387,15 +159381,15 @@ init_logger();
 
 // src/subagent-runner.ts
 import * as childProcess from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
-import { dirname, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname2, resolve as resolvePath } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 function resolveSubagentEntryPath() {
   try {
-    const here = dirname(fileURLToPath(import.meta.url));
+    const here = dirname2(fileURLToPath(import.meta.url));
     const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync3(candidate))
+    if (existsSync5(candidate))
       return candidate;
     return;
   } catch {
@@ -158941,7 +159935,7 @@ function deleteDreamState(db, key) {
 var LEASE_HOLDER_KEY = "dreaming_lease_holder";
 var LEASE_HEARTBEAT_KEY = "dreaming_lease_heartbeat";
 var LEASE_EXPIRY_KEY = "dreaming_lease_expiry";
-var LEASE_DURATION_MS = 2 * 60 * 1000;
+var LEASE_DURATION_MS2 = 2 * 60 * 1000;
 function getLeaseExpiry(db) {
   const value = getDreamState(db, LEASE_EXPIRY_KEY);
   if (!value) {
@@ -158968,7 +159962,7 @@ function acquireLease(db, holderId) {
     const now = Date.now();
     setDreamState(db, LEASE_HOLDER_KEY, holderId);
     setDreamState(db, LEASE_HEARTBEAT_KEY, String(now));
-    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS));
+    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS2));
     return true;
   })();
 }
@@ -158979,7 +159973,7 @@ function renewLease(db, holderId) {
     }
     const now = Date.now();
     setDreamState(db, LEASE_HEARTBEAT_KEY, String(now));
-    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS));
+    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS2));
     return true;
   })();
 }
@@ -158994,8 +159988,8 @@ function releaseLease(db, holderId) {
   })();
 }
 // ../plugin/src/features/magic-context/dreamer/runner.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join9 } from "node:path";
 
 // ../plugin/src/shared/index.ts
 init_logger();
@@ -159126,11 +160120,6 @@ function normalizeSDKResponse(response, fallback, options) {
   }
   return fallback;
 }
-// ../plugin/src/shared/record-type-guard.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // ../plugin/src/shared/assistant-message-extractor.ts
 function asSessionMessage(value) {
   if (!isRecord(value))
@@ -160393,11 +161382,11 @@ function countNewIds(beforeIds, afterIds) {
   return count;
 }
 function getOpenCodeDbPath2() {
-  return join7(getDataDir(), "opencode", "opencode.db");
+  return join9(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync4(dbPath)) {
+  if (!existsSync6(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -160647,8 +161636,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync4(join7(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync4(join7(docsDir, "STRUCTURE.md"))
+          architecture: existsSync6(join9(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync6(join9(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -162158,14 +163147,46 @@ function createScheduler(config2) {
 }
 
 // ../plugin/src/features/magic-context/tagger.ts
+var TOOL_COMPOSITE_KEY_SEP = "\x00";
+function makeToolCompositeKey(ownerMsgId, callId) {
+  return `${ownerMsgId}${TOOL_COMPOSITE_KEY_SEP}${callId}`;
+}
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
+var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
+var PROBE_DATA_VERSION_SQL = "PRAGMA main.data_version";
+var PROBE_TOTAL_CHANGES_SQL = "SELECT total_changes() AS tc";
+var probeDataVersionStatements = new WeakMap;
+var probeTotalChangesStatements = new WeakMap;
+function getProbeDataVersionStatement(db) {
+  let stmt = probeDataVersionStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(PROBE_DATA_VERSION_SQL);
+    probeDataVersionStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getProbeTotalChangesStatement(db) {
+  let stmt = probeTotalChangesStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(PROBE_TOTAL_CHANGES_SQL);
+    probeTotalChangesStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function isAssignmentRow(row) {
   if (row === null || typeof row !== "object") {
     return false;
   }
   const candidate = row;
-  return typeof candidate.message_id === "string" && typeof candidate.tag_number === "number";
+  if (typeof candidate.message_id !== "string")
+    return false;
+  if (typeof candidate.tag_number !== "number")
+    return false;
+  if (candidate.type !== "message" && candidate.type !== "tool" && candidate.type !== "file")
+    return false;
+  if (candidate.tool_owner_message_id !== null && typeof candidate.tool_owner_message_id !== "string")
+    return false;
+  return true;
 }
 var UPSERT_COUNTER_SQL = `
   INSERT INTO session_meta (session_id, counter, harness)
@@ -162199,6 +163220,7 @@ var MAX_TAG_ALLOC_RETRIES = 5;
 function createTagger() {
   const counters = new Map;
   const assignments = new Map;
+  const loadSignatures = new Map;
   function getSessionAssignments(sessionId) {
     let map2 = assignments.get(sessionId);
     if (!map2) {
@@ -162217,15 +163239,15 @@ function createTagger() {
     counters.set(sessionId, next);
     getUpsertCounterStatement(db).run(sessionId, next, getHarness());
   }
-  function assignTag(sessionId, messageId, type, byteSize2, db, reasoningByteSize = 0, toolName = null, inputByteSize = 0) {
+  function allocateTag(sessionId, messageId, type, byteSize2, db, reasoningByteSize, toolName, inputByteSize, toolOwnerMessageId, mapKey, dbExistingLookup) {
     const sessionAssignments = getSessionAssignments(sessionId);
-    const existing = sessionAssignments.get(messageId);
+    const existing = sessionAssignments.get(mapKey);
     if (existing !== undefined) {
       return existing;
     }
-    const dbExisting = getTagNumberByMessageId(db, sessionId, messageId);
+    const dbExisting = dbExistingLookup();
     if (dbExisting !== null) {
-      sessionAssignments.set(messageId, dbExisting);
+      sessionAssignments.set(mapKey, dbExisting);
       syncCounterAtLeast(sessionId, db, dbExisting);
       return dbExisting;
     }
@@ -162235,16 +163257,16 @@ function createTagger() {
       const next = Math.max(memCounter, dbMax) + 1;
       try {
         db.transaction(() => {
-          insertTag(db, sessionId, messageId, type, byteSize2, next, reasoningByteSize, toolName, inputByteSize);
+          insertTag(db, sessionId, messageId, type, byteSize2, next, reasoningByteSize, toolName, inputByteSize, toolOwnerMessageId);
           getUpsertCounterStatement(db).run(sessionId, next, getHarness());
         })();
       } catch (error48) {
         if (!isUniqueConstraintError(error48)) {
           throw error48;
         }
-        const racedRow = getTagNumberByMessageId(db, sessionId, messageId);
+        const racedRow = dbExistingLookup();
         if (racedRow !== null) {
-          sessionAssignments.set(messageId, racedRow);
+          sessionAssignments.set(mapKey, racedRow);
           syncCounterAtLeast(sessionId, db, racedRow);
           return racedRow;
         }
@@ -162253,51 +163275,124 @@ function createTagger() {
         continue;
       }
       counters.set(sessionId, next);
-      sessionAssignments.set(messageId, next);
+      sessionAssignments.set(mapKey, next);
       return next;
     }
-    throw new Error(`tagger.assignTag: failed to allocate tag for session=${sessionId} message=${messageId} after ${MAX_TAG_ALLOC_RETRIES} retries`);
+    throw new Error(`tagger.allocateTag: failed to allocate tag for session=${sessionId} key=${mapKey} after ${MAX_TAG_ALLOC_RETRIES} retries`);
   }
-  function getTag(sessionId, messageId) {
+  function assignTag(sessionId, messageId, type, byteSize2, db, reasoningByteSize = 0, toolName = null, inputByteSize = 0) {
+    if (type === "tool") {
+      throw new Error("tagger.assignTag: type='tool' is forbidden — use assignToolTag(sessionId, callId, ownerMsgId, ...)");
+    }
+    return allocateTag(sessionId, messageId, type, byteSize2, db, reasoningByteSize, toolName, inputByteSize, null, messageId, () => getTagNumberByMessageId(db, sessionId, messageId));
+  }
+  function assignToolTag(sessionId, callId, ownerMsgId, byteSize2, db, reasoningByteSize = 0, toolName = null, inputByteSize = 0) {
+    const compositeKey = makeToolCompositeKey(ownerMsgId, callId);
+    const sessionAssignments = getSessionAssignments(sessionId);
+    const existing = sessionAssignments.get(compositeKey);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const dbHit = getToolTagNumberByOwner(db, sessionId, callId, ownerMsgId);
+    if (dbHit !== null) {
+      sessionAssignments.set(compositeKey, dbHit);
+      syncCounterAtLeast(sessionId, db, dbHit);
+      return dbHit;
+    }
+    for (let attempt = 0;attempt < MAX_TAG_ALLOC_RETRIES; attempt += 1) {
+      const orphan = getNullOwnerToolTag(db, sessionId, callId);
+      if (orphan === null)
+        break;
+      const claimed = adoptNullOwnerToolTag(db, orphan.id, ownerMsgId);
+      if (claimed) {
+        sessionAssignments.set(compositeKey, orphan.tagNumber);
+        syncCounterAtLeast(sessionId, db, orphan.tagNumber);
+        return orphan.tagNumber;
+      }
+      const recheck = getToolTagNumberByOwner(db, sessionId, callId, ownerMsgId);
+      if (recheck !== null) {
+        sessionAssignments.set(compositeKey, recheck);
+        syncCounterAtLeast(sessionId, db, recheck);
+        return recheck;
+      }
+    }
+    return allocateTag(sessionId, callId, "tool", byteSize2, db, reasoningByteSize, toolName, inputByteSize, ownerMsgId, compositeKey, () => getToolTagNumberByOwner(db, sessionId, callId, ownerMsgId));
+  }
+  function getTag(sessionId, messageId, _type) {
     return assignments.get(sessionId)?.get(messageId);
   }
+  function getToolTag(sessionId, callId, ownerMsgId) {
+    return assignments.get(sessionId)?.get(makeToolCompositeKey(ownerMsgId, callId));
+  }
   function bindTag(sessionId, messageId, tagNumber) {
     getSessionAssignments(sessionId).set(messageId, tagNumber);
   }
+  function bindToolTag(sessionId, callId, ownerMsgId, tagNumber) {
+    getSessionAssignments(sessionId).set(makeToolCompositeKey(ownerMsgId, callId), tagNumber);
+  }
   function getAssignments(sessionId) {
     return getSessionAssignments(sessionId);
   }
   function resetCounter(sessionId, db) {
     counters.set(sessionId, 0);
     assignments.delete(sessionId);
+    loadSignatures.delete(sessionId);
     getResetCounterStatement(db).run(sessionId, getHarness());
   }
   function getCounter(sessionId) {
     return counters.get(sessionId) ?? 0;
   }
+  function probeSignature(db) {
+    const dvRow = getProbeDataVersionStatement(db).get();
+    const tcRow = getProbeTotalChangesStatement(db).get();
+    return {
+      dataVersion: dvRow?.data_version ?? 0,
+      totalChanges: tcRow?.tc ?? 0
+    };
+  }
   function initFromDb(sessionId, db) {
+    const probe = probeSignature(db);
+    const cached2 = loadSignatures.get(sessionId);
+    if (cached2 !== undefined && cached2.db === db && cached2.dataVersion === probe.dataVersion && cached2.totalChanges === probe.totalChanges) {
+      return;
+    }
     const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
     const assignmentRows = db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId).filter(isAssignmentRow);
     const sessionAssignments = getSessionAssignments(sessionId);
     sessionAssignments.clear();
     let maxTagNumber = 0;
     for (const assignment of assignmentRows) {
-      sessionAssignments.set(assignment.message_id, assignment.tag_number);
+      if (assignment.type === "tool") {
+        if (assignment.tool_owner_message_id !== null) {
+          sessionAssignments.set(makeToolCompositeKey(assignment.tool_owner_message_id, assignment.message_id), assignment.tag_number);
+        }
+      } else {
+        sessionAssignments.set(assignment.message_id, assignment.tag_number);
+      }
       if (assignment.tag_number > maxTagNumber) {
         maxTagNumber = assignment.tag_number;
       }
     }
     const counter = Math.max(row?.counter ?? 0, maxTagNumber, counters.get(sessionId) ?? 0);
     counters.set(sessionId, counter);
+    loadSignatures.set(sessionId, {
+      db,
+      dataVersion: probe.dataVersion,
+      totalChanges: probe.totalChanges
+    });
   }
   function cleanup(sessionId) {
     counters.delete(sessionId);
     assignments.delete(sessionId);
+    loadSignatures.delete(sessionId);
   }
   return {
     assignTag,
+    assignToolTag,
     getTag,
+    getToolTag,
     bindTag,
+    bindToolTag,
     getAssignments,
     resetCounter,
     getCounter,
@@ -163310,7 +164405,7 @@ function createNudger(config2) {
     }
     const largest = formatLargestTags(topNFn(db, sessionId, 3));
     const protectedCount = config2.protected_tags;
-    const activeTags = (preloadedTags ?? getTagsBySession(db, sessionId)).filter((t) => t.status === "active");
+    const activeTags = preloadedTags ? preloadedTags.filter((t) => t.status === "active") : getActiveTagsBySession(db, sessionId);
     const highestProtected = activeTags.map((t) => t.tagNumber).sort((a, b) => b - a).slice(0, protectedCount)[0];
     const protectedHint = highestProtected ? ` Tags §${highestProtected}§ and above are protected (last ${protectedCount}) — You MUST NOT try to reduce those.` : "";
     const oldToolHint = formatOldToolTags(activeTags, protectedCount, 5);
@@ -163401,7 +164496,7 @@ function estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags)
   if (pendingDrops.length === 0) {
     return null;
   }
-  const activeTags = (preloadedTags ?? getTagsBySession(db, sessionId)).filter((t) => t.status === "active");
+  const activeTags = preloadedTags ? preloadedTags.filter((t) => t.status === "active") : getActiveTagsBySession(db, sessionId);
   const totalActiveBytes = activeTags.reduce((sum, t) => sum + t.byteSize, 0);
   if (totalActiveBytes === 0) {
     return null;
@@ -163412,15 +164507,6 @@ function estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags)
   return contextUsage.percentage * (1 - dropRatio);
 }
 
-// ../plugin/src/hooks/magic-context/reasoning-capability.ts
-function modelRequiresInterleavedReasoning(model) {
-  if (!model?.providerID || !model?.modelID) {
-    return false;
-  }
-  const field = getModelsDevInterleavedField(model.providerID, model.modelID);
-  return typeof field === "string" && field.length > 0;
-}
-
 // src/context-handler.ts
 init_logger();
 
@@ -163429,107 +164515,105 @@ function tagTranscript(sessionId, transcript, tagger, db, options = {}) {
   const skipPrefixInjection = options.skipPrefixInjection === true;
   const targets = new Map;
   const toolAggregates = new Map;
-  db.transaction(() => {
-    for (let msgIndex = 0;msgIndex < transcript.messages.length; msgIndex += 1) {
-      const message = transcript.messages[msgIndex];
-      if (message === undefined)
+  for (let msgIndex = 0;msgIndex < transcript.messages.length; msgIndex += 1) {
+    const message = transcript.messages[msgIndex];
+    if (message === undefined)
+      continue;
+    const messageId = message.info.id;
+    let textOrdinal = 0;
+    for (let partIndex = 0;partIndex < message.parts.length; partIndex += 1) {
+      const part = message.parts[partIndex];
+      if (part === undefined)
         continue;
-      const messageId = message.info.id;
-      let textOrdinal = 0;
-      for (let partIndex = 0;partIndex < message.parts.length; partIndex += 1) {
-        const part = message.parts[partIndex];
-        if (part === undefined)
+      if (part.kind === "text") {
+        if (messageId === undefined) {
+          textOrdinal += 1;
           continue;
-        if (part.kind === "text") {
-          if (messageId === undefined) {
-            textOrdinal += 1;
-            continue;
-          }
-          tagTextPart({
+        }
+        tagTextPart({
+          sessionId,
+          message,
+          messageId,
+          msgIndex,
+          textOrdinal,
+          part,
+          tagger,
+          db,
+          targets,
+          skipPrefixInjection
+        });
+        textOrdinal += 1;
+        continue;
+      }
+      if (part.kind === "tool_use" || part.kind === "tool_result") {
+        if (messageId === undefined)
+          continue;
+        const callId = part.id;
+        const text = part.getText() ?? "";
+        const meta3 = part.getToolMetadata();
+        if (typeof callId !== "string" || callId.length === 0) {
+          tagToolPart({
             sessionId,
             message,
             messageId,
             msgIndex,
-            textOrdinal,
+            partIndex,
             part,
             tagger,
             db,
             targets,
             skipPrefixInjection
           });
-          textOrdinal += 1;
           continue;
         }
-        if (part.kind === "tool_use" || part.kind === "tool_result") {
-          if (messageId === undefined)
-            continue;
-          const callId = part.id;
-          const text = part.getText() ?? "";
-          const meta3 = part.getToolMetadata();
-          if (typeof callId !== "string" || callId.length === 0) {
-            tagToolPart({
-              sessionId,
-              message,
-              messageId,
-              msgIndex,
-              partIndex,
-              part,
-              tagger,
-              db,
-              targets,
-              skipPrefixInjection
-            });
-            continue;
+        const existing = toolAggregates.get(callId);
+        if (existing) {
+          existing.occurrences.push({
+            message,
+            part,
+            kind: part.kind
+          });
+          const newByteSize = byteSize(text);
+          if (newByteSize > existing.maxByteSize) {
+            existing.maxByteSize = newByteSize;
+            updateTagByteSize(db, sessionId, existing.tagId, newByteSize);
           }
-          const existing = toolAggregates.get(callId);
-          if (existing) {
-            existing.occurrences.push({
-              message,
-              part,
-              kind: part.kind
-            });
-            const newByteSize = byteSize(text);
-            if (newByteSize > existing.maxByteSize) {
-              existing.maxByteSize = newByteSize;
-              updateTagByteSize(db, sessionId, existing.tagId, newByteSize);
-            }
-            if (existing.toolName === null && meta3.toolName) {
-              existing.toolName = meta3.toolName;
-            }
-            if (existing.inputByteSize === 0 && part.kind === "tool_use" && meta3.inputByteSize > 0) {
-              existing.inputByteSize = meta3.inputByteSize;
-              updateTagInputByteSize(db, sessionId, existing.tagId, meta3.inputByteSize);
-            }
-            if (!skipPrefixInjection && part.kind === "tool_result") {
-              part.setText(prependTag(existing.tagId, text));
-            }
-            targets.set(existing.tagId, buildAggregateTarget(existing.tagId, existing.occurrences));
-          } else {
-            const tagId = tagger.assignTag(sessionId, callId, "tool", byteSize(text), db, 0, meta3.toolName ?? null, meta3.inputByteSize);
-            const aggregate = {
-              callId,
-              tagId,
-              occurrences: [
-                {
-                  message,
-                  part,
-                  kind: part.kind
-                }
-              ],
-              maxByteSize: byteSize(text),
-              toolName: meta3.toolName ?? null,
-              inputByteSize: part.kind === "tool_use" ? meta3.inputByteSize : 0
-            };
-            toolAggregates.set(callId, aggregate);
-            if (!skipPrefixInjection && part.kind === "tool_result") {
-              part.setText(prependTag(tagId, text));
-            }
-            targets.set(tagId, buildAggregateTarget(tagId, aggregate.occurrences));
+          if (existing.toolName === null && meta3.toolName) {
+            existing.toolName = meta3.toolName;
+          }
+          if (existing.inputByteSize === 0 && part.kind === "tool_use" && meta3.inputByteSize > 0) {
+            existing.inputByteSize = meta3.inputByteSize;
+            updateTagInputByteSize(db, sessionId, existing.tagId, meta3.inputByteSize);
+          }
+          if (!skipPrefixInjection && part.kind === "tool_result") {
+            part.setText(prependTag(existing.tagId, text));
+          }
+          targets.set(existing.tagId, buildAggregateTarget(existing.tagId, existing.occurrences));
+        } else {
+          const tagId = tagger.assignToolTag(sessionId, callId, messageId, byteSize(text), db, 0, meta3.toolName ?? null, meta3.inputByteSize);
+          const aggregate = {
+            callId,
+            tagId,
+            occurrences: [
+              {
+                message,
+                part,
+                kind: part.kind
+              }
+            ],
+            maxByteSize: byteSize(text),
+            toolName: meta3.toolName ?? null,
+            inputByteSize: part.kind === "tool_use" ? meta3.inputByteSize : 0
+          };
+          toolAggregates.set(callId, aggregate);
+          if (!skipPrefixInjection && part.kind === "tool_result") {
+            part.setText(prependTag(tagId, text));
           }
+          targets.set(tagId, buildAggregateTarget(tagId, aggregate.occurrences));
         }
       }
     }
-  })();
+  }
   return { targets };
 }
 function tagTextPart(args) {
@@ -163550,7 +164634,7 @@ function tagToolPart(args) {
   const contentId = stableId ?? `${args.messageId}:t${args.partIndex}`;
   const text = args.part.getText() ?? "";
   const meta3 = args.part.getToolMetadata();
-  const tagId = args.tagger.assignTag(args.sessionId, contentId, "tool", byteSize(text), args.db, 0, meta3.toolName ?? null, meta3.inputByteSize);
+  const tagId = args.tagger.assignToolTag(args.sessionId, contentId, contentId, byteSize(text), args.db, 0, meta3.toolName ?? null, meta3.inputByteSize);
   if (!args.skipPrefixInjection && args.part.kind === "tool_result") {
     const tagged = prependTag(tagId, text);
     args.part.setText(tagged);
@@ -163790,11 +164874,7 @@ function getMessageOrdinal(value) {
 }
 async function getSemanticScores(args) {
   const semanticScores = new Map;
-  if (!args.embeddingEnabled || !args.isEmbeddingRuntimeEnabled() || args.memories.length === 0) {
-    return semanticScores;
-  }
-  const queryEmbedding = await args.embedQuery(args.query, args.signal);
-  if (!queryEmbedding) {
+  if (!args.queryEmbedding || args.memories.length === 0) {
     return semanticScores;
   }
   const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
@@ -163808,7 +164888,7 @@ async function getSemanticScores(args) {
     if (!memoryEmbedding) {
       continue;
     }
-    semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(queryEmbedding, memoryEmbedding)));
+    semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(args.queryEmbedding, memoryEmbedding)));
   }
   return semanticScores;
 }
@@ -163904,12 +164984,8 @@ async function searchMemories(args) {
   const semanticScores = await getSemanticScores({
     db: args.db,
     projectPath: args.projectPath,
-    query: args.query,
     memories: semanticCandidates,
-    embeddingEnabled: args.embeddingEnabled,
-    embedQuery: args.embedQuery,
-    isEmbeddingRuntimeEnabled: args.isEmbeddingRuntimeEnabled,
-    signal: args.signal
+    queryEmbedding: args.queryEmbedding
   });
   return mergeMemoryResults({
     memories,
@@ -163925,7 +165001,6 @@ function linearDecayScore(rank, total) {
   return Math.max(0, 1 - rank / total);
 }
 function searchMessages(args) {
-  ensureMessagesIndexed(args.db, args.sessionId, args.readMessages);
   const sanitizedQuery = sanitizeFtsQuery(args.query.trim());
   if (sanitizedQuery.length === 0) {
     return [];
@@ -163996,20 +165071,12 @@ function toGitCommitResult(hit) {
     matchType: hit.matchType
   };
 }
-async function searchGitCommitsAsync(args) {
+function searchGitCommits(args) {
   if (args.limit <= 0)
     return [];
-  let queryEmbedding = null;
-  if (args.embeddingEnabled && args.isEmbeddingRuntimeEnabled()) {
-    try {
-      queryEmbedding = await args.embedQuery(args.query, args.signal);
-    } catch (error48) {
-      log(`[search] git commit query embedding failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
-    }
-  }
   const hits = searchGitCommitsSync(args.db, args.projectPath, args.query, {
     limit: args.limit,
-    queryEmbedding
+    queryEmbedding: args.queryEmbedding
   });
   return hits.map(toGitCommitResult);
 }
@@ -164040,37 +165107,37 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const runMemory = activeSources.has("memory") && (options.memoryEnabled ?? true);
   const runMessages = activeSources.has("message");
   const runGitCommits = activeSources.has("git_commit") && gitCommitsEnabled;
-  const [memoryResults, messageResults, gitCommitResults] = await Promise.all([
+  const needsEmbedding = (runMemory || runGitCommits) && embeddingEnabled && isEmbeddingRuntimeEnabled();
+  const queryEmbeddingPromise = needsEmbedding ? embedQuery(trimmedQuery, options.signal).catch((error48) => {
+    log(`[search] query embedding failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    return null;
+  }) : Promise.resolve(null);
+  await Promise.resolve();
+  const messageResults = runMessages ? searchMessages({
+    db,
+    sessionId,
+    query: trimmedQuery,
+    limit: tierLimit,
+    maxOrdinal: options.maxMessageOrdinal
+  }) : [];
+  const queryEmbedding = await queryEmbeddingPromise;
+  const [memoryResults, gitCommitResults] = await Promise.all([
     runMemory ? searchMemories({
       db,
       projectPath,
       query: trimmedQuery,
       limit: tierLimit,
       memoryEnabled: true,
-      embeddingEnabled,
-      embedQuery,
-      isEmbeddingRuntimeEnabled,
-      visibleMemoryIds: options.visibleMemoryIds,
-      signal: options.signal
+      queryEmbedding,
+      visibleMemoryIds: options.visibleMemoryIds
     }) : Promise.resolve([]),
-    runMessages ? Promise.resolve(searchMessages({
-      db,
-      sessionId,
-      query: trimmedQuery,
-      limit: tierLimit,
-      readMessages: options.readMessages ?? readRawSessionMessages,
-      maxOrdinal: options.maxMessageOrdinal
-    })) : Promise.resolve([]),
-    runGitCommits ? searchGitCommitsAsync({
+    runGitCommits ? Promise.resolve(searchGitCommits({
       db,
       projectPath,
       query: trimmedQuery,
       limit: tierLimit,
-      embeddingEnabled,
-      embedQuery,
-      isEmbeddingRuntimeEnabled,
-      signal: options.signal
-    }) : Promise.resolve([])
+      queryEmbedding
+    })) : Promise.resolve([])
   ]);
   const results = [...memoryResults, ...messageResults, ...gitCommitResults].sort(compareUnifiedResults).slice(0, limit);
   const countRetrievals = options.countRetrievals ?? true;
@@ -164487,8 +165554,8 @@ function collectStaleReduceCallIds(messages, messageIdToMaxTag, toolAgeCutoff) {
   return staleCallIds;
 }
 function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, preloadedTags) {
-  const tags = preloadedTags ?? getTagsBySession(db, sessionId);
-  const maxTag = tags.reduce((max, t) => Math.max(max, t.tagNumber), 0);
+  const tags = preloadedTags ?? getActiveTagsBySession(db, sessionId);
+  const maxTag = getMaxTagNumberBySession(db, sessionId);
   const toolAgeCutoff = maxTag - config2.autoDropToolAge;
   const protectedCutoff = maxTag - config2.protectedTags;
   let droppedTools = 0;
@@ -165601,12 +166668,24 @@ function clearPiCompressorState(sessionId) {
 init_logger();
 function queueDropsForCompartmentalizedMessages(db, sessionId, upToMessageIndex) {
   const tags = getTagsBySession(db, sessionId);
-  const rawTagKeys = new Set(getRawSessionTagKeysThrough(sessionId, upToMessageIndex));
+  const { messageFileKeys, toolObservations } = getRawSessionTagKeysThrough(sessionId, upToMessageIndex);
   let dropsQueued = 0;
   for (const tag of tags) {
     if (tag.status !== "active")
       continue;
-    if (rawTagKeys.has(tag.messageId)) {
+    if (tag.type === "tool") {
+      const observedOwners = toolObservations.get(tag.messageId);
+      if (!observedOwners)
+        continue;
+      if (tag.toolOwnerMessageId !== null) {
+        if (!observedOwners.has(tag.toolOwnerMessageId))
+          continue;
+      }
+      queuePendingOp(db, sessionId, tag.tagNumber, "drop");
+      dropsQueued += 1;
+      continue;
+    }
+    if (messageFileKeys.has(tag.messageId)) {
       queuePendingOp(db, sessionId, tag.tagNumber, "drop");
       dropsQueued += 1;
     }
@@ -165812,28 +166891,28 @@ function getReducedRecompTokenBudget(currentBudget) {
 }
 
 // ../plugin/src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync3, unlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync as mkdirSync4, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000;
-var HISTORIAN_STATE_DIR = join8(tmpdir2(), "magic-context-historian");
+var HISTORIAN_STATE_DIR = join10(tmpdir2(), "magic-context-historian");
 function maybeWriteHistorianStateFile(sessionId, existingState) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
-    mkdirSync3(HISTORIAN_STATE_DIR, { recursive: true });
-    const path4 = join8(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
-    writeFileSync(path4, existingState, "utf8");
-    return path4;
+    mkdirSync4(HISTORIAN_STATE_DIR, { recursive: true });
+    const path5 = join10(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
+    writeFileSync2(path5, existingState, "utf8");
+    return path5;
   } catch {
     return;
   }
 }
-function cleanupHistorianStateFile(path4) {
-  if (!path4)
+function cleanupHistorianStateFile(path5) {
+  if (!path5)
     return;
   try {
-    unlinkSync(path4);
+    unlinkSync(path5);
   } catch {}
 }
 
@@ -165932,24 +167011,12 @@ ${chunk.text}`, { stateFilePath });
       const maxExistingSequence = priorCompartments.reduce((max, c) => c.sequence > max ? c.sequence : max, -1);
       const sequenceOffset = priorCompartments.length === 0 ? 0 : maxExistingSequence + 1;
       sessionLog(sessionId, `pi-historian: invoking subagent (model=${historianModel}, chunk=${chunk.startIndex}-${chunk.endIndex}, ${chunk.messageCount} msgs, ~${chunk.tokenEstimate} tokens)`);
+      const traceRawEvents = process.env.MC_PI_HISTORIAN_TRACE === "1";
       const buildProgressLogger = (passLabel) => {
         return (event) => {
           try {
-            if (event.type === "raw_event") {
-              let serialized;
-              try {
-                serialized = JSON.stringify(event.event);
-              } catch {
-                serialized = "[unserializable]";
-              }
-              if (serialized.length > 4000) {
-                serialized = `${serialized.slice(0, 4000)}…[truncated ${serialized.length - 4000} chars]`;
-              }
-              sessionLog(sessionId, `pi-historian[${passLabel}] raw_event @${event.ms}ms type=${event.eventType ?? "?"}: ${serialized}`);
-            } else if (event.type === "spawned") {
+            if (event.type === "spawned") {
               sessionLog(sessionId, `pi-historian[${passLabel}] spawned pid=${event.pid ?? "?"} argv=${event.argv.length} args`);
-            } else if (event.type === "first_event") {
-              sessionLog(sessionId, `pi-historian[${passLabel}] first_event @${event.ms}ms type=${event.eventType}`);
             } else if (event.type === "terminal") {
               sessionLog(sessionId, `pi-historian[${passLabel}] terminal @${event.ms}ms stopReason=${event.stopReason ?? "?"} textLen=${event.textLength} hasToolCall=${event.hasToolCall}`);
             } else if (event.type === "stderr") {
@@ -165959,6 +167026,21 @@ ${chunk.text}`, { stateFilePath });
               }
             } else if (event.type === "child_exit") {
               sessionLog(sessionId, `pi-historian[${passLabel}] child_exit @${event.ms}ms code=${event.code} signal=${event.signal}`);
+            } else if (traceRawEvents) {
+              if (event.type === "raw_event") {
+                let serialized;
+                try {
+                  serialized = JSON.stringify(event.event);
+                } catch {
+                  serialized = "[unserializable]";
+                }
+                if (serialized.length > 4000) {
+                  serialized = `${serialized.slice(0, 4000)}…[truncated ${serialized.length - 4000} chars]`;
+                }
+                sessionLog(sessionId, `pi-historian[${passLabel}] raw_event @${event.ms}ms type=${event.eventType ?? "?"}: ${serialized}`);
+              } else if (event.type === "first_event") {
+                sessionLog(sessionId, `pi-historian[${passLabel}] first_event @${event.ms}ms type=${event.eventType}`);
+              }
             }
           } catch {}
         };
@@ -166373,16 +167455,7 @@ function clearOldReasoningPi(args) {
   return { cleared, newWatermark };
 }
 function replayClearedReasoningPi(args) {
-  const {
-    db,
-    sessionId,
-    messages,
-    messageIdToMaxTag,
-    piMessageStableId,
-    skipTypedReasoningCleanup
-  } = args;
-  if (skipTypedReasoningCleanup)
-    return 0;
+  const { db, sessionId, messages, messageIdToMaxTag, piMessageStableId } = args;
   const meta3 = getOrCreateSessionMeta(db, sessionId);
   const watermark = meta3.clearedReasoningThroughTag ?? 0;
   if (watermark <= 0)
@@ -167082,19 +168155,6 @@ var TOOL_HEAVY_TURN_REMINDER_THRESHOLD = 5;
 var TOOL_HEAVY_TURN_REMINDER_TEXT = `
 
 <instruction name="ctx_reduce_turn_cleanup">Also drop via \`ctx_reduce\` things you don't need anymore from the last turn before continuing.</instruction>`;
-function resolveLiveModelId(ctx) {
-  const model = ctx.model;
-  if (!model)
-    return;
-  const providerID = model.provider;
-  const modelID = model.id;
-  if (typeof providerID !== "string" || typeof modelID !== "string") {
-    return;
-  }
-  if (providerID.length === 0 || modelID.length === 0)
-    return;
-  return { providerID, modelID };
-}
 var DEFAULT_CLEAR_REASONING_AGE = 50;
 var lastEmergencyNotificationAtMs = new Map;
 var EMERGENCY_NOTIFICATION_COOLDOWN_MS = 60000;
@@ -167107,6 +168167,9 @@ var recentReduceBySession = new Map;
 var liveModelBySession = new Map;
 var toolUsageSinceUserTurn = new Map;
 var latestUserMessageBySession = new Map;
+function readPiSessionMessageById(ctx, messageId) {
+  return readPiSessionMessages(ctx).find((message) => message.id === messageId) ?? null;
+}
 function signalPiHistoryRefresh(sessionId) {
   historyRefreshSessions.add(sessionId);
 }
@@ -167307,8 +168370,15 @@ function registerPiContextHandler(pi, options) {
         return;
       }
       sessionIdForError = sessionId;
+      const rawMessageProvider = {
+        readMessages: () => readPiSessionMessages(ctx),
+        readMessageById: (messageId) => readPiSessionMessageById(ctx, messageId)
+      };
+      setRawMessageProvider(sessionId, rawMessageProvider);
+      scheduleReconciliation(options.db, sessionId, readRawSessionMessages);
       const latestUserId = findLatestUserMessageIdPi(event.messages);
       if (latestUserId) {
+        scheduleIncrementalIndex(options.db, sessionId, latestUserId, (_sessionId, messageId) => readPiSessionMessageById(ctx, messageId));
         const previousUserId = latestUserMessageBySession.get(sessionId);
         if (previousUserId !== latestUserId) {
           onPiNewUserMessage({ db: options.db, sessionId });
@@ -167371,8 +168441,6 @@ function registerPiContextHandler(pi, options) {
       }
       const isCacheBusting = historyRefreshSessions.has(sessionId);
       sessionLog(sessionId, `pi transform: usage=${usagePercentage.toFixed(1)}% (${usageInputTokens} tokens, limit=${usageContextLimit ?? "?"}) decision=${schedulerDecision}${forceMaterialization ? " force=true" : ""}${isEmergency ? " EMERGENCY=true" : ""}${isCacheBusting ? " busting=true" : ""}`);
-      const liveModelId = resolveLiveModelId(ctx);
-      const skipTypedReasoningCleanup = liveModelId ? modelRequiresInterleavedReasoning(liveModelId) : false;
       const entryIds = collectMessageEntryIds(ctx, event.messages.length, sessionId);
       const result = await runPipeline({
         db: options.db,
@@ -167389,8 +168457,7 @@ function registerPiContextHandler(pi, options) {
         forceMaterialization: forceMaterialization || isEmergency,
         isCacheBusting,
         reasoningClearing: {
-          clearReasoningAge: options.heuristics?.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE,
-          skipTypedReasoningCleanup
+          clearReasoningAge: options.heuristics?.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE
         },
         temporalAwareness: options.injection?.temporalAwareness === true
       });
@@ -167738,7 +168805,10 @@ async function runPipeline(args) {
       consumePendingMaterialization(args.sessionId);
     }
   }
-  applyFlushedStatuses(args.sessionId, args.db, targets);
+  const flushedSliceTags = getTagsByNumbers(args.db, args.sessionId, [
+    ...targets.keys()
+  ]);
+  applyFlushedStatuses(args.sessionId, args.db, targets, flushedSliceTags);
   const messageIdToMaxTag = buildMessageIdToMaxTag(targets);
   if (args.reasoningClearing) {
     try {
@@ -167747,8 +168817,7 @@ async function runPipeline(args) {
         sessionId: args.sessionId,
         messages: args.messages,
         messageIdToMaxTag,
-        piMessageStableId,
-        skipTypedReasoningCleanup: args.reasoningClearing.skipTypedReasoningCleanup
+        piMessageStableId
       });
       const inlineReplay = replayStrippedInlineThinkingPi({
         db: args.db,
@@ -167765,7 +168834,8 @@ async function runPipeline(args) {
     }
   }
   try {
-    const tags = getTagsBySession(args.db, args.sessionId);
+    const targetTagNumbers = [...targets.keys()];
+    const tags = getTagsByNumbers(args.db, args.sessionId, targetTagNumbers);
     const replayed = replayCavemanCompression(args.sessionId, args.db, targets, tags);
     if (replayed > 0) {
       sessionLog(args.sessionId, `pi caveman replay: ${replayed} tags re-compressed from source`);
@@ -167790,7 +168860,7 @@ async function runPipeline(args) {
       sessionLog(args.sessionId, `pi heuristic cleanup failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  if (args.reasoningClearing && !args.reasoningClearing.skipTypedReasoningCleanup && (args.schedulerDecision === "execute" || args.forceMaterialization === true)) {
+  if (args.reasoningClearing && (args.schedulerDecision === "execute" || args.forceMaterialization === true)) {
     try {
       const clearOutcome = clearOldReasoningPi({
         messages: args.messages,
@@ -167859,7 +168929,7 @@ function applyRollingNudge(args) {
     inputTokens: piUsage.tokens,
     contextLimit: piUsage.contextWindow
   };
-  const tags = getTagsBySession(db, sessionId);
+  const tags = getActiveTagsBySession(db, sessionId);
   const messagesSinceLastUser = countMessagesSinceLastUserPi(messages);
   const nudge = nudgerFn(sessionId, usage, db, getTopNBySize, tags, messagesSinceLastUser, undefined);
   if (!nudge)
@@ -167989,6 +169059,7 @@ function clearContextHandlerSession(sessionId) {
   liveModelBySession.delete(sessionId);
   toolUsageSinceUserTurn.delete(sessionId);
   latestUserMessageBySession.delete(sessionId);
+  clearSessionTracking(sessionId);
   clearPiCompressorState(sessionId);
 }
 
@@ -168038,7 +169109,7 @@ init_logger();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
   const chars = [];
@@ -168059,7 +169130,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join9(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -168612,11 +169683,11 @@ async function runCompressorPass2(args) {
 }
 
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join12 } from "node:path";
 init_magic_context();
-var HISTORIAN_RESPONSE_DUMP_DIR = join10(tmpdir3(), "magic-context-historian");
+var HISTORIAN_RESPONSE_DUMP_DIR = join12(tmpdir3(), "magic-context-historian");
 var MAX_HISTORIAN_RETRIES = 2;
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
@@ -168857,11 +169928,11 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 }
 function dumpHistorianResponse(sessionId, label, text) {
   try {
-    mkdirSync4(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
+    mkdirSync5(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join10(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync2(dumpPath, text, "utf8");
+    const dumpPath = join12(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync3(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -169872,8 +170943,8 @@ function createPiRecompClient(args) {
 function readPathId(input) {
   if (typeof input !== "object" || input === null)
     return "";
-  const path4 = input.path;
-  return typeof path4?.id === "string" ? path4.id : "";
+  const path5 = input.path;
+  return typeof path5?.id === "string" ? path5.id : "";
 }
 function readBody(input) {
   if (typeof input !== "object" || input === null)
@@ -170028,7 +171099,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.16.2",
+  version: "0.17.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -170565,14 +171636,14 @@ function readHistorianState(db, sessionId, meta3) {
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, isAbsolute, resolve } from "node:path";
+import { dirname as dirname3, isAbsolute, resolve } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -170591,7 +171662,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname2(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname3(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -170613,7 +171684,7 @@ function substituteConfigVariables(input) {
     } else if (!isAbsolute(filePath)) {
       filePath = resolve(configDir, filePath);
     }
-    if (!existsSync5(filePath)) {
+    if (!existsSync7(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
@@ -170635,38 +171706,38 @@ function substituteConfigVariables(input) {
 var import_comment_json = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join11(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join13(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir4();
-  const basePath = join11(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join13(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path4) => existsSync6(path4));
+  return paths.find((path5) => existsSync8(path5));
 }
-function loadConfigFile(path4, scope) {
+function loadConfigFile(path5, scope) {
   try {
-    const rawText = readFileSync3(path4, "utf-8");
+    const rawText = readFileSync3(path5, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path4
+      configPath: path5
     });
     return {
-      path: path4,
+      path: path5,
       scope,
       config: import_comment_json.parse(substituted.text),
-      warnings: substituted.warnings.map((warning) => `${path4}: ${warning}`)
+      warnings: substituted.warnings.map((warning) => `${path5}: ${warning}`)
     };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     return {
-      path: path4,
+      path: path5,
       scope,
       config: {},
       warnings: [
-        `${path4}: failed to load config: ${message}; using defaults for this file.`
+        `${path5}: failed to load config: ${message}; using defaults for this file.`
       ]
     };
   }
@@ -170796,8 +171867,8 @@ function stripTagPrefixFromAssistantMessage(message) {
 
 // src/system-prompt.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync } from "node:fs";
-import { join as join12, resolve as resolve2, sep } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync4, realpathSync } from "node:fs";
+import { join as join14, resolve as resolve2, sep } from "node:path";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -170899,9 +171970,9 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join12(directory, filename);
+    const filePath = join14(directory, filename);
     try {
-      if (existsSync7(filePath)) {
+      if (existsSync9(filePath)) {
         const content = readFileSync4(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
@@ -170945,7 +172016,7 @@ function buildKeyFilesBlock(db, sessionId, directory, tokenBudget) {
         log(`[magic-context-pi] key file path escapes project root, skipping: ${entry.filePath}`);
         continue;
       }
-      if (!existsSync7(absPath))
+      if (!existsSync9(absPath))
         continue;
       let realPath;
       try {
@@ -176022,7 +177093,7 @@ function registerMagicContextTools(pi, opts) {
 }
 
 // src/index.ts
-var PREFIX = "[magic-context][pi]";
+var PREFIX2 = "[magic-context][pi]";
 function persistPiMessageEndModelMeta(args) {
   if (!args.message || typeof args.message !== "object")
     return;
@@ -176039,14 +177110,14 @@ function persistPiMessageEndModelMeta(args) {
   }
 }
 function info(message, data) {
-  log(`${PREFIX} ${message}`, data);
+  log(`${PREFIX2} ${message}`, data);
 }
 function warn(message, data) {
-  log(`${PREFIX} WARN ${message}`, data);
+  log(`${PREFIX2} WARN ${message}`, data);
 }
 var PLUGIN_VERSION = (() => {
   try {
-    const req = createRequire(import.meta.url);
+    const req = createRequire2(import.meta.url);
     return req("../package.json").version;
   } catch {
     return "0.0.0";
@@ -176127,7 +177198,7 @@ function resolveDreamerFromConfig(config2) {
 }
 async function src_default2(pi) {
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join13(storageDir, "context.db");
+  const dbPath = join15(storageDir, "context.db");
   let db;
   try {
     db = openDatabase();
@@ -176381,6 +177452,11 @@ ${block}` : event.systemPrompt;
       const sessionId = sm?.getSessionId?.();
       if (typeof sessionId !== "string" || sessionId.length === 0)
         return;
+      const rawMessages = readPiSessionMessages(ctx);
+      const latest = rawMessages[rawMessages.length - 1];
+      if (latest?.role === "assistant" && latest.id.length > 0) {
+        scheduleIncrementalIndex(db, sessionId, latest.id, () => latest);
+      }
       persistPiMessageEndModelMeta({
         db,
         sessionId,