@retaw106/mmc-pi 2.2.1 → 2.4.0

package/dist/{index-j0jjtcwm.js → index-zmx631ey.js}

@@ -1,12 +1,14 @@
+import {
+  getTagIdentityWriteGeneration,
+  Database,
+  getSqliteDatabasePath
+} from "./index-cr4hzd76.js";
 import {
   getHarness,
   harnessOwnsOpenCodeStore,
   log,
   sessionLog
-} from "./index-54cgx9gm.js";
-import {
-  Database
-} from "./index-ny303arh.js";
+} from "./index-83p1tc98.js";
 
 // ../plugin/src/hooks/magic-context/tokenizer-calibration-seeds.json
 var tokenizer_calibration_seeds_default = [
@@ -571,7 +573,7 @@ import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 // ../plugin/src/shared/commit-detection.ts
 var HASH_HEX = "[0-9a-f]{7,12}";
@@ -593,6 +595,272 @@ function removeSystemReminders(text) {
   return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
 }
 
+// ../plugin/src/hooks/magic-context/token-count-exact.ts
+var NO_RANK = 4294967295;
+var LONG_PIECE_BYTES = 256;
+var MERGE_CACHE_GENERATION = 50000;
+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);
+}
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder("utf-8");
+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;
+}
+var mergeCaches = new WeakMap;
+var mergedPieces = 0;
+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;
+}
+
 // ../plugin/src/hooks/magic-context/read-session-formatting.ts
 var MAX_COMMITS_PER_BLOCK = 5;
 function hasMeaningfulUserText2(parts) {
@@ -705,22 +973,30 @@ var tokenizerSerializedTableBytes;
 function tokenizerPackageRoots() {
   const cwd = process.cwd();
   const openCodeCache = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "opencode");
-  const roots = [cwd, openCodeCache];
   const candidates = [];
-  for (const root of roots) {
+  const probeRoot = (root) => {
     for (const packageDir of TOKENIZER_PACKAGE_DIRS) {
       candidates.push(join(root, "node_modules", ...packageDir, "node_modules", "ai-tokenizer"));
     }
     candidates.push(join(root, "node_modules", "ai-tokenizer"));
+  };
+  for (const root of [cwd, openCodeCache]) {
+    probeRoot(root);
   }
-  let ancestor = process.argv[1] ? dirname(resolve(process.argv[1])) : cwd;
-  while (true) {
-    candidates.push(join(ancestor, "node_modules", "ai-tokenizer"));
-    const parent = dirname(ancestor);
-    if (parent === ancestor)
-      break;
-    ancestor = parent;
-  }
+  const pushAncestors = (startDir) => {
+    let ancestor = startDir;
+    while (true) {
+      candidates.push(join(ancestor, "node_modules", "ai-tokenizer"));
+      const parent = dirname(ancestor);
+      if (parent === ancestor)
+        break;
+      ancestor = parent;
+    }
+  };
+  pushAncestors(process.argv[1] ? dirname(resolve(process.argv[1])) : cwd);
+  const ownDir = dirname(fileURLToPath(new URL(import.meta.url)));
+  pushAncestors(ownDir);
+  probeRoot(join(homedir(), ".omp", "plugins"));
   return [...new Set(candidates)];
 }
 function packageImportTarget(value) {
@@ -838,7 +1114,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;
@@ -1013,6 +1289,16 @@ function prependTag(tagId, value) {
   return `§${tagId}§ ${stripped}`;
 }
 
+// ../plugin/src/hooks/magic-context/tail-hygiene-output-count.ts
+var CURRENT_OUTPUT_COUNT = Symbol.for("magic-context.current-reclaimable-tool-output-count");
+function countReclaimableToolOutputs(parts) {
+  return parts.filter((part) => part.kind === "toolOutput" && part.uTokens > 0).length;
+}
+function rememberCurrentToolOutputCount(baseline, measurement) {
+  return Object.assign(baseline, {
+    [CURRENT_OUTPUT_COUNT]: countReclaimableToolOutputs(measurement.parts)
+  });
+}
 // ../plugin/src/shared/record-type-guard.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1020,15 +1306,34 @@ function isRecord(value) {
 
 // ../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, (piece) => pieces.push(piece));
+  return pieces.join("");
+}
+function writeStable(value, seen, write) {
+  if (value === undefined) {
+    write("undefined");
+    return;
+  }
+  if (value === null || typeof value !== "object") {
+    write(JSON.stringify(value) ?? String(value));
+    return;
+  }
+  if (seen.has(value)) {
+    write('"[Circular]"');
+    return;
+  }
   seen.add(value);
   if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+    write("[");
+    for (let index = 0;index < value.length; index += 1) {
+      if (index > 0)
+        write(",");
+      if (index in value)
+        writeStable(value[index], seen, write);
+    }
+    write("]");
+    return;
   }
   const entries = Object.entries(value).sort(([a], [b]) => {
     if (a < b)
@@ -1037,11 +1342,34 @@ function stableStringify(value, seen = new WeakSet) {
       return 1;
     return 0;
   });
-  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
+  if (entries.length > 0 && entries.length <= 16 && entries.every(([key, child]) => key.length <= 4096 && !/^(0|[1-9]\d*)$/.test(key) && (child === null || typeof child === "number" || typeof child === "boolean" || typeof child === "string" && child.length <= 4096))) {
+    write(JSON.stringify(Object.fromEntries(entries)));
+    return;
+  }
+  write("{");
+  entries.forEach(([key, child], index) => {
+    if (index > 0)
+      write(",");
+    write(JSON.stringify(key));
+    write(":");
+    writeStable(child, seen, write);
+  });
+  write("}");
+}
+function jsonHashSink(prefix = "") {
+  let hash = 2166136261;
+  const write = (piece) => {
+    for (let index = 0;index < piece.length; index++) {
+      hash = Math.imul(hash ^ piece.charCodeAt(index), 16777619);
+    }
+  };
+  write(prefix);
+  return { write, digest: () => (hash >>> 0).toString(16).padStart(8, "0") };
 }
 
 // ../plugin/src/shared/tag-owner-id.ts
 var TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
+var PI_FALLBACK_PREFIXES_JSON = JSON.stringify([..."pi-msg-"].reduce((prefixes, char) => prefixes.flatMap((prefix) => /[a-z]/.test(char) ? [prefix + char, prefix + char.toUpperCase()] : [prefix + char]), [""]));
 var POSITIONAL_CONTENT_SUFFIX = /:(?:p|file)\d+$/;
 var CONTENT_DERIVED_TEXT_SUFFIX = /:mc-text-v1:[0-9a-f]+:[0-9a-f]+:o\d+$/;
 function contentTagOwnerMessageId(contentId) {
@@ -1054,6 +1382,197 @@ function contentTagOwnerMessageId(contentId) {
   return contentId;
 }
 
+// ../plugin/src/shared/tail-hygiene-json.ts
+var MAX_MEMO_BYTES = 64 * 1024 * 1024;
+var MAX_MEMO_ENTRIES = 1e4;
+
+class TailHygieneJsonMemo {
+  entries = new Map;
+  bytes = 0;
+  passText = new WeakMap;
+  passHash = new WeakMap;
+  beginPass() {
+    this.passText = new WeakMap;
+    this.passHash = new WeakMap;
+  }
+  get(key, value, compute, fingerprint = false) {
+    const pass = fingerprint ? this.passHash : this.passText;
+    const object = value !== null && typeof value === "object" ? value : undefined;
+    const local = object ? pass.get(object) : undefined;
+    if (local !== undefined)
+      return local;
+    const previous = this.entries.get(key);
+    if (previous && sameJson(previous.snapshot, value)) {
+      if (object)
+        pass.set(object, previous.result);
+      return previous.result;
+    }
+    const result = compute();
+    if (previous) {
+      this.bytes -= previous.bytes;
+      this.entries.delete(key);
+    }
+    try {
+      const copy = copyJson(value);
+      const bytes = copy.bytes + (key.length + result.length) * 2;
+      if (bytes <= MAX_MEMO_BYTES) {
+        this.entries.set(key, { snapshot: copy.value, result, bytes });
+        this.bytes += bytes;
+        if (object)
+          pass.set(object, result);
+      }
+    } catch {}
+    while (this.bytes > MAX_MEMO_BYTES || this.entries.size > MAX_MEMO_ENTRIES) {
+      const oldest = this.entries.entries().next().value;
+      if (!oldest)
+        break;
+      this.bytes -= oldest[1].bytes;
+      this.entries.delete(oldest[0]);
+    }
+    return result;
+  }
+}
+function copyJson(value) {
+  const seen = new Map;
+  let bytes = 0;
+  const copy = (current) => {
+    bytes += 16;
+    if (typeof current === "string")
+      bytes += current.length * 2;
+    if (bytes > MAX_MEMO_BYTES)
+      throw new Error("memo capacity");
+    if (current === null || typeof current !== "object") {
+      if (["function", "symbol", "bigint"].includes(typeof current))
+        throw new Error("exotic");
+      return current;
+    }
+    if (seen.has(current))
+      return seen.get(current);
+    const prototype = Object.getPrototypeOf(current);
+    if (!Array.isArray(current) && prototype !== Object.prototype && prototype !== null)
+      throw new Error("exotic");
+    const result = Array.isArray(current) ? new Array(current.length) : Object.create(prototype);
+    seen.set(current, result);
+    for (const key of Object.keys(current)) {
+      const descriptor = Object.getOwnPropertyDescriptor(current, key);
+      if (!descriptor || !("value" in descriptor))
+        throw new Error("accessor");
+      bytes += key.length * 2 + 16;
+      if (key === "__proto__") {
+        Object.defineProperty(result, key, {
+          value: copy(descriptor.value),
+          enumerable: true,
+          writable: true,
+          configurable: true
+        });
+      } else
+        result[key] = copy(descriptor.value);
+    }
+    return result;
+  };
+  return { value: copy(value), bytes };
+}
+function sameJson(before, after) {
+  const forward = new Map;
+  const reverse = new Set;
+  const same = (left, right) => {
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+      return Object.is(left, right);
+    if (forward.has(left))
+      return forward.get(left) === right;
+    if (reverse.has(right) || Object.getPrototypeOf(left) !== Object.getPrototypeOf(right))
+      return false;
+    forward.set(left, right);
+    reverse.add(right);
+    if (Array.isArray(left) && (!Array.isArray(right) || left.length !== right.length))
+      return false;
+    const keys = Object.keys(left);
+    const otherKeys = Object.keys(right);
+    if (keys.length !== otherKeys.length)
+      return false;
+    for (let index = 0;index < keys.length; index++) {
+      const key = keys[index];
+      if (key !== otherKeys[index])
+        return false;
+      const descriptor = Object.getOwnPropertyDescriptor(right, key);
+      if (!descriptor || !("value" in descriptor) || !same(left[key], descriptor.value))
+        return false;
+    }
+    return true;
+  };
+  return same(before, after);
+}
+function piJsonHash(value, fallback) {
+  const sink = jsonHashSink("excluded\x00");
+  try {
+    const seen = new Set;
+    const arrays = new Set;
+    const write = (current) => {
+      if (current === null || typeof current !== "object") {
+        if (["function", "symbol", "bigint"].includes(typeof current))
+          throw new Error("exotic");
+        sink.write(JSON.stringify(current) ?? "");
+      } else if (Array.isArray(current)) {
+        if (Object.getPrototypeOf(current) !== Array.prototype || Object.hasOwn(current, "toJSON"))
+          throw new Error("exotic array");
+        if (arrays.has(current))
+          throw new Error("array cycle");
+        arrays.add(current);
+        sink.write("[");
+        for (let index = 0;index < current.length; index++) {
+          if (index)
+            sink.write(",");
+          const descriptor = Object.getOwnPropertyDescriptor(current, index);
+          if (descriptor && !("value" in descriptor))
+            throw new Error("accessor");
+          if (!descriptor && index in current)
+            throw new Error("inherited array element");
+          write(descriptor?.value === undefined ? null : descriptor.value);
+        }
+        sink.write("]");
+        arrays.delete(current);
+      } else if (seen.has(current)) {
+        sink.write('"[Circular]"');
+      } else {
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype !== Object.prototype && prototype !== null)
+          throw new Error("exotic");
+        seen.add(current);
+        const entries = Object.keys(current).map((key) => {
+          const descriptor = Object.getOwnPropertyDescriptor(current, key);
+          if (!descriptor || !("value" in descriptor))
+            throw new Error("accessor");
+          return [key, descriptor.value];
+        });
+        const sorted = Object.fromEntries(entries.sort(([a], [b]) => a.localeCompare(b)));
+        if (entries.length <= 16 && entries.every(([key, child]) => key.length <= 4096 && (child === null || child === undefined || typeof child === "number" || typeof child === "boolean" || typeof child === "string" && child.length <= 4096))) {
+          sink.write(JSON.stringify(sorted));
+          return;
+        }
+        sink.write("{");
+        let first = true;
+        for (const [key, child] of Object.entries(sorted)) {
+          if (child === undefined)
+            continue;
+          if (!first)
+            sink.write(",");
+          first = false;
+          sink.write(JSON.stringify(key));
+          sink.write(":");
+          write(child);
+        }
+        sink.write("}");
+      }
+    };
+    write(value);
+    return sink.digest();
+  } catch {
+    const failed = jsonHashSink("excluded\x00");
+    failed.write(fallback());
+    return failed.digest();
+  }
+}
+
 // ../plugin/src/hooks/magic-context/image-token-estimate.ts
 var IMAGE_TOKEN_DIVISOR = 750;
 var IMAGE_FALLBACK_TOKENS = 1200;
@@ -1091,6 +1610,23 @@ function estimateImageTokensFromDataUrl(url) {
   }
   return IMAGE_FALLBACK_TOKENS;
 }
