@cortexkit/pi-magic-context 0.49.34 → 0.49.36

package/dist/{index-np9ryr8y.js → index-a7sj2bam.js}

@@ -1,15 +1,14 @@
+import {
+  getHarness2,
+  harnessOwnsOpenCodeStore2
+} from "./index-0h2mkab2.js";
 import {
   getMagicContextStorageDir,
   getLegacyOpenCodeMagicContextStorageDir,
-  sanitizeDiagnosticText,
   importPluginModule,
   writeForwardedLogLine2,
   log2
-} from "./index-fgs78jyd.js";
-import {
-  getHarness2,
-  harnessOwnsOpenCodeStore2
-} from "./index-0h2mkab2.js";
+} from "./index-gymgz20n.js";
 import {
   inRootAsyncContext2,
   registerSlowWriteReporter2,
@@ -25,13 +24,19 @@ import {
 } from "./index-2qtx0q6h.js";
 import {
   scheduleAfterBootQuiet
-} from "./index-48twbev2.js";
+} from "./index-6pk49fc3.js";
 import {
   configureContextDatabasePragmas2
 } from "./index-fapenpch.js";
+import {
+  attachFailClosedBlockingProcessEvidence
+} from "./index-3bb24eb6.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
 import {
   startMessageFtsRowidMapBackfill2
-} from "./index-bvpar0bg.js";
+} from "./index-ck8wj35v.js";
 import {
   LKG_SLOT_CHUNKS_DDL,
   SESSION_REPLAY_DECISIONS_DDL,
@@ -41,24 +46,26 @@ import {
   hasPendingMigrations,
   getMainThreadMigrationBodyCount,
   runMigrations
-} from "./index-pb3ea2tq.js";
+} from "./index-d107f484.js";
 import {
   ensureColumn,
   installV95PerfSchema,
   installTagIdentityRevisionTrigger
-} from "./index-c474g0gj.js";
+} from "./index-yacs388s.js";
 import {
   resolveOpenCodeDbPath,
-  hasV1MessageTables,
+  hasV1MessageTables
+} from "./index-n0zjvs3h.js";
+import {
   setDatabase,
   loadToolDefinitionMeasurements
-} from "./index-23t8ryqw.js";
+} from "./index-c6wbq66z.js";
 import {
   closeQuietly
 } from "./index-nrzkqte4.js";
 import {
   logSlowWriteTransaction
-} from "./index-hqw0rt9k.js";
+} from "./index-0wtm7g7f.js";
 import {
   shouldEnforcePrivateStoragePermissions,
   ensureStorageDirectorySync,
@@ -68,230 +75,6 @@ import {
   tightenStorageTreeSync
 } from "./index-81nthk8j.js";
 
-// ../plugin/src/features/magic-context/fail-closed-block.ts
-var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
-var FAIL_CLOSED_REPROBE_EVERY_N = 5;
-function attachFailClosedBlockingProcessEvidence(process2, evidence) {
-  Object.defineProperties(process2, {
-    startTime: { configurable: true, value: evidence.startTime },
-    commandLine: { configurable: true, value: evidence.commandLine }
-  });
-  return process2;
-}
-
-class FailClosedBlockingError extends Error {
-  code = "FAIL_CLOSED_BLOCKING";
-  reason;
-  constructor(message, reason, options) {
-    super(message, options);
-    this.name = "FailClosedBlockingError";
-    this.reason = reason;
-  }
-}
-var OPENCODE_INTERNAL_AGENT_NAMES = new Set(["title", "summary", "compaction"]);
-function isMagicContextHiddenAgentName(agent) {
-  if (agent === "smart-note-compiler" || agent.startsWith("smart-note-")) {
-    return true;
-  }
-  if (agent === "historian" || agent.startsWith("historian-"))
-    return true;
-  if (agent === "dreamer" || agent.startsWith("dreamer-"))
-    return true;
-  return false;
-}
-var MAX_FORMATTED_BLOCKING_PROCESSES = 8;
-var MAX_FORMATTED_COMMAND_LINE_LENGTH = 80;
-function normalizeFailClosedProcessKind(process2) {
-  switch (process2.kind) {
-    case "OpenCode server":
-    case "OpenCode instance (TUI/CLI)":
-    case "Pi":
-    case "process":
-      return process2.kind;
-  }
-  switch (process2.harness?.trim().toLowerCase()) {
-    case "opencode server":
-      return "OpenCode server";
-    case "opencode instance (tui/cli)":
-    case "opencode instance":
-      return "OpenCode instance (TUI/CLI)";
-    case "pi":
-    case "pi harness":
-    case "omp":
-      return "Pi";
-    default:
-      return "process";
-  }
-}
-function formatFailClosedProcessStartTime(startTime) {
-  if (!Number.isFinite(startTime) || startTime <= 0)
-    return "unverified";
-  try {
-    const parts = new Intl.DateTimeFormat("en-US", {
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-      month: "short",
-      hour12: false
-    }).formatToParts(new Date(startTime));
-    const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
-    if (!values.month || !values.day || !values.hour || !values.minute)
-      return "unverified";
-    return `${values.month} ${values.day} ${values.hour}:${values.minute}`;
-  } catch {
-    return "unverified";
-  }
-}
-function formatFailClosedCommandLine(commandLine) {
-  if (typeof commandLine !== "string" || commandLine.trim().length === 0)
-    return "unverified";
-  try {
-    const normalized = commandLine.replaceAll("\x00", " ").replace(/\s+/g, " ").trim();
-    if (normalized.length === 0)
-      return "unverified";
-    const sanitized = sanitizeDiagnosticText(normalized).trim();
-    if (sanitized.length === 0)
-      return "unverified";
-    return sanitized.length > MAX_FORMATTED_COMMAND_LINE_LENGTH ? `${sanitized.slice(0, MAX_FORMATTED_COMMAND_LINE_LENGTH - 3)}...` : sanitized;
-  } catch {
-    return "unverified";
-  }
-}
-function formatFailClosedBlockingProcesses(processes) {
-  const uniqueProcesses = new Map;
-  for (const process2 of processes) {
-    if (!Number.isInteger(process2.pid) || process2.pid <= 0)
-      continue;
-    const candidate = {
-      kind: normalizeFailClosedProcessKind(process2),
-      pid: process2.pid,
-      startTime: process2.startTime,
-      commandLine: process2.commandLine
-    };
-    const previous = uniqueProcesses.get(process2.pid);
-    if (!previous || previous.kind === "process" && candidate.kind !== "process") {
-      uniqueProcesses.set(process2.pid, candidate);
-    } else {
-      uniqueProcesses.set(process2.pid, {
-        ...previous,
-        startTime: previous.startTime ?? candidate.startTime,
-        commandLine: previous.commandLine ?? candidate.commandLine
-      });
-    }
-  }
-  const entries = [...uniqueProcesses.values()];
-  const visible = entries.slice(0, MAX_FORMATTED_BLOCKING_PROCESSES);
-  const rendered = visible.map(({ kind, pid }) => `${kind} (PID ${pid})`);
-  const omitted = entries.length - visible.length;
-  if (omitted > 0)
-    rendered.push(`${omitted} more blocking process(es)`);
-  if (rendered.length === 0)
-    return "a live process";
-  const summary = rendered.length === 1 ? rendered[0] : `${rendered.slice(0, -1).join(", ")}, and ${rendered.at(-1)}`;
-  const evidence = entries.map(({ kind, pid, startTime, commandLine }) => `- PID ${pid}: ${kind}, started ${formatFailClosedProcessStartTime(startTime)}, cmd: ${formatFailClosedCommandLine(commandLine)}`).join(`
-`);
-  return `${summary}
-Blocking process evidence:
-${evidence}`;
-}
-function formatFailClosedBlockingMessage(reason) {
-  if (reason.kind === "migration_guard") {
-    if (reason.unreadableFile) {
-      const arm = reason.unreadableArm ?? "io";
-      const recovery = arm === "io" ? `If none of these processes are running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop the relevant process before deleting it.`;
-      return [
-        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live process cannot be proven.`,
-        recovery,
-        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-      ].join(" ");
-    }
-    return [
-      `Magic Context cannot migrate the shared database (one database serves every project on this machine) because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
-      `The database is at upstream migration v${reason.persistedVersion}; this build needs v${reason.supportedVersion}.`,
-      "Restart the blocking process — even one from a different project — and it will pick up the new build and migrate on start; or shut it down and retry.",
-      "If that host loads a pinned or cached older Magic Context build, a restart alone is not enough: stop it or update its Magic Context build, then start this host once so it migrates the database with nothing older attached.",
-      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-    ].join(" ");
-  }
-  if (reason.kind === "schema_fence") {
-    return [
-      `Magic Context cannot operate: this Magic Context build is older than the database; upgrade/restart this harness (upstream migration lane v${reason.persistedVersion}, build supports through v${reason.supportedVersion}).`,
-      `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-    ].join(" ");
-  }
-  const cause = reason.cause.trim().length > 0 ? reason.cause.trim() : "unknown storage error";
-  return [
-    `Magic Context cannot operate: persistent storage failed (${cause}).`,
-    "The plugin will not silently degrade to native compaction while enabled.",
-    `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
-  ].join(" ");
-}
-function createFailClosedBlockingError(reason, options) {
-  return new FailClosedBlockingError(formatFailClosedBlockingMessage(reason), reason, options);
-}
-function isFailClosedBlockingError(error) {
-  return error instanceof FailClosedBlockingError || typeof error === "object" && error !== null && error.name === "FailClosedBlockingError" && error.code === "FAIL_CLOSED_BLOCKING";
-}
-function shouldBypassFailClosedBlock(input) {
-  if (input.isPiSubagentEnv === true)
-    return true;
-  if (input.isInternalChildSession === true)
-    return true;
-  const agent = typeof input.agent === "string" ? input.agent.trim() : "";
-  if (agent.length === 0)
-    return false;
-  if (OPENCODE_INTERNAL_AGENT_NAMES.has(agent))
-    return true;
-  if (isMagicContextHiddenAgentName(agent))
-    return true;
-  return false;
-}
-function createFailClosedController(options) {
-  const reprobeEveryN = Math.max(1, options?.reprobeEveryN ?? FAIL_CLOSED_REPROBE_EVERY_N);
-  let reason = null;
-  let blockedPassCount = 0;
-  return {
-    arm(next) {
-      reason = next;
-      blockedPassCount = 0;
-    },
-    clear() {
-      reason = null;
-      blockedPassCount = 0;
-    },
-    isArmed() {
-      return reason !== null;
-    },
-    getReason() {
-      return reason;
-    },
-    async enforce(input) {
-      if (!reason)
-        return;
-      if (!input.blockingEnabled)
-        return;
-      if (input.exempt)
-        return;
-      blockedPassCount += 1;
-      const shouldReprobe = typeof input.tryReopen === "function" && (blockedPassCount === 1 || blockedPassCount % reprobeEveryN === 0);
-      if (shouldReprobe) {
-        try {
-          const healed = await input.tryReopen?.();
-          if (healed) {
-            reason = null;
-            blockedPassCount = 0;
-            return;
-          }
-        } catch {}
-      }
-      const blockedReason = reason;
-      if (!blockedReason)
-        return;
-      throw createFailClosedBlockingError(blockedReason);
-    }
-  };
-}
-
 // ../plugin/src/shared/rpc-utils.ts
 import { execFile, execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
@@ -1211,7 +994,7 @@ function runMigrationsOffThread(data) {
   return new Promise((resolve, reject) => {
     let worker;
     try {
-      worker = inRootAsyncContext2(() => new Worker(workerEntryOverride ?? defaultWorkerEntry(), { workerData: data }));
+      worker = inRootAsyncContext2(() => workerEntryOverride ? new Worker(workerEntryOverride, { workerData: data }) : reuseWorker(defaultWorkerEntry(), { workerData: data }));
     } catch (error) {
       reject(workerStartError(error instanceof Error ? error.message : String(error)));
       return;
@@ -2005,8 +1788,8 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
       state.running = startMessageFtsRowidMapBackfill2(db, signal).then(async () => {
         if (signal.aborted || !readsOpenCodeStore)
           return;
-        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-2xcp6f40.js"));
-        const { startMessageTimeBackfill } = await importPluginModule(() => import("./message-time-backfill-e3r8ddh1.js"));
+        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-jxq427v6.js"));
+        const { startMessageTimeBackfill } = await importPluginModule(() => import("./message-time-backfill-x45573rs.js"));
         if (signal.aborted)
           return;
         await startMessageTimeBackfill(db, Object.assign(readRawSessionMessages, {
@@ -3525,4 +3308,4 @@ function closeDatabase() {
   return Promise.all(pendingDatabaseCloses).then(() => {});
 }
 
-export { FAIL_CLOSED_DOCTOR_COMMAND, formatFailClosedBlockingMessage, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, createFailClosedController, piHarnessKindFromExecutable, isPidAlive, readProcessStartTime, getErrorMessage, describeError, startBootDeadline, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, enforceSchemaFence, setSqlitePragmaConfig, applySqliteTuningPragmas, runSqliteOptimize, initializeDatabase, openDatabase, openCurrentDatabase, openDatabaseAsync, closeDatabase };
+export { piHarnessKindFromExecutable, isPidAlive, readProcessStartTime, getErrorMessage, describeError, startBootDeadline, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, enforceSchemaFence, setSqlitePragmaConfig, applySqliteTuningPragmas, runSqliteOptimize, initializeDatabase, openDatabase, openCurrentDatabase, openDatabaseAsync, closeDatabase };

package/dist/index-by1bzjcd.js

@@ -0,0 +1,24 @@
+// ../plugin/src/hooks/magic-context/host-served-rows.ts
+var HOST_UNSERVED_ROW = "hostUnservedRow";
+function markHostUnservedRow(target) {
+  Object.defineProperty(target, HOST_UNSERVED_ROW, {
+    value: true,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+}
+function isHostUnservedRow(value) {
+  return typeof value === "object" && value !== null && value[HOST_UNSERVED_ROW] === true;
+}
+function retreatPastHostUnservedRows(messages, exclusiveEnd, floor) {
+  if (!messages.some(isHostUnservedRow))
+    return exclusiveEnd;
+  const byOrdinal = new Map(messages.map((message) => [message.ordinal, message]));
+  let end = exclusiveEnd;
+  while (end - 1 >= floor && isHostUnservedRow(byOrdinal.get(end - 1)))
+    end -= 1;
+  return end;
+}
+
+export { markHostUnservedRow, isHostUnservedRow, retreatPastHostUnservedRows };

package/dist/{index-6981g1xv.js → index-c1dqxr10.js}

@@ -5,13 +5,16 @@ import {
 } from "./index-2qtx0q6h.js";
 import {
   registerExitAbort
-} from "./index-399p688g.js";
+} from "./index-8sqebjzk.js";
 import {
   log2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
 import {
   createWorkerShutdown
-} from "./index-54wmg4rj.js";
+} from "./index-x2n261wp.js";
 
 // ../plugin/src/hooks/magic-context/read-session-raw.ts
 import { isMainThread } from "node:worker_threads";
@@ -60,6 +63,7 @@ function runSessionWarmupWorker(input, options) {
       clearTimeout(deadline);
       options.signal?.removeEventListener("abort", abort);
       if (worker) {
+        worker.off("online", startDeadline);
         activeWorkers.delete(worker);
         const stopped = shutdown?.close() ?? worker.terminate();
         worker.unref();
@@ -77,6 +81,10 @@ function runSessionWarmupWorker(input, options) {
       deadline = setTimeout(() => finish({ failure, detail: `no reply within ${ms} ms` }), ms);
       deadline.unref?.();
     };
+    const startDeadline = () => {
+      if (!settled)
+        arm("not-accepted", options.acceptMs ?? ACCEPT_TIMEOUT_MS);
+    };
     const abort = () => finish({ failure: "stopped", detail: "stopped" });
     if (options.signal?.aborted) {
       abort();
@@ -84,8 +92,14 @@ function runSessionWarmupWorker(input, options) {
     }
     options.signal?.addEventListener("abort", abort, { once: true });
     try {
-      worker = inRootAsyncContext2(() => new Worker(options.entry ?? defaultEntry(), {
+      worker = inRootAsyncContext2(() => options.entry ? new Worker(options.entry, {
         workerData: { ...input, openCancellation: openCancellation.buffer }
+      }) : reuseWorker(defaultEntry(), {
+        workerData: {
+          ...input,
+          job: rawWorkerJobKind(input),
+          openCancellation: openCancellation.buffer
+        }
       }));
       shutdown = createWorkerShutdown(worker, "raw-ordinal-warmup", WARMUP_CLOSE_DEADLINE_MS);
     } catch (error) {
@@ -94,7 +108,10 @@ function runSessionWarmupWorker(input, options) {
     }
     worker.unref();
     activeWorkers.set(worker, (failure) => finish({ failure, detail: "stopped" }));
-    arm("not-accepted", options.acceptMs ?? ACCEPT_TIMEOUT_MS);
+    if (options.entry)
+      startDeadline();
+    else
+      worker.once("online", startDeadline);
     worker.on("message", (reply) => {
       if (reply.kind === "accepted")
         arm("no-result", options.resultMs ?? RESULT_TIMEOUT_MS);
@@ -124,6 +141,19 @@ function runSessionWarmupWorker(input, options) {
     worker.on("exit", (code) => finish({ failure: "exited", detail: `exit code ${code}` }));
   });
 }
+function rawWorkerJobKind(input) {
+  if (input.indexMessage)
+    return "index-message";
+  if (input.ftsRowidBackfill)
+    return "fts-rowid-backfill";
+  if (input.searchArchive)
+    return "search-archive";
+  if (input.exactOrdinalIds)
+    return "exact-ordinal-ids";
+  if (input.tagRatio !== undefined)
+    return input.tagState ? "tag-delta" : "tag-summary";
+  return "ordinal-scan";
+}
 function prewarmRawSessionOrdinalsForDb(db, sessionId, options = {}) {
   if (isRawSessionSummaryWarm2(db, sessionId))
     return Promise.resolve("warm");

package/dist/index-c6wbq66z.js

@@ -0,0 +1,168 @@
+// ../plugin/src/shared/bounded-session-map.ts
+class BoundedSessionMap {
+  maxEntries;
+  store = new Map;
+  constructor(maxEntries) {
+    if (!Number.isFinite(maxEntries) || maxEntries < 1) {
+      throw new Error(`BoundedSessionMap: maxEntries must be >= 1, got ${maxEntries}`);
+    }
+    this.maxEntries = maxEntries;
+  }
+  get(sessionId) {
+    const value = this.store.get(sessionId);
+    if (value === undefined)
+      return;
+    this.store.delete(sessionId);
+    this.store.set(sessionId, value);
+    return value;
+  }
+  peek(sessionId) {
+    return this.store.get(sessionId);
+  }
+  has(sessionId) {
+    return this.store.has(sessionId);
+  }
+  set(sessionId, value) {
+    if (this.store.has(sessionId)) {
+      this.store.delete(sessionId);
+    } else if (this.store.size >= this.maxEntries) {
+      const oldest = this.store.keys().next().value;
+      if (oldest !== undefined)
+        this.store.delete(oldest);
+    }
+    this.store.set(sessionId, value);
+  }
+  delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+}
+
+// ../plugin/src/features/magic-context/tool-definition-tokens.ts
+var ACTIVITY_WINDOW_MS = 10 * 60000;
+var MAX_ACTIVITY_GAP_MS = 60000;
+var WINDOWED_SINCE_KEY = "tool_definition_measurements:windowed_since";
+var routes = new Map;
+var sessionFlights = new BoundedSessionMap(1000);
+var persistenceDb = null;
+var windowedSince;
+var boundAt = 0;
+var cachedInsertStmt = null;
+var cachedDeleteStmt = null;
+function agentKey(agentName) {
+  return agentName && agentName.length > 0 ? agentName : "default";
+}
+function keyFor(providerID, modelID, agentName) {
+  return `${providerID}/${modelID}/${agentKey(agentName)}`;
+}
+function routeFor(providerID, modelID, agentName) {
+  const key = keyFor(providerID, modelID, agentName);
+  let route = routes.get(key);
+  if (!route) {
+    route = {
+      providerID,
+      modelID,
+      agentName: agentKey(agentName),
+      tools: new Map,
+      live: false,
+      clock: 0,
+      lastWallAt: Date.now(),
+      oldestFireAt: Number.POSITIVE_INFINITY,
+      retired: new Map,
+      legacyRows: new Set
+    };
+    routes.set(key, route);
+  }
+  return { key, route };
+}
+function advanceClock(route) {
+  const now = Date.now();
+  const gap = Math.min(Math.max(now - route.lastWallAt, 0), MAX_ACTIVITY_GAP_MS);
+  route.clock += gap;
+  route.lastWallAt = Math.max(route.lastWallAt, now);
+  return route.clock;
+}
+function readWindowedSince(db) {
+  try {
+    const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(WINDOWED_SINCE_KEY);
+    if (!row)
+      return;
+    const value = Number(row.value);
+    return Number.isFinite(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function markWindowed() {
+  if (windowedSince !== undefined || !persistenceDb)
+    return;
+  try {
+    persistenceDb.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, ?)").run(WINDOWED_SINCE_KEY, String(boundAt));
+    windowedSince = readWindowedSince(persistenceDb);
+  } catch {}
+}
+function setDatabase(db) {
+  const rebound = persistenceDb !== null && persistenceDb !== db;
+  persistenceDb = db;
+  boundAt = Date.now();
+  cachedInsertStmt = null;
+  cachedDeleteStmt = null;
+  if (rebound) {
+    for (const route of routes.values()) {
+      for (const slot of route.tools.values()) {
+        slot.persisted = false;
+        slot.writeFailedAt = undefined;
+      }
+      for (const retired of route.retired.values())
+        retired.rowKept = false;
+      route.legacyRows.clear();
+    }
+  }
+  windowedSince = readWindowedSince(db);
+  if (windowedSince !== undefined)
+    return;
+  try {
+    if (!db.prepare("SELECT 1 FROM tool_definition_measurements LIMIT 1").get())
+      markWindowed();
+  } catch {}
+}
+function loadToolDefinitionMeasurements(db) {
+  let rows = [];
+  try {
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count, recorded_at FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  const since = readWindowedSince(db);
+  const loadedAt = new Map;
+  for (const row of rows) {
+    const { route } = routeFor(row.provider_id, row.model_id, row.agent_name);
+    if (route.live)
+      continue;
+    let now = loadedAt.get(route);
+    if (now === undefined) {
+      now = advanceClock(route);
+      loadedAt.set(route, now);
+    }
+    const legacy = since === undefined || !(Number(row.recorded_at) >= since);
+    route.tools.set(row.tool_id, {
+      tokens: row.token_count,
+      fingerprint: undefined,
+      lastFireAt: now,
+      legacy,
+      persisted: !legacy
+    });
+    route.oldestFireAt = Math.min(route.oldestFireAt, now);
+    if (legacy)
+      route.legacyRows.add(row.tool_id);
+    else
+      route.legacyRows.delete(row.tool_id);
+  }
+}
+
+export { BoundedSessionMap, setDatabase, loadToolDefinitionMeasurements };

package/dist/{index-bvpar0bg.js → index-ck8wj35v.js}

@@ -5,10 +5,10 @@ import {
 } from "./index-2qtx0q6h.js";
 import {
   runSessionWarmupWorker
-} from "./index-6981g1xv.js";
+} from "./index-c1dqxr10.js";
 import {
   logSlowWriteTransaction
-} from "./index-hqw0rt9k.js";
+} from "./index-0wtm7g7f.js";
 
 // ../plugin/src/features/magic-context/message-fts-rowid-map.ts
 import { createHash } from "node:crypto";

package/dist/{index-jn44h81p.js → index-cq71g4dk.js}

@@ -1,6 +1,6 @@
 import {
   log2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
 
 // ../plugin/src/shared/safe-notification-target.ts
 var DEFAULT_TITLE_RE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;

package/dist/{index-pb3ea2tq.js → index-d107f484.js}

@@ -3,27 +3,27 @@ import {
 } from "./index-135e8hvg.js";
 import {
   log2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
 import {
   ensureColumn,
   healAllNullColumns,
   installV95PerfSchema
-} from "./index-c474g0gj.js";
+} from "./index-yacs388s.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
   getOpenCodeDbProbeDescriptions
-} from "./index-23t8ryqw.js";
+} from "./index-n0zjvs3h.js";
 import {
   Database2
 } from "./index-2qtx0q6h.js";
 import {
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity
-} from "./index-48twbev2.js";
+} from "./index-6pk49fc3.js";
 import {
   logSlowWriteTransaction
-} from "./index-hqw0rt9k.js";
+} from "./index-0wtm7g7f.js";
 
 // ../plugin/src/features/magic-context/migrations.ts
 import { isMainThread } from "node:worker_threads";