@cortexkit/opencode-magic-context 0.16.2 → 0.17.0

package/dist/index.js

@@ -147149,6 +147149,74 @@ var init_read_session_formatting = __esm(() => {
   tokenizer = new src_default(exports_claude);
 });
 
+// src/features/magic-context/tool-definition-tokens.ts
+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);
+  }
+}
+function recordToolDefinition(providerID, modelID, agentName, toolID, description, parameters) {
+  if (!providerID || !modelID || !toolID)
+    return;
+  const key = keyFor(providerID, modelID, agentName);
+  let paramsText = "";
+  try {
+    paramsText = parameters === undefined ? "" : JSON.stringify(parameters);
+  } catch {
+    paramsText = "";
+  }
+  const tokens = estimateTokens(description ?? "") + estimateTokens(paramsText);
+  let inner = measurements.get(key);
+  if (!inner) {
+    inner = new Map;
+    measurements.set(key, inner);
+  }
+  inner.set(toolID, tokens);
+  if (persistenceDb) {
+    try {
+      const agent = agentName && agentName.length > 0 ? agentName : "default";
+      persistenceDb.prepare(`INSERT OR REPLACE INTO tool_definition_measurements
+                     (provider_id, model_id, agent_name, tool_id, token_count, recorded_at)
+                     VALUES (?, ?, ?, ?, ?, ?)`).run(providerID, modelID, agent, toolID, tokens, Date.now());
+    } catch {}
+  }
+}
+function getMeasuredToolDefinitionTokens(providerID, modelID, agentName) {
+  if (!providerID || !modelID)
+    return;
+  const inner = measurements.get(keyFor(providerID, modelID, agentName));
+  if (!inner || inner.size === 0)
+    return;
+  let total = 0;
+  for (const tokens of inner.values())
+    total += tokens;
+  return total;
+}
+var measurements, persistenceDb = null;
+var init_tool_definition_tokens = __esm(() => {
+  init_read_session_formatting();
+  measurements = new Map;
+});
+
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS((exports, module) => {
   (function webpackUniversalModuleDefinition(root, factory) {
@@ -155708,7 +155776,7 @@ function formatConflictShort(result) {
     "",
     ...result.reasons.map((r) => `• ${r}`),
     "",
-    "Fix: run `bunx --bun @cortexkit/opencode-magic-context@latest doctor`"
+    "Fix: run `npx @cortexkit/opencode-magic-context@latest doctor`"
   ];
   return lines.join(`
 `);
@@ -156108,14 +156176,334 @@ function safeString(value) {
   }
 }
 
+// ../../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 name2 = _readString(buffer2, offset, 100);
+    if (name2.length === 0) {
+      break;
+    }
+    if (nextExtendedHeader) {
+      const longName = nextExtendedHeader.path || nextExtendedHeader.linkpath;
+      if (longName) {
+        name2 = 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);
+    name2 = _sanitizePath(name2);
+    const meta3 = {
+      name: name2,
+      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(path3) {
+  let normalized = path3.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 (path3.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_dist2 = __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"
+  };
+});
+
+// src/shared/native-binding.ts
+var exports_native_binding = {};
+__export(exports_native_binding, {
+  resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
+});
+import { existsSync as existsSync7, mkdirSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { createRequire } from "node:module";
+import * as path3 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 = path3.dirname(pkgJsonPath);
+    const pkgJson = requireFn(pkgJsonPath);
+    const binaryPath = path3.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 path3.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 (existsSync7(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 (existsSync7(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`);
+    }
+    mkdirSync(path3.dirname(cachedPath), { recursive: true });
+    const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
+    writeFileSync3(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_dist2();
+  init_data_path();
+  init_logger();
+});
+
 // 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;
 });
 
@@ -156847,9 +157235,9 @@ __export(exports_read_session_db, {
   findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
   closeReadOnlySessionDb: () => closeReadOnlySessionDb
 });
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function getOpenCodeDbPath() {
-  return join10(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -156908,7 +157296,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'
@@ -156919,7 +157308,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);
@@ -156951,9 +157345,9 @@ function cosineSimilarity(a, b) {
 }
 
 // src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync } from "node:fs";
+import { mkdirSync as mkdirSync2 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
@@ -157087,15 +157481,15 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join12(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join13(getMagicContextStorageDir(), "models");
         try {
-          mkdirSync(modelCacheDir, { recursive: true });
+          mkdirSync2(modelCacheDir, { recursive: true });
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join12(modelCacheDir, ".load.lock");
+        const lockPath = join13(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -157666,7 +158060,7 @@ var init_storage_memory_fts = __esm(() => {
 // src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import path3 from "node:path";
+import path4 from "node:path";
 function getRootCommitHash(directory) {
   try {
     const hash2 = execSync("git rev-list --max-parents=0 HEAD", {
@@ -157683,12 +158077,12 @@ function getRootCommitHash(directory) {
   }
 }
 function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
+  const canonical = path4.resolve(directory);
   const hash2 = createHash2("md5").update(canonical).digest("hex").slice(0, 12);
   return `dir:${hash2}`;
 }
 function resolveProjectIdentity(directory) {
-  const resolved = path3.resolve(directory);
+  const resolved = path4.resolve(directory);
   const cached2 = resolvedCache.get(resolved);
   if (cached2 !== undefined) {
     return cached2;
@@ -157822,6 +158216,33 @@ function readRawSessionMessagesFromDb(db, sessionId) {
     };
   });
 }
+function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
+  const row = db.prepare("SELECT id, data, time_created FROM message WHERE session_id = ? AND id = ?").get(sessionId, messageId);
+  if (!row || !isRawMessageRow(row) || typeof row.time_created !== "number") {
+    return null;
+  }
+  const info = parseJsonRecord(row.data);
+  if (!info || info.summary === true && info.finish === "stop") {
+    return null;
+  }
+  const ordinalRow = db.prepare(`SELECT COUNT(*) AS ordinal FROM message
+             WHERE session_id = ?
+               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
+               AND (time_created < ? OR (time_created = ? AND id <= ?))`).get(sessionId, row.time_created, row.time_created, messageId);
+  const ordinal = typeof ordinalRow?.ordinal === "number" ? ordinalRow.ordinal : 0;
+  if (ordinal <= 0) {
+    return null;
+  }
+  const partRows = db.prepare("SELECT message_id, data FROM part WHERE session_id = ? AND message_id = ? ORDER BY time_created ASC, id ASC").all(sessionId, messageId).filter(isRawPartRow);
+  const role = typeof info.role === "string" ? info.role : "unknown";
+  return {
+    ordinal,
+    id: row.id,
+    role,
+    parts: partRows.map((part) => parseJsonUnknown(part.data))
+  };
+}
 
 // src/hooks/magic-context/tag-content-primitives.ts
 function byteSize(value) {
@@ -157881,86 +158302,339 @@ var init_tag_part_guards = __esm(() => {
   init_tag_content_primitives();
 });
 
-// src/hooks/magic-context/read-session-chunk.ts
-function cleanUserText(text) {
-  return removeSystemReminders(text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
+// src/hooks/magic-context/tool-drop-target.ts
+function isToolCallId(value) {
+  return typeof value === "string" && value.length > 0;
 }
-function withRawSessionMessageCache(fn) {
-  const outerCache = activeRawMessageCache;
-  if (!outerCache) {
-    activeRawMessageCache = new Map;
+function getToolContent(part) {
+  if (!isRecord(part))
+    return;
+  if (part.type === "tool" && isRecord(part.state)) {
+    return typeof part.state.output === "string" ? part.state.output : undefined;
   }
-  try {
-    return fn();
-  } finally {
-    if (!outerCache) {
-      activeRawMessageCache = null;
-    }
+  if (part.type === "tool_result") {
+    return typeof part.content === "string" ? part.content : undefined;
   }
+  return;
 }
-function readRawSessionMessages(sessionId) {
-  if (activeRawMessageCache) {
-    const cached2 = activeRawMessageCache.get(sessionId);
-    if (cached2) {
-      return cached2;
-    }
-    const messages = readRawSessionMessagesFromSource(sessionId);
-    activeRawMessageCache.set(sessionId, messages);
-    return messages;
+function setToolContent(part, content) {
+  if (!isRecord(part))
+    return;
+  if (part.type === "tool" && isRecord(part.state)) {
+    part.state.output = content;
+    return;
   }
-  return readRawSessionMessagesFromSource(sessionId);
-}
-function readRawSessionMessagesFromSource(sessionId) {
-  const provider2 = sessionProviders.get(sessionId);
-  if (provider2)
-    return provider2.readMessages();
-  return withReadOnlySessionDb((db) => readRawSessionMessagesFromDb(db, sessionId));
-}
-function getRawSessionMessageCount(sessionId) {
-  const provider2 = sessionProviders.get(sessionId);
-  if (provider2) {
-    if (provider2.getMessageCount)
-      return provider2.getMessageCount();
-    return provider2.readMessages().length;
+  if (part.type === "tool_result") {
+    part.content = content;
   }
-  return withReadOnlySessionDb((db) => getRawSessionMessageCountFromDb(db, sessionId));
 }
-function getRawSessionTagKeysThrough(sessionId, upToMessageIndex) {
-  const messages = readRawSessionMessages(sessionId);
-  const keys = [];
-  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}`);
-      }
-      if (isFilePart(part)) {
-        keys.push(`${message.id}:file${partIndex}`);
-      }
-      if (isToolPartWithOutput(part)) {
-        keys.push(part.callID);
+function truncateToolPart(part) {
+  if (!isRecord(part))
+    return;
+  if (part.type === "tool" && isRecord(part.state)) {
+    const state = part.state;
+    state.output = "[truncated]";
+    if (isRecord(state.input)) {
+      const inputSize = estimateInputSize(state.input);
+      if (inputSize > 500) {
+        truncateInputValues(state.input);
       }
     }
+    return;
+  }
+  if (part.type === "tool_result") {
+    part.content = "[truncated]";
+    return;
+  }
+  if (part.type === "tool-invocation" && isRecord(part.args)) {
+    const inputSize = estimateInputSize(part.args);
+    if (inputSize > 500) {
+      truncateInputValues(part.args);
+    }
+    return;
+  }
+  if (part.type === "tool_use" && isRecord(part.input)) {
+    const inputSize = estimateInputSize(part.input);
+    if (inputSize > 500) {
+      truncateInputValues(part.input);
+    }
   }
-  return keys;
 }
-function getProtectedTailStartOrdinal(sessionId) {
-  const messages = readRawSessionMessages(sessionId);
-  const userOrdinals = messages.filter((m) => m.role === "user" && hasMeaningfulUserText(m.parts)).map((m) => m.ordinal);
-  if (userOrdinals.length < PROTECTED_TAIL_USER_TURNS) {
-    return 1;
+function estimateInputSize(input) {
+  try {
+    return JSON.stringify(input).length;
+  } catch {
+    return 0;
   }
-  return userOrdinals[userOrdinals.length - PROTECTED_TAIL_USER_TURNS];
 }
-function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal) {
-  const messages = readRawSessionMessages(sessionId);
-  const startOrdinal = Math.max(1, offset);
-  const lines = [];
-  const lineMeta = [];
-  const flushedToolOnlyBlocks = [];
-  let totalTokens = 0;
-  let messagesProcessed = 0;
+function safeSlice(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  const lastCharCode = str.charCodeAt(maxLen - 1);
+  if (lastCharCode >= 55296 && lastCharCode <= 56319) {
+    return str.slice(0, maxLen - 1);
+  }
+  return str.slice(0, maxLen);
+}
+function truncateInputValues(input) {
+  for (const key of Object.keys(input)) {
+    const value = input[key];
+    if (typeof value === "string") {
+      if (value.endsWith(TRUNCATION_SENTINEL) || value === "[object]" || /^\[\d+ items\]$/.test(value))
+        continue;
+      input[key] = value.length > 5 ? `${safeSlice(value, 5)}${TRUNCATION_SENTINEL}` : value;
+    } else if (Array.isArray(value)) {
+      input[key] = `[${value.length} items]`;
+    } else if (value !== null && typeof value === "object") {
+      input[key] = "[object]";
+    }
+  }
+}
+function hasMeaningfulPart(part) {
+  if (!isRecord(part))
+    return false;
+  const type = part.type;
+  if (type === "text") {
+    return typeof part.text === "string" && part.text.trim().length > 0;
+  }
+  if (typeof type !== "string")
+    return false;
+  if (IGNORE_PART_TYPES.has(type))
+    return false;
+  return true;
+}
+function clearThinkingParts(thinkingParts) {
+  for (const part of thinkingParts) {
+    if (part.thinking !== undefined)
+      part.thinking = "[cleared]";
+    if (part.text !== undefined)
+      part.text = "[cleared]";
+  }
+}
+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;
+}
+function isDropContent(content) {
+  return content.startsWith(DROP_PREFIX);
+}
+
+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();
+  }
+}
+function createToolDropTarget(compositeKey, thinkingParts, index, batch) {
+  const drop = () => {
+    const entry = index.get(compositeKey);
+    if (!entry || entry.occurrences.length === 0)
+      return "absent";
+    if (!entry.hasResult)
+      return "incomplete";
+    for (const occurrence of entry.occurrences) {
+      batch.markForRemoval(occurrence);
+    }
+    clearThinkingParts(thinkingParts);
+    index.delete(compositeKey);
+    return "removed";
+  };
+  const truncate = () => {
+    const entry = index.get(compositeKey);
+    if (!entry || entry.occurrences.length === 0)
+      return "absent";
+    if (!entry.hasResult)
+      return "incomplete";
+    for (const occurrence of entry.occurrences) {
+      truncateToolPart(occurrence.part);
+    }
+    clearThinkingParts(thinkingParts);
+    return "truncated";
+  };
+  return {
+    setContent: (content) => {
+      if (isDropContent(content)) {
+        drop();
+        return true;
+      }
+      const entry = index.get(compositeKey);
+      if (!entry)
+        return false;
+      let changed = false;
+      for (const occurrence of entry.occurrences) {
+        if (occurrence.kind !== "result")
+          continue;
+        const prevContent = getToolContent(occurrence.part);
+        if (prevContent !== content) {
+          setToolContent(occurrence.part, content);
+          changed = true;
+        }
+      }
+      return changed;
+    },
+    drop,
+    truncate
+  };
+}
+var DROP_PREFIX = "[dropped", IGNORE_PART_TYPES, TRUNCATION_SENTINEL = "...[truncated]";
+var init_tool_drop_target = __esm(() => {
+  IGNORE_PART_TYPES = new Set([
+    "thinking",
+    "reasoning",
+    "redacted_thinking",
+    "meta",
+    "step-start",
+    "step-finish"
+  ]);
+});
+
+// src/hooks/magic-context/read-session-chunk.ts
+function cleanUserText(text) {
+  return removeSystemReminders(text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
+}
+function withRawSessionMessageCache(fn) {
+  const outerCache = activeRawMessageCache;
+  if (!outerCache) {
+    activeRawMessageCache = new Map;
+  }
+  try {
+    return fn();
+  } finally {
+    if (!outerCache) {
+      activeRawMessageCache = null;
+    }
+  }
+}
+function readRawSessionMessages(sessionId) {
+  if (activeRawMessageCache) {
+    const cached2 = activeRawMessageCache.get(sessionId);
+    if (cached2) {
+      return cached2;
+    }
+    const messages = readRawSessionMessagesFromSource(sessionId);
+    activeRawMessageCache.set(sessionId, messages);
+    return messages;
+  }
+  return readRawSessionMessagesFromSource(sessionId);
+}
+function readRawSessionMessageById(sessionId, messageId) {
+  const provider2 = sessionProviders.get(sessionId);
+  if (provider2?.readMessageById) {
+    return provider2.readMessageById(messageId);
+  }
+  if (provider2) {
+    return provider2.readMessages().find((message) => message.id === messageId) ?? null;
+  }
+  return withReadOnlySessionDb((db) => readRawSessionMessageByIdFromDb(db, sessionId, messageId));
+}
+function readRawSessionMessagesFromSource(sessionId) {
+  const provider2 = sessionProviders.get(sessionId);
+  if (provider2)
+    return provider2.readMessages();
+  return withReadOnlySessionDb((db) => readRawSessionMessagesFromDb(db, sessionId));
+}
+function getRawSessionMessageCount(sessionId) {
+  const provider2 = sessionProviders.get(sessionId);
+  if (provider2) {
+    if (provider2.getMessageCount)
+      return provider2.getMessageCount();
+    return provider2.readMessages().length;
+  }
+  return withReadOnlySessionDb((db) => getRawSessionMessageCountFromDb(db, sessionId));
+}
+function getRawSessionTagKeysThrough(sessionId, upToMessageIndex) {
+  const messages = readRawSessionMessages(sessionId);
+  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)) {
+        messageFileKeys.add(`${message.id}:p${partIndex}`);
+        continue;
+      }
+      if (isFilePart(part)) {
+        messageFileKeys.add(`${message.id}:file${partIndex}`);
+        continue;
+      }
+      const obs = extractToolCallObservation(part);
+      if (!obs)
+        continue;
+      let ownerMsgId;
+      if (obs.kind === "invocation") {
+        ownerMsgId = message.id;
+        const queue2 = unpairedInvocations.get(obs.callId) ?? [];
+        queue2.push(message.id);
+        unpairedInvocations.set(obs.callId, queue2);
+      } else {
+        const queue2 = unpairedInvocations.get(obs.callId);
+        if (queue2 && queue2.length > 0) {
+          const popped = queue2.shift();
+          if (queue2.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 { messageFileKeys, toolObservations };
+}
+function getProtectedTailStartOrdinal(sessionId) {
+  const messages = readRawSessionMessages(sessionId);
+  const userOrdinals = messages.filter((m) => m.role === "user" && hasMeaningfulUserText(m.parts)).map((m) => m.ordinal);
+  if (userOrdinals.length < PROTECTED_TAIL_USER_TURNS) {
+    return 1;
+  }
+  return userOrdinals[userOrdinals.length - PROTECTED_TAIL_USER_TURNS];
+}
+function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal) {
+  const messages = readRawSessionMessages(sessionId);
+  const startOrdinal = Math.max(1, offset);
+  const lines = [];
+  const lineMeta = [];
+  const flushedToolOnlyBlocks = [];
+  let totalTokens = 0;
+  let messagesProcessed = 0;
   let lastOrdinal = startOrdinal - 1;
   let lastMessageId = "";
   let firstMessageId = "";
@@ -158094,6 +158768,7 @@ var activeRawMessageCache = null, sessionProviders, PROTECTED_TAIL_USER_TURNS =
 var init_read_session_chunk = __esm(async () => {
   init_read_session_formatting();
   init_tag_part_guards();
+  init_tool_drop_target();
   init_read_session_formatting();
   await init_read_session_db();
   sessionProviders = new Map;
@@ -158151,10 +158826,26 @@ function getCountIndexedMessageStatement(db) {
   }
   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 deleteIndexedMessage(db, sessionId, messageId) {
   const row = getCountIndexedMessageStatement(db).get(sessionId, messageId);
   const count = typeof row?.count === "number" ? row.count : 0;
@@ -158180,36 +158871,53 @@ function getIndexableContent(role, parts) {
   }
   return "";
 }
-function ensureMessagesIndexed(db, sessionId, readMessages) {
-  const messages = readMessages(sessionId);
-  if (messages.length === 0) {
-    db.transaction(() => clearIndexedMessages(db, sessionId))();
-    return;
+function indexSingleMessageInTransaction(db, sessionId, message, now) {
+  if (message.role !== "user" && message.role !== "assistant") {
+    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+    return false;
   }
-  let lastIndexedOrdinal = getLastIndexedOrdinal(db, sessionId);
-  if (lastIndexedOrdinal > messages.length) {
-    db.transaction(() => clearIndexedMessages(db, sessionId))();
-    lastIndexedOrdinal = 0;
+  const content = getIndexableContent(message.role, message.parts);
+  if (content.length === 0) {
+    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+    return false;
   }
-  if (lastIndexedOrdinal >= messages.length) {
-    return;
+  if (isMessageAlreadyIndexed(db, sessionId, message.id)) {
+    advanceIndexWatermark(db, sessionId, message.ordinal, now);
+    return false;
   }
-  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);
+  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 messagesToInsert) {
-      insertMessage.run(sessionId, message.ordinal, message.id, message.role, message.content);
+    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, messages.length, now, getHarness());
+    getUpsertIndexStatement(db).run(sessionId, finalWatermark, now, getHarness());
   })();
+  return inserted;
 }
-var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements;
+var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements, indexedMessageIdStatements;
 var init_message_index = __esm(async () => {
   init_compression_depth_storage();
   await init_read_session_chunk();
@@ -158219,6 +158927,7 @@ var init_message_index = __esm(async () => {
   deleteFtsStatements = new WeakMap;
   deleteIndexStatements = new WeakMap;
   countIndexedMessageStatements = new WeakMap;
+  indexedMessageIdStatements = new WeakMap;
 });
 
 // src/features/magic-context/migrations.ts
@@ -158235,22 +158944,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.`);
     }
@@ -158462,30 +159200,330 @@ var init_migrations = __esm(async () => {
           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;
+            `);
+      }
     }
   ];
 });
 
+// src/features/magic-context/tool-owner-backfill.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join14 } from "node:path";
+function resolveOpencodeDbPath() {
+  return join14(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 (!existsSync9(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_MS2;
+  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_MS2;
+  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();
+    }
+  }
+}
+var LEASE_DURATION_MS2, LEASE_RENEWAL_MS;
+var init_tool_owner_backfill = __esm(() => {
+  init_data_path();
+  init_logger();
+  LEASE_DURATION_MS2 = 5 * 60 * 1000;
+  LEASE_RENEWAL_MS = 60 * 1000;
+});
+
 // src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join13 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync10, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join15 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join13(dbDir, "context.db") };
+  return { dbDir, dbPath: join15(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync8(targetDbPath))
+  if (existsSync10(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join13(legacyDir, "context.db");
-  if (!existsSync8(legacyDbPath))
+  const legacyDbPath = join15(legacyDir, "context.db");
+  if (!existsSync10(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 = join13(targetDbDir, `context.db${suffix}`);
-    if (existsSync8(src)) {
+    const dst = join15(targetDbDir, `context.db${suffix}`);
+    if (existsSync10(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -158493,9 +159531,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join13(legacyDir, "models");
-  const targetModelsDir = join13(targetDbDir, "models");
-  if (existsSync8(legacyModelsDir) && !existsSync8(targetModelsDir)) {
+  const legacyModelsDir = join15(legacyDir, "models");
+  const targetModelsDir = join15(targetDbDir, "models");
+  if (existsSync10(legacyModelsDir) && !existsSync10(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -158781,6 +159819,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 ''");
@@ -158875,10 +159914,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);
@@ -158899,6 +159945,8 @@ var databases, persistenceByDatabase, persistenceErrorByDatabase;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
+  init_tool_definition_tokens();
+  init_tool_owner_backfill();
   await __promiseAll([
     init_sqlite(),
     init_migrations()
@@ -159469,7 +160517,7 @@ var init_storage_source = () => {};
 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;
@@ -159550,7 +160598,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) {
@@ -159568,8 +160617,8 @@ function isMaxTagNumberRow(row) {
 function escapeLikePattern(value) {
   return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
 }
-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) {
@@ -159588,12 +160637,27 @@ function deleteTagsByMessageId(db, sessionId, messageId) {
   const escapedMessageId = escapeLikePattern(messageId);
   const textPartPattern = `${escapedMessageId}:p%`;
   const filePartPattern = `${escapedMessageId}:file%`;
-  const tagNumbers = getTagNumbersByMessageIdStatement(db).all(sessionId, messageId, textPartPattern, filePartPattern).filter(isTagNumberRow).map((row) => row.tag_number);
-  if (tagNumbers.length === 0) {
+  const messageScopedTags = getTagNumbersByMessageIdStatement(db).all(sessionId, messageId, textPartPattern, filePartPattern).filter(isTagNumberRow).map((row) => row.tag_number);
+  const ownerScopedTagNumbers = getOwnerScopedToolTagNumbers(db, sessionId, messageId);
+  if (messageScopedTags.length === 0 && ownerScopedTagNumbers.length === 0) {
     return [];
   }
-  getDeleteTagsByMessageIdStatement(db).run(sessionId, messageId, textPartPattern, filePartPattern);
-  return tagNumbers;
+  if (messageScopedTags.length > 0) {
+    getDeleteTagsByMessageIdStatement(db).run(sessionId, messageId, textPartPattern, filePartPattern);
+  }
+  if (ownerScopedTagNumbers.length > 0) {
+    deleteToolTagsByOwner(db, sessionId, messageId);
+  }
+  const merged = new Set([...messageScopedTags, ...ownerScopedTagNumbers]);
+  return Array.from(merged).sort((a, b) => a - b);
+}
+function getOwnerScopedToolTagNumbers(db, sessionId, ownerMsgId) {
+  let stmt = getOwnerScopedToolTagNumbersStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT tag_number FROM tags WHERE session_id = ? AND type = 'tool' AND tool_owner_message_id = ? ORDER BY tag_number ASC");
+    getOwnerScopedToolTagNumbersStatements.set(db, stmt);
+  }
+  return stmt.all(sessionId, ownerMsgId).filter(isTagNumberRow).map((row) => row.tag_number);
 }
 function getMaxTagNumberBySession(db, sessionId) {
   const row = getMaxTagNumberBySessionStatement(db).get(sessionId);
@@ -159604,17 +160668,151 @@ function getTagNumberByMessageId(db, sessionId, messageId) {
   return isTagNumberRow(row) ? row.tag_number : null;
 }
 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);
+}
+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 getMaxDroppedTagNumberStatement(db) {
+  let stmt = getMaxDroppedTagNumberStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COALESCE(MAX(tag_number), 0) AS max_tag_number FROM tags WHERE session_id = ? AND status = 'dropped'");
+    getMaxDroppedTagNumberStatements.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 getMaxDroppedTagNumber(db, sessionId) {
+  const row = getMaxDroppedTagNumberStatement(db).get(sessionId);
+  return isMaxTagNumberRow(row) ? row.max_tag_number : 0;
+}
 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 insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements;
+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;
+}
+function getCandidateToolOwners(db, sessionId, callId) {
+  const rows = db.prepare(`SELECT DISTINCT tool_owner_message_id
+             FROM tags
+             WHERE session_id = ?
+               AND message_id = ?
+               AND type = 'tool'
+               AND tool_owner_message_id IS NOT NULL`).all(sessionId, callId);
+  return rows.map((r) => r.tool_owner_message_id);
+}
+function pickNearestPriorOwner(candidates, currentMessageId, times) {
+  const currentTime = times.get(currentMessageId);
+  if (typeof currentTime !== "number")
+    return null;
+  let best = null;
+  for (const id of candidates) {
+    const t = times.get(id);
+    if (typeof t !== "number")
+      continue;
+    if (t > currentTime)
+      continue;
+    if (t === currentTime && id >= currentMessageId)
+      continue;
+    if (best === null || t > best.time || t === best.time && id > best.id) {
+      best = { id, time: t };
+    }
+  }
+  return best?.id ?? null;
+}
+function getDeleteToolTagsByOwnerStatement(db) {
+  let stmt = deleteToolTagsByOwnerStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`DELETE FROM tags
+             WHERE session_id = ?
+               AND type = 'tool'
+               AND tool_owner_message_id = ?`);
+    deleteToolTagsByOwnerStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function deleteToolTagsByOwner(db, sessionId, ownerMsgId) {
+  const result = getDeleteToolTagsByOwnerStatement(db).run(sessionId, ownerMsgId);
+  return result.changes ?? 0;
+}
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, getOwnerScopedToolTagNumbersStatements, 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", getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(() => {
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
@@ -159626,6 +160824,13 @@ var init_storage_tags = __esm(() => {
   getTagNumberByMessageIdStatements = new WeakMap;
   updateTagByteSizeStatements = new WeakMap;
   updateTagInputByteSizeStatements = new WeakMap;
+  getOwnerScopedToolTagNumbersStatements = new WeakMap;
+  getActiveTagsBySessionStatements = new WeakMap;
+  getMaxDroppedTagNumberStatements = new WeakMap;
+  getToolTagNumberByOwnerStatements = new WeakMap;
+  getNullOwnerToolTagStatements = new WeakMap;
+  adoptNullOwnerToolTagStatements = new WeakMap;
+  deleteToolTagsByOwnerStatements = new WeakMap;
 });
 
 // src/features/magic-context/storage.ts
@@ -159645,9 +160850,9 @@ var init_storage = __esm(async () => {
 
 // src/shared/models-dev-cache.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir8, platform as platform3 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 function hashFast(input) {
   return createHash3("sha1").update(input).digest("hex");
 }
@@ -159658,16 +160863,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 join14(cacheBase, "opencode", filename);
+  return join16(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform3() === "win32" ? join14(homedir8(), ".config", "opencode") : join14(process.env.XDG_CONFIG_HOME || join14(homedir8(), ".config"), "opencode");
-  const jsonc = join14(configDir, "opencode.jsonc");
-  if (existsSync9(jsonc))
+  const configDir = envDir ? envDir : platform3() === "win32" ? join16(homedir8(), ".config", "opencode") : join16(process.env.XDG_CONFIG_HOME || join16(homedir8(), ".config"), "opencode");
+  const jsonc = join16(configDir, "opencode.jsonc");
+  if (existsSync11(jsonc))
     return jsonc;
-  const json2 = join14(configDir, "opencode.json");
-  if (existsSync9(json2))
+  const json2 = join16(configDir, "opencode.json");
+  if (existsSync11(json2))
     return json2;
   return null;
 }
@@ -159680,23 +160885,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") {
@@ -159710,7 +160904,7 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync9(modelsJsonPath)) {
+    if (existsSync11(modelsJsonPath)) {
       fileFound = true;
       const raw = readFileSync7(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
@@ -159727,7 +160921,7 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync9(configPath)) {
+    if (configPath && existsSync11(configPath)) {
       let raw = readFileSync7(configPath, "utf-8");
       raw = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/.*$/gm, (match) => match.startsWith('"') ? match : "");
       const config2 = JSON.parse(raw);
@@ -159768,8 +160962,18 @@ async function refreshModelLimitsFromApi(client) {
     const previousSize = apiCache?.size ?? null;
     apiCache = map2;
     apiLoadedAt = Date.now();
-    if (previousSize === null || previousSize !== map2.size) {
-      sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries${previousSize !== null ? ` (was ${previousSize})` : ""}`);
+    if (previousSize === null) {
+      recentlySeenApiSizes.add(map2.size);
+      sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries`);
+    } else if (previousSize !== map2.size) {
+      const sizeAlreadySeen = recentlySeenApiSizes.has(map2.size);
+      recentlySeenApiSizes.add(map2.size);
+      if (!sizeAlreadySeen) {
+        sessionLog("global", `models-dev-cache: API layer loaded ${map2.size} model metadata entries (was ${previousSize})`);
+      } else if (!oscillationLogged) {
+        oscillationLogged = true;
+        sessionLog("global", `models-dev-cache: API count oscillating between ${[...recentlySeenApiSizes].sort((a, b) => a - b).join(" ↔ ")} — likely upstream provider plugin returning slightly different model sets between calls (e.g. github-copilot's /models endpoint toggling model_picker_enabled). Suppressing further size-change logs.`);
+      }
     }
   } catch (error48) {
     sessionLog("global", "models-dev-cache: API refresh failed:", error48 instanceof Error ? error48.message : String(error48));
@@ -159789,27 +160993,12 @@ 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;
-}
-var RELOAD_INTERVAL_MS, apiCache = null, apiLoadedAt = 0, fileCache = null, fileLastAttempt = 0;
+var RELOAD_INTERVAL_MS, apiCache = null, apiLoadedAt = 0, recentlySeenApiSizes, oscillationLogged = false, fileCache = null, fileLastAttempt = 0;
 var init_models_dev_cache = __esm(() => {
   init_data_path();
   init_logger();
   RELOAD_INTERVAL_MS = 5 * 60 * 1000;
+  recentlySeenApiSizes = new Set;
 });
 
 // src/shared/rpc-notifications.ts
@@ -160059,9 +161248,9 @@ var init_compartment_runner_validation = __esm(async () => {
 });
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync3, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync4, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -160301,11 +161490,11 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 }
 function dumpHistorianResponse(sessionId, label, text) {
   try {
-    mkdirSync3(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
+    mkdirSync4(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join15(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync3(dumpPath, text, "utf8");
+    const dumpPath = join17(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync4(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -160329,7 +161518,7 @@ var init_compartment_runner_historian = __esm(async () => {
   init_assistant_message_extractor();
   init_compartment_prompt();
   await init_compartment_runner_validation();
-  HISTORIAN_RESPONSE_DUMP_DIR = join15(tmpdir2(), "magic-context-historian");
+  HISTORIAN_RESPONSE_DUMP_DIR = join17(tmpdir2(), "magic-context-historian");
 });
 
 // src/hooks/magic-context/compartment-runner-state-xml.ts
@@ -161308,7 +162497,7 @@ var init_derive_budgets = __esm(() => {
 });
 
 // src/features/magic-context/compaction-marker.ts
-import { join as join16 } from "node:path";
+import { join as join18 } from "node:path";
 function randomBase62(length) {
   const chars = [];
   for (let i = 0;i < length; i++) {
@@ -161328,7 +162517,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join16(getDataDir(), "opencode", "opencode.db");
+  return join18(getDataDir(), "opencode", "opencode.db");
 }
 function isOpenCodeSchemaCompatible(db, dbPath) {
   if (cachedSchemaCompatible?.path === dbPath) {
@@ -161465,7 +162654,7 @@ var init_compaction_marker = __esm(async () => {
 });
 
 // src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join17 } from "node:path";
+import { join as join19 } from "node:path";
 function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, directory) {
   const existing = getPersistedCompactionMarkerState(db, sessionId);
   if (existing) {
@@ -161508,7 +162697,7 @@ function removeCompactionMarkerForSession(db, sessionId) {
   }
 }
 function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join17(getDataDir(), "opencode", "opencode.db");
+  const opencodeDbPath = join19(getDataDir(), "opencode", "opencode.db");
   let opencodeDb;
   try {
     opencodeDb = new Database(opencodeDbPath, { readonly: true });
@@ -161895,31 +163084,31 @@ var init_caveman = __esm(() => {
 });
 
 // src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 function maybeWriteHistorianStateFile(sessionId, existingState) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
-    mkdirSync4(HISTORIAN_STATE_DIR, { recursive: true });
-    const path4 = join18(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
-    writeFileSync4(path4, existingState, "utf8");
-    return path4;
+    mkdirSync5(HISTORIAN_STATE_DIR, { recursive: true });
+    const path5 = join20(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
+    writeFileSync5(path5, existingState, "utf8");
+    return path5;
   } catch {
     return;
   }
 }
-function cleanupHistorianStateFile(path4) {
-  if (!path4)
+function cleanupHistorianStateFile(path5) {
+  if (!path5)
     return;
   try {
-    unlinkSync2(path4);
+    unlinkSync2(path5);
   } catch {}
 }
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000, HISTORIAN_STATE_DIR;
 var init_historian_state_file = __esm(() => {
-  HISTORIAN_STATE_DIR = join18(tmpdir3(), "magic-context-historian");
+  HISTORIAN_STATE_DIR = join20(tmpdir3(), "magic-context-historian");
 });
 
 // src/features/magic-context/memory/embedding-backfill.ts
@@ -162424,12 +163613,24 @@ var init_compartment_runner_compressor = __esm(async () => {
 // src/hooks/magic-context/compartment-runner-drop-queue.ts
 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;
     }
@@ -162989,8 +164190,8 @@ var exports_tui_config = {};
 __export(exports_tui_config, {
   ensureTuiPluginEntry: () => ensureTuiPluginEntry
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join21 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname6, join as join23 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -163004,11 +164205,11 @@ function isMagicContextEntry(entry) {
 }
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join21(configDir, "tui.jsonc");
-  const jsonPath = join21(configDir, "tui.json");
-  if (existsSync11(jsoncPath))
+  const jsoncPath = join23(configDir, "tui.jsonc");
+  const jsonPath = join23(configDir, "tui.json");
+  if (existsSync13(jsoncPath))
     return jsoncPath;
-  if (existsSync11(jsonPath))
+  if (existsSync13(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -163016,7 +164217,7 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync11(configPath)) {
+    if (existsSync13(configPath)) {
       const raw = readFileSync9(configPath, "utf-8");
       config2 = import_comment_json3.parse(raw) ?? {};
     }
@@ -163036,8 +164237,8 @@ function ensureTuiPluginEntry() {
       plugins.push(PLUGIN_ENTRY);
     }
     config2.plugin = plugins;
-    mkdirSync6(dirname5(configPath), { recursive: true });
-    writeFileSync6(configPath, `${import_comment_json3.stringify(config2, null, 2)}
+    mkdirSync7(dirname6(configPath), { recursive: true });
+    writeFileSync7(configPath, `${import_comment_json3.stringify(config2, null, 2)}
 `);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -163813,42 +165014,8 @@ async function runSidekick(deps) {
   }
 }
 
-// src/features/magic-context/tool-definition-tokens.ts
-init_read_session_formatting();
-var measurements = new Map;
-function keyFor(providerID, modelID, agentName) {
-  const agent = agentName && agentName.length > 0 ? agentName : "default";
-  return `${providerID}/${modelID}/${agent}`;
-}
-function recordToolDefinition(providerID, modelID, agentName, toolID, description, parameters) {
-  if (!providerID || !modelID || !toolID)
-    return;
-  const key = keyFor(providerID, modelID, agentName);
-  let paramsText = "";
-  try {
-    paramsText = parameters === undefined ? "" : JSON.stringify(parameters);
-  } catch {
-    paramsText = "";
-  }
-  const tokens = estimateTokens(description ?? "") + estimateTokens(paramsText);
-  let inner = measurements.get(key);
-  if (!inner) {
-    inner = new Map;
-    measurements.set(key, inner);
-  }
-  inner.set(toolID, tokens);
-}
-function getMeasuredToolDefinitionTokens(providerID, modelID, agentName) {
-  if (!providerID || !modelID)
-    return;
-  const inner = measurements.get(keyFor(providerID, modelID, agentName));
-  if (!inner || inner.size === 0)
-    return;
-  let total = 0;
-  for (const tokens of inner.values())
-    total += tokens;
-  return total;
-}
+// src/index.ts
+init_tool_definition_tokens();
 
 // src/hooks/auto-update-checker/index.ts
 init_logger();
@@ -164130,24 +165297,27 @@ function stripPackageNameFromPath(pathValue, packageName) {
   }
   return current;
 }
-function removeFromBunLock(installDir, packageName) {
-  const lockPath = join5(installDir, "bun.lock");
+function removeFromPackageLock(installDir, packageName) {
+  const lockPath = join5(installDir, "package-lock.json");
   if (!existsSync5(lockPath))
     return false;
   try {
     const lock = import_comment_json2.parse(readFileSync5(lockPath, "utf-8"));
     let modified = false;
-    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
-      delete lock.workspaces[""].dependencies[packageName];
-      modified = true;
+    if (lock.packages) {
+      const key = `node_modules/${packageName}`;
+      if (lock.packages[key] !== undefined) {
+        delete lock.packages[key];
+        modified = true;
+      }
     }
-    if (lock.packages?.[packageName]) {
-      delete lock.packages[packageName];
+    if (lock.dependencies?.[packageName]) {
+      delete lock.dependencies[packageName];
       modified = true;
     }
     if (modified) {
       writeFileSync2(lockPath, JSON.stringify(lock, null, 2));
-      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
+      log(`[auto-update-checker] Removed from package-lock.json: ${packageName}`);
     }
     return modified;
   } catch {
@@ -164212,7 +165382,7 @@ function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePacka
     if (!ensureDependencyVersion(installContext.packageJsonPath, packageName, version2))
       return null;
     const packageRemoved = removeInstalledPackage(installContext.installDir, packageName);
-    const lockRemoved = removeFromBunLock(installContext.installDir, packageName);
+    const lockRemoved = removeFromPackageLock(installContext.installDir, packageName);
     if (!packageRemoved && !lockRemoved) {
       log(`[auto-update-checker] No cached package artifacts removed for ${packageName}; continuing with updated dependency spec`);
     }
@@ -164222,12 +165392,12 @@ function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePacka
     return null;
   }
 }
-async function runBunInstallSafe(installDir, options = {}) {
+async function runNpmInstallSafe(installDir, options = {}) {
   let timeout = null;
   try {
     if (options.signal?.aborted)
       return false;
-    const proc = spawn("bun", ["install"], {
+    const proc = spawn("npm", ["install", "--no-audit", "--no-fund", "--no-progress"], {
       cwd: installDir,
       stdio: "pipe"
     });
@@ -164252,7 +165422,7 @@ async function runBunInstallSafe(installDir, options = {}) {
     }
     return result;
   } catch (err) {
-    warn2(`[auto-update-checker] bun install error: ${String(err)}`);
+    warn2(`[auto-update-checker] npm install error: ${String(err)}`);
     return false;
   } finally {
     if (timeout)
@@ -164370,7 +165540,7 @@ async function runBackgroundUpdateCheck(ctx, options) {
     warn3("[auto-update-checker] Failed to prepare install root for auto-update");
     return;
   }
-  const installSuccess = await runBunInstallSafe(installDir, { signal: options.signal });
+  const installSuccess = await runNpmInstallSafe(installDir, { signal: options.signal });
   if (installSuccess) {
     showToast(ctx, "Magic Context Updated!", `v${currentVersion} → v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
@@ -164378,7 +165548,7 @@ Restart OpenCode to apply.`, "success", 8000);
     return;
   }
   showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`, "error", 8000);
-  warn3("[auto-update-checker] bun install failed; update not installed");
+  warn3("[auto-update-checker] npm install failed; update not installed");
 }
 function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
   ctx.client.tui.showToast({ body: { title, message, variant, duration: duration3 } }).catch(() => {});
@@ -164395,7 +165565,8 @@ function createLiveSessionState() {
     agentBySession: new Map,
     historyRefreshSessions: new Set,
     systemPromptRefreshSessions: new Set,
-    pendingMaterializationSessions: new Set
+    pendingMaterializationSessions: new Set,
+    sessionDirectoryBySession: new Map
   };
 }
 
@@ -164562,8 +165733,8 @@ init_assistant_message_extractor();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
 init_logger();
@@ -164954,11 +166125,11 @@ function countNewIds(beforeIds, afterIds) {
   return count;
 }
 function getOpenCodeDbPath2() {
-  return join11(getDataDir(), "opencode", "opencode.db");
+  return join12(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync7(dbPath)) {
+  if (!existsSync8(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -165208,8 +166379,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync7(join11(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync7(join11(docsDir, "STRUCTURE.md"))
+          architecture: existsSync8(join12(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync8(join12(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -166535,14 +167706,46 @@ function createScheduler(config2) {
 
 // src/features/magic-context/tagger.ts
 init_storage_tags();
+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)
@@ -166576,6 +167779,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) {
@@ -166594,15 +167798,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;
     }
@@ -166612,16 +167816,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;
         }
@@ -166630,51 +167834,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 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) {
+  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,
@@ -167318,21 +168595,146 @@ ${snap.error}`;
 // src/hooks/magic-context/hook.ts
 init_derive_budgets();
 
-// 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,
+// src/features/magic-context/message-index-async.ts
+init_logger();
+await init_message_index();
+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;
+  }
+  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;
+  }
+  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 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 scheduleClearAndReindex(db, sessionId, readMessages) {
+  reconciledSessions.delete(sessionId);
+  reconciliationScheduledSessions.delete(sessionId);
+  defer(() => {
+    runWithSessionLock(sessionId, () => {
+      clearIndexedMessages(db, sessionId);
+      const messages = readMessages(sessionId);
+      indexMessagesAfterOrdinal(db, sessionId, messages, 0, messages.length);
+      reconciledSessions.add(sessionId);
+    }).catch((error48) => {
+      logIndexingError(sessionId, "clear and reindex", error48);
+    });
+  });
+}
+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);
+    }
+  }
+}
+
+// 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,
@@ -167488,6 +168890,24 @@ function getMessageUpdatedAssistantInfo(properties) {
     error: info.error !== undefined ? info.error : undefined
   };
 }
+function getMessageUpdatedInfo(properties) {
+  const eventProps = getSessionProperties(properties);
+  if (!eventProps || !isRecord(eventProps.info)) {
+    return null;
+  }
+  const info = eventProps.info;
+  if (typeof info.role !== "string" || typeof info.sessionID !== "string") {
+    return null;
+  }
+  const time3 = isRecord(info.time) ? info.time : undefined;
+  return {
+    role: info.role,
+    sessionID: info.sessionID,
+    messageID: typeof info.id === "string" ? info.id : undefined,
+    finish: typeof info.finish === "string" ? info.finish : undefined,
+    completedAt: typeof time3?.completed === "number" ? time3.completed : undefined
+  };
+}
 function getSessionErrorInfo(properties) {
   if (!isRecord(properties))
     return null;
@@ -167511,6 +168931,7 @@ function getMessageRemovedInfo(properties) {
 
 // src/hooks/magic-context/event-handler.ts
 init_note_nudger();
+await init_read_session_chunk();
 
 // src/hooks/magic-context/transform.ts
 init_compartment_storage();
@@ -167786,23 +169207,11 @@ function readUint32BE(b, offset) {
 // src/hooks/magic-context/transform.ts
 init_note_nudger();
 init_read_session_formatting();
+init_send_session_notification();
 await __promiseAll([
   init_inject_compartments(),
   init_read_session_chunk()
 ]);
-
-// src/hooks/magic-context/reasoning-capability.ts
-init_models_dev_cache();
-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/hooks/magic-context/transform.ts
-init_send_session_notification();
 // src/hooks/magic-context/sentinel.ts
 function makeSentinel(originalPart) {
   const sentinel = {
@@ -167979,9 +169388,7 @@ function stripDroppedPlaceholderMessages(messages) {
   }
   return { stripped, sentineledIds };
 }
-function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedWatermark, skipTypedReasoningCleanup = false) {
-  if (skipTypedReasoningCleanup)
-    return 0;
+function replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedWatermark) {
   if (persistedWatermark <= 0)
     return 0;
   let cleared = 0;
@@ -168027,9 +169434,7 @@ function replayStrippedInlineThinking(messages, messageTagNumbers, persistedWate
   }
   return stripped;
 }
-function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clearReasoningAge, skipTypedReasoningCleanup = false) {
-  if (skipTypedReasoningCleanup)
-    return 0;
+function clearOldReasoning(messages, reasoningByMessage, messageTagNumbers, clearReasoningAge) {
   const maxTag = findMaxTag(messageTagNumbers);
   if (maxTag === 0)
     return 0;
@@ -168064,9 +169469,7 @@ function findMaxTag(messageTagNumbers) {
   return max;
 }
 var CLEARED_REASONING_TYPES = new Set(["thinking", "reasoning"]);
-function stripClearedReasoning(messages, skipTypedReasoningCleanup = false) {
-  if (skipTypedReasoningCleanup)
-    return 0;
+function stripClearedReasoning(messages) {
   let stripped = 0;
   for (const message of messages) {
     if (message.info.role !== "assistant")
@@ -168588,374 +169991,189 @@ function isStructuralNoisePart(part) {
   if (!isRecord(part) || typeof part.type !== "string") {
     return false;
   }
-  if (!STRUCTURAL_PART_TYPES.has(part.type)) {
-    return false;
-  }
-  if (part.type === "reasoning" && typeof part.text === "string" && part.text !== "[cleared]") {
-    return false;
-  }
-  return true;
-}
-function stripStructuralNoise(messages) {
-  let strippedParts = 0;
-  for (const message of messages) {
-    if (!Array.isArray(message.parts)) {
-      continue;
-    }
-    for (let i = 0;i < message.parts.length; i++) {
-      const part = message.parts[i];
-      if (isSentinel(part))
-        continue;
-      if (!isStructuralNoisePart(part))
-        continue;
-      message.parts[i] = makeSentinel(part);
-      strippedParts++;
-    }
-  }
-  return strippedParts;
-}
-// src/hooks/magic-context/tag-messages.ts
-await init_storage();
-// src/hooks/magic-context/drop-stale-reduce-calls.ts
-var STALE_TOOL_NAMES = new Set(["ctx_reduce"]);
-function isReduceToolPart(part) {
-  if (!isRecord(part))
-    return false;
-  if (part.type === "tool" && typeof part.tool === "string" && STALE_TOOL_NAMES.has(part.tool))
-    return true;
-  if (part.type === "tool-invocation" && typeof part.toolName === "string" && STALE_TOOL_NAMES.has(part.toolName))
-    return true;
-  if (part.type === "tool_use" && typeof part.name === "string" && STALE_TOOL_NAMES.has(part.name))
-    return true;
-  return false;
-}
-function hasAnyMeaningfulPart(parts) {
-  for (const part of parts) {
-    if (!isRecord(part))
-      continue;
-    if (part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0)
-      return true;
-    if (part.type === "thinking" || part.type === "reasoning" || part.type === "redacted_thinking")
-      continue;
-    if (part.type === "meta" || part.type === "step-start" || part.type === "step-finish")
-      continue;
-    if (part.type !== "tool" || !isReduceToolPart(part))
-      return true;
-  }
-  return false;
-}
-function dropStaleReduceCalls(messages, protectedCount = 0) {
-  let didDrop = false;
-  const protectedStart = messages.length - protectedCount;
-  for (let i = 0;i < messages.length; i++) {
-    if (i >= protectedStart)
-      break;
-    const message = messages[i];
-    let touched = false;
-    for (let j = 0;j < message.parts.length; j++) {
-      const part = message.parts[j];
-      if (isSentinel(part))
-        continue;
-      if (isReduceToolPart(part)) {
-        message.parts[j] = makeSentinel(part);
-        touched = true;
-      }
-    }
-    if (touched) {
-      didDrop = true;
-      if (!hasAnyMeaningfulPart(message.parts)) {
-        message.parts.length = 0;
-        message.parts.push(makeSentinel(undefined));
-      }
-    }
-  }
-  return didDrop;
-}
-
-// src/hooks/magic-context/tag-messages.ts
-init_tag_content_primitives();
-
-// src/hooks/magic-context/tag-id-fallback.ts
-await init_storage();
-function parseScopedContentId(contentId) {
-  const match = /^(.*):(p|file)(\d+)$/.exec(contentId);
-  if (!match)
-    return null;
-  return {
-    messageId: match[1],
-    type: match[2] === "file" ? "file" : "message",
-    partIndex: Number.parseInt(match[3], 10)
-  };
-}
-function createScopedAssignments(assignments) {
-  const scoped = new Map;
-  for (const [contentId, tagNumber] of assignments) {
-    const parsed = parseScopedContentId(contentId);
-    if (!parsed)
-      continue;
-    const entry = scoped.get(parsed.messageId) ?? { message: [], file: [] };
-    entry[parsed.type].push({ tagNumber, contentId, partIndex: parsed.partIndex });
-    scoped.set(parsed.messageId, entry);
-  }
-  for (const entry of scoped.values()) {
-    entry.message.sort((left, right) => left.partIndex - right.partIndex);
-    entry.file.sort((left, right) => left.partIndex - right.partIndex);
-  }
-  return scoped;
-}
-function createExistingTagResolver(sessionId, tagger, db) {
-  const assignments = tagger.getAssignments(sessionId);
-  let cachedAssignmentSize = -1;
-  let cachedScopedAssignments = null;
-  const usedTagNumbers = new Set;
-  function getScopedAssignments() {
-    if (!cachedScopedAssignments || cachedAssignmentSize !== assignments.size) {
-      cachedScopedAssignments = createScopedAssignments(assignments);
-      cachedAssignmentSize = assignments.size;
-    }
-    return cachedScopedAssignments;
-  }
-  return {
-    resolve(messageId, type, currentContentId, ordinal) {
-      const exactTagId = assignments.get(currentContentId);
-      if (exactTagId !== undefined) {
-        usedTagNumbers.add(exactTagId);
-        return exactTagId;
-      }
-      const fallback = getScopedAssignments().get(messageId)?.[type][ordinal];
-      if (!fallback || usedTagNumbers.has(fallback.tagNumber)) {
-        return;
-      }
-      updateTagMessageId(db, sessionId, fallback.tagNumber, currentContentId);
-      tagger.bindTag(sessionId, currentContentId, fallback.tagNumber);
-      usedTagNumbers.add(fallback.tagNumber);
-      return fallback.tagNumber;
-    }
-  };
-}
-
-// src/hooks/magic-context/tag-messages.ts
-init_tag_part_guards();
-
-// src/hooks/magic-context/tool-drop-target.ts
-var DROP_PREFIX = "[dropped";
-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 getToolContent(part) {
-  if (!isRecord(part))
-    return;
-  if (part.type === "tool" && isRecord(part.state)) {
-    return typeof part.state.output === "string" ? part.state.output : undefined;
-  }
-  if (part.type === "tool_result") {
-    return typeof part.content === "string" ? part.content : undefined;
-  }
-  return;
-}
-function setToolContent(part, content) {
-  if (!isRecord(part))
-    return;
-  if (part.type === "tool" && isRecord(part.state)) {
-    part.state.output = content;
-    return;
-  }
-  if (part.type === "tool_result") {
-    part.content = content;
-  }
-}
-function truncateToolPart(part) {
-  if (!isRecord(part))
-    return;
-  if (part.type === "tool" && isRecord(part.state)) {
-    const state = part.state;
-    state.output = "[truncated]";
-    if (isRecord(state.input)) {
-      const inputSize = estimateInputSize(state.input);
-      if (inputSize > 500) {
-        truncateInputValues(state.input);
-      }
-    }
-    return;
-  }
-  if (part.type === "tool_result") {
-    part.content = "[truncated]";
-    return;
-  }
-  if (part.type === "tool-invocation" && isRecord(part.args)) {
-    const inputSize = estimateInputSize(part.args);
-    if (inputSize > 500) {
-      truncateInputValues(part.args);
-    }
-    return;
-  }
-  if (part.type === "tool_use" && isRecord(part.input)) {
-    const inputSize = estimateInputSize(part.input);
-    if (inputSize > 500) {
-      truncateInputValues(part.input);
-    }
-  }
-}
-function estimateInputSize(input) {
-  try {
-    return JSON.stringify(input).length;
-  } catch {
-    return 0;
-  }
-}
-var TRUNCATION_SENTINEL = "...[truncated]";
-function safeSlice(str, maxLen) {
-  if (str.length <= maxLen)
-    return str;
-  const lastCharCode = str.charCodeAt(maxLen - 1);
-  if (lastCharCode >= 55296 && lastCharCode <= 56319) {
-    return str.slice(0, maxLen - 1);
-  }
-  return str.slice(0, maxLen);
-}
-function truncateInputValues(input) {
-  for (const key of Object.keys(input)) {
-    const value = input[key];
-    if (typeof value === "string") {
-      if (value.endsWith(TRUNCATION_SENTINEL) || value === "[object]" || /^\[\d+ items\]$/.test(value))
-        continue;
-      input[key] = value.length > 5 ? `${safeSlice(value, 5)}${TRUNCATION_SENTINEL}` : value;
-    } else if (Array.isArray(value)) {
-      input[key] = `[${value.length} items]`;
-    } else if (value !== null && typeof value === "object") {
-      input[key] = "[object]";
-    }
-  }
-}
-function hasMeaningfulPart(part) {
-  if (!isRecord(part))
-    return false;
-  const type = part.type;
-  if (type === "text") {
-    return typeof part.text === "string" && part.text.trim().length > 0;
-  }
-  if (typeof type !== "string")
-    return false;
-  if (IGNORE_PART_TYPES.has(type))
-    return false;
-  return true;
-}
-function clearThinkingParts(thinkingParts) {
-  for (const part of thinkingParts) {
-    if (part.thinking !== undefined)
-      part.thinking = "[cleared]";
-    if (part.text !== undefined)
-      part.text = "[cleared]";
-  }
-}
-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 (!STRUCTURAL_PART_TYPES.has(part.type)) {
+    return false;
   }
-  if (part.type === "tool_result" && isToolCallId(part.tool_use_id)) {
-    return { callId: part.tool_use_id, kind: "result" };
+  if (part.type === "reasoning" && typeof part.text === "string" && part.text !== "[cleared]") {
+    return false;
   }
-  return null;
-}
-function isDropContent(content) {
-  return content.startsWith(DROP_PREFIX);
+  return true;
 }
-
-class ToolMutationBatch {
-  partsToRemove = new Set;
-  affectedMessages = new Set;
-  messages;
-  constructor(messages) {
-    this.messages = messages;
+function stripStructuralNoise(messages) {
+  let strippedParts = 0;
+  for (const message of messages) {
+    if (!Array.isArray(message.parts)) {
+      continue;
+    }
+    for (let i = 0;i < message.parts.length; i++) {
+      const part = message.parts[i];
+      if (isSentinel(part))
+        continue;
+      if (!isStructuralNoisePart(part))
+        continue;
+      message.parts[i] = makeSentinel(part);
+      strippedParts++;
+    }
   }
-  markForRemoval(occurrence) {
-    this.partsToRemove.add(occurrence.part);
-    this.affectedMessages.add(occurrence.message);
+  return strippedParts;
+}
+// src/hooks/magic-context/tag-messages.ts
+init_storage_tags();
+await init_storage();
+// src/hooks/magic-context/drop-stale-reduce-calls.ts
+var STALE_TOOL_NAMES = new Set(["ctx_reduce"]);
+function isReduceToolPart(part) {
+  if (!isRecord(part))
+    return false;
+  if (part.type === "tool" && typeof part.tool === "string" && STALE_TOOL_NAMES.has(part.tool))
+    return true;
+  if (part.type === "tool-invocation" && typeof part.toolName === "string" && STALE_TOOL_NAMES.has(part.toolName))
+    return true;
+  if (part.type === "tool_use" && typeof part.name === "string" && STALE_TOOL_NAMES.has(part.name))
+    return true;
+  return false;
+}
+function hasAnyMeaningfulPart(parts) {
+  for (const part of parts) {
+    if (!isRecord(part))
+      continue;
+    if (part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0)
+      return true;
+    if (part.type === "thinking" || part.type === "reasoning" || part.type === "redacted_thinking")
+      continue;
+    if (part.type === "meta" || part.type === "step-start" || part.type === "step-finish")
+      continue;
+    if (part.type !== "tool" || !isReduceToolPart(part))
+      return true;
   }
-  finalize() {
-    if (this.partsToRemove.size === 0)
-      return;
-    for (const message of this.affectedMessages) {
-      message.parts = message.parts.filter((p) => !this.partsToRemove.has(p));
+  return false;
+}
+function dropStaleReduceCalls(messages, protectedCount = 0) {
+  let didDrop = false;
+  const protectedStart = messages.length - protectedCount;
+  for (let i = 0;i < messages.length; i++) {
+    if (i >= protectedStart)
+      break;
+    const message = messages[i];
+    let touched = false;
+    for (let j = 0;j < message.parts.length; j++) {
+      const part = message.parts[j];
+      if (isSentinel(part))
+        continue;
+      if (isReduceToolPart(part)) {
+        message.parts[j] = makeSentinel(part);
+        touched = true;
+      }
     }
-    for (let i = this.messages.length - 1;i >= 0; i -= 1) {
-      if (!this.messages[i].parts.some(hasMeaningfulPart)) {
-        this.messages.splice(i, 1);
+    if (touched) {
+      didDrop = true;
+      if (!hasAnyMeaningfulPart(message.parts)) {
+        message.parts.length = 0;
+        message.parts.push(makeSentinel(undefined));
       }
     }
-    this.partsToRemove.clear();
-    this.affectedMessages.clear();
   }
+  return didDrop;
 }
-function createToolDropTarget(callId, thinkingParts, index, batch) {
-  const drop = () => {
-    const entry = index.get(callId);
-    if (!entry || entry.occurrences.length === 0)
-      return "absent";
-    if (!entry.hasResult)
-      return "incomplete";
-    for (const occurrence of entry.occurrences) {
-      batch.markForRemoval(occurrence);
-    }
-    clearThinkingParts(thinkingParts);
-    index.delete(callId);
-    return "removed";
+
+// src/hooks/magic-context/tag-messages.ts
+init_tag_content_primitives();
+await init_read_session_db();
+
+// src/hooks/magic-context/tag-id-fallback.ts
+await init_storage();
+function parseScopedContentId(contentId) {
+  const match = /^(.*):(p|file)(\d+)$/.exec(contentId);
+  if (!match)
+    return null;
+  return {
+    messageId: match[1],
+    type: match[2] === "file" ? "file" : "message",
+    partIndex: Number.parseInt(match[3], 10)
   };
-  const truncate = () => {
-    const entry = index.get(callId);
-    if (!entry || entry.occurrences.length === 0)
-      return "absent";
-    if (!entry.hasResult)
-      return "incomplete";
-    for (const occurrence of entry.occurrences) {
-      truncateToolPart(occurrence.part);
+}
+function createScopedAssignments(assignments) {
+  const scoped = new Map;
+  for (const [contentId, tagNumber] of assignments) {
+    const parsed = parseScopedContentId(contentId);
+    if (!parsed)
+      continue;
+    const entry = scoped.get(parsed.messageId) ?? { message: [], file: [] };
+    entry[parsed.type].push({ tagNumber, contentId, partIndex: parsed.partIndex });
+    scoped.set(parsed.messageId, entry);
+  }
+  for (const entry of scoped.values()) {
+    entry.message.sort((left, right) => left.partIndex - right.partIndex);
+    entry.file.sort((left, right) => left.partIndex - right.partIndex);
+  }
+  return scoped;
+}
+function createExistingTagResolver(sessionId, tagger, db) {
+  const assignments = tagger.getAssignments(sessionId);
+  let cachedAssignmentSize = -1;
+  let cachedScopedAssignments = null;
+  const usedTagNumbers = new Set;
+  function getScopedAssignments() {
+    if (!cachedScopedAssignments || cachedAssignmentSize !== assignments.size) {
+      cachedScopedAssignments = createScopedAssignments(assignments);
+      cachedAssignmentSize = assignments.size;
     }
-    clearThinkingParts(thinkingParts);
-    return "truncated";
-  };
+    return cachedScopedAssignments;
+  }
   return {
-    setContent: (content) => {
-      if (isDropContent(content)) {
-        drop();
-        return true;
+    resolve(messageId, type, currentContentId, ordinal) {
+      const exactTagId = assignments.get(currentContentId);
+      if (exactTagId !== undefined) {
+        usedTagNumbers.add(exactTagId);
+        return exactTagId;
       }
-      const entry = index.get(callId);
-      if (!entry)
-        return false;
-      let changed = false;
-      for (const occurrence of entry.occurrences) {
-        if (occurrence.kind !== "result")
-          continue;
-        const prevContent = getToolContent(occurrence.part);
-        if (prevContent !== content) {
-          setToolContent(occurrence.part, content);
-          changed = true;
-        }
+      const fallback = getScopedAssignments().get(messageId)?.[type][ordinal];
+      if (!fallback || usedTagNumbers.has(fallback.tagNumber)) {
+        return;
       }
-      return changed;
-    },
-    drop,
-    truncate
+      updateTagMessageId(db, sessionId, fallback.tagNumber, currentContentId);
+      tagger.bindTag(sessionId, currentContentId, fallback.tagNumber);
+      usedTagNumbers.add(fallback.tagNumber);
+      return fallback.tagNumber;
+    }
   };
 }
 
 // src/hooks/magic-context/tag-messages.ts
+init_tag_part_guards();
+init_tool_drop_target();
+function deriveToolOwnerMessageId(sessionId, db, message, obs, unpaired) {
+  const messageId = typeof message.info.id === "string" ? message.info.id : "";
+  if (obs.kind === "invocation") {
+    if (messageId) {
+      const queue4 = unpaired.get(obs.callId) ?? [];
+      queue4.push(messageId);
+      unpaired.set(obs.callId, queue4);
+      return messageId;
+    }
+    return obs.callId;
+  }
+  const queue3 = unpaired.get(obs.callId);
+  if (queue3 && queue3.length > 0) {
+    const popped = queue3.shift();
+    if (queue3.length === 0)
+      unpaired.delete(obs.callId);
+    if (popped !== undefined)
+      return popped;
+  }
+  if (messageId) {
+    const candidates = getCandidateToolOwners(db, sessionId, obs.callId);
+    if (candidates.length > 0) {
+      const ids = [...candidates, messageId];
+      const times = getMessageTimesFromOpenCodeDb(sessionId, ids);
+      const persisted = pickNearestPriorOwner(candidates, messageId, times);
+      if (persisted !== null)
+        return persisted;
+    }
+    return messageId;
+  }
+  return obs.callId;
+}
 function collectRelevantSourceTagIds(messages, assignments) {
   const currentMessageIds = new Set(messages.flatMap((message) => typeof message.info.id === "string" ? [message.info.id] : []));
   const relevantTagIds = new Set;
@@ -169006,6 +170224,8 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const toolTagByCallId = new Map;
   const toolThinkingByCallId = new Map;
   const toolCallIndex = new Map;
+  const unpairedInvocations = new Map;
+  const ownerByPartKey = new Map;
   const batch = new ToolMutationBatch(messages);
   const assignments = tagger.getAssignments(sessionId);
   const resolver = createExistingTagResolver(sessionId, tagger, db);
@@ -169036,22 +170256,37 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
       }
       const toolObservation = extractToolCallObservation(part);
       if (toolObservation) {
-        const entry = toolCallIndex.get(toolObservation.callId) ?? {
+        const ownerMsgId = deriveToolOwnerMessageId(sessionId, db, message, toolObservation, unpairedInvocations);
+        const compositeKey = makeToolCompositeKey(ownerMsgId, toolObservation.callId);
+        const entry = toolCallIndex.get(compositeKey) ?? {
           occurrences: [],
           hasResult: false
         };
         entry.occurrences.push({ message, part, kind: toolObservation.kind });
         if (toolObservation.kind === "result")
           entry.hasResult = true;
-        toolCallIndex.set(toolObservation.callId, entry);
-        const existingTagId = tagger.getTag(sessionId, toolObservation.callId);
+        toolCallIndex.set(compositeKey, entry);
+        let existingTagId = tagger.getToolTag(sessionId, toolObservation.callId, ownerMsgId);
+        if (existingTagId === undefined) {
+          const orphan = getNullOwnerToolTag(db, sessionId, toolObservation.callId);
+          if (orphan !== null) {
+            const claimed = adoptNullOwnerToolTag(db, orphan.id, ownerMsgId);
+            if (claimed) {
+              tagger.bindToolTag(sessionId, toolObservation.callId, ownerMsgId, orphan.tagNumber);
+              existingTagId = orphan.tagNumber;
+            } else {
+              existingTagId = tagger.getToolTag(sessionId, toolObservation.callId, ownerMsgId);
+            }
+          }
+        }
         if (existingTagId !== undefined) {
-          toolTagByCallId.set(toolObservation.callId, existingTagId);
+          toolTagByCallId.set(compositeKey, existingTagId);
           messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, existingTagId));
-          if (message.info.role === "tool" && precedingThinkingParts.length > 0 && !toolThinkingByCallId.has(toolObservation.callId)) {
-            toolThinkingByCallId.set(toolObservation.callId, precedingThinkingParts);
+          if (message.info.role === "tool" && precedingThinkingParts.length > 0 && !toolThinkingByCallId.has(compositeKey)) {
+            toolThinkingByCallId.set(compositeKey, precedingThinkingParts);
           }
         }
+        ownerByPartKey.set(part, { ownerMsgId, callId: toolObservation.callId });
       }
       if (messageId && isTextPart(part)) {
         const textPart = part;
@@ -169097,14 +170332,17 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         const thinkingParts = precedingThinkingParts;
         const reasoningBytes = getReasoningByteSize(thinkingParts);
         const { toolName, inputByteSize } = extractToolTagMetadata(toolPart);
-        const tagId = tagger.assignTag(sessionId, toolPart.callID, "tool", byteSize(toolPart.state.output), db, reasoningBytes, toolName, inputByteSize);
+        const memo = ownerByPartKey.get(part);
+        const ownerMsgId = memo?.ownerMsgId ?? messageId ?? toolPart.callID;
+        const compositeKey = makeToolCompositeKey(ownerMsgId, toolPart.callID);
+        const tagId = tagger.assignToolTag(sessionId, toolPart.callID, ownerMsgId, byteSize(toolPart.state.output), db, reasoningBytes, toolName, inputByteSize);
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         if (!skipPrefixInjection) {
           toolPart.state.output = prependTag(tagId, toolPart.state.output);
         }
-        toolTagByCallId.set(toolPart.callID, tagId);
-        if (thinkingParts.length > 0 && !toolThinkingByCallId.has(toolPart.callID)) {
-          toolThinkingByCallId.set(toolPart.callID, thinkingParts);
+        toolTagByCallId.set(compositeKey, tagId);
+        if (thinkingParts.length > 0 && !toolThinkingByCallId.has(compositeKey)) {
+          toolThinkingByCallId.set(compositeKey, thinkingParts);
         }
       }
       if (messageId && isFilePart(part)) {
@@ -169152,9 +170390,9 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
       }
     }
   }
-  for (const [callId, tagId] of toolTagByCallId) {
-    const thinkingParts = toolThinkingByCallId.get(callId) ?? [];
-    targets.set(tagId, createToolDropTarget(callId, thinkingParts, toolCallIndex, batch));
+  for (const [compositeKey, tagId] of toolTagByCallId) {
+    const thinkingParts = toolThinkingByCallId.get(compositeKey) ?? [];
+    targets.set(tagId, createToolDropTarget(compositeKey, thinkingParts, toolCallIndex, batch));
   }
   const hasRecentReduceCall = lastReduceMessageIndex >= 0 && messages.length - lastReduceMessageIndex <= RECENT_REDUCE_LOOKBACK;
   return {
@@ -169315,11 +170553,9 @@ function applyContextNudge(messages, nudge, nudgePlacements, sessionId) {
 
 // src/features/magic-context/search.ts
 init_logger();
-await init_read_session_chunk();
 init_memory();
 init_embedding();
 init_storage_memory_fts();
-await init_message_index();
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
 var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
 var SEMANTIC_WEIGHT = 0.7;
@@ -169369,11 +170605,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);
@@ -169387,7 +170619,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;
 }
@@ -169483,12 +170715,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,
@@ -169504,7 +170732,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 [];
@@ -169575,20 +170802,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);
 }
@@ -169619,37 +170838,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;
@@ -169787,8 +171006,31 @@ function collectUserPromptParts(message) {
 function hasStackedAugmentation(rawText) {
   return rawText.includes("<sidekick-augmentation>") || rawText.includes("<ctx-search-hint>") || rawText.includes("<ctx-search-auto>");
 }
+function stripNestedSystemReminders(text) {
+  const OPEN = "<system-reminder>";
+  const CLOSE = "</system-reminder>";
+  let result = "";
+  let depth = 0;
+  let i = 0;
+  while (i < text.length) {
+    if (text.startsWith(OPEN, i)) {
+      depth += 1;
+      i += OPEN.length;
+    } else if (text.startsWith(CLOSE, i)) {
+      if (depth > 0)
+        depth -= 1;
+      i += CLOSE.length;
+    } else if (depth === 0) {
+      result += text[i];
+      i += 1;
+    } else {
+      i += 1;
+    }
+  }
+  return result;
+}
 function extractUserPromptText(message) {
-  return collectUserPromptParts(message).replace(/§\d+§\s*/g, "").replace(/<!--\s*\+[\d\s.hmdw]+\s*-->/g, "").replace(/<!--\s*OMO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/[ \t]+\n/g, `
+  return stripNestedSystemReminders(collectUserPromptParts(message)).replace(/§\d+§\s*/g, "").replace(/<!--\s*\+[\d\s.hmdw]+\s*-->/g, "").replace(/<!--\s*OMO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<!--\s*ALFONSO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/[ \t]+\n/g, `
 `).replace(/\n{3,}/g, `
 
 `).trim();
@@ -169944,8 +171186,8 @@ var DEDUP_SAFE_TOOLS = new Set([
   "mcp_lsp_prepare_rename"
 ]);
 function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, 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;
@@ -170010,15 +171252,16 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
   const allMessages = Array.from(messageTagNumbers.keys());
   const toolFingerprints = buildToolFingerprints(allMessages);
   if (toolFingerprints.size > 0) {
-    const tagsByMessageId = new Map;
+    const tagsByCompositeKey = new Map;
     for (const tag of tags) {
       if (tag.type === "tool" && tag.status === "active" && tag.messageId) {
-        tagsByMessageId.set(tag.messageId, tag);
+        const key = tag.toolOwnerMessageId ? `${tag.toolOwnerMessageId}\x00${tag.messageId}` : tag.messageId;
+        tagsByCompositeKey.set(key, tag);
       }
     }
     const fingerprintGroups = new Map;
-    for (const [messageId, fingerprint] of toolFingerprints) {
-      const tag = tagsByMessageId.get(messageId);
+    for (const [compositeKey, fingerprint] of toolFingerprints) {
+      const tag = tagsByCompositeKey.get(compositeKey);
       if (!tag || tag.tagNumber > protectedCutoff)
         continue;
       const group = fingerprintGroups.get(fingerprint) ?? [];
@@ -170075,6 +171318,9 @@ function buildToolFingerprints(messages) {
   for (const message of messages) {
     if (message.info.role !== "assistant")
       continue;
+    const ownerMsgId = typeof message.info.id === "string" ? message.info.id : null;
+    if (!ownerMsgId)
+      continue;
     for (const part of message.parts) {
       const record2 = part;
       const info = extractToolInfo(record2);
@@ -170084,8 +171330,9 @@ function buildToolFingerprints(messages) {
       if (!callId)
         continue;
       try {
-        const fingerprint = `${info.toolName}:${JSON.stringify(info.args)}`;
-        fingerprints.set(callId, fingerprint);
+        const fingerprint = `${ownerMsgId}:${info.toolName}:${JSON.stringify(info.args)}`;
+        const compositeKey = `${ownerMsgId}\x00${callId}`;
+        fingerprints.set(compositeKey, fingerprint);
       } catch {}
     }
   }
@@ -170191,7 +171438,7 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
       const pendingCountBefore = pendingOps.length;
       const tApply = performance.now();
-      didMutateFromPendingOperations = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, args.tags, pendingOps);
+      didMutateFromPendingOperations = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, pendingOps);
       const pendingCountAfter = getPendingOps(args.db, args.sessionId).length;
       if (pendingCountBefore > 0 && pendingCountAfter === 0) {
         clearPersistedStickyTurnReminder(args.db, args.sessionId);
@@ -170222,8 +171469,8 @@ async function runPostTransformPhase(args) {
         logTransformTiming(args.sessionId, "watermarkCleanup", t6);
       }
       const t7 = performance.now();
-      const clearedReasoning = clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge, args.skipTypedReasoningCleanup);
-      stripClearedReasoning(args.messages, args.skipTypedReasoningCleanup);
+      const clearedReasoning = clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge);
+      stripClearedReasoning(args.messages);
       const strippedInline = stripInlineThinking(args.messages, args.messageTagNumbers, args.clearReasoningAge);
       if (clearedReasoning > 0 || strippedInline > 0) {
         let maxTag = 0;
@@ -170493,6 +171740,9 @@ function createTransform(deps) {
     const resolvedSessionId = sessionId;
     logTransformTiming(sessionId, "findSessionId", startTime, `messages=${messages.length}`);
     const db = deps.db;
+    if (deps.client !== undefined) {
+      scheduleReconciliation(db, sessionId, readRawSessionMessages);
+    }
     const tUserMsg = performance.now();
     const currentTurnId = findLastUserMessageId(messages);
     logTransformTiming(sessionId, "findLastUserMessageId", tUserMsg);
@@ -170508,12 +171758,16 @@ function createTransform(deps) {
     const reducedMode = sessionMeta.isSubagent;
     const fullFeatureMode = !reducedMode;
     let sessionDirectory = deps.directory ?? "";
-    if (deps.client !== undefined) {
+    const cachedDirectory = deps.sessionDirectoryBySession?.get(sessionId);
+    if (cachedDirectory && cachedDirectory.length > 0) {
+      sessionDirectory = cachedDirectory;
+    } else if (deps.client !== undefined) {
       try {
         const sessionResponse = await deps.client.session.get({ path: { id: sessionId } }).catch(() => null);
         const sessionInfo = sessionResponse?.data;
         if (sessionInfo && typeof sessionInfo.directory === "string" && sessionInfo.directory.length > 0) {
           sessionDirectory = sessionInfo.directory;
+          deps.sessionDirectoryBySession?.set(sessionId, sessionDirectory);
         }
       } catch {}
     }
@@ -170710,13 +171964,17 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       }
     }
     const t1 = performance.now();
-    const tags = getTagsBySession(db, sessionId);
-    logTransformTiming(sessionId, "getTagsBySession", t1, `count=${tags.length}`);
+    const activeTags = getActiveTagsBySession(db, sessionId);
+    logTransformTiming(sessionId, "getActiveTagsBySession", t1, `count=${activeTags.length}`);
+    const t1b = performance.now();
+    const targetTagNumbers = [...targets.keys()];
+    const targetsSliceTags = getTagsByNumbers(db, sessionId, targetTagNumbers);
+    logTransformTiming(sessionId, "getTagsByNumbers", t1b, `targets=${targetTagNumbers.length} fetched=${targetsSliceTags.length}`);
     let didMutateFromFlushedStatuses = false;
     if (taggingSucceeded) {
       try {
         const t2 = performance.now();
-        didMutateFromFlushedStatuses = applyFlushedStatuses(sessionId, db, targets, tags);
+        didMutateFromFlushedStatuses = applyFlushedStatuses(sessionId, db, targets, targetsSliceTags);
         logTransformTiming(sessionId, "applyFlushedStatuses", t2);
         batch?.finalize();
         logTransformTiming(sessionId, "batchFinalize:flushed", t2);
@@ -170732,12 +171990,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     const t3 = performance.now();
     const strippedStructuralNoise = stripStructuralNoise(messages);
     logTransformTiming(sessionId, "stripStructuralNoise", t3, `strippedParts=${strippedStructuralNoise}`);
-    const currentSessionModel = deps.liveModelBySession?.get(sessionId) ?? findLastAssistantModel(messages) ?? undefined;
-    const skipTypedReasoningCleanup = modelRequiresInterleavedReasoning(currentSessionModel);
     const persistedReasoningWatermark = sessionMeta?.clearedReasoningThroughTag ?? 0;
     if (persistedReasoningWatermark > 0) {
       const tReplay = performance.now();
-      const replayed = replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark, skipTypedReasoningCleanup);
+      const replayed = replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark);
       const replayedInline = replayStrippedInlineThinking(messages, messageTagNumbers, persistedReasoningWatermark);
       if (replayed > 0 || replayedInline > 0) {
         sessionLog(sessionId, `reasoning replay: cleared=${replayed} inlineStripped=${replayedInline} (watermark=${persistedReasoningWatermark})`);
@@ -170746,27 +172002,22 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     }
     if (!deps.ctxReduceEnabled && !reducedMode && deps.cavemanTextCompression?.enabled) {
       const tCavemanReplay = performance.now();
-      const replayedCaveman = replayCavemanCompression(sessionId, db, targets, tags);
+      const replayedCaveman = replayCavemanCompression(sessionId, db, targets, targetsSliceTags);
       if (replayedCaveman > 0) {
         sessionLog(sessionId, `caveman replay: re-applied ${replayedCaveman} text tags`);
       }
       logTransformTiming(sessionId, "replayCavemanCompression", tCavemanReplay);
     }
     const t4 = performance.now();
-    const strippedClearedReasoning = stripClearedReasoning(messages, skipTypedReasoningCleanup);
+    const strippedClearedReasoning = stripClearedReasoning(messages);
     logTransformTiming(sessionId, "stripClearedReasoning", t4, `strippedParts=${strippedClearedReasoning}`);
     const tMergeStrip = performance.now();
-    const strippedMergedReasoning = skipTypedReasoningCleanup ? 0 : stripReasoningFromMergedAssistants(messages);
+    const strippedMergedReasoning = stripReasoningFromMergedAssistants(messages);
     if (strippedMergedReasoning > 0) {
       sessionLog(sessionId, `stripped ${strippedMergedReasoning} reasoning parts from merged assistants (anthropic groupIntoBlocks workaround)`);
     }
     logTransformTiming(sessionId, "stripReasoningFromMergedAssistants", tMergeStrip, `strippedParts=${strippedMergedReasoning}`);
-    let watermark = 0;
-    for (const tag of tags) {
-      if (tag.status === "dropped" && tag.tagNumber > watermark) {
-        watermark = tag.tagNumber;
-      }
-    }
+    const watermark = getMaxDroppedTagNumber(db, sessionId);
     const contextUsage = contextUsageEarly;
     const schedulerDecision = schedulerDecisionEarly;
     const rawGetNotifParams = deps.getNotificationParams;
@@ -170816,7 +172067,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       sessionId,
       db,
       messages,
-      tags,
+      tags: activeTags,
       targets,
       reasoningByMessage,
       messageTagNumbers,
@@ -170842,7 +172093,6 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       watermark,
       forceMaterializationPercentage: FORCE_MATERIALIZE_PERCENTAGE,
       hasRecentReduceCall,
-      skipTypedReasoningCleanup,
       projectPath: deps.projectPath,
       autoSearch: deps.autoSearch,
       cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined
@@ -171211,6 +172461,7 @@ function createEventHandler2(deps) {
       sessionLog(info.sessionID, `event message.removed: invalidating state for message ${info.messageID}`);
       try {
         const cleanup = cleanupRemovedMessageState(deps, info.sessionID, info.messageID);
+        scheduleClearAndReindex(deps.db, info.sessionID, readRawSessionMessages);
         deps.tagger.cleanup(info.sessionID);
         sessionLog(info.sessionID, "event message.removed: invalidated tagger session cache");
         if (cleanup.clearedNudgePlacement) {
@@ -171329,7 +172580,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);
@@ -171420,7 +172671,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;
@@ -171493,6 +172744,7 @@ function clearSidebarSnapshotCache(sessionId) {
 // src/hooks/magic-context/hook-handlers.ts
 init_logger();
 init_note_nudger();
+await init_read_session_chunk();
 var TOOL_HEAVY_TURN_REMINDER_THRESHOLD = 5;
 var TOOL_HEAVY_TURN_REMINDER_TEXT = `
 
@@ -171545,6 +172797,14 @@ function createEventHook(args) {
   return async (input) => {
     await args.eventHandler(input);
     if (input.event.type === "message.updated") {
+      const messageInfo = getMessageUpdatedInfo(input.event.properties);
+      if (messageInfo?.messageID) {
+        const isTerminalUser = messageInfo.role === "user";
+        const isTerminalAssistant = messageInfo.role === "assistant" && (typeof messageInfo.completedAt === "number" || typeof messageInfo.finish === "string");
+        if (isTerminalUser || isTerminalAssistant) {
+          scheduleIncrementalIndex(args.db, messageInfo.sessionID, messageInfo.messageID, readRawSessionMessageById);
+        }
+      }
       const assistantInfo = getMessageUpdatedAssistantInfo(input.event.properties);
       if (assistantInfo?.providerID && assistantInfo?.modelID) {
         const previous = args.liveModelBySession.get(assistantInfo.sessionID);
@@ -171566,10 +172826,14 @@ function createEventHook(args) {
     const sessionId = resolveSessionId(properties);
     if (!sessionId)
       return;
+    if (input.event.type !== "session.deleted") {
+      scheduleReconciliation(args.db, sessionId, readRawSessionMessages);
+    }
     if (input.event.type === "session.deleted") {
       args.liveModelBySession.delete(sessionId);
       args.variantBySession.delete(sessionId);
       args.agentBySession.delete(sessionId);
+      args.sessionDirectoryBySession.delete(sessionId);
       args.recentReduceBySession.delete(sessionId);
       args.toolUsageSinceUserTurn.delete(sessionId);
       args.historyRefreshSessions.delete(sessionId);
@@ -171580,6 +172844,7 @@ function createEventHook(args) {
       clearNoteNudgeState(args.db, sessionId);
       clearAutoSearchForSession(sessionId);
       clearSidebarSnapshotCache(sessionId);
+      clearSessionTracking(sessionId);
     }
   };
 }
@@ -171627,8 +172892,8 @@ init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync8, realpathSync } from "node:fs";
-import { join as join19, resolve as resolve4, sep } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, realpathSync } from "node:fs";
+import { join as join21, resolve as resolve4, sep } from "node:path";
 
 // src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -171741,9 +173006,9 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join19(directory, filename);
+    const filePath = join21(directory, filename);
     try {
-      if (existsSync10(filePath)) {
+      if (existsSync12(filePath)) {
         const content = readFileSync8(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
@@ -171856,7 +173121,7 @@ ${items}
                 log(`[magic-context] key file path escapes project root, skipping: ${entry.filePath}`);
                 continue;
               }
-              if (!existsSync10(absPath))
+              if (!existsSync12(absPath))
                 continue;
               let realPath;
               try {
@@ -172024,6 +173289,7 @@ function createMagicContextHook(deps) {
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
   const liveModelBySession = deps.liveSessionState?.liveModelBySession ?? new Map;
   const agentBySession = deps.liveSessionState?.agentBySession ?? new Map;
+  const sessionDirectoryBySession = deps.liveSessionState?.sessionDirectoryBySession ?? new Map;
   const recentReduceBySession = new Map;
   const toolUsageSinceUserTurn = new Map;
   const resolveLiveModel = (sessionId) => {
@@ -172091,6 +173357,7 @@ function createMagicContextHook(deps) {
     compressorMaxMergeDepth: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.max_merge_depth,
     compressorCooldownMs: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.cooldown_ms,
     liveModelBySession,
+    sessionDirectoryBySession,
     autoSearch: deps.config.experimental?.auto_search?.enabled ? {
       enabled: true,
       scoreThreshold: deps.config.experimental.auto_search.score_threshold,
@@ -172255,6 +173522,7 @@ function createMagicContextHook(deps) {
     liveModelBySession,
     variantBySession,
     agentBySession,
+    sessionDirectoryBySession,
     recentReduceBySession,
     toolUsageSinceUserTurn,
     historyRefreshSessions,
@@ -172398,8 +173666,14 @@ function truncateError(name2, code, message, maxLen = 240) {
 
 // src/plugin/rpc-handlers.ts
 init_project_identity();
+init_storage_memory();
+init_tool_definition_tokens();
 await init_storage();
 init_read_session_formatting();
+await __promiseAll([
+  init_inject_compartments(),
+  init_read_session_db()
+]);
 
 // src/hooks/magic-context/tokenizer-calibration.ts
 var CALIBRATION_TABLE = [
@@ -172606,7 +173880,7 @@ function resolveConfigValue(cfg, key, modelKey, defaultValue) {
   }
   return defaultValue;
 }
-function buildSidebarSnapshot(db, sessionId, directory, liveSessionState) {
+function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens) {
   const empty = {
     sessionId,
     usagePercentage: 0,
@@ -172691,6 +173965,20 @@ ${c.content}
       const cached2 = meta3.memory_block_cache;
       if (typeof cached2 === "string" && cached2.length > 0) {
         memoryTokens = estimateTokens(cached2);
+      } else if (memoryBlockCount > 0 && projectIdentity) {
+        try {
+          let memories = getMemoriesByProject(db, projectIdentity, [
+            "active",
+            "permanent"
+          ]);
+          if (injectionBudgetTokens && memories.length > 0) {
+            memories = trimMemoriesToBudget(sessionId, memories, injectionBudgetTokens);
+          }
+          const block = renderMemoryBlock(memories);
+          memoryTokens = block ? estimateTokens(block) : 0;
+        } catch {
+          memoryTokens = 0;
+        }
       }
     }
     let lastDreamerRunAt = null;
@@ -172709,8 +173997,24 @@ ${c.content}
     let activeProviderID;
     let activeModelID;
     if (liveSessionState) {
-      const model = liveSessionState.liveModelBySession.get(sessionId);
-      const agent = liveSessionState.agentBySession.get(sessionId);
+      let model = liveSessionState.liveModelBySession.get(sessionId);
+      let agent = liveSessionState.agentBySession.get(sessionId);
+      if (!model || !agent) {
+        const recovered = findLastAssistantModelFromOpenCodeDb(sessionId);
+        if (recovered) {
+          if (!model) {
+            model = {
+              providerID: recovered.providerID,
+              modelID: recovered.modelID
+            };
+            liveSessionState.liveModelBySession.set(sessionId, model);
+          }
+          if (!agent && recovered.agent) {
+            agent = recovered.agent;
+            liveSessionState.agentBySession.set(sessionId, agent);
+          }
+        }
+      }
       if (model) {
         activeProviderID = model.providerID;
         activeModelID = model.modelID;
@@ -172759,8 +174063,8 @@ ${c.content}
     return empty;
   }
 }
-function buildStatusDetail(db, sessionId, directory, modelKey, config2, liveSessionState) {
-  const base = buildSidebarSnapshot(db, sessionId, directory, liveSessionState);
+function buildStatusDetail(db, sessionId, directory, modelKey, config2, liveSessionState, injectionBudgetTokens) {
+  const base = buildSidebarSnapshot(db, sessionId, directory, liveSessionState, injectionBudgetTokens);
   const detail = {
     ...base,
     tagCounter: 0,
@@ -172876,13 +174180,14 @@ function registerRpcHandlers(rpcServer, args) {
   const { directory, config: config2, liveSessionState } = args;
   const rawConfig = config2;
   const getNotificationParams = (sessionId) => getLiveNotificationParams(sessionId, liveSessionState.liveModelBySession, liveSessionState.variantBySession, liveSessionState.agentBySession);
+  const injectionBudgetTokens = config2.memory?.injection_budget_tokens;
   rpcServer.handle("sidebar-snapshot", async (params) => {
     const sessionId = String(params.sessionId ?? "");
     const dir = String(params.directory ?? directory);
     const db = getDb();
     if (!db || !sessionId)
       return { error: "unavailable" };
-    return buildSidebarSnapshot(db, sessionId, dir, liveSessionState);
+    return buildSidebarSnapshot(db, sessionId, dir, liveSessionState, injectionBudgetTokens);
   });
   rpcServer.handle("status-detail", async (params) => {
     const sessionId = String(params.sessionId ?? "");
@@ -172891,7 +174196,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db || !sessionId)
       return { error: "unavailable" };
-    return buildStatusDetail(db, sessionId, dir, modelKey, rawConfig, liveSessionState);
+    return buildStatusDetail(db, sessionId, dir, modelKey, rawConfig, liveSessionState, injectionBudgetTokens);
   });
   rpcServer.handle("compartment-count", async (params) => {
     const sessionId = String(params.sessionId ?? "");
@@ -173898,19 +175203,19 @@ init_models_dev_cache();
 
 // src/shared/rpc-server.ts
 init_logger();
-import { mkdirSync as mkdirSync5, renameSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync6, renameSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash5 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash5("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortFilePath(storageDir, directory) {
-  return join20(storageDir, "rpc", projectHash(directory), "port");
+  return join22(storageDir, "rpc", projectHash(directory), "port");
 }
 
 // src/shared/rpc-server.ts
@@ -173941,10 +175246,10 @@ class MagicContextRpcServer {
         this.port = addr.port;
         this.server = server;
         try {
-          const dir = dirname4(this.portFilePath);
-          mkdirSync5(dir, { recursive: true });
+          const dir = dirname5(this.portFilePath);
+          mkdirSync6(dir, { recursive: true });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync5(tmpPath, String(this.port), "utf-8");
+          writeFileSync6(tmpPath, String(this.port), "utf-8");
           renameSync(tmpPath, this.portFilePath);
           log(`[rpc] server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
@@ -174106,7 +175411,7 @@ var plugin = async (ctx) => {
     refreshModelLimitsFromApi(ctx.client);
     setInterval(() => {
       refreshModelLimitsFromApi(ctx.client);
-    }, 5 * 60 * 1000);
+    }, 60 * 60 * 1000);
   }
   if (conflictResult?.hasConflict) {
     sendConflictWarning(ctx.client, ctx.directory, conflictResult);