+function estimateToolAttachmentImageTokens(state) {
+  if (!state || typeof state !== "object")
+    return 0;
+  const attachments = state.attachments;
+  if (!Array.isArray(attachments))
+    return 0;
+  let tokens = 0;
+  for (const attachment of attachments) {
+    if (!attachment || typeof attachment !== "object")
+      continue;
+    const { mime, url } = attachment;
+    if (typeof mime !== "string" || !mime.startsWith("image/"))
+      continue;
+    tokens += typeof url === "string" && url.startsWith("data:") ? estimateImageTokensFromDataUrl(url) : IMAGE_FALLBACK_TOKENS;
+  }
+  return tokens;
+}
 function clampImageTokens(n) {
   if (n < 1)
     return 1;
@@ -1229,6 +1765,88 @@ function readUint32BE(b, offset) {
   return (b[offset] << 24 | b[offset + 1] << 16 | b[offset + 2] << 8 | b[offset + 3]) >>> 0;
 }
 
+// ../plugin/src/hooks/magic-context/provider-visible-parts.ts
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var KEPT_TOOL_STATE_FIELDS = new Set([
+  "status",
+  "input",
+  "output",
+  "error",
+  "attachments",
+  "content"
+]);
+var KEPT_TOOL_STATE_TIME_FIELD = "compacted";
+function providerVisiblePart(part) {
+  if (!isRecord2(part) || part.type !== "tool" || !isRecord2(part.state))
+    return part;
+  if (toolStateIsReduced(part.state))
+    return part;
+  return { ...part, state: providerVisibleToolState(part.state) };
+}
+var KEPT_ERROR_METADATA_FIELDS = ["interrupted", "output"];
+function providerVisibleToolState(state) {
+  const view = {};
+  for (const key of Object.keys(state)) {
+    const value = state[key];
+    if (KEPT_TOOL_STATE_FIELDS.has(key)) {
+      view[key] = value;
+    } else if (key === "time" && isRecord2(value)) {
+      view.time = value[KEPT_TOOL_STATE_TIME_FIELD] === undefined ? {} : { [KEPT_TOOL_STATE_TIME_FIELD]: value[KEPT_TOOL_STATE_TIME_FIELD] };
+    } else if (key === "metadata" && state.status === "error" && isRecord2(value)) {
+      const kept = {};
+      for (const field of KEPT_ERROR_METADATA_FIELDS) {
+        if (Object.hasOwn(value, field))
+          kept[field] = value[field];
+      }
+      view.metadata = kept;
+    }
+  }
+  return view;
+}
+function toolStateIsReduced(state) {
+  for (const key of Object.keys(state)) {
+    if (KEPT_TOOL_STATE_FIELDS.has(key))
+      continue;
+    const value = state[key];
+    if (key === "time" && isRecord2(value)) {
+      const keys = Object.keys(value);
+      if (keys.length === 0)
+        continue;
+      if (keys.length === 1 && keys[0] === KEPT_TOOL_STATE_TIME_FIELD)
+        continue;
+      return false;
+    }
+    if (key === "metadata" && state.status === "error" && isRecord2(value)) {
+      const extra = Object.keys(value).some((field) => !KEPT_ERROR_METADATA_FIELDS.includes(field));
+      if (!extra)
+        continue;
+    }
+    return false;
+  }
+  return true;
+}
+function providerVisibleMessage(message) {
+  return projectMessage(message, providerVisiblePart);
+}
+function projectMessage(message, projectPart) {
+  if (!isRecord2(message) || !Array.isArray(message.parts))
+    return message;
+  let parts;
+  for (let index = 0;index < message.parts.length; index += 1) {
+    const part = message.parts[index];
+    const view = projectPart(part);
+    if (view !== part) {
+      parts ??= message.parts.slice(0, index);
+      parts.push(view);
+    } else if (parts) {
+      parts.push(part);
+    }
+  }
+  return parts ? { ...message, parts } : message;
+}
+
 // ../plugin/src/hooks/magic-context/todo-view.ts
 import { createHash } from "node:crypto";
 var TODO_STATUS_PENDING = "pending";
@@ -1337,7 +1955,7 @@ function isTodoItem(value) {
 }
 
 // ../plugin/src/hooks/magic-context/tail-hygiene-walk.ts
-var MAX_CONTENT_MEMO_BYTES = 64 * 1024 * 1024;
+var MAX_CONTENT_MEMO_BYTES = 256 * 1024 * 1024;
 var contentMemo = new Map;
 var contentMemoOrder = new Set;
 var CHANNEL1_REMINDER_OPEN = `
@@ -1356,6 +1974,7 @@ function stripChannel1ReminderSpans(output) {
   }
   return stripped;
 }
+var partJsonMemo = new TailHygieneJsonMemo;
 function messageIdFromPartKey(key) {
   const separator = key.indexOf("\x00");
   return separator > 0 ? key.slice(0, separator) : key;
@@ -1653,7 +2272,7 @@ function formatOldestReclaimableHint(hint) {
 oldest reclaimable: ${rendered}.` : "";
 }
 function reclaimableToolOutputCount(parts) {
-  return parts.filter((part) => part.kind === "toolOutput" && part.uTokens > 0).length;
+  return countReclaimableToolOutputs(parts);
 }
 function formatReclaimableOutputSummary(count, tokens) {
   const outputCount = Math.max(0, Math.floor(count));
@@ -1991,6 +2610,102 @@ function removePendingOp(db, sessionId, tagId) {
   getRemovePendingOpStatement(db).run(sessionId, tagId);
 }
 
+// ../plugin/src/features/magic-context/storage-tag-identity-revision.ts
+var TAG_IDENTITY_REVISION_PREFIX = "tag_identity_revision:";
+var TAG_REVISION_PREFIX = "tag_revision:";
+var TAG_REVISION_INCARNATION_KEY = "tag_revision_incarnation";
+var tagRevisionIncarnationSql = (value) => `CASE WHEN INSTR(${value}, ':') > 0 THEN SUBSTR(${value}, 1, INSTR(${value}, ':') - 1) ELSE '0' END`;
+var tagRevisionCountSql = (value) => `CAST(CASE WHEN INSTR(${value}, ':') > 0 THEN SUBSTR(${value}, INSTR(${value}, ':') + 1) ELSE ${value} END AS INTEGER)`;
+var ADVANCE = (delta = "1") => `CASE
+    WHEN ${tagRevisionCountSql("value")} <= 9223372036854775807 - ${delta}
+    THEN (${tagRevisionIncarnationSql("value")}) || ':' || CAST(${tagRevisionCountSql("value")} + ${delta} AS TEXT)
+    ELSE NULL END`;
+function tagRevisionKey(sessionId) {
+  return `${TAG_REVISION_PREFIX}${sessionId}`;
+}
+function tagIdentityRevisionKey(sessionId) {
+  return `${TAG_IDENTITY_REVISION_PREFIX}${sessionId}`;
+}
+var 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()}`;
+var 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`;
+var 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)")}`;
+var 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`;
+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;`);
+}
+
 // ../plugin/src/features/magic-context/storage-tags.ts
 var insertTagStatements = new WeakMap;
 var updateTagStatusStatements = new WeakMap;
