@retaw106/mmc-oc 2.2.1 → 2.4.0

package/dist/{index-btp5tdc8.js → index-48e9znrc.js}

@@ -5,17 +5,30 @@ import {
   hasMeasuredDecisionCalibration,
   providerMass
 } from "./index-x37vg474.js";
+import {
+  getTagIdentityWriteGeneration
+} from "./index-dwh99z66.js";
 import {
   getHarness,
   sessionLog
-} from "./index-qbkzdkk0.js";
+} from "./index-k59af64t.js";
 import {
   isKnownAutocommit,
+  readRawSessionMessagesFromDb,
+  readRawSessionMessagePageFromDb,
+  readRawSessionMessageSummaryPageFromDb,
+  countRawSessionMessageOrdinalsFromDb,
+  readRawSessionMessageIdOrdinalsForRangeFromDb,
+  readRawSessionTailFromDb,
+  warmRawSessionOrdinalsForDb,
+  readRawSessionMessageOrdinalByIdFromDb,
+  readRawSessionMessageByIdFromDb,
+  hasRawSessionMessageByIdFromDb,
   openCodeDbExists,
   withReadOnlySessionDb,
   getRawSessionMessageCountFromDb,
   getMessageTimesFromOpenCodeDb
-} from "./index-ramz5kkm.js";
+} from "./index-ykq24x1n.js";
 
 // src/shared/protected-tools-policy.ts
 var DEFAULT_PROTECTED_TOOLS = {
@@ -67,7 +80,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";
 
 // src/shared/commit-detection.ts
 var HASH_HEX = "[0-9a-f]{7,12}";
@@ -92,6 +105,272 @@ function removeSystemReminders(text) {
   return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
 }
 
+// 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;
+}
+
 // src/hooks/magic-context/read-session-formatting.ts
 var MAX_COMMITS_PER_BLOCK = 5;
 function hasMeaningfulUserText2(parts) {
@@ -204,22 +483,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) {
@@ -379,7 +666,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;
@@ -500,10 +787,34 @@ function mergeCommitHashes(existing, next) {
 var encoder = new TextEncoder;
 var TAG_PREFIX_REGEX = /^(?:§\d+§\s*)+/;
 var MALFORMED_TAG_PREFIX_REGEX = /^(?:§\d+">§(?:\d+§)?\s*)+/;
+var DANGLING_TAG_GLOBAL_REGEX = /\u00a7\d+(?!\.\d)[^\s\u00a7\w.]?/g;
 var DANGLING_TAG_PREFIX_REGEX = /^(?:\u00a7\d+(?!\.\d)[^\s\u00a7\w.]?\s*)+/;
+var COMPLETE_TAG_PAIR_GLOBAL_REGEX = /\u00a7\d+\u00a7/g;
+var MALFORMED_TAG_GLOBAL_REGEX = /\u00a7\d+">(?:\u00a7(?:\d+\u00a7)?)?/g;
+var STRAY_SECTION_CHAR_REGEX = /\u00a7/g;
 function stripWellFormedLeadingTagPrefix(value) {
   return value.replace(/^(\u00a7\d+\u00a7\s*)+/, "");
 }
+function stripCompleteTagPairsGlobally(value) {
+  return value.replace(COMPLETE_TAG_PAIR_GLOBAL_REGEX, "");
+}
+function stripMalformedTagNotationGlobally(value) {
+  return value.replace(MALFORMED_TAG_GLOBAL_REGEX, "");
+}
+function stripDanglingTagNotationGlobally(value) {
+  return value.replace(DANGLING_TAG_GLOBAL_REGEX, "");
+}
+function stripTagSectionCharacters(value) {
+  return value.replace(STRAY_SECTION_CHAR_REGEX, "");
+}
+function stripPersistedAssistantText(value) {
+  let text = stripWellFormedLeadingTagPrefix(value);
+  text = stripCompleteTagPairsGlobally(text);
+  text = stripMalformedTagNotationGlobally(text);
+  text = stripDanglingTagNotationGlobally(text);
+  text = stripTagSectionCharacters(text);
+  return text.trim();
+}
 function byteSize(value) {
   return encoder.encode(value).length;
 }
@@ -536,6 +847,21 @@ function isThinkingPart(part) {
   return candidate.type === "thinking" || candidate.type === "reasoning";
 }
 
+// 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)
+  });
+}
+function currentReclaimableToolOutputCount(baseline) {
+  if (!baseline || !Object.hasOwn(baseline, CURRENT_OUTPUT_COUNT))
+    return 0;
+  return baseline[CURRENT_OUTPUT_COUNT];
+}
 // src/shared/record-type-guard.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -543,15 +869,34 @@ function isRecord(value) {
 
 // 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)
@@ -560,10 +905,38 @@ 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 stableStringifyHash(value, prefix = "") {
+  const sink = jsonHashSink(prefix);
+  writeStable(value, new WeakSet, sink.write);
+  return sink.digest();
+}
+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") };
 }
 
 // src/shared/tag-owner-id.ts
+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) {
@@ -576,6 +949,127 @@ function contentTagOwnerMessageId(contentId) {
   return contentId;
 }
 
+// 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);
+}
+
 // src/hooks/magic-context/image-token-estimate.ts
 var IMAGE_TOKEN_DIVISOR = 750;
 var IMAGE_FALLBACK_TOKENS = 1200;
@@ -768,6 +1262,151 @@ function readUint32BE(b, offset) {
   return (b[offset] << 24 | b[offset + 1] << 16 | b[offset + 2] << 8 | b[offset + 3]) >>> 0;
 }
 
+// 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 tailProviderVisibleToolState(state, openCode1) {
+  const view = {};
+  for (const key of Object.keys(state)) {
+    if (tailToolStateFieldIsKept(key, openCode1)) {
+      view[key] = state[key];
+    } else if (key === "time" && openCode1) {
+      const value = state.time;
+      if (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" && openCode1 && state.status === "error") {
+      const metadata = state.metadata;
+      if (isRecord2(metadata) && metadata.interrupted === true) {
+        const output = metadata.output;
+        if (typeof output === "string")
+          view.metadata = { interrupted: true, output };
+      }
+    }
+  }
+  return view;
+}
+function tailToolStateFieldIsKept(key, openCode1) {
+  return KEPT_TOOL_STATE_FIELDS.has(key) && (key !== "content" || !openCode1);
+}
+function tailToolStateIsReduced(state, openCode1) {
+  for (const key of Object.keys(state)) {
+    if (tailToolStateFieldIsKept(key, openCode1))
+      continue;
+    return false;
+  }
+  return true;
+}
+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) };
+}
+function providerVisiblePartForTailHygiene(part) {
+  return providerVisiblePartForHost(part, true);
+}
+function providerVisiblePartForOpenCode2(part) {
+  return providerVisiblePartForHost(part, false);
+}
+function providerVisiblePartForHost(part, openCode1) {
+  if (!isRecord2(part))
+    return part;
+  if (part.type !== "tool") {
+    if (!Object.hasOwn(part, "state"))
+      return part;
+    const view = {};
+    for (const key of Object.keys(part)) {
+      if (key !== "state")
+        view[key] = part[key];
+    }
+    return view;
+  }
+  if (!isRecord2(part.state))
+    return part;
+  if (tailToolStateIsReduced(part.state, openCode1))
+    return part;
+  return { ...part, state: tailProviderVisibleToolState(part.state, openCode1) };
+}
+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 providerVisibleMessageForTailHygiene(message) {
+  return projectMessage(message, providerVisiblePartForTailHygiene);
+}
+function providerVisibleMessageForOpenCode2(message) {
+  return projectMessage(message, providerVisiblePartForOpenCode2);
+}
+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;
+}
+
 // src/hooks/magic-context/todo-view.ts
 import { createHash } from "node:crypto";
 var TODO_STATUS_PENDING = "pending";
