@retaw106/mmc-pi 2.2.1 → 2.4.0

package/dist/web/main.js

@@ -381,8 +381,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 = [];
@@ -442,16 +446,21 @@ var init_logger = __esm(() => {
 });
 
 // ../plugin/src/shared/sqlite.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+function inRootAsyncContext(operation) {
+  return resourceRoot.runInAsyncScope(operation);
+}
 function registerSlowWriteReporter(reporter) {
   reportSlowPrivilegedWrite = reporter;
 }
-function registerSqliteDiagnosticSink(sink) {
+function registerSqliteDiagnosticSink(sink, host) {
   sqliteDiagnosticSink = sink;
+  if (host)
+    sqliteDiagnosticHost = host;
 }
 function reportSqliteDiagnostic(message) {
   try {
-    sqliteDiagnosticSink?.(`[magic-context] ${message}`);
+    sqliteDiagnosticSink?.(`[magic-context] ${message} pid=${process.pid} host=${sqliteDiagnosticHost()}`);
   } catch {}
 }
 function detectSqliteRuntime() {
@@ -473,10 +482,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);
@@ -484,6 +514,64 @@ 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 installTransactionRouting(db, readonly) {
   const nativeExec = db.exec.bind(db);
   Object.defineProperty(db, "exec", {
@@ -494,16 +582,30 @@ function installTransactionRouting(db, readonly) {
         assertTransformWrite();
       if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
         openWriterTransactions.delete(db);
-        if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
+        if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore()) {
           acquireShort(db, () => nativeExec(sql), sql.trim());
-        else
+        } else {
           nativeExec(sql);
+          openWriterTransactions.set(db, {
+            site: sql.trim(),
+            lane: "background",
+            acquireMs: 0,
+            attempts: 1,
+            acquiredAt: performance.now()
+          });
+        }
         return db;
       }
       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), false);
+        } finally {
+          if (mayChangeTagIdentity(sql))
+            tagIdentityWriteGeneration += 1;
+        }
+      }
       return nativeExec(sql);
     }
   });
@@ -514,13 +616,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;
     }
@@ -568,6 +680,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++;
@@ -701,25 +842,52 @@ function foregroundWaitLease() {
   const lease = transformPassScope.getStore();
   return lease?.active && !admissionScope.getStore() && !backgroundWriterScope.getStore() ? lease : undefined;
 }