@@ -2207,8 +2922,41 @@ function getPersistedToolTagAccounting(db, sessionId, tagNumber) {
   }
   return row;
 }
-function getAllStatusTagTokenTotalsFlat(db, sessionId, floor = 0, calibration = { proseRatio: 1, toolsRatio: 1 }, options) {
-  const rows = floor > 0 ? db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
+function getAllStatusTagTokenTotalsFlat(db, sessionId, floor = 0, calibration = { proseRatio: 1, toolsRatio: 1 }, options, ownerMessageIds) {
+  const columns = "type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count";
+  const owners = ownerMessageIds ? new Set(ownerMessageIds) : undefined;
+  let scanOrder = "id";
+  if (owners) {
+    const planStatement = db.prepare(`EXPLAIN QUERY PLAN SELECT ${columns} FROM tags WHERE session_id = ?${floor > 0 ? " AND tag_number >= ?" : ""}`);
+    let plan;
+    try {
+      plan = planStatement.all(sessionId, ...floor > 0 ? [floor] : []);
+    } finally {
+      planStatement.finalize?.();
+    }
+    const index = plan.map((row) => /USING (?:COVERING )?INDEX (\S+)/.exec(row.detail)?.[1]).find(Boolean);
+    if (index) {
+      const keyStatement = db.prepare("SELECT name, coll, desc FROM pragma_index_xinfo(?) WHERE key = 1 ORDER BY seqno");
+      let keys;
+      try {
+        keys = keyStatement.all(index);
+      } finally {
+        keyStatement.finalize?.();
+      }
+      scanOrder = [
+        ...keys.map((key) => `"${(key.name ?? "id").replaceAll('"', '""')}" COLLATE "${key.coll.replaceAll('"', '""')}"${key.desc ? " DESC" : ""}`),
+        "id"
+      ].join(", ");
+    }
+  }
+  const rows = owners ? db.prepare(`SELECT ${columns} FROM tags WHERE id IN (
+                SELECT t.id FROM json_each(?) o CROSS JOIN tags t INDEXED BY idx_tags_session_message_id
+                ON t.session_id = ? AND t.message_id >= o.value AND t.message_id < o.value || ';'
+                UNION
+                SELECT t.id FROM json_each(?) o CROSS JOIN tags t INDEXED BY idx_tags_pi_fallback_tool_owner
+                ON t.session_id = ? AND t.tool_owner_message_id = o.value
+                WHERE t.type = 'tool'
+              ) AND tag_number >= ? ORDER BY ${scanOrder}`).all(JSON.stringify([...owners]), sessionId, JSON.stringify([...owners]), sessionId, floor) : floor > 0 ? db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
                        FROM tags
                        WHERE session_id = ? AND tag_number >= ?`).all(sessionId, floor) : db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
                        FROM tags
@@ -2221,6 +2969,8 @@ function getAllStatusTagTokenTotalsFlat(db, sessionId, floor = 0, calibration =
     if (options?.excludeToolTags === true && row.type === "tool")
       continue;
     const owner = ownerMessageIdForTagRow(row);
+    if (owners && !owners.has(owner))
+      continue;
     if (row.token_count === null) {
       nullMessageIds.add(owner);
       totals.delete(owner);
@@ -2235,15 +2985,163 @@ function getAllStatusTagTokenTotalsFlat(db, sessionId, floor = 0, calibration =
   return { totals, nullMessageIds };
 }
 function getReasoningTokenEstimatesByMessage(db, sessionId, proseRatio) {
-  const rows = db.prepare(`SELECT type, message_id, tool_owner_message_id, reasoning_token_count FROM tags WHERE session_id = ? AND reasoning_token_count IS NOT NULL`).all(sessionId);
-  const totals = new Map;
-  for (const row of rows) {
-    if (row.type !== "message")
-      continue;
-    const id = ownerMessageIdForTagRow(row);
-    totals.set(id, Math.max(totals.get(id) ?? 0, row.reasoning_token_count * proseRatio));
+  const summary = readTagOwnerSummary(db, sessionId, proseRatio);
+  return summary.reasoningEstimatesByRatio.get(proseRatio) ?? new Map;
+}
+var tagOwnerSummaries = new WeakMap;
+var MAX_CACHED_PROSE_RATIOS = 4;
+var TAG_OWNER_PAGE_LIMIT = 512;
+var tagOwnerRowsRead = 0;
+var tagOwnerShapeChecks = 0;
+function foldTagOwnerRow(summary, row, newRow = true) {
+  summary.lastRowId = Math.max(summary.lastRowId, row.id);
+  if (newRow)
+    summary.rowCount += 1;
+  if (row.type === "tool" && typeof row.tool_owner_message_id !== "string")
+    summary.unownedToolRows.add(row.id);
+  else
+    summary.unownedToolRows.delete(row.id);
+  const owner = row.type === "tool" ? typeof row.tool_owner_message_id === "string" ? row.tool_owner_message_id : null : typeof row.message_id === "string" ? contentTagOwnerMessageId(row.message_id) : null;
+  if (owner) {
+    summary.maxTagByOwner.set(owner, Math.max(summary.maxTagByOwner.get(owner) ?? 0, row.tag_number));
+  }
+  if (row.type !== "message" || row.reasoning_token_count === null)
+    return;
+  const reasoningOwner = ownerMessageIdForTagRow({
+    type: row.type,
+    message_id: row.message_id,
+    tool_owner_message_id: row.tool_owner_message_id
+  });
+  for (const [ratio, estimates] of summary.reasoningEstimatesByRatio) {
+    estimates.set(reasoningOwner, Math.max(estimates.get(reasoningOwner) ?? 0, row.reasoning_token_count * ratio));
+  }
+}
+var TAG_OWNER_COLUMNS = "id, type, message_id, tool_owner_message_id, tag_number, reasoning_token_count";
+function connectionInTransaction(db) {
+  try {
+    const state = db;
+    return state.inTransaction !== false && state.isTransaction !== false;
+  } catch {
+    return true;
+  }
+}
+var 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 = ?`;
+function readTagIdentityRevision(db, sessionId) {
+  const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagIdentityRevisionKey(sessionId));
+  return typeof row?.value === "string" ? row.value : null;
+}
+function captureInitialTagOwnerRevision(db, sessionId, cached, appendedRows) {
+  if (cached.identityRevision !== null || appendedRows === 0)
+    return true;
+  const revision = readTagIdentityRevision(db, sessionId);
+  if (revision !== null && !/^[1-9]\d*:0$/.test(revision))
+    return false;
+  cached.identityRevision = revision;
+  return true;
+}
+function appendedSinceForeignCommit(db, sessionId, cached) {
+  tagOwnerShapeChecks += 1;
+  const rows = db.prepare(TAG_OWNER_APPENDED_WITH_SHAPE_SQL).all(cached.globalLastRowId, sessionId, tagIdentityRevisionKey(sessionId), sessionId);
+  const shape = rows.find((row) => row.shape === 1);
+  const appended = rows.filter((row) => row.shape === 0);
+  const highest = appended.reduce((max, row) => Math.max(max, row.id), cached.lastRowId);
+  if (!shape || (shape.revision ?? null) !== cached.identityRevision || shape.tag_count !== cached.rowCount + appended.length || (shape.max_id ?? 0) !== highest)
+    return null;
+  return appended;
+}
+function adoptedSinceForeignCommit(db, cached) {
+  if (cached.unownedToolRows.size === 0)
+    return [];
+  return db.prepare(`SELECT ${TAG_OWNER_COLUMNS} FROM tags
+             WHERE id IN (SELECT value FROM json_each(?)) AND tool_owner_message_id IS NOT NULL LIMIT ${TAG_OWNER_PAGE_LIMIT + 1}`).all(JSON.stringify([...cached.unownedToolRows]));
+}
+function readTagOwnerSummary(db, sessionId, proseRatio, extraRatios = []) {
+  const inTransaction = connectionInTransaction(db);
+  const versions = inTransaction ? null : db.prepare("SELECT data_version AS dataVersion, (SELECT schema_version FROM pragma_schema_version) AS schemaVersion FROM pragma_data_version").get();
+  const dataVersion = versions?.dataVersion ?? -1;
+  const schemaVersion = versions?.schemaVersion ?? -1;
+  const generation = getTagIdentityWriteGeneration();
+  const sessions = tagOwnerSummaries.get(db) ?? new Map;
+  const cached = inTransaction ? undefined : sessions.get(sessionId);
+  if (cached && (cached.generation === generation || cached.identityRevision === readTagIdentityRevision(db, sessionId)) && cached.schemaVersion === schemaVersion && (proseRatio === undefined || cached.reasoningEstimatesByRatio.has(proseRatio))) {
+    let rows;
+    let globalLastRowId = db.prepare("SELECT COALESCE(MAX(id), 0) AS id FROM tags").get().id;
+    if (cached.dataVersion === dataVersion && cached.generation === generation) {
+      const statement = db.prepare(`SELECT ${TAG_OWNER_COLUMNS} FROM tags WHERE id > ? AND +session_id = ? ORDER BY id LIMIT ${TAG_OWNER_PAGE_LIMIT + 1}`);
+      rows = statement.all(cached.globalLastRowId, sessionId);
+      let page = rows;
+      while (page.length === TAG_OWNER_PAGE_LIMIT + 1) {
+        page = statement.all(page[page.length - 1].id, sessionId);
+        rows.push(...page);
+      }
+      if (!captureInitialTagOwnerRevision(db, sessionId, cached, rows.length)) {
+        rows = null;
+      }
+    } else {
+      try {
+        globalLastRowId = db.prepare("SELECT COALESCE(MAX(id),0) AS id FROM tags").get().id;
+        rows = appendedSinceForeignCommit(db, sessionId, cached);
+        const adopted = rows ? adoptedSinceForeignCommit(db, cached) : [];
+        if (!rows || rows.length > TAG_OWNER_PAGE_LIMIT || adopted.length > TAG_OWNER_PAGE_LIMIT) {
+          rows = null;
+        } else {
+          tagOwnerRowsRead += rows.length + adopted.length;
+          for (const row of rows)
+            foldTagOwnerRow(cached, row);
+          for (const row of adopted)
+            foldTagOwnerRow(cached, row, false);
+          cached.dataVersion = dataVersion;
+          cached.generation = generation;
+          cached.globalLastRowId = globalLastRowId;
+          return cached;
+        }
+      } catch {
+        rows = null;
+      }
+    }
+    if (rows) {
+      const adopted = cached.dataVersion === dataVersion ? [] : adoptedSinceForeignCommit(db, cached);
+      tagOwnerRowsRead += rows.length + adopted.length;
+      for (const row of rows)
+        foldTagOwnerRow(cached, row);
+      for (const row of adopted)
+        foldTagOwnerRow(cached, row, false);
+      cached.dataVersion = dataVersion;
+      cached.generation = generation;
+      cached.globalLastRowId = globalLastRowId;
+      return cached;
+    }
+  }
+  const ratios = [
+    ...new Set([...cached?.reasoningEstimatesByRatio.keys() ?? [], ...extraRatios])
+  ];
+  if (proseRatio !== undefined && !ratios.includes(proseRatio))
+    ratios.push(proseRatio);
+  const summary = {
+    dataVersion,
+    schemaVersion,
+    generation,
+    lastRowId: 0,
+    globalLastRowId: db.prepare("SELECT COALESCE(MAX(id), 0) AS id FROM tags").get().id,
+    rowCount: 0,
+    unownedToolRows: new Set,
+    identityRevision: readTagIdentityRevision(db, sessionId),
+    maxTagByOwner: new Map,
+    reasoningEstimatesByRatio: new Map(ratios.slice(-MAX_CACHED_PROSE_RATIOS).map((ratio) => [ratio, new Map]))
+  };
+  const rows = db.prepare(`SELECT ${TAG_OWNER_COLUMNS} FROM tags WHERE session_id = ? ORDER BY id`).all(sessionId);
+  tagOwnerRowsRead += rows.length;
+  for (const row of rows)
+    foldTagOwnerRow(summary, row);
+  if (!inTransaction) {
+    sessions.set(sessionId, summary);
+    tagOwnerSummaries.set(db, sessions);
   }
-  return totals;
+  return summary;
 }
 function updateTagInputTokenCount(db, sessionId, tagNumber, newInputTokenCount) {
   getUpdateTagInputTokenCountStatement(db).run(newInputTokenCount, sessionId, tagNumber);
@@ -2278,7 +3176,7 @@ function getTagNumberByMessageIdStatement(db) {
 function getAssignableTagNumberByMessageIdStatement(db) {
   let stmt = getAssignableTagNumberByMessageIdStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare(`SELECT tag_number FROM tags
+    stmt = db.prepare(`SELECT tag_number FROM tags INDEXED BY idx_tags_session_message_id
              WHERE session_id = ?
                AND message_id = ?
                AND NOT (
@@ -2339,31 +3237,37 @@ function insertTag(db, sessionId, messageId, type, byteSize, tagNumber, reasonin
 function updateTagStatus(db, sessionId, tagId, status) {
   getUpdateTagStatusStatement(db).run(status, sessionId, tagId);
 }
-var inertWhitespaceStatements = new WeakMap;
-function getInertWhitespaceAssistantTags(db, sessionId, messageIds) {
-  if (messageIds) {
-    let statement = inertWhitespaceStatements.get(db);
-    if (!statement) {
-      statement = db.prepare(`SELECT tag_number AS tagNumber, entry_fingerprint AS entryFingerprint
-                 FROM json_each(?) AS owners CROSS JOIN tags
-                 WHERE tags.session_id = ? AND tags.type = 'message' AND tags.status = 'compacted'
-                   AND entry_fingerprint >= ? || owners.value || ':p'
-                   AND entry_fingerprint < ? || owners.value || ':q'
-                 ORDER BY CAST(owners.key AS INTEGER), entry_fingerprint, tags.id`);
-      inertWhitespaceStatements.set(db, statement);
-    }
-    const rows = statement.all(JSON.stringify([...new Set(messageIds)]), sessionId, WHITESPACE_ASSISTANT_INERT_FINGERPRINT_PREFIX, WHITESPACE_ASSISTANT_INERT_FINGERPRINT_PREFIX);
-    return rows.map((row) => ({
-      tagNumber: row.tagNumber,
-      contentId: row.entryFingerprint.slice(WHITESPACE_ASSISTANT_INERT_FINGERPRINT_PREFIX.length)
-    }));
+var droppedTagStatements = new WeakMap;
+function markTagDropped(db, sessionId, tagId, mode) {
+  if (!mode) {
+    updateTagStatus(db, sessionId, tagId, "dropped");
+    return;
   }
-  const rows = db.prepare(`SELECT tag_number AS tagNumber, entry_fingerprint AS entryFingerprint
-             FROM tags
-             WHERE session_id = ?
-               AND type = 'message'
-               AND status = 'compacted'
-               AND entry_fingerprint LIKE ?`).all(sessionId, `${WHITESPACE_ASSISTANT_INERT_FINGERPRINT_PREFIX}%`);
+  let statement = droppedTagStatements.get(db);
+  if (!statement) {
+    statement = db.prepare("UPDATE tags SET status = ?, drop_mode = ? WHERE session_id = ? AND tag_number = ?");
+    droppedTagStatements.set(db, statement);
+  }
+  statement.run("dropped", mode, sessionId, tagId);
+}
+var inertWhitespaceStatements = new WeakMap;
+var inertWhitespaceByNumberStatements = new WeakMap;
+function getInertWhitespaceAssistantTagsByNumbers(db, sessionId, tagNumbers) {
+  if (tagNumbers.length === 0)
+    return [];
+  let statement = inertWhitespaceByNumberStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`SELECT tags.tag_number AS tagNumber, tags.entry_fingerprint AS entryFingerprint
+             FROM json_each(?) AS wanted CROSS JOIN tags
+             WHERE tags.session_id = ?
+               AND tags.tag_number = wanted.value
+               AND tags.type = 'message'
+               AND tags.status = 'compacted'
+               AND tags.entry_fingerprint LIKE ?
+             ORDER BY tags.tag_number, tags.id`);
+    inertWhitespaceByNumberStatements.set(db, statement);
+  }
+  const rows = statement.all(JSON.stringify([...new Set(tagNumbers)]), sessionId, `${WHITESPACE_ASSISTANT_INERT_FINGERPRINT_PREFIX}%`);
   return rows.flatMap((row) => {
     const contentId = row.entryFingerprint.slice(WHITESPACE_ASSISTANT_INERT_FINGERPRINT_PREFIX.length);
     return contentId.length > 0 ? [{ tagNumber: row.tagNumber, contentId }] : [];
@@ -2562,13 +3466,54 @@ function findPiFallbackToolOwnerTags(db, sessionId) {
                     message_id AS callId,
                     tool_owner_message_id AS toolOwnerMessageId,
                     status
-             FROM tags
+             FROM json_each(?) prefix CROSS JOIN tags
              WHERE session_id = ?
-               AND type = 'tool'
-               AND tool_owner_message_id LIKE 'pi-msg-%'
-             ORDER BY tag_number ASC`).all(sessionId).filter(isPiFallbackToolOwnerTag);
+               AND tags.type = 'tool'
+                AND tool_owner_message_id >= prefix.value
+                AND tool_owner_message_id < substr(prefix.value, 1, 6) || '.'
+                AND tool_owner_message_id LIKE 'pi-msg-%'
+             ORDER BY tag_number ASC`).all(PI_FALLBACK_PREFIXES_JSON, sessionId).filter(isPiFallbackToolOwnerTag);
+}
+
+class PiTagIdentityConflictError extends Error {
+  code = "PI_TAG_IDENTITY_CONFLICT";
+  constructor(detail, kind = "tool") {
+    super(`Magic Context ${kind}-tag identity conflict: ${detail}. This turn was refused without sending raw history; resending alone will not repair it`);
+    this.name = "PiTagIdentityConflictError";
+  }
+}
+function selectPiTagSurvivor(rows, servedTagNumbers, cachedSurvivor, kind, rebuildingSurvivor) {
+  const served = rows.filter((row) => servedTagNumbers.has(row.tagNumber));
+  const cached = cachedSurvivor === undefined ? undefined : rows.find((row) => row.tagNumber === cachedSurvivor);
+  const rebuilding = rows.find((row) => row.tagNumber === rebuildingSurvivor);
+  const noProofInputs = served.length === 0 && cachedSurvivor === undefined;
+  if (cachedSurvivor !== undefined && !cached || served.length !== 1 && !cached && !rebuilding && !noProofInputs) {
+    throw new PiTagIdentityConflictError(served.length > 1 ? `Conflicting served Pi ${kind} tag numbers; no byte-safe cached survivor is proven` : `duplicate ${kind} tag identities have no proven served-byte survivor`, kind);
+  }
+  const kept = cached ?? rebuilding ?? served[0] ?? rows[1] ?? rows[0];
+  if (!kept)
+    throw new PiTagIdentityConflictError("no served survivor is proven", kind);
+  return kept;
+}
+function foldPiIdentityDuplicate(db, sessionId, kept, duplicate) {
+  const owesDrop = kept.status !== "dropped" && duplicate.status === "dropped";
+  foldDuplicateIntoSurvivor(db, sessionId, kept, duplicate, true, false);
+  if (owesDrop)
+    queuePendingOp(db, sessionId, kept.tagNumber, "drop");
+}
+function getPiMessageTagCandidates(db, sessionId, messageId) {
+  return getPiFallbackMessageFoldTagRowsByMessageId(db, sessionId, messageId);
+}
+function findPiTagIdentityConflict(error) {
+  const seen = new Set;
+  while (error instanceof Error && !seen.has(error)) {
+    if (error instanceof PiTagIdentityConflictError)
+      return error;
+    seen.add(error);
+    error = error.cause;
+  }
 }
-function adoptPiFallbackToolOwnerTag(db, sessionId, tagNumber, callId, oldOwnerMessageId, newOwnerMessageId, servedTagNumbers = new Set) {
+function adoptPiFallbackToolOwnerTag(db, sessionId, tagNumber, callId, oldOwnerMessageId, newOwnerMessageId, servedTagNumbers = new Set, cachedSurvivor, rebuildingSurvivor) {
   const survivor = getPiFallbackFoldTagRowByNumber(db, sessionId, tagNumber);
   if (survivor === null || survivor.type !== "tool" || survivor.messageId !== callId || survivor.toolOwnerMessageId !== oldOwnerMessageId) {
     return { action: "skipped" };
@@ -2587,22 +3532,21 @@ function adoptPiFallbackToolOwnerTag(db, sessionId, tagNumber, callId, oldOwnerM
   if (existing.tagNumber === tagNumber) {
     return { action: "skipped" };
   }
-  if (servedTagNumbers.has(survivor.tagNumber)) {
-    if (servedTagNumbers.has(existing.tagNumber)) {
-      throw new Error("Conflicting served Pi tool tag numbers; refusing identity adoption");
-    }
-    foldDuplicateIntoSurvivor(db, sessionId, survivor, existing);
+  const toolRows = [survivor, existing];
+  const kept = selectPiTagSurvivor(toolRows, servedTagNumbers, cachedSurvivor, "tool", rebuildingSurvivor);
+  if (kept.tagNumber === survivor.tagNumber) {
+    foldPiIdentityDuplicate(db, sessionId, survivor, existing);
     db.prepare("UPDATE tags SET tool_owner_message_id = ? WHERE session_id = ? AND tag_number = ?").run(newOwnerMessageId, sessionId, tagNumber);
     return { action: "folded", tagNumber, deletedTagNumbers: [existing.tagNumber] };
   }
-  foldDuplicateIntoSurvivor(db, sessionId, existing, survivor);
+  foldPiIdentityDuplicate(db, sessionId, existing, survivor);
   return {
     action: "folded",
     tagNumber: existing.tagNumber,
     deletedTagNumbers: [tagNumber]
   };
 }
-function adoptPiFallbackMessageTag(db, sessionId, tagNumber, oldFallbackMessageId, newRealMessageId, servedTagNumbers = new Set) {
+function adoptPiFallbackMessageTag(db, sessionId, tagNumber, oldFallbackMessageId, newRealMessageId, servedTagNumbers = new Set, cachedSurvivor, rebuildingSurvivor) {
   if (oldFallbackMessageId.startsWith(WHITESPACE_ASSISTANT_INERT_MESSAGE_PREFIX)) {
     return { action: "skipped" };
   }
@@ -2620,18 +3564,13 @@ function adoptPiFallbackMessageTag(db, sessionId, tagNumber, oldFallbackMessageI
                    AND message_id = ?`).run(newRealMessageId, sessionId, tagNumber, oldFallbackMessageId);
     return (result.changes ?? 0) > 0 ? { action: "rekeyed", tagNumber } : { action: "skipped" };
   }
-  const servedRows = [survivor, ...duplicates].filter((row) => servedTagNumbers.has(row.tagNumber));
-  if (servedRows.length > 1) {
-    throw new Error("Conflicting served Pi message tag numbers; refusing identity adoption");
-  }
-  const realSurvivor = servedRows[0] ?? duplicates[0];
-  if (!realSurvivor)
-    return { action: "skipped" };
+  const messageRows = [survivor, ...duplicates];
+  const realSurvivor = selectPiTagSurvivor(messageRows, servedTagNumbers, cachedSurvivor, "message", rebuildingSurvivor);
   const deletedTagNumbers = [];
-  for (const duplicate of [survivor, ...duplicates]) {
+  for (const duplicate of messageRows) {
     if (duplicate.tagNumber === realSurvivor.tagNumber)
       continue;
-    foldDuplicateIntoSurvivor(db, sessionId, realSurvivor, duplicate);
+    foldPiIdentityDuplicate(db, sessionId, realSurvivor, duplicate);
     deletedTagNumbers.push(duplicate.tagNumber);
   }
   if (realSurvivor.tagNumber === tagNumber) {
@@ -2774,7 +3713,7 @@ function getNewestToolTagNumbers(db, sessionId, limit) {
   let statement = newestToolTagNumberStatements.get(db);
   if (!statement) {
     statement = db.prepare(`SELECT tag_number FROM tags
-              WHERE session_id = ? AND type = 'tool'
+              WHERE session_id = ? AND +type = 'tool'
                 AND typeof(message_id) = 'text'
                 AND typeof(status) = 'text'
                 AND typeof(byte_size) IN ('integer', 'real')
@@ -3409,88 +4348,8 @@ function claimOpenCodeDbDiagnosticOnce(surface, resolution) {
   return true;
 }
 
-// ../plugin/src/hooks/magic-context/read-session-db.ts
-function openCodeDbExists() {
-  return harnessOwnsOpenCodeStore() && openCodeDbPathExists(resolveOpenCodeDbPath());
-}
-var cachedReadOnlyDb = null;
-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;
-}
-var trackedSessions = new Map;
-var pendingParts = new Map;
-var probeLogObserverForTests;
-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;
-}
-
 // ../plugin/src/hooks/magic-context/read-session-raw.ts
+import { isMainThread } from "node:worker_threads";
 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";
 function isRawMessageRow(row) {
   if (row === null || typeof row !== "object")
@@ -3521,6 +4380,25 @@ function isRawCompactionSummaryInfo(info) {
   const candidate = info;
   return candidate.summary === true && candidate.finish === "stop";
 }
+var RAW_METADATA_KEEP_CHARS = 16384;
+var RAW_METADATA_KEPT_KEYS = [
+  "description",
+  "title",
+  "userAnswer",
+  "answers",
+  "answer",
+  "selectedOptions",
+  "customInput",
+  "results"
+];
+var 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`;
 function parseJsonUnknown(value) {
   try {
     return JSON.parse(value);
@@ -3551,7 +4429,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)
@@ -3583,7 +4461,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)
@@ -3591,6 +4469,65 @@ function readRawSessionMessagePageFromDb(db, sessionId, afterOrdinal, limit, fin
   return assembleRawMessagePage(messageRows, partRows);
 }
 function readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWatermark, after) {
+  try {
+    return readRawMessagePageRowsBounded(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+  } catch (error) {
+    if (error !== ORDINALS_COLD)
+      throw error;
+    if (warmRawSessionOrdinalsForDb(db, sessionId)) {
+      try {
+        return readRawMessagePageRowsBounded(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+      } catch (retry) {
+        if (retry !== ORDINALS_COLD)
+          throw retry;
+      }
+    }
+    return readRawMessagePageRowsOffset(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+  }
+}
+var ORDINALS_COLD = Symbol("mmcCanonicalOrdinalsCold");
+function readRawMessagePageRowsBounded(db, sessionId, afterOrdinal, limit, finalWatermark, after) {
+  const remaining = Math.max(0, Math.floor(finalWatermark) - Math.floor(afterOrdinal));
+  const pageSize = Math.min(Math.max(1, Math.floor(limit)), remaining);
+  if (pageSize === 0)
+    return [];
+  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)
+      throw ORDINALS_COLD;
+    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)
+      throw ORDINALS_COLD;
+    return eligible.slice(skip, skip + pageSize).filter(isRawMessageRow).map((row, index) => ({
+      ...row,
+      ordinal: ordinal + index + 1
+    }));
+  });
+}
+var rawMessagePageRowsVisited = 0;
+function readRawMessagePageRowsOffset(db, sessionId, afterOrdinal, limit, finalWatermark, after) {
   const remaining = Math.max(0, Math.floor(finalWatermark) - Math.floor(afterOrdinal));
   const pageSize = Math.min(Math.max(1, Math.floor(limit)), remaining);
   if (pageSize === 0)
@@ -3682,6 +4619,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 = ?
@@ -3740,7 +4680,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));
@@ -3768,49 +4708,491 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
   }
   return { messages, absoluteMessageCount: Math.max(0, ord - 1) };
 }
-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;
+var ORDINAL_SUMMARY_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+        THEN COALESCE(json_extract(data, '$.summary'), 0)
+        ELSE 0 END = 1)`;
+var ORDINAL_STOP_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+        THEN COALESCE(json_extract(data, '$.finish'), '')
+        ELSE '' END = 'stop')`;
+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) <= (?, ?)`;
+}
+var ORDINAL_RANGE_FROM_START_SQL = ordinalRangeSql(false);
+var ORDINAL_RANGE_BETWEEN_SQL = ordinalRangeSql(true);
+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;
+  }
 }
-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 sameStoreStamp(left, right) {
+  return left !== null && right !== null && left.dataVersion === right.dataVersion && left.totalChanges === right.totalChanges && left.schemaVersion === right.schemaVersion;
+}
+var ordinalWatermarks = new WeakMap;
+var ordinalWatermarkEpochs = new Map;
+var ordinalRowsVisited = 0;
+var STABLE_STORE_ATTEMPTS = 3;
+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;
+}
+var EXCLUDED_ROW_SQL = `${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL}`;
+var SUMMARY_ANCHOR_SPAN = 256;
+var SUMMARY_ANCHOR_LIMIT = 64;
+var summaryCandidateSets = new WeakMap;
+var summaryCandidateEpochs = new Map;
+var writtenSummaryIds = new Map;
+var indexedCountUnsupported = new WeakSet;
+var ordinalJsonRowsRead = 0;
+var summaryFullScans = 0;
+var ANCHOR_ROWS_SQL = `SELECT rowid AS rid, id, 1 AS kind FROM message
+    WHERE rowid > (SELECT MAX(rowid) FROM message) - ${SUMMARY_ANCHOR_SPAN}`;
+var 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 = ?`;
+var 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 = ?`;
+var ANCHOR_CHECK_SQL = "SELECT rowid AS rid, id FROM message WHERE rowid IN (SELECT value FROM json_each(?))";
+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);
+}
+var ordinalCheckpoints = new WeakMap;
+var ordinalSummarySeeds = new WeakMap;
+var ORDINAL_LOOKUP_LIMIT = 512;
+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 warmRawSessionOrdinalsForDb(db, sessionId) {
+  if (isRawSessionSummaryWarm(db, sessionId))
+    return true;
+  try {
+    const epoch = getRawSessionSummaryEpoch(sessionId);
+    const scan = scanRawSessionSummaryRows(db, sessionId);
+    installRawSessionSummaryScan(db, sessionId, scan, epoch, true);
+  } catch {
+    return false;
   }
-  const info = parseJsonRecord(row.data);
-  if (!info || isRawCompactionSummaryInfo(info)) {
+  return isRawSessionSummaryWarm(db, sessionId);
+}
+function boundedOrdinalPrefix(db, sessionId, through) {
+  try {
+    return boundedOrdinalPrefixBounded(db, sessionId, through);
+  } catch (error) {
+    if (error !== ORDINALS_COLD)
+      throw error;
+    if (warmRawSessionOrdinalsForDb(db, sessionId)) {
+      try {
+        return boundedOrdinalPrefixBounded(db, sessionId, through);
+      } catch (retry) {
+        if (retry !== ORDINALS_COLD)
+          throw retry;
+      }
+    }
+    const bindings = [sessionId];
+    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 = ?${through ? " AND (time_created, id) <= (?, ?)" : ""}
+        ORDER BY time_created, id)`).all(...bindings);
+    ordinalRowsVisited += rows.length;
+    ordinalJsonRowsRead += rows.length;
+    return rows.reduce((sum, row) => sum + (row.excluded === 1 ? 0 : 1), 0);
+  }
+}
+function boundedOrdinalPrefixBounded(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)
+    throw ORDINALS_COLD;
+  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) && isMainThread)
+    return false;
+  if (isRawSessionSummaryWarm(db, sessionId))
+    return true;
+  let sessions = summaryCandidateSets.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    summaryCandidateSets.set(db, sessions);
+  }
+  sessions.set(sessionId, { epoch, anchors: [...scan.anchors], ids: new Set(scan.ids) });
+  return isRawSessionSummaryWarm(db, sessionId);
+}
+function isRawSessionSummaryWarm(db, sessionId) {
+  if (isMainThread && 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`;
+}
+var CANONICAL_COUNT_SQL = new Map;
+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 (isMainThread && 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;
   }
-  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;
+}
+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;
   }
@@ -3836,6 +5218,88 @@ function hasRawSessionMessageByIdFromDb(db, sessionId, messageId) {
     return readRawSessionMessageByIdFromDb(db, sessionId, messageId) !== null;
   return true;
 }
+var boundaryEndpointCaches = new WeakMap;
+
+// ../plugin/src/hooks/magic-context/read-session-db.ts
+function openCodeDbExists() {
+  return harnessOwnsOpenCodeStore() && openCodeDbPathExists(resolveOpenCodeDbPath());
+}
+var cachedReadOnlyDb = null;
+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;
+}
+var trackedSessions = new Map;
+var pendingParts = new Map;
+var probeLogObserverForTests;
+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;
+}
 
 // ../plugin/src/hooks/magic-context/read-session-true-raw-tokens.ts
 function completedToolArcCrossesBoundary(invOrdinal, resOrdinal, boundary) {
@@ -3974,7 +5438,7 @@ function callIdFromPart(part) {
   const state = isRecord(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 (!isRecord(part))
     return null;
   const type = partType(part);
@@ -3993,8 +5457,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") {
@@ -4003,7 +5467,7 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: args !== undefined,
       hasOutput: false,
-      inputText: args !== undefined ? stringValue(args) : "",
+      inputText: withText && args !== undefined ? stringValue(args) : "",
       outputText: ""
     };
   }
@@ -4013,7 +5477,7 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: input !== undefined,
       hasOutput: false,
-      inputText: input !== undefined ? stringValue(input) : "",
+      inputText: withText && input !== undefined ? stringValue(input) : "",
       outputText: ""
     };
   }
@@ -4024,7 +5488,7 @@ function toolSignalFromPart(part) {
       hasInput: false,
       hasOutput: content !== undefined,
       inputText: "",
-      outputText: content !== undefined ? textFromToolResultContent(content) : ""
+      outputText: withText && content !== undefined ? textFromToolResultContent(content) : ""
     };
   }
   return null;
@@ -4034,7 +5498,7 @@ function partCheapFingerprint(part) {
     return `${typeof part}:${recursiveByteLength(part)}`;
   const version = rawPartVersion(part);
   const type = typeof part.type === "string" ? part.type : "";
-  return `${type}:${String(version)}:${recursiveByteLength(part)}`;
+  return `${type}:${String(version)}:${recursiveByteLength(providerVisiblePart(part))}`;
 }
 function messageCacheKey(message, options) {
   const namespace = "cacheNamespace" in options ? options.cacheNamespace : "estimate";
@@ -4154,7 +5618,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) {
@@ -4514,11 +5978,11 @@ function containsDroppedInputPlaceholder(value) {
   };
   return visit(value);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return value !== null && typeof value === "object";
 }
 function isOptionalZodField(field) {
-  if (!isRecord2(field))
+  if (!isRecord3(field))
     return false;
   const isOptional = field.isOptional;
   if (typeof isOptional === "function") {
@@ -4530,10 +5994,10 @@ function isOptionalZodField(field) {
   return internals?.optin === "optional";
 }
 function toolParameterNames(schema) {
-  if (!isRecord2(schema))
+  if (!isRecord3(schema))
     return;
   const properties = schema.properties;
-  if (isRecord2(properties) && !Array.isArray(properties)) {
+  if (isRecord3(properties) && !Array.isArray(properties)) {
     const names = Object.keys(properties);
     const requiredList = Array.isArray(schema.required) ? schema.required : [];
     const required = new Set(requiredList.filter((name) => typeof name === "string"));
@@ -4548,7 +6012,7 @@ function toolParameterNames(schema) {
   } catch {
     shape = undefined;
   }
-  if (isRecord2(shape) && !Array.isArray(shape)) {
+  if (isRecord3(shape) && !Array.isArray(shape)) {
     const result = { required: [], optional: [] };
     for (const [name, field] of Object.entries(shape)) {
       (isOptionalZodField(field) ? result.optional : result.required).push(name);
@@ -4700,6 +6164,17 @@ function loadToolDefinitionMeasurements(db) {
 
 // ../plugin/src/hooks/magic-context/final-wire-token-estimate.ts
 var wireTextTokens = createTokenCountMemo(1e5, 128 * 1024 * 1024);
+function estimatePartImageTokens(raw) {
+  if (!raw || typeof raw !== "object")
+    return 0;
+  const part = raw;
+  if (part.ignored)
+    return 0;
+  if (part.type === "file" && part.mime?.startsWith("image/")) {
+    return typeof part.url === "string" && part.url.startsWith("data:") ? estimateImageTokensFromDataUrl(part.url) : 1200;
+  }
+  return part.type === "tool" ? estimateToolAttachmentImageTokens(part.state) : 0;
+}
 
 // ../plugin/src/features/magic-context/overflow-detection.ts
 var OVERFLOW_PATTERNS = [
@@ -5308,6 +6783,14 @@ function readRawSessionMessageRange2(sessionId, fromOrdinal, toOrdinal) {
 }
 readRawSessionMessages2.readPage = readRawSessionMessagePage2;
 readRawSessionMessages2.getCount = getRawSessionMessageOrdinalCount2;
+readRawSessionMessages2.prepare = prepareRawSessionOrdinals;
+async function prepareRawSessionOrdinals(sessionId) {
+  if (sessionProviders.get(sessionId)?.provider)
+    return true;
+  if (!openCodeDbExists())
+    return true;
+  return withReadOnlySessionDb((db) => warmRawSessionOrdinalsForDb(db, sessionId));
+}
 function primeTailRawMessageCache2(args) {
   const { sessionId, lastCompartmentEnd, anchorMessageId } = args;
   if (!activeRawMessageCache)
@@ -5459,6 +6942,7 @@ function readRawSessionMessageById2(sessionId, messageId) {
     return null;
   return withReadOnlySessionDb((db) => readRawSessionMessageByIdFromDb(db, sessionId, messageId));
 }
+readRawSessionMessageById2.prepare = prepareRawSessionOrdinals;
 function readRawSessionMessagesFromSource(sessionId) {
   const provider = sessionProviders.get(sessionId)?.provider;
   if (provider)
@@ -5839,6 +7323,14 @@ function readSessionChunk2(sessionId, tokenBudget, offset = 1, eligibleEndOrdina
     pinComponentWhenFormattedBudgetCrosses(msg.ordinal, text);
   }
   if (flushCurrentBlock() && pendingNoiseMeta.length > 0) {
+    const lastNoise = pendingNoiseMeta[pendingNoiseMeta.length - 1];
+    if (messagesProcessed > 0 && lastNoise) {
+      lineMeta.push(...pendingNoiseMeta);
+      messagesProcessed += pendingNoiseMeta.length;
+      lastOrdinal = lastNoise.ordinal;
+      lastMessageId = lastNoise.messageId;
+      pendingNoiseMeta = [];
+    }
     highestScannedOrdinal = Math.max(highestScannedOrdinal, pendingNoiseMeta[pendingNoiseMeta.length - 1]?.ordinal ?? highestScannedOrdinal);
   }
   const toolOnlyRanges = [];
@@ -5876,4 +7368,4 @@ function readSessionChunk2(sessionId, tokenBudget, offset = 1, eligibleEndOrdina
     toolResultBoundaries
   };
 }
-export { canonicalModelIdentity, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, toolTemplateError, DEFAULT_PROTECTED_TOOLS, normalizeProtectedToolName, mergeProtectedTools, detectThinkingBindingMismatch, detectLatestTurnThinkingMismatch, isPrefixBoundThinkingModel, detectOverflow, stableStringify, UNKNOWN_FIT_RATIO, resolveDecisionCalibration, hasMeasuredDecisionCalibration, providerMass, localBudget, calibrationForModelKey, historyLocalBudget, adoptedProtectedToolsPolicy, protectedToolTagNumbers, protectedToolTokenCount, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, preloadTokenizer, hasTokenizerForFit, tokenCountUsesByteBound, estimateTokens, estimateFixedPromptTokens, stripWellFormedLeadingTagPrefix, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isRecord, TEXT_TAG_IDENTITY_MARKER, contentTagOwnerMessageId, estimateImageTokensFromDataUrl, TODO_STATUSES, TODO_PRIORITIES, TITLE_DONE_STATUSES, normalizeTodoStateJson, buildSyntheticTodoPart, stripChannel1ReminderSpans, compareMeasuredTailPrefix, formatTailHygienePrefixMismatch, freezeTailHygieneMeasurement, effectiveTailHygiene, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, decideChannel1, evaluateChannel2, reclaimableToolOutputCount, buildChannel2Reminder, buildChannel1Reminder, planEmergencyDrop, measureEmergencyTag, closeQuietly, isKnownAutocommit, installV3PerfSchema, queuePendingOp, queuePendingDropForUnchangedTag, getPendingOps, getPendingOpsCount, clearPendingOps, removePendingOp, updateTagByteSize, getRecentTagOwnerMessageIds, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, updateTagInputByteSize, updateTagTokenCount, getPersistedToolTagAccounting, getAllStatusTagTokenTotalsFlat, getReasoningTokenEstimatesByMessage, updateTagInputTokenCount, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, getInertWhitespaceAssistantTags, updateTagDropMode, updateCavemanDepth, hasPiFallbackMessageTags, findAdoptableFallbackTags, hasPiFallbackToolOwnerTags, findPiFallbackToolOwnerTags, adoptPiFallbackToolOwnerTag, adoptPiFallbackMessageTag, getMaxTagNumberBySession, getTagNumberByMessageId, getAssignableTagNumberByMessageId, deriveTagLoadFloor, TAG_SELECT_COLUMNS, getTagsBySession, getActiveTagsBySession, getTagsForPendingOperations, getTagsByNumbers, getNewestToolTagNumbers, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getTagById, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, withReadOnlySessionDb, expandToolPart, retreatPastHostUnservedRows, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForCompletedToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, invalidateTrueRawTokenCache, stripSystemInjection, hasUserAnswerMetadata, droppedInputMarker, createDroppedInputGuard, isEditTool, applyEditMarkerToInput, setDatabase, loadToolDefinitionMeasurements, modelAcceptsEmptyContent, isAnthropicFamilyRoute, variantChangeBustsProviderCache, SKELETON_REAL_INPUT_MAX_BYTES, toolInputStringBytes, resolveHostServedBoundaryId2, hasRawMessageProvider2, setRawMessageProvider2, withRawMessageProvider2, cleanUserText2, withRawSessionMessageCache2, readRawSessionMessages2, readRawSessionMessagePage2, getRawSessionMessageOrdinalCount2, visitRawSessionMessages2, readRawSessionMessageRange2, primeTailRawMessageCache2, getCachedAbsoluteMessageCount2, primeInMemoryTailRawMessageCache2, readRawSessionMessageIdOrdinalsForRange2, hasRawSessionMessageById2, readRawSessionMessageOrdinalById2, compareRawSessionMessageOrder2, readRawSessionMessageById2, getRawSessionMessageCount2, getRawSessionTagKeysThrough2, getLegacyProtectedTailStartOrdinal2, readSessionChunk2 };
+export { canonicalModelIdentity, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, toolTemplateError, DEFAULT_PROTECTED_TOOLS, normalizeProtectedToolName, mergeProtectedTools, detectThinkingBindingMismatch, detectLatestTurnThinkingMismatch, isPrefixBoundThinkingModel, detectOverflow, stableStringify, UNKNOWN_FIT_RATIO, resolveDecisionCalibration, hasMeasuredDecisionCalibration, providerMass, localBudget, calibrationForModelKey, historyLocalBudget, adoptedProtectedToolsPolicy, protectedToolTagNumbers, protectedToolTokenCount, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, preloadTokenizer, hasTokenizerForFit, tokenCountUsesByteBound, estimateTokens, estimateFixedPromptTokens, stripWellFormedLeadingTagPrefix, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, rememberCurrentToolOutputCount, isRecord, TEXT_TAG_IDENTITY_MARKER, PI_FALLBACK_PREFIXES_JSON, contentTagOwnerMessageId, TailHygieneJsonMemo, piJsonHash, estimateImageTokensFromDataUrl, providerVisibleMessage, TODO_STATUSES, TODO_PRIORITIES, TITLE_DONE_STATUSES, normalizeTodoStateJson, buildSyntheticTodoPart, stripChannel1ReminderSpans, compareMeasuredTailPrefix, formatTailHygienePrefixMismatch, freezeTailHygieneMeasurement, effectiveTailHygiene, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, decideChannel1, evaluateChannel2, reclaimableToolOutputCount, buildChannel2Reminder, buildChannel1Reminder, planEmergencyDrop, measureEmergencyTag, closeQuietly, isKnownAutocommit, installV3PerfSchema, queuePendingOp, queuePendingDropForUnchangedTag, getPendingOps, getPendingOpsCount, clearPendingOps, removePendingOp, tagRevisionIncarnationSql, tagRevisionCountSql, tagRevisionKey, tagIdentityRevisionKey, TAG_INSERT_CONFLICT_ROWS, installTagIdentityRevisionTrigger, updateTagByteSize, getRecentTagOwnerMessageIds, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, updateTagInputByteSize, updateTagTokenCount, getPersistedToolTagAccounting, getAllStatusTagTokenTotalsFlat, getReasoningTokenEstimatesByMessage, updateTagInputTokenCount, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, markTagDropped, getInertWhitespaceAssistantTagsByNumbers, updateTagDropMode, updateCavemanDepth, hasPiFallbackMessageTags, findAdoptableFallbackTags, hasPiFallbackToolOwnerTags, findPiFallbackToolOwnerTags, PiTagIdentityConflictError, getPiMessageTagCandidates, findPiTagIdentityConflict, adoptPiFallbackToolOwnerTag, adoptPiFallbackMessageTag, getMaxTagNumberBySession, getTagNumberByMessageId, getAssignableTagNumberByMessageId, deriveTagLoadFloor, TAG_SELECT_COLUMNS, getTagsBySession, getActiveTagsBySession, getTagsForPendingOperations, getTagsByNumbers, getNewestToolTagNumbers, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getTagById, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, withReadOnlySessionDb, expandToolPart, retreatPastHostUnservedRows, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForCompletedToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, invalidateTrueRawTokenCache, stripSystemInjection, hasUserAnswerMetadata, droppedInputMarker, createDroppedInputGuard, isEditTool, applyEditMarkerToInput, setDatabase, loadToolDefinitionMeasurements, estimatePartImageTokens, modelAcceptsEmptyContent, isAnthropicFamilyRoute, variantChangeBustsProviderCache, SKELETON_REAL_INPUT_MAX_BYTES, toolInputStringBytes, resolveHostServedBoundaryId2, hasRawMessageProvider2, setRawMessageProvider2, withRawMessageProvider2, cleanUserText2, withRawSessionMessageCache2, readRawSessionMessages2, readRawSessionMessagePage2, getRawSessionMessageOrdinalCount2, visitRawSessionMessages2, readRawSessionMessageRange2, primeTailRawMessageCache2, getCachedAbsoluteMessageCount2, primeInMemoryTailRawMessageCache2, readRawSessionMessageIdOrdinalsForRange2, hasRawSessionMessageById2, readRawSessionMessageOrdinalById2, compareRawSessionMessageOrder2, readRawSessionMessageById2, getRawSessionMessageCount2, getRawSessionTagKeysThrough2, getLegacyProtectedTailStartOrdinal2, readSessionChunk2 };