@cortexkit/magic-context 0.47.0 → 0.49.0

package/dist/index.js

@@ -2212,8 +2212,12 @@ function flush() {
     let currentSize = getCurrentLogSize(logFile);
     const dataSize = Buffer.byteLength(data);
     if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
-      rotateLogFile(logFile, currentSize);
-      currentSize = 0;
+      flushesSinceSizeCheck = SIZE_CHECK_INTERVAL_FLUSHES;
+      currentSize = getCurrentLogSize(logFile);
+      if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+        rotateLogFile(logFile, currentSize);
+        currentSize = 0;
+      }
     }
     fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 384 });
     buffer = [];
@@ -3476,6 +3480,15 @@ function migrateLegacyExperimental(rawConfig, warnings) {
   return patched;
 }
 
+// ../plugin/src/config/mural-model-deprecation.ts
+function warnDeprecatedMuralModel(config, warnings) {
+  const mural = config.mural;
+  if (typeof mural === "object" && mural !== null && Object.hasOwn(mural, "model")) {
+    warnings.push(MURAL_MODEL_DEPRECATION_WARNING);
+  }
+}
+var MURAL_MODEL_DEPRECATION_WARNING = "mural.model is deprecated and ignored; compress-cues now uses the dreamer model for each harness, like every other dreamer task. To override it, set dreamer.opencode.tasks.compress-cues.model (or the pi/omp equivalent). This key no longer does anything; remove it.";
+
 // ../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/core.js
 function $constructor(name, initializer, params) {
   function init(inst, def) {
@@ -9315,7 +9328,7 @@ var init_magic_context = __esm(() => {
     allow_home_project: boolean2().default(false).describe("Allow Magic Context sessions launched from the exact canonical home directory. A non-git home uses its deterministic dir: identity; a home repository uses its git: identity. USER-LEVEL ONLY: project config is ignored. The home identity is excluded from registry seed exports, never resolves descendants by containment, and cannot join a workspace."),
     mural: object({
       enabled: boolean2().default(false),
-      model: string2().trim().min(1).optional().describe("Model for the compress-cues task that compresses each memory into a mural cue. The mural image itself is rendered deterministically (no author model).")
+      model: unknown().optional().describe("Deprecated: ignored. compress-cues now uses the dreamer model for each harness, like every other dreamer task; override it with dreamer.opencode.tasks.compress-cues.model (or the pi/omp equivalent). Remove this key; it no longer does anything.").meta({ deprecated: true })
     }).default({ enabled: false }).describe("Experimental mural: a single deterministically-rendered image of project memories that did not fit the context budget. Cues are compressed per-memory by the compress-cues dreamer task."),
     transform_mode: _enum(["ts", "rust"]).default("ts").describe('Experimental: routes the entire Magic Context runtime for the project through the ck-mc Rust module over subc (requires user-level `subc` config); "ts" is the current TypeScript pipeline.'),
     auto_update: boolean2().optional().describe("Enable automatic npm self-update checks for the OpenCode plugin. Security: USER-only in config loader, so hostile project configs cannot suppress updates."),
@@ -9325,8 +9338,9 @@ var init_magic_context = __esm(() => {
     historian: HistorianConfigSchema.describe("Historian metadata plus independent strict OpenCode, Pi, and OMP execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode, historian.pi, or historian.omp."),
     dreamer: DreamerConfigSchema.optional().describe("Dreamer metadata and scheduling plus independent strict OpenCode, Pi, and OMP execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block."),
     smart_notes: object({
+      enabled: boolean2().default(true).describe("Enable smart-note authoring and condition evaluation. User-level only: tool definitions are process-wide. Changes require a host restart and rebuild each session's cached prompt once. Pending notes remain stored and unchecked; already-ready notes still surface."),
       retina_handoff: boolean2().default(false).describe("When true, dreamer skips smart notes whose surface conditions compiled to retina provider configs at authoring time. Default false keeps both paths active until the retina consumer is deployed.")
-    }).default({ retina_handoff: false }).describe("Smart-note ownership transition controls."),
+    }).default({ enabled: true, retina_handoff: false }).describe("Smart-note ownership transition controls."),
     cache_ttl: union([string2(), object({ default: string2() }).catchall(string2())]).default("5m").describe(`How long Magic Context assumes the provider's cached prefix stays valid. This is MC's own deferral gate — it does not change the provider's actual cache lifetime. String (e.g. "5m", "1h", "30s") or per-model object ({ default: "5m", "provider/model": "1h", "provider/*": "never" }); keys resolve most-specific first (exact provider/model, bare model ID, shorter dash-prefixes, then the provider/* wildcard, then default). User and project settings, including an explicit "5m" or object default, apply on the next pass. Only built-in defaults are frozen per session, including across restarts: when unset, GPT-5.6 and later (including gpt-6*, through any provider prefix) use 30m, other models use 5m. /ctx-status shows the effective TTL and whether it comes from your config or a frozen built-in default. Editing the TTL does not itself rewrite prompt bytes; a lowered TTL rebuilds only after normal idle expiry. OpenAI documents at least 30 minutes since the latest write or reuse: https://developers.openai.com/api/docs/guides/prompt-caching (Cache lifetime and Summary of model differences). Set to "never" to mean MC never assumes expiry (for lanes kept warm externally by a cache-keep tool) — disables the idle-TTL heuristic so MC never initiates a rebuild based on elapsed time. Provider-side extended TTL is a separate request-level concern (cache_control: { ttl } in the request body).`),
     prompt_surface: PromptSurfaceConfigSchema.default({ default: "full" }).describe("Prompt-surface presets: default is full; models use bare model IDs, provider/model, or provider/* routing keys. Guidance and tool-description overrides are user-level only. OpenCode 1.x, Pi, and OMP register tool descriptions once per process (they follow the default preset). OpenCode 2 rewrites the five ctx_* descriptions per request from the draft model."),
     output_reserve: union([
@@ -9431,7 +9445,6 @@ var init_magic_context = __esm(() => {
   });
   LIVE_RELOAD_CONFIG_PATHS = [
     "cache_ttl",
-    "mural.model",
     "toast_duration_ms",
     "historian.opencode.model",
     "historian.opencode.fallback_models",
@@ -9612,16 +9625,6 @@ function stripEscalationAtExecutableSite(block, path, removed) {
     }
   }
 }
-function stripNestedMuralModels(node, path, removed) {
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "mural" && isPlainObject2(value) && "model" in value) {
-      delete value.model;
-      removed.push(`${path}.${key}.model`);
-    } else if (isPlainObject2(value)) {
-      stripNestedMuralModels(value, `${path}.${key}`, removed);
-    }
-  }
-}
 function isValidPercentageThreshold(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 20 && value <= 90;
 }
@@ -9762,6 +9765,11 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete storage.enforce_private_permissions;
     warnings.push("Ignoring storage.enforce_private_permissions from project config (security: only user-level config may opt into externally managed shared storage permissions).");
   }
+  const smartNotes = projectRaw.smart_notes;
+  if (isPlainObject2(smartNotes) && "enabled" in smartNotes) {
+    delete smartNotes.enabled;
+    warnings.push("Ignoring smart_notes.enabled from project config (only user-level config may change process-wide tool definitions; restart required).");
+  }
   const promptSurface = projectRaw.prompt_surface;
   if (isPlainObject2(promptSurface)) {
     const removed = [];
@@ -9860,27 +9868,6 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete dreamer.runner;
     warnings.push("Ignoring dreamer.runner from project config (security: which process and provider account run dreamer completions is a user-level setting).");
   }
-  const mural = projectRaw.mural;
-  if (isPlainObject2(mural) && "model" in mural) {
-    delete mural.model;
-    warnings.push("Ignoring mural.model from project config (security: the mural cue-compressor model is a user-level setting; a repository cannot choose where project memory is sent).");
-  }
-  const experimental = projectRaw.experimental;
-  const legacyMural = isPlainObject2(experimental) ? experimental.mural : undefined;
-  if (isPlainObject2(legacyMural) && "model" in legacyMural) {
-    delete legacyMural.model;
-    warnings.push("Ignoring experimental.mural.model from project config (security: the mural cue-compressor model is a user-level setting; use user-level mural.model).");
-  }
-  const nestedMuralRemoved = [];
-  for (const agentKey of HIDDEN_AGENT_KEYS) {
-    const block = projectRaw[agentKey];
-    if (!isPlainObject2(block))
-      continue;
-    stripNestedMuralModels(block, agentKey, nestedMuralRemoved);
-  }
-  if (nestedMuralRemoved.length > 0) {
-    warnings.push(`Ignoring ${nestedMuralRemoved.join(", ")} from project config (security: the mural cue-compressor model is a user-level setting; a repository cannot choose where project memory is sent).`);
-  }
   return warnings;
 }
 function constrainProjectThresholdOverrides(args) {
@@ -10929,6 +10916,7 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
   }
   preMigrationWarnings.push(...misplacedAgentModelWarnings(rawConfig));
   const migratedExperimental = migrateLegacyExperimental(configWithoutRemovedAgent, preMigrationWarnings);
+  warnDeprecatedMuralModel(migratedExperimental, preMigrationWarnings);
   const migratedDreamer = migrateDreamerV2(migratedExperimental, preMigrationWarnings);
   const migrated = migrateLegacyAgentEnabledInMemory(migratedDreamer, preMigrationWarnings);
   const parsed = MagicContextConfigSchema.safeParse(migrated);
@@ -12856,17 +12844,23 @@ __export(exports_sqlite, {
   detectSqliteRuntime: () => detectSqliteRuntime,
   getSqliteDatabasePath: () => getSqliteDatabasePath,
   getSqliteMemoryStats: () => getSqliteMemoryStats,
+  getTagIdentityWriteGeneration: () => getTagIdentityWriteGeneration,
   guardSqliteTransformPass: () => guardSqliteTransformPass,
+  indexCoordinationInput: () => indexCoordinationInput,
   isTransientSqliteError: () => isTransientSqliteError,
   loadSqliteModule: () => loadSqliteModule,
+  mayChangeTagIdentity: () => mayChangeTagIdentity,
   prepareCachedStatement: () => prepareCachedStatement,
   registerSlowWriteReporter: () => registerSlowWriteReporter,
   registerSqliteDiagnosticSink: () => registerSqliteDiagnosticSink,
+  releaseIndexOwner: () => releaseIndexOwner,
   withAsyncPrivilegedWriter: () => withAsyncPrivilegedWriter,
+  withIndexChunk: () => withIndexChunk,
   withPrivilegedWriter: () => withPrivilegedWriter,
   withSqliteBackgroundWriter: () => withSqliteBackgroundWriter,
   withSqliteTransformPass: () => withSqliteTransformPass,
-  withoutSqliteTransformPass: () => withoutSqliteTransformPass
+  withoutSqliteTransformPass: () => withoutSqliteTransformPass,
+  yieldIndexChunk: () => yieldIndexChunk
 });
 import { AsyncLocalStorage } from "node:async_hooks";
 import { statSync as statSync4 } from "node:fs";
@@ -12900,10 +12894,31 @@ function isModuleNotFoundError(error, specifier) {
     return false;
   return code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND" || name === "ResolveMessage" || details.includes("module not found") || details.includes("cannot find module") || details.includes("cannot find package") || details.includes("no such built-in module");
 }
+function isNodeSqliteExperimentalWarning(args) {
+  const [warning, options] = args;
+  const message = warning instanceof Error ? warning.message : warning;
+  const type = typeof options === "string" ? options : options && typeof options === "object" ? options.type : undefined;
+  return type === "ExperimentalWarning" && typeof message === "string" && message.startsWith("SQLite is an experimental feature");
+}
+async function importSqliteModuleForRuntime(runtime, specifier, importer) {
+  if (runtime !== "Node.js")
+    return importer(specifier);
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = function(...args) {
+    if (isNodeSqliteExperimentalWarning(args))
+      return;
+    Reflect.apply(originalEmitWarning, this, args);
+  };
+  try {
+    return await importer(specifier);
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
 async function loadSqliteModule(runtime = detectSqliteRuntime(), importer = importSqliteModule) {
   const specifier = runtime === "Bun" ? bunSpec : nodeSpec;
   try {
-    return await importer(specifier);
+    return await importSqliteModuleForRuntime(runtime, specifier, importer);
   } catch (error) {
     if (isModuleNotFoundError(error, specifier)) {
       throw new SqliteRuntimeUnavailableError(runtime, specifier, error);
@@ -12911,6 +12926,67 @@ async function loadSqliteModule(runtime = detectSqliteRuntime(), importer = impo
     throw error;
   }
 }
+function mayChangeTagIdentity(sql) {
+  if (!/\btags\b/i.test(sql) || /^\s*(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(sql))
+    return false;
+  if (/^\s*WITH\b/i.test(sql) && !/\b(?:INSERT|UPDATE|DELETE|REPLACE)\b/i.test(sql))
+    return false;
+  if (/;\s*\S/.test(sql) || /\bREPLACE\b/i.test(sql) || /\bON\s+CONFLICT\b/i.test(sql))
+    return true;
+  const insert = /^\s*INSERT\s+INTO\s+(?:main\.)?["`]?tags["`]?\s*\(([^)]*)\)/i.exec(sql);
+  if (insert) {
+    const columns = (insert[1] ?? "").split(",").map((column) => column.trim().replace(/["`[\]]/g, "").toLowerCase());
+    return columns.includes("id") || columns.includes("rowid");
+  }
+  const update = /^\s*UPDATE\s+(?:main\.)?["`]?tags["`]?\s+SET\s+([\s\S]*?)\bWHERE\b/i.exec(sql);
+  if (update && !/\bSELECT\b/i.test(sql)) {
+    const assignments = topLevelCommaSegments(update[1] ?? "");
+    if (!assignments)
+      return true;
+    return !assignments.every((assignment) => {
+      const column = /^\s*["`]?(\w+)["`]?\s*=(?!=)/.exec(assignment)?.[1];
+      return column !== undefined && TAG_COLUMNS_OUTSIDE_IDENTITY.has(column.toLowerCase());
+    });
+  }
+  return true;
+}
+function topLevelCommaSegments(text) {
+  const segments = [];
+  let depth = 0;
+  let quote = null;
+  let start = 0;
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (char === quote) {
+        if (text[index + 1] === quote)
+          index += 1;
+        else
+          quote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`")
+      quote = char;
+    else if (char === "(")
+      depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth < 0)
+        return null;
+    } else if (char === "," && depth === 0) {
+      segments.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (quote || depth !== 0)
+    return null;
+  segments.push(text.slice(start));
+  return segments;
+}
+function getTagIdentityWriteGeneration() {
+  return tagIdentityWriteGeneration;
+}
 function installTransactionRouting(db, readonly) {
   const nativeExec = db.exec.bind(db);
   Object.defineProperty(db, "exec", {
@@ -12929,8 +13005,14 @@ function installTransactionRouting(db, readonly) {
       }
       if (WRITER_TRANSACTION_END.test(sql) && openWriterTransactions.has(db))
         return endWriterTransaction(db, () => nativeExec(sql), sql);
-      if (!/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql))
-        return withAutocommitTimeout(db, () => nativeExec(sql));
+      if (!/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql)) {
+        try {
+          return withAutocommitTimeout(db, () => nativeExec(sql));
+        } finally {
+          if (mayChangeTagIdentity(sql))
+            tagIdentityWriteGeneration += 1;
+        }
+      }
       return nativeExec(sql);
     }
   });
@@ -12941,13 +13023,23 @@ function installTransactionRouting(db, readonly) {
     value: (sql) => {
       const statement = nativePrepare(sql);
       if (!readonly && !/^\s*(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(sql)) {
+        const changesTagIdentity = mayChangeTagIdentity(sql);
         for (const method of ["run", "get", "all"]) {
           const execute = statement[method].bind(statement);
           Object.defineProperty(statement, method, {
             configurable: true,
-            value: (...args) => withAutocommitTimeout(db, () => execute(...args))
+            value: (...args) => {
+              try {
+                return withAutocommitTimeout(db, () => execute(...args));
+              } finally {
+                if (changesTagIdentity)
+                  tagIdentityWriteGeneration += 1;
+              }
+            }
           });
         }
+        if (changesTagIdentity)
+          wrapRemainingTagWriteForms(statement);
       }
       return statement;
     }
@@ -12995,6 +13087,35 @@ function installTransactionRouting(db, readonly) {
     }
   });
 }
+function wrapRemainingTagWriteForms(statement) {
+  if (typeof statement.iterate === "function") {
+    const iterate = statement.iterate.bind(statement);
+    Object.defineProperty(statement, "iterate", {
+      configurable: true,
+      value: function* (...args) {
+        tagIdentityWriteGeneration += 1;
+        try {
+          yield* iterate(...args);
+        } finally {
+          tagIdentityWriteGeneration += 1;
+        }
+      }
+    });
+  }
+  if (typeof statement.values === "function") {
+    const values = statement.values.bind(statement);
+    Object.defineProperty(statement, "values", {
+      configurable: true,
+      value: (...args) => {
+        try {
+          return values(...args);
+        } finally {
+          tagIdentityWriteGeneration += 1;
+        }
+      }
+    });
+  }
+}
 function trackSqliteConnection(db, filename, options) {
   const originalClose = db.close.bind(db);
   const sequence = nextSqliteConnectionSequence++;
@@ -13054,6 +13175,10 @@ function getSqliteDatabasePath(db) {
       return connection.filename === ":memory:" || connection.filename === "<buffer>" ? null : connection.filename;
     }
   }
+  const native = db;
+  const path = native.filename ?? native.name;
+  if (typeof path === "string" && path !== ":memory:" && path !== "")
+    return path;
   return null;
 }
 function pragmaValue(db, name) {
@@ -13135,6 +13260,15 @@ function getSqliteMemoryStats() {
     connections
   };
 }
+function closeReleasingStatements(close, args) {
+  if (args[0] === true)
+    return close(true);
+  try {
+    return close(true);
+  } catch {
+    return close(...args);
+  }
+}
 function ownPreparedStatement(db, statement) {
   const finalizable = statement;
   if (typeof finalizable.finalize !== "function")
@@ -13158,7 +13292,7 @@ function ownPreparedStatement(db, statement) {
           }
         }
         references.clear();
-        const result = close(...args);
+        const result = closeReleasingStatements(close, args);
         if (failure)
           throw failure;
         return result;
@@ -13188,22 +13322,29 @@ function withSqliteTransformPass(operation) {
   const existing = transformPassScope.getStore();
   if (existing?.active)
     return operation();
-  const lease = { active: true, remainingWaitMs: FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS };
-  return transformPassScope.run(lease, () => {
-    try {
-      const result = operation();
-      if (result && typeof result.then === "function") {
-        return Promise.resolve(result).finally(() => {
-          lease.active = false;
-        });
+  const reservation = reserveForegroundSqliteTurn();
+  const run = (release) => {
+    const lease = { active: true, remainingWaitMs: FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS };
+    return transformPassScope.run(lease, () => {
+      try {
+        const result = operation();
+        if (result && typeof result.then === "function") {
+          return Promise.resolve(result).finally(() => {
+            lease.active = false;
+            release();
+          });
+        }
+        lease.active = false;
+        release();
+        return result;
+      } catch (error) {
+        lease.active = false;
+        release();
+        throw error;
       }
-      lease.active = false;
-      return result;
-    } catch (error) {
-      lease.active = false;
-      throw error;
-    }
-  });
+    });
+  };
+  return typeof reservation === "function" ? run(reservation) : reservation.then(run);
 }
 function withoutSqliteTransformPass(operation) {
   return transformPassScope.run(undefined, operation);
@@ -13291,18 +13432,20 @@ function acquireShort(db, acquire, site) {
 }
 function endWriterTransaction(db, end, sql) {
   let ended = false;
+  const endStarted = performance.now();
   try {
     const result = end();
     ended = true;
     return result;
   } finally {
     const open = openWriterTransactions.get(db);
+    const endMs = performance.now() - endStarted;
     if (open && !isInTransaction(db)) {
       openWriterTransactions.delete(db);
       const holdMs = performance.now() - open.acquiredAt;
       if (open.acquireMs >= SLOW_WRITER_LOG_MS || holdMs >= SLOW_WRITER_LOG_MS) {
         const outcome = /^\s*ROLLBACK/i.test(sql) ? "rolled_back" : ended ? "committed" : "failed";
-        reportSqliteDiagnostic(`sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} attempts=${open.attempts} outcome=${outcome}`);
+        reportSqliteDiagnostic(`sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} end_ms=${Math.round(endMs)} attempts=${open.attempts} outcome=${outcome}`);
       }
     }
   }
@@ -13442,7 +13585,55 @@ function withPrivilegedWriter(db, operation) {
     throw error;
   }
 }
-var reportSlowPrivilegedWrite, sqliteDiagnosticSink, bunSpec, nodeSpec, SqliteRuntimeUnavailableError, detectedRuntime, isBun, sqliteModule, DatabaseImpl, trackedSqliteConnections, nextSqliteConnectionSequence = 1, TrackedDatabase, Database, statementOwners, FIRST_PRUNE_AT = 256, privilegeDepth, transformPassScope, admissionScope, backgroundWriterScope, SqliteAcquisitionBusyError, SHORT_BUSY_TIMEOUT_MS = 25, FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 250, FOREGROUND_ACQUISITION_BUDGET_MS = 16500, SLOW_WRITER_LOG_MS = 250, WRITER_TRANSACTION_END, writerAcquisitionScope, openWriterTransactions;
+function indexCoordinationInput() {
+  return {
+    indexCoordination: indexCoordinationBuffer,
+    indexOwner: Atomics.add(indexCoordinationState, 2, 1) + 1
+  };
+}
+function reserveForegroundSqliteTurn() {
+  Atomics.add(indexCoordinationState, 0, 1);
+  const release = () => {
+    Atomics.sub(indexCoordinationState, 0, 1);
+    Atomics.notify(indexCoordinationState, 0);
+  };
+  if (Atomics.load(indexCoordinationState, 1) === 0)
+    return release;
+  return (async () => {
+    while (Atomics.load(indexCoordinationState, 1) !== 0)
+      await yieldIndexTurn();
+    return release;
+  })();
+}
+function releaseIndexOwner(input) {
+  if (!input.indexCoordination || !input.indexOwner)
+    return;
+  const shared = new Int32Array(input.indexCoordination);
+  Atomics.compareExchange(shared, 1, input.indexOwner, 0);
+  Atomics.notify(shared, 1);
+}
+async function withIndexChunk(input, operation) {
+  if (!input.indexCoordination || !input.indexOwner)
+    return operation();
+  const shared = new Int32Array(input.indexCoordination);
+  for (;; ) {
+    if (Atomics.load(shared, 0) === 0 && Atomics.compareExchange(shared, 1, 0, input.indexOwner) === 0) {
+      if (Atomics.load(shared, 0) === 0)
+        break;
+      releaseIndexOwner(input);
+    }
+    await yieldIndexTurn();
+  }
+  try {
+    return await operation();
+  } finally {
+    releaseIndexOwner(input);
+  }
+}
+async function yieldIndexChunk() {
+  await yieldIndexTurn();
+}
+var reportSlowPrivilegedWrite, sqliteDiagnosticSink, bunSpec, nodeSpec, SqliteRuntimeUnavailableError, detectedRuntime, isBun, sqliteModule, DatabaseImpl, trackedSqliteConnections, nextSqliteConnectionSequence = 1, TAG_COLUMNS_OUTSIDE_IDENTITY, tagIdentityWriteGeneration = 0, TrackedDatabase, Database, statementOwners, FIRST_PRUNE_AT = 256, privilegeDepth, transformPassScope, admissionScope, backgroundWriterScope, SqliteAcquisitionBusyError, SHORT_BUSY_TIMEOUT_MS = 25, FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 250, FOREGROUND_ACQUISITION_BUDGET_MS = 16500, SLOW_WRITER_LOG_MS = 250, WRITER_TRANSACTION_END, writerAcquisitionScope, openWriterTransactions, indexCoordinationKey, indexCoordinationHeap, indexCoordinationBuffer, indexCoordinationState, yieldIndexTurn = () => new Promise((resolve) => setTimeout(resolve, 1));
 var init_sqlite = __esm(async () => {
   bunSpec = "bun:" + "sqlite";
   nodeSpec = "node:" + "sqlite";
@@ -13462,6 +13653,19 @@ var init_sqlite = __esm(async () => {
   sqliteModule = await loadSqliteModule(detectedRuntime);
   DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
   trackedSqliteConnections = new Map;
+  TAG_COLUMNS_OUTSIDE_IDENTITY = new Set([
+    "status",
+    "drop_mode",
+    "byte_size",
+    "input_byte_size",
+    "reasoning_byte_size",
+    "token_count",
+    "input_token_count",
+    "caveman_depth",
+    "entry_fingerprint",
+    "tool_name",
+    "harness"
+  ]);
   TrackedDatabase = new Proxy(DatabaseImpl, {
     construct(target, args) {
       const db = Reflect.construct(target, args, target);
@@ -13486,6 +13690,11 @@ var init_sqlite = __esm(async () => {
   WRITER_TRANSACTION_END = /^\s*(?:COMMIT|END|ROLLBACK)(?:\s+TRANSACTION)?\s*;?\s*$/i;
   writerAcquisitionScope = new AsyncLocalStorage;
   openWriterTransactions = new WeakMap;
+  indexCoordinationKey = Symbol.for("magic-context.index-foreground-coordination.v1");
+  indexCoordinationHeap = globalThis;
+  indexCoordinationBuffer = indexCoordinationHeap[indexCoordinationKey] ?? new SharedArrayBuffer(3 * Int32Array.BYTES_PER_ELEMENT);
+  indexCoordinationHeap[indexCoordinationKey] = indexCoordinationBuffer;
+  indexCoordinationState = new Int32Array(indexCoordinationBuffer);
 });
 
 // src/lib/docs-proposal-gitignore.ts
@@ -22933,6 +23142,22 @@ function readConfiguredOpenCodePluginSpec(config) {
   }
   return "latest";
 }
+function readReferencedOpenCodePluginSpecs(config, host) {
+  const specs = new Set;
+  for (const { key, entry } of readPluginEntries(config)) {
+    if (host === "opencode1" && key !== "plugin")
+      continue;
+    const specifier = pluginEntrySpecifier(entry);
+    const spec = specifier === undefined ? undefined : openCodeV2PluginSpecOf(specifier);
+    if (spec !== undefined)
+      specs.add(spec);
+  }
+  return specs;
+}
+function describeUnusedOpenCodePluginCache(input) {
+  const why = input.loadedFrom ? `the config loads Magic Context from ${input.loadedFrom}` : `no ${input.host} plugin entry in the config references it`;
+  return `${input.host} plugin cache: unused cached copy of ${OPENCODE_PLUGIN_NAME}@${input.spec} (cached: ${input.cached ?? "unreadable"}); ${input.host} never loads it because ${why}. Informational, nothing breaks; safe to delete: ${input.paths.join(", ")}`;
+}
 function pluginEntrySpecifier(entry) {
   if (typeof entry === "string")
     return entry;
@@ -23158,6 +23383,9 @@ function checkOpenCodeV2PluginCache(options, deps = {}) {
   const distTag = options.distTag && options.distTag !== "latest" ? options.distTag : undefined;
   const slot = deps.slot ?? getOpenCodeV2PluginCacheSlot(undefined, distTag ?? "latest");
   const tagged = distTag ? { distTag } : {};
+  if (options.referencedSpecs !== undefined && !options.referencedSpecs.has(distTag ?? "latest")) {
+    return existsSync13(slot) ? { action: "unused", slot, cached: readOpenCodeV2CachedPluginVersion(slot), ...tagged } : { action: "not_found", slot, unused: true, ...tagged };
+  }
   if (!existsSync13(slot))
     return { action: "not_found", slot, ...tagged };
   const cached = readOpenCodeV2CachedPluginVersion(slot);
@@ -23197,7 +23425,7 @@ function reportOpenCodeV2PluginCache(result, report, options) {
   const slotName = result.distTag ? ` @${result.distTag}` : "";
   switch (result.action) {
     case "not_found":
-      if (options.reportMissing) {
+      if (options.reportMissing && !result.unused) {
         report.pass(`OpenCode 2 plugin cache has no Magic Context${slotName} install yet (OpenCode installs it on next start)`);
       }
       return { fixed: false, issue: false };
@@ -23225,6 +23453,15 @@ function reportOpenCodeV2PluginCache(result, report, options) {
       report.pass(`Cleared ${result.forced ? "" : "outdated "}Magic Context${slotName} from the OpenCode 2 plugin cache (${versions}${result.forced ? ", --force" : ""}) — OpenCode installs the ${result.distTag ? `current ${tag} release` : "latest"} on next start`);
       report.info(`  ${result.slot}`);
       return { fixed: true, issue: false };
+    case "unused":
+      report.info(describeUnusedOpenCodePluginCache({
+        host: "OpenCode 2",
+        spec: tag,
+        cached: result.cached,
+        paths: [result.slot],
+        loadedFrom: options.loadedFrom
+      }));
+      return { fixed: false, issue: false };
     case "error":
       report.warn(`Could not clear the OpenCode 2 plugin cache: ${result.error}`);
       report.info(`  Manually delete: ${result.slot}`);
@@ -28760,6 +28997,90 @@ var init_migrations = __esm(async () => {
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
 });
 
+// ../plugin/src/features/magic-context/storage-tag-identity-revision.ts
+function installTagIdentityRevisionTrigger(db) {
+  db.exec(`DROP TRIGGER IF EXISTS temp.mc_tag_identity_revision_au;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_bi;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_ai;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_au;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_ad;
+        DROP TRIGGER IF EXISTS temp.mc_tag_revision_seed_ai;`);
+  db.exec(`CREATE TEMP TRIGGER mc_tag_revision_seed_ai AFTER INSERT ON main.schema_migrations_meta
+        WHEN INSTR(NEW.value, ':') = 0 AND (
+          SUBSTR(NEW.key, 1, ${TAG_REVISION_PREFIX.length}) = '${TAG_REVISION_PREFIX}'
+          OR SUBSTR(NEW.key, 1, ${TAG_IDENTITY_REVISION_PREFIX.length}) = '${TAG_IDENTITY_REVISION_PREFIX}')
+        BEGIN
+            INSERT INTO schema_migrations_meta (key, value) VALUES ('${TAG_REVISION_INCARNATION_KEY}', '1')
+                ON CONFLICT(key) DO UPDATE SET value = CAST(CASE
+                    WHEN CAST(value AS INTEGER) < 9223372036854775807 THEN CAST(value AS INTEGER) + 1
+                    ELSE NULL END AS TEXT);
+            UPDATE schema_migrations_meta SET value =
+                (SELECT value FROM schema_migrations_meta WHERE key = '${TAG_REVISION_INCARNATION_KEY}')
+                || ':' || CAST(NEW.value AS TEXT) WHERE key = NEW.key;
+            INSERT INTO schema_migrations_meta (key, value)
+                SELECT '${TAG_REVISION_INCARNATION_KEY}', '1'
+                WHERE SUBSTR(NEW.key, 1, ${TAG_REVISION_PREFIX.length}) = '${TAG_REVISION_PREFIX}'
+                  AND NOT EXISTS (SELECT 1 FROM schema_migrations_meta
+                    WHERE key = '${TAG_IDENTITY_REVISION_PREFIX}' || SUBSTR(NEW.key, ${TAG_REVISION_PREFIX.length + 1}))
+                ON CONFLICT(key) DO UPDATE SET value = CAST(CASE
+                    WHEN CAST(value AS INTEGER) < 9223372036854775807 THEN CAST(value AS INTEGER) + 1
+                    ELSE NULL END AS TEXT);
+            INSERT INTO schema_migrations_meta (key, value)
+                SELECT '${TAG_IDENTITY_REVISION_PREFIX}' || SUBSTR(NEW.key, ${TAG_REVISION_PREFIX.length + 1}),
+                    (SELECT value FROM schema_migrations_meta WHERE key = '${TAG_REVISION_INCARNATION_KEY}') || ':0'
+                WHERE SUBSTR(NEW.key, 1, ${TAG_REVISION_PREFIX.length}) = '${TAG_REVISION_PREFIX}'
+                  AND NOT EXISTS (SELECT 1 FROM schema_migrations_meta
+                    WHERE key = '${TAG_IDENTITY_REVISION_PREFIX}' || SUBSTR(NEW.key, ${TAG_REVISION_PREFIX.length + 1}));
+        END;`);
+  db.exec(TRIGGER_SQL);
+  db.exec(`CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_bi BEFORE INSERT ON main.tags BEGIN
+        ${BUMP_INSERT_CONFLICTS(TAG_REVISION_PREFIX)};
+        ${BUMP_INSERT_CONFLICTS(TAG_IDENTITY_REVISION_PREFIX)};
+        UPDATE session_meta SET tags_version = tags_version + 1
+            WHERE session_id IN (SELECT session_id FROM (${TAG_INSERT_CONFLICT_ROWS}));
+    END;`);
+  db.exec(`CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_ai AFTER INSERT ON main.tags BEGIN
+        ${BUMP("NEW.session_id", TAG_REVISION_PREFIX)};
+    END;
+    CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_au AFTER UPDATE ON main.tags BEGIN
+        ${BUMP("OLD.session_id", TAG_REVISION_PREFIX)};
+        INSERT INTO schema_migrations_meta (key, value)
+            SELECT '${TAG_REVISION_PREFIX}' || NEW.session_id, '1'
+            WHERE NEW.session_id IS NOT OLD.session_id
+            ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()};
+    END;
+    CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_revision_ad AFTER DELETE ON main.tags BEGIN
+        ${BUMP("OLD.session_id", TAG_REVISION_PREFIX)};
+    END;`);
+}
+var TAG_IDENTITY_REVISION_PREFIX = "tag_identity_revision:", TAG_REVISION_PREFIX = "tag_revision:", TAG_REVISION_INCARNATION_KEY = "tag_revision_incarnation", tagRevisionIncarnationSql = (value) => `CASE WHEN INSTR(${value}, ':') > 0 THEN SUBSTR(${value}, 1, INSTR(${value}, ':') - 1) ELSE '0' END`, tagRevisionCountSql = (value) => `CAST(CASE WHEN INSTR(${value}, ':') > 0 THEN SUBSTR(${value}, INSTR(${value}, ':') + 1) ELSE ${value} END AS INTEGER)`, ADVANCE = (delta = "1") => `CASE
+    WHEN ${tagRevisionCountSql("value")} <= 9223372036854775807 - ${delta}
+    THEN (${tagRevisionIncarnationSql("value")}) || ':' || CAST(${tagRevisionCountSql("value")} + ${delta} AS TEXT)
+    ELSE NULL END`, BUMP = (session, prefix = TAG_IDENTITY_REVISION_PREFIX) => `INSERT INTO schema_migrations_meta (key, value)
+        VALUES ('${prefix}' || ${session}, '1')
+        ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()}`, TAG_INSERT_CONFLICT_ROWS = `SELECT id, session_id, tag_number FROM tags WHERE id = NEW.id
+    UNION SELECT id, session_id, tag_number FROM tags WHERE session_id = NEW.session_id AND tag_number = NEW.tag_number
+    UNION SELECT id, session_id, tag_number FROM tags
+        WHERE NEW.type = 'tool' AND NEW.tool_owner_message_id IS NOT NULL
+          AND type = 'tool' AND tool_owner_message_id IS NOT NULL
+          AND session_id = NEW.session_id AND message_id = NEW.message_id
+          AND tool_owner_message_id = NEW.tool_owner_message_id`, BUMP_INSERT_CONFLICTS = (prefix) => `INSERT INTO schema_migrations_meta (key, value)
+    SELECT '${prefix}' || session_id, CAST(COUNT(*) AS TEXT)
+    FROM (${TAG_INSERT_CONFLICT_ROWS}) GROUP BY session_id
+    ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE("CAST(excluded.value AS INTEGER)")}`, TRIGGER_SQL;
+var init_storage_tag_identity_revision = __esm(() => {
+  TRIGGER_SQL = `CREATE TEMP TRIGGER IF NOT EXISTS mc_tag_identity_revision_au
+    AFTER UPDATE OF id, session_id, message_id, tag_number, type, tool_owner_message_id, reasoning_token_count
+    ON main.tags
+    BEGIN
+        ${BUMP("OLD.session_id")};
+        INSERT INTO schema_migrations_meta (key, value)
+            SELECT '${TAG_IDENTITY_REVISION_PREFIX}' || NEW.session_id, '1'
+            WHERE NEW.session_id IS NOT OLD.session_id
+            ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()};
+    END`;
+});
+
 // ../plugin/src/shared/commit-detection.ts
 function createCommitHashExtractPattern() {
   return new RegExp(`\`?\\b(${HASH_HEX})\\b\`?`, "gi");