-function withAutocommitTimeout(db, operation) {
+function withAutocommitTimeout(db, operation, singleStatement = true) {
   assertTransformWrite();
   const lease = foregroundWaitLease();
-  if (isInTransaction(db) || !lease && !backgroundWriterScope.getStore())
+  if (isInTransaction(db))
     return operation();
-  const previous = pragmaNumber(db, "busy_timeout");
-  db.exec(`PRAGMA busy_timeout=${lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS}`);
+  const scoped = lease || backgroundWriterScope.getStore();
+  const previous = scoped ? pragmaNumber(db, "busy_timeout") : null;
   const started = performance.now();
+  let completed = false;
+  const execute = () => {
+    const result = operation();
+    completed = true;
+    return result;
+  };
   try {
-    return operation();
+    if (!scoped)
+      return execute();
+    if (singleStatement) {
+      db.exec("PRAGMA busy_timeout=0");
+      try {
+        return execute();
+      } catch (error) {
+        if (!isTransientSqliteError(error) || isInTransaction(db))
+          throw error;
+      }
+      assertTransformWrite();
+    }
+    const timeout = Math.floor(Math.min(lease?.remainingWaitMs ?? SHORT_BUSY_TIMEOUT_MS, lease?.guard?.remainingMs() ?? Infinity));
+    db.exec(`PRAGMA busy_timeout=${timeout}`);
+    const waitStarted = performance.now();
+    try {
+      return execute();
+    } finally {
+      if (lease)
+        lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - (performance.now() - waitStarted));
+    }
   } catch (error) {
     if (lease && isTransientSqliteError(error))
       throw new SqliteAcquisitionBusyError(error, "autocommit");
     throw error;
   } finally {
-    if (lease)
-      lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - (performance.now() - started));
+    const elapsed = performance.now() - started;
     if (previous !== null)
       db.exec(`PRAGMA busy_timeout=${previous}`);
+    if (elapsed >= SLOW_WRITER_LOG_MS)
+      reportSqliteDiagnostic(`sqlite writer site=autocommit lane=${lease ? "foreground" : "background"} elapsed_ms=${Math.round(elapsed)} timing=statement_including_acquisition outcome=${completed ? "completed" : "failed"} caller=${writerCaller()}`);
   }
 }
 function acquireShort(db, acquire, site) {
@@ -776,17 +944,22 @@ function endWriterTransaction(db, end, sql) {
       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)} attempts=${open.attempts} outcome=${outcome} timing=through_commit_upper_bound caller=${writerCaller()}`);
       }
     }
   }
 }
+function writerCaller() {
+  return new Error().stack?.split(`
+`).find((line) => line.includes(" at ") && !/[/\\]sqlite\.[tj]s[:)]/.test(line) && !/\b(?:writerCaller|endWriterTransaction|withAutocommitTimeout|value)\b/.test(line))?.trim().replace(/\s+/g, "_") ?? "unknown";
+}
 function isInTransaction(db) {
   const candidate = db;
   return candidate.inTransaction === true || candidate.isTransaction === true;
 }
-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, SLOW_WRITER_LOG_MS = 250, WRITER_TRANSACTION_END, writerAcquisitionScope, openWriterTransactions;
+var resourceRoot, reportSlowPrivilegedWrite, sqliteDiagnosticSink, sqliteDiagnosticHost = () => "unknown", 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, SLOW_WRITER_LOG_MS = 100, WRITER_TRANSACTION_END, writerAcquisitionScope, openWriterTransactions, indexCoordinationKey, indexCoordinationHeap, indexCoordinationBuffer, indexCoordinationState;
 var init_sqlite = __esm(async () => {
+  resourceRoot = new AsyncResource("magic-context:root");
   bunSpec = "bun:" + "sqlite";
   nodeSpec = "node:" + "sqlite";
   SqliteRuntimeUnavailableError = class SqliteRuntimeUnavailableError extends Error {
@@ -805,9 +978,22 @@ 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);
+      const db = inRootAsyncContext(() => Reflect.construct(target, args, target));
       return trackSqliteConnection(db, args[0], args[1]);
     }
   });
@@ -829,6 +1015,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);
 });
 
 // ../plugin/src/shared/sqlite-helpers.ts
@@ -885,15 +1076,108 @@ var init_migration_v3_perf_schema = __esm(() => {
   tagOrderIndexes = new WeakMap;
 });
 
+// ../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
 var HASH_HEX = "[0-9a-f]{7,12}", COMMIT_HASH_TEST_PATTERN;
 var init_commit_detection = __esm(() => {
   COMMIT_HASH_TEST_PATTERN = new RegExp(`\\b${HASH_HEX}\\b`, "i");
 });
+// ../plugin/src/hooks/magic-context/token-count-exact.ts
+var textEncoder, textDecoder, mergeCaches;
+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
 var promptTokenCounts, PROMPT_TOKEN_COUNT_BYTES;
 var init_read_session_formatting = __esm(() => {
   init_commit_detection();
+  init_token_count_exact();
   promptTokenCounts = new Map;
   PROMPT_TOKEN_COUNT_BYTES = 8 * 1024 * 1024;
 });
@@ -1379,6 +1663,89 @@ function installV4TemporalDecisions(db) {
 init_logger();
 init_write_transaction_timing();
 init_migration_v3_perf_schema();
+
+// ../plugin/src/features/magic-context/storage-compartment-history-version.ts
+function definitions(db) {
+  const hasPrivilegeTable = Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='context_privilege_state'").get());
+  const externalUpdate = hasPrivilegeTable ? "CASE WHEN COALESCE((SELECT enabled FROM context_privilege_state WHERE id=1),0)=0 THEN 1 ELSE 0 END" : "1";
+  return [
+    {
+      type: "table",
+      name: "compartment_history_versions",
+      sql: `CREATE TABLE compartment_history_versions (
+            session_id TEXT PRIMARY KEY NOT NULL,
+            generation TEXT NOT NULL DEFAULT (lower(hex(randomblob(16)))),
+            version INTEGER NOT NULL DEFAULT 0 CHECK (version >= 0),
+            rewrite_version INTEGER NOT NULL DEFAULT 0 CHECK (rewrite_version >= 0),
+            seeded INTEGER NOT NULL DEFAULT 0 CHECK (seeded IN (0, 1))
+        )`
+    },
+    {
+      type: "trigger",
+      name: "compartment_history_ai",
+      sql: `CREATE TRIGGER compartment_history_ai AFTER INSERT ON compartments BEGIN
+            INSERT INTO compartment_history_versions(session_id, version) VALUES (NEW.session_id, 1)
+            ON CONFLICT(session_id) DO UPDATE SET version = version + 1;
+        END`
+    },
+    {
+      type: "trigger",
+      name: "compartment_history_ad",
+      sql: `CREATE TRIGGER compartment_history_ad AFTER DELETE ON compartments BEGIN
+            INSERT INTO compartment_history_versions(session_id, version) VALUES (OLD.session_id, 1)
+            ON CONFLICT(session_id) DO UPDATE SET version = version + 1;
+        END`
+    },
+    {
+      type: "trigger",
+      name: "compartment_history_au",
+      sql: `CREATE TRIGGER compartment_history_au AFTER UPDATE ON compartments BEGIN
+            INSERT INTO compartment_history_versions(session_id, version, rewrite_version) VALUES (OLD.session_id, 1, ${externalUpdate})
+            ON CONFLICT(session_id) DO UPDATE SET version = version + 1, rewrite_version = rewrite_version + ${externalUpdate};
+            INSERT INTO compartment_history_versions(session_id, version, rewrite_version)
+                SELECT NEW.session_id, 1, ${externalUpdate} WHERE NEW.session_id != OLD.session_id
+            ON CONFLICT(session_id) DO UPDATE SET version = version + 1, rewrite_version = rewrite_version + ${externalUpdate};
+        END`
+    }
+  ];
+}
+function installedDefinitions(db) {
+  const rows = db.prepare(`SELECT type, name, sql FROM sqlite_master
+        WHERE name IN ('compartment_history_versions', 'compartment_history_ai', 'compartment_history_ad', 'compartment_history_au')`).all();
+  return new Map(rows.map((row) => [`${row.type}:${row.name}`, row.sql]));
+}
+function matches(expected, installed) {
+  return expected.every((definition) => installed.get(`${definition.type}:${definition.name}`) === definition.sql);
+}
+function installCompartmentHistoryVersions(db) {
+  if (!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='compartments'").get())
+    return;
+  if (matches(definitions(db), installedDefinitions(db)))
+    return;
+  db.transaction(() => {
+    const expected = definitions(db);
+    const installed = installedDefinitions(db);
+    if (matches(expected, installed))
+      return;
+    const table = expected[0];
+    const existingTable = installed.get(`table:${table.name}`);
+    if (existingTable !== undefined && existingTable !== table.sql) {
+      throw new Error("compartment_history_versions schema differs from v5; refusing to replace revision data");
+    }
+    if (existingTable === undefined)
+      db.exec(table.sql);
+    db.exec(`INSERT OR IGNORE INTO compartment_history_versions(session_id, seeded)
+            SELECT DISTINCT session_id, 1 FROM compartments`);
+    for (const trigger of expected.slice(1)) {
+      if (installed.get(`trigger:${trigger.name}`) === trigger.sql)
+        continue;
+      db.exec(`DROP TRIGGER IF EXISTS ${trigger.name}`);
+      db.exec(trigger.sql);
+    }
+  }).immediate();
+}
+
+// ../plugin/src/features/magic-context/migrations.ts
 var FORK_MIGRATION_VERSION_FLOOR = 1e4;
 class MigrationLockBusyError extends Error {
   constructor(message) {
@@ -1421,6 +1788,13 @@ var MIGRATIONS = [
     up(db) {
       installV4TemporalDecisions(db);
     }
+  },
+  {
+    version: 5,
+    description: "per-session compartment history revision for shared readers",
+    up(db) {
+      installCompartmentHistoryVersions(db);
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -1562,6 +1936,7 @@ function ensureColumn(db, table, column, definition) {
 }
 
 // ../plugin/src/features/magic-context/storage-db.ts
+init_storage_tag_identity_revision();
 init_tool_definition_tokens();
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
@@ -1572,13 +1947,13 @@ var LEASE_RENEWAL_MS = 60 * 1000;
 
 // ../plugin/src/features/magic-context/storage-db.ts
 registerSlowWriteReporter(logSlowWriteTransaction);
-registerSqliteDiagnosticSink((message) => log(message));
+registerSqliteDiagnosticSink((message) => log(message), getHarness);
 var databases = new Map;
 var pendingAsyncOpens = new Map;
 var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 var pathByDatabase = new WeakMap;
-var LATEST_SUPPORTED_VERSION = 4;
+var LATEST_SUPPORTED_VERSION = 5;
 var BOOT_SQLITE_BUSY_TIMEOUT_MS = 5000;
 function resolveBootBusyTimeoutMs(value) {
   if (value === undefined)
@@ -3039,6 +3414,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     `);
   installV3PerfSchema(db);
   installV4TemporalDecisions(db);