@@ -885,7 +1524,7 @@ function isTodoItem(value) {
 
 // src/hooks/magic-context/tail-hygiene-walk.ts
 var MAX_CONTENT_MEMO_ENTRIES = 1e5;
-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 contentMemoBytes = 0;
@@ -1069,41 +1708,46 @@ function stripChannel1ReminderSpans(output) {
   return stripped;
 }
 function isDropSentinel(content) {
-  const stripped = content.trimStart().replace(TAG_PREFIX, "").trimStart().toLowerCase();
-  return DROP_PREFIXES.some((prefix) => stripped.startsWith(prefix));
-}
-function toolOutputText(part) {
+  let stripped = content.trimStart();
+  const tag = TAG_PREFIX.exec(stripped);
+  if (tag)
+    stripped = stripped.slice(tag[0].length).trimStart();
+  return DROP_PREFIXES.some((prefix) => stripped.slice(0, prefix.length).toLowerCase() === prefix);
+}
+function toolOutputText(part, key) {
+  const serialize = (value) => partJsonMemo.get(key, value, () => safeStableStringify(value));
   if (part.type === "tool") {
     const state = isRecord(part.state) ? part.state : null;
     if (!state)
       return null;
     if (state.output !== undefined)
-      return safeStableStringify(state.output);
+      return serialize(state.output);
     if (state.error !== undefined)
-      return safeStableStringify(state.error);
+      return serialize(state.error);
     if (state.result !== undefined)
-      return safeStableStringify(state.result);
+      return serialize(state.result);
     return null;
   }
   if (part.type === "tool_result") {
     const value = part.content ?? part.output ?? part.result;
-    return value === undefined ? null : safeStableStringify(value);
+    return value === undefined ? null : serialize(value);
   }
   return null;
 }
-function toolInputText(part) {
+function toolInputText(part, key) {
+  const serialize = (value) => partJsonMemo.get(key, value, () => safeStableStringify(value));
   if (part.type === "tool") {
     const state = isRecord(part.state) ? part.state : null;
     if (!state || state.input === undefined)
       return null;
-    return safeStableStringify(state.input);
+    return serialize(state.input);
   }
   if (part.type === "tool-invocation") {
     const value = part.args ?? part.input;
-    return value === undefined ? null : safeStableStringify(value);
+    return value === undefined ? null : serialize(value);
   }
   if (part.type === "tool_use") {
-    return part.input === undefined ? null : safeStableStringify(part.input);
+    return part.input === undefined ? null : serialize(part.input);
   }
   return null;
 }
@@ -1114,8 +1758,8 @@ function messageIdForTag(tag) {
 }
 function resolveProtectedTagNumbers(tags, protectedTagNumbersInput, protectedToolTags) {
   const protectedNumbers = new Set(protectedTagNumbersInput);
-  const protectedExemplars = protectedToolTags ?? protectedToolTagNumbers(tags);
-  for (const tagNumber of protectedExemplars)
+  const protectedCtxReduceTags = protectedToolTags ?? protectedToolTagNumbers(tags);
+  for (const tagNumber of protectedCtxReduceTags)
     protectedNumbers.add(tagNumber);
   return protectedNumbers;
 }
@@ -1230,17 +1874,28 @@ function snapshot(args) {
     queuedForDrop
   };
 }
+var partJsonMemo = new TailHygieneJsonMemo;
 function excludedSnapshot(key, part) {
-  const content = safeStableStringify(part);
-  return snapshot({
+  const contentHash = partJsonMemo.get(key, part, () => {
+    if (part === null || part === undefined || typeof part === "string")
+      return memoizedContent("excluded", safeStableStringify(part)).hash;
+    try {
+      return stableStringifyHash(part, "excluded\x00");
+    } catch {
+      return memoizedContent("excluded", String(part)).hash;
+    }
+  }, true);
+  return {
     key,
+    contentHash,
     kind: "excluded",
-    content,
     tokens: 0,
-    tag: undefined,
-    protectedNumbers: new Set,
-    pendingDropTagNumbers: new Set
-  });
+    uTokens: 0,
+    tagNumber: null,
+    tagStatus: null,
+    protected: false,
+    queuedForDrop: false
+  };
 }
 function fileContentAndTokens(part) {
   const mime = typeof part.mime === "string" ? part.mime : "";
@@ -1280,12 +1935,12 @@ function structuralSize(value) {
   }
   return 0;
 }
-function tailHygieneStructuralSignature(messages) {
+function tailHygieneStructuralSignature(messages, opencode2 = false) {
   const partCounts = [];
   let totalBytes = 0;
   for (const message of messages) {
     partCounts.push(message.parts.length);
-    totalBytes += structuralSize(message);
+    totalBytes += structuralSize(opencode2 ? providerVisibleMessageForOpenCode2(message) : providerVisibleMessageForTailHygiene(message));
   }
   return { messageCount: messages.length, partCounts, totalBytes };
 }
@@ -1299,10 +1954,22 @@ function measureTailHygiene(input) {
   return measureWithReplay(input);
 }
 function measureWithReplay(input, replay) {
+  partJsonMemo.beginPass();
+  const projectPart = input.opencode2 ? providerVisiblePartForOpenCode2 : providerVisiblePartForTailHygiene;
+  const views = new WeakMap;
+  const excluded = (key, part) => {
+    let view = part !== null && typeof part === "object" ? views.get(part) : undefined;
+    if (view === undefined) {
+      view = projectPart(part);
+      if (part !== null && typeof part === "object")
+        views.set(part, view);
+    }
+    return excludedSnapshot(key, view);
+  };
   const pendingDropTagNumbers = input.pendingDropTagNumbers ?? new Set;
   const unchanged = input.messages.map((message, index) => {
     const previous = replay?.messages[index];
-    return previous !== undefined && sameReplayMessage(previous, message);
+    return previous !== undefined && sameReplayMessage(previous, message, projectPart);
   });
   const toolIdentities = collectToolPartIdentities(input.messages);
   const attribution = buildTagAttribution({
@@ -1312,7 +1979,7 @@ function measureWithReplay(input, replay) {
     protectedTagNumbers: input.protectedTagNumbers,
     protectedToolTags: input.protectedToolTags
   });
-  const toolOutputs = input.messages.map((message, index) => message.parts.map((part, partIndex) => unchanged[index] ? replay?.measured.toolOutputs[index][partIndex] ?? null : isRecord(part) ? toolOutputText(part) : null));
+  const toolOutputs = input.messages.map((message, index) => message.parts.map((part, partIndex) => unchanged[index] ? replay?.measured.toolOutputs[index][partIndex] ?? null : isRecord(part) ? toolOutputText(part, `${messageIdentity(message, index)}\x00${partIndex}\x00output`) : null));
   const outputByPart = new Map;
   input.messages.forEach((message, index) => {
     message.parts.forEach((part, partIndex) => {
@@ -1378,19 +2045,19 @@ function measureWithReplay(input, replay) {
       const part = message.parts[partIndex];
       const key = `${messageKey}\x00${partIndex}`;
       if (messageSynthetic || isSyntheticPart(part) || !isRecord(part)) {
-        parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+        parts.push(excluded(`${key}\x00excluded`, part));
         continue;
       }
       const type = typeof part.type === "string" ? part.type : "";
       if (type === "reasoning" || type === "thinking" || type === "redacted_thinking" || type === "signature") {
-        parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+        parts.push(excluded(`${key}\x00excluded`, part));
         continue;
       }
       if (type === "text") {
         const rawContent = firstString(part, ["text", "content"]);
         const content = rawContent === null ? null : stripChannel1ReminderSpans(rawContent);
         if (!content || isDropSentinel(content)) {
-          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          parts.push(excluded(`${key}\x00excluded`, part));
           continue;
         }
         const tokens = memoizedTokens("text", content);
@@ -1412,7 +2079,7 @@ function measureWithReplay(input, replay) {
       if (type === "file" || type.includes("image") || type === "source") {
         const file = fileContentAndTokens(part);
         if (!file.content || isDropSentinel(file.content)) {
-          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          parts.push(excluded(`${key}\x00excluded`, part));
           continue;
         }
         const tag = attribution.messageTags.get(`${message.info.id}:file${partIndex}`);
@@ -1434,11 +2101,11 @@ function measureWithReplay(input, replay) {
       if (toolIdentity) {
         const ownerKey = `${toolIdentity.ownerMessageId}\x00${toolIdentity.callId}`;
         if (droppedToolOwners.has(ownerKey)) {
-          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          parts.push(excluded(`${key}\x00excluded`, part));
           continue;
         }
         const tag = attribution.toolTagsByPart.get(part);
-        const inputText = toolInputText(part);
+        const inputText = toolInputText(part, `${key}\x00input`);
         if (inputText !== null) {
           const tokens = memoizedTokens("toolInput", inputText);
           const measured = snapshot({
@@ -1458,7 +2125,7 @@ function measureWithReplay(input, replay) {
         if (rawOutput !== null) {
           const output = stripChannel1ReminderSpans(rawOutput);
           if (isDropSentinel(output)) {
-            parts.push(excludedSnapshot(`${key}\x00excludedOutput`, output));
+            parts.push(excluded(`${key}\x00excludedOutput`, output));
           } else {
             const tokens = memoizedTokens("toolOutput", output) + (part.type === "tool" ? estimateToolAttachmentImageTokens(part.state) : 0);
             const measured = snapshot({
@@ -1476,11 +2143,11 @@ function measureWithReplay(input, replay) {
           }
         }
         if (inputText === null && rawOutput === null) {
-          parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+          parts.push(excluded(`${key}\x00excluded`, part));
         }
         continue;
       }
-      parts.push(excludedSnapshot(`${key}\x00excluded`, part));
+      parts.push(excluded(`${key}\x00excluded`, part));
     }
   }
   return {
@@ -1621,16 +2288,19 @@ function sameNumbers(before, after) {
       return false;
   return true;
 }
-function sameReplayMessage(left, right) {
-  return left.info.id === right.info.id && left.info.role === right.info.role && left.info.summary === right.info.summary && sameReplayValue(left.parts, right.parts);
+function sameReplayMessage(left, right, projectPart = providerVisiblePartForTailHygiene) {
+  return left.info.id === right.info.id && left.info.role === right.info.role && left.info.summary === right.info.summary && sameReplayValue(left.parts, right.parts.map(projectPart));
 }
-function sameReplayMessages(before, after) {
+function replaySnapshotParts(parts, projectPart = providerVisiblePartForTailHygiene) {
+  return copyReplayValue(parts.map(projectPart));
+}
+function sameReplayMessages(before, after, projectPart = providerVisiblePartForTailHygiene) {
   if (before.length !== after.length)
     return false;
   for (let index = 0;index < before.length; index += 1) {
     const left = before[index];
     const right = after[index];
-    if (!sameReplayMessage(left, right))
+    if (!sameReplayMessage(left, right, projectPart))
       return false;
   }
   return true;
@@ -1689,8 +2359,10 @@ function refreshTailHygieneBaseline(input) {
     protectedTagNumbers: new Set([...input.protectedTagNumbers, ...protectedToolTags])
   };
   const pendingDropTagNumbers = input.pendingDropTagNumbers ?? new Set;
-  const cached = input.previous ? baselineMeasurementMemo.get(input.previous.baselineParts) : undefined;
-  const hit = !input.cacheBusting && cached && sameReplayMessages(cached.messages, input.messages) && sameReplayValue(cached.tags, input.tags) && sameNumbers(cached.protectedTagNumbers, input.protectedTagNumbers) && sameNumbers(cached.pendingDropTagNumbers, pendingDropTagNumbers);
+  const priorMemo = input.previous ? baselineMeasurementMemo.get(input.previous.baselineParts) : undefined;
+  const cached = priorMemo?.opencode2 === !!input.opencode2 ? priorMemo : undefined;
+  const projectPart = input.opencode2 ? providerVisiblePartForOpenCode2 : providerVisiblePartForTailHygiene;
+  const hit = !input.cacheBusting && cached && sameReplayMessages(cached.messages, input.messages, projectPart) && sameReplayValue(cached.tags, input.tags) && sameNumbers(cached.protectedTagNumbers, input.protectedTagNumbers) && sameNumbers(cached.pendingDropTagNumbers, pendingDropTagNumbers);
   const rawMeasured = hit ? cached.measured : measureWithReplay(input, cached);
   const frozenCalibration = !input.cacheBusting && input.previous ? {
     toolsRatio: input.previous.toolsRatio,
@@ -1710,19 +2382,20 @@ function refreshTailHygieneBaseline(input) {
     })
   };
   const memo = hit ? cached : {
-    messages: input.messages.map((message, index) => cached?.messages[index] && sameReplayMessage(cached.messages[index], message) ? cached.messages[index] : {
+    opencode2: !!input.opencode2,
+    messages: input.messages.map((message, index) => cached?.messages[index] && sameReplayMessage(cached.messages[index], message, projectPart) ? cached.messages[index] : {
       info: {
         id: message.info.id,
         role: message.info.role,
         summary: message.info.summary
       },
-      parts: copyReplayValue(message.parts)
+      parts: replaySnapshotParts(message.parts, projectPart)
     }),
     tags: structuredClone(input.tags),
     protectedTagNumbers: new Set(input.protectedTagNumbers),
     pendingDropTagNumbers: new Set(pendingDropTagNumbers),
     measured: rawMeasured,
-    size: 2 * structuralSize(input.messages) + 512 * input.tags.length
+    size: 2 * structuralSize(input.messages.map(input.opencode2 ? providerVisibleMessageForOpenCode2 : providerVisibleMessageForTailHygiene)) + 512 * input.tags.length
   };
   if (!hit) {
     const owners = new Map;
@@ -1739,8 +2412,9 @@ function refreshTailHygieneBaseline(input) {
   const refrozen = (mismatch) => {
     const frozen = freezeTailHygieneMeasurement(measured);
     retainBaselineMeasurement(frozen.baselineParts, memo);
-    return {
+    return rememberCurrentToolOutputCount({
       ...frozen,
+      protectedToolsPolicy,
       hygieneUnitsVersion: frozenCalibration.hygieneUnitsVersion,
       toolsRatio: frozenCalibration.toolsRatio,
       proseRatio: frozenCalibration.proseRatio,
@@ -1750,9 +2424,8 @@ function refreshTailHygieneBaseline(input) {
       generationInvalidated: false,
       contentSignature: measured.contentSignature,
       channel1PostReduceGrace: input.previous?.channel1PostReduceGrace,
-      lastPrefixMismatch: mismatch,
-      protectedToolsPolicy
-    };
+      lastPrefixMismatch: mismatch
+    }, measured);
   };
   if (input.cacheBusting || !input.previous)
     return refrozen();
@@ -1768,7 +2441,7 @@ function refreshTailHygieneBaseline(input) {
     if (part.kind !== "toolOutput" || !part.protected)
       turnDeltaU += part.uTokens;
   }
-  return {
+  return rememberCurrentToolOutputCount({
     ...input.previous,
     protectedToolsPolicy,
     turnDeltaU,
@@ -1777,7 +2450,7 @@ function refreshTailHygieneBaseline(input) {
     generationInvalidated: false,
     contentSignature: measured.contentSignature,
     lastPrefixMismatch: undefined
-  };
+  }, measured);
 }
 function effectiveTailHygiene(baseline) {
   const t = Math.ceil(Math.max(0, baseline.baselineT + baseline.turnDeltaT));
@@ -2049,7 +2722,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));
@@ -2392,6 +3065,117 @@ function removePendingOp(db, sessionId, tagId) {
   getRemovePendingOpStatement(db).run(sessionId, tagId);
 }
 
+// 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_TOMBSTONE_OWNER_PREFIX = "tag_revision_owner:";
+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 tagTombstoneOwnerRange(sessionId) {
+  const stem = `${TAG_TOMBSTONE_OWNER_PREFIX}${JSON.stringify(sessionId)}`;
+  return [`${stem}:`, `${stem};`];
+}
+function tagTombstoneOwnerKey(sessionId, harness) {
+  return `${tagTombstoneOwnerRange(sessionId)[0]}${harness}`;
+}
+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;`);
+}
+function deleteTagIdentityRevisions(db, sessionIds) {
+  const statement = db.prepare(`INSERT INTO schema_migrations_meta (key, value) VALUES (?, '1')
+         ON CONFLICT(key) DO UPDATE SET value = ${ADVANCE()}`);
+  for (const sessionId of sessionIds) {
+    statement.run(tagIdentityRevisionKey(sessionId));
+  }
+}
+
 // src/features/magic-context/storage-tags.ts
 var insertTagStatements = new WeakMap;
 var updateTagStatusStatements = new WeakMap;
@@ -2610,8 +3394,41 @@ function getActiveTagTokenTotalsByMessage(db, sessionId, messageIds) {
 }
 var updateTagTokenCountStatements = new WeakMap;
 var updateTagInputTokenCountStatements = new WeakMap;
-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
@@ -2624,6 +3441,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);
@@ -2638,15 +3457,199 @@ 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;
+}
+function tryGetReasoningTokenEstimatesByMessage(db, sessionId, ratio) {
+  try {
+    return getReasoningTokenEstimatesByMessage(db, sessionId, ratio);
+  } catch (error) {
+    if (error instanceof TagOwnerSummaryNotReady)
+      return;
+    throw error;
+  }
+}
+function getMaxTagNumberByOwnerMessage(db, sessionId) {
+  return readTagOwnerSummary(db, sessionId).maxTagByOwner;
+}
+var tagOwnerSummaries = new WeakMap;
+var MAX_CACHED_PROSE_RATIOS = 4;
+var TAG_OWNER_PAGE_LIMIT = 512;
+
+class TagOwnerSummaryNotReady extends Error {
+  constructor() {
+    super("tag owner summary needs off-thread preparation");
+  }
+}
+function scanTagOwnerSummary(db, sessionId, ratio, ratios = []) {
+  db.exec("BEGIN");
+  try {
+    return readTagOwnerSummary(db, sessionId, ratio, ratios);
+  } finally {
+    db.exec("ROLLBACK");
+  }
+}
+function isTagOwnerSummaryReady(db, sessionId, ratio) {
+  try {
+    readTagOwnerSummary(db, sessionId, ratio);
+    return true;
+  } catch (error) {
+    if (error instanceof TagOwnerSummaryNotReady)
+      return false;
+    throw error;
+  }
+}
+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 tagTokenCountIsNull(db, sessionId, tagNumber) {
   const row = db.prepare("SELECT token_count FROM tags WHERE session_id = ? AND tag_number = ?").get(sessionId, tagNumber);
@@ -2689,7 +3692,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 (
@@ -2750,6 +3753,19 @@ function insertTag(db, sessionId, messageId, type, byteSize, tagNumber, reasonin
 function updateTagStatus(db, sessionId, tagId, status) {
   getUpdateTagStatusStatement(db).run(status, sessionId, tagId);
 }
+var droppedTagStatements = new WeakMap;
+function markTagDropped(db, sessionId, tagId, mode) {
+  if (!mode) {
+    updateTagStatus(db, sessionId, tagId, "dropped");
+    return;
+  }
+  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;
 function markWhitespaceAssistantTagInert(db, sessionId, tagNumber, contentId) {
   db.prepare(`UPDATE tags
@@ -2787,6 +3803,28 @@ function getInertWhitespaceAssistantTags(db, sessionId, messageIds) {
     return contentId.length > 0 ? [{ tagNumber: row.tagNumber, contentId }] : [];
   });
 }
+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 }] : [];
+  });
+}
 function updateTagDropMode(db, sessionId, tagNumber, dropMode) {
   getUpdateTagDropModeStatement(db).run(dropMode, sessionId, tagNumber);
 }
@@ -3013,7 +4051,8 @@ function markTagsCompactedByMessageIds(db, sessionId, messageIds, eligibleTagNum
             SELECT value AS source_id, lower(value) AS folded_id FROM json_each(?)
         )
         SELECT id, tag_number, message_id, tool_owner_message_id FROM tags INDEXED BY ${tagOrderConstraintIndex(db)}
-        WHERE session_id = ? AND status IN ('active', 'dropped') AND (
+        WHERE session_id = ? ${eligibleTagNumbers ? "AND tag_number IN (SELECT value FROM json_each(?))" : ""}
+        AND status IN ('active', 'dropped') AND (
             message_id IN (SELECT source_id FROM ids)
             OR tool_owner_message_id IN (SELECT source_id FROM ids)
             OR (instr(lower(message_id), ':p') > 0 AND
@@ -3022,8 +4061,8 @@ function markTagsCompactedByMessageIds(db, sessionId, messageIds, eligibleTagNum
                 lower(substr(message_id, 1, instr(lower(message_id), ':file') - 1)) IN (SELECT folded_id FROM ids))
             OR (? AND instr(message_id, ':') > 0)
             OR ?
-        )`).all(JSON.stringify(Array.from(ids)), sessionId, Array.from(ids).some((id) => id.includes(":")) ? 1 : 0, nulPrefixes.size > 0 ? 1 : 0);
-  const candidates = rows.filter((row) => (eligibleTagNumbers === undefined || eligibleTagNumbers.has(row.tag_number)) && matches(row.message_id, row.tool_owner_message_id));
+        )`).all(JSON.stringify(Array.from(ids)), sessionId, ...eligibleTagNumbers ? [JSON.stringify([...eligibleTagNumbers])] : [], Array.from(ids).some((id) => id.includes(":")) ? 1 : 0, nulPrefixes.size > 0 ? 1 : 0);
+  const candidates = rows.filter((row) => matches(row.message_id, row.tool_owner_message_id));
   if (candidates.length === 0)
     return 0;
   const update = db.prepare(`UPDATE tags SET status = 'compacted'
@@ -3177,7 +4216,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')
@@ -3685,423 +4724,6 @@ function isHostRenderedSystemMessage(message) {
   return (typeof id !== "string" || id.length === 0) && message.info.role === "system";
 }
 
-// src/hooks/magic-context/read-session-raw.ts
-function isStrictGapHealingMessage(message) {
-  if (message.storeType === "synthetic")
-    return true;
-  let sawTool = false;
-  for (const part of message.parts) {
-    if (!part || typeof part !== "object" || Array.isArray(part))
-      return false;
-    const record = part;
-    const type = typeof record.type === "string" ? record.type : "";
-    if (type === "tool" || type === "tool_use" || type === "tool_result") {
-      sawTool = true;
-      continue;
-    }
-    const text = typeof record.text === "string" ? record.text : typeof record.content === "string" ? record.content : "";
-    if (text.trim().length > 0 || type.length > 0)
-      return false;
-  }
-  return sawTool;
-}
-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")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "string" && typeof candidate.data === "string";
-}
-function isRawPartRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.message_id === "string" && typeof candidate.data === "string";
-}
-function parseJsonRecord(value) {
-  try {
-    const parsed = JSON.parse(value);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isRawCompactionSummaryInfo(info) {
-  if (info === null || typeof info !== "object" || Array.isArray(info))
-    return false;
-  const candidate = info;
-  return candidate.summary === true && candidate.finish === "stop";
-}
-function parseJsonUnknown(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return null;
-  }
-}
-function attachRawPartVersion(value, timeUpdated) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return value;
-  if (typeof timeUpdated !== "number")
-    return value;
-  try {
-    Object.defineProperty(value, "__magicContextPartUpdatedAt", {
-      value: timeUpdated,
-      enumerable: false,
-      configurable: true
-    });
-  } catch {}
-  return value;
-}
-function readRawSessionMessagesFromDb(db, sessionId) {
-  const messageRows = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
-  const partsByMessageId = new Map;
-  const partMessageBatchSize = 128;
-  for (let offset = 0;offset < messageRows.length; offset += partMessageBatchSize) {
-    const messageIds = messageRows.slice(offset, offset + partMessageBatchSize).map((row) => row.id);
-    if (messageIds.length === 0)
-      continue;
-    const placeholders = messageIds.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 message_id ASC, time_created ASC, id ASC`).all(sessionId, ...messageIds).filter(isRawPartRow);
-    for (const part of partRows) {
-      const list = partsByMessageId.get(part.message_id) ?? [];
-      list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
-      partsByMessageId.set(part.message_id, list);
-    }
-  }
-  const filtered = messageRows.filter((row) => !isRawCompactionSummaryInfo(parseJsonRecord(row.data)));
-  return filtered.flatMap((row, index) => {
-    const info = parseJsonRecord(row.data);
-    if (!info)
-      return [];
-    const role = typeof info.role === "string" ? info.role : "unknown";
-    return {
-      ordinal: index + 1,
-      id: row.id,
-      role,
-      parts: partsByMessageId.get(row.id) ?? [],
-      createdAt: row.time_created ?? null,
-      version: row.time_updated ?? null
-    };
-  });
-}
-function readRawSessionMessagePageFromDb(db, sessionId, afterOrdinal, limit, finalWatermark = Number.MAX_SAFE_INTEGER, after) {
-  const messageRows = readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWatermark, after);
-  if (messageRows.length === 0)
-    return [];
-  const placeholders = messageRows.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 message_id ASC, time_created ASC, id ASC`).all(sessionId, ...messageRows.map((row) => row.id)).filter(isRawPartRow);
-  return assembleRawMessagePage(messageRows, partRows);
-}
-function readRawMessagePageRows(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 [];
-  const parameters = [sessionId];
-  if (after)
-    parameters.push(after.timeCreated, after.timeCreated, after.timeCreated, after.id);
-  parameters.push(pageSize);
-  if (!after)
-    parameters.push(Math.max(0, Math.floor(afterOrdinal)));
-  return db.prepare(`SELECT id, data, time_created, time_updated
-             FROM message
-             WHERE session_id = ?
-                ${after ? "AND time_created >= ? AND (time_created > ? OR (time_created = ? AND id > ?))" : ""}
-                AND NOT (
-                   CASE WHEN json_valid(data) = 1
-                        THEN COALESCE(json_extract(data, '$.summary'), 0)
-                        ELSE 0 END = 1
-                   AND CASE WHEN json_valid(data) = 1
-                            THEN COALESCE(json_extract(data, '$.finish'), '')
-                            ELSE '' END = 'stop'
-               )
-             ORDER BY time_created ASC, id ASC
-             LIMIT ? ${after ? "" : "OFFSET ?"}`).all(...parameters).filter(isRawMessageRow).map((row, index) => ({
-    ...row,
-    ordinal: Math.floor(afterOrdinal) + index + 1
-  }));
-}
-function assembleRawMessagePage(messageRows, partRows) {
-  const partsByMessageId = new Map;
-  for (const part of partRows) {
-    const list = partsByMessageId.get(part.message_id) ?? [];
-    list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
-    partsByMessageId.set(part.message_id, list);
-  }
-  return messageRows.map((row) => {
-    const info = parseJsonRecord(row.data);
-    return {
-      ordinal: row.ordinal,
-      id: row.id,
-      role: typeof info?.role === "string" ? info.role : "unknown",
-      parts: partsByMessageId.get(row.id) ?? [],
-      createdAt: row.time_created ?? null,
-      version: row.time_updated ?? null
-    };
-  });
-}
-var RAW_SUMMARY_TEXT_MAX_CHARS = 8192;
-var RAW_SUMMARY_ARG_MAX_CHARS = 512;
-var RAW_SUMMARY_TOOL_INPUT_KEYS = [
-  "description",
-  "filePath",
-  "path",
-  "pattern",
-  "query",
-  "symbol",
-  "module",
-  "action"
-];
-function summaryStringField(jsonPath) {
-  return `CASE WHEN json_type(data, '${jsonPath}') = 'text' THEN substr(json_extract(data, '${jsonPath}'), 1, ${RAW_SUMMARY_ARG_MAX_CHARS}) END`;
-}
-var RAW_SUMMARY_PART_DATA_SQL = `CASE
-    WHEN json_extract(data, '$.type') = 'text'
-        THEN json_set(data, '$.text', substr(json_extract(data, '$.text'), 1, ${RAW_SUMMARY_TEXT_MAX_CHARS}))
-    ELSE json_object(
-        'type', 'tool',
-        'tool', ${summaryStringField("$.tool")},
-        'callID', ${summaryStringField("$.callID")},
-        'state', json_object(
-            'status', ${summaryStringField("$.state.status")},
-            'input', json_object(${RAW_SUMMARY_TOOL_INPUT_KEYS.map((key) => `'${key}', ${summaryStringField(`$.state.input.${key}`)}`).join(", ")}),
-            'metadata', json_object('description', ${summaryStringField("$.state.metadata.description")})
-        )
-    )
-END`;
-function readRawSessionMessageSummaryPageFromDb(db, sessionId, afterOrdinal, limit, finalWatermark = Number.MAX_SAFE_INTEGER, after) {
-  const messageRows = readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWatermark, after);
-  if (messageRows.length === 0)
-    return [];
-  const placeholders = messageRows.map(() => "?").join(", ");
-  const partRows = db.prepare(`SELECT message_id, ${RAW_SUMMARY_PART_DATA_SQL} AS data, time_updated
-             FROM part
-             WHERE +session_id = ?
-               AND likelihood(message_id IN (${placeholders}), 0.000001)
-               AND json_valid(data) = 1
-               AND json_extract(data, '$.type') IN ('text', 'tool')
-             ORDER BY message_id ASC, time_created ASC, id ASC`).all(sessionId, ...messageRows.map((row) => row.id)).filter(isRawPartRow);
-  return assembleRawMessagePage(messageRows, partRows);
-}
-function countRawSessionMessageOrdinalsFromDb(db, sessionId) {
-  const row = db.prepare(`SELECT COUNT(*) AS count
-             FROM message
-             WHERE session_id = ?
-               AND NOT (
-                   CASE WHEN json_valid(data) = 1
-                        THEN COALESCE(json_extract(data, '$.summary'), 0)
-                        ELSE 0 END = 1
-                   AND CASE WHEN json_valid(data) = 1
-                            THEN COALESCE(json_extract(data, '$.finish'), '')
-                            ELSE '' END = 'stop'
-               )`).get(sessionId);
-  return typeof row?.count === "number" ? row.count : 0;
-}
-function readRawSessionMessageIdOrdinalsForRangeFromDb(db, sessionId, fromOrdinal, toOrdinal) {
-  const from = Math.max(1, Math.floor(fromOrdinal));
-  const to = Math.floor(toOrdinal);
-  if (to < from)
-    return new Map;
-  const rows = db.prepare(`
-        SELECT id, data FROM message WHERE session_id = ?
-          AND CASE WHEN json_valid(data) THEN NOT (
-            COALESCE(json_type(data, '$.summary'), '') = 'true'
-            AND COALESCE(json_extract(data, '$.finish'), '') = 'stop'
-          ) ELSE 1 END
-        ORDER BY time_created, id LIMIT ? OFFSET ?
-    `).all(sessionId, to - from + 1, from - 1).filter(isRawMessageRow);
-  const result = new Map;
-  for (const [index, row] of rows.entries()) {
-    if (parseJsonRecord(row.data))
-      result.set(row.id, from + index);
-  }
-  return result;
-}
-function isAnchorRow(row) {
-  return row !== null && typeof row === "object" && typeof row.time_created === "number" && typeof row.id === "string";
-}
-function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
-  const anchorRow = db.prepare("SELECT time_created, id, data FROM message WHERE id = ? AND session_id = ?").get(anchorMessageId, sessionId);
-  if (!isAnchorRow(anchorRow))
-    return null;
-  const anchorInfo = parseJsonRecord(anchorRow.data ?? "");
-  if (anchorInfo?.summary === true && anchorInfo?.finish === "stop")
-    return null;
-  const messageRows = db.prepare(`SELECT id, data, time_created, time_updated FROM message
-             WHERE session_id = ?
-               AND (time_created > ? OR (time_created = ? AND id >= ?))
-             ORDER BY time_created ASC, id ASC`).all(sessionId, anchorRow.time_created, anchorRow.time_created, anchorRow.id).filter(isRawMessageRow);
-  const filtered = messageRows.filter((row) => {
-    const info = parseJsonRecord(row.data);
-    return !(info?.summary === true && info?.finish === "stop");
-  });
-  const ids = filtered.map((row) => row.id);
-  const partsByMessageId = new Map;
-  if (ids.length > 0) {
-    const CHUNK = 800;
-    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);
-      for (const part of partRows) {
-        const list = partsByMessageId.get(part.message_id) ?? [];
-        list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
-        partsByMessageId.set(part.message_id, list);
-      }
-    }
-  }
-  const messages = [];
-  let ord = baseOrdinal;
-  for (const row of filtered) {
-    const info = parseJsonRecord(row.data);
-    if (!info) {
-      ord += 1;
-      continue;
-    }
-    messages.push({
-      ordinal: ord,
-      id: row.id,
-      role: typeof info.role === "string" ? info.role : "unknown",
-      parts: partsByMessageId.get(row.id) ?? [],
-      createdAt: row.time_created ?? null,
-      version: row.time_updated ?? null
-    });
-    ord += 1;
-  }
-  return { messages, absoluteMessageCount: Math.max(0, ord - 1) };
-}
-function extractInMemoryMessageViews(messages) {
-  return messages.map((m) => {
-    const info = m.info ?? {};
-    return {
-      id: typeof info.id === "string" ? info.id : "",
-      role: typeof info.role === "string" ? info.role : "unknown",
-      parts: Array.isArray(m.parts) ? m.parts : [],
-      summary: info.summary === true ? true : undefined,
-      finish: typeof info.finish === "string" ? info.finish : undefined
-    };
-  });
-}
-function buildInMemoryTailRawMessages(args) {
-  const { messages, lastCompartmentEnd, anchorMessageId } = args;
-  const filtered = messages.filter((m) => !(m.summary === true && m.finish === "stop"));
-  if (filtered.length === 0)
-    return null;
-  let startIndex = 0;
-  let baseOrdinal;
-  let anchorFound = false;
-  if (anchorMessageId) {
-    const anchorIndex = filtered.findIndex((m) => m.id === anchorMessageId);
-    if (anchorIndex >= 0) {
-      anchorFound = true;
-      startIndex = anchorIndex;
-      baseOrdinal = lastCompartmentEnd;
-    } else {
-      baseOrdinal = Math.max(1, lastCompartmentEnd + 1);
-    }
-  } else {
-    baseOrdinal = Math.max(1, lastCompartmentEnd + 1);
-  }
-  const out = [];
-  let ord = baseOrdinal;
-  for (let i = startIndex;i < filtered.length; i += 1) {
-    const m = filtered[i];
-    if (!m.id || typeof m.id !== "string") {
-      ord += 1;
-      continue;
-    }
-    out.push({
-      ordinal: ord,
-      id: m.id,
-      role: typeof m.role === "string" ? m.role : "unknown",
-      parts: m.parts ?? [],
-      version: null
-    });
-    ord += 1;
-  }
-  return { messages: out, absoluteMessageCount: Math.max(0, ord - 1), anchorFound };
-}
-function readRawSessionMessageOrdinalByIdFromDb(db, sessionId, messageId) {
-  const row = db.prepare(`SELECT COUNT(candidate.id) AS ordinal
-             FROM message AS target
-             JOIN message AS candidate
-               ON candidate.session_id = target.session_id
-              AND NOT (
-                  CASE WHEN json_valid(candidate.data) = 1
-                       THEN COALESCE(json_extract(candidate.data, '$.summary'), 0)
-                       ELSE 0 END = 1
-                  AND CASE WHEN json_valid(candidate.data) = 1
-                           THEN COALESCE(json_extract(candidate.data, '$.finish'), '')
-                           ELSE '' END = 'stop'
-              )
-              AND (candidate.time_created < target.time_created
-                   OR (candidate.time_created = target.time_created AND candidate.id <= target.id))
-             WHERE target.session_id = ?
-               AND target.id = ?
-               AND NOT (
-                   CASE WHEN json_valid(target.data) = 1
-                        THEN COALESCE(json_extract(target.data, '$.summary'), 0)
-                        ELSE 0 END = 1
-                   AND CASE WHEN json_valid(target.data) = 1
-                            THEN COALESCE(json_extract(target.data, '$.finish'), '')
-                            ELSE '' END = 'stop'
-               )`).get(sessionId, messageId);
-  const ordinal = row?.ordinal;
-  return typeof ordinal === "number" && ordinal > 0 ? ordinal : null;
-}
-function 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") {
-    return null;
-  }
-  const info = parseJsonRecord(row.data);
-  if (!info || isRawCompactionSummaryInfo(info)) {
-    return null;
-  }
-  const ordinalRow = db.prepare(`SELECT COUNT(*) AS ordinal FROM message
-             WHERE session_id = ?
-               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
-                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
-               AND (time_created < ? OR (time_created = ? AND id <= ?))`).get(sessionId, row.time_created, row.time_created, messageId);
-  const ordinal = typeof ordinalRow?.ordinal === "number" ? ordinalRow.ordinal : 0;
-  if (ordinal <= 0) {
-    return null;
-  }
-  const partRows = db.prepare(RAW_MESSAGE_PARTS_BY_ID_SQL).all(sessionId, messageId).filter(isRawPartRow);
-  const role = typeof info.role === "string" ? info.role : "unknown";
-  return {
-    ordinal,
-    id: row.id,
-    role,
-    parts: partRows.map((part) => attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated)),
-    createdAt: row.time_created,
-    version: row.time_updated ?? null
-  };
-}
-function hasRawSessionMessageByIdFromDb(db, sessionId, messageId) {
-  const row = db.prepare("SELECT id, data, time_created FROM message WHERE session_id = ? AND id = ?").get(sessionId, messageId);
-  if (!row || !isRawMessageRow(row) || typeof row.time_created !== "number")
-    return false;
-  const info = parseJsonRecord(row.data);
-  if (!info || isRawCompactionSummaryInfo(info))
-    return false;
-  if (info.summary === 1 && info.finish === "stop")
-    return readRawSessionMessageByIdFromDb(db, sessionId, messageId) !== null;
-  return true;
-}
-
 // src/hooks/magic-context/read-session-true-raw-tokens.ts
 function completedToolArcCrossesBoundary(invOrdinal, resOrdinal, boundary) {
   return invOrdinal < boundary && boundary <= resOrdinal;
@@ -4239,7 +4861,7 @@ function callIdFromPart2(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);
@@ -4258,8 +4880,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") {
@@ -4268,7 +4890,7 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: args !== undefined,
       hasOutput: false,
-      inputText: args !== undefined ? stringValue(args) : "",
+      inputText: withText && args !== undefined ? stringValue(args) : "",
       outputText: ""
     };
   }
@@ -4278,7 +4900,7 @@ function toolSignalFromPart(part) {
       callId,
       hasInput: input !== undefined,
       hasOutput: false,
-      inputText: input !== undefined ? stringValue(input) : "",
+      inputText: withText && input !== undefined ? stringValue(input) : "",
       outputText: ""
     };
   }
@@ -4289,7 +4911,7 @@ function toolSignalFromPart(part) {
       hasInput: false,
       hasOutput: content !== undefined,
       inputText: "",
-      outputText: content !== undefined ? textFromToolResultContent(content) : ""
+      outputText: withText && content !== undefined ? textFromToolResultContent(content) : ""
     };
   }
   return null;
@@ -4299,7 +4921,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";
@@ -4419,7 +5041,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) {
@@ -4787,11 +5409,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") {
@@ -4803,10 +5425,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"));
@@ -4821,7 +5443,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);
@@ -4939,6 +5561,12 @@ function safeSlice(str, maxLen) {
 function isEditTool(name) {
   return name === "edit" || name === "write";
 }
+function needsEditMarker(input) {
+  return Object.keys(input).some((key) => {
+    const value = input[key];
+    return DIFF_KEYS.has(key) && typeof value === "string" && value.length > EDIT_REGION_HINT_LEN && !value.endsWith(TRUNCATION_SENTINEL);
+  });
+}
 function applyEditMarkerToInput(input) {
   for (const key of Object.keys(input)) {
     if (PATH_KEYS.has(key))
@@ -5100,6 +5728,17 @@ function serializedTokens(value, bounded = false) {
     return Buffer.byteLength(serialized);
   return serialized ? wireTextTokens(serialized) : 0;
 }
+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;
+}
 function visitWireContent(message, visit) {
   for (const part of message.parts) {
     if (!part || typeof part !== "object")
@@ -5128,15 +5767,13 @@ function visitWireContent(message, visit) {
         text(p.data);
         break;
       case "file":
-        if (typeof p.mime === "string" && p.mime.startsWith("image/")) {
-          visit.image("conversation", typeof p.url === "string" && p.url.startsWith("data:") ? estimateImageTokensFromDataUrl(p.url) : 1200);
-        }
+        visit.image("conversation", estimatePartImageTokens(part));
         break;
       case "tool":
         tool(p.state?.input ?? p.input ?? p.args);
         tool(p.state?.output ?? p.state?.content ?? p.output ?? p.result ?? p.content);
         tool(p.state?.error);
-        visit.image("toolCall", estimateToolAttachmentImageTokens(p.state));
+        visit.image("toolCall", estimatePartImageTokens(part));
         break;
       case "tool-call":
         tool(p.input ?? p.args);
@@ -5680,6 +6317,15 @@ function makeWholeMessageSentinel(providerID) {
     text: modelAcceptsEmptyContent(providerID) ? "" : WHOLE_MESSAGE_PLACEHOLDER_TEXT
   };
 }
+function wholeMessageNeutralizationRemoves(message, providerID) {
+  return message.info.role === "system" && modelAcceptsEmptyContent(providerID);
+}
+function neutralizeWholeMessage(message, providerID) {
+  message.parts.length = 0;
+  if (!wholeMessageNeutralizationRemoves(message, providerID)) {
+    message.parts.push(makeWholeMessageSentinel(providerID));
+  }
+}
 function isSentinel(part) {
   if (!isRecord(part))
     return false;
@@ -5707,8 +6353,9 @@ function replaySentinelByMessageIds(messages, ids, providerID, hiddenSeamIds = n
     }
     if (msg.parts.length === 1 && isSentinel(msg.parts[0]))
       continue;
-    msg.parts.length = 0;
-    msg.parts.push(makeWholeMessageSentinel(providerID));
+    if (wholeMessageNeutralizationRemoves(msg, providerID) && msg.parts.length === 0)
+      continue;
+    neutralizeWholeMessage(msg, providerID);
     replayed += 1;
   }
   const missingIds = [];
@@ -5776,24 +6423,18 @@ function setToolContent(part, content) {
   }
 }
 function clonePart(part) {
-  if (part === null || typeof part !== "object")
-    return part;
-  try {
-    return structuredClone(part);
-  } catch {
-    try {
-      return JSON.parse(JSON.stringify(part));
-    } catch {
-      return part;
-    }
-  }
+  return {
+    ...part,
+    ...isRecord(part.state) ? { state: { ...part.state } } : {}
+  };
 }
 function clampCloneInPlace(occurrence, clamp) {
-  const clone = clonePart(occurrence.part);
-  clamp(clone);
   const parts = occurrence.message.parts;
   const index = parts.indexOf(servedPart(occurrence));
   if (index >= 0) {
+    const clone = clamp(occurrence.part);
+    if (clone === servedPart(occurrence))
+      return;
     parts[index] = clone;
     occurrence.served = clone;
   }
@@ -5803,17 +6444,24 @@ function servedPart(occurrence) {
 }
 function skeletonRealToolPart(part, tagId, stripAttachments = false) {
   if (!isRecord(part))
-    return;
+    return part;
   const sentinel = `[dropped §${tagId}§]`;
   if (part.type === "tool" && isRecord(part.state)) {
-    part.state.output = sentinel;
+    if (part.state.output === sentinel && !needsAttachmentStrip(part.state, stripAttachments))
+      return part;
+    const clone = clonePart(part);
+    const state = clone.state;
+    state.output = sentinel;
     if (stripAttachments)
-      part.state.attachments = [];
-    return;
-  }
-  if (part.type === "tool_result") {
-    part.content = sentinel;
+      state.attachments = [];
+    return clone;
   }
+  if (part.type === "tool_result" && part.content !== sentinel)
+    return { ...part, content: sentinel };
+  return part;
+}
+function needsAttachmentStrip(state, strip) {
+  return strip && (!Array.isArray(state.attachments) || state.attachments.length !== 0);
 }
 function readToolPartRawInput(part) {
   if (!isRecord(part))
@@ -5826,51 +6474,62 @@ function readToolPartRawInput(part) {
     return part.input;
   return;
 }
+function isDroppedInput(input, sentinel) {
+  return isRecord(input) && Object.keys(input).length === 1 && Object.hasOwn(input, "dropped") && input.dropped === sentinel;
+}
 function truncateToolPart(part, tagId) {
   if (!isRecord(part))
-    return;
+    return part;
   const sentinel = `[dropped §${tagId}§]`;
   if (part.type === "tool" && isRecord(part.state)) {
-    const state = part.state;
+    if (part.state.output === sentinel && isDroppedInput(part.state.input, sentinel))
+      return part;
+    const clone = clonePart(part);
+    const state = clone.state;
     state.output = sentinel;
     state.input = droppedInputMarker(tagId);
-    return;
+    return clone;
   }
   if (part.type === "tool_result") {
-    part.content = sentinel;
-    return;
+    return part.content === sentinel ? part : { ...part, content: sentinel };
   }
   if (part.type === "tool-invocation") {
-    part.args = droppedInputMarker(tagId);
-    return;
+    return isDroppedInput(part.args, sentinel) ? part : { ...part, args: droppedInputMarker(tagId) };
   }
   if (part.type === "tool_use") {
-    part.input = droppedInputMarker(tagId);
+    return isDroppedInput(part.input, sentinel) ? part : { ...part, input: droppedInputMarker(tagId) };
   }
+  return part;
 }
 function editMarkerToolPart(part, tagId, stripAttachments = false) {
   if (!isRecord(part))
-    return;
+    return part;
   const sentinel = `[dropped §${tagId}§]`;
+  const input = readToolPartInput(part);
+  const rewriteInput = input !== null && needsEditMarker(input);
   if (part.type === "tool" && isRecord(part.state)) {
-    part.state.output = sentinel;
+    if (part.state.output === sentinel && !rewriteInput && !needsAttachmentStrip(part.state, stripAttachments))
+      return part;
+    const clone = clonePart(part);
+    const state = clone.state;
+    state.output = sentinel;
     if (stripAttachments)
-      part.state.attachments = [];
-    if (isRecord(part.state.input))
-      applyEditMarkerToInput(part.state.input);
-    return;
+      state.attachments = [];
+    if (rewriteInput) {
+      state.input = { ...input };
+      applyEditMarkerToInput(state.input);
+    }
+    return clone;
   }
   if (part.type === "tool_result") {
-    part.content = sentinel;
-    return;
-  }
-  if (part.type === "tool-invocation" && isRecord(part.args)) {
-    applyEditMarkerToInput(part.args);
-    return;
+    return part.content === sentinel ? part : { ...part, content: sentinel };
   }
-  if (part.type === "tool_use" && isRecord(part.input)) {
-    applyEditMarkerToInput(part.input);
+  if (rewriteInput) {
+    const markedInput = { ...input };
+    applyEditMarkerToInput(markedInput);
+    return { ...part, [part.type === "tool-invocation" ? "args" : "input"]: markedInput };
   }
+  return part;
 }
 function readToolPartInput(part) {
   if (!isRecord(part))
@@ -6099,9 +6758,7 @@ function createToolDropTarget(compositeKey, thinkingParts, index, batch, tagId)
         parts
       });
       const before = count(parts);
-      const retained = skeleton ? structuredClone(parts) : [];
-      for (const part of retained)
-        skeletonRealToolPart(part, tagId);
+      const retained = skeleton ? parts.map((part) => skeletonRealToolPart(part, tagId)) : [];
       const after = count(retained);
       return {
         beforeTools: before.toolCall,
@@ -6149,6 +6806,10 @@ function createToolDropTarget(compositeKey, thinkingParts, index, batch, tagId)
         return false;
       return batch.wouldStrandConversationEnd(entry.occurrences);
     },
+    prepareDrop: () => {
+      const entry = index.get(compositeKey);
+      return !!entry && entry.occurrences.length > 0 && entry.hasResult;
+    },
     canDrop: () => {
       const entry = index.get(compositeKey);
       return !!entry && entry.occurrences.length > 0 && entry.hasResult && !entry.occurrences.some((occurrence) => toolPartHasUserAnswer(occurrence.part));
@@ -6422,6 +7083,14 @@ function readRawSessionMessageRange2(sessionId, fromOrdinal, toOrdinal) {
 }
 readRawSessionMessages2.readPage = readRawSessionMessagePage2;
 readRawSessionMessages2.getCount = getRawSessionMessageOrdinalCount2;
+readRawSessionMessages2.prepare = prepareRawSessionOrdinals2;
+async function prepareRawSessionOrdinals2(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)
@@ -6573,6 +7242,7 @@ function readRawSessionMessageById2(sessionId, messageId) {
     return null;
   return withReadOnlySessionDb((db) => readRawSessionMessageByIdFromDb(db, sessionId, messageId));
 }
+readRawSessionMessageById2.prepare = prepareRawSessionOrdinals2;
 function readRawSessionMessagesFromSource(sessionId) {
   const provider = sessionProviders.get(sessionId)?.provider;
   if (provider)
@@ -6953,6 +7623,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 = [];
@@ -6990,4 +7668,4 @@ function readSessionChunk2(sessionId, tokenBudget, offset = 1, eligibleEndOrdina
     toolResultBoundaries
   };
 }
-export { toolTemplateError, DEFAULT_PROTECTED_TOOLS, normalizeProtectedToolName, mergeProtectedTools, isRecord, detectLatestTurnThinkingMismatch, isPrefixBoundThinkingModel, detectOverflow, protectedToolTagNumbers, protectedToolTokenCount, textMentionsRecentCommit, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, getTokenizerNativeMemoryStats, preloadTokenizer, estimateTokens, estimateFixedPromptTokens, stripWellFormedLeadingTagPrefix, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isThinkingPart, stableStringify, contentTagOwnerMessageId, estimateImageTokensFromDataUrl, estimateToolAttachmentImageTokens, normalizeTodoStateJson, buildSyntheticTodoPart, isSyntheticTodoPart, countRealUserMessages, tailHygieneStructuralSignature, sameTailHygieneStructuralSignature, formatTailHygienePrefixMismatch, refreshTailHygieneBaseline, effectiveTailHygiene, assertTailHygieneContentUnchangedIfEnabled, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, isDroppedToolOutput, toolOutputTokens, decideChannel1, evaluateChannel2, formatChannel1Evaluation, formatChannel2Evaluation, reclaimableToolOutputCount, buildChannel2Reminder, buildChannel1Reminder, estimateEmergencyDropReclaimTokens, planEmergencyDrop, measureEmergencyTag, installV3PerfSchema, queuePendingOp, queuePendingDropForUnchangedTag, getPendingOps, getPendingOpsCount, clearPendingOps, removePendingOp, getRecentTagOwnerMessageIds, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, getActiveTagTokenTotalsByMessage, getAllStatusTagTokenTotalsFlat, getReasoningTokenEstimatesByMessage, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, markWhitespaceAssistantTagInert, getInertWhitespaceAssistantTags, updateTagDropMode, updateCavemanDepth, updateTagMessageId, foldShrunkPartTags, markTagsCompactedByMessageIds, getMaxTagNumberBySession, getTagNumberByMessageId, getAssignableTagNumberByMessageId, deriveTagLoadFloor, TAG_SELECT_COLUMNS, getTagsBySession, getActiveTagsBySession, getTailHygieneTags, getTagsByNumbers, getNewestToolTagNumbers, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getTagById, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, getCandidateToolOwners, pickNearestPriorOwner, expandToolPart, markHostUnservedRow, retreatPastHostUnservedRows, snapTerminalCompartmentToServedRow, isHostRenderedSystemMessage, isStrictGapHealingMessage, extractInMemoryMessageViews, buildInMemoryTailRawMessages, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForCompletedToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, stripSystemInjection, isTextPart, isToolPartWithOutput, isFilePart, buildFileSourceContent, toolPartHasUserAnswer, recordToolParameters, createDroppedInputGuard, assertExecutableToolInput, isEditTool, getCurrentToolSetHash, setDatabase, loadToolDefinitionMeasurements, recordToolDefinition, getMeasuredToolDefinitionTokens, describeFinalWireTail, estimateMessageTokens, wireContentBytes, createFinalWireUsageTracker, estimateFinalWireInputTokens, modelAcceptsEmptyContent, isAnthropicFamilyRoute, neutralizeDroppedReasoningPart, restoreNeutralizedReasoningPart, isNeutralizedReasoningPart, neutralizedReasoningSource, variantChangeBustsProviderCache, makeSentinel, makeWholeMessageSentinel, isSentinel, replaySentinelByMessageIds, SKELETON_REAL_INPUT_MAX_BYTES, partHasCompletedResult, extractToolCallObservation, ToolMutationBatch, createToolDropTarget, resolveHostServedBoundaryId2, hasRawMessageProvider2, setBoundedRawMessageProvider2, cleanUserText2, withRawSessionMessageCache2, readRawSessionMessages2, readRawSessionMessagePage2, getRawSessionMessageOrdinalCount2, visitRawSessionMessages2, readRawSessionMessageRange2, primeTailRawMessageCache2, getCachedAbsoluteMessageCount2, primeInMemoryTailRawMessageCache2, readRawSessionMessageIdOrdinalsForRange2, hasRawSessionMessageById2, readRawSessionMessageOrdinalById2, compareRawSessionMessageOrder2, readRawSessionMessageById2, getRawSessionMessageCount2, getRawSessionTagKeysThrough2, getLegacyProtectedTailStartOrdinal2, readSessionChunk2 };
+export { toolTemplateError, DEFAULT_PROTECTED_TOOLS, normalizeProtectedToolName, mergeProtectedTools, detectLatestTurnThinkingMismatch, isPrefixBoundThinkingModel, detectOverflow, stripWellFormedLeadingTagPrefix, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isThinkingPart, isRecord, protectedToolTagNumbers, protectedToolTokenCount, textMentionsRecentCommit, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, getTokenizerNativeMemoryStats, preloadTokenizer, estimateTokens, estimateFixedPromptTokens, currentReclaimableToolOutputCount, stableStringify, contentTagOwnerMessageId, estimateImageTokensFromDataUrl, estimateToolAttachmentImageTokens, providerVisibleMessage, normalizeTodoStateJson, buildSyntheticTodoPart, isSyntheticTodoPart, countRealUserMessages, tailHygieneStructuralSignature, sameTailHygieneStructuralSignature, formatTailHygienePrefixMismatch, refreshTailHygieneBaseline, effectiveTailHygiene, assertTailHygieneContentUnchangedIfEnabled, CHANNEL1_SENTINEL, CHANNEL1_FLOOR_TOKENS, isDroppedToolOutput, toolOutputTokens, decideChannel1, evaluateChannel2, formatChannel1Evaluation, formatChannel2Evaluation, reclaimableToolOutputCount, buildChannel2Reminder, buildChannel1Reminder, estimateEmergencyDropReclaimTokens, planEmergencyDrop, measureEmergencyTag, installV3PerfSchema, queuePendingOp, queuePendingDropForUnchangedTag, getPendingOps, getPendingOpsCount, clearPendingOps, removePendingOp, tagTombstoneOwnerRange, tagTombstoneOwnerKey, tagRevisionKey, tagIdentityRevisionKey, installTagIdentityRevisionTrigger, deleteTagIdentityRevisions, getRecentTagOwnerMessageIds, AGE_RECLAIM_MIN_TOKENS, getOldestActiveUnprotectedToolTags, getActiveToolTagsForAgeReclaim, getTriggerTagTokenUpperBound, getActiveTagTokenTotalsByMessage, getAllStatusTagTokenTotalsFlat, getReasoningTokenEstimatesByMessage, tryGetReasoningTokenEstimatesByMessage, getMaxTagNumberByOwnerMessage, scanTagOwnerSummary, isTagOwnerSummaryReady, tagTokenCountIsNull, backfillTagTokenCounts, insertTag, updateTagStatus, markTagDropped, markWhitespaceAssistantTagInert, getInertWhitespaceAssistantTags, getInertWhitespaceAssistantTagsByNumbers, updateTagDropMode, updateCavemanDepth, updateTagMessageId, foldShrunkPartTags, markTagsCompactedByMessageIds, getMaxTagNumberBySession, getTagNumberByMessageId, getAssignableTagNumberByMessageId, deriveTagLoadFloor, TAG_SELECT_COLUMNS, getTagsBySession, getActiveTagsBySession, getTailHygieneTags, getTagsByNumbers, getNewestToolTagNumbers, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getTagById, getToolTagNumberByOwner, getNullOwnerToolTag, adoptNullOwnerToolTag, getCandidateToolOwners, pickNearestPriorOwner, expandToolPart, markHostUnservedRow, retreatPastHostUnservedRows, snapTerminalCompartmentToServedRow, isHostRenderedSystemMessage, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForCompletedToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, stripSystemInjection, isTextPart, isToolPartWithOutput, isFilePart, buildFileSourceContent, toolPartHasUserAnswer, recordToolParameters, createDroppedInputGuard, assertExecutableToolInput, isEditTool, getCurrentToolSetHash, setDatabase, loadToolDefinitionMeasurements, recordToolDefinition, getMeasuredToolDefinitionTokens, describeFinalWireTail, estimatePartImageTokens, estimateMessageTokens, wireContentBytes, createFinalWireUsageTracker, estimateFinalWireInputTokens, modelAcceptsEmptyContent, isAnthropicFamilyRoute, neutralizeDroppedReasoningPart, restoreNeutralizedReasoningPart, isNeutralizedReasoningPart, neutralizedReasoningSource, variantChangeBustsProviderCache, makeSentinel, makeWholeMessageSentinel, neutralizeWholeMessage, isSentinel, replaySentinelByMessageIds, SKELETON_REAL_INPUT_MAX_BYTES, partHasCompletedResult, extractToolCallObservation, ToolMutationBatch, createToolDropTarget, resolveHostServedBoundaryId2, hasRawMessageProvider2, setBoundedRawMessageProvider2, cleanUserText2, withRawSessionMessageCache2, readRawSessionMessages2, readRawSessionMessagePage2, getRawSessionMessageOrdinalCount2, visitRawSessionMessages2, readRawSessionMessageRange2, prepareRawSessionOrdinals2, primeTailRawMessageCache2, getCachedAbsoluteMessageCount2, primeInMemoryTailRawMessageCache2, readRawSessionMessageIdOrdinalsForRange2, hasRawSessionMessageById2, readRawSessionMessageOrdinalById2, compareRawSessionMessageOrder2, readRawSessionMessageById2, getRawSessionMessageCount2, getRawSessionTagKeysThrough2, getLegacyProtectedTailStartOrdinal2, readSessionChunk2 };