@@ -28782,6 +29103,271 @@ function removeSystemReminders(text) {
 }
 var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
 
+// ../plugin/src/hooks/magic-context/token-count-exact.ts
+function hasInternals(tokenizer) {
+  const value = tokenizer;
+  return !!value && value.patternRegex instanceof RegExp && value.patternRegex.global && typeof value.stringRankEncoder === "object" && value.stringRankEncoder !== null && Array.isArray(value.binaryFirstByteIndex);
+}
+function isValidUtf8(bytes) {
+  let index = 0;
+  while (index < bytes.length) {
+    const first = bytes[index];
+    let size = 0;
+    let codePoint = 0;
+    if (first <= 127) {
+      size = 1;
+      codePoint = first;
+    } else if ((first & 224) === 192) {
+      size = 2;
+      codePoint = first & 31;
+      if (first <= 193)
+        return false;
+    } else if ((first & 240) === 224) {
+      size = 3;
+      codePoint = first & 15;
+    } else if ((first & 248) === 240) {
+      size = 4;
+      codePoint = first & 7;
+      if (first > 244)
+        return false;
+    } else
+      return false;
+    if (index + size > bytes.length)
+      return false;
+    for (let offset = 1;offset < size; offset += 1) {
+      const byte = bytes[index + offset];
+      if ((byte & 192) !== 128)
+        return false;
+      codePoint = codePoint << 6 | byte & 63;
+    }
+    if (size === 2 && codePoint < 128)
+      return false;
+    if (size === 3 && codePoint < 2048)
+      return false;
+    if (size === 4 && codePoint < 65536)
+      return false;
+    if (codePoint >= 55296 && codePoint <= 57343)
+      return false;
+    if (codePoint > 1114111)
+      return false;
+    index += size;
+  }
+  return true;
+}
+function binarySearchBytes(sorted, key) {
+  let low = 0;
+  let high = sorted.length - 1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const midKey = sorted[mid][0];
+    let compare = 0;
+    const shared = Math.min(midKey.length, key.length);
+    for (let index = 0;index < shared; index += 1) {
+      compare = midKey[index] - key[index];
+      if (compare !== 0)
+        break;
+    }
+    if (compare === 0)
+      compare = midKey.length - key.length;
+    if (compare === 0)
+      return sorted[mid][1];
+    if (compare < 0)
+      low = mid + 1;
+    else
+      high = mid - 1;
+  }
+  return -1;
+}
+function rankOf(tokenizer, slice) {
+  if (isValidUtf8(slice)) {
+    const rank = tokenizer.stringRankEncoder[textDecoder.decode(slice)];
+    if (rank !== undefined)
+      return rank;
+  }
+  const bucket = tokenizer.binaryFirstByteIndex[slice[0]];
+  if (bucket !== null && bucket !== undefined) {
+    const rank = binarySearchBytes(bucket, slice);
+    if (rank !== -1)
+      return rank;
+  }
+  return NO_RANK;
+}
+function mergeByScanning(tokenizer, bytes) {
+  const starts = [];
+  const ranks = [];
+  const pairRank = (index) => {
+    const end = starts[index + 2];
+    return end === undefined ? NO_RANK : rankOf(tokenizer, bytes.subarray(starts[index], end));
+  };
+  for (let index = 0;index <= bytes.length; index += 1)
+    starts.push(index);
+  for (let index = 0;index < starts.length; index += 1)
+    ranks.push(pairRank(index));
+  while (starts.length > 1) {
+    let minRank = NO_RANK;
+    let minIndex = -1;
+    for (let index = 0;index < ranks.length - 1; index += 1) {
+      if (ranks[index] < minRank) {
+        minRank = ranks[index];
+        minIndex = index;
+      }
+    }
+    if (minIndex === -1)
+      break;
+    starts.splice(minIndex + 1, 1);
+    ranks.splice(minIndex, 1);
+    ranks[minIndex] = pairRank(minIndex);
+    if (minIndex > 0)
+      ranks[minIndex - 1] = pairRank(minIndex - 1);
+  }
+  const tokens = [];
+  for (let index = 0;index < starts.length - 1; index += 1) {
+    const rank = rankOf(tokenizer, bytes.subarray(starts[index], starts[index + 1]));
+    if (rank !== NO_RANK)
+      tokens.push(rank);
+  }
+  return tokens;
+}
+function mergeWithHeap(tokenizer, bytes) {
+  const length = bytes.length;
+  const next = new Int32Array(length + 1);
+  const prev = new Int32Array(length + 1);
+  const alive = new Uint8Array(length + 1).fill(1);
+  const rank = new Float64Array(length + 1).fill(NO_RANK);
+  for (let index = 0;index <= length; index += 1) {
+    next[index] = index + 1;
+    prev[index] = index - 1;
+  }
+  const heapRank = [];
+  const heapAt = [];
+  const less = (a, b) => heapRank[a] < heapRank[b] || heapRank[a] === heapRank[b] && heapAt[a] < heapAt[b];
+  const swap = (a, b) => {
+    [heapRank[a], heapRank[b]] = [heapRank[b], heapRank[a]];
+    [heapAt[a], heapAt[b]] = [heapAt[b], heapAt[a]];
+  };
+  const push = (value, at) => {
+    heapRank.push(value);
+    heapAt.push(at);
+    let child = heapRank.length - 1;
+    while (child > 0) {
+      const parent = child - 1 >> 1;
+      if (!less(child, parent))
+        break;
+      swap(child, parent);
+      child = parent;
+    }
+  };
+  const pop = () => {
+    const last = heapRank.length - 1;
+    swap(0, last);
+    heapRank.pop();
+    heapAt.pop();
+    let parent = 0;
+    for (;; ) {
+      const left = parent * 2 + 1;
+      const right = left + 1;
+      let smallest = parent;
+      if (left < heapRank.length && less(left, smallest))
+        smallest = left;
+      if (right < heapRank.length && less(right, smallest))
+        smallest = right;
+      if (smallest === parent)
+        break;
+      swap(parent, smallest);
+      parent = smallest;
+    }
+  };
+  const pairRank = (at) => {
+    const middle = next[at];
+    if (middle >= length)
+      return NO_RANK;
+    return rankOf(tokenizer, bytes.subarray(at, next[middle]));
+  };
+  const update = (at) => {
+    rank[at] = pairRank(at);
+    if (rank[at] !== NO_RANK)
+      push(rank[at], at);
+  };
+  for (let at = 0;at < length; at += 1)
+    update(at);
+  while (heapRank.length > 0) {
+    const value = heapRank[0];
+    const at = heapAt[0];
+    pop();
+    if (!alive[at] || rank[at] !== value)
+      continue;
+    const removed = next[at];
+    alive[removed] = 0;
+    next[at] = next[removed];
+    prev[next[removed]] = at;
+    update(at);
+    if (at > 0)
+      update(prev[at]);
+  }
+  const tokens = [];
+  for (let at = 0;at < length; at = next[at]) {
+    const value = rankOf(tokenizer, bytes.subarray(at, next[at]));
+    if (value !== NO_RANK)
+      tokens.push(value);
+  }
+  return tokens;
+}
+function mergePiece(tokenizer, piece) {
+  let cache = mergeCaches.get(tokenizer);
+  if (!cache) {
+    cache = { current: new Map, previous: new Map };
+    mergeCaches.set(tokenizer, cache);
+  }
+  let tokens = cache.current.get(piece);
+  if (tokens)
+    return tokens;
+  tokens = cache.previous.get(piece);
+  if (!tokens) {
+    const bytes = textEncoder.encode(piece);
+    mergedPieces += 1;
+    tokens = bytes.length > LONG_PIECE_BYTES ? mergeWithHeap(tokenizer, bytes) : mergeByScanning(tokenizer, bytes);
+  }
+  if (cache.current.size >= MERGE_CACHE_GENERATION) {
+    cache.previous = cache.current;
+    cache.current = new Map;
+  }
+  cache.current.set(piece, tokens);
+  return tokens;
+}
+function encodeTokensExactly(tokenizer, text) {
+  if (!hasInternals(tokenizer)) {
+    return tokenizer.encode(text, "all");
+  }
+  if (text.length < 10) {
+    const direct = tokenizer.stringRankEncoder[text];
+    if (direct !== undefined)
+      return [direct];
+  }
+  const tokens = [];
+  const regex = tokenizer.patternRegex;
+  regex.lastIndex = 0;
+  for (let match = regex.exec(text);match !== null; match = regex.exec(text)) {
+    const piece = match[0];
+    const direct = tokenizer.stringRankEncoder[piece];
+    if (direct !== undefined) {
+      tokens.push(direct);
+      continue;
+    }
+    for (const token of mergePiece(tokenizer, piece))
+      tokens.push(token);
+  }
+  return tokens;
+}
+function countTokensExactly(tokenizer, text) {
+  return encodeTokensExactly(tokenizer, text).length;
+}
+var NO_RANK = 4294967295, LONG_PIECE_BYTES = 256, MERGE_CACHE_GENERATION = 50000, textEncoder, textDecoder, mergeCaches, mergedPieces = 0;
+var init_token_count_exact = __esm(() => {
+  textEncoder = new TextEncoder;
+  textDecoder = new TextDecoder("utf-8");
+  mergeCaches = new WeakMap;
+});
+
 // ../plugin/src/hooks/magic-context/read-session-formatting.ts
 import { createRequire as createRequire2 } from "node:module";
 function hasMeaningfulUserText(parts) {
@@ -28924,7 +29510,7 @@ function estimateTokens(text) {
   if (!activeTokenizer)
     return estimateTokensHeuristically(text);
   try {
-    return activeTokenizer.encode(text, "all").length;
+    return countTokensExactly(activeTokenizer, text);
   } catch (error) {
     tokenizer = undefined;
     tokenizerLoadAttempted = true;
@@ -29015,21 +29601,41 @@ var MAX_COMMITS_PER_BLOCK = 5, tokenizer, tokenizerLoadAttempted = false, tokeni
 var init_read_session_formatting = __esm(() => {
   init_commit_detection();
   init_logger();
+  init_token_count_exact();
   promptTokenCounts = new Map;
   PROMPT_TOKEN_COUNT_BYTES = 8 * 1024 * 1024;
 });
 
 // ../plugin/src/shared/stable-json.ts
 function stableStringify(value, seen = new WeakSet) {
-  if (value === undefined)
-    return "undefined";
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value) ?? String(value);
-  if (seen.has(value))
-    return '"[Circular]"';
+  const pieces = [];
+  writeStable(value, seen, pieces);
+  return pieces.join("");
+}
+function writeStable(value, seen, pieces) {
+  if (value === undefined) {
+    pieces.push("undefined");
+    return;
+  }
+  if (value === null || typeof value !== "object") {
+    pieces.push(JSON.stringify(value) ?? String(value));
+    return;
+  }
+  if (seen.has(value)) {
+    pieces.push('"[Circular]"');
+    return;
+  }
   seen.add(value);
   if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+    pieces.push("[");
+    for (let index = 0;index < value.length; index += 1) {
+      if (index > 0)
+        pieces.push(",");
+      if (index in value)
+        writeStable(value[index], seen, pieces);
+    }
+    pieces.push("]");
+    return;
   }
   const entries = Object.entries(value).sort(([a], [b]) => {
     if (a < b)
@@ -29038,7 +29644,14 @@ function stableStringify(value, seen = new WeakSet) {
       return 1;
     return 0;
   });
-  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
+  pieces.push("{");
+  entries.forEach(([key, child], index) => {
+    if (index > 0)
+      pieces.push(",");
+    pieces.push(JSON.stringify(key), ":");
+    writeStable(child, seen, pieces);
+  });
+  pieces.push("}");
 }
 
 // ../plugin/src/features/magic-context/tool-definition-tokens.ts
@@ -29724,6 +30337,19 @@ var init_image_token_estimate = __esm(() => {
   JPEG_SCAN_LIMIT_BYTES = 256 * 1024;
 });
 
+// ../plugin/src/hooks/magic-context/provider-visible-parts.ts
+var KEPT_TOOL_STATE_FIELDS;
+var init_provider_visible_parts = __esm(() => {
+  KEPT_TOOL_STATE_FIELDS = new Set([
+    "status",
+    "input",
+    "output",
+    "error",
+    "attachments",
+    "content"
+  ]);
+});
+
 // ../plugin/src/hooks/magic-context/todo-view.ts
 var TODO_STATUS_PENDING = "pending", TODO_STATUS_IN_PROGRESS = "in_progress", TODO_STATUS_COMPLETED = "completed", TODO_STATUS_CANCELLED = "cancelled", TODO_PRIORITY_HIGH = "high", TODO_PRIORITY_MEDIUM = "medium", TODO_PRIORITY_LOW = "low", TODO_STATUSES, TODO_PRIORITIES, TODO_STATUS_SET, TODO_PRIORITY_SET, TERMINAL_STATUSES, TITLE_DONE_STATUSES;
 var init_todo_view = __esm(() => {
@@ -29753,10 +30379,11 @@ var init_tail_hygiene_walk = __esm(() => {
   init_reclaim_protection();
   init_tag_owner_id();
   init_image_token_estimate();
+  init_provider_visible_parts();
   init_read_session_formatting();
   init_todo_view();
   init_reclaim_protection();
-  MAX_CONTENT_MEMO_BYTES = 64 * 1024 * 1024;
+  MAX_CONTENT_MEMO_BYTES = 256 * 1024 * 1024;
   contentMemo = new Map;
   contentMemoOrder = new Set;
   baselineMeasurementMemo = new Map;
@@ -29822,12 +30449,14 @@ function pickNearestPriorOwner(candidates, currentMessageId, times) {
   }
   return best?.id ?? null;
 }
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, getAssignableTagNumberByMessageIdStatements, hasPiFallbackMessageTagStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, recentTagOwnerStatements, RECLAIM_HINT_EXCLUDED_TOOLS, getActiveToolTagsForAgeReclaimStatements, scopedActiveTokenTotalStatements, updateTagTokenCountStatements, updateTagInputTokenCountStatements, inertWhitespaceStatements, foldStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, getActiveTagsBySessionStatements, getNullOwnerToolTagsBySessionStatements, getDroppedTagsBySessionStatements, getMaxDroppedTagNumberStatements, newestToolTagNumberStatements, droppedNumberStatements, tagByIdStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, getToolOwnerByTagIdStatements, deleteToolTagsByOwnerStatements;
-var init_storage_tags = __esm(() => {
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, getAssignableTagNumberByMessageIdStatements, hasPiFallbackMessageTagStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, recentTagOwnerStatements, RECLAIM_HINT_EXCLUDED_TOOLS, getActiveToolTagsForAgeReclaimStatements, scopedActiveTokenTotalStatements, updateTagTokenCountStatements, updateTagInputTokenCountStatements, tagOwnerSummaries, TAG_OWNER_COLUMNS = "id, type, message_id, tool_owner_message_id, tag_number, reasoning_token_count", TAG_OWNER_APPENDED_WITH_SHAPE_SQL, inertWhitespaceStatements, inertWhitespaceByNumberStatements, foldStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, getActiveTagsBySessionStatements, getNullOwnerToolTagsBySessionStatements, getDroppedTagsBySessionStatements, getMaxDroppedTagNumberStatements, newestToolTagNumberStatements, droppedNumberStatements, tagByIdStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, getToolOwnerByTagIdStatements, deleteToolTagsByOwnerStatements;
+var init_storage_tags = __esm(async () => {
   init_emergency_drop();
   init_tag_owner_id();
   init_migration_v95_perf_indexes();
   init_storage_ops();
+  init_storage_tag_identity_revision();
+  await init_sqlite();
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
   updateTagDropModeStatements = new WeakMap;
@@ -29855,7 +30484,14 @@ var init_storage_tags = __esm(() => {
   scopedActiveTokenTotalStatements = new WeakMap;
   updateTagTokenCountStatements = new WeakMap;
   updateTagInputTokenCountStatements = new WeakMap;
+  tagOwnerSummaries = new WeakMap;
+  TAG_OWNER_APPENDED_WITH_SHAPE_SQL = `SELECT ${TAG_OWNER_COLUMNS}, 0 AS shape, NULL AS tag_count, NULL AS max_id, NULL AS revision
+    FROM tags WHERE id > ? AND +session_id = ?
+    UNION ALL
+    SELECT NULL, NULL, NULL, NULL, NULL, NULL, 1, COUNT(*), MAX(id), (SELECT value FROM schema_migrations_meta WHERE key = ?)
+    FROM tags WHERE session_id = ?`;
   inertWhitespaceStatements = new WeakMap;
+  inertWhitespaceByNumberStatements = new WeakMap;
   foldStatements = new WeakMap;
   getOwnerScopedToolTagNumbersStatements = new WeakMap;
   getMinMessageTagNumberForRawIdStatements = new WeakMap;
@@ -29973,92 +30609,28 @@ function isHostUnservedRow(value) {
 }
 var HOST_UNSERVED_ROW = "hostUnservedRow";
 
-// ../plugin/src/hooks/magic-context/read-session-db.ts
-function openCodeDbExists() {
-  return harnessOwnsOpenCodeStore() && openCodeDbPathExists(resolveOpenCodeDbPath());
-}
-function closeCachedReadOnlyDb() {
-  if (!cachedReadOnlyDb) {
-    return;
-  }
-  try {
-    closeQuietly(cachedReadOnlyDb.db);
-  } catch (error) {
-    log("[magic-context] failed to close cached OpenCode read-only DB:", error);
-  } finally {
-    cachedReadOnlyDb = null;
-  }
-}
-function getReadOnlySessionDb() {
-  if (!harnessOwnsOpenCodeStore()) {
-    throw new Error("OpenCode session database is not readable from a Pi-compatible process; its history lives in Pi sessions");
-  }
-  const resolution = resolveOpenCodeDbPath();
-  const dbPath = resolution.path;
-  if (!openCodeDbPathExists(resolution)) {
-    throw new Error(`OpenCode session database is unavailable at ${dbPath} (source=${resolution.source})`);
-  }
-  if (cachedReadOnlyDb?.path === dbPath) {
-    return cachedReadOnlyDb.db;
-  }
-  closeCachedReadOnlyDb();
-  const db = new Database(dbPath, { readonly: true });
-  try {
-    assertOpenCodeStoreGeneration(db, "v1", dbPath);
-  } catch (error) {
-    closeQuietly(db);
-    throw error;
+// ../plugin/src/shared/exit-abort-registry.ts
+function abortAll() {
+  for (const controller of controllers) {
+    try {
+      controller.abort();
+    } catch {}
   }
-  cachedReadOnlyDb = { path: dbPath, db };
-  clearOpenCodeDbReadFailure();
-  return db;
-}
-function withReadOnlySessionDb(fn) {
-  return fn(getReadOnlySessionDb());
 }
-function getRawSessionMessageCountFromDb(db, sessionId) {
-  const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
-             AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
-                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
-  return typeof row?.count === "number" ? row.count : 0;
-}
-function logProbeFailureOnce(resolution, error) {
-  const failure = recordOpenCodeDbReadFailure(resolution, error);
-  if (!claimOpenCodeDbDiagnosticOnce("session-state-probe", resolution))
+function registerExitAbort(controller) {
+  controllers.add(controller);
+  if (listenerRegistered)
     return;
-  const message = `[magic-context] OpenCode DB probe failed: path=${resolution.path} source=${resolution.source} cause=${failure.message}`;
-  probeLogObserverForTests?.(message);
-  log(message);
+  listenerRegistered = true;
+  process.once("exit", abortAll);
 }
-function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
-  const result = new Map;
-  if (messageIds.length === 0 || !harnessOwnsOpenCodeStore())
-    return result;
-  try {
-    withReadOnlySessionDb((db) => {
-      const placeholders = messageIds.map(() => "?").join(",");
-      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
-      for (const row of rows) {
-        if (typeof row.id === "string" && typeof row.time_created === "number") {
-          result.set(row.id, row.time_created);
-        }
-      }
-    });
-  } catch (error) {
-    logProbeFailureOnce(resolveOpenCodeDbPath(), error);
-  }
-  return result;
-}
-var cachedReadOnlyDb = null, trackedSessions, pendingParts, probeLogObserverForTests;
-var init_read_session_db = __esm(async () => {
-  init_logger();
-  init_opencode_db_path();
-  await init_sqlite();
-  trackedSessions = new Map;
-  pendingParts = new Map;
+var controllers, listenerRegistered = false;
+var init_exit_abort_registry = __esm(() => {
+  controllers = new Set;
 });
 
 // ../plugin/src/hooks/magic-context/read-session-raw.ts
+import { isMainThread as isMainThread2 } from "node:worker_threads";
 function isRawMessageRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -30118,7 +30690,7 @@ function readRawSessionMessagesFromDb(db, sessionId) {
     if (messageIds.length === 0)
       continue;
     const placeholders = messageIds.map(() => "?").join(", ");
-    const partRows = db.prepare(`SELECT message_id, data, time_updated
+    const partRows = db.prepare(`SELECT message_id, ${RAW_PART_DATA_SQL} AS data, time_updated
                  FROM part
                  WHERE +session_id = ?
                    AND likelihood(message_id IN (${placeholders}), 0.000001)
@@ -30150,7 +30722,7 @@ function readRawSessionMessagePageFromDb(db, sessionId, afterOrdinal, limit, fin
   if (messageRows.length === 0)
     return [];
   const placeholders = messageRows.map(() => "?").join(", ");
-  const partRows = db.prepare(`SELECT message_id, data, time_updated
+  const partRows = db.prepare(`SELECT message_id, ${RAW_PART_DATA_SQL} AS data, time_updated
              FROM part
              WHERE +session_id = ?
                AND likelihood(message_id IN (${placeholders}), 0.000001)
@@ -30162,29 +30734,44 @@ function readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWaterma
   const pageSize = Math.min(Math.max(1, Math.floor(limit)), remaining);
   if (pageSize === 0)
     return [];
-  const parameters = [sessionId];
-  if (after)
-    parameters.push(after.timeCreated, after.timeCreated, after.timeCreated, after.id);
-  parameters.push(pageSize);
-  if (!after)
-    parameters.push(Math.max(0, Math.floor(afterOrdinal)));
-  return db.prepare(`SELECT id, data, time_created, time_updated
-             FROM message
-             WHERE session_id = ?
-                ${after ? "AND time_created >= ? AND (time_created > ? OR (time_created = ? AND id > ?))" : ""}
-                AND NOT (
-                   CASE WHEN json_valid(data) = 1
-                        THEN COALESCE(json_extract(data, '$.summary'), 0)
-                        ELSE 0 END = 1
-                   AND CASE WHEN json_valid(data) = 1
-                            THEN COALESCE(json_extract(data, '$.finish'), '')
-                            ELSE '' END = 'stop'
-               )
-             ORDER BY time_created ASC, id ASC
-             LIMIT ? ${after ? "" : "OFFSET ?"}`).all(...parameters).filter(isRawMessageRow).map((row, index) => ({
-    ...row,
-    ordinal: Math.floor(afterOrdinal) + index + 1
-  }));
+  return withReadSnapshot(db, () => {
+    const ordinal = Math.max(0, Math.floor(afterOrdinal));
+    const points = currentOrdinalCheckpoints(db, sessionId)?.scan.checkpoints ?? [];
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (points[middle].ordinal <= ordinal)
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    const floor = points[low - 1];
+    const useFloor = floor && (!after || compareOrdinalKeys(floor, after) > 0);
+    const anchor = useFloor ? floor : after;
+    const skip = anchor === after && after ? 0 : ordinal - (floor?.ordinal ?? 0);
+    if (skip > ORDINAL_LOOKUP_LIMIT) {
+      prewarmRawSessionOrdinalsForDb(db, sessionId);
+      throw new RawOrdinalsNotReady;
+    }
+    const rawLimit = skip + pageSize + ORDINAL_LOOKUP_LIMIT;
+    const rows = db.prepare(`SELECT id, data, time_created, time_updated, ${EXCLUDED_ROW_SQL} AS excluded
+                FROM message WHERE id IN (
+                    SELECT id FROM message WHERE session_id = ?
+                    ${anchor ? "AND (time_created, id) > (?, ?)" : ""}
+                    ORDER BY time_created, id LIMIT ?)
+                ORDER BY time_created, id`).all(sessionId, ...anchor ? [anchor.timeCreated, anchor.id] : [], rawLimit);
+    rawMessagePageRowsVisited += rows.length;
+    const eligible = rows.filter((row) => row.excluded !== 1);
+    if (eligible.length <= skip && rows.length === rawLimit) {
+      prewarmRawSessionOrdinalsForDb(db, sessionId);
+      throw new RawOrdinalsNotReady;
+    }
+    return eligible.slice(skip, skip + pageSize).filter(isRawMessageRow).map((row, index) => ({
+      ...row,
+      ordinal: ordinal + index + 1
+    }));
+  });
 }
 function assembleRawMessagePage(messageRows, partRows) {
   const partsByMessageId = new Map;
@@ -30223,6 +30810,9 @@ function readRawSessionMessageSummaryPageFromDb(db, sessionId, afterOrdinal, lim
   return assembleRawMessagePage(messageRows, partRows);
 }
 function countRawSessionMessageOrdinalsFromDb(db, sessionId) {
+  const indexed = countCanonicalOrdinalsIndexed(db, sessionId, null, null);
+  if (indexed !== null)
+    return indexed;
   const row = db.prepare(`SELECT COUNT(*) AS count
              FROM message
              WHERE session_id = ?
@@ -30309,7 +30899,7 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
     for (let i = 0;i < ids.length; i += CHUNK) {
       const slice = ids.slice(i, i + CHUNK);
       const placeholders = slice.map(() => "?").join(",");
-      const partRows = db.prepare(`SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id IN (${placeholders}), 0.000001) ORDER BY time_created ASC, id ASC`).all(sessionId, ...slice).filter(isRawPartRow);
+      const partRows = db.prepare(`SELECT message_id, ${RAW_PART_DATA_SQL} AS data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id IN (${placeholders}), 0.000001) ORDER BY time_created ASC, id ASC`).all(sessionId, ...slice).filter(isRawPartRow);
       for (const part of partRows) {
         const list = partsByMessageId.get(part.message_id) ?? [];
         list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
@@ -30355,49 +30945,431 @@ function readRawSessionMessagePartsByIdFromDb(db, sessionId, messageId, onQuery)
     version: row.time_updated ?? null
   };
 }
-function readRawSessionMessageOrdinalByIdFromDb(db, sessionId, messageId) {
-  const row = db.prepare(`SELECT COUNT(candidate.id) AS ordinal
-             FROM message AS target
-             JOIN message AS candidate
-               ON candidate.session_id = target.session_id
-              AND NOT (
-                  CASE WHEN json_valid(candidate.data) = 1
-                       THEN COALESCE(json_extract(candidate.data, '$.summary'), 0)
-                       ELSE 0 END = 1
-                  AND CASE WHEN json_valid(candidate.data) = 1
-                           THEN COALESCE(json_extract(candidate.data, '$.finish'), '')
-                           ELSE '' END = 'stop'
-              )
-              AND (candidate.time_created < target.time_created
-                   OR (candidate.time_created = target.time_created AND candidate.id <= target.id))
-             WHERE target.session_id = ?
-               AND target.id = ?
-               AND NOT (
-                   CASE WHEN json_valid(target.data) = 1
-                        THEN COALESCE(json_extract(target.data, '$.summary'), 0)
-                        ELSE 0 END = 1
-                   AND CASE WHEN json_valid(target.data) = 1
-                            THEN COALESCE(json_extract(target.data, '$.finish'), '')
-                            ELSE '' END = 'stop'
-               )`).get(sessionId, messageId);
-  const ordinal = row?.ordinal;
-  return typeof ordinal === "number" && ordinal > 0 ? ordinal : null;
+function ordinalRangeSql(lowerBound) {
+  return `SELECT COUNT(*) AS visited,
+                   COALESCE(SUM(CASE WHEN ${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL}
+                                     THEN 0 ELSE 1 END), 0) AS eligible
+            FROM message
+            WHERE session_id = ?
+              ${lowerBound ? "AND (time_created, id) > (?, ?)" : ""}
+              AND (time_created, id) <= (?, ?)`;
 }
-function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
-  const row = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? AND id = ?").get(sessionId, messageId);
-  if (!row || !isRawMessageRow(row) || typeof row.time_created !== "number") {
+function readStoreStamp(db) {
+  try {
+    const row = db.prepare(`SELECT data_version AS dataVersion, total_changes() AS totalChanges,
+                        (SELECT schema_version FROM pragma_schema_version) AS schemaVersion
+                 FROM pragma_data_version`).get();
+    if (typeof row?.dataVersion !== "number" || typeof row.totalChanges !== "number" || typeof row.schemaVersion !== "number")
+      return null;
+    return {
+      dataVersion: row.dataVersion,
+      totalChanges: row.totalChanges,
+      schemaVersion: row.schemaVersion
+    };
+  } catch {
     return null;
   }
-  const info = parseJsonRecord(row.data);
-  if (!info || isRawCompactionSummaryInfo(info)) {
+}
+function sameStoreStamp(left, right) {
+  return left !== null && right !== null && left.dataVersion === right.dataVersion && left.totalChanges === right.totalChanges && left.schemaVersion === right.schemaVersion;
+}
+function compareOrdinalKeys(left, right) {
+  if (left.timeCreated !== right.timeCreated)
+    return left.timeCreated < right.timeCreated ? -1 : 1;
+  if (left.id === right.id)
+    return 0;
+  return Buffer.compare(Buffer.from(left.id, "utf8"), Buffer.from(right.id, "utf8"));
+}
+function countEligibleOrdinals(db, sessionId, after, through) {
+  const indexed = countCanonicalOrdinalsIndexed(db, sessionId, after, through);
+  if (indexed !== null)
+    return indexed;
+  const row = after ? db.prepare(ORDINAL_RANGE_BETWEEN_SQL).get(sessionId, after.timeCreated, after.id, through.timeCreated, through.id) : db.prepare(ORDINAL_RANGE_FROM_START_SQL).get(sessionId, through.timeCreated, through.id);
+  const visited = typeof row?.visited === "number" ? row.visited : 0;
+  ordinalRowsVisited += visited;
+  ordinalJsonRowsRead += visited;
+  return typeof row?.eligible === "number" ? row.eligible : 0;
+}
+function survivingAnchor(db, set) {
+  if (set.anchors.length === 0)
     return null;
+  const current = new Map(db.prepare(ANCHOR_CHECK_SQL).all(JSON.stringify(set.anchors.map((anchor) => anchor.rowid))).map((row) => [row.rid, row.id]));
+  return set.anchors.find((anchor) => current.get(anchor.rowid) === anchor.id);
+}
+function currentOrdinalCheckpoints(db, sessionId) {
+  const cached = ordinalCheckpoints.get(db)?.get(sessionId);
+  if (!cached)
+    return;
+  return withReadSnapshot(db, () => {
+    if (!extendOrdinalCheckpoints(db, sessionId, cached.scan, ORDINAL_LOOKUP_LIMIT))
+      return;
+    cached.epoch = getRawSessionSummaryEpoch(sessionId);
+    return cached;
+  });
+}
+function extendOrdinalCheckpoints(db, sessionId, scan, limit) {
+  const points = scan.checkpoints ?? [];
+  const exists = (point) => Boolean(db.prepare("SELECT 1 FROM message WHERE id=? AND session_id=? AND time_created=?").get(point.id, sessionId, point.timeCreated));
+  if (points.length && !exists(points[points.length - 1])) {
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (exists(points[middle]))
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    points.length = low;
+    scan.total = points.at(-1)?.ordinal ?? 0;
+    scan.sessionRows = points.at(-1)?.storedCount ?? 0;
+  }
+  const tail = points.at(-1);
+  const rows = db.prepare(`SELECT id, time_created AS timeCreated, ${EXCLUDED_ROW_SQL} AS excluded FROM message
+        WHERE session_id=?${tail ? " AND (time_created,id) > (?,?)" : ""}
+        ORDER BY time_created,id${limit === undefined ? "" : ` LIMIT ${limit + 1}`}`).all(sessionId, ...tail ? [tail.timeCreated, tail.id] : []);
+  ordinalJsonRowsRead += rows.length;
+  if (limit !== undefined && rows.length > limit)
+    return false;
+  let total = scan.total ?? 0;
+  if (rows.length && tail && (tail.storedCount ?? 0) % 256 !== 0)
+    points.pop();
+  for (let index = 0;index < rows.length; index++) {
+    const row = rows[index];
+    if (row.excluded !== 1)
+      total++;
+    const storedCount = scan.sessionRows + index + 1;
+    if (storedCount % 256 === 0 || index === rows.length - 1)
+      points.push({ id: row.id, timeCreated: row.timeCreated, ordinal: total, storedCount });
+  }
+  scan.checkpoints = points;
+  scan.sessionRows += rows.length;
+  scan.total = total;
+  return true;
+}
+function rawOrdinalSummarySeed(db, sessionId) {
+  const retained = ordinalCheckpoints.get(db)?.get(sessionId);
+  if (retained)
+    return retained.scan;
+  const seed = ordinalSummarySeeds.get(db)?.get(sessionId);
+  if (!seed || seed.epoch !== getRawSessionSummaryEpoch(sessionId))
+    return;
+  return {
+    ...seed.scan,
+    ids: [...new Set([...seed.scan.ids, ...writtenSummaryIds.get(sessionId) ?? []])]
+  };
+}
+function boundedOrdinalPrefix(db, sessionId, through) {
+  const cached = currentOrdinalCheckpoints(db, sessionId);
+  if (cached && through === null)
+    return cached.scan.total ?? 0;
+  let floor;
+  if (cached && through) {
+    const points = cached.scan.checkpoints ?? [];
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (compareOrdinalKeys(points[middle], through) <= 0)
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    floor = points[low - 1];
+    if (floor && compareOrdinalKeys(floor, through) === 0)
+      return floor.ordinal;
+  }
+  const bindings = [sessionId];
+  if (floor)
+    bindings.push(floor.timeCreated, floor.id);
+  if (through)
+    bindings.push(through.timeCreated, through.id);
+  const rows = db.prepare(`SELECT ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE id IN (
+        SELECT id FROM message WHERE session_id = ?${floor ? " AND (time_created, id) > (?, ?)" : ""}${through ? " AND (time_created, id) <= (?, ?)" : ""}
+        ORDER BY time_created, id LIMIT ${ORDINAL_LOOKUP_LIMIT + 1})`).all(...bindings);
+  ordinalRowsVisited += rows.length;
+  ordinalJsonRowsRead += rows.length;
+  if (rows.length > ORDINAL_LOOKUP_LIMIT) {
+    prewarmRawSessionOrdinalsForDb(db, sessionId);
+    throw new RawOrdinalsNotReady;
+  }
+  return (floor?.ordinal ?? 0) + rows.reduce((sum, row) => sum + (row.excluded === 1 ? 0 : 1), 0);
+}
+function scanRawSessionSummaryRows(db, sessionId, previous) {
+  return withReadSnapshot(db, () => {
+    if (previous?.checkpoints) {
+      extendOrdinalCheckpoints(db, sessionId, previous);
+      return previous;
+    }
+    if (previous) {
+      const sessions = summaryCandidateSets.get(db) ?? new Map;
+      sessions.set(sessionId, {
+        epoch: getRawSessionSummaryEpoch(sessionId),
+        anchors: previous.anchors,
+        ids: new Set(previous.ids)
+      });
+      summaryCandidateSets.set(db, sessions);
+    }
+    const incremental = previous && isRawSessionSummaryWarm(db, sessionId) ? summaryCandidatesOf(db, sessionId) : undefined;
+    const rows = incremental ? [] : db.prepare(SUMMARY_FULL_SCAN_SQL).all(sessionId, sessionId);
+    const anchors = [];
+    const ids = [];
+    let sessionRows = 0;
+    for (const row of rows) {
+      if (row.kind === 1 && typeof row.rid === "number" && typeof row.id === "string")
+        anchors.push({ rowid: row.rid, id: row.id });
+      else if (row.kind === 2 && typeof row.id === "string")
+        ids.push(row.id);
+      else if (row.kind === 4 && typeof row.rid === "number")
+        sessionRows = row.rid;
+    }
+    if (incremental) {
+      ids.push(...incremental.ids);
+      anchors.push(...summaryCandidateSets.get(db)?.get(sessionId)?.anchors ?? []);
+      sessionRows = countStoredRawSessionRowsIndexed(db, sessionId);
+    }
+    anchors.sort((left, right) => right.rowid - left.rowid);
+    anchors.length = Math.min(anchors.length, SUMMARY_ANCHOR_LIMIT);
+    const keys = db.prepare(`SELECT id, time_created AS timeCreated, ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE session_id = ?
+        ORDER BY time_created, id`).all(sessionId);
+    const checkpoints = [];
+    let total = 0;
+    for (let index = 0;index < keys.length; index++) {
+      const key = keys[index];
+      if (key.excluded !== 1)
+        total++;
+      if (index % 256 === 255 || index === keys.length - 1)
+        checkpoints.push({
+          id: key.id,
+          timeCreated: key.timeCreated,
+          ordinal: total,
+          storedCount: index + 1
+        });
+    }
+    return { anchors, ids, sessionRows, checkpoints, total };
+  });
+}
+function getRawSessionSummaryEpoch(sessionId) {
+  return summaryCandidateEpochs.get(sessionId) ?? 0;
+}
+function installRawSessionSummaryScan(db, sessionId, scan, epoch, workerPrepared = false) {
+  if (epoch !== getRawSessionSummaryEpoch(sessionId))
+    return false;
+  const seeds = ordinalSummarySeeds.get(db) ?? new Map;
+  seeds.set(sessionId, { epoch, scan });
+  ordinalSummarySeeds.set(db, seeds);
+  if (scan.checkpoints && workerPrepared) {
+    const counts = ordinalCheckpoints.get(db) ?? new Map;
+    counts.set(sessionId, { epoch, scan });
+    ordinalCheckpoints.set(db, counts);
+  } else if (getSqliteDatabasePath(db) && isMainThread2)
+    return false;
+  if (isRawSessionSummaryWarm(db, sessionId))
+    return true;
+  let sessions = summaryCandidateSets.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    summaryCandidateSets.set(db, sessions);
   }
-  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;
+  sessions.set(sessionId, { epoch, anchors: [...scan.anchors], ids: new Set(scan.ids) });
+  return isRawSessionSummaryWarm(db, sessionId);
+}
+function isRawSessionSummaryWarm(db, sessionId) {
+  if (isMainThread2 && getSqliteDatabasePath(db)) {
+    return Boolean(currentOrdinalCheckpoints(db, sessionId));
+  }
+  const set = summaryCandidateSets.get(db)?.get(sessionId);
+  if (!set || set.epoch !== getRawSessionSummaryEpoch(sessionId))
+    return false;
+  try {
+    return survivingAnchor(db, set) !== undefined;
+  } catch {
+    return false;
+  }
+}
+function countStoredRawSessionRowsIndexed(db, sessionId) {
+  const row = db.prepare("SELECT COUNT(*) AS count FROM message WHERE session_id = ?").get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function summaryCandidatesOf(db, sessionId) {
+  let sessions = summaryCandidateSets.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    summaryCandidateSets.set(db, sessions);
+  }
+  const epoch = getRawSessionSummaryEpoch(sessionId);
+  const cached = sessions.get(sessionId);
+  const floor = cached && cached.epoch === epoch ? survivingAnchor(db, cached) : undefined;
+  let ids;
+  let anchors;
+  if (floor === undefined) {
+    const scan = scanRawSessionSummaryRows(db, sessionId);
+    summaryFullScans += 1;
+    ordinalJsonRowsRead += scan.sessionRows;
+    ids = new Set(scan.ids);
+    anchors = scan.anchors;
+  } else {
+    const rows = db.prepare(SUMMARY_SCAN_AFTER_SQL).all(floor?.rowid ?? 0, sessionId);
+    ids = cached?.ids ?? new Set;
+    anchors = [];
+    for (const row of rows) {
+      if (row.kind === 1 && typeof row.rid === "number" && typeof row.id === "string")
+        anchors.push({ rowid: row.rid, id: row.id });
+      else if (row.kind === 2 && typeof row.id === "string")
+        ids.add(row.id);
+      if (row.kind === 2 || row.kind === 3)
+        ordinalJsonRowsRead += 1;
+    }
+    anchors.sort((left, right) => right.rowid - left.rowid);
+    anchors.length = Math.min(anchors.length, SUMMARY_ANCHOR_LIMIT);
+  }
+  for (const id of writtenSummaryIds.get(sessionId) ?? [])
+    ids.add(id);
+  sessions.set(sessionId, { epoch, anchors, ids });
+  const top = anchors[0];
+  return { ids: [...ids], floorRowid: top?.rowid ?? 0, floorId: top?.id ?? null };
+}
+function canonicalCountSql(lower, upper) {
+  const range = `${lower ? " AND (time_created, id) > (?, ?)" : ""}${upper ? " AND (time_created, id) <= (?, ?)" : ""}`;
+  return `SELECT
+        (SELECT COUNT(*) FROM message WHERE session_id = ?${range}) AS stored,
+        (SELECT COUNT(*) FROM message
+          WHERE id IN (SELECT value FROM json_each(?)) AND +session_id = ?${range}
+            AND ${EXCLUDED_ROW_SQL}) AS knownExcluded,
+        (SELECT COUNT(*) FROM message
+          WHERE rowid > ? AND +session_id = ? AND id NOT IN (SELECT value FROM json_each(?))${range}
+            AND ${EXCLUDED_ROW_SQL}) AS newExcluded,
+        (SELECT id FROM message WHERE rowid = ?) AS floorId`;
+}
+function canonicalCountStatementText(lower, upper) {
+  const key = `${lower}:${upper}`;
+  let sql = CANONICAL_COUNT_SQL.get(key);
+  if (!sql) {
+    sql = canonicalCountSql(lower, upper);
+    CANONICAL_COUNT_SQL.set(key, sql);
+  }
+  return sql;
+}
+function countCanonicalOrdinalsIndexed(db, sessionId, after, through) {
+  if (isMainThread2 && getSqliteDatabasePath(db)) {
+    return withReadSnapshot(db, () => boundedOrdinalPrefix(db, sessionId, through) - (after ? boundedOrdinalPrefix(db, sessionId, after) : 0));
+  }
+  if (indexedCountUnsupported.has(db))
+    return null;
+  const range = [];
+  if (after)
+    range.push(after.timeCreated, after.id);
+  if (through)
+    range.push(through.timeCreated, through.id);
+  try {
+    return withReadSnapshot(db, () => {
+      for (let attempt = 0;attempt < STABLE_STORE_ATTEMPTS; attempt += 1) {
+        const view = summaryCandidatesOf(db, sessionId);
+        const ids = JSON.stringify(view.ids);
+        const row = db.prepare(canonicalCountStatementText(after !== null, through !== null)).get(sessionId, ...range, ids, sessionId, ...range, view.floorRowid, sessionId, ids, ...range, view.floorRowid);
+        if (view.floorId !== null && row?.floorId !== view.floorId)
+          continue;
+        const stored = typeof row?.stored === "number" ? row.stored : 0;
+        const excluded = (typeof row?.knownExcluded === "number" ? row.knownExcluded : 0) + (typeof row?.newExcluded === "number" ? row.newExcluded : 0);
+        ordinalRowsVisited += stored;
+        ordinalJsonRowsRead += view.ids.length;
+        return stored - excluded;
+      }
+      return null;
+    });
+  } catch (error) {
+    if (/no such (column|table|function)|json_each/i.test(String(error))) {
+      indexedCountUnsupported.add(db);
+      return null;
+    }
+    throw error;
+  }
+}
+function connectionHasOpenTransaction(db) {
+  const state = db;
+  return state.inTransaction === true || state.isTransaction === true;
+}
+function withReadSnapshot(db, read) {
+  if (connectionHasOpenTransaction(db))
+    return read();
+  db.exec("BEGIN");
+  try {
+    return read();
+  } finally {
+    if (connectionHasOpenTransaction(db))
+      db.exec("ROLLBACK");
+  }
+}
+function reusableWatermark(db, sessionId, stamp) {
+  const watermark = ordinalWatermarks.get(db)?.get(sessionId);
+  if (!watermark || watermark.epoch !== (ordinalWatermarkEpochs.get(sessionId) ?? 0) || !sameStoreStamp(watermark.stamp, stamp))
+    return null;
+  return watermark;
+}
+function rememberOrdinalWatermark(db, sessionId, key, ordinal, stamp) {
+  let sessions = ordinalWatermarks.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    ordinalWatermarks.set(db, sessions);
+  }
+  const current = sessions.get(sessionId);
+  if (current && sameStoreStamp(current.stamp, stamp) && compareOrdinalKeys(current, key) >= 0)
+    return;
+  sessions.set(sessionId, {
+    timeCreated: key.timeCreated,
+    id: key.id,
+    ordinal,
+    stamp,
+    epoch: ordinalWatermarkEpochs.get(sessionId) ?? 0
+  });
+}
+function canonicalOrdinalOf(db, sessionId, readTarget) {
+  for (let attempt = 1;; attempt += 1) {
+    const before = readStoreStamp(db);
+    const target = readTarget();
+    if (!target)
+      return null;
+    const watermark = attempt < STABLE_STORE_ATTEMPTS ? reusableWatermark(db, sessionId, before) : null;
+    if (!watermark) {
+      const ordinal = countEligibleOrdinals(db, sessionId, null, target);
+      if (before && sameStoreStamp(before, readStoreStamp(db)))
+        rememberOrdinalWatermark(db, sessionId, target, ordinal, before);
+      return { target, ordinal };
+    }
+    const order = compareOrdinalKeys(target, watermark);
+    const ordinal = order === 0 ? watermark.ordinal : order < 0 ? watermark.ordinal - countEligibleOrdinals(db, sessionId, target, watermark) : watermark.ordinal + countEligibleOrdinals(db, sessionId, watermark, target);
+    if (sameStoreStamp(before, readStoreStamp(db))) {
+      rememberOrdinalWatermark(db, sessionId, target, ordinal, before);
+      return { target, ordinal };
+    }
+  }
+}
+function readRawSessionMessageOrdinalByIdFromDb(db, sessionId, messageId) {
+  const counted = canonicalOrdinalOf(db, sessionId, () => {
+    const row = db.prepare(`SELECT id, time_created, ${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL} AS excluded
+                 FROM message WHERE session_id = ? AND id = ?`).get(sessionId, messageId);
+    if (typeof row?.id !== "string" || typeof row.time_created !== "number")
+      return null;
+    return { id: row.id, timeCreated: row.time_created, excluded: row.excluded === 1 };
+  });
+  if (!counted || counted.target.excluded)
+    return null;
+  return counted.ordinal > 0 ? counted.ordinal : null;
+}
+function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
+  const counted = canonicalOrdinalOf(db, sessionId, () => {
+    const row = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? AND id = ?").get(sessionId, messageId);
+    if (!row || !isRawMessageRow(row) || typeof row.time_created !== "number")
+      return null;
+    const parsed = parseJsonRecord(row.data);
+    if (!parsed || isRawCompactionSummaryInfo(parsed))
+      return null;
+    return { ...row, timeCreated: row.time_created, info: parsed };
+  });
+  if (!counted)
+    return null;
+  const { target: row, ordinal } = counted;
+  const info = row.info;
   if (ordinal <= 0) {
     return null;
   }
@@ -30461,8 +31433,147 @@ function readRawSeedTailFromDb(db, sessionId, boundaryId) {
     throw new Error("state_sync materialized boundary is missing from raw storage");
   return messages;
 }
-var RAW_MESSAGE_PARTS_BY_ID_SQL = "SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001) ORDER BY time_created ASC, id ASC", RAW_SUMMARY_TEXT_MAX_CHARS = 8192, RAW_SUMMARY_ARG_MAX_CHARS = 512, RAW_SUMMARY_TOOL_INPUT_KEYS, RAW_SUMMARY_PART_DATA_SQL;
-var init_read_session_raw = __esm(() => {
+function readBoundaryEndpointRows(db, sessionId, ids, blockIds, into) {
+  if (ids.length > 0) {
+    boundaryEndpointRowsRead += ids.length;
+    const wanted = JSON.stringify(ids);
+    const ordinals = new Map;
+    for (const row of db.prepare(BOUNDARY_ORDINAL_SQL).all(sessionId, wanted)) {
+      ordinals.set(row.id, row.ordinal);
+    }
+    const rows = db.prepare(BOUNDARY_MESSAGE_SQL).all(sessionId, wanted);
+    for (const id of ids)
+      into.set(id, null);
+    for (const row of rows) {
+      if (!isRawMessageRow(row) || typeof row.time_created !== "number")
+        continue;
+      const info = parseJsonRecord(row.data);
+      if (!info || isRawCompactionSummaryInfo(info))
+        continue;
+      into.set(row.id, {
+        ordinal: ordinals.get(row.id) ?? null,
+        createdAt: row.time_created
+      });
+    }
+  }
+  const servable = blockIds.filter((id) => {
+    const endpoint = into.get(id);
+    return endpoint && endpoint.lastBlockIndex === undefined;
+  });
+  if (servable.length === 0)
+    return;
+  const counts = new Map;
+  for (const row of db.prepare(BOUNDARY_BLOCK_COUNT_SQL).all(sessionId, JSON.stringify(servable))) {
+    counts.set(row.id, row.blocks);
+  }
+  for (const id of servable) {
+    const endpoint = into.get(id);
+    if (!endpoint)
+      continue;
+    const blocks = counts.get(id) ?? 0;
+    into.set(id, { ...endpoint, lastBlockIndex: blocks > 0 ? blocks - 1 : 0 });
+  }
+}
+function readRawSessionBoundaryEndpointsFromDb(db, sessionId, ids, blockIds = []) {
+  const wanted = [...new Set(ids)];
+  const wantedBlocks = [...new Set(blockIds)];
+  let sessions = boundaryEndpointCaches.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    boundaryEndpointCaches.set(db, sessions);
+  }
+  for (let attempt = 1;; attempt += 1) {
+    const before = readStoreStamp(db);
+    const cached = sessions.get(sessionId);
+    const reuse = attempt === 1 && cached && sameStoreStamp(cached.stamp, before);
+    const endpoints = new Map(reuse ? cached.endpoints : []);
+    const missing = wanted.filter((id) => !endpoints.has(id));
+    withReadSnapshot(db, () => readBoundaryEndpointRows(db, sessionId, missing, wantedBlocks, endpoints));
+    const unchanged = before !== null && sameStoreStamp(before, readStoreStamp(db));
+    if (unchanged) {
+      sessions.delete(sessionId);
+      sessions.set(sessionId, { stamp: before, endpoints });
+      while (sessions.size > BOUNDARY_ENDPOINT_CACHE_SESSIONS) {
+        const oldest = sessions.keys().next().value;
+        if (oldest === undefined)
+          break;
+        sessions.delete(oldest);
+      }
+    } else if (reuse) {
+      continue;
+    }
+    return new Map(wanted.map((id) => [id, endpoints.get(id) ?? null]));
+  }
+}
+var RAW_MESSAGE_PARTS_BY_ID_SQL = "SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001) ORDER BY time_created ASC, id ASC", RAW_METADATA_KEEP_CHARS = 16384, RAW_METADATA_KEPT_KEYS, RAW_PART_DATA_SQL, rawMessagePageRowsVisited = 0, RAW_SUMMARY_TEXT_MAX_CHARS = 8192, RAW_SUMMARY_ARG_MAX_CHARS = 512, RAW_SUMMARY_TOOL_INPUT_KEYS, RAW_SUMMARY_PART_DATA_SQL, ORDINAL_SUMMARY_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+        THEN COALESCE(json_extract(data, '$.summary'), 0)
+        ELSE 0 END = 1)`, ORDINAL_STOP_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+        THEN COALESCE(json_extract(data, '$.finish'), '')
+        ELSE '' END = 'stop')`, ORDINAL_RANGE_FROM_START_SQL, ORDINAL_RANGE_BETWEEN_SQL, ordinalWatermarks, ordinalWatermarkEpochs, ordinalRowsVisited = 0, STABLE_STORE_ATTEMPTS = 3, EXCLUDED_ROW_SQL, SUMMARY_ANCHOR_SPAN = 256, SUMMARY_ANCHOR_LIMIT = 64, summaryCandidateSets, summaryCandidateEpochs, writtenSummaryIds, indexedCountUnsupported, ordinalJsonRowsRead = 0, summaryFullScans = 0, ANCHOR_ROWS_SQL, SUMMARY_FULL_SCAN_SQL, SUMMARY_SCAN_AFTER_SQL, ANCHOR_CHECK_SQL = "SELECT rowid AS rid, id FROM message WHERE rowid IN (SELECT value FROM json_each(?))", ordinalCheckpoints, ordinalSummarySeeds, ORDINAL_LOOKUP_LIMIT = 512, RawOrdinalsNotReady, CANONICAL_COUNT_SQL, BOUNDARY_ORDINAL_SQL = `
+    SELECT id, ordinal FROM (
+        SELECT id, ROW_NUMBER() OVER (ORDER BY time_created, id) AS ordinal
+        FROM message
+        WHERE session_id = ?
+          AND typeof(id) = 'text' AND typeof(data) = 'text'
+          AND CASE WHEN json_valid(data) THEN NOT (
+                COALESCE(json_type(data, '$.summary'), '') = 'true'
+                AND COALESCE(json_extract(data, '$.finish'), '') = 'stop'
+              ) ELSE 1 END
+    )
+    WHERE id IN (SELECT value FROM json_each(?))`, BOUNDARY_MESSAGE_SQL = `
+    SELECT id, data, time_created FROM message
+    WHERE +session_id = ? AND id IN (SELECT value FROM json_each(?))`, BOUNDARY_BLOCK_COUNT_SQL = `
+    SELECT message_id AS id, SUM(
+        CASE
+            WHEN NOT json_valid(data) OR json_type(data) <> 'object' THEN 0
+            ELSE CASE (CASE WHEN json_type(data, '$.type') = 'text'
+                            THEN json_extract(data, '$.type') ELSE 'unknown' END)
+                WHEN 'text' THEN CASE WHEN json_type(data, '$.ignored') = 'true' THEN 0 ELSE 1 END
+                WHEN 'reasoning' THEN 1
+                WHEN 'thinking' THEN 1
+                WHEN 'redacted_thinking' THEN 1
+                WHEN 'tool' THEN 1 + CASE
+                    WHEN json_type(data, '$.state') = 'object'
+                     AND json_type(data, '$.state.status') = 'text'
+                     AND json_extract(data, '$.state.status') IN ('completed', 'error')
+                    THEN 1 ELSE 0 END
+                WHEN 'compaction' THEN 0
+                WHEN 'step-finish' THEN 0
+                WHEN 'snapshot' THEN 0
+                WHEN 'patch' THEN 0
+                WHEN 'agent' THEN 0
+                WHEN 'retry' THEN 0
+                ELSE 1
+            END
+        END) AS blocks
+    FROM part
+    WHERE +session_id = ?
+      AND message_id IN (SELECT value FROM json_each(?))
+      AND typeof(message_id) = 'text' AND typeof(data) = 'text'
+    GROUP BY message_id`, boundaryEndpointCaches, BOUNDARY_ENDPOINT_CACHE_SESSIONS = 16, boundaryEndpointRowsRead = 0;
+var init_read_session_raw = __esm(async () => {
+  await __promiseAll([
+    init_sqlite(),
+    init_raw_ordinal_warmup()
+  ]);
+  RAW_METADATA_KEPT_KEYS = [
+    "description",
+    "title",
+    "userAnswer",
+    "answers",
+    "answer",
+    "selectedOptions",
+    "customInput",
+    "results"
+  ];
+  RAW_PART_DATA_SQL = `CASE
+    WHEN json_valid(data) = 1
+     AND json_type(data, '$.state.metadata') = 'object'
+     AND COALESCE(json_extract(data, '$.state.status'), '') <> 'error'
+     AND length(json_extract(data, '$.state.metadata')) > ${RAW_METADATA_KEEP_CHARS}
+    THEN json_set(data, '$.state.metadata', json_patch('{}', json_object(${RAW_METADATA_KEPT_KEYS.map((key) => `'${key}', json_extract(data, '$.state.metadata.${key}')`).join(", ")})))
+    ELSE data
+END`;
   RAW_SUMMARY_TOOL_INPUT_KEYS = [
     "description",
     "filePath",
@@ -30487,6 +31598,269 @@ var init_read_session_raw = __esm(() => {
         )
     )
 END`;
+  ORDINAL_RANGE_FROM_START_SQL = ordinalRangeSql(false);
+  ORDINAL_RANGE_BETWEEN_SQL = ordinalRangeSql(true);
+  ordinalWatermarks = new WeakMap;
+  ordinalWatermarkEpochs = new Map;
+  EXCLUDED_ROW_SQL = `${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL}`;
+  summaryCandidateSets = new WeakMap;
+  summaryCandidateEpochs = new Map;
+  writtenSummaryIds = new Map;
+  indexedCountUnsupported = new WeakSet;
+  ANCHOR_ROWS_SQL = `SELECT rowid AS rid, id, 1 AS kind FROM message
+    WHERE rowid > (SELECT MAX(rowid) FROM message) - ${SUMMARY_ANCHOR_SPAN}`;
+  SUMMARY_FULL_SCAN_SQL = `${ANCHOR_ROWS_SQL}
+    UNION ALL
+    SELECT rowid, id, 2 FROM message WHERE session_id = ? AND ${ORDINAL_SUMMARY_FLAG_SQL}
+    UNION ALL
+    SELECT COUNT(*), NULL, 4 FROM message WHERE session_id = ?`;
+  SUMMARY_SCAN_AFTER_SQL = `${ANCHOR_ROWS_SQL}
+    UNION ALL
+    SELECT rowid, id, CASE WHEN ${ORDINAL_SUMMARY_FLAG_SQL} THEN 2 ELSE 3 END
+    FROM message WHERE rowid > ? AND +session_id = ?`;
+  ordinalCheckpoints = new WeakMap;
+  ordinalSummarySeeds = new WeakMap;
+  RawOrdinalsNotReady = class RawOrdinalsNotReady extends Error {
+    constructor() {
+      super("canonical ordinals are warming off-thread; retry after preparation");
+    }
+  };
+  CANONICAL_COUNT_SQL = new Map;
+  boundaryEndpointCaches = new WeakMap;
+});
+
+// ../plugin/src/hooks/magic-context/raw-ordinal-warmup.ts
+import { Worker } from "node:worker_threads";
+function stopRawSessionOrdinalWarmups() {
+  for (const stop of [...activeWorkers.values()])
+    stop("stopped");
+}
+function defaultEntry() {
+  return new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./raw-ordinal-warmup-worker.ts" : "./raw-ordinal-warmup-worker.js", import.meta.url);
+}
+function ensureExitHook() {
+  if (exitHookRegistered)
+    return;
+  exitHookRegistered = true;
+  const controller = new AbortController;
+  controller.signal.addEventListener("abort", stopRawSessionOrdinalWarmups, { once: true });
+  registerExitAbort(controller);
+}
+function runSessionWarmupWorker(input, options) {
+  ensureExitHook();
+  return new Promise((resolve) => {
+    let worker;
+    let deadline;
+    let settled = false;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(deadline);
+      if (worker) {
+        activeWorkers.delete(worker);
+        const stopped = worker.terminate();
+        worker.unref();
+        stopped.finally(() => {
+          releaseIndexOwner(input);
+          resolve(result);
+        });
+        return;
+      }
+      releaseIndexOwner(input);
+      resolve(result);
+    };
+    const arm = (failure, ms) => {
+      clearTimeout(deadline);
+      deadline = setTimeout(() => finish({ failure, detail: `no reply within ${ms} ms` }), ms);
+      deadline.unref?.();
+    };
+    try {
+      worker = new Worker(options.entry ?? defaultEntry(), { workerData: input });
+    } catch (error) {
+      finish({ failure: "start-failed", detail: String(error) });
+      return;
+    }
+    worker.unref();
+    activeWorkers.set(worker, (failure) => finish({ failure, detail: "stopped" }));
+    arm("not-accepted", options.acceptMs ?? ACCEPT_TIMEOUT_MS);
+    worker.on("message", (reply) => {
+      if (reply.kind === "accepted")
+        arm("no-result", options.resultMs ?? RESULT_TIMEOUT_MS);
+      else if (reply.kind === "scan")
+        finish({ scan: reply.scan });
+      else if (reply.kind === "tag-summary")
+        finish({ summary: reply.summary });
+      else if (reply.kind === "tag-delta")
+        finish({ delta: reply.delta });
+      else if (reply.kind === "indexed")
+        finish({ inserted: reply.inserted, measurements: reply.measurements });
+      else
+        finish({ failure: "worker-error", detail: reply.error });
+    });
+    worker.on("error", (error) => finish({ failure: "worker-error", detail: String(error) }));
+    worker.on("exit", (code) => finish({ failure: "exited", detail: `exit code ${code}` }));
+  });
+}
+function prewarmRawSessionOrdinalsForDb(db, sessionId, options = {}) {
+  if (isRawSessionSummaryWarm(db, sessionId))
+    return Promise.resolve("warm");
+  if (!db.prepare("SELECT 1 FROM sqlite_master WHERE name = 'message' AND type IN ('table', 'view')").get())
+    return Promise.resolve("warm");
+  const path = getSqliteDatabasePath(db);
+  if (!path) {
+    countRawSessionMessageOrdinalsFromDb(db, sessionId);
+    return Promise.resolve("warm");
+  }
+  let connectionId = connectionIds.get(db);
+  if (connectionId === undefined) {
+    connectionId = ++nextConnectionId;
+    connectionIds.set(db, connectionId);
+  }
+  const key = `${path}\x00${sessionId}\x00${connectionId}`;
+  let shared = inFlight.get(key);
+  if (!shared) {
+    const failed = failedAt.get(key);
+    if (failed !== undefined && Date.now() - failed < FAILURE_BACKOFF_MS)
+      return Promise.resolve("failed");
+    const epoch = getRawSessionSummaryEpoch(sessionId);
+    const started = performance.now();
+    const result = runSessionWarmupWorker({ path, sessionId, previous: rawOrdinalSummarySeed(db, sessionId) }, options).then((outcome) => {
+      if ("failure" in outcome)
+        recordFailure(key, sessionId, outcome.failure, outcome.detail);
+      return outcome;
+    }).finally(() => {
+      if (inFlight.get(key) === scan)
+        inFlight.delete(key);
+    });
+    const scan = { epoch, started, result };
+    inFlight.set(key, scan);
+    shared = scan;
+  }
+  const awaited = shared;
+  return awaited.result.then((result) => {
+    if (!("scan" in result))
+      return "failed";
+    try {
+      if (installRawSessionSummaryScan(db, sessionId, result.scan, awaited.epoch, true)) {
+        failedAt.delete(key);
+        log(`[magic-context] canonical ordinals of ${sessionId} warmed off-thread (${result.scan.sessionRows} messages, ${Math.round(performance.now() - awaited.started)} ms)`);
+        return "warm";
+      }
+    } catch {}
+    recordFailure(key, sessionId, "superseded", `session removed during scan: epoch=${awaited.epoch}/${getRawSessionSummaryEpoch(sessionId)}`);
+    return "failed";
+  });
+}
+function recordFailure(key, sessionId, failure, detail) {
+  failures.set(failure, (failures.get(failure) ?? 0) + 1);
+  if (failure !== "superseded")
+    failedAt.set(key, Date.now());
+  log(`[magic-context] WARN canonical ordinal warm-up failed for ${sessionId} (${failure}: ${detail}); counts remain bounded and callers must defer or retry`);
+}
+var ACCEPT_TIMEOUT_MS = 2000, RESULT_TIMEOUT_MS, FAILURE_BACKOFF_MS, inFlight, connectionIds, nextConnectionId = 0, failedAt, activeWorkers, failures, exitHookRegistered = false;
+var init_raw_ordinal_warmup = __esm(async () => {
+  init_exit_abort_registry();
+  init_logger();
+  await __promiseAll([
+    init_sqlite(),
+    init_read_session_raw()
+  ]);
+  RESULT_TIMEOUT_MS = 10 * 60000;
+  FAILURE_BACKOFF_MS = 5 * 60000;
+  inFlight = new Map;
+  connectionIds = new WeakMap;
+  failedAt = new Map;
+  activeWorkers = new Map;
+  failures = new Map;
+});
+
+// ../plugin/src/hooks/magic-context/read-session-db.ts
+function openCodeDbExists() {
+  return harnessOwnsOpenCodeStore() && openCodeDbPathExists(resolveOpenCodeDbPath());
+}
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
+    return;
+  }
+  try {
+    closeQuietly(cachedReadOnlyDb.db);
+  } catch (error) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
+}
+function getReadOnlySessionDb() {
+  if (!harnessOwnsOpenCodeStore()) {
+    throw new Error("OpenCode session database is not readable from a Pi-compatible process; its history lives in Pi sessions");
+  }
+  const resolution = resolveOpenCodeDbPath();
+  const dbPath = resolution.path;
+  if (!openCodeDbPathExists(resolution)) {
+    throw new Error(`OpenCode session database is unavailable at ${dbPath} (source=${resolution.source})`);
+  }
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    assertOpenCodeStoreGeneration(db, "v1", dbPath);
+  } catch (error) {
+    closeQuietly(db);
+    throw error;
+  }
+  cachedReadOnlyDb = { path: dbPath, db };
+  clearOpenCodeDbReadFailure();
+  return db;
+}
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
+}
+function getRawSessionMessageCountFromDb(db, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
+             AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function logProbeFailureOnce(resolution, error) {
+  const failure = recordOpenCodeDbReadFailure(resolution, error);
+  if (!claimOpenCodeDbDiagnosticOnce("session-state-probe", resolution))
+    return;
+  const message = `[magic-context] OpenCode DB probe failed: path=${resolution.path} source=${resolution.source} cause=${failure.message}`;
+  probeLogObserverForTests?.(message);
+  log(message);
+}
+function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
+  const result = new Map;
+  if (messageIds.length === 0 || !harnessOwnsOpenCodeStore())
+    return result;
+  try {
+    withReadOnlySessionDb((db) => {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, time_created FROM message WHERE +session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
+      for (const row of rows) {
+        if (typeof row.id === "string" && typeof row.time_created === "number") {
+          result.set(row.id, row.time_created);
+        }
+      }
+    });
+  } catch (error) {
+    logProbeFailureOnce(resolveOpenCodeDbPath(), error);
+  }
+  return result;
+}
+var cachedReadOnlyDb = null, trackedSessions, pendingParts, probeLogObserverForTests;
+var init_read_session_db = __esm(async () => {
+  init_logger();
+  init_opencode_db_path();
+  await __promiseAll([
+    init_sqlite(),
+    init_read_session_raw()
+  ]);
+  trackedSessions = new Map;
+  pendingParts = new Map;
 });
 
 // ../plugin/src/hooks/magic-context/read-session-true-raw-tokens.ts
@@ -30538,7 +31912,7 @@ function callIdFromPart(part) {
   const state = isRecord2(part.state) ? part.state : null;
   return state ? firstStringField(state, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) ?? "" : "";
 }
-function toolSignalFromPart(part) {
+function toolSignalFromPart(part, withText = true) {
   if (!isRecord2(part))
     return null;
   const type = partType(part);
@@ -30557,8 +31931,8 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: hasInput || openInvocation,
       hasOutput,
-      inputText: hasInput && state ? stringValue(state.input) : "",
-      outputText: hasOutput ? stringValue(outputValue) : ""
+      inputText: withText && hasInput && state ? stringValue(state.input) : "",
+      outputText: withText && hasOutput ? stringValue(outputValue) : ""
     };
   }
   if (type === "tool-invocation") {
@@ -30567,7 +31941,7 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: args !== undefined,
       hasOutput: false,
-      inputText: args !== undefined ? stringValue(args) : "",
+      inputText: withText && args !== undefined ? stringValue(args) : "",
       outputText: ""
     };
   }
@@ -30577,7 +31951,7 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: input !== undefined,
       hasOutput: false,
-      inputText: input !== undefined ? stringValue(input) : "",
+      inputText: withText && input !== undefined ? stringValue(input) : "",
       outputText: ""
     };
   }
@@ -30588,7 +31962,7 @@ function toolSignalFromPart(part) {
       hasInput: false,
       hasOutput: content !== undefined,
       inputText: "",
-      outputText: content !== undefined ? textFromToolResultContent(content) : ""
+      outputText: withText && content !== undefined ? textFromToolResultContent(content) : ""
     };
   }
   return null;
@@ -30598,7 +31972,7 @@ function buildToolArcs(messages) {
   const arcs = [];
   for (const message of messages) {
     for (const part of message.parts) {
-      const signal = toolSignalFromPart(part);
+      const signal = toolSignalFromPart(part, false);
       if (!signal || signal.callId.length === 0)
         continue;
       if (signal.hasInput && signal.hasOutput) {
@@ -30637,6 +32011,7 @@ function buildToolArcs(messages) {
 }
 var MAX_MESSAGE_CACHE_KEY_BYTES, messageEstimateCache, messageEstimateKeysByField;
 var init_read_session_true_raw_tokens = __esm(() => {
+  init_provider_visible_parts();
   init_read_session_formatting();
   MAX_MESSAGE_CACHE_KEY_BYTES = 64 * 1024 * 1024;
   messageEstimateCache = new Map;
@@ -30798,8 +32173,10 @@ __export(exports_read_session_chunk, {
   hasMeaningfulUserText: () => hasMeaningfulUserText,
   hasRawMessageProvider: () => hasRawMessageProvider,
   hasRawSessionMessageById: () => hasRawSessionMessageById,
+  prepareRawSessionOrdinals: () => prepareRawSessionOrdinals,
   primeInMemoryTailRawMessageCache: () => primeInMemoryTailRawMessageCache,
   primeTailRawMessageCache: () => primeTailRawMessageCache,
+  readRawSessionBoundaryEndpoints: () => readRawSessionBoundaryEndpoints,
   readRawSessionMessageById: () => readRawSessionMessageById,
   readRawSessionMessageIdOrdinals: () => readRawSessionMessageIdOrdinals,
   readRawSessionMessageIdOrdinalsForRange: () => readRawSessionMessageIdOrdinalsForRange,
@@ -31068,6 +32445,36 @@ function readRawSessionMessageRange(sessionId, fromOrdinal, toOrdinal) {
   }
   return messages;
 }
+async function prepareRawSessionOrdinals(sessionId) {
+  if (sessionProviders.get(sessionId)?.provider)
+    return true;
+  if (!openCodeDbExists())
+    return true;
+  const db = withReadOnlySessionDb((connection) => connection);
+  let timer;
+  const deadline = Date.now() + 250;
+  const prepare = async () => {
+    for (let attempt = 0;attempt < 3 && Date.now() < deadline; attempt++) {
+      if (await prewarmRawSessionOrdinalsForDb(db, sessionId) === "warm")
+        return true;
+    }
+    return false;
+  };
+  try {
+    const ready = await Promise.race([
+      prepare(),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), 250);
+      })
+    ]);
+    if (!ready) {
+      sessionLog(sessionId, "WARN canonical ordinal preparation unavailable within 250ms; exact reads must defer or retry");
+    }
+    return ready;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function primeTailRawMessageCache(args) {
   const { sessionId, lastCompartmentEnd, anchorMessageId } = args;
   if (!activeRawMessageCache)
@@ -31182,6 +32589,13 @@ function readRawSessionMessagePartsById(sessionId, messageId, onQuery) {
     return null;
   return withReadOnlySessionDb((db) => readRawSessionMessagePartsByIdFromDb(db, sessionId, messageId, onQuery));
 }
+function readRawSessionBoundaryEndpoints(sessionId, ids, blockIds) {
+  if (sessionProviders.get(sessionId)?.provider)
+    return null;
+  if (!openCodeDbExists())
+    return new Map(ids.map((id) => [id, null]));
+  return withReadOnlySessionDb((db) => readRawSessionBoundaryEndpointsFromDb(db, sessionId, ids, blockIds));
+}
 function hasRawSessionMessageById(sessionId, messageId) {
   const provider = sessionProviders.get(sessionId)?.provider;
   if (provider?.hasMessageById)
@@ -31702,22 +33116,28 @@ function readRawSessionSeedTail(sessionId, boundaryId, onQuery) {
 }
 var BLOCK_TOKEN_MEMO_MAX = 2048, blockTokenMemo, activeRawMessageCache = null, activeAbsoluteCountCache = null, sessionProviders, boundedProviderWrappers, SYSTEM_REMINDER_BLOCK_REGEX, RAW_MESSAGE_RANGE_PAGE_SIZE = 100, RAW_MESSAGE_VISIT_PAGE_SIZE = 50, RAW_SESSION_TAG_KEY_PAGE_SIZE = 32, PROTECTED_TAIL_USER_TURNS = 5;
 var init_read_session_chunk = __esm(async () => {
-  init_storage_tags();
   init_historian_tool_expansions();
+  init_logger();
   init_read_session_formatting();
-  init_read_session_raw();
   init_read_session_true_raw_tokens();
   init_system_injection_stripper();
   init_tag_part_guards();
   init_tool_drop_target();
   init_read_session_formatting();
-  await init_read_session_db();
+  await __promiseAll([
+    init_storage_tags(),
+    init_raw_ordinal_warmup(),
+    init_read_session_db(),
+    init_read_session_raw()
+  ]);
   blockTokenMemo = new Map;
   sessionProviders = new Map;
   boundedProviderWrappers = new WeakMap;
   SYSTEM_REMINDER_BLOCK_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
   readRawSessionMessages.readPage = readRawSessionMessagePage;
   readRawSessionMessages.getCount = getRawSessionMessageOrdinalCount;
+  readRawSessionMessages.prepare = prepareRawSessionOrdinals;
+  readRawSessionMessageById.prepare = prepareRawSessionOrdinals;
 });
 
 // ../plugin/src/features/magic-context/message-time-backfill.ts
@@ -33578,6 +34998,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   const version = getPersistedSchemaVersion(db);
   if (version === 0 || version >= 95)
     installV95PerfSchema(db, false, version === 0);
+  installTagIdentityRevisionTrigger(db);
 }
 function healWedgedChannel2Claims(db) {
   try {
@@ -33657,6 +35078,7 @@ function openDatabase(dbPathOrOptions) {
     } else
       runMigrations(db);
     ensureContextStoreUuid(db);
+    installTagIdentityRevisionTrigger(db);
     return finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion);
   } catch (error) {
     if (db)
@@ -33691,6 +35113,7 @@ var init_storage_db = __esm(async () => {
   init_migration_v95_perf_indexes();
   init_migration_worker_client();
   init_storage_schema_helpers();
+  init_storage_tag_identity_revision();
   init_tool_definition_tokens();
   init_tool_owner_backfill();
   await __promiseAll([
@@ -33896,6 +35319,9 @@ var init_config_location_migration = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/dreamer/task-registry.ts
+function availableDreamTasks(smartNotesEnabled = true) {
+  return CANONICAL_DREAM_TASKS.filter((task) => smartNotesEnabled || task !== "evaluate-smart-notes");
+}
 var CANONICAL_DREAM_TASKS, DREAM_TOOL_LOOP_TOKEN_BUDGETS, MEMORY_DOMAIN_TASKS, MEMORY_DOMAIN_SET;
 var init_task_registry = __esm(() => {
   CANONICAL_DREAM_TASKS = [
@@ -34646,8 +36072,10 @@ function openCodeConfigFileChain(directory, hostGeneration) {
   const globalSupplementary = getOpenCodeConfigDirs().filter((dir) => dir !== globalDir).flatMap((dir) => [join17(dir, "opencode.json"), join17(dir, "opencode.jsonc")]);
   const explicitConfig = process.env.OPENCODE_CONFIG?.trim();
   const explicit = explicitConfig ? [explicitConfig] : [];
-  const direct = [join17(directory, "opencode.json"), join17(directory, "opencode.jsonc")];
-  const projectSupplementary = [
+  const disableProjectConfig = process.env.OPENCODE_DISABLE_PROJECT_CONFIG?.toLowerCase();
+  const skipProject = hostGeneration === "v1" && (disableProjectConfig === "true" || disableProjectConfig === "1");
+  const direct = skipProject ? [] : [join17(directory, "opencode.json"), join17(directory, "opencode.jsonc")];
+  const projectSupplementary = skipProject ? [] : [
     join17(directory, ".opencode", "opencode.json"),
     join17(directory, ".opencode", "opencode.jsonc")
   ];
@@ -35877,6 +37305,24 @@ function readCachedPluginVersion(pluginCacheDir) {
     return;
   }
 }
+function readOpenCodePluginConfigUse(config, configDir) {
+  const use = {
+    referencedSpecs: {
+      opencode1: readReferencedOpenCodePluginSpecs(config, "opencode1"),
+      opencode2: readReferencedOpenCodePluginSpecs(config, "opencode2")
+    },
+    loadedFrom: {}
+  };
+  for (const { key, entry } of readPluginEntries(config)) {
+    if (!isDevPathPluginEntry(entry, configDir))
+      continue;
+    const specifier = pluginEntryPackage(entry) ?? undefined;
+    if (key === "plugin")
+      use.loadedFrom.opencode1 ??= specifier;
+    use.loadedFrom.opencode2 ??= specifier;
+  }
+  return use;
+}
 async function clearPluginCache(options = {}, deps = {}) {
   const remove = deps.remove ?? ((path) => rmSync6(path, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
@@ -35889,6 +37335,15 @@ async function clearPluginCache(options = {}, deps = {}) {
     path,
     cached: readCachedPluginVersion(path)
   }));
+  if (options.referencedSpecs !== undefined && !options.referencedSpecs.has("latest")) {
+    const firstEntry = cacheEntries[0];
+    return {
+      action: "unused",
+      path: firstEntry?.path ?? pluginCacheRoots[0] ?? "",
+      paths: cacheEntries.map((entry) => entry.path),
+      cached: firstEntry?.cached
+    };
+  }
   if (options.force !== true && latestVersion === undefined) {
     const firstEntry = cacheEntries[0];
     return {
@@ -35960,15 +37415,24 @@ async function clearPluginCache(options = {}, deps = {}) {
 }
 var init_doctor_opencode_cache = __esm(async () => {
   init_opencode_plugin_cache();
-  await init_doctor_opencode2_cache();
+  init_opencode_plugin_registration();
+  await __promiseAll([
+    init_opencode(),
+    init_doctor_opencode2_cache()
+  ]);
 });
 
 // src/commands/doctor-cached-plugin-fence.ts
 import { existsSync as existsSync29 } from "node:fs";
 import { dirname as dirname15 } from "node:path";
+function isReferenced(sources, host, spec) {
+  const specs = sources.referencedSpecs?.[host];
+  return specs === undefined || specs.has(spec);
+}
 function listCachedOpenCodePluginFences(sources = {}) {
   const fences = [];
-  for (const root of sources.openCodeV1Roots ?? getOpenCodePluginCacheRoots()) {
+  const v1Referenced = isReferenced(sources, "opencode1", "latest");
+  for (const root of v1Referenced ? sources.openCodeV1Roots ?? getOpenCodePluginCacheRoots() : []) {
     const packageJson = getOpenCodePluginPackageJsonPath(root);
     if (!existsSync29(packageJson))
       continue;
@@ -35982,6 +37446,8 @@ function listCachedOpenCodePluginFences(sources = {}) {
   for (const slot of listOpenCodeV2PluginCacheSlots(sources.openCodeV2NpmCacheDir)) {
     if (!isOpenCodePluginDistTag(slot.spec))
       continue;
+    if (!isReferenced(sources, "opencode2", slot.spec))
+      continue;
     const generation = getOpenCodeV2ActiveGeneration(slot.slot);
     if (!generation)
       continue;
@@ -41170,11 +42636,6 @@ var init_user_facing_codes = __esm(() => {
       sentence: "Magic Context has no context.db.",
       action: "Run `npx @cortexkit/magic-context doctor store init`, then restart ck-mc."
     },
-    checkout_claim_held_elsewhere: {
-      code: "MC-C16",
-      sentence: "This request was not sent: this agent is checked out on another machine, so Magic Context will not work on its sessions here.",
-      action: "Move the agent back to this machine, then send your message again."
-    },
     single_store_migration_required: {
       code: "MC-C14",
       sentence: "Magic Context's Rust mode needs a one-time migration of its store.",
@@ -42765,7 +44226,9 @@ function parsePiConfig(rawConfig, recoveredTopLevelKeys = []) {
     delete configToMigrate.protected_tags;
   }
   const agentMigrated = migrateLegacyAgentEnabledInMemory(configToMigrate, preMigrationWarnings);
-  const migrated = migrateDreamerV2(migrateLegacyExperimental(agentMigrated, preMigrationWarnings), preMigrationWarnings);
+  const migratedExperimental = migrateLegacyExperimental(agentMigrated, preMigrationWarnings);
+  warnDeprecatedMuralModel(migratedExperimental, preMigrationWarnings);
+  const migrated = migrateDreamerV2(migratedExperimental, preMigrationWarnings);
   const parsed = MagicContextConfigSchema.safeParse(migrated);
   if (parsed.success) {
     return { config: parsed.data, warnings: preMigrationWarnings };
@@ -43607,64 +45070,66 @@ async function runHealthChecks(options) {
     add(results, "fail", "OMP binary not found on PATH or in standard user bin directories");
   } else {
     const version = options.deps.getOmpVersion(omp.path);
-    if (!version)
-      add(results, "fail", `OMP at ${omp.path} could not report its version`);
-    else if (isOlderThan(version, MIN_OMP_VERSION)) {
-      add(results, "fail", `OMP ${version} is older than tested minimum ${MIN_OMP_VERSION}`);
-    } else
-      add(results, "pass", `OMP ${version} detected at ${omp.path}`);
     const plugins = options.deps.listOmpPlugins(omp.path);
     if (!plugins) {
       add(results, "fail", "`omp plugin list --json` failed or returned invalid JSON");
     } else {
       const plugin = plugins.find((entry) => entry.name === OMP_PLUGIN_PACKAGE);
       if (!plugin) {
-        add(results, "fail", `${OMP_PLUGIN_PACKAGE} is not installed in OMP`);
-        repairPlan.installPlugin = true;
-      } else if (!plugin.enabled) {
-        add(results, "fail", `${OMP_PLUGIN_PACKAGE} is installed but disabled in OMP`);
+        add(results, "info", `${version ? `Oh My Pi ${version}` : "Oh My Pi"} found; Magic Context is not installed there (run setup to add it)`);
         repairPlan.installPlugin = true;
       } else {
-        add(results, "pass", `${OMP_PLUGIN_PACKAGE} ${plugin.version} is enabled`);
-        const manifest = pluginDeclaresOmp(plugin.path);
-        if (manifest === true)
-          add(results, "pass", "Plugin exposes an OMP/Pi extension manifest");
-        else if (manifest === false)
-          add(results, "fail", "Installed plugin has no OMP/Pi extension manifest");
-        else
-          add(results, "warn", "Could not inspect the installed plugin manifest");
-      }
-    }
-    const compaction = options.deps.getOmpSetting(omp.path, "compaction.enabled");
-    if (compaction === false)
-      add(results, "pass", "OMP native compaction is disabled");
-    else if (compaction === true) {
-      add(results, "fail", "OMP native compaction is enabled and conflicts with Magic Context");
-      repairPlan.disableCompaction = true;
-    } else
-      add(results, "fail", "Could not read OMP compaction.enabled");
-    const memory = options.deps.getOmpSetting(omp.path, "memory.backend");
-    if (memory === "off")
-      add(results, "pass", "OMP automatic memory backend is disabled");
-    else if (typeof memory === "string") {
-      add(results, "fail", `OMP memory.backend=${memory} duplicates Magic Context memory injection`);
-      repairPlan.disableMemory = true;
-    } else
-      add(results, "fail", "Could not read OMP memory.backend");
-    const nonGlobalSources = getOmpNonGlobalConfigSources(options.cwd);
-    if (nonGlobalSources.length > 0 && (repairPlan.disableCompaction || repairPlan.disableMemory)) {
-      add(results, "warn", "OMP project/overlay config owns effective conflicting settings; automatic global repair is disabled: " + nonGlobalSources.join(", "));
-    }
-    const reportedAgentDir = options.deps.runOmpCommand(omp.path, ["config", "path"], 1e4);
-    if (!reportedAgentDir.ok) {
-      add(results, "warn", "Could not verify OMP active agent directory");
-    } else {
-      const reportedPath = resolve15(reportedAgentDir.stdout);
-      const expectedPath = resolve15(getOmpAgentDir());
-      if (reportedPath === expectedPath) {
-        add(results, "pass", `OMP agent directory resolved to ${getOmpAgentDir()}`);
-      } else {
-        add(results, "fail", `OMP reports agent directory ${reportedAgentDir.stdout}, but Magic Context resolved ${getOmpAgentDir()}`);
+        if (!version) {
+          add(results, "fail", `OMP at ${omp.path} could not report its version`);
+        } else if (isOlderThan(version, MIN_OMP_VERSION)) {
+          add(results, "fail", `OMP ${version} is older than tested minimum ${MIN_OMP_VERSION}`);
+        } else
+          add(results, "pass", `OMP ${version} detected at ${omp.path}`);
+        if (!plugin.enabled) {
+          add(results, "fail", `${OMP_PLUGIN_PACKAGE} is installed but disabled in OMP`);
+          repairPlan.installPlugin = true;
+        } else {
+          add(results, "pass", `${OMP_PLUGIN_PACKAGE} ${plugin.version} is enabled`);
+          const manifest = pluginDeclaresOmp(plugin.path);
+          if (manifest === true)
+            add(results, "pass", "Plugin exposes an OMP/Pi extension manifest");
+          else if (manifest === false)
+            add(results, "fail", "Installed plugin has no OMP/Pi extension manifest");
+          else
+            add(results, "warn", "Could not inspect the installed plugin manifest");
+        }
+        const compaction = options.deps.getOmpSetting(omp.path, "compaction.enabled");
+        if (compaction === false)
+          add(results, "pass", "OMP native compaction is disabled");
+        else if (compaction === true) {
+          add(results, "fail", "OMP native compaction is enabled and conflicts with Magic Context");
+          repairPlan.disableCompaction = true;
+        } else
+          add(results, "fail", "Could not read OMP compaction.enabled");
+        const memory = options.deps.getOmpSetting(omp.path, "memory.backend");
+        if (memory === "off")
+          add(results, "pass", "OMP automatic memory backend is disabled");
+        else if (typeof memory === "string") {
+          add(results, "fail", `OMP memory.backend=${memory} duplicates Magic Context memory injection`);
+          repairPlan.disableMemory = true;
+        } else
+          add(results, "fail", "Could not read OMP memory.backend");
+        const nonGlobalSources = getOmpNonGlobalConfigSources(options.cwd);
+        if (nonGlobalSources.length > 0 && (repairPlan.disableCompaction || repairPlan.disableMemory)) {
+          add(results, "warn", "OMP project/overlay config owns effective conflicting settings; automatic global repair is disabled: " + nonGlobalSources.join(", "));
+        }
+        const reportedAgentDir = options.deps.runOmpCommand(omp.path, ["config", "path"], 1e4);
+        if (!reportedAgentDir.ok) {
+          add(results, "warn", "Could not verify OMP active agent directory");
+        } else {
+          const reportedPath = resolve15(reportedAgentDir.stdout);
+          const expectedPath = resolve15(getOmpAgentDir());
+          if (reportedPath === expectedPath) {
+            add(results, "pass", `OMP agent directory resolved to ${getOmpAgentDir()}`);
+          } else {
+            add(results, "fail", `OMP reports agent directory ${reportedAgentDir.stdout}, but Magic Context resolved ${getOmpAgentDir()}`);
+          }
+        }
       }
     }
   }
@@ -46665,6 +48130,16 @@ function listDanglingCompartmentBoundaries(contextDb, openCodeDb, hostGeneration
               ORDER BY c.session_id ASC, c.sequence ASC`).all();
   const statement = openCodeDb.prepare(`SELECT 1 AS found FROM ${selection.table} WHERE session_id = ? AND id = ? LIMIT 1`);
   const exists = (sessionId, messageId) => statement.get(sessionId, messageId) != null;
+  const sessionStatement = openCodeDb.prepare(`SELECT 1 AS found FROM ${selection.table} WHERE session_id = ? LIMIT 1`);
+  const sessionPresence = new Map;
+  const sessionInStore = (sessionId) => {
+    let present = sessionPresence.get(sessionId);
+    if (present === undefined) {
+      present = sessionStatement.get(sessionId) != null;
+      sessionPresence.set(sessionId, present);
+    }
+    return present;
+  };
   return rows.flatMap((row) => {
     const missingStart = !exists(row.session_id, row.start_message_id);
     const missingEnd = !exists(row.session_id, row.end_message_id);
@@ -46675,7 +48150,8 @@ function listDanglingCompartmentBoundaries(contextDb, openCodeDb, hostGeneration
         sessionId: row.session_id,
         sequence: row.sequence,
         missingStartMessageId: missingStart ? row.start_message_id : null,
-        missingEndMessageId: missingEnd ? row.end_message_id : null
+        missingEndMessageId: missingEnd ? row.end_message_id : null,
+        sessionInStore: sessionInStore(row.session_id)
       }
     ];
   });
@@ -46687,6 +48163,52 @@ function formatDanglingCompartmentBoundary(boundary) {
   ].filter((value) => value !== null);
   return `session=${boundary.sessionId} sequence=${boundary.sequence} missing ${missing.join(" ")}`;
 }
+function countDanglingCompartmentBoundariesBySession(boundaries) {
+  const bySession = new Map;
+  for (const boundary of boundaries) {
+    const entry = bySession.get(boundary.sessionId);
+    if (entry)
+      entry.count++;
+    else
+      bySession.set(boundary.sessionId, {
+        sessionId: boundary.sessionId,
+        count: 1,
+        sessionInStore: boundary.sessionInStore
+      });
+  }
+  return [...bySession.values()].sort((a, b) => b.count - a.count || a.sessionId.localeCompare(b.sessionId));
+}
+function formatDanglingCompartmentBoundaryHeadline(boundaries, store) {
+  const sessions = countDanglingCompartmentBoundariesBySession(boundaries);
+  const absent = sessions.filter((session) => !session.sessionInStore).length;
+  const scope = `${boundaries.length} compartment(s) in ${sessions.length} session(s)`;
+  const absentNote = absent > 0 ? ` ${absent} of those session(s) have no messages in this store at all, so OpenCode cannot open them from it and their compartments are not used.` : "";
+  if (store === "opencode2") {
+    return `Informational, no action needed: ${scope} point at OpenCode message ids that are not in the OpenCode 2 store.${absentNote} Magic Context places these from the neighbouring compartments; any it cannot place are listed as excluded from range recovery below.`;
+  }
+  return `${scope} have dangling OpenCode boundary ids.${absentNote}`;
+}
+function formatDanglingCompartmentBoundaryDetails(boundaries, options = {}) {
+  const limit = options.verbose ? Number.POSITIVE_INFINITY : options.limit ?? DANGLING_BOUNDARY_EXAMPLE_LIMIT;
+  const sessions = countDanglingCompartmentBoundariesBySession(boundaries);
+  const lines = [];
+  lines.push(options.verbose || sessions.length <= limit ? "By session:" : `By session (largest ${limit} of ${sessions.length}):`);
+  for (const session of sessions.slice(0, limit)) {
+    lines.push(`  session=${session.sessionId}: ${session.count} compartment(s)${session.sessionInStore ? "" : " (session has no messages in this store)"}`);
+  }
+  if (sessions.length > limit) {
+    lines.push(`  … and ${sessions.length - limit} more session(s)`);
+  }
+  lines.push(options.verbose || boundaries.length <= limit ? "Compartments:" : `Examples (${limit} of ${boundaries.length}):`);
+  for (const boundary of boundaries.slice(0, limit)) {
+    lines.push(`  ${formatDanglingCompartmentBoundary(boundary)}`);
+  }
+  if (sessions.length > limit || boundaries.length > limit) {
+    lines.push(`Run \`magic-context doctor --verbose\` for the full list of ${boundaries.length} compartment(s).`);
+  }
+  return lines;
+}
+var DANGLING_BOUNDARY_EXAMPLE_LIMIT = 10;
 
 // src/commands/doctor-harness-relabel.ts
 function reportUnresolvedHarnessRelabel(args) {
@@ -46840,6 +48362,9 @@ function withPluginEntrySpecifier(entry, specifier) {
   }
   return specifier;
 }
+function isOpenCodePluginRegistered(config, configDir) {
+  return readPluginEntries(config).some(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry, configDir));
+}
 function checkOpenCodePluginEntry(config, configName, options, report) {
   const allEntries = readPluginEntries(config);
   const found = allEntries.find(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry, options.configDir));
@@ -47497,6 +49022,21 @@ function logOpenCodeInstallationTable(installations) {
 function describeOpenCode2SessionAPIRequirement(hostVersion) {
   return `OpenCode host ${hostVersion}; Magic Context requires OpenCode 2.0.22 or newer with session.remove and session.compact.`;
 }
+function getOpenCodePluginHostStatus(hostLabel, hostVersion, installed) {
+  if (!installed) {
+    return {
+      status: "info",
+      message: `${hostLabel} found; Magic Context is not installed there (run setup to add it)`
+    };
+  }
+  if (openCodeHostGenerationFromVersion(hostVersion) === "v2" && compareVersions(hostVersion, "2.0.22") === -1) {
+    return {
+      status: "fail",
+      message: describeOpenCode2SessionAPIRequirement(hostVersion)
+    };
+  }
+  return null;
+}
 async function runDoctor2(options = {}) {
   migrateConfigLocationsForCli(process.cwd(), log3);
   if (options.issue) {
@@ -47572,8 +49112,15 @@ async function runDoctor2(options = {}) {
     pass(installationReports.length > 1 ? `OpenCode ${activeInstallation.version} installed (active install marked above)` : `OpenCode ${activeInstallation.version} installed`);
   }
   const hostGeneration = openCodeHostGenerationFromVersion(activeInstallation.version);
-  if (hostGeneration === "v2") {
-    log3.info(describeOpenCode2SessionAPIRequirement(activeInstallation.version));
+  const paths = detectConfigPaths();
+  let magicContextInstalled = false;
+  let magicContextStatusKnown = paths.opencodeConfigFormat === "none";
+  if (!magicContextStatusKnown) {
+    try {
+      const config = import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8"));
+      magicContextInstalled = isOpenCodePluginRegistered(config, dirname25(paths.opencodeConfig));
+      magicContextStatusKnown = true;
+    } catch {}
   }
   const storeHostSelection = selectOpenCodeStoreHost(installationReports, openCodeHostGenerationFromVersion);
   const storeHost = storeHostSelection?.host ?? activeInstallation;
@@ -47591,7 +49138,9 @@ async function runDoctor2(options = {}) {
   const openCodeDbCheck = describeOpenCodeDatabaseDoctorCheck(openCodeDbResolution);
   if (openCodeDbCheck.ok)
     pass(openCodeDbCheck.message);
-  else
+  else if (magicContextStatusKnown && !magicContextInstalled) {
+    log3.info("OpenCode session database not yet created (will be created on first OpenCode session)");
+  } else
     fail(openCodeDbCheck.message);
   if (openCodeDbCheck.ok) {
     let markerDb = null;
@@ -47612,7 +49161,7 @@ async function runDoctor2(options = {}) {
       } else if (options.fix) {
         warn(`${summary}; repaired=${report.repaired}, but some rows remain unconvertible`);
       } else if (report.migrationCompleted) {
-        log3.info(`${summary}; OpenCode 2 already converted this store`);
+        log3.info(`${summary}; OpenCode 2 already converted this store, so these markers no longer matter (informational, no action needed)`);
       } else {
         warn(`${summary}; run \`magic-context doctor --fix\` before upgrading OpenCode`);
       }
@@ -47640,14 +49189,18 @@ async function runDoctor2(options = {}) {
         if (dangling.length === 0) {
           pass("Compartment boundary ids resolve in the OpenCode session store");
         } else if (storeGeneration === "v2" && /\d/.test(storeHost.version)) {
-          log3.info(`${dangling.length} compartment(s) point at OpenCode message ids that are not in the OpenCode 2 store. Magic Context places these from the neighbouring compartments; any it cannot place are listed as excluded from range recovery below.`);
-          for (const boundary of dangling) {
-            log3.info(`  ${formatDanglingCompartmentBoundary(boundary)}`);
+          log3.info(formatDanglingCompartmentBoundaryHeadline(dangling, "opencode2"));
+          for (const line of formatDanglingCompartmentBoundaryDetails(dangling, {
+            verbose: options.verbose
+          })) {
+            log3.info(`  ${line}`);
           }
         } else {
-          warn(`${dangling.length} compartment(s) have dangling OpenCode boundary ids`);
-          for (const boundary of dangling) {
-            log3.warn(`  ${formatDanglingCompartmentBoundary(boundary)}`);
+          warn(formatDanglingCompartmentBoundaryHeadline(dangling, "other"));
+          for (const line of formatDanglingCompartmentBoundaryDetails(dangling, {
+            verbose: options.verbose
+          })) {
+            log3.warn(`  ${line}`);
           }
         }
         if (!supportsCoordinateGenerationReporting(contextDb)) {
@@ -47683,10 +49236,7 @@ async function runDoctor2(options = {}) {
     }
   }
   const selfVersion = getSelfVersion2();
-  const [npmLatest, pluginNpmLatest] = await Promise.all([
-    fetchNpmLatest(CLI_PACKAGE_NAME),
-    fetchNpmLatest(OPENCODE_PLUGIN_NAME)
-  ]);
+  const npmLatest = await fetchNpmLatest(CLI_PACKAGE_NAME);
   const cliComparison = npmLatest ? compareVersions(selfVersion, npmLatest) : null;
   if (!npmLatest) {
     log3.info(`Magic Context CLI v${selfVersion}; npm latest check unavailable`);
@@ -47697,9 +49247,8 @@ async function runDoctor2(options = {}) {
   } else {
     pass(`Magic Context CLI v${selfVersion} is current (npm latest v${npmLatest})`);
   }
-  const paths = detectConfigPaths();
   if (paths.opencodeConfigFormat === "none") {
-    fail(`No opencode.json found at ${paths.opencodeConfig}`);
+    magicContextStatusKnown = true;
   } else {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
@@ -47869,6 +49418,7 @@ async function runDoctor2(options = {}) {
       log3.warn("Could not migrate deprecated config keys in magic-context.jsonc");
     }
   }
+  const openCodeHostLabel = activeInstallation.kind === "desktop" ? "OpenCode Desktop" : activeInstallation.version === "unknown" ? "OpenCode" : `OpenCode ${activeInstallation.version}`;
   const reportedAutoUpdateStalls = new Set;
   const reportAutoUpdateStall = (specifier) => {
     const message = describeAutoUpdateStall(specifier, autoUpdateEnabled);
@@ -47883,71 +49433,90 @@ async function runDoctor2(options = {}) {
       const config = import_comment_json11.parse(raw);
       const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
       const configDir = dirname25(paths.opencodeConfig);
-      if (checkPluginDuplicates(config, configName, { fix: options.fix, configDir }, {
-        warn,
-        pass: (message) => {
-          pass(message);
-          fixed++;
-        },
-        info: (message) => log3.info(message)
-      })) {
-        writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
+      magicContextInstalled = isOpenCodePluginRegistered(config, configDir);
+      magicContextStatusKnown = true;
+      if (magicContextInstalled) {
+        if (checkPluginDuplicates(config, configName, { fix: options.fix, configDir }, {
+          warn,
+          pass: (message) => {
+            pass(message);
+            fixed++;
+          },
+          info: (message) => log3.info(message)
+        })) {
+          writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
 `);
-      }
-      const allEntries = readPluginEntries(config);
-      if (allEntries.some(({ entry }) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry, configDir))) {
-        warn("An unverifiable local OpenCode plugin path was ignored because its package name is not Magic Context");
-      }
-      if (checkOpenCodePluginEntry(config, configName, {
-        force: options.force,
-        registrationKey: pluginConfigKeyFor(hostGeneration),
-        configDir
-      }, {
-        pass,
-        warn,
-        fixed: (message) => {
-          pass(message);
-          fixed++;
-        },
-        autoUpdateStall: reportAutoUpdateStall
-      })) {
-        writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
+        }
+        const allEntries = readPluginEntries(config);
+        if (allEntries.some(({ entry }) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry, configDir))) {
+          warn("An unverifiable local OpenCode plugin path was ignored because its package name is not Magic Context");
+        }
+        if (checkOpenCodePluginEntry(config, configName, {
+          force: options.force,
+          registrationKey: pluginConfigKeyFor(hostGeneration),
+          configDir
+        }, {
+          pass,
+          warn,
+          fixed: (message) => {
+            pass(message);
+            fixed++;
+          },
+          autoUpdateStall: reportAutoUpdateStall
+        })) {
+          writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
 `);
+        }
       }
     } catch {
       warn("Could not parse opencode config to verify plugin entry");
     }
-  }
-  const cwd = process.cwd();
-  const compactionEnabled = resolveCompactionEnabledForDoctor();
-  const conflictResult = detectConflicts(cwd, { compactionEnabled });
-  log3.info("Compaction check: file-based; the running server's resolved config may differ — `opencode debug config` is authoritative");
-  if (conflictResult.hasConflict) {
-    for (const reason of conflictResult.reasons) {
-      fail(`Conflict: ${reason}`);
-    }
-    const actions = fixConflicts(cwd, conflictResult.conflicts, { compactionEnabled });
-    for (const action of actions) {
-      pass(`Fixed: ${action}`);
-      fixed++;
-    }
-    if (actions.length > 0) {
-      warn("Restart OpenCode for conflict fixes to take effect");
-    }
   } else {
-    if (!compactionEnabled) {
-      if (conflictResult.nativeCompaction.auto || conflictResult.nativeCompaction.prune) {
-        pass("No conflicts detected (compaction, DCP, OMO hooks) — native compaction active (compaction-off mode)");
-      } else {
-        warn("No compaction manager is active: Magic Context compaction is off and OpenCode auto-compaction is disabled");
+    magicContextStatusKnown = true;
+  }
+  if (!magicContextStatusKnown)
+    magicContextInstalled = true;
+  const hostPluginStatus = magicContextStatusKnown ? getOpenCodePluginHostStatus(openCodeHostLabel, activeInstallation.version, magicContextInstalled) : null;
+  if (hostPluginStatus?.status === "info")
+    log3.info(hostPluginStatus.message);
+  else if (hostPluginStatus?.status === "fail")
+    fail(hostPluginStatus.message);
+  else if (magicContextInstalled && hostGeneration === "v2") {
+    log3.info(describeOpenCode2SessionAPIRequirement(activeInstallation.version));
+  }
+  const pluginNpmLatest = magicContextInstalled ? await fetchNpmLatest(OPENCODE_PLUGIN_NAME) : null;
+  if (magicContextInstalled) {
+    const cwd = process.cwd();
+    const compactionEnabled = resolveCompactionEnabledForDoctor();
+    const conflictResult = detectConflicts(cwd, { compactionEnabled });
+    log3.info("Compaction check: file-based; the running server's resolved config may differ — `opencode debug config` is authoritative");
+    if (conflictResult.hasConflict) {
+      for (const reason of conflictResult.reasons) {
+        fail(`Conflict: ${reason}`);
+      }
+      const actions = fixConflicts(cwd, conflictResult.conflicts, { compactionEnabled });
+      for (const action of actions) {
+        pass(`Fixed: ${action}`);
+        fixed++;
+      }
+      if (actions.length > 0) {
+        warn("Restart OpenCode for conflict fixes to take effect");
       }
     } else {
-      pass("No conflicts detected (compaction, DCP, OMO hooks)");
+      if (!compactionEnabled) {
+        if (conflictResult.nativeCompaction.auto || conflictResult.nativeCompaction.prune) {
+          pass("No conflicts detected (compaction, DCP, OMO hooks) — native compaction active (compaction-off mode)");
+        } else {
+          warn("No compaction manager is active: Magic Context compaction is off and OpenCode auto-compaction is disabled");
+        }
+      } else {
+        pass("No conflicts detected (compaction, DCP, OMO hooks)");
+      }
     }
   }
-  if (hostGeneration === "v2") {
+  if (magicContextInstalled && hostGeneration === "v2") {
     pass("TUI sidebar loads from the plugin entry on OpenCode 2 (tui.json not used)");
-  } else {
+  } else if (magicContextInstalled) {
     const tuiAdded = ensureTuiPluginEntry();
     if (tuiAdded) {
       pass("Added TUI sidebar plugin to tui.json");
@@ -48097,65 +49666,88 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     warn(`RPC discovery check unavailable: ${error instanceof Error ? error.message : String(error)}`);
     issues++;
   }
-  const cacheResult = await clearPluginCache({
-    force: options.force,
-    latestVersion: pluginNpmLatest,
-    hostFiles: openCodeHostDatabaseFiles([openCodeDbResolution.path])
-  });
-  if (cacheResult.action === "cleared") {
-    const versionInfo = cacheResult.cached ? ` (cached: ${cacheResult.cached}${cacheResult.latest ? `, latest: ${cacheResult.latest}` : ""})` : "";
-    const reason = cacheResult.latest ? "outdated plugin cache" : "plugin cache (latest version check unavailable)";
-    pass(`Cleared ${reason}${versionInfo} — latest will download on restart`);
-    log3.info(`  ${cacheResult.path}`);
-    fixed++;
-  } else if (cacheResult.action === "up_to_date") {
-    pass(`Plugin cache up to date (v${cacheResult.cached})`);
-  } else if (cacheResult.action === "check_unavailable") {
-    warn(`Plugin cache version check unavailable; preserving cached plugin${cacheResult.cached ? ` (cached: ${cacheResult.cached})` : ""}. Use doctor --force to reinstall it.`);
-  } else if (cacheResult.action === "in_use" || cacheResult.action === "in_use_unknown") {
-    const versionInfo = cacheResult.cached ? ` (cached: ${cacheResult.cached}${cacheResult.latest ? `, latest: ${cacheResult.latest}` : ""})` : "";
-    const why = cacheResult.action === "in_use" ? `OpenCode is running (pid ${cacheResult.pids?.join(", ")})` : cacheResult.reason ?? "could not tell whether OpenCode is running";
-    warn(`Plugin cache${versionInfo} was not cleared: ${why}`);
-    log3.info("  Quit OpenCode and rerun doctor to clear it.");
-    for (const path of cacheResult.paths ?? [cacheResult.path])
-      log3.info(`  ${path}`);
-    issues++;
-  } else if (cacheResult.action === "error") {
-    warn(`Could not clear plugin cache: ${cacheResult.error}`);
-    if (cacheResult.clearedPaths && cacheResult.clearedPaths.length > 0) {
-      log3.info(`  Cleared roots: ${cacheResult.clearedPaths.join(", ")}`);
+  if (magicContextInstalled) {
+    let pluginConfigUse;
+    if (paths.opencodeConfigFormat !== "none") {
+      try {
+        pluginConfigUse = readOpenCodePluginConfigUse(import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8")), dirname25(paths.opencodeConfig));
+      } catch {}
     }
-    if (cacheResult.failedPaths && cacheResult.failedPaths.length > 0) {
-      log3.info(`  Failed roots: ${cacheResult.failedPaths.join(", ")}`);
-    } else {
-      log3.info(`  Manually delete: ${cacheResult.path}`);
+    const cacheResult = await clearPluginCache({
+      force: options.force,
+      latestVersion: pluginNpmLatest,
+      hostFiles: openCodeHostDatabaseFiles([openCodeDbResolution.path]),
+      referencedSpecs: pluginConfigUse?.referencedSpecs.opencode1
+    });
+    if (cacheResult.action === "unused") {
+      log3.info(describeUnusedOpenCodePluginCache({
+        host: "OpenCode 1",
+        spec: "latest",
+        cached: cacheResult.cached,
+        paths: cacheResult.paths ?? [cacheResult.path],
+        loadedFrom: pluginConfigUse?.loadedFrom.opencode1
+      }));
+    } else if (cacheResult.action === "cleared") {
+      const versionInfo = cacheResult.cached ? ` (cached: ${cacheResult.cached}${cacheResult.latest ? `, latest: ${cacheResult.latest}` : ""})` : "";
+      const reason = cacheResult.latest ? "outdated plugin cache" : "plugin cache (latest version check unavailable)";
+      pass(`Cleared ${reason}${versionInfo} — latest will download on restart`);
+      log3.info(`  ${cacheResult.path}`);
+      fixed++;
+    } else if (cacheResult.action === "up_to_date") {
+      pass(`Plugin cache up to date (v${cacheResult.cached})`);
+    } else if (cacheResult.action === "check_unavailable") {
+      warn(`Plugin cache version check unavailable; preserving cached plugin${cacheResult.cached ? ` (cached: ${cacheResult.cached})` : ""}. Use doctor --force to reinstall it.`);
+    } else if (cacheResult.action === "in_use" || cacheResult.action === "in_use_unknown") {
+      const versionInfo = cacheResult.cached ? ` (cached: ${cacheResult.cached}${cacheResult.latest ? `, latest: ${cacheResult.latest}` : ""})` : "";
+      const why = cacheResult.action === "in_use" ? `OpenCode is running (pid ${cacheResult.pids?.join(", ")})` : cacheResult.reason ?? "could not tell whether OpenCode is running";
+      warn(`Plugin cache${versionInfo} was not cleared: ${why}`);
+      log3.info("  Quit OpenCode and rerun doctor to clear it.");
+      for (const path of cacheResult.paths ?? [cacheResult.path])
+        log3.info(`  ${path}`);
+      issues++;
+    } else if (cacheResult.action === "error") {
+      warn(`Could not clear plugin cache: ${cacheResult.error}`);
+      if (cacheResult.clearedPaths && cacheResult.clearedPaths.length > 0) {
+        log3.info(`  Cleared roots: ${cacheResult.clearedPaths.join(", ")}`);
+      }
+      if (cacheResult.failedPaths && cacheResult.failedPaths.length > 0) {
+        log3.info(`  Failed roots: ${cacheResult.failedPaths.join(", ")}`);
+      } else {
+        log3.info(`  Manually delete: ${cacheResult.path}`);
+      }
+      issues++;
+    } else if (hostGeneration !== "v2") {
+      pass("Plugin cache clean (no cached version found)");
+    }
+    let v2DistTag;
+    if (paths.opencodeConfigFormat !== "none") {
+      try {
+        v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8")));
+      } catch {}
+    }
+    const v2Cache = reportOpenCodeV2PluginCache(checkOpenCodeV2PluginCache({
+      fix: options.fix,
+      force: options.force,
+      latestVersion: v2DistTag ? await fetchNpmLatest(OPENCODE_PLUGIN_NAME, v2DistTag) : pluginNpmLatest,
+      distTag: v2DistTag,
+      hostFiles: openCodeHostDatabaseFiles([openCodeDbResolution.path]),
+      referencedSpecs: pluginConfigUse?.referencedSpecs.opencode2
+    }), { pass, warn, info: (message) => log3.info(message) }, {
+      reportMissing: hostGeneration === "v2",
+      loadedFrom: pluginConfigUse?.loadedFrom.opencode2
+    });
+    if (v2Cache.fixed)
+      fixed++;
+    if (v2Cache.issue)
+      issues++;
+    const sharedDbVersion = readContextDbSchemaVersion(dbPath);
+    if (sharedDbVersion !== null) {
+      reportCachedPluginFences(compareCachedPluginFences(listCachedOpenCodePluginFences({
+        referencedSpecs: pluginConfigUse?.referencedSpecs
+      }), sharedDbVersion), { pass, fail, info: (message) => log3.info(message) });
     }
-    issues++;
-  } else if (hostGeneration !== "v2") {
-    pass("Plugin cache clean (no cached version found)");
-  }
-  let v2DistTag;
-  if (paths.opencodeConfigFormat !== "none") {
-    try {
-      v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8")));
-    } catch {}
-  }
-  const v2Cache = reportOpenCodeV2PluginCache(checkOpenCodeV2PluginCache({
-    fix: options.fix,
-    force: options.force,
-    latestVersion: v2DistTag ? await fetchNpmLatest(OPENCODE_PLUGIN_NAME, v2DistTag) : pluginNpmLatest,
-    distTag: v2DistTag,
-    hostFiles: openCodeHostDatabaseFiles([openCodeDbResolution.path])
-  }), { pass, warn, info: (message) => log3.info(message) }, { reportMissing: hostGeneration === "v2" });
-  if (v2Cache.fixed)
-    fixed++;
-  if (v2Cache.issue)
-    issues++;
-  const sharedDbVersion = readContextDbSchemaVersion(dbPath);
-  if (sharedDbVersion !== null) {
-    reportCachedPluginFences(compareCachedPluginFences(listCachedOpenCodePluginFences(), sharedDbVersion), { pass, fail, info: (message) => log3.info(message) });
   }
-  {
+  if (magicContextInstalled) {
     const ageWarnings = collectNpmReleaseAgeWarnings();
     if (ageWarnings.length > 0) {
       log3.warn("npm min-release-age restriction detected — this can prevent OpenCode from installing the latest plugin version");
@@ -48167,17 +49759,19 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
       issues++;
     }
   }
-  const logHarnesses = [
-    ...hostGeneration === "v1" ? ["opencode"] : [],
-    ...hostGeneration === "v2" || storeGeneration === "v2" ? ["opencode2"] : []
-  ];
-  const logFiles = logHarnesses.flatMap((harness) => inspectMagicContextLogs(harness)).filter((file, index, all) => all.findIndex((other) => other.path === file.path) === index);
-  const existingLogFiles = logFiles.filter((file) => file.exists);
-  if (existingLogFiles.length === 0) {
-    log3.info(`No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
-  } else {
-    for (const file of existingLogFiles) {
-      log3.info(`Log file read: ${formatLogFileInspection(file)}`);
+  if (magicContextInstalled) {
+    const logHarnesses = [
+      ...hostGeneration === "v1" ? ["opencode"] : [],
+      ...hostGeneration === "v2" || storeGeneration === "v2" ? ["opencode2"] : []
+    ];
+    const logFiles = logHarnesses.flatMap((harness) => inspectMagicContextLogs(harness)).filter((file, index, all) => all.findIndex((other) => other.path === file.path) === index);
+    const existingLogFiles = logFiles.filter((file) => file.exists);
+    if (existingLogFiles.length === 0) {
+      log3.info(`No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
+    } else {
+      for (const file of existingLogFiles) {
+        log3.info(`Log file read: ${formatLogFileInspection(file)}`);
+      }
     }
   }
   const diagnostics = await collectDiagnostics();
@@ -48358,13 +49952,12 @@ function resolveDreamerTaskModel(args) {
   const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
   const harnessQualifier = harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ?? normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
   const taskHasModel = taskBlock !== undefined && hasOwn2(taskBlock, "model");
-  const usesMuralModel = !taskHasModel && args.task === "compress-cues" && Boolean(readString(args.muralModel));
-  const primarySource = taskHasModel ? taskBlock?.model : usesMuralModel ? args.muralModel : harnessBlock.model;
+  const primarySource = taskHasModel ? taskBlock?.model : harnessBlock.model;
   const fallbackSource = taskBlock !== undefined && hasOwn2(taskBlock, "fallback_models") ? taskBlock.fallback_models : harnessBlock.fallback_models;
   return {
     primary: resolvePrimaryEntry({
       entry: primarySource,
-      defaultQualifier: usesMuralModel ? harnessQualifier : taskQualifier ?? harnessQualifier,
+      defaultQualifier: taskQualifier ?? harnessQualifier,
       harness: args.harness
     }),
     fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
@@ -48375,13 +49968,12 @@ function resolveDreamerTaskModel(args) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-config.ts
-function buildDreamTaskRuntimeConfigs(dreamer, harness, language, muralModel) {
-  return CANONICAL_DREAM_TASKS.map((task) => {
+function buildDreamTaskRuntimeConfigs(dreamer, harness, language, smartNotesEnabled = true) {
+  return availableDreamTasks(smartNotesEnabled).map((task) => {
     const resolved = resolveDreamerTaskModel({
       config: { dreamer },
       harness,
-      task,
-      muralModel
+      task
     });
     return {
       task,
@@ -48489,7 +50081,7 @@ function runnablePiModelChains(config, harness) {
     });
   }
   if (isDreamerRunnable(config)) {
-    for (const task of buildDreamTaskRuntimeConfigs(config.dreamer, harness, config.language, config.mural?.model)) {
+    for (const task of buildDreamTaskRuntimeConfigs(config.dreamer, harness, config.language, config.smart_notes?.enabled)) {
       if (task.schedule.trim() === "")
         continue;
       const chain = [task.model, ...task.fallbackModels ?? []].filter((entry) => entry !== undefined);
@@ -49283,22 +50875,9 @@ async function runHealthChecks2(options) {
   };
   const self = options.deps.selfVersion();
   const pi = options.deps.detectPiBinary();
-  if (!pi) {
+  const piVersion = pi ? options.deps.getPiVersion(pi.path) : null;
+  if (!pi)
     add2(results, "fail", "Pi binary not found on PATH or at ~/.pi/bin/pi");
-  } else {
-    const version = options.deps.getPiVersion(pi.path);
-    if (version === null) {
-      add2(results, "fail", `Pi CLI was found at ${pi.path} but could not be executed`);
-    } else {
-      add2(results, "pass", `Pi ${version} detected at ${pi.path}`);
-    }
-    const compare = compareSemver(version, MIN_PI_VERSION);
-    if (compare !== null && compare < 0) {
-      add2(results, "fail", `Pi ${version} is older than required ${MIN_PI_VERSION}. Subagents (historian/dreamer) use the long-form \`--extension\` flag introduced in Pi 0.71.0; older versions hard-fail with "Unknown option". Run \`pi update\` (or \`npm install -g @earendil-works/pi-coding-agent@latest\`).`);
-    } else if (version) {
-      add2(results, "pass", `Pi version meets minimum ${MIN_PI_VERSION} requirement`);
-    }
-  }
   const latest = options.deps.getLatestNpmVersion();
   const latestCompare = latest ? compareSemver(self, latest) : null;
   if (latest && latestCompare === -1) {
@@ -49312,8 +50891,11 @@ async function runHealthChecks2(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
+  let piPluginInstalled = false;
   if (!existsSync47(settingsPath)) {
-    add2(results, "fail", `Pi settings not found at ${settingsPath}`);
+    if (pi) {
+      add2(results, "info", `${piVersion ? `Pi ${piVersion}` : "Pi"} found; Magic Context is not installed there (run setup to add it)`);
+    }
     repairPlan.addPackageEntry = true;
   } else {
     const parsed = readJsonc2(settingsPath);
@@ -49321,15 +50903,31 @@ async function runHealthChecks2(options) {
       add2(results, "fail", `Could not parse Pi settings ${settingsPath}: ${parsed.error}`);
     } else {
       packages = packagesFrom(parsed.value);
-      add2(results, "pass", `Pi settings found at ${settingsPath}`);
       if (hasPiMagicContextPackage(packages)) {
+        piPluginInstalled = true;
+        add2(results, "pass", `Pi settings found at ${settingsPath}`);
         add2(results, "pass", `${PI_PACKAGE_SOURCE} is registered in packages[]`);
       } else {
-        add2(results, "fail", `${PI_PACKAGE_SOURCE} is missing from packages[]`);
+        if (pi) {
+          add2(results, "info", `${piVersion ? `Pi ${piVersion}` : "Pi"} found; Magic Context is not installed there (run setup to add it)`);
+        }
         repairPlan.addPackageEntry = true;
       }
     }
   }
+  if (pi && piPluginInstalled) {
+    if (piVersion === null) {
+      add2(results, "fail", `Pi CLI was found at ${pi.path} but could not be executed`);
+    } else {
+      add2(results, "pass", `Pi ${piVersion} detected at ${pi.path}`);
+    }
+    const compare = compareSemver(piVersion, MIN_PI_VERSION);
+    if (compare !== null && compare < 0) {
+      add2(results, "fail", `Pi ${piVersion} is older than required ${MIN_PI_VERSION}. Subagents (historian/dreamer) use the long-form \`--extension\` flag introduced in Pi 0.71.0; older versions hard-fail with "Unknown option". Run \`pi update\` (or \`npm install -g @earendil-works/pi-coding-agent@latest\`).`);
+    } else if (piVersion) {
+      add2(results, "pass", `Pi version meets minimum ${MIN_PI_VERSION} requirement`);
+    }
+  }
   const userConfigPath = getPiUserConfigPath();
   const projectPath = projectConfigPath(options.cwd);
   for (const [label, path, required] of [
@@ -49378,7 +50976,8 @@ async function runHealthChecks2(options) {
   } else if (historianModel.startsWith("github-copilot/") && historianThinkingLevel) {
     add2(results, "pass", `historian.model "${historianModel}" has thinking_level "${historianThinkingLevel}" configured`);
   }
-  checkPiModelChains(results, pi, loadedConfig.config, options.deps);
+  if (piPluginInstalled)
+    checkPiModelChains(results, pi, loadedConfig.config, options.deps);
   const storage = getMagicContextStorageResolution();
   const storageDir = storage.path;
   const dbPath = join41(storageDir, "context.db");
@@ -49501,7 +51100,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     }
   } else if (loadedConfig.config.embedding.provider === "off") {
     add2(results, "info", "Embedding provider disabled");
-  } else {
+  } else if (piPluginInstalled) {
     let runtimeReported = false;
     let firstFallback = null;
     const brokenWarnings = [];
@@ -49540,38 +51139,40 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
       }
     }
   }
-  const piEntries = packages.filter(isConfiguredPiMagicContextEntry2).map(describePiPackageEntry);
-  if (piEntries.length > 1) {
-    add2(results, "fail", `Multiple magic-context entries in Pi packages[] — this loads the plugin twice: ${piEntries.join(", ")}`);
-  } else {
-    add2(results, "pass", "No conflicting magic-context entries in Pi packages[]");
-  }
-  const otherExtensions = packages.filter((entry) => !isConfiguredPiMagicContextEntry2(entry)).map(describePiPackageEntry);
-  if (otherExtensions.length > 0) {
-    add2(results, "info", `Other Pi extensions registered: ${otherExtensions.join(", ")}`);
-  } else {
-    add2(results, "info", "No other Pi extensions listed in settings.json");
-  }
-  const configuredEntry = packages.find(isPiMagicContextPackageEntry);
-  const configuredSpecifier = getPiMagicContextPackageSpecifier(configuredEntry);
-  const expectedPluginVersion = pinnedVersionFromPackageSpecifier(configuredSpecifier) ?? latest ?? null;
-  const staleCaches = findPiMagicContextCacheDirs(options.cwd, expectedPluginVersion, options.force === true);
-  if (staleCaches.length > 0) {
-    repairPlan.clearCachePaths = staleCaches.map((entry) => entry.path);
-    add2(results, "warn", `Stale Pi extension cache found: ${staleCaches.map((entry) => `${entry.path}${entry.version ? ` (v${entry.version})` : ""}`).join(", ")}`);
-  } else {
-    add2(results, "pass", "Pi extension cache clean (no stale cached package found)");
-  }
-  const logFiles = inspectMagicContextLogs("pi");
-  const existingLogFiles = logFiles.filter((file) => file.exists);
-  if (existingLogFiles.length === 0) {
-    add2(results, "info", `No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
-  } else {
-    for (const file of existingLogFiles) {
-      add2(results, "info", `Log file read: ${formatLogFileInspection(file)}`);
+  if (piPluginInstalled) {
+    const piEntries = packages.filter(isConfiguredPiMagicContextEntry2).map(describePiPackageEntry);
+    if (piEntries.length > 1) {
+      add2(results, "fail", `Multiple magic-context entries in Pi packages[] — this loads the plugin twice: ${piEntries.join(", ")}`);
+    } else {
+      add2(results, "pass", "No conflicting magic-context entries in Pi packages[]");
+    }
+    const otherExtensions = packages.filter((entry) => !isConfiguredPiMagicContextEntry2(entry)).map(describePiPackageEntry);
+    if (otherExtensions.length > 0) {
+      add2(results, "info", `Other Pi extensions registered: ${otherExtensions.join(", ")}`);
+    } else {
+      add2(results, "info", "No other Pi extensions listed in settings.json");
+    }
+    const configuredEntry = packages.find(isPiMagicContextPackageEntry);
+    const configuredSpecifier = getPiMagicContextPackageSpecifier(configuredEntry);
+    const expectedPluginVersion = pinnedVersionFromPackageSpecifier(configuredSpecifier) ?? latest ?? null;
+    const staleCaches = findPiMagicContextCacheDirs(options.cwd, expectedPluginVersion, options.force === true);
+    if (staleCaches.length > 0) {
+      repairPlan.clearCachePaths = staleCaches.map((entry) => entry.path);
+      add2(results, "warn", `Stale Pi extension cache found: ${staleCaches.map((entry) => `${entry.path}${entry.version ? ` (v${entry.version})` : ""}`).join(", ")}`);
+    } else {
+      add2(results, "pass", "Pi extension cache clean (no stale cached package found)");
+    }
+    const logFiles = inspectMagicContextLogs("pi");
+    const existingLogFiles = logFiles.filter((file) => file.exists);
+    if (existingLogFiles.length === 0) {
+      add2(results, "info", `No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
+    } else {
+      for (const file of existingLogFiles) {
+        add2(results, "info", `Log file read: ${formatLogFileInspection(file)}`);
+      }
+      const lastLine = readLogLines(existingLogFiles).at(-1);
+      add2(results, "info", `Last plugin log line: ${lastLine ? sanitizeDiagnosticText(lastLine) : "<empty log>"}`);
     }
-    const lastLine = readLogLines(existingLogFiles).at(-1);
-    add2(results, "info", `Last plugin log line: ${lastLine ? sanitizeDiagnosticText(lastLine) : "<empty log>"}`);
   }
   const diagnosticsForDumps = await collectDiagnostics2(options.cwd);
   const dumpBuckets = diagnosticsForDumps.historianDumps.byProject;
@@ -49967,7 +51568,8 @@ async function dispatchDoctor(adapter, options) {
         force: options.force,
         fix: options.fix,
         issue: options.issue,
-        report: options.report
+        report: options.report,
+        verbose: options.verbose
       });
     }
     case "pi": {
@@ -50131,6 +51733,7 @@ var DOCTOR_HELP = [
   "    --fix                               Repair safe, Magic Context-owned store rows and clear an outdated OpenCode 2 plugin cache",
   "    --force                             Force-clear the plugin cache",
   "    --clear                             Interactive cache cleanup picker",
+  "    --verbose                           Print long listings in full instead of a capped summary",
   "    --prune-discovery [--yes]           List RPC discovery records that block offline maintenance, then remove them after confirmation",
   "    --issue                             Collect diagnostics and open a GitHub issue",
   "    --report <path>                     Write the issue diagnostics to <path> without prompting",
@@ -50389,6 +51992,7 @@ async function runCommand(command, rest) {
       issue: rest.includes("--issue") || report !== null,
       ...report !== null ? { report } : {},
       clear: rest.includes("--clear"),
+      verbose: rest.includes("--verbose"),
       checkV22Backfill: rest.includes("--check-v22-backfill"),
       retryV22Backfill: rest.includes("--retry-v22-backfill"),
       ...rekeyV22DirIdentity !== null ? { rekeyV22DirIdentity } : {},