+  installCompartmentHistoryVersions(db);
+  installTagIdentityRevisionTrigger(db);
 }
 var CHANNEL2_CLAIM_TTL_MS = 10 * 60000;
 var channel2HealStatements = new WeakMap;
@@ -4796,6 +5173,7 @@ var AGENT_STEP_CAPS = {
   [MEMORY_MAINTAINER_A_AGENT]: MEMORY_MAINTAINER_A_STEP_CAP,
   [HIDDEN_HISTORIAN_AGENT]: HISTORIAN_STEP_CAP
 };
+var DISPOSED_CHILDREN_KEY = Symbol.for("magic-context.v2.disposed-hidden-children");
 
 // ../plugin/src/v2/hidden-child-record.ts
 var HIDDEN_CHILD_ROLE_TITLES = {
@@ -7471,12 +7849,31 @@ function attachPiPartVersion(parts, version) {
     return part;
   });
 }
-function* iterateEntriesToRawMessageRange(entries, afterOrdinal, limit, finalWatermark, synthIdAliases) {
+var UNREACHABLE_PI_STORE_TYPE = "unavailable";
+function unreachablePiOrdinalSlot(ordinal) {
+  const slot = { ordinal, id: "", role: "system", parts: [] };
+  Object.defineProperty(slot, "storeType", {
+    value: UNREACHABLE_PI_STORE_TYPE,
+    enumerable: false
+  });
+  return slot;
+}
+function* iterateEntriesToRawMessageRange(entries, afterOrdinal, limit, finalWatermark, synthIdAliases, ordinalOffset = 0) {
   let emitted = 0;
   const normalizedAfter = Math.max(0, Math.floor(afterOrdinal));
   const normalizedLimit = Math.max(1, Math.floor(limit));
   const normalizedWatermark = Math.max(normalizedAfter, Math.floor(finalWatermark));
-  let nextOrdinal = 1;
+  const prefix = Number.isSafeInteger(ordinalOffset) && ordinalOffset > 0 ? ordinalOffset : 0;
+  const prefixEnd = Math.min(prefix, normalizedWatermark);
+  for (let ordinal = normalizedAfter + 1;ordinal <= prefixEnd; ordinal++) {
+    emitted++;
+    yield unreachablePiOrdinalSlot(ordinal);
+    if (emitted >= normalizedLimit)
+      return;
+  }
+  if (prefix >= normalizedWatermark)
+    return;
+  let nextOrdinal = prefix + 1;
   let heldToolRow = null;
   let orphanToolParts = [];
   const buildOrphanParts = (results) => results.flatMap(({ msg, version }) => attachPiPartVersion(synthesizeToolResultParts(msg), version));
@@ -7591,9 +7988,9 @@ function* iterateEntriesToRawMessageRange(entries, afterOrdinal, limit, finalWat
     yield* appendMessage(`${SYNTH_USER_ID_PREFIX}${orphanFirstId}`, "user", orphanFirstVersion, orphanFirstCreatedAt, () => buildOrphanParts(trailingOrphanResults));
   }
 }
-function convertEntriesToRawMessages(entries) {
+function convertEntriesToRawMessages(entries, ordinalOffset = 0) {
   return [
-    ...iterateEntriesToRawMessageRange(entries, 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)
+    ...iterateEntriesToRawMessageRange(entries, 0, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, undefined, ordinalOffset)
   ];
 }
 function buildPiSynthUserIdAlias(entries) {