@retaw106/mmc-oc 2.0.0 → 2.1.0

package/dist/v2/server.js

@@ -7803,7 +7803,7 @@ class Parser {
       } else
         break;
     }
-    const expression = { steps, cap: 300 };
+    const expression = { steps };
     if (this.take(".each(")) {
       if (relative)
         return this.error();
@@ -7869,9 +7869,23 @@ function compiled(source) {
 function oneLine(value) {
   return value.replace(/[\r\n\u2028\u2029]+/g, " ");
 }
-function truncate(value, cap) {
+function truncate(value, cap, legacyPreview = false) {
   const chars = Array.from(oneLine(value));
-  return chars.length > cap ? `${chars.slice(0, cap).join("")}…` : chars.join("");
+  if (cap === undefined || chars.length <= cap)
+    return chars.join("");
+  if (legacyPreview)
+    return `${chars.slice(0, cap).join("")}…`;
+  let end = 0;
+  for (let i = 0;i < Math.min(cap, chars.length); i++) {
+    if (!".!?。！？".includes(chars[i]))
+      continue;
+    let next = i + 1;
+    while (next < chars.length && `"'”’)]`.includes(chars[next]))
+      next++;
+    if (next <= cap && ("。！？".includes(chars[i]) || next === chars.length || /[ \t]/.test(chars[next])))
+      end = next;
+  }
+  return `${end ? `${chars.slice(0, end).join("")} ` : ""}[… ${chars.length - end} more characters]`;
 }
 function scalar(value) {
   if (value === undefined)
@@ -7888,10 +7902,11 @@ function compactJson(value) {
 function field(value, key) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && Object.hasOwn(value, key) ? value[key] : undefined;
 }
-function render(nodes, root) {
+function render(nodes, root, legacyPreview) {
   return nodes.map((node) => {
     if (typeof node === "string")
       return node;
+    const cap = node.cap ?? (legacyPreview ? 300 : undefined);
     let value = root;
     let list = false;
     for (const step of node.steps) {
@@ -7905,19 +7920,19 @@ function render(nodes, root) {
       }
     }
     if (node.count)
-      return truncate(Array.isArray(value) ? String(value.length) : "", node.cap);
+      return truncate(Array.isArray(value) ? String(value.length) : "", cap, legacyPreview);
     if (node.each || list || node.join !== undefined) {
       if (!Array.isArray(value))
         return "";
-      const elements = value.slice(0, 10).map((item) => truncate(node.each ? render(node.each, item) : scalar(item), 300));
-      if (value.length > 10)
+      const elements = value.slice(0, legacyPreview ? 10 : undefined).map((item) => truncate(node.each ? render(node.each, item, legacyPreview) : scalar(item), legacyPreview ? 300 : undefined, legacyPreview));
+      if (legacyPreview && value.length > 10)
         elements.push(`… +${value.length - 10} more`);
-      return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), node.cap);
+      return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), cap, legacyPreview);
     }
-    return truncate(scalar(value), node.cap);
+    return truncate(scalar(value), cap, legacyPreview);
   }).join("");
 }
-function renderToolTemplate(source, input, output) {
+function renderToolTemplate(source, input, output, legacyPreview = false) {
   const nodes = compiled(source);
   if (!nodes)
     return null;
@@ -7932,8 +7947,8 @@ function renderToolTemplate(source, input, output) {
     }
   }
   const root = { input, output: structured };
-  const bareOutputNodes = nodes.map((node) => typeof node !== "string" && node.steps.length === 1 && ("field" in node.steps[0]) && node.steps[0].field === "output" && !node.each && !node.count && node.join === undefined ? truncate(text ?? "", node.cap) : node);
-  return truncate(render(bareOutputNodes, root), 1000);
+  const bareOutputNodes = nodes.map((node) => typeof node !== "string" && node.steps.length === 1 && ("field" in node.steps[0]) && node.steps[0].field === "output" && !node.each && !node.count && node.join === undefined ? truncate(text ?? "", node.cap ?? (legacyPreview ? 300 : undefined), legacyPreview) : node);
+  return truncate(render(bareOutputNodes, root, legacyPreview), legacyPreview ? 1000 : undefined, legacyPreview);
 }
 var templates;
 var init_historian_tool_template = __esm(() => {
@@ -9821,6 +9836,10 @@ function sampleLiveConfig(boot, fresh) {
     let value = fresh;
     for (const part of parts)
       value = value?.[part];
+    if (value === undefined) {
+      removeLeaf(result, parts);
+      continue;
+    }
     let target = result;
     for (const part of parts.slice(0, -1)) {
       const child = target[part];
@@ -9834,6 +9853,26 @@ function sampleLiveConfig(boot, fresh) {
   }
   return result;
 }
+function removeLeaf(root, parts) {
+  const parents = parts.slice(0, -1);
+  let node = root;
+  for (const part of parents) {
+    const child = node[part];
+    if (!child || typeof child !== "object" || Array.isArray(child))
+      return;
+    node = child;
+  }
+  const leaf = parts.at(-1);
+  if (leaf === undefined || !Object.hasOwn(node, leaf))
+    return;
+  let target = root;
+  for (const part of parents) {
+    const copy = { ...target[part] };
+    target[part] = copy;
+    target = copy;
+  }
+  delete target[leaf];
+}
 function changedLiveKeys(previous, next) {
   const at = (config, path) => path.split(".").reduce((node, part) => node?.[part], config);
   return LIVE_RELOAD_CONFIG_PATHS.filter((path) => JSON.stringify(at(previous, path)) !== JSON.stringify(at(next, path)));
@@ -10614,6 +10653,8 @@ function installTransactionRouting(db, readonly) {
     configurable: true,
     writable: true,
     value: (sql) => {
+      if (/^\s*(?:COMMIT|END)\b/i.test(sql))
+        assertTransformWrite();
       if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
         openWriterTransactions.delete(db);
         if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
@@ -10822,6 +10863,15 @@ function getSqliteMemoryStats() {
     connections
   };
 }
+function closeReleasingStatements(close, args) {
+  if (args[0] === true)
+    return close(true);
+  try {
+    return close(true);
+  } catch {
+    return close(...args);
+  }
+}
 function ownPreparedStatement(db, statement) {
   const finalizable = statement;
   if (typeof finalizable.finalize !== "function")
@@ -10845,7 +10895,7 @@ function ownPreparedStatement(db, statement) {
           }
         }
         references.clear();
-        const result = close(...args);
+        const result = closeReleasingStatements(close, args);
         if (failure)
           throw failure;
         return result;
@@ -10895,6 +10945,10 @@ function withSqliteTransformPass(operation) {
 function withoutSqliteTransformPass(operation) {
   return transformPassScope.run(undefined, operation);
 }
+function assertTransformWrite() {
+  if (!backgroundWriterScope.getStore())
+    transformPassScope.getStore()?.guard?.assert();
+}
 function isTransientSqliteError(error) {
   if (!error || typeof error !== "object")
     return false;
@@ -10906,6 +10960,7 @@ function foregroundWaitLease() {
   return lease?.active && !admissionScope.getStore() && !backgroundWriterScope.getStore() ? lease : undefined;
 }
 function withAutocommitTimeout(db, operation) {
+  assertTransformWrite();
   const lease = foregroundWaitLease();
   if (isInTransaction(db) || !lease && !backgroundWriterScope.getStore())
     return operation();
@@ -10926,6 +10981,7 @@ function withAutocommitTimeout(db, operation) {
   }
 }
 function acquireShort(db, acquire, site) {
+  assertTransformWrite();
   const started = performance.now();
   const previous = pragmaNumber(db, "busy_timeout");
   const outer = writerAcquisitionScope.getStore();
@@ -10937,7 +10993,7 @@ function acquireShort(db, acquire, site) {
   let acquiredAt;
   try {
     const lease = foregroundWaitLease();
-    const timeout = lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS;
+    const timeout = Math.floor(Math.min(lease ? lease.remainingWaitMs : SHORT_BUSY_TIMEOUT_MS, owner?.remainingMs?.() ?? lease?.guard?.remainingMs() ?? Infinity));
     db.exec(`PRAGMA busy_timeout=${timeout}`);
     acquire();
     acquiredAt = performance.now();
@@ -11010,29 +11066,53 @@ async function beginSqliteWriterAsync(db, site) {
     }
   }
 }
-async function withAsyncPrivilegedWriter(db, operation) {
+async function withAsyncPrivilegedWriter(db, operation, options = {}) {
   const started = performance.now();
+  const budgetMs = Math.max(0, Math.min(FOREGROUND_ACQUISITION_BUDGET_MS, options.budgetMs ?? Infinity));
   let attempts = 0;
   for (;; ) {
+    options.signal?.throwIfAborted();
+    options.assertCurrentPass?.();
     attempts++;
+    let entered = false;
     try {
       const acquisition = {
         site: "privileged_writer",
         lane: "foreground",
         startedAt: started,
         attempts,
-        claimed: false
+        claimed: false,
+        remainingMs: () => Math.max(0, budgetMs - (performance.now() - started))
       };
-      return admissionScope.run(true, () => withSqliteTransformPass(() => writerAcquisitionScope.run(acquisition, () => withPrivilegedWriter(db, operation))));
+      return admissionScope.run(true, () => withSqliteTransformPass(() => writerAcquisitionScope.run(acquisition, () => withPrivilegedWriter(db, () => {
+        entered = true;
+        return operation();
+      }))));
     } catch (error) {
-      if (!(error instanceof SqliteAcquisitionBusyError))
+      if (entered || !(error instanceof SqliteAcquisitionBusyError))
         throw error;
+      options.beforeRetry?.(error);
       const elapsed = performance.now() - started;
-      if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+      if (elapsed >= budgetMs) {
         reportSqliteDiagnostic(`sqlite writer site=privileged_writer lane=foreground acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`);
         throw error;
       }
-      await new Promise((resolve) => setTimeout(resolve, Math.min(attempts === 1 ? 500 : 1000, FOREGROUND_ACQUISITION_BUDGET_MS - elapsed)));
+      const backoff = attempts === 1 ? 500 : 1000;
+      const delay = Math.min(options.jitter ? backoff * (0.8 + Math.random() * 0.4) : backoff, budgetMs - elapsed);
+      await new Promise((resolve, reject) => {
+        const abort = () => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", abort);
+          reject(options.signal?.reason ?? new Error("Writer wait aborted"));
+        };
+        const timer = setTimeout(() => {
+          options.signal?.removeEventListener("abort", abort);
+          resolve();
+        }, delay);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+          abort();
+      });
     }
   }
 }
@@ -11947,6 +12027,27 @@ var init_storage_memory_fts = __esm(async () => {
 function clearMemoryVerifications(db, memoryId) {
   db.prepare("DELETE FROM memory_verifications WHERE memory_id = ?").run(memoryId);
 }
+
+// src/features/magic-context/memory/types.ts
+var MEMORY_CATEGORY_RECORD, MEMORY_CATEGORIES;
+var init_types = __esm(() => {
+  MEMORY_CATEGORY_RECORD = {
+    PROJECT_RULES: true,
+    ARCHITECTURE: true,
+    CONFIG_VALUES: true,
+    ARCHITECTURE_DECISIONS: true,
+    CONSTRAINTS: true,
+    CONFIG_DEFAULTS: true,
+    NAMING: true,
+    USER_PREFERENCES: true,
+    USER_DIRECTIVES: true,
+    ENVIRONMENT: true,
+    WORKFLOW_RULES: true,
+    KNOWN_ISSUES: true
+  };
+  MEMORY_CATEGORIES = Object.keys(MEMORY_CATEGORY_RECORD);
+});
+
 // src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -11963,6 +12064,7 @@ var init_memory = __esm(async () => {
   init_project_identity();
   init_storage_memory();
   init_storage_memory_fts();
+  init_types();
   init_verification_paths();
 });
 
@@ -14102,7 +14204,8 @@ var init_overflow_detection = __esm(() => {
   PREFIX_BOUND_THINKING_MODELS = [
     ["fable", 5, 1],
     ["opus", 5, 5],
-    ["sonnet", 5, 5]
+    ["sonnet", 5, 5],
+    ["haiku", 5, 5]
   ];
   PREFIX_BOUND_THINKING_PATTERN = new RegExp(`(?:^|[-_.:/])(?:${PREFIX_BOUND_THINKING_MODELS.map(([family, major, minor]) => `${family}[-_.]?${major}[-_.]${minor}`).join("|")})(?:$|[-_.:/@])`, "i");
 });
@@ -19574,6 +19677,24 @@ var init_storage_tags = __esm(() => {
 var historian_tool_defaults_default;
 var init_historian_tool_defaults = __esm(() => {
   historian_tool_defaults_default = {
+    todowrite: 'Todos (${input.todos.count}): ${input.todos.each("${status}: ${content}")}',
+    question: 'Asked user: ${input.questions[*].question.join(" / ")} → ${output}',
+    task: "Task ${input.subagent_type}: ${input.prompt.truncate(600)} → ${output.truncate(200)}",
+    ask: 'Asked: ${input.question} [options: ${input.options.join(" / ")}] ${input.text}${input.resolution} → ${output.truncate(300)}',
+    peer_send: "PM ${input.recipient}: ${input.message}",
+    board: 'Board ${input.verb}${input.board_lane}: ${input.ops.each("${op} ${lane_label} ${item}${props.text}${lane.items} ${state}${props.state}${lane.status}${id}${title}")}',
+    room: "Room ${input.action} ${input.room_label}: ${input.room_detail}",
+    work: "Work ${input.action} ${input.title}${input.id}: ${input.prompt.truncate(600)}${input.notes.truncate(600)} → ${output.truncate(160)}",
+    knowhow: "Looked up how-to: ${input.query}${input.id}",
+    mmc_note: "Note ${input.action} ${input.note_ids}: ${input.content} → ${output.truncate(160)}",
+    mmc_memory: "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}"
+  };
+});
+
+// src/shared/historian-tool-preview-defaults.json
+var historian_tool_preview_defaults_default;
+var init_historian_tool_preview_defaults = __esm(() => {
+  historian_tool_preview_defaults_default = {
     todowrite: 'Todos (${input.todos.count}): ${input.todos.each("${status}: ${content}")}',
     question: 'Asked user: ${input.questions[*].question.join(" / ")} → ${output}',
     task: "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
@@ -19589,20 +19710,52 @@ var init_historian_tool_defaults = __esm(() => {
 });
 
 // src/shared/historian-tool-expansions.ts
-function expandToolPart(part, overrides) {
+function builtinInput(tool, input) {
+  if (!input || typeof input !== "object")
+    return input;
+  const i = input;
+  if (tool === "peer_send") {
+    const external = i.external;
+    const recipient = i.reply_to_pmid ? `reply to ${i.reply_to_pmid}` : i.agent || i.agent_id ? `to ${i.agent || i.agent_id}` : external?.session_id || i.session_id ? `to session ${external?.session_id || i.session_id}` : "to unknown recipient";
+    return { ...i, recipient };
+  }
+  if (tool === "room") {
+    return {
+      ...i,
+      room_label: i.room_id || i.title,
+      room_detail: i.action === "create" || i.action === "invite" ? `invitees: ${renderToolTemplate("${input.invitees}", i)}` : i.text
+    };
+  }
+  if (tool === "board") {
+    return {
+      ...i,
+      board_lane: i.lane ? ` ${i.lane}` : "",
+      ops: Array.isArray(i.ops) ? i.ops.map((op) => op && typeof op === "object" ? {
+        ...op,
+        lane_label: typeof op.lane === "string" ? op.lane : op.lane?.title || op.lane?.id
+      } : op) : i.ops
+    };
+  }
+  return input;
+}
+function expandToolPart(part, overrides, legacyPreview = false) {
   if (!part || typeof part !== "object")
     return null;
   const p = part;
   if (p.type !== "tool" || typeof p.tool !== "string")
     return null;
-  const template = overrides && Object.hasOwn(overrides, p.tool) ? overrides[p.tool] : Object.hasOwn(historian_tool_defaults_default, p.tool) ? historian_tool_defaults_default[p.tool] : undefined;
+  const builtinDefaults = legacyPreview ? historian_tool_preview_defaults_default : historian_tool_defaults_default;
+  const overridden = overrides && Object.hasOwn(overrides, p.tool);
+  const template = overridden ? overrides[p.tool] : Object.hasOwn(builtinDefaults, p.tool) ? builtinDefaults[p.tool] : undefined;
   if (typeof template !== "string")
     return null;
   const state = p.state;
-  return renderToolTemplate(template, state?.input, state?.output ?? state?.error);
+  const input = overridden || legacyPreview ? state?.input : builtinInput(p.tool, state?.input);
+  return renderToolTemplate(template, input, state?.output ?? state?.error, legacyPreview);
 }
 var init_historian_tool_expansions = __esm(() => {
   init_historian_tool_defaults();
+  init_historian_tool_preview_defaults();
   init_historian_tool_template();
 });
 
@@ -20935,20 +21088,22 @@ function fenceBoundaryForCompletedToolArcs(candidate, arcs, publicationFloorOrdi
   return minInvocation < publicationFloorOrdinal ? maxResult + 1 : minInvocation;
 }
 function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal, recentOpenArcCutoff) {
-  const boundary = fenceBoundaryForCompletedToolArcs(candidate, arcs, lastCompartmentEndOrdinal + 1);
+  let boundary = fenceBoundaryForCompletedToolArcs(candidate, arcs, lastCompartmentEndOrdinal + 1);
   for (const arc of arcs) {
     if (arc.resOrdinal !== null)
       continue;
     if (arc.invOrdinal < recentOpenArcCutoff)
       continue;
     if (arc.invOrdinal >= lastCompartmentEndOrdinal + 1 && arc.invOrdinal < boundary) {
-      return arc.invOrdinal;
+      boundary = arc.invOrdinal;
+      break;
     }
     if (arc.invOrdinal >= boundary) {
-      return arc.invOrdinal;
+      boundary = arc.invOrdinal;
+      break;
     }
   }
-  return boundary;
+  return fenceBoundaryForCompletedToolArcs(boundary, arcs, 1);
 }
 function tokenForMessage(message, options) {
   const key = messageCacheKey(message, options);
@@ -21683,7 +21838,7 @@ function estimateFinalWireInputTokens(input) {
     total.toolCall += next.toolCall;
     return total;
   }, { conversation: 0, toolCall: 0 });
-  const measuredToolDefinitions = input.providerID && input.modelID ? getMeasuredToolDefinitionTokens(input.providerID, input.modelID, input.agentName) : undefined;
+  const measuredToolDefinitions = input.toolDefinitionTokens ?? (input.providerID && input.modelID ? getMeasuredToolDefinitionTokens(input.providerID, input.modelID, input.agentName) : undefined);
   const calibration = resolveDecisionCalibration(input.providerID, input.modelID);
   const largestToolDefinitions = measuredToolDefinitions === undefined ? getLargestMeasuredToolDefinitionTokens() : undefined;
   const toolDefinitions = measuredToolDefinitions ?? (largestToolDefinitions === undefined ? undefined : Math.ceil(largestToolDefinitions * UNKNOWN_FIT_RATIO / (calibration.seeded ? calibration.toolsRatio : UNKNOWN_FIT_RATIO)));
@@ -25349,6 +25504,41 @@ function emergencyDrainExitThreshold(executeThresholdPercentage) {
   }
   return Math.max(0, executeThresholdPercentage - EMERGENCY_DRAIN_EXIT_MARGIN);
 }
+function resolvedEmergencyDrainLatch(meta, usagePercentage, executeThresholdPercentage, now) {
+  const { forceMaterializationPercentage } = escalationBands(executeThresholdPercentage);
+  if (usagePercentage >= forceMaterializationPercentage)
+    return meta.emergencyDrainActive > 0 ? meta.emergencyDrainActive : now;
+  if (usagePercentage < emergencyDrainExitThreshold(executeThresholdPercentage) || now - meta.emergencyDrainActive > EMERGENCY_DRAIN_MAX_LATCH_MS)
+    return 0;
+  return meta.emergencyDrainActive;
+}
+function drainFailureBackoffActive(meta, now) {
+  return meta.historianDrainFailureAt > 0 && meta.historianDrainFailureAt <= now && now - meta.historianDrainFailureAt < EMERGENCY_DRAIN_FAILURE_BACKOFF_MS;
+}
+function getProtectedTailDrainBudgetSkip(args) {
+  const now = args.now ?? Date.now();
+  const meta = loadProtectedTailMeta(args.db, args.sessionId);
+  const latch = resolvedEmergencyDrainLatch(meta, args.usagePercentage, args.executeThresholdPercentage, now);
+  if (latch !== meta.emergencyDrainActive) {
+    args.db.prepare("UPDATE session_meta SET emergency_drain_active = ? WHERE session_id = ? AND emergency_drain_active = ?").run(latch, args.sessionId, meta.emergencyDrainActive);
+  }
+  const startedAt = meta.protectedTailDrainWindowStartedAt;
+  if (startedAt <= 0 || startedAt > now || now - startedAt >= DRAIN_WINDOW_MS)
+    return null;
+  const limitTokens = protectedTailWindowBudget(args.usagePercentage, args.usable, args.perRunCap);
+  if (meta.protectedTailDrainTokens < limitTokens)
+    return null;
+  if (latch > 0 && !drainFailureBackoffActive(meta, now))
+    return null;
+  return {
+    windowStartedAt: startedAt,
+    resetsAt: startedAt + DRAIN_WINDOW_MS,
+    nextEligibleAt: latch > 0 ? Math.min(startedAt + DRAIN_WINDOW_MS, meta.historianDrainFailureAt + EMERGENCY_DRAIN_FAILURE_BACKOFF_MS) : startedAt + DRAIN_WINDOW_MS,
+    resetInMs: startedAt + DRAIN_WINDOW_MS - now,
+    spentTokens: meta.protectedTailDrainTokens,
+    limitTokens
+  };
+}
 function reserveProtectedTailDrainTokens(args) {
   const now = args.now ?? Date.now();
   const requested = Math.max(0, Math.floor(args.trueRawTokens));
@@ -25380,17 +25570,7 @@ function reserveProtectedTailDrainTokens(args) {
                      WHERE session_id = ?`).run(now, args.sessionId);
       meta = loadProtectedTailMeta(args.db, args.sessionId);
     }
-    const exitThreshold = emergencyDrainExitThreshold(args.executeThresholdPercentage);
-    let latchActiveSince = meta.emergencyDrainActive;
-    const { forceMaterializationPercentage } = escalationBands(args.executeThresholdPercentage);
-    if (args.usagePercentage >= forceMaterializationPercentage) {
-      if (latchActiveSince <= 0)
-        latchActiveSince = now;
-    } else if (latchActiveSince > 0) {
-      const expired = now - latchActiveSince > EMERGENCY_DRAIN_MAX_LATCH_MS;
-      if (args.usagePercentage < exitThreshold || expired)
-        latchActiveSince = 0;
-    }
+    const latchActiveSince = resolvedEmergencyDrainLatch(meta, args.usagePercentage, args.executeThresholdPercentage, now);
     if (latchActiveSince !== meta.emergencyDrainActive) {
       args.db.prepare("UPDATE session_meta SET emergency_drain_active = ? WHERE session_id = ?").run(latchActiveSince, args.sessionId);
     }
@@ -25399,7 +25579,7 @@ function reserveProtectedTailDrainTokens(args) {
     const remaining = Math.max(0, budget - meta.protectedTailDrainTokens);
     let reserved = Math.min(requested, args.perRunCap, remaining);
     let bypass = false;
-    const inFailureBackoff = meta.historianDrainFailureAt > 0 && meta.historianDrainFailureAt <= now && now - meta.historianDrainFailureAt < EMERGENCY_DRAIN_FAILURE_BACKOFF_MS;
+    const inFailureBackoff = drainFailureBackoffActive(meta, now);
     if (reserved <= 0 && latchActive && !inFailureBackoff) {
       reserved = Math.min(requested, args.perRunCap);
       bypass = true;
@@ -29841,7 +30021,9 @@ var init_storage_db = __esm(async () => {
   channel2HealStatements = new WeakMap;
 });
 // src/v2/store-reader.ts
+import { createHash as createHash13 } from "node:crypto";
 import { statSync as statSync8 } from "node:fs";
+import { hostname } from "node:os";
 import { resolve as resolve7 } from "node:path";
 function gaDatabasePath(dataHome, channel = "latest", env = process.env) {
   return resolveOpenCodeDbPath("v2", { dataHome, channel, env }).path;
@@ -29910,6 +30092,8 @@ function decode2(row) {
   return { ...row, data };
 }
 function connect(path, identity = "") {
+  const stat = statSync8(path);
+  const acquiredIdentity = identity || `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
   const db = new Database(path, { readonly: true, fileMustExist: true });
   try {
     assertOpenCodeStoreGeneration(db, "v2", path);
@@ -29921,7 +30105,7 @@ function connect(path, identity = "") {
   counters.openReaders += 1;
   counters.readersOpened += 1;
   counters.maxOpenReaders = Math.max(counters.maxOpenReaders, counters.openReaders);
-  return { db, statements: new Map, identity, leases: 0, retired: false };
+  return { db, statements: new Map, identity: acquiredIdentity, leases: 0, retired: false };
 }
 function closeConnection(connection) {
   connection.statements.clear();
@@ -29993,15 +30177,20 @@ class V2StoreReaderPool {
 }
 
 class V2StoreReader {
+  path;
   pool;
   db;
   connection;
   closed = false;
   constructor(path, pool) {
+    this.path = path;
     this.pool = pool;
     this.connection = pool ? pool.acquire(path) : connect(path);
     this.db = this.connection.db;
   }
+  hostIdentity() {
+    return createHash13("sha256").update(JSON.stringify([hostname(), resolve7(this.path), this.connection.identity])).digest("hex");
+  }
   prepare(sql) {
     if (this.closed)
       throw new Error("Store reader is closed");
@@ -30097,6 +30286,10 @@ class V2StoreReader {
       return null;
     return typeof row.parent_id === "string" && row.parent_id.length > 0;
   }
+  storedRowsAfter(sessionID, after) {
+    const row = this.prepare("SELECT COUNT(*) AS count FROM session_message WHERE session_id = ? AND seq > ?").get(sessionID, after);
+    return row.count;
+  }
   storedMessageCount(sessionID) {
     return trackDecodeOperation("storedMessageCount", () => {
       const row = this.prepare("SELECT COUNT(*) AS count FROM session_message WHERE session_id = ?").get(sessionID);
@@ -30411,11 +30604,14 @@ function getSessionMetaSelectColumns(db) {
   sessionMetaSelectColumnsCache.set(db, projection);
   return projection;
 }
-function getOrCreateSessionMeta(db, sessionId) {
+function findSessionMeta(db, sessionId) {
   const result = db.prepare(`SELECT ${getSessionMetaSelectColumns(db)} FROM session_meta WHERE session_id = ?`).get(sessionId);
-  if (isSessionMetaRow(result)) {
-    return toSessionMeta(result);
-  }
+  return isSessionMetaRow(result) ? toSessionMeta(result) : undefined;
+}
+function getOrCreateSessionMeta(db, sessionId) {
+  const existing = findSessionMeta(db, sessionId);
+  if (existing)
+    return existing;
   const harness = getHarness();
   const defaults = getDefaultSessionMeta(sessionId);
   const fallbackSubagent = harness === "opencode" ? resolveIsSubagentFromOpenCodeDb(sessionId) : harness === "opencode2" ? resolveIsSubagentFromOpenCode2Db(sessionId) : null;
@@ -30948,7 +31144,7 @@ var init_storage_v22_backfill_failures = __esm(() => {
 });
 
 // src/features/magic-context/workspaces.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 function tableExists3(db, tableName) {
   const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ? LIMIT 1").get(tableName);
   return Boolean(row);
@@ -31132,7 +31328,7 @@ function computeWorkspaceEpochFingerprint(db, identities) {
   const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
   const epochs = getEpochMap(db, canonical);
   const shareCategories = selectWorkspaceShareCategories(db, canonical);
-  const hash = createHash13("sha256");
+  const hash = createHash14("sha256");
   hash.update("share_categories", "utf8");
   hash.update("\x00");
   hash.update(shareCategories === null ? "NO_WORKSPACE" : JSON.stringify(shareCategories), "utf8");
@@ -33249,7 +33445,7 @@ var init_compartment_runner_types = __esm(() => {
 });
 
 // src/v2/hooks/hidden-child.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function hiddenAgentAllowedTools(agent) {
   return agent !== undefined && Object.hasOwn(AGENT_TOOL_ALLOWLIST, agent) ? AGENT_TOOL_ALLOWLIST[agent] : undefined;
 }
@@ -33337,7 +33533,7 @@ function markerCandidates(text) {
 function textDigest(text) {
   return {
     length: text.length,
-    sha256: createHash14("sha256").update(text).digest("hex").slice(0, 16)
+    sha256: createHash15("sha256").update(text).digest("hex").slice(0, 16)
   };
 }
 function firstDifference(a, b) {
@@ -34040,10 +34236,10 @@ var init_shared = __esm(() => {
 });
 
 // src/features/magic-context/compaction-marker.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync11 } from "node:fs";
 function deterministicBase62(seed, length) {
-  let value = BigInt(`0x${createHash15("sha256").update(seed).digest("hex")}`);
+  let value = BigInt(`0x${createHash16("sha256").update(seed).digest("hex")}`);
   const chars = Array(length);
   for (let index = length - 1;index >= 0; index -= 1) {
     chars[index] = BASE62_CHARS[Number(value % 62n)];
@@ -42166,12 +42362,14 @@ function applyHeadCap(args) {
     diagnostics.completedRefence.tokenMass = index.rangeTokens(Math.min(...component.map((arc) => arc.invocation)), Math.max(...component.map((arc) => arc.result)) + 1);
   });
   diagnostics.completedRefence.to = end;
-  diagnostics.eligibleEnd = end <= offset ? offset : Math.min(end, protectedTailStart);
+  if (end > protectedTailStart)
+    end = offset;
+  diagnostics.eligibleEnd = end <= offset ? offset : end;
   args.observeDiagnostics?.(diagnostics);
   if (end <= offset && offset < protectedTailStart) {
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit };
   }
-  return { eligibleEndOrdinal: Math.min(end, protectedTailStart), oversizeAtomicUnit };
+  return { eligibleEndOrdinal: end, oversizeAtomicUnit };
 }
 function resolveProtectedTailBoundary(ctx) {
   const createdAt = ctx.createdAt ?? Date.now();
@@ -42326,6 +42524,7 @@ function resolveProtectedTailBoundary(ctx) {
   }
   protectedTailStart = clampOrdinal(protectedTailStart, rawMessageCount);
   protectedTailStart = retreatPastHostUnservedRows(messages, protectedTailStart, offset);
+  protectedTailStart = Math.max(offset, fenceBoundaryForCompletedToolArcs(protectedTailStart, arcs, 1));
   const perRunCap = selectPerRunCap({
     usagePercentage,
     N: scaledN,
@@ -42345,7 +42544,8 @@ function resolveProtectedTailBoundary(ctx) {
     capTokens: perRunCap,
     recentOpenArcCutoff
   });
-  const eligibleEndOrdinal = retreatPastHostUnservedRows(messages, head.eligibleEndOrdinal, offset);
+  const servedEndOrdinal = retreatPastHostUnservedRows(messages, head.eligibleEndOrdinal, offset);
+  const eligibleEndOrdinal = Math.max(offset, fenceBoundaryForCompletedToolArcs(servedEndOrdinal, arcs, 1));
   const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, eligibleEndOrdinal);
   return {
     sessionId: ctx.sessionId,
@@ -42373,7 +42573,7 @@ function resolveProtectedTailBoundary(ctx) {
     cacheNamespace: ctx.cacheNamespace,
     createdAt,
     rawRangeFingerprint,
-    trueRawEligibleTokens: index.rangeTokens(offset, protectedTailStart),
+    trueRawEligibleTokens: index.rangeTokens(offset, eligibleEndOrdinal),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
     boundaryReason,
     diagnostics: boundaryDiagnostics({
@@ -42604,6 +42804,8 @@ function getRawHistoryEligibility(db, sessionId) {
 function hasRunnableCompartmentWindow(snapshot) {
   if (snapshot.offset >= snapshot.protectedTailStart)
     return false;
+  if (snapshot.eligibleEndOrdinal <= snapshot.offset)
+    return false;
   const forceMaterializationPercentage = escalationBands(snapshot.executeThresholdPercentage).forceMaterializationPercentage;
   if (snapshot.usagePercentage >= forceMaterializationPercentage || snapshot.emergencyTailScale) {
     return snapshot.trueRawEligibleTokens >= deriveMinForceEligibleTokens(snapshot.N) || snapshot.eligibleEndOrdinal > snapshot.offset;
@@ -44633,10 +44835,10 @@ function startLeaseRenewal(deps, holderId) {
     }
   }, COMPARTMENT_LEASE_RENEWAL_MS);
 }
-function startCompartmentAgent(deps, runAgent = runCompartmentAgent) {
-  withoutSqliteTransformPass(() => startBackgroundCompartmentAgent(deps, runAgent));
+function startCompartmentAgent(deps, runAgent = runCompartmentAgent, prepareBoundary) {
+  withoutSqliteTransformPass(() => startBackgroundCompartmentAgent(deps, runAgent, prepareBoundary));
 }
-function startBackgroundCompartmentAgent(deps, runAgent) {
+function startBackgroundCompartmentAgent(deps, runAgent, prepareBoundary) {
   const existing = activeRuns.get(deps.sessionId);
   if (existing) {
     return;
@@ -44661,15 +44863,33 @@ function startBackgroundCompartmentAgent(deps, runAgent) {
     return;
   }
   const renewal = startLeaseRenewal(deps, holderId);
-  let realRunStarted = false;
   const runnerDeps = withPublishedCallback({
     ...deps,
-    compartmentLeaseHolderId: holderId,
-    onHistorianRunStarted: () => {
-      realRunStarted = true;
-    }
+    compartmentLeaseHolderId: holderId
   });
-  const promise = runAgent(runnerDeps).catch((err) => {
+  const promise = new Promise((resolve) => setTimeout(resolve, 0)).then(() => withRawSessionMessageCache(() => {
+    const snapshot = deps.boundarySnapshot;
+    try {
+      primeTailRawMessageCache({
+        sessionId: deps.sessionId,
+        lastCompartmentEnd: snapshot?.lastCompartmentEndMessageId !== undefined ? snapshot.offset - 1 : getLastCompartmentEndMessage(deps.db, deps.sessionId),
+        anchorMessageId: snapshot?.lastCompartmentEndMessageId !== undefined ? snapshot.lastCompartmentEndMessageId : getLastCompartmentEndMessageId(deps.db, deps.sessionId)
+      });
+    } catch (error) {
+      sessionLog(deps.sessionId, "compartment agent: tail prime failed (non-fatal):", error);
+    }
+    if (prepareBoundary) {
+      const boundary = prepareBoundary();
+      if (!boundary) {
+        updateSessionMeta(deps.db, deps.sessionId, {
+          compartmentInProgress: false
+        });
+        return;
+      }
+      runnerDeps.boundarySnapshot = boundary;
+    }
+    return runAgent(runnerDeps);
+  })).catch((err) => {
     sessionLog(deps.sessionId, "compartment agent: unhandled rejection:", err);
     try {
       updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
@@ -44686,9 +44906,6 @@ function startBackgroundCompartmentAgent(deps, runAgent) {
     }
   });
   activeRuns.set(deps.sessionId, { promise, published: false, kind: "incremental" });
-  if (!realRunStarted && activeRuns.get(deps.sessionId)?.promise === promise) {
-    activeRuns.delete(deps.sessionId);
-  }
 }
 async function executeContextRecompWithResult(deps, options = {}) {
   const { sessionId } = deps;
@@ -44756,11 +44973,13 @@ var init_compartment_runner = __esm(async () => {
   init_compartment_lease();
   init_logger();
   await __promiseAll([
+    init_compartment_storage(),
     init_storage_meta(),
     init_sqlite(),
     init_compartment_runner_incremental(),
     init_compartment_runner_partial_recomp(),
     init_compartment_runner_recomp(),
+    init_read_session_chunk(),
     init_compartment_runner_incremental()
   ]);
   activeRuns = new Map;
@@ -47586,13 +47805,54 @@ function isSuccessfulProviderCompletion(input) {
 }
 
 // src/hooks/magic-context/lkg-measured-request.ts
+import { createHash as createHash17 } from "node:crypto";
 function lkgProviderInputTotal(tokens) {
   const counts = [tokens?.input ?? 0, tokens?.cache?.read ?? 0, tokens?.cache?.write ?? 0];
   return counts.every((count) => Number.isSafeInteger(count) && count >= 0) ? counts.reduce((sum, count) => sum + count, 0) : Number.NaN;
 }
+function identity(slot) {
+  return createHash17("sha256").update(JSON.stringify([
+    slot.capturedAt,
+    slot.captureSequence,
+    slot.rowVersion,
+    slot.modelKey,
+    slot.providerKey,
+    slot.inputIdSeq,
+    slot.inputContentDigests
+  ])).update(slot.jsonPrefix).digest("hex");
+}
+function envelope(modelKey, systemPromptTokens, agentName) {
+  const slash = modelKey.indexOf("/");
+  return JSON.stringify([
+    modelKey,
+    systemPromptTokens,
+    agentName,
+    getMeasuredToolDefinitionTokens(modelKey.slice(0, slash), modelKey.slice(slash + 1), agentName)
+  ]);
+}
 function beginV2LkgRequest(sessionId, modelKey, previousResponseId) {
   requests.set(sessionId, { kind: "v2", previousResponseId, startedAt: Date.now(), modelKey });
 }
+function claimLkgRequestIdentity(sessionId) {
+  const request = requests.get(sessionId);
+  if (!request || claimedRequests.has(request))
+    return;
+  claimedRequests.add(request);
+  return request;
+}
+function noteCapturedLkgRequest(args) {
+  const request = args.request;
+  if (!request || request.modelKey !== args.slot.modelKey) {
+    captures.delete(args.sessionId);
+    return;
+  }
+  captures.set(args.sessionId, {
+    request,
+    slot: identity(args.slot),
+    prefixCount: JSON.parse(args.slot.jsonPrefix).length,
+    envelope: envelope(request.modelKey, args.systemPromptTokens, args.agentName)
+  });
+}
 function noteLkgProviderResponse(args) {
   if (!args.responseId || !args.modelKey)
     return;
@@ -47627,7 +47887,7 @@ var init_lkg_measured_request = __esm(() => {
 });
 
 // src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 function parseStringArray(value) {
   if (typeof value !== "string")
     return null;
@@ -47739,7 +47999,7 @@ function rememberFingerprint(db, sessionId, fingerprint) {
   saved.set(sessionId, fingerprint);
 }
 function slotFingerprint(slot) {
-  return createHash16("sha256").update(JSON.stringify([
+  return createHash18("sha256").update(JSON.stringify([
     slot.jsonPrefix,
     slot.inputIdSeq,
     slot.inputContentDigests,
@@ -48192,7 +48452,7 @@ function captureLkgSlot(args) {
   if (!built)
     return false;
   const modelKeys = canonicalLkgModelKeys(args.modelKey, args.providerKey);
-  return captureSlot(args.sessionId, {
+  const slot = {
     jsonPrefix: built.jsonPrefix,
     inputIdSeq: built.inputIdSeq,
     inputContentDigests: built.inputContentDigests,
@@ -48200,7 +48460,17 @@ function captureLkgSlot(args) {
     modelKey: modelKeys.modelKey,
     providerKey: modelKeys.providerKey,
     capturedAt: args.capturedAt ?? Date.now()
-  });
+  };
+  const captured = captureSlot(args.sessionId, slot);
+  if (captured)
+    noteCapturedLkgRequest({
+      sessionId: args.sessionId,
+      slot,
+      request: built.anchorIndex === args.input.length - 1 ? claimLkgRequestIdentity(args.sessionId) : undefined,
+      systemPromptTokens: args.systemPromptTokens ?? 0,
+      agentName: args.agentName
+    });
+  return captured;
 }
 function entryIdsAreValid(slot, entryIds) {
   if (slot.inputIdSeq.length === 0 || entryIds.length < slot.inputIdSeq.length)
@@ -48427,9 +48697,58 @@ function replayLkg(args) {
 }
 var init_lkg_replay = __esm(() => {
   init_harness_provider_map();
+  init_lkg_measured_request();
   init_lkg_slot();
 });
 
+// src/hooks/magic-context/lkg-replay-fit.ts
+function lkgReplayLimit(args) {
+  const { db, sessionId, model } = args;
+  const trusted = model ? resolveTrustedContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : undefined;
+  if (trusted !== undefined && trusted > 0)
+    return trusted;
+  const detected = getOverflowState(db, sessionId, args.modelKey).detectedContextLimit;
+  return detected > 0 ? detected : undefined;
+}
+function measureLkgReplay(args) {
+  const baseline = args.measuredInputTokens ?? 0;
+  const tailLimit = Math.max(0, args.limit - baseline);
+  const proxy = wireContentBytes(args.messages, tailLimit * RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN, RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+  const skipped = { proxy, estimatorRan: false, trusted: false };
+  if (proxy === null)
+    return { fit: "unproven", tokens: null, ...skipped };
+  const proxyTokens = baseline + Math.ceil(proxy.bytes / RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN);
+  if (proxy.aborted || proxyTokens > args.limit) {
+    return { fit: "over", tokens: null, proxyTokens, ...skipped };
+  }
+  let estimate;
+  try {
+    estimate = args.estimate();
+  } catch {
+    return { fit: "unproven", tokens: null, ...skipped };
+  }
+  const seen = { proxy, estimatorRan: true, trusted: estimate.trusted };
+  const tokens = baseline + estimate.tokens;
+  if (!estimate.trusted || !Number.isFinite(tokens) || tokens <= 0 || estimate.tokens < 0) {
+    return {
+      fit: "unproven",
+      tokens: Number.isFinite(estimate.tokens) ? estimate.tokens : null,
+      ...seen
+    };
+  }
+  return tokens > args.limit ? { fit: "over", tokens, proxyTokens, ...seen } : { fit: "under", tokens, ...seen };
+}
+var RAW_FALLBACK_BYTES_PER_CONTEXT_TOKEN = 4;
+var init_lkg_replay_fit = __esm(async () => {
+  init_final_wire_token_estimate();
+  init_lkg_measured_request();
+  init_lkg_slot();
+  await __promiseAll([
+    init_storage_meta_persisted(),
+    init_event_resolvers()
+  ]);
+});
+
 // src/hooks/magic-context/storage-busy-refusal.ts
 function describeStorageBusyCause(cause) {
   let original = cause;
@@ -48584,7 +48903,7 @@ Some things on the desk are Magic Context's own markings, not conversation. \`<s
 });
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash17 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function clearSystemPromptHashSession(sessionId, handleMaps) {
   handleMaps.stickyDateBySession.delete(sessionId);
   handleMaps.cachedDocsBySession.delete(sessionId);
@@ -48678,7 +48997,7 @@ function createSystemPromptHashHandler(deps) {
     }
     const stickyDate = stickyDateBySession.get(sessionId);
     const stableCandidate = currentDate && stickyDate && currentDate !== stickyDate ? liveSystemContent.replace(DATE_PATTERN_ALL, stickyDate) : liveSystemContent;
-    const stableCandidateHash = createHash17("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = createHash19("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const dateMayAdvance = isCacheBusting || idleCacheExpired || contentOrPresetChanged;
     if (currentDate && !stickyDate) {
@@ -48698,7 +49017,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash17("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = createHash19("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -48937,10 +49256,14 @@ function recordSessionProjectIdentity(db, sessionId, projectPath) {
     return;
   const harness = getHarness();
   const now = Date.now();
+  let previousProjectPath;
   db.transaction(() => {
+    const existing = db.prepare("SELECT project_path FROM session_projects WHERE session_id = ? AND harness = ?").get(sessionId, harness);
+    previousProjectPath = existing?.project_path;
     getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
     getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath, SESSION_CHUNK_REPAIR_BATCH_SIZE);
   }).immediate();
+  return previousProjectPath === projectPath ? undefined : { previousProjectPath, projectPath };
 }
 function hasRecordedSessionProjectIdentity(db, sessionId) {
   const row = db.prepare("SELECT 1 AS found FROM session_projects WHERE session_id = ? AND harness = ?").get(sessionId, getHarness());
@@ -48979,6 +49302,7 @@ function recordPendingTransformDecision(sessionId, decision) {
 }
 var canonicalReasons, piReasonAliases, sharedReasonAliases, pendingDecisionBySession, pendingPiDecisionBySession, lastBoundMessageIdBySession, scheduledWriteTokensBySession;
 var init_transform_decision_log = __esm(async () => {
+  init_logger();
   await __promiseAll([
     init_sqlite(),
     init_storage_db()
@@ -49407,6 +49731,37 @@ var init_compaction_off_transition = __esm(async () => {
   };
 });
 
+// src/hooks/magic-context/historian-drain-gate.ts
+function isHistorianDrainBudgetSpent(args) {
+  const target = deriveProtectedTailTokenTarget(args);
+  const state = getProtectedTailDrainBudgetSkip({
+    ...args,
+    usable: target.usable,
+    perRunCap: selectPerRunCap({ ...args, N: target.N })
+  });
+  if (!state)
+    return false;
+  let windows = loggedWindows.get(args.db);
+  if (!windows) {
+    windows = new Map;
+    loggedWindows.set(args.db, windows);
+  }
+  if (windows.get(args.sessionId) !== state.resetsAt) {
+    windows.set(args.sessionId, state.resetsAt);
+    sessionLog(args.sessionId, `historian skip: internal drain budget spent (${state.spentTokens}/${state.limitTokens} tokens); next eligible at ${new Date(state.nextEligibleAt).toISOString()}`);
+  }
+  return true;
+}
+var loggedWindows;
+var init_historian_drain_gate = __esm(async () => {
+  init_logger();
+  await __promiseAll([
+    init_storage_meta_persisted(),
+    init_protected_tail_boundary()
+  ]);
+  loggedWindows = new WeakMap;
+});
+
 // src/features/magic-context/storage-reasoning-removal.ts
 function invalidState(sessionId) {
   return new Error(`invalid persisted reasoning removal state for session ${sessionId}`);
@@ -50402,7 +50757,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         taggerFloor,
         storedTotalsExcludeToolTags
       });
-      const hasProtectedEligibleHead = boundary.offset < boundary.protectedTailStart;
+      const hasProtectedEligibleHead = boundary.offset < Math.min(boundary.protectedTailStart, boundary.eligibleEndOrdinal);
       if (!hasProtectedEligibleHead) {
         return {
           ...TAIL_INFO_DEFAULTS,
@@ -50414,7 +50769,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
       const seed = sessionDecisionCalibration(db, sessionId);
       const sourceRatio = Math.max(seed.proseRatio, seed.toolsRatio);
       const scanBudget = Math.floor(Math.max(MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE, triggerBudget * TAIL_SIZE_TRIGGER_MULTIPLIER) / sourceRatio);
-      const chunk = readSessionChunk(sessionId, scanBudget, rawEligibility.offset, boundary.protectedTailStart);
+      const chunk = readSessionChunk(sessionId, scanBudget, rawEligibility.offset, boundary.eligibleEndOrdinal);
       const isMeaningful = chunk.hasMore || boundary.trueRawEligibleTokens >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || Math.ceil(chunk.tokenEstimate * sourceRatio) >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || chunk.messageCount >= MIN_PROACTIVE_TAIL_MESSAGE_COUNT;
       return {
         nextStartOrdinal: rawEligibility.offset,
@@ -50441,6 +50796,14 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
   }
+  if (isHistorianDrainBudgetSpent({
+    db,
+    sessionId,
+    usagePercentage: usage.percentage,
+    contextLimit: resolveBoundaryContextLimit(usage, contextLimit),
+    executeThresholdPercentage
+  }))
+    return { shouldFire: false };
   const lazyInMemoryTail = typeof inMemoryTail === "function" ? inMemoryTail : undefined;
   let resolvedInMemoryTail = typeof inMemoryTail === "function" ? undefined : inMemoryTail;
   if (resolvedInMemoryTail) {
@@ -50587,6 +50950,7 @@ var init_compartment_trigger = __esm(async () => {
   await __promiseAll([
     init_compartment_storage(),
     init_storage(),
+    init_historian_drain_gate(),
     init_protected_tail_boundary(),
     init_read_session_chunk(),
     init_reasoning_budget()
@@ -51002,8 +51366,24 @@ function historianJoinFailClosedMessage(input) {
   return `historian did not complete within ${seconds} s: ${reason}`;
 }
 function runCompartmentPhase(args) {
+  if (args.historianRunnable !== false && !args.compactionOff && args.canRunCompartments && !getActiveCompartmentRun(args.sessionId) && (args.sessionMeta.compartmentInProgress || args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE) && isHistorianDrainBudgetSpent({
+    db: args.db,
+    sessionId: args.sessionId,
+    contextLimit: args.boundaryContextLimit,
+    executeThresholdPercentage: args.boundaryExecuteThresholdPercentage,
+    usagePercentage: args.boundaryUsage.percentage
+  })) {
+    if (args.sessionMeta.compartmentInProgress) {
+      updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
+    }
+    return runCompartmentPhaseImpl({
+      ...args,
+      canRunCompartments: false,
+      sessionMeta: { compartmentInProgress: false }
+    });
+  }
   const historianRunnable = args.historianRunnable !== false;
-  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && (args.sessionMeta.compartmentInProgress || args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE);
+  const willReadRawHistory = historianRunnable && !args.compactionOff && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE;
   if (!willReadRawHistory) {
     return runCompartmentPhaseImpl(args);
   }
@@ -51129,7 +51509,7 @@ async function runCompartmentPhaseImpl(args) {
     compartmentInProgress = false;
   }
   if (historianRunnable && args.canRunCompartments && args.sessionMeta.compartmentInProgress && !getActiveCompartmentRun(args.sessionId)) {
-    if (!hasEligibleHistoryForCompartment()) {
+    if (args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE && !hasEligibleHistoryForCompartment()) {
       sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
       updateSessionMeta(args.db, args.sessionId, { compartmentInProgress: false });
       compartmentInProgress = false;
@@ -51146,7 +51526,7 @@ async function runCompartmentPhaseImpl(args) {
         db: args.db,
         sessionId: args.sessionId,
         historianChunkTokens: args.historianChunkTokens,
-        boundarySnapshot: getBoundarySnapshotForCompartment() ?? undefined,
+        boundarySnapshot: args.preResolvedBoundarySnapshot,
         currentContextLimit: args.boundaryContextLimit,
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
@@ -51164,6 +51544,12 @@ async function runCompartmentPhaseImpl(args) {
         autoPromote: args.autoPromote,
         onCompartmentStatePublished: args.onCompartmentStatePublished,
         preserveInjectionCacheUntilConsumed: true
+      }, undefined, () => {
+        const snapshot = getBoundarySnapshotForCompartment();
+        if (snapshot && hasRunnableCompartmentWindow(snapshot))
+          return snapshot;
+        sessionLog(args.sessionId, `transform: skipping compartment start, no eligible history before protected tail (beyond ${lastObservedCompartmentEnd})`);
+        return null;
       });
       compartmentInProgress = true;
     }
@@ -51237,6 +51623,7 @@ var init_transform_compartment_phase = __esm(async () => {
     init_sqlite(),
     init_compartment_runner(),
     init_compartment_trigger(),
+    init_historian_drain_gate(),
     init_inject_compartments(),
     init_protected_tail_boundary(),
     init_read_session_chunk(),
@@ -55062,19 +55449,33 @@ function createTransform(deps) {
       if (false) {}
       return false;
     };
-    const startRecoveryRun = () => {
-      const scale = emergencyUsagePercentageEarly >= 95 ? 0.25 : 0.5;
-      let boundarySnapshot = getRunnableBoundaryForCompartment();
-      if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
-        boundarySnapshot = getRunnableBoundaryForCompartment(scale);
-      }
-      if (false) {}
-      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || !boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+    const startRecoveryRun = (onReady) => {
+      if (isHistorianDrainBudgetSpent({
+        db,
+        sessionId,
+        contextLimit: boundaryContextLimit,
+        executeThresholdPercentage: boundaryExecuteThreshold,
+        usagePercentage: boundaryUsageForProtectedTail.percentage
+      }))
         return false;
-      }
-      if (getActiveCompartmentRun(sessionId)) {
+      if (!canRunCompartments || !deps.client && !deps.hiddenCompletionExecutor || getActiveCompartmentRun(sessionId))
+        return false;
+      const prepareRecoveryBoundary = () => {
+        const scale = emergencyUsagePercentageEarly >= 95 ? 0.25 : 0.5;
+        let boundarySnapshot = getRunnableBoundaryForCompartment();
+        if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot)) {
+          boundarySnapshot = getRunnableBoundaryForCompartment(scale);
+        }
+        if (false) {}
+        if (!boundarySnapshot || !hasRunnableCompartmentWindow(boundarySnapshot))
+          return null;
+        onReady?.();
+        return boundarySnapshot;
+      };
+      const urgent = emergencyUsagePercentageEarly >= 95;
+      const boundarySnapshot = urgent ? prepareRecoveryBoundary() : undefined;
+      if (urgent && !boundarySnapshot)
         return false;
-      }
       updateSessionMeta(db, sessionId, { compartmentInProgress: true });
       startCompartmentAgent({
         client: deps.client,
@@ -55083,7 +55484,7 @@ function createTransform(deps) {
         db,
         sessionId,
         historianChunkTokens: historianRun?.chunkTokens ?? deps.getHistorianChunkTokens?.() ?? 20000,
-        boundarySnapshot,
+        boundarySnapshot: boundarySnapshot ?? undefined,
         currentContextLimit: boundaryContextLimit,
         historyBudgetTokens,
         historianTimeoutMs: historianRun?.timeoutMs ?? deps.historianTimeoutMs,
@@ -55103,7 +55504,7 @@ function createTransform(deps) {
           deferredHistoryRefreshSessions.add(sid);
           deferredMaterializationSessions.add(sid);
         }
-      });
+      }, undefined, urgent ? undefined : prepareRecoveryBoundary);
       return true;
     };
     if (fullFeatureMode && !compactionOff && historianFailureState.failureCount > 0 && emergencyUsagePercentageEarly >= 95 && !recoveryNoHeadEscapeActive) {
@@ -55117,13 +55518,15 @@ function createTransform(deps) {
         sessionLog(sessionId, "transform: emergency recovery remains armed — no complete eligible head before protected tail");
       }
       sessionLog(sessionId, `EMERGENCY: historian recovery requested at ${emergencyPercentage}%, failures: ${historianFailureState.failureCount}`);
-    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0 && getEligibleHistoryForCompartment() && startRecoveryRun()) {
-      sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
-      if (deps.client) {
-        withoutSqliteTransformPass(() => sendStatusNotification(deps.client, sessionId, `## Historian recovery
+    } else if (fullFeatureMode && !compactionOff && isFirstTransformPassForSession && historianFailureState.failureCount > 0) {
+      startRecoveryRun(() => {
+        sessionLog(sessionId, `transform: historian recovery triggered on session load after ${historianFailureState.failureCount} failure(s)`);
+        if (deps.client) {
+          withoutSqliteTransformPass(() => sendStatusNotification(deps.client, sessionId, `## Historian recovery
 
 Historian previously failed ${historianFailureState.failureCount} time(s), so Magic Context is retrying history comparting immediately after restart.`, notificationParams));
-      }
+        }
+      });
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
     const memoryProjectDirectory = compartmentDirectory || process.cwd();
@@ -55670,7 +56073,9 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         input: lkgInput,
         output: messages,
         modelKey,
-        providerKey
+        providerKey,
+        systemPromptTokens: sessionMeta.systemPromptTokens,
+        agentName: notificationParams?.agent
       });
       if (captured) {
         const capturedSlot = getInMemorySlot(sessionId);
@@ -55964,6 +56369,7 @@ var init_transform = __esm(async () => {
     init_ctx_reduce_availability(),
     init_degraded_pass_refusal(),
     init_event_resolvers(),
+    init_historian_drain_gate(),
     init_inject_compartments(),
     init_protected_tail_boundary(),
     init_read_session_chunk(),
@@ -58598,7 +59004,8 @@ function hostUsesMediaAssets() {
   schemaUsesAssets.set(messageClass, uses);
   return uses;
 }
-function decodeThroughHostSchema(source) {
+function decodeThroughHostSchema(encoded) {
+  const source = encoded.source;
   const messageClass = rememberedMessageClass;
   if (!messageClass)
     return "no host message class seen";
@@ -58618,7 +59025,7 @@ function decodeThroughHostSchema(source) {
   const run = decode?.run;
   if (typeof run !== "function")
     return "host media schema has no decode transformation";
-  const result = run.call(decode, { _tag: "Some", value: { source } }, {});
+  const result = run.call(decode, { _tag: "Some", value: encoded }, {});
   const option = result?._tag === "Success" ? result.value : undefined;
   const asset = option?._tag === "Some" ? option.value : undefined;
   if (!isClassInstance(asset) || asset.source !== source)
@@ -58626,18 +59033,30 @@ function decodeThroughHostSchema(source) {
   return asset;
 }
 function hostMediaAsset(data, mediaType) {
-  const source = { type: "base64", data, mediaType };
+  return hostMediaFromEncoded({ source: { type: "base64", data, mediaType } });
+}
+function hostMediaFromEncoded(value) {
+  if (!isRecord6(value.source))
+    return "missing Media.Asset source";
+  const encoded = structuredClone(value);
+  if (encoded.source.type === "bytes") {
+    if (typeof encoded.source.data !== "string")
+      return "bytes media has no JSON codec payload";
+    encoded.source.data = new Uint8Array(Buffer.from(encoded.source.data, "base64"));
+  }
+  if (!["bytes", "base64", "url", "ref"].includes(String(encoded.source.type)))
+    return "unknown Media.Asset source";
   let first = "no Media.Asset seen in this process";
   if (rememberedAssetClass) {
     try {
-      return new rememberedAssetClass({ source });
+      return new rememberedAssetClass(encoded);
     } catch (error) {
       first = `remembered asset class threw: ${String(error)}`;
     }
   }
   let second;
   try {
-    const decoded = decodeThroughHostSchema(source);
+    const decoded = decodeThroughHostSchema(encoded);
     if (typeof decoded !== "string")
       return decoded;
     second = decoded;
@@ -58663,7 +59082,7 @@ var init_markers = __esm(() => {
 });
 
 // src/v2/fold/owner.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 
 class FoldOwner {
   storage;
@@ -58742,9 +59161,638 @@ class FoldOwner {
     });
   }
 }
-var foldDigest = (value) => createHash18("sha256").update(value).digest("hex");
+var foldDigest = (value) => createHash20("sha256").update(value).digest("hex");
 var init_owner = () => {};
 
+// src/v2/fold/memory-cache.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+class NativeFoldCache {
+  resolveDB;
+  sourceID = randomUUID4();
+  tails = new Map;
+  nativeRows = new Map;
+  admissions = new Map;
+  retention = new Map;
+  evictionListeners = new Set;
+  budget;
+  constructor(resolveDB, budget = DEFAULT_NATIVE_FOLD_BUDGET) {
+    this.resolveDB = resolveDB;
+    if (!Number.isSafeInteger(budget.maxSessionBytes) || budget.maxSessionBytes < 1 || !Number.isSafeInteger(budget.maxSessions) || budget.maxSessions < 1)
+      throw new Error("Native fold cache budgets must be positive integers");
+    this.budget = { ...budget };
+  }
+  onEvict(listener) {
+    this.evictionListeners.add(listener);
+  }
+  touch(sessionID) {
+    const state = this.retention.get(sessionID) ?? { active: 0, bytes: 0, replayBytes: 0 };
+    this.retention.delete(sessionID);
+    this.retention.set(sessionID, state);
+    return state;
+  }
+  hold(sessionID) {
+    const state = this.touch(sessionID);
+    state.active++;
+    return () => {
+      state.active--;
+      this.enforceBudget();
+    };
+  }
+  accountReplay(sessionID, bytes) {
+    this.touch(sessionID).replayBytes = bytes;
+    this.recount(sessionID);
+  }
+  usage() {
+    return {
+      sessions: this.retention.size,
+      bytes: [...this.retention.values()].reduce((total, state) => total + state.bytes, 0)
+    };
+  }
+  recount(sessionID) {
+    const state = this.touch(sessionID);
+    let bytes = 256 + stringBytes(sessionID) + state.replayBytes;
+    const tail = this.tails.get(sessionID);
+    if (tail)
+      bytes += 128 + stringBytes(tail.data) + stringBytes(tail.digest);
+    for (const row of this.nativeRows.get(sessionID)?.values() ?? [])
+      bytes += 256 + stringBytes(row.id) + stringBytes(row.type) + stringBytes(row.data) + stringBytes(row.digest);
+    for (const row of this.admissions.get(sessionID)?.values() ?? [])
+      bytes += 256 + stringBytes(row.admission_id) + stringBytes(row.status) + stringBytes(row.owner_token) + stringBytes(row.data) + stringBytes(row.payload) + stringBytes(row.digest);
+    state.bytes = bytes;
+    this.enforceBudget();
+  }
+  enforceBudget() {
+    for (const [id, state] of this.retention)
+      if (!state.active && state.bytes > this.budget.maxSessionBytes)
+        this.evict(id);
+    for (const [id, state] of this.retention) {
+      if (this.retention.size <= this.budget.maxSessions)
+        break;
+      if (!state.active)
+        this.evict(id);
+    }
+  }
+  evict(sessionID) {
+    this.tails.delete(sessionID);
+    this.nativeRows.delete(sessionID);
+    this.admissions.delete(sessionID);
+    this.retention.delete(sessionID);
+    for (const listener of this.evictionListeners)
+      listener(sessionID);
+  }
+  get db() {
+    return this.resolveDB();
+  }
+  tail(sessionID) {
+    const record = this.tails.get(sessionID);
+    if (record)
+      this.touch(sessionID);
+    return record && { ...record };
+  }
+  async saveTail(sessionID, data, rows) {
+    this.tails.set(sessionID, {
+      revision: (this.tails.get(sessionID)?.revision ?? -1) + 1,
+      data,
+      digest: foldDigest(data)
+    });
+    const kept = this.nativeRows.get(sessionID) ?? new Map;
+    for (const row of rows)
+      kept.set(row.id, Object.freeze({ ...row, revision: (kept.get(row.id)?.revision ?? -1) + 1 }));
+    this.nativeRows.set(sessionID, kept);
+    this.recount(sessionID);
+  }
+  replaceRows(sessionID, through, rows, after = -1) {
+    const kept = this.nativeRows.get(sessionID) ?? new Map;
+    for (const [id, row] of kept)
+      if (row.seq > after && row.seq <= through)
+        kept.delete(id);
+    for (const row of rows)
+      kept.set(row.id, Object.freeze({ ...row, revision: 0 }));
+    this.nativeRows.set(sessionID, kept);
+    this.recount(sessionID);
+  }
+  truncate(sessionID, through) {
+    const kept = this.nativeRows.get(sessionID);
+    if (kept) {
+      for (const [id, row] of kept)
+        if (row.seq > through)
+          kept.delete(id);
+    }
+    if (kept)
+      this.recount(sessionID);
+  }
+  sequenceForID(sessionID, id) {
+    return this.nativeRows.get(sessionID)?.get(id)?.seq;
+  }
+  containsRows(sessionID, ids) {
+    const kept = this.nativeRows.get(sessionID);
+    return ids.every((id) => kept?.has(id));
+  }
+  rows(sessionID, after, through) {
+    if (this.retention.has(sessionID))
+      this.touch(sessionID);
+    return [...this.nativeRows.get(sessionID)?.values() ?? []].filter((row) => row.seq > after && row.seq <= through).sort((a, b) => a.seq - b.seq).map((row) => ({ ...row }));
+  }
+  admission(sessionID, id) {
+    const record = this.admissions.get(sessionID)?.get(id);
+    if (record)
+      this.touch(sessionID);
+    return record && { ...record };
+  }
+  put(sessionID, id, record) {
+    const kept = this.admissions.get(sessionID) ?? new Map;
+    kept.set(id, Object.freeze({ ...record }));
+    this.admissions.set(sessionID, kept);
+    this.recount(sessionID);
+  }
+  async supply(sessionID, id, payload) {
+    const old = this.admission(sessionID, id);
+    this.put(sessionID, id, {
+      admission_id: id,
+      revision: (old?.revision ?? -1) + 1,
+      status: old?.status ?? "supplied",
+      owner_token: old?.owner_token ?? null,
+      data: old?.data ?? "{}",
+      payload,
+      digest: foldDigest(payload),
+      logged_at: old?.logged_at ?? null
+    });
+  }
+  latestAttempt(sessionID) {
+    const record = [...this.admissions.get(sessionID)?.values() ?? []].reverse().find((row) => JSON.parse(row.data).after !== undefined);
+    return record && { ...record };
+  }
+  async claim(sessionID, id, data, owner, _now) {
+    const old = this.admission(sessionID, id);
+    if (old?.owner_token || old?.logged_at !== null && old?.logged_at !== undefined)
+      return false;
+    this.put(sessionID, id, {
+      admission_id: id,
+      revision: 0,
+      status: "pending",
+      owner_token: owner,
+      data,
+      payload: old?.payload ?? null,
+      digest: old?.digest ?? null,
+      logged_at: null
+    });
+    return true;
+  }
+  async finish(sessionID, id, owner, status, now) {
+    const old = this.admission(sessionID, id);
+    if (!old || old.owner_token !== owner || old.status !== "pending")
+      return false;
+    this.put(sessionID, id, { ...old, status, owner_token: null, logged_at: now });
+    return true;
+  }
+  async forget(sessionID) {
+    this.evict(sessionID);
+  }
+}
+function nativeFoldCache(db, budget) {
+  return new NativeFoldCache(typeof db === "function" ? db : () => db, budget);
+}
+var DEFAULT_NATIVE_FOLD_BUDGET, stringBytes = (value) => (value?.length ?? 0) * 2;
+var init_memory_cache = __esm(() => {
+  init_owner();
+  DEFAULT_NATIVE_FOLD_BUDGET = Object.freeze({
+    maxSessionBytes: 16 * 1024 * 1024,
+    maxSessions: 16
+  });
+});
+
+// src/v2/tool-result.ts
+function isToolError(part) {
+  const result = part.result;
+  return part.resultType === "error" || result?.type === "error" || result !== null && typeof result === "object" && "error" in result;
+}
+function toolErrorText(result) {
+  const value = result.value === undefined ? result : result.value;
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function toolStateContent(state) {
+  if (typeof state.output === "string")
+    return state.output;
+  if (state.status === "error")
+    return toolErrorText({ error: state.error, content: state.content ?? [] });
+  if (typeof state.content === "string")
+    return state.content;
+  if (!Array.isArray(state.content))
+    return "";
+  return state.content.map((part) => {
+    if (typeof part === "string")
+      return part;
+    if (!part || typeof part !== "object")
+      return "";
+    const value = part;
+    if (typeof value.text === "string")
+      return value.text;
+    if (typeof value.value === "string")
+      return value.value;
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+
+// src/v2/hooks/payload.ts
+function rejectContentPart(message, part, reason) {
+  const type = typeof part.type === "string" ? part.type : "<missing>";
+  const text = `v2 context omitted a content part the host would reject: type=${type} message=${String(message.info.id ?? "<head>")} reason=${reason}`;
+  if (typeof message.info.sessionID === "string")
+    sessionLog(message.info.sessionID, text);
+  else
+    log(text);
+}
+function isHostInstance(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype !== Object.prototype && prototype !== null;
+}
+function containsHostInstance(value) {
+  if (isHostInstance(value))
+    return true;
+  if (Array.isArray(value))
+    return value.some(containsHostInstance);
+  if (value && typeof value === "object")
+    return Object.values(value).some(containsHostInstance);
+  return false;
+}
+function clonePreservingInstances(value) {
+  if (isHostInstance(value))
+    return value;
+  if (Array.isArray(value))
+    return value.map(clonePreservingInstances);
+  if (value && typeof value === "object") {
+    const copy = {};
+    for (const [key, entry] of Object.entries(value))
+      copy[key] = clonePreservingInstances(entry);
+    return copy;
+  }
+  return value;
+}
+function contentKey(value) {
+  const plain = (entry) => {
+    if (ArrayBuffer.isView(entry)) {
+      return {
+        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
+      };
+    }
+    if (Array.isArray(entry))
+      return entry.map(plain);
+    if (entry && typeof entry === "object") {
+      return Object.fromEntries(Object.entries(entry).map(([key, nested]) => [key, plain(nested)]));
+    }
+    return entry;
+  };
+  return JSON.stringify(plain(value));
+}
+function fileContentValue(result) {
+  const value = result?.value;
+  if (result?.type !== "content" || !Array.isArray(value))
+    return;
+  return value.some((item) => item?.type === "file") ? value : undefined;
+}
+function contentValueText(value) {
+  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
+`);
+}
+function contentValueAttachments(value) {
+  return value.filter((item) => item?.type === "file").map((item) => ({
+    type: "file",
+    mime: item.mime,
+    url: item.uri,
+    ...typeof item.name === "string" ? { filename: item.name } : {}
+  }));
+}
+function rebuildFileContent(value, output) {
+  if (isDroppedToolOutput(output))
+    return { type: "text", value: output };
+  const rebuilt = [];
+  let placed = false;
+  for (const item of value) {
+    if (item?.type !== "text") {
+      rebuilt.push(item);
+      continue;
+    }
+    if (placed)
+      continue;
+    placed = true;
+    rebuilt.push({ ...item, text: output });
+  }
+  if (!placed && output)
+    rebuilt.unshift({ type: "text", text: output });
+  return { type: "content", value: rebuilt };
+}
+function adaptPayload(draft, admittedIDs = new Set) {
+  const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
+  const source = draft.messages.filter((m) => !existingHeads.has(m.id));
+  const results = new Map;
+  const hostParts = new Map;
+  const hostPartTypes = new Set;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
+        const key = contentKey(part);
+        if (!hostParts.has(key))
+          hostParts.set(key, part);
+        hostPartTypes.add(part.type);
+      }
+      if (part.type === "tool-result" && typeof part.id === "string") {
+        const queue = results.get(part.id) ?? [];
+        queue.push({ part, message });
+        results.set(part.id, queue);
+      }
+    }
+  }
+  const paired = new Set;
+  const bridges = new Map;
+  const originals = new Map;
+  const bridgesByMessageID = new Map;
+  const bridgesByCarrier = new Map;
+  const originalsByID = new Map;
+  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
+  const nativeTool = (call, result) => {
+    const hostResult = result?.part.result;
+    const failed = result !== undefined && isToolError(result.part);
+    const value = hostResult?.value;
+    const files = fileContentValue(hostResult);
+    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
+    const part = {
+      type: "tool",
+      callID: call?.id ?? result?.part.id,
+      tool: call?.name ?? result?.part.name,
+      state: {
+        input: structuredClone(call?.input ?? {}),
+        status: failed ? "error" : result ? "completed" : "running",
+        ...result ? { output } : {},
+        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
+        ...files ? { attachments: contentValueAttachments(files) } : {}
+      }
+    };
+    bridges.set(part, {
+      call,
+      result: result?.part,
+      resultMessage: result?.message,
+      output,
+      files
+    });
+    if (result)
+      paired.add(result.part);
+    return part;
+  };
+  const convertedTool = (source) => {
+    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
+    const output = toolStateContent(sourceState);
+    const { content: _content, ...projectedState } = structuredClone(sourceState);
+    const part = {
+      type: "tool",
+      callID: source.callID ?? source.id,
+      tool: source.tool ?? source.name,
+      state: { ...projectedState, output }
+    };
+    bridges.set(part, { native: source, output });
+    return part;
+  };
+  const callParts = new Map;
+  for (const message of source) {
+    for (const part of message.content) {
+      if (part.type === "tool-call") {
+        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
+      } else if (part.type === "tool") {
+        callParts.set(part, convertedTool(part));
+      }
+    }
+  }
+  const messages = [];
+  for (const message of source) {
+    const parts = [];
+    for (const content of message.content) {
+      if (paired.has(content))
+        continue;
+      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
+      if (message.id && admittedIDs.has(message.id))
+        part.synthetic = true;
+      parts.push(part);
+    }
+    if (!parts.length && message.content.length)
+      continue;
+    const byCallID = new Map;
+    for (const part of parts) {
+      const bridge = bridges.get(part);
+      if (bridge && typeof part.callID === "string")
+        byCallID.set(part.callID, bridge);
+    }
+    if (typeof message.id === "string") {
+      bridgesByMessageID.set(message.id, byCallID);
+      originalsByID.set(message.id, message);
+    }
+    const mapped = {
+      info: {
+        id: message.id,
+        sessionID: draft.sessionID,
+        role: message.role,
+        ...{
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agent: draft.agent
+        }
+      },
+      parts
+    };
+    originals.set(mapped, message);
+    if (typeof message.id !== "string")
+      bridgesByCarrier.set(mapped, byCallID);
+    messages.push(mapped);
+  }
+  return {
+    messages,
+    commit() {
+      let head = 0;
+      const rendered = [];
+      for (const message of messages) {
+        const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
+        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
+        const content = [];
+        const following = [];
+        for (const candidate of message.parts) {
+          const part = candidate;
+          const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
+          if (!bridge) {
+            if (part.type === "tool") {
+              const state = part.state;
+              if (typeof part.callID !== "string" || typeof part.tool !== "string" || !state || typeof state !== "object") {
+                rejectContentPart(message, part, "tool has no call ID, name, or state");
+                continue;
+              }
+              content.push({
+                type: "tool-call",
+                id: part.callID,
+                name: part.tool,
+                input: state.input
+              });
+              if (state.status === "completed" || state.status === "error") {
+                following.push({
+                  role: "tool",
+                  content: [
+                    {
+                      type: "tool-result",
+                      id: part.callID,
+                      name: part.tool,
+                      result: {
+                        type: state.status === "error" ? "error" : "text",
+                        value: toolStateContent(state)
+                      }
+                    }
+                  ]
+                });
+              }
+              continue;
+            }
+            if (part.type === "file") {
+              const mime = part.mime;
+              const url = part.url;
+              const prefix = `data:${mime};base64,`;
+              if (typeof mime !== "string" || !/^image\/(png|jpeg|gif|webp)$/.test(mime) || typeof url !== "string" || !url.startsWith(prefix)) {
+                rejectContentPart(message, part, "file is not an inline supported image");
+                continue;
+              }
+              const asset = hostMediaAsset(url.slice(prefix.length), mime);
+              if (typeof asset === "string") {
+                rejectContentPart(message, part, `host media unavailable: ${asset}`);
+                continue;
+              }
+              content.push({ type: "media", media: asset });
+              continue;
+            }
+            if (!HOST_CONTENT_TYPES.has(String(part.type))) {
+              rejectContentPart(message, part, "unknown host content type");
+              continue;
+            }
+            const { synthetic: _synthetic, ...clean } = part;
+            const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
+            content.push(original ?? clean);
+            continue;
+          }
+          const state = part.state;
+          if (bridge.native) {
+            const native = bridge.native;
+            const callID = String(native.id ?? native.callID ?? part.callID);
+            const name = String(native.name ?? native.tool ?? part.tool);
+            content.push({ type: "tool-call", id: callID, name, input: state.input });
+            if (state.status === "completed" || state.status === "error") {
+              following.push({
+                role: "tool",
+                content: [
+                  {
+                    type: "tool-result",
+                    id: callID,
+                    name,
+                    result: {
+                      type: state.status === "error" ? "error" : "text",
+                      value: state.output
+                    }
+                  }
+                ]
+              });
+            }
+            continue;
+          }
+          if (bridge.call)
+            content.push({ ...bridge.call, input: state.input });
+          if (bridge.result && bridge.resultMessage) {
+            const result = {
+              ...bridge.result,
+              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
+                type: state.status === "error" ? "error" : "text",
+                value: state.output
+              }
+            };
+            if (bridge.resultMessage === original)
+              content.push(result);
+            else
+              following.push({ ...bridge.resultMessage, content: [result] });
+          }
+        }
+        if (content.length || !original?.content.length) {
+          const value = {
+            ...original,
+            id,
+            role: message.info.role ?? "user",
+            content
+          };
+          const existing = id ? existingHeads.get(id) : undefined;
+          rendered.push(existing ? Object.assign(existing, { content }) : value);
+        }
+        rendered.push(...following);
+      }
+      draft.messages.splice(0, draft.messages.length, ...rendered);
+    }
+  };
+}
+var HEAD_IDS, HOST_CONTENT_TYPES;
+var init_payload = __esm(() => {
+  init_ctx_reduce_nudge();
+  init_logger();
+  init_host_media();
+  HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
+  HOST_CONTENT_TYPES = new Set([
+    "text",
+    "media",
+    "tool-call",
+    "tool-result",
+    "reasoning",
+    "compaction",
+    "effort"
+  ]);
+});
+
+// src/v2/fold/native-codec.ts
+function encodeNative(messages) {
+  for (const message of messages)
+    for (const part of message.content) {
+      if (part.type !== "media" || !part.media)
+        continue;
+      const asset = part.media;
+      if (typeof asset.toJSON !== "function" || asset.headers !== undefined)
+        throw new NativeReplayUnavailable("Native media has no lossless replay codec");
+      const encoded = asset.toJSON();
+      const revived = hostMediaFromEncoded(encoded);
+      if (typeof revived === "string" || JSON.stringify(revived) !== JSON.stringify(asset))
+        throw new NativeReplayUnavailable("Native media cannot be decoded losslessly before admission");
+    }
+  const encoded = JSON.parse(JSON.stringify(messages));
+  const freeze = (value) => {
+    if (!value || typeof value !== "object")
+      return;
+    for (const item of Object.values(value))
+      freeze(item);
+    Object.freeze(value);
+  };
+  freeze(encoded);
+  return encoded;
+}
+function reviveNative(messages) {
+  const result = structuredClone([...messages]);
+  for (const message of result)
+    for (const part of message.content) {
+      if (part.type !== "media" || !part.media)
+        continue;
+      const asset = hostMediaFromEncoded(part.media);
+      if (typeof asset === "string")
+        throw new NativeReplayUnavailable(asset);
+      part.media = asset;
+    }
+  return result;
+}
+var NativeReplayUnavailable;
+var init_native_codec = __esm(() => {
+  init_host_media();
+  NativeReplayUnavailable = class NativeReplayUnavailable extends Error {
+  };
+});
+
 // src/v2/hooks/storage-notice.ts
 function formatStorageRefusalNotice(reason) {
   return `${STORAGE_NOTICE_PREFIX}This turn was not sent to the model. ${formatFailClosedBlockingSummary(reason)}`;
@@ -58978,6 +60026,411 @@ var init_restore = __esm(() => {
   imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 });
 
+// src/v2/fold/native-replay.ts
+function nativeRowID(message) {
+  return coordinates.get(message) ?? message.id;
+}
+function copyNativeInput(messages) {
+  const copies = reviveNative(encodeNative(messages));
+  copies.forEach((copy, i) => {
+    const original = messages[i];
+    const id = original && nativeRowID(original);
+    if (id !== undefined)
+      coordinates.set(copy, id);
+  });
+  return copies;
+}
+function isLocalCheckpoint(row) {
+  return row.type === "compaction" && row.data.status === "completed" && row.data.providerContext === undefined;
+}
+
+class NativeFoldReplay {
+  storage;
+  openReader;
+  changed = new Set;
+  dirty = new Set;
+  unavailable = new Set;
+  metadata = new Map;
+  metadataThrough = new Map;
+  loaded = new Map;
+  sources = new Map;
+  constructor(storage, openReader) {
+    this.storage = storage;
+    this.openReader = openReader;
+    storage.onEvict((sessionID) => this.clear(sessionID));
+  }
+  account(sessionID) {
+    const source = this.sources.get(sessionID);
+    let bytes = 256 + (source?.length ?? 0) * 2;
+    for (const row of this.metadata.get(sessionID) ?? [])
+      bytes += 128 + (row.id.length + row.type.length) * 2;
+    this.storage.accountReplay(sessionID, bytes);
+  }
+  async observeSource(sessionID, reader) {
+    const source = reader.hostIdentity();
+    const prior = this.sources.get(sessionID);
+    if (prior && prior !== source)
+      await this.forget(sessionID);
+    this.sources.set(sessionID, source);
+    this.account(sessionID);
+  }
+  onEvent(event) {
+    const sessionID = event.data?.sessionID;
+    if (sessionID && (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated"))
+      this.invalidate(sessionID);
+  }
+  invalidate(sessionID, suppressNomination = false) {
+    if (suppressNomination)
+      this.unavailable.add(sessionID);
+    this.dirty.add(sessionID);
+    this.changed.add(sessionID);
+    this.metadata.delete(sessionID);
+    this.metadataThrough.delete(sessionID);
+    this.account(sessionID);
+  }
+  tail(sessionID) {
+    const record = this.storage.tail(sessionID);
+    return record ? JSON.parse(record.data) : undefined;
+  }
+  async baseline(sessionID) {
+    return this.tail(sessionID)?.baseline;
+  }
+  rendered(row, model) {
+    return restoreRow(row, model, hostUsesMediaAssets() ? {
+      asset: hostMediaAsset,
+      unavailable: () => {}
+    } : undefined);
+  }
+  record(row, messages) {
+    const data = JSON.stringify(encodeNative(messages));
+    return { id: row.id, type: row.type, seq: row.seq, data, digest: foldDigest(data) };
+  }
+  records(sessionID, native, reader) {
+    let metadata = this.metadata.get(sessionID);
+    const through = reader.latestSequence(sessionID);
+    const known = new Set(metadata?.map((row) => row.id));
+    if (!metadata || (this.metadataThrough.get(sessionID) ?? -1) < through || native.some((message) => message.id && !known.has(message.id))) {
+      metadata = reader.rowStampsThrough(sessionID, through).filter(conversational);
+      this.metadata.set(sessionID, metadata);
+      this.metadataThrough.set(sessionID, through);
+    }
+    const byID = new Map(metadata.map((row) => [row.id, row]));
+    const grouped = new Map;
+    const anchorIndex = native.findIndex((message) => {
+      const id = nativeRowID(message);
+      return id !== undefined && byID.has(id);
+    });
+    const leading = native.slice(0, anchorIndex < 0 ? native.length : anchorIndex).filter((message) => !nativeRowID(message) && message.role === "system");
+    const anchorMessage = native[anchorIndex];
+    const anchorID = anchorMessage && nativeRowID(anchorMessage);
+    const anchor = anchorID ? byID.get(anchorID) : undefined;
+    const leadingRows = anchor ? metadata.filter((row) => row.type === "system" && row.seq < anchor.seq).slice(-leading.length) : [];
+    const leadingIDs = new Map(leading.map((message, i) => [message, leadingRows[i]?.id]));
+    let cursor = -1;
+    let owner;
+    for (const message of native) {
+      let id = nativeRowID(message);
+      if (!id && message.role === "system") {
+        if (leadingIDs.has(message)) {
+          id = leadingIDs.get(message);
+          if (!id)
+            continue;
+        } else
+          id = metadata.find((row) => row.type === "system" && row.seq > cursor)?.id;
+      }
+      if (!id && message.role === "tool")
+        id = owner;
+      const row = id ? byID.get(id) : undefined;
+      if (!row)
+        throw new NativeReplayUnavailable("Native carrier has no source row coordinate");
+      cursor = row.seq;
+      coordinates.set(message, row.id);
+      if (message.role !== "tool")
+        owner = row.id;
+      const messages = grouped.get(row) ?? [];
+      messages.push(message);
+      grouped.set(row, messages);
+    }
+    return [...grouped].map(([row, messages]) => this.record(row, messages));
+  }
+  async capture(draft, native) {
+    const release = this.storage.hold(draft.sessionID);
+    try {
+      rememberHostMedia(native);
+      const reader = this.openReader(draft.sessionID);
+      try {
+        const rows = this.records(draft.sessionID, native, reader);
+        const baseline = draft.messages.find((message) => message.id === HEAD_IDS[0])?.content.find((part) => part.type === "text")?.text;
+        const through = Math.max(-1, ...rows.map((row) => row.seq));
+        const tail = {
+          model: `${draft.model.providerID}/${draft.model.id}`,
+          sourceSeq: through,
+          baseline: typeof baseline === "string" ? baseline : this.tail(draft.sessionID)?.baseline
+        };
+        await this.storage.saveTail(draft.sessionID, JSON.stringify(tail), rows);
+        this.storage.truncate(draft.sessionID, through);
+        this.loaded.set(draft.sessionID, through);
+        this.unavailable.delete(draft.sessionID);
+        this.changed.delete(draft.sessionID);
+      } finally {
+        reader.close();
+      }
+    } catch {
+      this.unavailable.add(draft.sessionID);
+      this.invalidate(draft.sessionID);
+    } finally {
+      this.account(draft.sessionID);
+      release();
+    }
+  }
+  async canReplay(sessionID, _reader) {
+    return !this.unavailable.has(sessionID) && typeof await this.baseline(sessionID) === "string";
+  }
+  async supply(args) {
+    const release = this.storage.hold(args.draft.sessionID);
+    try {
+      return await this.supplyHeld(args);
+    } finally {
+      this.account(args.draft.sessionID);
+      release();
+    }
+  }
+  async supplyHeld(args) {
+    const { draft, reader, summary } = args;
+    const tail = this.tail(draft.sessionID);
+    const id = reader.latestRunningCompaction(draft.sessionID)?.id;
+    if (!id || !tail || tail.model !== `${draft.model.providerID}/${draft.model.id}`)
+      return false;
+    const through = reader.latestSequence(draft.sessionID);
+    const after = this.dirty.has(draft.sessionID) ? -1 : tail.sourceSeq;
+    const fresh = reader.range(draft.sessionID, after, through).filter(conversational);
+    const records = fresh.map((row) => this.record(row, this.rendered(row, draft.model)));
+    if (this.dirty.has(draft.sessionID))
+      this.storage.replaceRows(draft.sessionID, through, records);
+    await this.storage.saveTail(draft.sessionID, JSON.stringify({
+      ...tail,
+      sourceSeq: Math.max(tail.sourceSeq, ...fresh.map((row) => row.seq))
+    }), records);
+    this.dirty.delete(draft.sessionID);
+    this.metadata.delete(draft.sessionID);
+    this.metadataThrough.delete(draft.sessionID);
+    this.loaded.set(draft.sessionID, through);
+    const snapshot = {
+      source: this.storage.sourceID,
+      sessionID: draft.sessionID,
+      admissionID: id,
+      summary
+    };
+    await this.storage.supply(draft.sessionID, id, JSON.stringify(snapshot));
+    return true;
+  }
+  async restore(sessionID, cut, model, options = {}) {
+    const release = this.storage.hold(sessionID);
+    try {
+      return await this.restoreHeld(sessionID, cut, model, options);
+    } finally {
+      this.account(sessionID);
+      release();
+    }
+  }
+  async restoreHeld(sessionID, cut, model, options) {
+    if (!isLocalCheckpoint(cut))
+      return;
+    const resolvedModel = {
+      providerID: model.slice(0, model.indexOf("/")),
+      id: model.slice(model.indexOf("/") + 1)
+    };
+    const tail = this.tail(sessionID);
+    if (tail && tail.model !== model)
+      this.invalidate(sessionID);
+    let after = options.after ?? -1;
+    if (options.bounded && options.after === undefined && !this.changed.has(sessionID)) {
+      const state = getOrCreateSessionMeta(this.storage.db, sessionID);
+      const max = this.storage.db.prepare("SELECT COALESCE(MAX(id),0) AS id FROM m0_mutation_log WHERE session_id=?").get(sessionID);
+      const boundary = this.storage.db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id=?").get(sessionID)?.id;
+      if (max.id <= (state.cachedM0MaxMutationId ?? 0) && boundary)
+        after = this.storage.sequenceForID(sessionID, boundary) ?? -1;
+    }
+    const through = cut.seq - 1;
+    let reader;
+    try {
+      let metadata = this.metadata.get(sessionID);
+      if (!metadata || (this.metadataThrough.get(sessionID) ?? -1) < through) {
+        reader = this.openReader(sessionID);
+        metadata = reader.rowStampsThrough(sessionID, through).filter(conversational);
+        this.metadata.set(sessionID, metadata);
+        this.metadataThrough.set(sessionID, through);
+      }
+      const required = metadata.filter((row) => row.seq > after && row.seq <= through);
+      if (this.dirty.has(sessionID) || !tail || (this.loaded.get(sessionID) ?? -1) < through && !this.storage.admission(sessionID, cut.id) || !this.storage.containsRows(sessionID, required.map((row) => row.id))) {
+        reader ??= this.openReader(sessionID);
+        const fresh = reader.range(sessionID, after, through).filter(conversational);
+        const records = fresh.map((row) => this.record(row, this.rendered(row, resolvedModel)));
+        const restored = new Set(records.map((row) => row.id));
+        if (required.some((row) => !restored.has(row.id)))
+          throw new NativeReplayUnavailable("Host restore omitted a required source row");
+        this.storage.replaceRows(sessionID, through, records, after);
+        await this.storage.saveTail(sessionID, JSON.stringify({
+          model,
+          sourceSeq: through,
+          baseline: tail?.baseline ?? cut.data.summary
+        }), []);
+        this.loaded.set(sessionID, through);
+        this.dirty.delete(sessionID);
+      }
+    } finally {
+      reader?.close();
+    }
+    const messages = [];
+    for (const row of this.storage.rows(sessionID, after, cut.seq - 1)) {
+      const revived = reviveNative(JSON.parse(row.data));
+      for (const message of revived)
+        coordinates.set(message, row.id);
+      messages.push(...revived);
+    }
+    return messages;
+  }
+  async restoreRead(sessionID, cut, model) {
+    const reader = this.openReader(sessionID);
+    try {
+      return reader.range(sessionID, -1, cut.seq - 1).filter(conversational).flatMap((row) => {
+        const messages = this.rendered(row, model);
+        for (const message of messages)
+          coordinates.set(message, row.id);
+        return messages;
+      });
+    } finally {
+      reader.close();
+    }
+  }
+  sourceChanged(sessionID) {
+    return this.changed.has(sessionID);
+  }
+  clear(sessionID) {
+    this.sources.delete(sessionID);
+    this.metadata.delete(sessionID);
+    this.metadataThrough.delete(sessionID);
+    this.loaded.delete(sessionID);
+    this.unavailable.delete(sessionID);
+    this.dirty.delete(sessionID);
+    this.changed.delete(sessionID);
+  }
+  async forget(sessionID) {
+    await this.storage.forget(sessionID);
+  }
+}
+var coordinates, conversational = (row) => RAW_MESSAGE_TYPES.includes(row.type) || row.type === "location-switched";
+var init_native_replay = __esm(async () => {
+  init_payload();
+  init_host_media();
+  init_native_codec();
+  init_owner();
+  init_restore();
+  await __promiseAll([
+    init_storage(),
+    init_store_reader()
+  ]);
+  coordinates = new WeakMap;
+});
+
+// src/v2/fold/policy.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+
+class HostFoldPolicy {
+  deps;
+  active = new Set;
+  owner = randomUUID5();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  owned(sessionID, cut, id) {
+    const row = this.deps.storage.admission(sessionID, id);
+    if (!isLocalCheckpoint(cut) || cut.id !== id || !row?.payload || row.digest !== foldDigest(row.payload))
+      return false;
+    const snapshot = JSON.parse(row.payload);
+    return snapshot.summary === cut.data.summary && snapshot.source === this.deps.storage.sourceID && snapshot.sessionID === sessionID && snapshot.admissionID === id;
+  }
+  async idle(sessionID) {
+    const { storage, session, threshold } = this.deps;
+    if (!Number.isSafeInteger(threshold) || threshold <= 0 || typeof session.compact !== "function" || this.active.has(sessionID))
+      return;
+    this.active.add(sessionID);
+    const now = this.deps.now ?? Date.now;
+    let attempt;
+    let claimed = false;
+    try {
+      const reader = this.deps.openReader();
+      try {
+        const cut = reader.latestCompaction(sessionID);
+        const previous = storage.latestAttempt(sessionID);
+        const old = previous ? JSON.parse(previous.data) : undefined;
+        if (cut && previous?.status === "pending" && old && this.owned(sessionID, cut, old.id)) {
+          if (await storage.claim(sessionID, old.id, previous.data, this.owner, now()) && await storage.finish(sessionID, old.id, this.owner, "completed", now()))
+            this.deps.log(sessionID, `v2 host fold: rows_before=${old.before} rows_after=${reader.storedRowsAfter(sessionID, cut.seq)} duration_ms=${now() - old.started} reason=row_threshold id=${cut.id} status=completed`);
+          return;
+        }
+        const after = cut?.seq ?? -1;
+        const before = reader.storedRowsAfter(sessionID, after);
+        if (before < threshold || !await this.deps.canReplay(sessionID, reader))
+          return;
+        const retry = old?.after === after ? old.attempt + (previous?.status === "failed" || previous?.status === "coalesced" ? 1 : 0) : 0;
+        const id = old?.after === after && previous?.status === "pending" ? old.id : `msg_mc_fold_${foldDigest(`${storage.sourceID}/${sessionID}/${after}/${retry}`).slice(0, 24)}`;
+        attempt = {
+          after,
+          before,
+          watermark: reader.latestSequence(sessionID),
+          attempt: retry,
+          id,
+          started: now()
+        };
+        claimed = await storage.claim(sessionID, id, JSON.stringify(attempt), this.owner, now());
+        if (!claimed)
+          return;
+      } finally {
+        reader.close();
+      }
+      const admitted = await session.compact({
+        sessionID,
+        id: attempt.id,
+        delivery: "queue"
+      });
+      await session.wait({ sessionID });
+      const settled = this.deps.openReader();
+      try {
+        const cut = settled.latestCompaction(sessionID);
+        if (admitted?.id !== attempt.id || !cut || cut.seq <= attempt.after || !this.owned(sessionID, cut, attempt.id)) {
+          if (await storage.finish(sessionID, attempt.id, this.owner, "coalesced", now()))
+            this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=unknown duration_ms=${now() - attempt.started} reason=row_threshold id=${attempt.id} actual_id=${cut?.id ?? admitted?.id ?? "unknown"} status=coalesced`);
+          return;
+        }
+        const after = settled.storedRowsAfter(sessionID, cut.seq);
+        if (await storage.finish(sessionID, attempt.id, this.owner, "completed", now()))
+          this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=${after} duration_ms=${now() - attempt.started} reason=row_threshold id=${cut.id} status=completed`);
+      } finally {
+        settled.close();
+      }
+    } catch (error) {
+      if (claimed && attempt) {
+        let finished = false;
+        try {
+          finished = await storage.finish(sessionID, attempt.id, this.owner, "failed", now());
+        } catch {
+          finished = true;
+        }
+        if (finished)
+          this.deps.log(sessionID, `v2 host fold: rows_before=${attempt.before} rows_after=unknown duration_ms=${now() - attempt.started} reason=row_threshold id=${attempt.id} status=failed error=${JSON.stringify(String(error))}`);
+      } else
+        this.deps.log(sessionID, `v2 host fold: rows_before=unknown rows_after=unknown duration_ms=0 reason=row_threshold status=failed error=${JSON.stringify(String(error))} cache_error=${JSON.stringify(String(error))}`);
+    } finally {
+      this.active.delete(sessionID);
+    }
+  }
+}
+var init_policy = __esm(async () => {
+  init_owner();
+  await init_native_replay();
+});
+
 // src/v2/fork-inheritance.ts
 function forkBoundarySeq(origin, sequenceForId) {
   const seq = sequenceForId(origin.parentSessionID, origin.boundary.messageID);
@@ -59106,11 +60559,7 @@ function keptUnderRetention(keepSubagents, child) {
   return keepSubagents && (child.ever_settled === true || child.role === "historian");
 }
 function roleTitle(role) {
-  if (role === "maintainer-a")
-    return "Magic Context maintainer A";
-  if (role === "maintainer-b")
-    return "Magic Context maintainer B";
-  return "Magic Context historian";
+  return HIDDEN_CHILD_ROLE_TITLES[role];
 }
 function roleAgent(role) {
   if (role === "maintainer-a")
@@ -59157,9 +60606,15 @@ function errorText(value) {
     return String(value);
   }
 }
+var HIDDEN_CHILD_ROLE_TITLES;
 var init_hidden_child_record = __esm(() => {
   init_memory_maintainer();
   init_hidden_child();
+  HIDDEN_CHILD_ROLE_TITLES = {
+    "maintainer-a": "Magic Context maintainer A",
+    "maintainer-b": "Magic Context maintainer B",
+    historian: "Magic Context historian"
+  };
 });
 
 // src/v2/hidden-child-native.ts
@@ -59686,7 +61141,8 @@ async function createV2HiddenCompletionExecutor(host, options) {
           aborted
         ]);
         if (!attempt.shaped) {
-          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", "Host did not dispatch the hidden child context hook", true);
+          const task = run.identity.title.replace(/^magic-context-dream-/, "");
+          throw new HiddenCompletionRefusal("hidden_prompt_unrecognized", `Host did not dispatch the hidden child context hook (task=${task}, agent=${run.identity.agent}, child=${run.child.id}, directory=${run.identity.directory}, stage=context/HiddenChildHook.apply). Check that the child's location loads the owning Magic Context instance; changing models cannot repair missing context shaping.`, true);
         }
         const text = assistantText(row);
         const system = typeof request.body.system === "string" ? request.body.system : run.identity.system;
@@ -60010,392 +61466,6 @@ class DeletedSessionTombstones {
   }
 }
 
-// src/v2/tool-result.ts
-function isToolError(part) {
-  const result = part.result;
-  return part.resultType === "error" || result?.type === "error" || result !== null && typeof result === "object" && "error" in result;
-}
-function toolErrorText(result) {
-  const value = result.value === undefined ? result : result.value;
-  return typeof value === "string" ? value : JSON.stringify(value);
-}
-function toolStateContent(state) {
-  if (typeof state.output === "string")
-    return state.output;
-  if (state.status === "error")
-    return toolErrorText({ error: state.error, content: state.content ?? [] });
-  if (typeof state.content === "string")
-    return state.content;
-  if (!Array.isArray(state.content))
-    return "";
-  return state.content.map((part) => {
-    if (typeof part === "string")
-      return part;
-    if (!part || typeof part !== "object")
-      return "";
-    const value = part;
-    if (typeof value.text === "string")
-      return value.text;
-    if (typeof value.value === "string")
-      return value.value;
-    return "";
-  }).filter(Boolean).join(`
-`);
-}
-
-// src/v2/hooks/payload.ts
-function rejectContentPart(message, part, reason) {
-  const type = typeof part.type === "string" ? part.type : "<missing>";
-  const text = `v2 context omitted a content part the host would reject: type=${type} message=${String(message.info.id ?? "<head>")} reason=${reason}`;
-  if (typeof message.info.sessionID === "string")
-    sessionLog(message.info.sessionID, text);
-  else
-    log(text);
-}
-function isHostInstance(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype !== Object.prototype && prototype !== null;
-}
-function containsHostInstance(value) {
-  if (isHostInstance(value))
-    return true;
-  if (Array.isArray(value))
-    return value.some(containsHostInstance);
-  if (value && typeof value === "object")
-    return Object.values(value).some(containsHostInstance);
-  return false;
-}
-function clonePreservingInstances(value) {
-  if (isHostInstance(value))
-    return value;
-  if (Array.isArray(value))
-    return value.map(clonePreservingInstances);
-  if (value && typeof value === "object") {
-    const copy = {};
-    for (const [key, entry] of Object.entries(value))
-      copy[key] = clonePreservingInstances(entry);
-    return copy;
-  }
-  return value;
-}
-function contentKey(value) {
-  const plain = (entry) => {
-    if (ArrayBuffer.isView(entry)) {
-      return {
-        bytes: Buffer.from(entry.buffer, entry.byteOffset, entry.byteLength).toString("base64")
-      };
-    }
-    if (Array.isArray(entry))
-      return entry.map(plain);
-    if (entry && typeof entry === "object") {
-      return Object.fromEntries(Object.entries(entry).map(([key, nested]) => [key, plain(nested)]));
-    }
-    return entry;
-  };
-  return JSON.stringify(plain(value));
-}
-function fileContentValue(result) {
-  const value = result?.value;
-  if (result?.type !== "content" || !Array.isArray(value))
-    return;
-  return value.some((item) => item?.type === "file") ? value : undefined;
-}
-function contentValueText(value) {
-  return value.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join(`
-`);
-}
-function contentValueAttachments(value) {
-  return value.filter((item) => item?.type === "file").map((item) => ({
-    type: "file",
-    mime: item.mime,
-    url: item.uri,
-    ...typeof item.name === "string" ? { filename: item.name } : {}
-  }));
-}
-function rebuildFileContent(value, output) {
-  if (isDroppedToolOutput(output))
-    return { type: "text", value: output };
-  const rebuilt = [];
-  let placed = false;
-  for (const item of value) {
-    if (item?.type !== "text") {
-      rebuilt.push(item);
-      continue;
-    }
-    if (placed)
-      continue;
-    placed = true;
-    rebuilt.push({ ...item, text: output });
-  }
-  if (!placed && output)
-    rebuilt.unshift({ type: "text", text: output });
-  return { type: "content", value: rebuilt };
-}
-function adaptPayload(draft, admittedIDs = new Set) {
-  const existingHeads = new Map(draft.messages.filter((m) => HEAD_IDS.some((id) => m.id === id)).map((m) => [m.id, m]));
-  const source = draft.messages.filter((m) => !existingHeads.has(m.id));
-  const results = new Map;
-  const hostParts = new Map;
-  const hostPartTypes = new Set;
-  for (const message of source) {
-    for (const part of message.content) {
-      if (part.type !== "tool-call" && part.type !== "tool-result" && part.type !== "tool" && containsHostInstance(part)) {
-        const key = contentKey(part);
-        if (!hostParts.has(key))
-          hostParts.set(key, part);
-        hostPartTypes.add(part.type);
-      }
-      if (part.type === "tool-result" && typeof part.id === "string") {
-        const queue = results.get(part.id) ?? [];
-        queue.push({ part, message });
-        results.set(part.id, queue);
-      }
-    }
-  }
-  const paired = new Set;
-  const bridges = new Map;
-  const originals = new Map;
-  const bridgesByMessageID = new Map;
-  const bridgesByCarrier = new Map;
-  const originalsByID = new Map;
-  const bridgesFor = (message) => typeof message.info.id === "string" ? bridgesByMessageID.get(message.info.id) : bridgesByCarrier.get(message);
-  const nativeTool = (call, result) => {
-    const hostResult = result?.part.result;
-    const failed = result !== undefined && isToolError(result.part);
-    const value = hostResult?.value;
-    const files = fileContentValue(hostResult);
-    const output = failed && hostResult ? toolErrorText(hostResult) : files ? contentValueText(files) : typeof value === "string" ? value : value === undefined ? "" : JSON.stringify(value);
-    const part = {
-      type: "tool",
-      callID: call?.id ?? result?.part.id,
-      tool: call?.name ?? result?.part.name,
-      state: {
-        input: structuredClone(call?.input ?? {}),
-        status: failed ? "error" : result ? "completed" : "running",
-        ...result ? { output } : {},
-        ...result && (call?.name ?? result.part.name) === "question" ? { metadata: { userAnswer: true } } : {},
-        ...files ? { attachments: contentValueAttachments(files) } : {}
-      }
-    };
-    bridges.set(part, {
-      call,
-      result: result?.part,
-      resultMessage: result?.message,
-      output,
-      files
-    });
-    if (result)
-      paired.add(result.part);
-    return part;
-  };
-  const convertedTool = (source) => {
-    const sourceState = source.state && typeof source.state === "object" ? source.state : {};
-    const output = toolStateContent(sourceState);
-    const { content: _content, ...projectedState } = structuredClone(sourceState);
-    const part = {
-      type: "tool",
-      callID: source.callID ?? source.id,
-      tool: source.tool ?? source.name,
-      state: { ...projectedState, output }
-    };
-    bridges.set(part, { native: source, output });
-    return part;
-  };
-  const callParts = new Map;
-  for (const message of source) {
-    for (const part of message.content) {
-      if (part.type === "tool-call") {
-        callParts.set(part, nativeTool(part, results.get(String(part.id))?.shift()));
-      } else if (part.type === "tool") {
-        callParts.set(part, convertedTool(part));
-      }
-    }
-  }
-  const messages = [];
-  for (const message of source) {
-    const parts = [];
-    for (const content of message.content) {
-      if (paired.has(content))
-        continue;
-      const part = callParts.get(content) ?? (content.type === "tool-result" ? nativeTool(undefined, { part: content, message }) : clonePreservingInstances(content));
-      if (message.id && admittedIDs.has(message.id))
-        part.synthetic = true;
-      parts.push(part);
-    }
-    if (!parts.length && message.content.length)
-      continue;
-    const byCallID = new Map;
-    for (const part of parts) {
-      const bridge = bridges.get(part);
-      if (bridge && typeof part.callID === "string")
-        byCallID.set(part.callID, bridge);
-    }
-    if (typeof message.id === "string") {
-      bridgesByMessageID.set(message.id, byCallID);
-      originalsByID.set(message.id, message);
-    }
-    const mapped = {
-      info: {
-        id: message.id,
-        sessionID: draft.sessionID,
-        role: message.role,
-        ...{
-          providerID: draft.model.providerID,
-          modelID: draft.model.id,
-          agent: draft.agent
-        }
-      },
-      parts
-    };
-    originals.set(mapped, message);
-    if (typeof message.id !== "string")
-      bridgesByCarrier.set(mapped, byCallID);
-    messages.push(mapped);
-  }
-  return {
-    messages,
-    commit() {
-      let head = 0;
-      const rendered = [];
-      for (const message of messages) {
-        const original = originals.get(message) ?? (typeof message.info.id === "string" ? originalsByID.get(message.info.id) : undefined);
-        const id = message.info.syntheticHead ? HEAD_IDS[head++] : original?.id;
-        const content = [];
-        const following = [];
-        for (const candidate of message.parts) {
-          const part = candidate;
-          const bridge = bridges.get(part) ?? (part.type === "tool" && typeof part.callID === "string" ? bridgesFor(message)?.get(part.callID) : undefined);
-          if (!bridge) {
-            if (part.type === "tool") {
-              const state = part.state;
-              if (typeof part.callID !== "string" || typeof part.tool !== "string" || !state || typeof state !== "object") {
-                rejectContentPart(message, part, "tool has no call ID, name, or state");
-                continue;
-              }
-              content.push({
-                type: "tool-call",
-                id: part.callID,
-                name: part.tool,
-                input: state.input
-              });
-              if (state.status === "completed" || state.status === "error") {
-                following.push({
-                  role: "tool",
-                  content: [
-                    {
-                      type: "tool-result",
-                      id: part.callID,
-                      name: part.tool,
-                      result: {
-                        type: state.status === "error" ? "error" : "text",
-                        value: toolStateContent(state)
-                      }
-                    }
-                  ]
-                });
-              }
-              continue;
-            }
-            if (part.type === "file") {
-              const mime = part.mime;
-              const url = part.url;
-              const prefix = `data:${mime};base64,`;
-              if (typeof mime !== "string" || !/^image\/(png|jpeg|gif|webp)$/.test(mime) || typeof url !== "string" || !url.startsWith(prefix)) {
-                rejectContentPart(message, part, "file is not an inline supported image");
-                continue;
-              }
-              const asset = hostMediaAsset(url.slice(prefix.length), mime);
-              if (typeof asset === "string") {
-                rejectContentPart(message, part, `host media unavailable: ${asset}`);
-                continue;
-              }
-              content.push({ type: "media", media: asset });
-              continue;
-            }
-            if (!HOST_CONTENT_TYPES.has(String(part.type))) {
-              rejectContentPart(message, part, "unknown host content type");
-              continue;
-            }
-            const { synthetic: _synthetic, ...clean } = part;
-            const original = hostPartTypes.has(clean.type) && !containsHostInstance(clean) ? hostParts.get(contentKey(clean)) : undefined;
-            content.push(original ?? clean);
-            continue;
-          }
-          const state = part.state;
-          if (bridge.native) {
-            const native = bridge.native;
-            const callID = String(native.id ?? native.callID ?? part.callID);
-            const name = String(native.name ?? native.tool ?? part.tool);
-            content.push({ type: "tool-call", id: callID, name, input: state.input });
-            if (state.status === "completed" || state.status === "error") {
-              following.push({
-                role: "tool",
-                content: [
-                  {
-                    type: "tool-result",
-                    id: callID,
-                    name,
-                    result: {
-                      type: state.status === "error" ? "error" : "text",
-                      value: state.output
-                    }
-                  }
-                ]
-              });
-            }
-            continue;
-          }
-          if (bridge.call)
-            content.push({ ...bridge.call, input: state.input });
-          if (bridge.result && bridge.resultMessage) {
-            const result = {
-              ...bridge.result,
-              result: state.output === bridge.output ? bridge.result.result : bridge.files && typeof state.output === "string" ? rebuildFileContent(bridge.files, state.output) : {
-                type: state.status === "error" ? "error" : "text",
-                value: state.output
-              }
-            };
-            if (bridge.resultMessage === original)
-              content.push(result);
-            else
-              following.push({ ...bridge.resultMessage, content: [result] });
-          }
-        }
-        if (content.length || !original?.content.length) {
-          const value = {
-            ...original,
-            id,
-            role: message.info.role ?? "user",
-            content
-          };
-          const existing = id ? existingHeads.get(id) : undefined;
-          rendered.push(existing ? Object.assign(existing, { content }) : value);
-        }
-        rendered.push(...following);
-      }
-      draft.messages.splice(0, draft.messages.length, ...rendered);
-    }
-  };
-}
-var HEAD_IDS, HOST_CONTENT_TYPES;
-var init_payload = __esm(() => {
-  init_ctx_reduce_nudge();
-  init_logger();
-  init_host_media();
-  HEAD_IDS = ["__magic_context_v2_m0__", "__magic_context_v2_m1__"];
-  HOST_CONTENT_TYPES = new Set([
-    "text",
-    "media",
-    "tool-call",
-    "tool-result",
-    "reasoning",
-    "compaction",
-    "effort"
-  ]);
-});
-
 // src/v2/hooks/generate.ts
 class V2GenerateReplay {
   prefixes = new Map;
@@ -60445,9 +61515,9 @@ var init_hidden_terminal_error = __esm(() => {
 });
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash19 } from "node:crypto";
-function identity(slot) {
-  return createHash19("sha256").update(JSON.stringify({
+import { createHash as createHash21 } from "node:crypto";
+function identity2(slot) {
+  return createHash21("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -60462,14 +61532,14 @@ class V2LkgSystemReplay {
   systems = new BoundedSessionMap(1000);
   capture(sessionId, slot, input, served) {
     this.systems.set(sessionId, {
-      slot: identity(slot),
+      slot: identity2(slot),
       input: JSON.stringify(input),
       served: structuredClone(served)
     });
   }
   restore(sessionId, slot, input, target) {
     const saved = this.systems.get(sessionId);
-    if (!slot || !saved || saved.slot !== identity(slot) || saved.input !== JSON.stringify(input))
+    if (!slot || !saved || saved.slot !== identity2(slot) || saved.input !== JSON.stringify(input))
       return false;
     target.splice(0, target.length, ...structuredClone(saved.served));
     return true;
@@ -60662,7 +61732,7 @@ function hasRequiredSessionAPI(session) {
 var OPENCODE2_SESSION_API_NOTICE = "Magic Context is disabled: OpenCode 2.0.22 or newer is required (session.remove and session.compact). Upgrade OpenCode and restart.";
 
 // src/features/magic-context/session-project-backfill.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync14 } from "node:fs";
 function ensureBackfillStateTable2(db) {
   db.exec(`
@@ -60799,7 +61869,7 @@ async function runSessionProjectBackfill(db, source, options = {}) {
   const now = options.now ?? Date.now;
   const resolveIdentity = options.resolveIdentity ?? ((directory) => resolveProjectIdentityForSession(directory, options.allowHomeProject));
   const yieldFn = options.yieldFn ?? defaultYieldFn;
-  const holderId = options.holderId ?? randomUUID4();
+  const holderId = options.holderId ?? randomUUID6();
   const readPage = createPageReader(source);
   const result = {
     status: "completed",
@@ -62222,7 +63292,7 @@ __export(exports_regexes2, {
   extendedDuration: () => extendedDuration,
   guid: () => guid2,
   hex: () => hex,
-  hostname: () => hostname,
+  hostname: () => hostname2,
   html5Email: () => html5Email,
   idnEmail: () => idnEmail,
   integer: () => integer2,
@@ -62292,7 +63362,7 @@ var cuid3, cuid22, ulid2, xid2, ksuid2, nanoid2, duration3, extendedDuration, gu
   if (!version)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
   return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
-}, uuid4, uuid6, uuid7, email2, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv42, ipv62, cidrv42, cidrv62, base642, base64url2, hostname, domain, e1642, dateSource2 = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date3, string3 = (params) => {
+}, uuid4, uuid6, uuid7, email2, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv42, ipv62, cidrv42, cidrv62, base642, base64url2, hostname2, domain, e1642, dateSource2 = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date3, string3 = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 }, bigint2, integer2, number3, boolean3, _null3, _undefined3, lowercase2, uppercase2, hex, md5_hex, md5_base64, md5_base64url, sha1_hex, sha1_base64, sha1_base64url, sha256_hex, sha256_base64, sha256_base64url, sha384_hex, sha384_base64, sha384_base64url, sha512_hex, sha512_base64, sha512_base64url;
@@ -62321,7 +63391,7 @@ var init_regexes2 = __esm(() => {
   cidrv62 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
   base642 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
   base64url2 = /^[A-Za-z0-9_-]*$/;
-  hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+  hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
   domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
   e1642 = /^\+(?:[0-9]){6,14}[0-9]$/;
   date3 = /* @__PURE__ */ new RegExp(`^${dateSource2}$`);
@@ -63432,7 +64502,7 @@ var init_schemas3 = __esm(() => {
               code: "invalid_format",
               format: "url",
               note: "Invalid hostname",
-              pattern: hostname.source,
+              pattern: hostname2.source,
               input: payload.value,
               inst,
               continue: !def.abort
@@ -72706,8 +73776,8 @@ function jwt(params) {
 function stringFormat(format, fnOrRegex, _params = {}) {
   return _stringFormat2(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname2(_params) {
-  return _stringFormat2(ZodCustomStringFormat, "hostname", hostname, _params);
+function hostname3(_params) {
+  return _stringFormat2(ZodCustomStringFormat, "hostname", hostname2, _params);
 }
 function hex2(_params) {
   return _stringFormat2(ZodCustomStringFormat, "hex", hex, _params);
@@ -73792,7 +74862,7 @@ __export(exports_external2, {
   guid: () => guid3,
   hash: () => hash,
   hex: () => hex2,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   httpUrl: () => httpUrl,
   includes: () => _includes2,
   instanceof: () => _instanceof,
@@ -74073,7 +75143,7 @@ function resolveCtxExpandMode(args, domain) {
 var init_mode = () => {};
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash20 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 function isRecord7(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -74162,7 +75232,7 @@ function reasoningOf(part) {
 function renderPartPreview(part, expandTools) {
   if (!isRecord7(part))
     return null;
-  const expansion = expandToolPart(part, expandTools);
+  const expansion = expandToolPart(part, expandTools, true);
   if (expansion !== null)
     return `    • tool ${part.tool}: ${expansion}`;
   const text = textOf(part);
@@ -74297,7 +75367,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord7(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord7(part) && typeof part.text === "string" && createHash20("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord7(part) && typeof part.text === "string" && createHash22("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   return selected ? renderPartFull(selected) ?? "" : `Tag ${number}'s original text part is no longer in stored history.`;
 }
@@ -74445,7 +75515,7 @@ var init_memory_visibility = __esm(() => {
 
 // src/tools/ctx-memory/types.ts
 var CTX_MEMORY_ACTIONS;
-var init_types = __esm(() => {
+var init_types2 = __esm(() => {
   CTX_MEMORY_ACTIONS = ["write", "update", "archive", "merge", "get"];
 });
 
@@ -74469,7 +75539,7 @@ var init_verification_recording = __esm(() => {
 
 // src/tools/ctx-memory/tools.ts
 function isMemoryCategory2(value) {
-  return MEMORY_CATEGORIES.has(value);
+  return MEMORY_CATEGORIES2.has(value);
 }
 function getAllowedActions(deps) {
   const allowed = deps.allowedActions?.length ? deps.allowedActions : CTX_MEMORY_ACTIONS;
@@ -74871,7 +75941,7 @@ function createCtxMemoryTools(deps) {
     [CTX_MEMORY_TOOL_NAME]: createCtxMemoryTool(deps)
   };
 }
-var MEMORY_CATEGORIES, GET_NOT_VISIBLE_MESSAGE = (id) => `id ${id}: not found or not visible from this project`, GET_MAX_IDS = 20, DUPLICATE_MEMORY_ERROR = (id) => `Error: Memory content already exists as ID ${id}; merge or archive duplicates instead.`, ctxMemoryArgsShape, ctxMemoryArgsSchema;
+var MEMORY_CATEGORIES2, GET_NOT_VISIBLE_MESSAGE = (id) => `id ${id}: not found or not visible from this project`, GET_MAX_IDS = 20, DUPLICATE_MEMORY_ERROR = (id) => `Error: Memory content already exists as ID ${id}; merge or archive duplicates instead.`, ctxMemoryArgsShape, ctxMemoryArgsSchema;
 var init_tools2 = __esm(async () => {
   init_dist();
   init_memory_visibility();
@@ -74879,7 +75949,7 @@ var init_tools2 = __esm(async () => {
   init_project_identity();
   init_user_facing_codes();
   init_unwrap_imitated_reduced_args();
-  init_types();
+  init_types2();
   init_verification_recording();
   await __promiseAll([
     init_context_authority(),
@@ -74887,7 +75957,7 @@ var init_tools2 = __esm(async () => {
     init_storage_memory(),
     init_storage()
   ]);
-  MEMORY_CATEGORIES = new Set(CATEGORY_PRIORITY);
+  MEMORY_CATEGORIES2 = new Set(CATEGORY_PRIORITY);
   ctxMemoryArgsShape = {
     action: tool.schema.enum([...CTX_MEMORY_ACTIONS]).optional().describe("write | update | archive | merge | get"),
     content: tool.schema.string().optional().describe("The memory text — one standalone fact (write, update, merge)."),
@@ -74901,7 +75971,7 @@ var init_tools2 = __esm(async () => {
 // src/tools/ctx-memory/index.ts
 var init_ctx_memory = __esm(async () => {
   init_tools2();
-  init_types();
+  init_types2();
 });
 
 // src/tools/ctx-note/constants.ts
@@ -75934,6 +77004,8 @@ async function registerContext(context) {
     return;
   }
   const folds = new FoldOwner(context.storage);
+  const nativeFoldMemory = !compactionOff && process.env.MMC_OC2_INVISIBLE_FOLD === "1" ? nativeFoldCache(() => storage.require()) : undefined;
+  const nativeFoldReplay = nativeFoldMemory ? new NativeFoldReplay(nativeFoldMemory, () => openStoreReader()) : undefined;
   setOutputReserveConfig(config.output_reserve);
   const queriedModels = new Set;
   const rawLimits = new Map;
@@ -75965,7 +77037,7 @@ async function registerContext(context) {
   let storageRecoveryAnnounced = false;
   const storageNoticeBySession = new Map;
   const storeStorageNotice = (sessionID, text, what) => {
-    withoutSqliteTransformPass(() => context.session.wait({ sessionID }).then(() => deliverSynthetic(context, sessionID, text)).catch((error) => sessionLog(sessionID, `v2 storage ${what} notice could not be delivered:`, error)));
+    withoutSqliteTransformPass(() => Promise.resolve().then(() => context.session.wait({ sessionID })).then(() => deliverSynthetic(context, sessionID, text)).catch((error) => sessionLog(sessionID, `v2 storage ${what} notice could not be delivered:`, error)));
   };
   const noticeStorageRefusal = (sessionID, reason) => {
     const message = formatStorageRefusalNotice(reason);
@@ -76232,6 +77304,14 @@ async function registerContext(context) {
     }
     return unsafe;
   };
+  const hostFolds = nativeFoldReplay && nativeFoldMemory ? new HostFoldPolicy({
+    session: context.session,
+    storage: nativeFoldMemory,
+    openReader: openStoreReader,
+    canReplay: (sessionID, reader) => nativeFoldReplay.canReplay(sessionID, reader),
+    threshold: Number(process.env.MMC_OC2_HOST_FOLD_ROWS ?? 1000),
+    log: sessionLog
+  }) : undefined;
   const usageController = new AbortController;
   const usageDone = (async () => {
     try {
@@ -76242,6 +77322,10 @@ async function registerContext(context) {
         if (!event.data?.sessionID)
           continue;
         const sessionID = event.data.sessionID;
+        if (event.type?.startsWith("session.revert.") || event.type === "session.message.content.updated") {
+          nativeFoldReplay?.onEvent(event);
+          restoredRows.forget(sessionID);
+        }
         if (event.type === "session.error" || event.type === "session.execution.failed") {
           const error = hiddenTerminalError(event);
           if (error !== undefined)
@@ -76267,6 +77351,7 @@ async function registerContext(context) {
           pendingMaterializationSessions.delete(sessionID);
           lastHeuristicsTurnId.delete(sessionID);
           restoredRows.forget(sessionID);
+          await nativeFoldReplay?.forget(sessionID);
           generateReplay.forget(sessionID);
           systemPromptRefreshSessions.delete(sessionID);
           systemPrompt?.clearSession(sessionID);
@@ -76279,11 +77364,14 @@ async function registerContext(context) {
         if (event.type !== "session.execution.succeeded")
           continue;
         const model = liveModels.get(sessionID);
-        if (model)
+        if (model) {
           await recordUsage({
             sessionID,
             model: { providerID: model.providerID, id: model.modelID }
           });
+          if (!compactionOff && typeof await nativeFoldReplay?.baseline(sessionID) === "string")
+            hostFolds?.idle(sessionID);
+        }
       }
     } catch (error) {
       if (!usageController.signal.aborted)
@@ -76318,10 +77406,32 @@ async function registerContext(context) {
     }
     if (compactionOff)
       return;
+    if (nativeFoldReplay)
+      rememberHostMedia(draft.messages);
     const reader = openStoreReader();
     try {
       const watermark = reader.latestSequenceForIds(draft.sessionID, draft.messages.flatMap((message) => message.id ? [message.id] : []));
       const running = reader.latestRunningCompaction(draft.sessionID);
+      if (nativeFoldReplay) {
+        try {
+          if (await nativeFoldReplay.canReplay(draft.sessionID, reader)) {
+            const state = getOrCreateSessionMeta(storage.require(), draft.sessionID);
+            const summary = await nativeFoldReplay.baseline(draft.sessionID) ?? state.cachedM0Bytes?.toString("utf8") ?? "<session-history></session-history>";
+            if (await nativeFoldReplay.supply({
+              draft,
+              reader,
+              previousCut: reader.latestCompaction(draft.sessionID),
+              summary
+            })) {
+              draft.result = { summary };
+              return;
+            }
+          }
+        } catch (error) {
+          nativeFoldReplay.invalidate(draft.sessionID, true);
+          sessionLog(draft.sessionID, `v2 host fold: legacy compaction reason=${JSON.stringify(String(error))}`);
+        }
+      }
       const fold = await folds.supply({
         sessionID: draft.sessionID,
         watermark,
@@ -76368,12 +77478,88 @@ async function registerContext(context) {
       withoutSqliteTransformPass(() => warmModelLimitCacheFromCatalog(context));
     agents.set(draft.sessionID, draft.agent);
     applyV2PromptSurfaceTools(draft, promptSurfaceRuntime, config.prompt_surface);
+    const admissionDb = db ?? storage.current();
+    const replayFits = (messages) => {
+      const system = structuredClone(draft.system);
+      if (!admissionDb || !draft.tools || !lkgSystems.restore(draft.sessionID, getSlot(draft.sessionID), draft.system, system))
+        return false;
+      const limit = lkgReplayLimit({
+        db: admissionDb,
+        sessionId: draft.sessionID,
+        model: {
+          providerID: draft.model.providerID,
+          modelID: draft.model.id
+        },
+        modelKey: `${draft.model.providerID}/${draft.model.id}`
+      });
+      if (limit === undefined)
+        return false;
+      let toolDefinitionTokens = 0;
+      for (const tool of Object.values(draft.tools)) {
+        if (!tool || typeof tool.description !== "string" || !tool.input)
+          return false;
+        const schema = JSON.stringify(tool.input);
+        if (!schema)
+          return false;
+        toolDefinitionTokens += estimateTokens(tool.description) + estimateTokens(schema);
+      }
+      return measureLkgReplay({
+        messages,
+        limit,
+        estimate: () => estimateFinalWireInputTokens({
+          messages,
+          toolDefinitionTokens,
+          systemPromptTokens: estimateTokens(JSON.stringify(system)),
+          providerID: draft.model.providerID,
+          modelID: draft.model.id,
+          agentName: draft.agent
+        })
+      }).fit === "under";
+    };
     let postFold = false;
     try {
-      const admissionDb = db ?? storage.current();
       if (!compactionOff && admissionDb)
         await withAsyncPrivilegedWriter(admissionDb, () => {
           return;
+        }, {
+          beforeRetry: (_error) => {
+            let replayBlocked = false;
+            const mapped = adaptPayload(draft);
+            try {
+              const overflowDb = db;
+              if (overflowDb !== undefined && overflowDb !== null && (isEmergencyRecoveryArmed(draft.sessionID) || getOverflowState(overflowDb, draft.sessionID).needsEmergencyRecovery)) {
+                replayBlocked = true;
+                sessionLog(draft.sessionID, "lkg_emergency_armed");
+              } else {
+                const keys = resolveLkgModelKeys(mapped.messages);
+                const replay = replayLkg({
+                  sessionId: draft.sessionID,
+                  messages: mapped.messages,
+                  modelKey: keys.modelKey,
+                  providerKey: keys.providerKey
+                });
+                if (replay.ok && !replayFits(replay.messages)) {
+                  replayBlocked = true;
+                  sessionLog(draft.sessionID, "lkg_replay_does_not_fit");
+                } else if (replay.ok) {
+                  restoreLkgSystem();
+                  mapped.messages.splice(0, mapped.messages.length, ...replay.messages);
+                  mapped.commit();
+                  sessionLog(draft.sessionID, "lkg_replay_served");
+                  throw new V2LkgAdmissionReplay;
+                } else {
+                  sessionLog(draft.sessionID, replay.reason);
+                }
+              }
+            } catch (replayError) {
+              if (replayError instanceof V2LkgAdmissionReplay)
+                throw replayError;
+              replayBlocked = true;
+              sessionLog(draft.sessionID, "lkg_replay_unavailable", replayError);
+            }
+            if (replayBlocked)
+              sessionLog(draft.sessionID, "lkg_replay_declined");
+          }
         });
       if (admissionDb)
         hideSubagentTools(draft, admissionDb);
@@ -76528,7 +77714,28 @@ async function registerContext(context) {
         postFold = cut !== undefined;
         if (cut && !incoming)
           throw new Error("The host checkpoint disappeared from the context draft");
-        if (cut && incoming) {
+        let nativeRestored;
+        if (cut && nativeFoldReplay && isLocalCheckpoint(cut)) {
+          try {
+            nativeRestored = await nativeFoldReplay.restore(draft.sessionID, cut, `${draft.model.providerID}/${draft.model.id}`, { bounded: true });
+          } catch (error) {
+            nativeFoldReplay.invalidate(draft.sessionID, true);
+            sessionLog(draft.sessionID, "v2 host fold: cache unavailable; restoring host rows", error);
+            nativeRestored = await nativeFoldReplay.restoreRead(draft.sessionID, cut, draft.model);
+          }
+        }
+        if (nativeRestored && nativeFoldReplay?.sourceChanged(draft.sessionID)) {
+          historyRefreshSessions.add(draft.sessionID);
+          pendingMaterializationSessions.add(draft.sessionID);
+        }
+        if (cut && incoming && nativeRestored) {
+          const present = new Set(draft.messages.flatMap((message) => message.id ? [message.id] : []));
+          const hidden = nativeRestored.filter((message) => {
+            const id = nativeRowID(message);
+            return !id || !present.has(id);
+          });
+          draft.messages.splice(0, draft.messages.length, ...hidden, ...draft.messages.filter((message) => message !== incoming));
+        } else if (cut && incoming) {
           const identity = await folds.observe({
             sessionID: draft.sessionID,
             cutSeq: cut.seq,
@@ -76555,6 +77762,14 @@ async function registerContext(context) {
       } finally {
         reader.close();
       }
+      let nativeMessages;
+      if (nativeFoldReplay) {
+        try {
+          nativeMessages = copyNativeInput(draft.messages);
+        } catch {
+          nativeFoldReplay.invalidate(draft.sessionID, true);
+        }
+      }
       const mapped = adaptPayload(draft, admitted);
       beginV2LkgRequest(draft.sessionID, `${draft.model.providerID}/${draft.model.id}`, latestLkgResponseIds.get(draft.sessionID));
       await transform({}, mapped);
@@ -76580,6 +77795,14 @@ ${baseline}
           draft.messages.splice(0, draft.messages.length, checkpoint, ...draft.messages.filter((message) => message !== head));
         }
       }
+      if (nativeMessages && !checkpoint) {
+        try {
+          await nativeFoldReplay?.capture(draft, nativeMessages);
+        } catch (error) {
+          nativeFoldReplay?.invalidate(draft.sessionID, true);
+          sessionLog(draft.sessionID, "v2 host fold: optional capture unavailable", error);
+        }
+      }
       const capturedSlot = getSlot(draft.sessionID);
       if (capturedSlot && (!slotAtEntry || capturedSlot.capturedAt !== slotAtEntry.capturedAt || capturedSlot.captureSequence !== slotAtEntry.captureSequence || capturedSlot.jsonPrefix !== slotAtEntry.jsonPrefix)) {
         lkgSystems.capture(draft.sessionID, capturedSlot, systemAtEntry, draft.system);
@@ -76587,6 +77810,8 @@ ${baseline}
     } catch (error) {
       if (error instanceof V2ContextRefusal)
         throw error;
+      if (error instanceof V2LkgAdmissionReplay)
+        return;
       if (!compactionOff && (isTransientSqliteError(error) || error instanceof StorageBusyRefusalError)) {
         if (isTransientSqliteError(error)) {
           try {
@@ -76614,13 +77839,16 @@ ${baseline}
                 modelKey: keys.modelKey,
                 providerKey: keys.providerKey
               });
-              if (replay.ok) {
+              if (replay.ok && !replayFits(replay.messages)) {
+                sessionLog(draft.sessionID, "lkg_replay_does_not_fit");
+              } else if (replay.ok) {
                 restoreLkgSystem();
                 replayMapped.messages.splice(0, replayMapped.messages.length, ...replay.messages);
                 replayMapped.commit();
                 return;
+              } else {
+                sessionLog(draft.sessionID, replay.reason);
               }
-              sessionLog(draft.sessionID, replay.reason);
             }
           } catch (replayError) {
             replayBlocked = true;
@@ -76774,7 +78002,7 @@ ${baseline}
     }
   };
 }
-var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
+var HIDDEN_SESSION_ERROR_GRACE_MS = 50, V2LkgAdmissionReplay;
 var init_context = __esm(async () => {
   init_memory_maintainer();
   init_config();
@@ -76789,6 +78017,7 @@ var init_context = __esm(async () => {
   init_derive_budgets();
   init_dropped_input_guard();
   init_emergency_fail_closed();
+  init_final_wire_token_estimate();
   init_lkg_measured_request();
   init_lkg_persist();
   init_lkg_replay();
@@ -76806,6 +78035,7 @@ var init_context = __esm(async () => {
   init_parameter_descriptions();
   init_host_media();
   init_markers();
+  init_memory_cache();
   init_owner();
   init_restore();
   init_hidden_child_cleanup();
@@ -76835,6 +78065,7 @@ var init_context = __esm(async () => {
     init_history_boundary_repair(),
     init_hook_handlers(),
     init_inject_compartments(),
+    init_lkg_replay_fit(),
     init_protected_tail_boundary(),
     init_read_session_chunk(),
     init_storage_busy_refusal(),
@@ -76843,6 +78074,8 @@ var init_context = __esm(async () => {
     init_rpc_handlers(),
     init_subagent_tool_policy(),
     init_sqlite(),
+    init_native_replay(),
+    init_policy(),
     init_fork_inheritance(),
     init_store_reader(),
     init_channel2(),
@@ -76851,6 +78084,8 @@ var init_context = __esm(async () => {
     init_tools6(),
     init_usage_persist()
   ]);
+  V2LkgAdmissionReplay = class V2LkgAdmissionReplay extends Error {
+  };
 });
 
 // src/v2/server.ts