@retaw106/mmc-pi 2.0.0 → 2.1.1

package/dist/index.js

@@ -165,7 +165,7 @@ import {
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-kxehmcmt.js";
+} from "./index-4n1w7ehq.js";
 import {
   registerSlowWriteReporter,
   registerSqliteDiagnosticSink,
@@ -175,9 +175,11 @@ import {
   withSqliteBackgroundWriter,
   withSqliteTransformPass,
   withoutSqliteTransformPass,
+  guardSqliteTransformPass,
   isTransientSqliteError,
+  withAsyncPrivilegedWriter,
   withPrivilegedWriter
-} from "./index-wv28nczk.js";
+} from "./index-ny303arh.js";
 import {
   pushNotification2
 } from "./index-b3eqj1g6.js";
@@ -189,7 +191,7 @@ import {
 // src/index.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join14, resolve as resolve7 } from "node:path";
+import { join as join14, resolve as resolve8 } from "node:path";
 
 // ../plugin/src/config/agent-disable.ts
 var COMPACTION_ENABLED_PATH = `compaction${"."}enabled`;
@@ -8084,6 +8086,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];
@@ -8097,6 +8103,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)));
@@ -10152,6 +10178,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));
@@ -10183,17 +10244,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);
     }
@@ -10202,7 +10253,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;
@@ -11043,6 +11094,10 @@ function resolveEpochFloorForPass(db, sessionId, inputs) {
 import { Buffer as Buffer3 } from "node:buffer";
 
 // ../plugin/src/v2/store-reader.ts
+import { createHash as createHash4 } from "node:crypto";
+import { statSync as statSync3 } from "node:fs";
+import { hostname } from "node:os";
+import { resolve as resolve3 } from "node:path";
 function gaDatabasePath(dataHome, channel = "latest", env = process.env) {
   return resolveOpenCodeDbPath("v2", { dataHome, channel, env }).path;
 }
@@ -11155,6 +11210,8 @@ function decode2(row) {
   return { ...row, data };
 }
 function connect(path, identity = "") {
+  const stat = statSync3(path);
+  const acquiredIdentity = identity || `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
   const db = new Database(path, { readonly: true, fileMustExist: true });
   try {
     assertOpenCodeStoreGeneration(db, "v2", path);
@@ -11166,7 +11223,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();
@@ -11179,15 +11236,20 @@ function closeConnection(connection) {
   }
 }
 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 createHash4("sha256").update(JSON.stringify([hostname(), resolve3(this.path), this.connection.identity])).digest("hex");
+  }
   prepare(sql) {
     if (this.closed)
       throw new Error("Store reader is closed");
@@ -11283,6 +11345,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);
@@ -11526,10 +11592,10 @@ function resolveIsSubagentFromOpenCode2Db(sessionId) {
 }
 
 // ../plugin/src/features/magic-context/message-fts-rowid-map.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
 var BACKFILL_STATE_ID = 1;
-var EMPTY_INDEX_CONTENT_HASH = createHash4("sha256").update("").digest("hex");
+var EMPTY_INDEX_CONTENT_HASH = createHash5("sha256").update("").digest("hex");
 var upsertMapStatements = new WeakMap;
 var rangeReadyStatements = new WeakMap;
 var updateTimeStatements = new WeakMap;
@@ -11732,11 +11798,17 @@ 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 readSessionMeta(db, sessionId) {
+  return findSessionMeta(db, sessionId) ?? getDefaultSessionMeta(sessionId);
+}
+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;
@@ -11863,10 +11935,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 };
 }
 
 // ../plugin/src/features/magic-context/session-project-backfill.ts
@@ -13233,7 +13309,7 @@ function ensureContextStoreUuid(db) {
   return getContextStoreUuid(db) ?? minted;
 }
 // ../plugin/src/features/magic-context/message-index.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var MESSAGE_HISTORY_ORPHAN_SAFETY_AGE_MS = 24 * 60 * 60 * 1000;
 var MESSAGE_HISTORY_ORPHAN_SWEEP_COOLDOWN_MS = 10 * 60 * 1000;
 var MESSAGE_HISTORY_ORPHAN_UNAVAILABLE_REPROBE_MS = 24 * 60 * 60 * 1000;
@@ -13440,7 +13516,7 @@ function toMessageIndexSource(message) {
     role: message.role,
     createdAt: message.createdAt,
     sourceVersion: normalizeSourceVersion(message.version),
-    contentHash: createHash5("sha256").update(content).digest("hex"),
+    contentHash: createHash6("sha256").update(content).digest("hex"),
     content
   };
 }
@@ -13662,7 +13738,7 @@ function indexItemsAfterOrdinal(db, sessionId, items, finalWatermark, toSource)
   return inserted;
 }
 // ../plugin/src/features/magic-context/lkg-prefix-chunks.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 var LKG_PREFIX_CHUNK_CHARS = 64 * 1024;
 function splitLkgPrefix(jsonPrefix) {
   const chunks = [];
@@ -13680,10 +13756,10 @@ function splitLkgPrefix(jsonPrefix) {
   return chunks;
 }
 function hashLkgChunk(body) {
-  return createHash6("sha256").update(body).digest("hex");
+  return createHash7("sha256").update(body).digest("hex");
 }
 function hashLkgChunkList(chunkHashes) {
-  return createHash6("sha256").update(chunkHashes.join(`
+  return createHash7("sha256").update(chunkHashes.join(`
 `)).digest("hex");
 }
 function layoutLkgPrefix(jsonPrefix) {
@@ -14153,7 +14229,7 @@ async function runMigrationsWithRetry(db, options = {}) {
   }
 }
 // ../plugin/src/hooks/magic-context/lkg-slot.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 
 // ../plugin/src/shared/bounded-session-map.ts
 class BoundedSessionMap {
@@ -14308,7 +14384,7 @@ function lkgContentFields(value) {
   }
 }
 function lkgContentDigestFromFields(fields) {
-  const hash = createHash7("sha256");
+  const hash = createHash8("sha256");
   for (const field of fields) {
     const value = typeof field === "symbol" ? field.description ?? "" : String(field);
     hash.update(`${typeof field}:${value.length}:`).update(value).update("\x00");
@@ -15135,8 +15211,8 @@ function copySessionStateForClone(db, sourceSessionId, destinationSessionId, fil
   });
 }
 // ../plugin/src/features/magic-context/storage-db.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync3, unlinkSync } from "node:fs";
-import { basename, dirname as dirname3, join as join6, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync4, unlinkSync } from "node:fs";
+import { basename, dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
 
 // ../plugin/src/plugin/boot-quiet.ts
 var BOOT_QUIET_MS = 120000;
@@ -15626,7 +15702,7 @@ var RPC_DISCOVERY_PARSE_GRACE_MS = 10 * 60 * 1000;
 var defaultRpcDiscoveryFs = {
   readdirSync: (path, options) => options?.withFileTypes ? readdirSync2(path, { withFileTypes: true }) : readdirSync2(path),
   readFileSync: (path, encoding) => String(readFileSync9(path, encoding)),
-  statSync: (path) => ({ mtimeMs: statSync3(path).mtimeMs }),
+  statSync: (path) => ({ mtimeMs: statSync4(path).mtimeMs }),
   unlinkSync: (path) => unlinkSync(path)
 };
 var rpcDiscoveryFs = defaultRpcDiscoveryFs;
@@ -15830,7 +15906,7 @@ function isDefaultSharedDatabasePath(dbPath) {
   if (!process.env.XDG_DATA_HOME && (process.env.MMC_TEST_DATA_DIR || false)) {
     return false;
   }
-  return resolve3(dbPath) === resolve3(join6(getMagicContextStorageDir(), "context.db"));
+  return resolve4(dbPath) === resolve4(join6(getMagicContextStorageDir(), "context.db"));
 }
 function migrationBlockingPiPids(dbPath, discovery, discoveredPiPids) {
   if (isDefaultSharedDatabasePath(dbPath))
@@ -15915,8 +15991,8 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
       startMessageFtsRowidMapBackfill(db).then(async () => {
         if (!readsOpenCodeStore)
           return;
-        const { readRawSessionMessagePage, readRawSessionMessages } = await import("./read-session-chunk-7m31yz4a.js");
-        const { startMessageTimeBackfill } = await import("./message-time-backfill-wnxmrd09.js");
+        const { readRawSessionMessagePage, readRawSessionMessages } = await import("./read-session-chunk-7wcjah1z.js");
+        const { startMessageTimeBackfill } = await import("./message-time-backfill-a3p9r5rh.js");
         await startMessageTimeBackfill(db, Object.assign(readRawSessionMessages, {
           readPage: readRawSessionMessagePage
         }));
@@ -18115,7 +18191,7 @@ var ERROR_CLASSES = new Set([
   "unknown"
 ]);
 // ../plugin/src/features/magic-context/workspaces.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/memory/constants.ts
 var V2_MEMORY_CATEGORIES = [
@@ -18342,7 +18418,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 = createHash8("sha256");
+  const hash = createHash9("sha256");
   hash.update("share_categories", "utf8");
   hash.update("\x00");
   hash.update(shareCategories === null ? "NO_WORKSPACE" : JSON.stringify(shareCategories), "utf8");
@@ -19056,8 +19132,8 @@ function resolveHistorianModel(config, harness) {
 }
 
 // ../plugin/src/shared/prompt-surface-runtime.ts
-import { readFileSync as readFileSync11, statSync as statSync4 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync11, statSync as statSync5 } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve5 } from "node:path";
 
 // ../plugin/src/tools/light-descriptions.ts
 var CTX_REDUCE_LIGHT_DESCRIPTION = `Stamp an item as no longer needed for the work ahead. Not a delete: stamping QUEUES it, the item stays readable until Magic Context clears stamped items in one sweep, newest tags are protected, and a cleared item goes to the archive (recent: a [dropped §N§] placeholder; older: removed) recoverable via mmc_expand(tag=N). The question is "does this need to stay on my desk for what comes next?" — a file you keep editing stays, the grep that found it goes. Stamp used reads/searches/outputs, acted-on build/test output, redundant dumps, extracted pasted payloads; keep user messages, your own text, unresolved errors, raw evidence, exact wording that may matter. Look at each tag; never blanket-stamp "1-50". Grammar: "3-5", "1,2,9", "1-5,8,12-15".`;
@@ -19090,7 +19166,7 @@ function promptSurfaceHashMaterial(systemContent, preset = "full") {
 var PROMPT_SURFACE_TOOL_ID_SET = new Set(ACTIVE_TOOL_IDS);
 function resolveUserConfigDirectory(options) {
   if (options.userConfigDirectory)
-    return resolve4(options.userConfigDirectory);
+    return resolve5(options.userConfigDirectory);
   return dirname4(opencodeUserConfigBasePath());
 }
 function markerCount(content) {
@@ -19108,10 +19184,10 @@ function createPromptSurfaceRuntime(options) {
   const readGuidanceOverride = (configuredPath) => {
     if (!configuredPath)
       return;
-    const path = isAbsolute2(configuredPath) ? configuredPath : resolve4(userConfigDirectory, configuredPath);
+    const path = isAbsolute2(configuredPath) ? configuredPath : resolve5(userConfigDirectory, configuredPath);
     let content;
     try {
-      if (!statSync4(path).isFile()) {
+      if (!statSync5(path).isFile()) {
         warnOnce(`guidance-not-file:${path}`, `prompt_surface.guidance_override_path (${path}) is not a file; using built-in guidance.`);
         return;
       }
@@ -21092,12 +21168,14 @@ function normalizeMaterializeReason(harness, reason, rematerialized) {
   }
   return rematerialized ? "pressure_refold" : null;
 }
-function recordPendingPiTransformDecision(sessionId, decision, snapshotNewestAssistantEntryId) {
+function recordPendingPiTransformDecision(sessionId, decision, snapshotNewestAssistantEntryId, publicationGuard) {
+  publicationGuard?.();
   if (!decision.bustedThisPass)
     return;
   pendingPiDecisionBySession.set(sessionId, {
     ...decision,
-    snapshotNewestAssistantEntryId
+    snapshotNewestAssistantEntryId,
+    publicationGuard
   });
 }
 function findNewestPiAssistantEntryId(entries) {
@@ -21122,6 +21200,14 @@ function schedulePiTransformDecisionResolve(args) {
   const pending = pendingPiDecisionBySession.get(args.sessionId);
   if (!pending)
     return false;
+  try {
+    pending.publicationGuard?.();
+    args.assertCurrentPass?.();
+  } catch {
+    pendingPiDecisionBySession.delete(args.sessionId);
+    sessionLog(args.sessionId, "DISCARDED CONTEXT RESULT: pending Pi transform decision");
+    return false;
+  }
   const targetMessageId = findNewestPiAssistantEntryIdAfter(args.branchEntries, pending.snapshotNewestAssistantEntryId);
   if (!targetMessageId)
     return false;
@@ -21134,6 +21220,13 @@ function schedulePiTransformDecisionResolve(args) {
     try {
       if (!hasScheduledWriteToken(args.sessionId, token))
         return;
+      try {
+        pending.publicationGuard?.();
+        args.assertCurrentPass?.();
+      } catch {
+        sessionLog(args.sessionId, "DISCARDED CONTEXT RESULT: queued Pi transform decision");
+        return;
+      }
       writeTransformDecisionBestEffort(dbPath, {
         ...pending,
         sessionId: args.sessionId,
@@ -22700,12 +22793,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();
@@ -22860,6 +22955,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,
@@ -22879,7 +22975,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,
@@ -22907,7 +23004,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({
@@ -23138,6 +23235,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;
@@ -23208,6 +23307,29 @@ function recordHighPressureNoEligibleHead(db, snapshot) {
   return recordProtectedTailNoEligibleHead(db, snapshot.sessionId);
 }
 
+// ../plugin/src/hooks/magic-context/historian-drain-gate.ts
+var loggedWindows = new WeakMap;
+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;
+}
+
 // ../plugin/src/hooks/magic-context/active-anthropic-turn.ts
 function isInActiveAnthropicTurn(messages, index, anthropic) {
   if (!anthropic)
@@ -23490,7 +23612,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,
@@ -23502,7 +23624,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 = readSessionChunk2(sessionId, scanBudget, rawEligibility.offset, boundary.protectedTailStart);
+      const chunk = readSessionChunk2(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,
@@ -23529,6 +23651,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) {
@@ -23808,13 +23938,13 @@ function hasMuralCueRejectionCountColumn(db) {
 }
 
 // ../plugin/src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash9("md5").update(normalized).digest("hex");
+  return createHash10("md5").update(normalized).digest("hex");
 }
 
 // ../plugin/src/features/magic-context/memory/visibility.ts
@@ -24400,14 +24530,14 @@ function archiveMemory(db, id, reason) {
 }
 
 // ../plugin/src/features/magic-context/compaction-marker.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import { existsSync as existsSync9 } from "node:fs";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 var ID_PREFIX_HEX_LENGTH = 12;
 var ID_SUFFIX_LENGTH = 14;
 var ID_PREFIX_MASK = (1n << BigInt(ID_PREFIX_HEX_LENGTH * 4)) - 1n;
 function deterministicBase62(seed, length) {
-  let value = BigInt(`0x${createHash10("sha256").update(seed).digest("hex")}`);
+  let value = BigInt(`0x${createHash11("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)];
@@ -25693,9 +25823,9 @@ function advanceToolReclaimWatermarkToCurrentMax(db, sessionId) {
 }
 
 // ../plugin/src/shared/tag-transcript.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function textIdentityDigest(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function buildContentDerivedTextIds(messageId, parts) {
   const sources = parts.filter((part) => part.kind === "text").map((part) => stripTagPrefix(part.getText() ?? ""));
@@ -26636,6 +26766,22 @@ function searchMemoriesFTSUnion(db, projectPaths, query, limit = DEFAULT_SEARCH_
 function clearMemoryVerifications(db, memoryId) {
   db.prepare("DELETE FROM memory_verifications WHERE memory_id = ?").run(memoryId);
 }
+// ../plugin/src/features/magic-context/memory/types.ts
+var 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
+};
+var MEMORY_CATEGORIES = Object.keys(MEMORY_CATEGORY_RECORD);
 // ../plugin/src/features/magic-context/memory/verification-paths.ts
 import { execFile as execFile2 } from "node:child_process";
 import { promisify } from "node:util";
@@ -28031,8 +28177,10 @@ function findLatestMeaningfulUserMessage(messages, entryIds, entryIdByRef) {
     const msg = messages[i];
     if (msg?.role !== "user")
       continue;
-    if (collectUserPromptParts(msg).trim().length === 0)
+    const promptText = extractUserPromptText(msg);
+    if (promptText.length === 0 || !hasMeaningfulUserText2([{ type: "text", text: promptText }])) {
       continue;
+    }
     if (entryIdByRef) {
       const byRef = msg && typeof msg === "object" ? entryIdByRef.get(msg) : undefined;
       if (typeof byRef === "string") {
@@ -28072,6 +28220,8 @@ function appendHintToUserMessage(message, hint) {
 }
 async function runAutoSearchHintForPi(args) {
   const startedAt = performance.now();
+  args.passGuard?.assert();
+  const wait = args.passGuard?.wait ?? ((pending) => pending);
   const { sessionId, db, messages, options, entryIdByRef } = args;
   const entryIds = args.entryIds === undefined ? messages.map((message, index) => {
     const timestamp = message.timestamp;
@@ -28094,7 +28244,8 @@ async function runAutoSearchHintForPi(args) {
       appendHintToUserMessage(userMsg, decision.text);
     }
   };
-  return await coalesceAutoSearchTurn(db, sessionId, userMsgId, async (lifecycleSignal) => {
+  return await wait(coalesceAutoSearchTurn(db, sessionId, userMsgId, async (lifecycleSignal) => {
+    args.passGuard?.assert();
     if (lifecycleSignal.aborted)
       return messages;
     if (wasAutoSearchSkipped(db, sessionId, userMsgId))
@@ -28195,7 +28346,7 @@ ${hintText}`;
     }
     sessionLog(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top score ${results[0].score.toFixed(3)})`);
     return messages;
-  }, replayServedDecision);
+  }, replayServedDecision));
 }
 function clearAutoSearchForPiSession(sessionId) {
   clearAutoSearchTimeoutForSession(sessionId);
@@ -32053,7 +32204,10 @@ function isTransientHistorianPromptError(message) {
 
 // src/pi-harness-kind.ts
 import { existsSync as existsSync10, readFileSync as readFileSync12, realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname5, join as join8, parse as parse7, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, join as join8, parse as parse7, resolve as resolve6 } from "node:path";
+import { pathToFileURL } from "node:url";
+var OMP_UTILS_MODULE = "@oh-my-pi/pi-utils";
+var OMP_HOST_PACKAGE = "@oh-my-pi/pi-coding-agent";
 var PI_HOST_PACKAGES = new Set([
   "@earendil-works/pi-coding-agent",
   "@mariozechner/pi-coding-agent"
@@ -32066,7 +32220,7 @@ function hostEntries() {
   for (const candidate of [process.argv[1], process.execPath]) {
     if (!candidate)
       continue;
-    const requestedPath = resolve5(candidate);
+    const requestedPath = resolve6(candidate);
     let resolvedPath;
     try {
       resolvedPath = realpathSync2(requestedPath);
@@ -32104,12 +32258,64 @@ function nearestPackageName(entryPath) {
 function packageNameDetection(entries) {
   for (const entry of entries) {
     const packageName = nearestPackageName(entry.resolvedPath);
+    if (packageName === OMP_HOST_PACKAGE) {
+      return { kind: "omp", via: "package-name" };
+    }
     if (packageName !== undefined && PI_HOST_PACKAGES.has(packageName)) {
       return { kind: "pi", via: "package-name" };
     }
   }
   return;
 }
+function dependencyPackageRoot(entryPath, moduleName) {
+  const moduleParts = moduleName.split("/");
+  let directory = dirname5(entryPath);
+  const root = parse7(directory).root;
+  while (true) {
+    const packageRoot = join8(directory, "node_modules", ...moduleParts);
+    if (existsSync10(join8(packageRoot, "package.json")))
+      return packageRoot;
+    if (directory === root)
+      return;
+    directory = dirname5(directory);
+  }
+}
+function importTarget(exportsValue) {
+  if (typeof exportsValue === "string")
+    return exportsValue;
+  if (!exportsValue || typeof exportsValue !== "object")
+    return;
+  const conditions = exportsValue;
+  if (typeof conditions.import === "string")
+    return conditions.import;
+  if (typeof conditions.default === "string")
+    return conditions.default;
+  return importTarget(conditions["."]);
+}
+function hostModuleImportUrl(entryPath) {
+  const packageRoot = dependencyPackageRoot(entryPath, OMP_UTILS_MODULE);
+  if (!packageRoot)
+    return;
+  const packageJson = readPackageJson(join8(packageRoot, "package.json"));
+  const target = importTarget(packageJson?.exports) ?? (typeof packageJson?.module === "string" ? packageJson.module : typeof packageJson?.main === "string" ? packageJson.main : undefined);
+  if (!target?.startsWith("./"))
+    return;
+  return pathToFileURL(resolve6(packageRoot, target)).href;
+}
+async function appNameDetection(entries) {
+  for (const entry of entries) {
+    const moduleUrl = hostModuleImportUrl(entry.resolvedPath);
+    if (!moduleUrl)
+      continue;
+    try {
+      const hostUtils = await import(moduleUrl);
+      if (hostUtils.APP_NAME === "omp") {
+        return { kind: "omp", via: "app-name" };
+      }
+    } catch {}
+  }
+  return;
+}
 function executableDetection(entries) {
   for (const entry of entries) {
     const kind = piHarnessKindFromExecutable(entry.requestedPath);
@@ -32124,7 +32330,7 @@ async function detectPiHarnessKind() {
     return { kind: processTitleKind, via: "process-title" };
   }
   const entries = hostEntries();
-  return packageNameDetection(entries) ?? executableDetection(entries) ?? { kind: "pi", via: "default" };
+  return packageNameDetection(entries) ?? await appNameDetection(entries) ?? executableDetection(entries) ?? { kind: "pi", via: "default" };
 }
 async function resolvePiHarnessDetection() {
   const processGlobal = globalThis;
@@ -33551,6 +33757,8 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           continue;
         const strippedSource = stripTagPrefix(stripped);
         if (strippedSource.trim().length === 0) {
+          if (target.thinkingDropProtected)
+            continue;
           const dropResult = target.drop?.() ?? "absent";
           const didReplace = dropResult === "absent" ? target.setContent(`[dropped §${tag.tagNumber}§]`) : false;
           if (dropResult === "removed" || dropResult === "absent") {
@@ -34431,7 +34639,7 @@ function currentReclaimHints(db, sessionId, hints) {
 
 // src/debug-assertions-pi.ts
 function runPiDebugAssertion(assert) {
-  if (process.env.MAGIC_CONTEXT_DEBUG_ASSERTIONS === "1")
+  if (process.env.MMC_DEBUG_ASSERTIONS === "1")
     assert?.();
 }
 
@@ -34580,9 +34788,6 @@ function probe(db, sessionId, kind) {
 function hasPiFallbackMessageTags2(db, sessionId) {
   return probe(db, sessionId, "message");
 }
-function hasPiFallbackToolOwnerTags2(db, sessionId) {
-  return probe(db, sessionId, "tool");
-}
 
 // src/historian-tail-pi.ts
 function readPiHistorianTail(db, sessionId, provider) {
@@ -34938,7 +35143,7 @@ function readCurrentMarkersFromCompartments(db, state, compartments) {
   };
 }
 function mustMaterializePi(state, db, currentCompartmentsOverride, passSnapshot) {
-  const meta = passSnapshot?.sessionMeta ?? getOrCreateSessionMeta(db, state.sessionId);
+  const meta = passSnapshot?.sessionMeta ?? readSessionMeta(db, state.sessionId);
   if (!meta.cachedM0Bytes)
     return { value: true, reason: "first_render" };
   if (!meta.cachedM1Bytes)
@@ -35090,7 +35295,7 @@ function readFrozenM0InputsPi(state, db, memoryCutoff, compartmentsOverride) {
   return read.deferred();
 }
 function renderFreshM0PiNonPersisted(state, db) {
-  const cachedMaterializedAt = getOrCreateSessionMeta(db, state.sessionId).cachedM0MaterializedAt ?? 0;
+  const cachedMaterializedAt = readSessionMeta(db, state.sessionId).cachedM0MaterializedAt ?? 0;
   const frozen = readFrozenM0InputsPi(state, db, cachedMaterializedAt);
   frozen.markers.materializedAt = cachedMaterializedAt;
   const historyBudget = historyLocalBudget(state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS, piModelRefToCanonical(state.hardSignals?.modelKey ?? ""));
@@ -35359,7 +35564,7 @@ function readCachedPiM0M1Row(db, sessionId) {
 function createPiM0M1PassSnapshot(args) {
   const compartments = args.compactionOff ? [] : args.compartments ? [...args.compartments] : getCompartments(args.db, args.sessionId);
   return {
-    sessionMeta: args.sessionMeta ?? getOrCreateSessionMeta(args.db, args.sessionId),
+    sessionMeta: args.sessionMeta ?? readSessionMeta(args.db, args.sessionId),
     compartments,
     cachedRow: readCachedPiM0M1Row(args.db, args.sessionId),
     compartmentSequence: compartments.at(-1)?.sequence ?? EMPTY_MAX_COMPARTMENT_SEQ
@@ -36060,6 +36265,83 @@ function authorizePiToolRemoval(args) {
   }
 }
 
+// src/pi-context-budget.ts
+var PI_CONTEXT_BUDGET = {
+  hostDeadlineMs: 30000,
+  hostMarginMs: 5000,
+  outcomeMs: 25000,
+  fallbackObservedMs: 4,
+  workMs: 21000,
+  writerMs: 16500,
+  completionReserveMs: 2000,
+  searchMs: 3000
+};
+
+class PiContextDeadlineError extends Error {
+}
+
+class PiContextBudget {
+  startedAt;
+  now;
+  sideTurn = false;
+  stage = "entry";
+  recovery = "not attempted";
+  abandoned = false;
+  completed = false;
+  failureReason;
+  assertOwner = () => {};
+  constructor(startedAt = performance.now(), now = () => performance.now()) {
+    this.startedAt = startedAt;
+    this.now = now;
+  }
+  elapsed() {
+    return this.now() - this.startedAt;
+  }
+  remainingWork() {
+    return Math.max(0, PI_CONTEXT_BUDGET.workMs - this.elapsed());
+  }
+  remainingOutcome = () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - this.elapsed());
+  writerAllowance() {
+    return Math.max(0, Math.min(PI_CONTEXT_BUDGET.writerMs, this.remainingWork() - PI_CONTEXT_BUDGET.completionReserveMs));
+  }
+  assertOutcome = () => {
+    this.assertOwner();
+    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assert = () => {
+    this.assertOutcome();
+    if (this.elapsed() >= PI_CONTEXT_BUDGET.workMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  assertDecisionPublication = () => {
+    if (!this.completed)
+      this.assertOwner();
+    if (this.abandoned || this.elapsed() >= PI_CONTEXT_BUDGET.outcomeMs)
+      throw new PiContextDeadlineError(this.diagnostic());
+  };
+  diagnostic() {
+    return `stage=${this.stage} elapsed=${Math.round(this.elapsed())}ms recovery=${this.recovery}`;
+  }
+  waitUntil = async (pending, assert, remaining) => {
+    assert();
+    let timer;
+    try {
+      return await Promise.race([
+        pending,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new PiContextDeadlineError(this.diagnostic())), remaining());
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      assert();
+    }
+  };
+  wait = (pending) => this.waitUntil(pending, this.assert, () => this.remainingWork());
+  waitMandatory = (pending) => this.waitUntil(pending, this.assertOutcome, this.remainingOutcome);
+}
+
 // src/pi-context-limit.ts
 var MIN_SANE_LIMIT2 = 16000;
 var MAX_SANE_LIMIT2 = 1e7;
@@ -36111,31 +36393,187 @@ function resolvePiUsableContextLimit(args) {
 
 // src/pi-context-refusal.ts
 import { Text as Text2 } from "@earendil-works/pi-tui";
+
+// src/omp-request-kind.ts
+var SIDE_REMINDER = `<system-reminder>
+Ephemeral side-channel turn; reuses current conversation context.
+Tool catalog attached only to keep prompt cache warm; tools NOT available this turn.
+Do NOT emit tool calls; reply plain text only. Tool calls discarded without execution.
+</system-reminder>`;
+function textContainsReminder(value) {
+  if (typeof value === "string")
+    return value.trim() === SIDE_REMINDER;
+  if (!Array.isArray(value))
+    return false;
+  return value.some((block) => {
+    if (!block || typeof block !== "object")
+      return false;
+    const part = block;
+    return typeof part.text === "string" && part.text.trim() === SIDE_REMINDER;
+  });
+}
+function isOmpSideContext(event) {
+  const tail = event.messages.at(-1);
+  if (tail?.role !== "user" || tail.attribution !== "agent")
+    return false;
+  return event.messages.some((message) => {
+    const row = message;
+    return row.role === "developer" && row.attribution === "agent" && textContainsReminder(row.content);
+  });
+}
+
+// src/pi-context-refusal.ts
 var ENTRY_TYPE = "magic-context-turn-refused";
 var RETRY_MESSAGE = "Magic Context could not safely prepare this turn; send your message again.";
-function registerPiGuardedContext(pi, handler) {
+
+class PiContextSupersededError extends Error {
+}
+var receiptMaps = new Set;
+function clearPiContextReceipt(sessionId) {
+  for (const receipts of receiptMaps)
+    receipts.delete(sessionId);
+}
+function operationKey(ctx) {
+  return ctx.sessionManager?.getSessionId?.() ?? ctx.sessionManager ?? "no-session";
+}
+function registerPiGuardedContext(pi, handler, options = {}) {
+  const operations = new Map;
+  const sideSessions = new Map;
+  receiptMaps.add(operations);
+  const newOperation = () => ({
+    ready: false,
+    refused: false,
+    ended: false
+  });
+  const fenceEnabled = resolvePiHarnessKind() === "omp";
+  const refuse = (ctx, budget, reason, isCurrent) => {
+    if (!isCurrent()) {
+      log(`[magic-context][pi] DISCARDED CONTEXT RESULT ${budget.diagnostic()}`, reason);
+      return;
+    }
+    budget.abandoned = true;
+    budget.recovery = budget.recovery === "not attempted" ? "no managed result; refused" : budget.recovery;
+    const message = `${RETRY_MESSAGE} ${budget.diagnostic()} (${reason instanceof Error ? reason.message : String(reason)})`;
+    try {
+      ctx.ui?.notify(message, "error");
+    } catch (error) {
+      log("[magic-context][pi] refusal notice failed", error);
+    }
+    try {
+      pi.appendEntry(ENTRY_TYPE, { message });
+    } catch (error) {
+      log("[magic-context][pi] refusal entry failed", error);
+    } finally {
+      if (!budget.sideTurn)
+        ctx.abort();
+    }
+    try {
+      options.onRefusal?.(ctx, budget, message, isCurrent);
+    } catch (error) {
+      log("[magic-context][pi] refusal diagnostic failed", error);
+    }
+  };
+  if (fenceEnabled) {
+    pi.on("agent_start", (_event, ctx) => {
+      operations.set(operationKey(ctx), newOperation());
+    });
+    pi.on("agent_end", (_event, ctx) => {
+      const key = operationKey(ctx);
+      const counts = sideSessions.get(key);
+      if (counts)
+        log(`[magic-context][pi] OMP context counts session=${String(key)} side_contexts=${counts.sides} context_passes=${counts.contexts} dispatch_fence=${counts.sides ? "latched off" : "on"}`);
+      const operation = operations.get(key);
+      if (operation) {
+        operation.ended = true;
+        operation.ready = false;
+      }
+    });
+    pi.on("before_provider_request", (_event, ctx) => {
+      if (options.compactionOff?.(ctx))
+        return;
+      const key = operationKey(ctx);
+      if (sideSessions.get(key)?.sides)
+        return;
+      let operation = operations.get(key);
+      if (!operation) {
+        operation = newOperation();
+        operations.set(key, operation);
+      }
+      const active = operation;
+      const isCurrent = () => operations.get(key) === active;
+      const budget = active.pass ?? new PiContextBudget;
+      try {
+        budget.assertOwner();
+        if (!budget.completed)
+          budget.assertOutcome();
+        if (!active.ready || active.refused || active.ended || budget.abandoned)
+          throw new Error("missing managed context receipt");
+      } catch (error) {
+        active.refused = true;
+        budget.stage = "provider dispatch";
+        refuse(ctx, budget, error, isCurrent);
+      }
+    });
+  }
   pi.registerEntryRenderer?.(ENTRY_TYPE, (entry) => new Text2(entry.data?.message ?? RETRY_MESSAGE, 0, 0));
   pi.on("context", async (event, ctx) => {
+    const budget = new PiContextBudget;
+    budget.sideTurn = fenceEnabled && isOmpSideContext(event);
+    const key = operationKey(ctx);
+    if (fenceEnabled) {
+      let counts = sideSessions.get(key);
+      if (!counts) {
+        counts = { contexts: 0, sides: 0 };
+        sideSessions.set(key, counts);
+      }
+      counts.contexts++;
+      if (budget.sideTurn && ++counts.sides === 1)
+        log(`[magic-context][pi] OMP dispatch fence disabled for session ${String(key)}: verified ephemeral context; session-wide abort cannot distinguish provider operations (side_contexts=${counts.sides} context_passes=${counts.contexts})`);
+    }
+    const owner = operations.get(key);
+    let operation = operations.get(key);
+    if (budget.sideTurn || !operation || !fenceEnabled) {
+      operation = newOperation();
+      if (!budget.sideTurn)
+        operations.set(key, operation);
+    }
+    const active = operation;
+    active.pass = budget;
+    active.ready = false;
+    const isOwned = () => budget.sideTurn ? operations.get(key) === owner : operations.get(key) === active && active.pass === budget;
+    const isCurrent = () => isOwned() && (budget.sideTurn || !active.ended);
+    budget.assertOwner = () => {
+      if (!isCurrent())
+        throw new PiContextSupersededError("Pi context pass superseded before writer admission");
+    };
     try {
-      return await withSqliteTransformPass(() => handler(event, ctx));
+      const result = await withSqliteTransformPass(() => handler(event, ctx, budget));
+      budget.assertOutcome();
+      if (result?.messages) {
+        budget.completed = true;
+        active.ready = true;
+      }
+      return result;
     } catch (error) {
+      if (error instanceof PiContextSupersededError || !isCurrent()) {
+        log(`[magic-context][pi] DISCARDED CONTEXT RESULT ${budget.diagnostic()}`, error);
+        throw error;
+      }
       log("[magic-context][pi] turn refused", error);
-      if (typeof ctx.abort !== "function")
+      if (typeof ctx.abort !== "function") {
+        budget.abandoned = true;
+        options.onRefusal?.(ctx, budget, error instanceof Error ? error.message : String(error), isOwned);
         throw error;
-      try {
-        pi.appendEntry(ENTRY_TYPE, { message: RETRY_MESSAGE });
-      } catch (displayError) {
-        log("[magic-context][pi] refusal entry failed", displayError);
-      } finally {
-        ctx.abort();
       }
+      active.refused = true;
+      refuse(ctx, budget, error, isOwned);
       return { messages: event.messages };
     }
   });
 }
 
 // src/pi-maintenance-runner.ts
-import { closeSync as closeSync2, existsSync as existsSync11, openSync as openSync2, readSync as readSync2, statSync as statSync5 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync11, openSync as openSync2, readSync as readSync2, statSync as statSync6 } from "node:fs";
 import { join as join9 } from "node:path";
 
 // ../plugin/src/features/magic-context/memory-maintainer/lease.ts
@@ -36966,7 +37404,7 @@ function screenAgentsCitation(item, agentsSourceText) {
 }
 
 // ../plugin/src/features/magic-context/memory-maintainer/provider-output-failure.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 var MAX_NEAR_ZERO_OUTPUT_TOKENS = 32;
 
 class DreamerProviderOutputFailureError extends Error {
@@ -37023,7 +37461,7 @@ function providerOutputFailureFromInvalidManifest2(messages, responseText) {
   const normalized = responseText.trim().replace(/\s+/g, " ").toLowerCase();
   if (!normalized)
     return null;
-  const fingerprint = createHash12("sha256").update(normalized).digest("hex").slice(0, 16);
+  const fingerprint = createHash13("sha256").update(normalized).digest("hex").slice(0, 16);
   return new DreamerProviderOutputFailureError(fingerprint, completion.outputTokens, completion.reasoningTokens, responseText);
 }
 
@@ -37439,7 +37877,7 @@ function readProjectAgentsBlock(directory) {
   try {
     if (!existsSync11(path))
       return null;
-    const stat = statSync5(path);
+    const stat = statSync6(path);
     if (!stat.isFile())
       return null;
     const cap = AGENTS_BLOCK_MAX_BYTES;
@@ -37713,7 +38151,7 @@ function runPiMaintenanceFactory(deps) {
 }
 
 // ../plugin/src/hooks/magic-context/lkg-persist.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 function parseStringArray(value) {
   if (typeof value !== "string")
     return null;
@@ -37827,7 +38265,7 @@ function rememberFingerprint(db, sessionId, fingerprint) {
   saved.set(sessionId, fingerprint);
 }
 function slotFingerprint(slot) {
-  return createHash13("sha256").update(JSON.stringify([
+  return createHash14("sha256").update(JSON.stringify([
     slot.jsonPrefix,
     slot.inputIdSeq,
     slot.inputContentDigests,
@@ -38004,6 +38442,11 @@ function readServedTemporalDecisions(db, sessionId, runtime, messageIds) {
   return result;
 }
 
+// ../plugin/src/hooks/magic-context/lkg-measured-request.ts
+var requests = new BoundedSessionMap(1000);
+var claimedRequests = new WeakSet;
+var captures = new BoundedSessionMap(1000);
+
 // ../plugin/src/hooks/magic-context/openai-compat-adjacency.ts
 function assertOpenAiCompatAdjacency(messages) {
   const violations = [];
@@ -38533,7 +38976,7 @@ function plainOutputFields(messages) {
   }
   return outputs;
 }
-function snapshotInputs(messages, entryIds) {
+function snapshotInputs(messages, entryIds, omitsBookkeeping) {
   if (!entryIds || entryIds.length !== messages.length) {
     return { inputs: [], failure: "lkg_entry_ids_unavailable" };
   }
@@ -38544,7 +38987,7 @@ function snapshotInputs(messages, entryIds) {
   const inputs = [];
   const seen = new Set;
   for (let index = 0;index < entryIds.length; index += 1) {
-    const fields = lkgContentFields(messages[index]);
+    const fields = lkgContentFields(omitsBookkeeping ? piProviderInput(messages[index]) : messages[index]);
     if (!fields)
       return { inputs: [], failure: "lkg_content_snapshot_failed" };
     const id = entryIds[index] || `pi-lkg-unmapped:${lkgContentDigestFromFields(fields)}`;
@@ -38560,6 +39003,35 @@ function snapshotInputs(messages, entryIds) {
   }
   return { inputs, failure: null };
 }
+var bookkeepingOmittingApis = new Set([
+  "anthropic-messages",
+  "google-generative-ai",
+  "openai-completions",
+  "openai-responses",
+  "openai-codex-responses"
+]);
+function omitsRootBookkeeping(args) {
+  if (args.transport != null)
+    return false;
+  let api = args.apiKey;
+  if (api === undefined) {
+    const apis = new Set(args.messages.flatMap((message) => {
+      const value = message;
+      return value?.role === "assistant" && typeof value.api === "string" ? [value.api] : [];
+    }));
+    if (apis.size === 1)
+      api = [...apis][0];
+  }
+  return typeof api === "string" && bookkeepingOmittingApis.has(api);
+}
+function piProviderInput(message) {
+  if (!message || typeof message !== "object" || Array.isArray(message))
+    return message;
+  const descriptors = Object.getOwnPropertyDescriptors(message);
+  delete descriptors.completedAt;
+  delete descriptors.contextSnapshot;
+  return Object.create(Object.getPrototypeOf(message), descriptors);
+}
 function extendsMeasuredRequest(measuredJson, nextJson) {
   return measuredJson === nextJson || measuredJson.length > 2 && nextJson.startsWith(`${measuredJson.slice(0, -1)},`);
 }
@@ -38580,7 +39052,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     return state;
   };
   const beginPass = (args) => {
-    const snapped = snapshotInputs(args.messages, args.entryIds);
+    const snapped = snapshotInputs(args.messages, args.entryIds, omitsRootBookkeeping(args));
     const slot = getSlot(args.sessionId);
     if (snapped.failure || !slot) {
       return {
@@ -38734,6 +39206,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     return result.ok && measuredPrefix ? { ...result, measuredPrefix } : result;
   };
   const captureAppliedPass = (args) => {
+    args.assertCurrentPass?.();
     const { snapshot } = args;
     if (snapshot.preparationFailure || snapshot.inputs.length === 0)
       return;
@@ -38750,12 +39223,14 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         ...plainOutput ? args.outputMessages.slice(prefix).map((message) => JSON.stringify(message) ?? "null") : []
       ];
       jsonPrefix = !plainOutput ? JSON.stringify(args.outputMessages) : priorOutput && prefix === outputs.length && prefix === priorOutput.inputs.length ? priorOutput.json : `[${jsonMessages.join(",")}]`;
+      args.assertCurrentPass?.();
       state.outputSnapshot = plainOutput ? {
         inputs: outputs,
         jsonMessages,
         json: jsonPrefix
       } : null;
     } catch (error) {
+      args.assertCurrentPass?.();
       dropSlot(snapshot.sessionId, "lkg_snapshot_serialize_failed");
       const failedState = stateFor(snapshot.sessionId);
       failedState.syncCaptureRequired = true;
@@ -38779,6 +39254,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     const outputIds = args.outputEntryIds ?? inferredIds;
     const inputIds = new Set(snapshot.inputs.map((input) => input.id));
     const ownership = outputIds.length === args.outputMessages.length && outputIds.every((id) => id === null || typeof id === "string" && inputIds.has(id)) ? [...outputIds] : undefined;
+    args.assertCurrentPass?.();
     state.captureSequence += 1;
     const plan = {
       sessionId: snapshot.sessionId,
@@ -38794,6 +39270,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     state.capturedRequest = args.hostEnvelopeSignature ? { ...plan, envelopeSignature: args.hostEnvelopeSignature } : undefined;
     const livePrior = getSlot(snapshot.sessionId);
     const unchanged = livePrior && livePrior.modelKey === plan.modelKey && livePrior.providerKey === plan.providerKey && livePrior.jsonPrefix === plan.jsonPrefix && livePrior.inputIdSeq.length === plan.inputs.length && exactReusablePrefix(plan.inputs, state.acceptedInputs) === plan.inputs.length && JSON.stringify(livePrior.piOutputEntryIds) === JSON.stringify(ownership);
+    args.assertCurrentPass?.();
     if (unchanged && !state.syncCaptureRequired) {
       const kept = {
         ...livePrior,
@@ -38809,6 +39286,12 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
       dropSlot(snapshot.sessionId, "lkg_cache_bust_pending_capture");
     }
     const commit = () => {
+      try {
+        args.assertCurrentPass?.();
+      } catch (error) {
+        sessionLog(plan.sessionId, "DISCARDED CONTEXT RESULT: queued LKG capture", error);
+        return;
+      }
       if (plan.captureSequence !== state.captureSequence)
         return;
       const startedAt = performance.now();
@@ -38837,6 +39320,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         } : undefined);
         reusedPrefix = incremental.reusedPrefix;
         if (!state.syncCaptureRequired && prior && reusedPrefix === plan.inputs.length && prior.inputIdSeq.length === plan.inputs.length && prior.jsonPrefix === plan.jsonPrefix && JSON.stringify(prior.piOutputEntryIds) === JSON.stringify(ownership)) {
+          args.assertCurrentPass?.();
           state.acceptedInputs = plan.inputs;
           return;
         }
@@ -38852,6 +39336,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
           capturedAt: plan.capturedAt,
           captureSequence: plan.captureSequence
         };
+        args.assertCurrentPass?.();
         if (!captureSlot(plan.sessionId, slot)) {
           throw new Error("LKG slot rejected the Pi snapshot");
         }
@@ -38860,6 +39345,12 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         const persisted = saveLkgSlotToDb(db, plan.sessionId, slot);
         state.syncCaptureRequired = !persisted;
       } catch (error) {
+        try {
+          args.assertCurrentPass?.();
+        } catch (discarded) {
+          sessionLog(plan.sessionId, "DISCARDED CONTEXT RESULT: LKG publication", discarded);
+          return;
+        }
         if (plan.captureSequence !== state.captureSequence)
           return;
         dropSlot(plan.sessionId, "lkg_async_capture_failed");
@@ -38955,7 +39446,7 @@ function resolvePiLkgOutputEntryIds(messages, syntheticLeadingCount, entryId) {
 }
 
 // src/pi-lkg-fit-envelope.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 
 // src/host-system-prompt.ts
 function readHostSystemPrompt(ctx) {
@@ -38973,7 +39464,7 @@ function readHostSystemPrompt(ctx) {
 }
 
 // src/pi-lkg-fit-envelope.ts
-function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen) {
+function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
   try {
     if (!modelKey || typeof pi.getAllTools !== "function")
       return;
@@ -38985,7 +39476,8 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen) {
     for (const tool of allTools) {
       if (!tool || typeof tool !== "object")
         return;
-      const { name, description, parameters } = tool;
+      const { name, description } = tool;
+      const parameters = wireSchema ? wireSchema(tool) : tool.parameters;
       if (typeof name !== "string" || !name.length || typeof description !== "string" || !parameters || typeof parameters !== "object" || Array.isArray(parameters))
         return;
       tools.push({ name, description, parameters });
@@ -39033,7 +39525,7 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen) {
       refusalToolDefinitionTokens,
       toolDefinitionsMeasured: refusalToolDefinitionTokens !== undefined,
       envelopeBytes: Buffer.byteLength(envelopeJson),
-      envelopeSignature: activeNames ? createHash14("sha256").update(envelopeJson).update(JSON.stringify(activeNames)).digest("hex") : undefined,
+      envelopeSignature: activeNames ? createHash15("sha256").update(envelopeJson).update(JSON.stringify(activeNames)).digest("hex") : undefined,
       calibration
     };
   } catch {
@@ -39928,6 +40420,29 @@ function injectSyntheticTodowriteForPi(args) {
   return args.messages;
 }
 
+// src/pi-tool-wire-schema.ts
+import { isAbsolute as isAbsolute3 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+var resolver;
+function loadPiToolWireSchema() {
+  if (resolver)
+    return resolver;
+  resolver = (async () => {
+    const specifier = "@oh-my-pi/pi-ai/utils/schema/wire";
+    for (const base of [process.argv[1], import.meta.url]) {
+      if (!base || !base.startsWith("file:") && !isAbsolute3(base))
+        continue;
+      try {
+        const path = import.meta.resolve(specifier, base.startsWith("file:") ? base : pathToFileURL2(base).href);
+        const host = await import(path);
+        if (typeof host.toolWireSchema === "function")
+          return host.toolWireSchema;
+      } catch {}
+    }
+  })();
+  return resolver;
+}
+
 // src/provider-error-recovery-pi.ts
 function reportBindingRecovery(sessionId, report, message) {
   if (report)
@@ -40587,14 +41102,26 @@ function replayPiReminderStrips(args) {
 }
 
 // src/served-array-ledger.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
+import { readFileSync as readFileSync13 } from "node:fs";
 import * as path5 from "node:path";
 var PI_SERVED_ARRAY_TAIL_MESSAGES = 40;
 var PI_SERVED_ARRAY_BODY_CAPTURE_ENV = "MMC_PI_SERVED_BODY_CAPTURE";
 var LEDGER_DIRECTORY = "pi-served-array-digests";
 var BODY_DIRECTORY = "pi-served-array-bodies";
+var IDENTITY_DIRECTORY = "pi-served-tag-numbers";
 var FLUSH_DELAY_MS = 25;
+
+class PiServedIdentityError extends Error {
+  constructor(cause) {
+    super("Pi served-number identity could not be persisted or restored", {
+      cause
+    });
+    this.name = "PiServedIdentityError";
+  }
+}
 var previousBySession = new Map;
+var servedTagNumbersBySession = new Map;
 var sequenceBySession = new Map;
 var pendingLinesByPath = new Map;
 var flushTimer = null;
@@ -40602,10 +41129,39 @@ var swallowedWriteCount = 0;
 var lastWriteError = null;
 function clearPiServedArraySession(sessionId) {
   previousBySession.delete(sessionId);
+  servedTagNumbersBySession.delete(sessionId);
   sequenceBySession.delete(sessionId);
 }
+function getPiServedTagNumbers(sessionId, storageDir = getMagicContextStorageDir()) {
+  const filePath = getPiServedTagNumbersPath(sessionId, storageDir);
+  const cached = servedTagNumbersBySession.get(sessionId);
+  if (cached?.path === filePath)
+    return cached.numbers;
+  let text;
+  try {
+    text = readFileSync13(filePath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    text = "";
+  }
+  const numbers = new Set;
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const row = JSON.parse(line);
+    if (row.version !== 1 || row.session_id !== sessionId || !Array.isArray(row.tag_numbers) || !row.tag_numbers.every((number) => Number.isSafeInteger(number) && number > 0)) {
+      throw new Error("Invalid durable Pi served-number record; refusing identity adoption");
+    }
+    for (const number of row.tag_numbers)
+      numbers.add(number);
+  }
+  servedTagNumbersBySession.set(sessionId, { path: filePath, numbers });
+  return numbers;
+}
 function sha256(value) {
-  return createHash15("sha256").update(value).digest("hex");
+  return createHash16("sha256").update(value).digest("hex");
 }
 function safeSessionFileStem(sessionId) {
   const readable = sessionId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 96);
@@ -40617,6 +41173,9 @@ function getPiServedArrayLedgerPath(sessionId, storageDir = getMagicContextStora
 function getPiServedArrayBodyPath(sessionId, storageDir = getMagicContextStorageDir()) {
   return path5.join(storageDir, BODY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
+function getPiServedTagNumbersPath(sessionId, storageDir = getMagicContextStorageDir()) {
+  return path5.join(storageDir, IDENTITY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+}
 function fullBodyCaptureEnabled() {
   const value = process.env[PI_SERVED_ARRAY_BODY_CAPTURE_ENV]?.trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
@@ -40682,8 +41241,19 @@ function flushPiServedArrayLedger() {
     return;
   const pending = [...pendingLinesByPath.entries()];
   pendingLinesByPath.clear();
-  for (const [filePath, lines] of pending)
-    appendPendingLines(filePath, lines);
+  for (const [filePath, lines] of pending) {
+    const admitted = lines.filter((item) => {
+      try {
+        item.assertCurrentPass?.();
+        return true;
+      } catch (error) {
+        log("[magic-context][pi] DISCARDED CONTEXT RESULT: queued served capture", error);
+        return false;
+      }
+    }).map((item) => item.line);
+    if (admitted.length)
+      appendPendingLines(filePath, admitted);
+  }
 }
 function scheduleFlush() {
   if (flushTimer)
@@ -40691,19 +41261,30 @@ function scheduleFlush() {
   flushTimer = setTimeout(flushPiServedArrayLedger, FLUSH_DELAY_MS);
   flushTimer.unref?.();
 }
-function enqueue(filePath, line) {
+function enqueue(filePath, line, assertCurrentPass) {
   const pending = pendingLinesByPath.get(filePath);
   if (pending)
-    pending.push(line);
+    pending.push({ line, assertCurrentPass });
   else
-    pendingLinesByPath.set(filePath, [line]);
+    pendingLinesByPath.set(filePath, [{ line, assertCurrentPass }]);
   scheduleFlush();
 }
 function capturePiServedArray(sessionId, messages, options = {}) {
+  options.assertCurrentPass?.();
+  let identityPersistenceFailed = false;
   try {
     const serializedMessages = options.serializedOutput?.jsonMessages ?? messages.map(serializeMessage);
     const serializedArray = options.serializedOutput?.json ?? `[${serializedMessages.join(",")}]`;
     const digest = sha256(serializedArray);
+    const storageDir = options.storageDir ?? getMagicContextStorageDir();
+    identityPersistenceFailed = true;
+    const previousNumbers = getPiServedTagNumbers(sessionId, storageDir);
+    identityPersistenceFailed = false;
+    const served = new Set(previousNumbers);
+    for (const number of options.servedTagNumbers ?? []) {
+      if (Number.isSafeInteger(number) && number > 0)
+        served.add(number);
+    }
     const previous = previousBySession.get(sessionId);
     const divergence = previous ? firstDivergence(previous.serializedMessages, serializedMessages) : null;
     const sequence = (sequenceBySession.get(sessionId) ?? 0) + 1;
@@ -40720,9 +41301,27 @@ function capturePiServedArray(sessionId, messages, options = {}) {
       block_vector_start: tailStart,
       block_vectors: messages.slice(tailStart).map(blockVector)
     };
-    const storageDir = options.storageDir ?? getMagicContextStorageDir();
+    options.assertCurrentPass?.();
+    const newNumbers = [...served].filter((number) => !previousNumbers.has(number));
+    const identityPath = getPiServedTagNumbersPath(sessionId, storageDir);
+    if (newNumbers.length) {
+      identityPersistenceFailed = true;
+      ensureStorageDirectorySync(path5.dirname(identityPath));
+      options.assertCurrentPass?.();
+      writeStorageFileSync(identityPath, `${JSON.stringify({ version: 1, session_id: sessionId, tag_numbers: newNumbers })}
+`, {
+        encoding: "utf8",
+        flag: "a"
+      });
+      identityPersistenceFailed = false;
+    }
+    options.assertCurrentPass?.();
+    servedTagNumbersBySession.set(sessionId, {
+      path: identityPath,
+      numbers: served
+    });
     enqueue(getPiServedArrayLedgerPath(sessionId, storageDir), `${JSON.stringify(record)}
-`);
+`, options.assertCurrentPass);
     if (options.fullBodyCapture ?? fullBodyCaptureEnabled()) {
       const bodyHeader = JSON.stringify({
         version: 1,
@@ -40732,12 +41331,15 @@ function capturePiServedArray(sessionId, messages, options = {}) {
         sha256: digest
       });
       enqueue(getPiServedArrayBodyPath(sessionId, storageDir), `${bodyHeader.slice(0, -1)},"messages":${serializedArray}}
-`);
+`, options.assertCurrentPass);
     }
     previousBySession.set(sessionId, { digest, serializedMessages });
     sequenceBySession.set(sessionId, sequence);
     return record;
   } catch (error) {
+    options.assertCurrentPass?.();
+    if (identityPersistenceFailed)
+      throw new PiServedIdentityError(error);
     recordWriteFailure(error);
     return;
   }
@@ -40932,7 +41534,7 @@ function stripPiProcessedImages(args) {
 }
 
 // src/system-prompt.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
@@ -41106,7 +41708,7 @@ function processSystemPromptForCache(args) {
   const liveDate = dateMatch ? dateMatch[0] : null;
   const stickyDate = stickyDateBySession.get(sessionId);
   const stableCandidate = liveDate && stickyDate && liveDate !== stickyDate ? systemPrompt.replace(DATE_PATTERN, stickyDate) : systemPrompt;
-  const stableCandidateHash = createHash16("md5").update(promptSurfaceHashMaterial(stableCandidate, args.promptSurfacePreset)).digest("hex");
+  const stableCandidateHash = createHash17("md5").update(promptSurfaceHashMaterial(stableCandidate, args.promptSurfacePreset)).digest("hex");
   const contentOrPresetChanged = !isFirstHash && stableCandidateHash !== previousHash;
   const idleCacheExpired = sessionMeta !== undefined && computeHardCacheExpired(sessionMeta.cacheTtl, sessionMeta.lastResponseTime, Date.now());
   const dateMayAdvance = isCacheBusting || idleCacheExpired || contentOrPresetChanged;
@@ -41121,7 +41723,7 @@ function processSystemPromptForCache(args) {
       sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
     }
   }
-  const currentHash = createHash16("md5").update(promptSurfaceHashMaterial(frozenPrompt, args.promptSurfacePreset)).digest("hex");
+  const currentHash = createHash17("md5").update(promptSurfaceHashMaterial(frozenPrompt, args.promptSurfacePreset)).digest("hex");
   const hashChanged = !isFirstHash && currentHash !== previousHash;
   if (hashChanged) {
     sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
@@ -41149,19 +41751,6 @@ function clearPiSystemPromptSession(sessionId) {
   stickyDateBySession.delete(sessionId);
 }
 
-// src/timeout.ts
-function withTimeout(p, ms) {
-  let handle;
-  const timeout = new Promise((resolve) => {
-    handle = setTimeout(() => resolve(undefined), ms);
-    handle.unref?.();
-  });
-  return Promise.race([p, timeout]).finally(() => {
-    if (handle)
-      clearTimeout(handle);
-  });
-}
-
 // src/transcript-pi.ts
 function createPiTranscript(source, sessionId, entryIds, options = {}) {
   const working = source.slice();
@@ -41730,6 +42319,7 @@ var pendingDecisionLogObserverForTests;
 var mutationGateObserverForTests;
 var lkgRecoveryLogObserverForTests;
 var variantChangeLogObserverForTests;
+var beforePipelineForTests;
 function logPiLkgRecovery(sessionId, message) {
   lkgRecoveryLogObserverForTests?.(message);
   sessionLog(sessionId, message);
@@ -41745,11 +42335,22 @@ var deferredMaterializationSessions = new Set;
 var sessionsByProject = new Map;
 var lastSeenProjectIdentityBySession = new Map;
 var persistedProjectIdentityBySession = new Map;
+var sessionProjectBindingFailureLogAtBySession = new Map;
+var SESSION_PROJECT_BINDING_FAILURE_LOG_INTERVAL_MS = 10 * 60 * 1000;
 var rawMessageProviderUnregistersBySession = new Map;
 var activeContextHandlerSessions = new Set;
 var lastHeuristicsTurnIdBySession = new Map;
 var routinePressureAppliedBySession = new Map;
 var firstContextPassSeenBySession = new Set;
+var contextPassGeneration = new Map;
+
+class PiLkgAdmissionReplay extends Error {
+  messages;
+  constructor(messages) {
+    super("Saved request served before writer wait");
+    this.messages = messages;
+  }
+}
 var liveModelBySession = new Map;
 var latestAssistantModelTimestampBySession = new Map;
 var taggedStableMessageIdsBySession = new Map;
@@ -41974,7 +42575,7 @@ function trackSessionForProject(projectIdentity, sessionId) {
 function isContextHandlerSessionActive(sessionId) {
   return activeContextHandlerSessions.has(sessionId);
 }
-function updateSessionProjectTracking(sessionId, projectIdentity, db) {
+function updateSessionProjectTracking(sessionId, projectIdentity, db, observedCwd) {
   if (!projectIdentity)
     return;
   const prev = lastSeenProjectIdentityBySession.get(sessionId);
@@ -41987,9 +42588,22 @@ function updateSessionProjectTracking(sessionId, projectIdentity, db) {
   }
   if (db && persistedProjectIdentityBySession.get(sessionId) !== projectIdentity) {
     try {
-      recordSessionProjectIdentity(db, sessionId, projectIdentity);
+      const change = recordSessionProjectIdentity(db, sessionId, projectIdentity);
       persistedProjectIdentityBySession.set(sessionId, projectIdentity);
-    } catch {}
+      if (change) {
+        sessionLog(sessionId, `project binding changed harness=${getHarness()} cwd=${observedCwd ?? "unknown"} old=${change.previousProjectPath ?? "none"} new=${change.projectPath}`);
+      }
+    } catch (error) {
+      const now = Date.now();
+      const lastLoggedAt = sessionProjectBindingFailureLogAtBySession.get(sessionId);
+      if (lastLoggedAt === undefined || now - lastLoggedAt >= SESSION_PROJECT_BINDING_FAILURE_LOG_INTERVAL_MS) {
+        sessionProjectBindingFailureLogAtBySession.set(sessionId, now);
+        sessionLog(sessionId, `project binding write failed harness=${getHarness()} cwd=${observedCwd ?? "unknown"} attempted=${projectIdentity}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  if (db && persistedProjectIdentityBySession.get(sessionId) === projectIdentity && sessionProjectBindingFailureLogAtBySession.delete(sessionId)) {
+    sessionLog(sessionId, `project binding write recovered harness=${getHarness()} cwd=${observedCwd ?? "unknown"} identity=${projectIdentity}`);
   }
   trackSessionForProject(projectIdentity, sessionId);
   lastSeenProjectIdentityBySession.set(sessionId, projectIdentity);
@@ -42004,11 +42618,6 @@ function recordPiLiveModel(sessionId, modelKey, assistantTimestamp) {
   liveModelBySession.set(sessionId, modelKey);
   return true;
 }
-function summarizeTransformError(error) {
-  const raw = error instanceof Error ? error.message : String(error);
-  const normalized = raw.replace(/\s+/g, " ").trim();
-  return normalized.length > 180 ? `${normalized.slice(0, 177).trimEnd()}...` : normalized || "Unknown transform error";
-}
 function persistLastTransformErrorIfChanged(db, sessionId, summary, knownCurrent) {
   try {
     const current = knownCurrent === undefined ? getOrCreateSessionMeta(db, sessionId).lastTransformError : knownCurrent;
@@ -42113,15 +42722,195 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId, preloadedBranchEn
   }
   return result;
 }
+function piContextHeaderFields(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  const record = message;
+  if (typeof record.role !== "string")
+    return null;
+  return {
+    responseId: typeof record.responseId === "string" ? record.responseId : null,
+    timestamp: typeof record.timestamp === "number" || typeof record.timestamp === "string" ? record.timestamp : null,
+    role: record.role,
+    toolCallId: typeof record.toolCallId === "string" ? record.toolCallId : null
+  };
+}
+function piAlignmentCheckForEntry(entry) {
+  if (!isPiContextEmitEligible(entry))
+    return null;
+  const row = entry;
+  const header = row.type === "message" ? piContextHeaderFields(row.message) : {
+    responseId: null,
+    timestamp: new Date(row.timestamp).getTime(),
+    role: row.type === "custom_message" ? "custom" : "branchSummary",
+    toolCallId: null
+  };
+  if (!header)
+    return null;
+  return {
+    ...header,
+    headerKey: JSON.stringify([
+      header.responseId,
+      header.timestamp,
+      header.role,
+      header.toolCallId
+    ]),
+    entry: row
+  };
+}
+function piAlignedContentMatches(check, message) {
+  const entry = check.entry;
+  if (entry.type === "branch_summary") {
+    const summary = message;
+    return summary.summary === entry.summary && summary.fromId === entry.fromId;
+  }
+  if (entry.type === "custom_message") {
+    const custom = message;
+    if (custom.customType !== entry.customType)
+      return false;
+  }
+  if (check.fingerprint === undefined) {
+    check.fingerprint = entry.type === "message" ? piMessageEntryFingerprint(entry.message) : piMessageEntryFingerprint({
+      role: check.role,
+      timestamp: check.timestamp,
+      content: entry.content ?? []
+    });
+  }
+  return check.fingerprint !== null && piMessageEntryFingerprint(message) === check.fingerprint;
+}
+function findPiAlignmentMismatch(lookup, entryIds, messages) {
+  for (let index = 0;index < entryIds.length; index += 1) {
+    const id = entryIds[index];
+    if (id === undefined)
+      continue;
+    if (!piAlignedPositionMatches(lookup, id, messages[index]))
+      return index;
+  }
+  return -1;
+}
+function piAlignedPositionMatches(lookup, id, message) {
+  const check = lookup.alignmentChecks.get(id);
+  const header = piContextHeaderFields(message);
+  if (!check || !header || header.role !== check.role || !Object.is(header.timestamp, check.timestamp) || header.responseId !== check.responseId || header.toolCallId !== check.toolCallId)
+    return false;
+  return (lookup.alignmentHeaderCounts.get(check.headerKey) ?? 0) <= 1 || piAlignedContentMatches(check, message);
+}
+function anchorPiEventEntryIds(lookup, aligned, messages) {
+  const projectionIndex = new Map;
+  for (let index = 0;index < aligned.length; index += 1) {
+    const id = aligned[index];
+    if (id !== undefined)
+      projectionIndex.set(id, index);
+  }
+  const result = new Array(messages.length).fill(undefined);
+  const used = new Set;
+  const anchors = [];
+  for (let index = 0;index < messages.length; index += 1) {
+    const header = piContextHeaderFields(messages[index]);
+    if (!header)
+      continue;
+    const key = JSON.stringify([
+      header.responseId,
+      header.timestamp,
+      header.role,
+      header.toolCallId
+    ]);
+    if (lookup.alignmentHeaderCounts.get(key) !== 1)
+      continue;
+    const id = lookup.alignmentEntryIdByHeader.get(key);
+    const position = id === undefined ? undefined : projectionIndex.get(id);
+    if (id === undefined || position === undefined)
+      continue;
+    const previous = anchors.at(-1);
+    if (used.has(id) || previous && position <= previous.projection)
+      return null;
+    anchors.push({ message: index, projection: position });
+    used.add(id);
+    result[index] = id;
+  }
+  const fillRun = (messageStart, messageEnd, projectionStart, projectionEnd) => {
+    if (messageEnd - messageStart !== projectionEnd - projectionStart)
+      return;
+    for (let offset = 0;offset < messageEnd - messageStart; offset += 1) {
+      const id = aligned[projectionStart + offset];
+      const message = messages[messageStart + offset];
+      if (id !== undefined && !used.has(id) && piAlignedPositionMatches(lookup, id, message)) {
+        result[messageStart + offset] = id;
+        used.add(id);
+      }
+    }
+  };
+  let previousMessage = -1;
+  let previousProjection = -1;
+  for (const anchor of anchors) {
+    fillRun(previousMessage + 1, anchor.message, previousProjection + 1, anchor.projection);
+    previousMessage = anchor.message;
+    previousProjection = anchor.projection;
+  }
+  fillRun(previousMessage + 1, messages.length, previousProjection + 1, aligned.length);
+  for (let index = 0;index < messages.length; index += 1) {
+    if (result[index] !== undefined)
+      continue;
+    const message = messages[index];
+    if (!message || typeof message !== "object")
+      continue;
+    const byRef = lookup.entryIdByMessageRef.get(message);
+    if (byRef !== undefined && !used.has(byRef)) {
+      result[index] = byRef;
+      used.add(byRef);
+      continue;
+    }
+    const fingerprint = piMessageEntryFingerprint(message);
+    const bucket = fingerprint ? lookup.entryIdsByFingerprint.get(fingerprint) : undefined;
+    const id = bucket?.length === 1 ? bucket[0] : undefined;
+    if (id !== undefined && !used.has(id)) {
+      result[index] = id;
+      used.add(id);
+    }
+  }
+  return result;
+}
+var piAlignmentMismatchLoggedSessions = new Set;
+var piEntryAlignmentLaneCounts = { anchored: 0, fingerprint: 0 };
+function resolvePiEventEntryIds(ctx, messages, sessionId, branchEntries) {
+  if (branchEntries === null)
+    return null;
+  const lookup = getPiBranchEntryLookup(branchEntries);
+  const aligned = messages.some(isPiSystemEntry) ? lookup.alignedEntryIds : lookup.alignedVisibleEntryIds;
+  if (aligned.length === messages.length) {
+    const mismatch = findPiAlignmentMismatch(lookup, aligned, messages);
+    if (mismatch < 0)
+      return aligned;
+    if (!piAlignmentMismatchLoggedSessions.has(sessionId)) {
+      piAlignmentMismatchLoggedSessions.add(sessionId);
+      sessionLog(sessionId, `pi entry alignment: message ${mismatch} of ${messages.length} does not match its projected entry; resolving ids by content fingerprint (logged once per session)`);
+    }
+  }
+  const anchored = anchorPiEventEntryIds(lookup, aligned, messages);
+  if (anchored) {
+    piEntryAlignmentLaneCounts.anchored += 1;
+    return anchored;
+  }
+  piEntryAlignmentLaneCounts.fingerprint += 1;
+  return collectMessageEntryIdsByRef(ctx, messages, sessionId, branchEntries);
+}
 function addPiBranchEntryToLookup(lookup, entry) {
   if (!entry || typeof entry !== "object")
     return;
+  const check = piAlignmentCheckForEntry(entry);
+  if (check) {
+    lookup.alignmentChecks.set(entry.id, check);
+    lookup.alignmentEntryIdByHeader.set(check.headerKey, entry.id);
+    lookup.alignmentHeaderCounts.set(check.headerKey, (lookup.alignmentHeaderCounts.get(check.headerKey) ?? 0) + 1);
+  }
   const row = entry;
   if (row.type !== "message" || typeof row.id !== "string" || !row.message || typeof row.message !== "object") {
     return;
   }
   lookup.entryIdByMessageRef.set(row.message, row.id);
   const fingerprint = piMessageEntryFingerprint(row.message);
+  if (check)
+    check.fingerprint = fingerprint;
   if (!fingerprint)
     return;
   const bucket = lookup.entryIdsByFingerprint.get(fingerprint);
@@ -42139,6 +42928,56 @@ function isPiContextEmitEligible(entry) {
   return row.type === "message" || row.type === "custom_message" || row.type === "branch_summary" && typeof row.summary === "string" && row.summary.length > 0;
 }
 function buildPiAlignedEntryIds(entries) {
+  const all = buildPiAlignedEntryIdsIncludingSystem(entries);
+  return { all, visible: buildPiAlignedVisibleEntryIds(entries) };
+}
+function buildPiAlignedVisibleEntryIds(entries) {
+  let compactionIndex = -1;
+  for (let index = entries.length - 1;index >= 0; index -= 1) {
+    if (entries[index]?.type === "compaction") {
+      compactionIndex = index;
+      break;
+    }
+  }
+  const context = [];
+  if (compactionIndex >= 0) {
+    const compaction = entries[compactionIndex];
+    context.push(compaction);
+    const firstKeptEntryId = compaction.firstKeptEntryId;
+    let foundFirstKept = false;
+    for (let index = 0;index < compactionIndex; index += 1) {
+      const entry = entries[index];
+      if (typeof firstKeptEntryId === "string" && entry?.id === firstKeptEntryId) {
+        foundFirstKept = true;
+      }
+      if (foundFirstKept)
+        context.push(entry);
+    }
+  }
+  for (let index = compactionIndex + 1;index < entries.length; index += 1) {
+    context.push(entries[index]);
+  }
+  const omitted = new Map;
+  for (const entry of context) {
+    const edit = entry;
+    if (edit?.type !== "context_edit" || typeof edit.targetId !== "string")
+      continue;
+    omitted.set(edit.targetId, edit.replacement === null);
+  }
+  const ids = [];
+  if (compactionIndex >= 0) {
+    const compactionId = entries[compactionIndex].id;
+    if (typeof compactionId !== "string" || omitted.get(compactionId) !== true)
+      ids.push(undefined);
+  }
+  for (let index = compactionIndex >= 0 ? 1 : 0;index < context.length; index += 1) {
+    const entry = context[index];
+    if (isPiContextEmitEligible(entry) && !isPiSystemMessageEntry(entry) && omitted.get(entry.id) !== true)
+      ids.push(entry.id);
+  }
+  return ids;
+}
+function buildPiAlignedEntryIdsIncludingSystem(entries) {
   let compactionIndex = -1;
   let firstKeptEntryId;
   for (let index = entries.length - 1;index >= 0; index -= 1) {
@@ -42202,10 +43041,15 @@ function getPiBranchEntryLookup(entries) {
   const cached = piBranchLookupByProjection.get(entries);
   if (cached)
     return cached;
+  const aligned = buildPiAlignedEntryIds(entries);
   const lookup = {
     entryIdByMessageRef: new Map,
     entryIdsByFingerprint: new Map,
-    alignedEntryIds: buildPiAlignedEntryIds(entries)
+    alignedEntryIds: aligned.all,
+    alignedVisibleEntryIds: aligned.visible,
+    alignmentChecks: new Map,
+    alignmentHeaderCounts: new Map,
+    alignmentEntryIdByHeader: new Map
   };
   for (const entry of entries)
     addPiBranchEntryToLookup(lookup, entry);
@@ -42281,7 +43125,10 @@ function readPiBranchEntriesForContext(ctx, sessionId) {
     suffix.reverse();
     if (cached && cachedAncestorIndex === cached.entries.length - 1) {
       const entries = [...cached.entries, ...suffix];
-      if (suffix.some((entry) => entry?.type === "compaction")) {
+      if (suffix.some((entry) => {
+        const type = entry?.type;
+        return type === "compaction" || type === "context_edit";
+      })) {
         return installProjection(leafId, entries);
       }
       for (let index = 0;index < suffix.length; index += 1) {
@@ -42291,6 +43138,9 @@ function readPiBranchEntriesForContext(ctx, sessionId) {
         addPiBranchEntryToLookup(cached.lookup, entry);
         if (isPiContextEmitEligible(entry)) {
           cached.lookup.alignedEntryIds.push(entry.id);
+          if (!isPiSystemMessageEntry(entry)) {
+            cached.lookup.alignedVisibleEntryIds.push(entry.id);
+          }
         }
       }
       const projection = {
@@ -42315,46 +43165,69 @@ function readPiBranchEntriesForContext(ctx, sessionId) {
     }
   }
 }
-function piMessageEntryFingerprint(message) {
+function piMessageEntryFingerprintHeader(message) {
   if (!message || typeof message !== "object")
     return null;
   const record = message;
   if (typeof record.role !== "string")
     return null;
-  const firstText = firstPiTextContent(record.content);
-  const firstTextHash = crypto3.createHash("sha256").update(firstText ?? "").digest("hex").slice(0, 16);
   return JSON.stringify([
     typeof record.responseId === "string" ? record.responseId : null,
     typeof record.timestamp === "number" || typeof record.timestamp === "string" ? record.timestamp : null,
     record.role,
-    typeof record.toolCallId === "string" ? record.toolCallId : null,
-    firstTextHash
+    typeof record.toolCallId === "string" ? record.toolCallId : null
   ]);
 }
-function firstPiTextContent(content) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return null;
-  for (const part of content) {
-    if (!part || typeof part !== "object")
-      continue;
-    const record = part;
-    if (record.type === "text" && typeof record.text === "string") {
-      return record.text;
+function readPiFallbackFingerprintHeaders(db, sessionId) {
+  const rows = db.prepare(`SELECT DISTINCT entry_fingerprint FROM tags WHERE session_id = ? AND type = 'message'
+			 AND entry_fingerprint IS NOT NULL AND message_id LIKE 'pi-msg-%'`).all(sessionId);
+  const headers = new Set;
+  for (const row of rows) {
+    let parsed;
+    try {
+      parsed = JSON.parse(row.entry_fingerprint);
+    } catch {
+      return null;
     }
+    if (!Array.isArray(parsed) || parsed.length !== 5)
+      return null;
+    headers.add(JSON.stringify(parsed.slice(0, 4)));
   }
-  return null;
+  return headers;
 }
-function buildEntryFingerprintMap(messages, resolveStableId, reusableMessageIds, includeReusable = true) {
+var piEntryFingerprintCount = 0;
+function piMessageEntryFingerprint(message) {
+  piEntryFingerprintCount += 1;
+  if (!message || typeof message !== "object")
+    return null;
+  const record = message;
+  if (typeof record.role !== "string")
+    return null;
+  const contentHash = crypto3.createHash("sha256").update(stableStringify(record.content)).digest("hex");
+  return JSON.stringify([
+    typeof record.responseId === "string" ? record.responseId : null,
+    typeof record.timestamp === "number" || typeof record.timestamp === "string" ? record.timestamp : null,
+    record.role,
+    typeof record.toolCallId === "string" ? record.toolCallId : null,
+    contentHash
+  ]);
+}
+function buildEntryFingerprintMap(messages, resolveStableId, reusableMessageIds, includeReusable = true, reusableHeaders) {
   const map = new Map;
   for (let i = 0;i < messages.length; i++) {
     const msg = messages[i];
     const id = resolveStableId(msg, i);
     if (!id)
       continue;
-    if (!includeReusable && reusableMessageIds?.has(id))
-      continue;
+    if (reusableMessageIds?.has(id)) {
+      if (!includeReusable)
+        continue;
+      if (reusableHeaders) {
+        const header = piMessageEntryFingerprintHeader(msg);
+        if (header === null || !reusableHeaders.has(header))
+          continue;
+      }
+    }
     const fp = piMessageEntryFingerprint(msg);
     if (fp)
       map.set(id, fp);
@@ -42422,54 +43295,116 @@ function runImmediateTransaction(db, fn) {
   try {
     const result = fn();
     db.exec("COMMIT");
-    logSlowWriteTransaction("pi_compaction_queue", transactionStartedAt);
+    logSlowWriteTransaction("pi_fallback_adoption", transactionStartedAt);
     return result;
   } catch (error) {
     db.exec("ROLLBACK");
     throw error;
   }
 }
-function hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById) {
-  const fingerprints = [
-    ...new Set([...fingerprintById].filter(([id]) => !id.startsWith("pi-msg-")).map(([, fingerprint]) => fingerprint))
-  ];
-  for (let index = 0;index < fingerprints.length; index += 900) {
-    const batch = fingerprints.slice(index, index + 900);
-    const placeholders = batch.map(() => "?").join(",");
-    const match = db.prepare(`SELECT 1 FROM tags WHERE session_id = ? AND type = 'message'
-             AND entry_fingerprint IN (${placeholders})
-             AND message_id LIKE 'pi-msg-%' LIMIT 1`).get(sessionId, ...batch);
-    if (match != null)
-      return true;
+function readPiAdoptionRevision(db) {
+  return {
+    external: db.prepare("PRAGMA data_version").get(),
+    local: db.prepare("SELECT total_changes() AS changes").get()
+  };
+}
+function preparePiAdoptionFingerprints(fingerprintById) {
+  const realIdsByFingerprint = new Map;
+  for (const [id, fingerprint] of fingerprintById) {
+    if (id.startsWith("pi-msg-"))
+      continue;
+    const ids = realIdsByFingerprint.get(fingerprint) ?? [];
+    ids.push(id);
+    realIdsByFingerprint.set(fingerprint, ids);
   }
-  return false;
+  const fingerprints = [...realIdsByFingerprint.keys()];
+  const batches = [];
+  for (let i = 0;i < fingerprints.length; i += 900) {
+    const values = fingerprints.slice(i, i + 900);
+    batches.push({ values, placeholders: values.map(() => "?").join(",") });
+  }
+  return { realIdsByFingerprint, batches };
 }
-function readAdoptablePiFallbackFingerprints(db, sessionId, fingerprintById) {
-  const fingerprints = [
-    ...new Set([...fingerprintById].filter(([id]) => !id.startsWith("pi-msg-")).map(([, fingerprint]) => fingerprint))
-  ];
+function readAdoptablePiFallbackFingerprints(db, sessionId, batches) {
   const found = new Set;
-  for (let index = 0;index < fingerprints.length; index += 900) {
-    const batch = fingerprints.slice(index, index + 900);
-    const placeholders = batch.map(() => "?").join(",");
+  for (const { values, placeholders } of batches) {
     const rows = db.prepare(`SELECT DISTINCT entry_fingerprint FROM tags WHERE session_id = ? AND type = 'message'
-             AND entry_fingerprint IN (${placeholders}) AND message_id LIKE 'pi-msg-%'`).all(sessionId, ...batch);
+			 AND entry_fingerprint IN (${placeholders}) AND message_id LIKE 'pi-msg-%'`).all(sessionId, ...values);
     for (const row of rows)
       found.add(row.entry_fingerprint);
   }
   return found;
 }
+function piFallbackBaseId(messageId) {
+  return /^(.*):p\d+$/.exec(messageId)?.[1] ?? messageId;
+}
+function pairPiFallbackBases(realIds, candidates, realIdPositions) {
+  const pairs = new Map(realIds.map((id) => [id, null]));
+  if (realIds.length < 2)
+    return pairs;
+  const positions = realIdPositions();
+  if (!positions || realIds.some((id) => !positions.has(id)))
+    return pairs;
+  const newestTag = new Map;
+  for (const c of candidates) {
+    const base = piFallbackBaseId(c.messageId);
+    newestTag.set(base, Math.max(newestTag.get(base) ?? 0, c.tagNumber));
+  }
+  if (newestTag.size < realIds.length)
+    return pairs;
+  const chosen = [...newestTag.entries()].sort((left, right) => right[1] - left[1]).slice(0, realIds.length).map(([base]) => ({ base, index: /^pi-msg-(\d+)-/.exec(base)?.[1] }));
+  if (chosen.some((entry) => entry.index === undefined))
+    return pairs;
+  chosen.sort((left, right) => Number(left.index) - Number(right.index));
+  if (new Set(chosen.map((entry) => entry.index)).size !== chosen.length)
+    return pairs;
+  const ordered = [...realIds].sort((left, right) => (positions.get(left) ?? 0) - (positions.get(right) ?? 0));
+  for (let index = 0;index < ordered.length; index += 1) {
+    pairs.set(ordered[index], chosen[index]?.base ?? null);
+  }
+  return pairs;
+}
 function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {}) {
-  const hasFallbackMessageTags = options.hasFallbackMessageTags === true || hasPiFallbackMessageTags2(db, sessionId);
-  const hasFallbackToolOwnerTags = options.hasFallbackToolOwnerTags === true || hasPiFallbackToolOwnerTags2(db, sessionId);
-  const shouldRunMessageMigration = hasFallbackMessageTags && hasAdoptablePiFallbackMessageTags(db, sessionId, fingerprintById);
-  const shouldRunToolOwnerMigration = Boolean(options.messages && options.resolveStableId && hasFallbackToolOwnerTags);
-  if (!shouldRunMessageMigration && !shouldRunToolOwnerMigration)
+  let { realIdsByFingerprint, batches } = preparePiAdoptionFingerprints(fingerprintById);
+  const ownerMap = options.messages && options.resolveStableId ? buildPiToolOwnerMap(options.messages, options.resolveStableId) : null;
+  if (!batches.length && !ownerMap?.size && !options.rebuildFingerprints)
     return;
+  const revision = () => readPiAdoptionRevision(db);
+  const beforeDiscovery = revision();
+  const discovered = hasPiFallbackMessageTags(db, sessionId) ? readAdoptablePiFallbackFingerprints(db, sessionId, batches) : new Set;
+  const targetsFor = (fingerprints) => [...fingerprints].flatMap((fingerprint) => (realIdsByFingerprint.get(fingerprint) ?? []).map((id) => [id, fingerprint]));
+  const discoveredTargets = targetsFor(discovered);
   runImmediateTransaction(db, () => {
-    if (shouldRunMessageMigration) {
-      const adoptable = readAdoptablePiFallbackFingerprints(db, sessionId, fingerprintById);
-      for (const [realMessageId, fingerprint] of fingerprintById) {
+    const admitted = revision();
+    const preflight = options.preflightRevision;
+    const rebuild = options.rebuildFingerprints;
+    const expanded = Boolean(preflight && rebuild && (preflight.external.data_version !== admitted.external.data_version || preflight.local.changes !== admitted.local.changes));
+    if (expanded && rebuild) {
+      ({ realIdsByFingerprint, batches } = preparePiAdoptionFingerprints(rebuild()));
+    }
+    if (batches.length && hasPiFallbackMessageTags(db, sessionId)) {
+      const unchanged = !expanded && beforeDiscovery.external.data_version === admitted.external.data_version && beforeDiscovery.local.changes === admitted.local.changes;
+      const adoptable = unchanged ? discovered : readAdoptablePiFallbackFingerprints(db, sessionId, batches);
+      const targets = expanded ? targetsFor(adoptable) : discoveredTargets.filter(([, fp]) => adoptable.has(fp));
+      if (!expanded)
+        targets.push(...targetsFor([...adoptable].filter((fp) => !discovered.has(fp))));
+      const pairedBaseByRealId = new Map;
+      let positions;
+      const realIdPositions = () => {
+        if (positions)
+          return positions;
+        const { messages, resolveStableId } = options;
+        if (!messages || !resolveStableId)
+          return;
+        positions = new Map;
+        for (let index = 0;index < messages.length; index += 1) {
+          const id = resolveStableId(messages[index], index);
+          if (id !== undefined && !positions.has(id))
+            positions.set(id, index);
+        }
+        return positions;
+      };
+      for (const [realMessageId, fingerprint] of targets) {
         if (realMessageId.startsWith("pi-msg-"))
           continue;
         if (!adoptable.has(fingerprint))
@@ -42477,19 +43412,27 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
         const candidates = findAdoptableFallbackTags(db, sessionId, fingerprint);
         if (candidates.length === 0)
           continue;
-        const baseIds = new Set;
-        for (const c of candidates) {
-          const m = /^(.*):p\d+$/.exec(c.messageId);
-          baseIds.add(m ? m[1] : c.messageId);
+        const baseIds = new Set(candidates.map((c) => piFallbackBaseId(c.messageId)));
+        let base;
+        if (baseIds.size === 1)
+          base = [...baseIds][0];
+        else {
+          if (!pairedBaseByRealId.has(realMessageId)) {
+            for (const [id, paired] of pairPiFallbackBases((realIdsByFingerprint.get(fingerprint) ?? []).filter((id) => !id.startsWith("pi-msg-")), candidates, realIdPositions))
+              pairedBaseByRealId.set(id, paired);
+          }
+          base = pairedBaseByRealId.get(realMessageId) ?? undefined;
         }
-        if (baseIds.size !== 1)
+        if (base === undefined)
           continue;
         for (const c of candidates) {
+          if (piFallbackBaseId(c.messageId) !== base)
+            continue;
           const ordinalMatch = /:p(\d+)$/.exec(c.messageId);
           if (!ordinalMatch)
             continue;
           const realContentId = `${realMessageId}:p${ordinalMatch[1]}`;
-          const adoption = adoptPiFallbackMessageTag(db, sessionId, c.tagNumber, c.messageId, realContentId);
+          const adoption = adoptPiFallbackMessageTag(db, sessionId, c.tagNumber, c.messageId, realContentId, getPiServedTagNumbers(sessionId));
           if (adoption.action !== "skipped") {
             tagger.unbindTag(sessionId, c.messageId);
             if (adoption.action === "folded") {
@@ -42500,8 +43443,7 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
         }
       }
     }
-    if (shouldRunToolOwnerMigration && options.messages && options.resolveStableId) {
-      const ownerMap = buildPiToolOwnerMap(options.messages, options.resolveStableId);
+    if (ownerMap && hasPiFallbackToolOwnerTags(db, sessionId)) {
       for (const row of findPiFallbackToolOwnerTags(db, sessionId)) {
         const parsed = parsePiFallbackToolOwnerId(row.toolOwnerMessageId);
         if (parsed?.role !== "assistant")
@@ -42512,7 +43454,7 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
         const [realOwnerId] = owners;
         if (!realOwnerId || realOwnerId.startsWith("pi-msg-"))
           continue;
-        const adoption = adoptPiFallbackToolOwnerTag(db, sessionId, row.tagNumber, row.callId, row.toolOwnerMessageId, realOwnerId);
+        const adoption = adoptPiFallbackToolOwnerTag(db, sessionId, row.tagNumber, row.callId, row.toolOwnerMessageId, realOwnerId, getPiServedTagNumbers(sessionId));
         if (adoption.action !== "skipped") {
           tagger.unbindToolTag(sessionId, row.toolOwnerMessageId, row.callId);
           if (adoption.action === "folded") {
@@ -42583,12 +43525,32 @@ function registerPiContextHandler(pi, baseOptions) {
     variantChangeLogObserverForTests?.(message);
     sessionLog(sessionId, message);
   });
-  registerPiGuardedContext(pi, async (event, ctx) => {
-    const transformStartTime = performance.now();
+  const contextHandler = async (event, ctx, budget) => {
+    const passSessionId = ctx.sessionManager ? resolveSessionId2(ctx) : undefined;
+    const generation = Symbol();
+    if (passSessionId && !budget.sideTurn)
+      contextPassGeneration.set(passSessionId, generation);
+    const signal = event.signal ?? ctx.signal;
+    const assertOperation = budget.assertOwner;
+    budget.assertOwner = () => {
+      assertOperation();
+      if (!budget.sideTurn && passSessionId && contextPassGeneration.get(passSessionId) !== generation)
+        throw new PiContextSupersededError("Pi context pass superseded before writer admission");
+      signal?.throwIfAborted();
+    };
+    let assertCurrentPass = budget.assert;
+    const guardAwait = budget.wait;
+    const passGuard = { assert: assertCurrentPass, wait: guardAwait };
+    guardSqliteTransformPass({
+      assert: assertCurrentPass,
+      remainingMs: () => budget.remainingWork()
+    });
+    budget.stage = "schema/claim";
+    const toolWireSchema = await guardAwait(loadPiToolWireSchema());
+    const transformStartTime = budget.startedAt;
     let rawMessageCount = 0;
     let rawFallbackLimit;
     let sessionIdForError;
-    let sessionMetaForPass;
     let lkgPassSnapshot;
     let lkgCompactionOff = baseOptions.compactionOff === true;
     let lkgEmergencyRecoveryArmed = false;
@@ -42616,17 +43578,21 @@ function registerPiContextHandler(pi, baseOptions) {
       const scheduler = schedulerFor(options);
       lkgCompactionOff = options.compactionOff === true;
       const projectIdentity = resolveProjectIdentityForSession(projectDirectory, options.allowHomeProject) ?? "";
-      updateSessionProjectTracking(sessionId, projectIdentity, options.db);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
+      budget.stage = "branch projection";
       const tEntryBranch = performance.now();
       const branchEntries = readPiBranchEntriesForContext(ctx, sessionId);
+      assertCurrentPass();
       const piLiveUsageIsRawBranchEstimate = isPiLiveUsageRawBranchEstimate(branchEntries);
       recordPiLiveUsageClassification(sessionId, piLiveUsageIsRawBranchEstimate);
-      schedulePiTransformDecisionResolve({
-        db: options.db,
-        sessionId,
-        branchEntries
-      });
+      assertCurrentPass();
+      if (!budget.sideTurn)
+        schedulePiTransformDecisionResolve({
+          db: options.db,
+          sessionId,
+          branchEntries,
+          assertCurrentPass
+        });
       let rawOrdinalCount;
       const rawMessageProvider = {
         getMessageCount: () => rawOrdinalCount ??= branchEntries !== null ? countPiRawMessages(branchEntries) : readPiSessionMessages(ctx).length,
@@ -42638,21 +43604,63 @@ function registerPiContextHandler(pi, baseOptions) {
       const unregisterRaw = setRawMessageProvider2(sessionId, rawMessageProvider);
       rawMessageProviderUnregistersBySession.set(sessionId, unregisterRaw);
       scheduleReconciliation(options.db, sessionId, readRawSessionMessages2);
-      const branchLookup = branchEntries === null ? null : getPiBranchEntryLookup(branchEntries);
-      const alignedEntryIds = branchLookup?.alignedEntryIds ?? null;
-      const resolvedEntryIds = alignedEntryIds?.length === event.messages.length ? alignedEntryIds : branchEntries === null ? null : collectMessageEntryIdsByRef(ctx, event.messages, sessionId, branchEntries);
+      const alignedEntryIds = branchEntries === null ? null : getPiBranchEntryLookup(branchEntries).alignedEntryIds;
+      const resolvedEntryIds = resolvePiEventEntryIds(ctx, event.messages, sessionId, branchEntries);
       const strictEntryIds = resolvedEntryIds ? [...resolvedEntryIds] : null;
       const lkgEntryIds = reconcilePiLkgEntryIds(strictEntryIds, alignedEntryIds);
       const lkgModelKey = resolvePiContextModelKey(ctx) ?? null;
       const lkgContextModel = ctx.model;
       const lkgProviderKey = typeof lkgContextModel?.provider === "string" ? lkgContextModel.provider : null;
-      lkgPassSnapshot = lkgCoordinator.beginPass({
+      const snapshot = lkgCoordinator.beginPass({
         sessionId,
         messages: event.messages,
         entryIds: lkgEntryIds,
         modelKey: lkgModelKey,
-        providerKey: lkgProviderKey
+        providerKey: lkgProviderKey,
+        apiKey: ctx.model?.api ?? null,
+        transport: ctx.model?.transport
       });
+      lkgPassSnapshot = snapshot;
+      let checkedReplay = false;
+      budget.stage = "writer admission";
+      assertCurrentPass();
+      const sessionMetaForUsage = await guardAwait(withAsyncPrivilegedWriter(options.db, () => {
+        assertCurrentPass();
+        return getOrCreateSessionMeta(options.db, sessionId);
+      }, {
+        signal,
+        budgetMs: budget.writerAllowance(),
+        assertCurrentPass,
+        jitter: true,
+        beforeRetry: (error) => {
+          assertCurrentPass();
+          if (checkedReplay)
+            return;
+          checkedReplay = true;
+          const state = loadPiHistorianStateSnapshot(options.db, sessionId);
+          lkgEmergencyRecoveryArmed = state.needsEmergencyRecovery;
+          if (state.detectedContextLimit > 0)
+            rawFallbackLimit = resolvePiWindowGeometry({
+              model: ctx.model,
+              rawContextWindow: piUsage?.contextWindow,
+              detectedContextLimit: state.detectedContextLimit
+            })?.usableHard;
+          if (lkgCompactionOff || lkgEmergencyRecoveryArmed || isProviderOverflowFailClosedProven(sessionId))
+            return;
+          const replay = lkgCoordinator.replay(snapshot, (id) => ctx.sessionManager.getEntry?.(id)?.parentId);
+          if (!replay.ok)
+            return;
+          try {
+            assertPiRawFallbackFits(replay.messages, rawFallbackLimit, (line) => logPiLkgRecovery(sessionId, line), error, readPiLkgFitEnvelope(ctx, pi, lkgModelKey, sessionDecisionCalibration(options.db, sessionId), toolWireSchema), replay.measuredPrefix);
+          } catch {
+            return;
+          }
+          logPiLkgRecovery(sessionId, `TRANSIENT STORAGE FAILURE ${piStorageErrorReason(error)}: LKG replay served ${replay.messages.length} messages instead of raw ${rawMessageCount}`);
+          throw new PiLkgAdmissionReplay(replay.messages);
+        }
+      }));
+      assertCurrentPass();
+      updateSessionProjectTracking(sessionId, projectIdentity, options.db, projectDirectory);
       const lkgInputIdByRef = new Map;
       for (const input of lkgPassSnapshot.inputs)
         lkgInputIdByRef.set(event.messages[input.messageIndex], input.id);
@@ -42680,8 +43688,6 @@ function registerPiContextHandler(pi, baseOptions) {
         }
       }
       const tMeta = performance.now();
-      const sessionMetaForUsage = getOrCreateSessionMeta(options.db, sessionId);
-      sessionMetaForPass = sessionMetaForUsage;
       const historianStateForPass = options.compactionOff ? EMPTY_PI_HISTORIAN_STATE_SNAPSHOT : (() => {
         try {
           return loadPiHistorianStateSnapshot(options.db, sessionId);
@@ -42841,7 +43847,7 @@ function registerPiContextHandler(pi, baseOptions) {
       } catch (err) {
         sessionLog(sessionId, `transform: overflow state read failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-      const sessionMeta = sessionMetaForUsage;
+      let sessionMeta = sessionMetaForUsage;
       const modelKey = liveModelBySession.get(sessionId);
       const providerId = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
       const canUseEmptySentinels = modelAcceptsEmptyContent(providerId);
@@ -42953,14 +43959,25 @@ function registerPiContextHandler(pi, baseOptions) {
         if (now - lastNotifiedAt >= EMERGENCY_NOTIFICATION_COOLDOWN_MS) {
           lastEmergencyNotificationAtMs.set(sessionId, now);
           sendPiIgnoredNotification(ctx, "Context full — /mmc-flush or /clear to continue.");
-          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, awaiting in-flight historian + evaluating tiered emergency reclaim`);
-        }
-        const histPromise = inFlightHistorian.get(sessionId);
-        if (histPromise) {
-          try {
-            await withTimeout(histPromise, 30000);
-            sessionLog(sessionId, "EMERGENCY: historian wait completed (or timed out)");
-          } catch {}
+          sessionLog(sessionId, `EMERGENCY: usage=${usagePercentage.toFixed(1)}% — notified user, evaluating available emergency reclaim`);
+        }
+        const historian = inFlightHistorian.get(sessionId);
+        const visibleToolResults = new Set(event.messages.flatMap((message) => message.role === "toolResult" ? [message.toolCallId] : []));
+        const toolTags = getTagsBySession(options.db, sessionId).filter((tag) => tag.type === "tool");
+        const knownTools = new Set(toolTags.map((tag) => tag.messageId));
+        const activeTools = new Set(toolTags.filter((tag) => tag.status === "active").map((tag) => tag.messageId));
+        const hasToolReclaim = event.messages.some((message) => message.role === "assistant" && message.content.some((part) => part.type === "toolCall" && visibleToolResults.has(part.id) && (!knownTools.has(part.id) || activeTools.has(part.id))));
+        if (historian && !hasToolReclaim && getPendingOps(options.db, sessionId).length === 0 && !historyRefreshSessions.has(sessionId) && !deferredHistoryRefreshSessions.has(sessionId)) {
+          budget.stage = "emergency historian";
+          await budget.wait(historian);
+          assertCurrentPass();
+          sessionMeta = getOrCreateSessionMeta(options.db, sessionId);
+          piM0M1PassSnapshot = options.injection ? createPiM0M1PassSnapshot({
+            db: options.db,
+            sessionId,
+            compactionOff: false,
+            sessionMeta
+          }) : undefined;
         }
         if (emergencyRecoveryArmed && realUsagePercentageBeforeEmergencyBump < forceMaterializationPercentage && !inFlightHistorian.has(sessionId) && !hasEligiblePiCompartmentHistory(options.db, sessionId)) {
           try {
@@ -42983,7 +44000,17 @@ function registerPiContextHandler(pi, baseOptions) {
       }) / 100)) : undefined;
       logTransformTiming(sessionId, "prePipelineTotal", transformStartTime);
       const tRunPipeline = performance.now();
-      const result = await runPipeline({
+      budget.stage = "pipeline";
+      assertCurrentPass = budget.assertOutcome;
+      guardSqliteTransformPass({
+        assert: assertCurrentPass,
+        remainingMs: budget.remainingOutcome
+      });
+      if (beforePipelineForTests)
+        await budget.waitMandatory(beforePipelineForTests());
+      assertCurrentPass();
+      const result = await budget.waitMandatory(runPipeline({
+        assertCurrentPass,
         db: options.db,
         tagger,
         sessionId,
@@ -43036,20 +44063,21 @@ function registerPiContextHandler(pi, baseOptions) {
         resolvedModelID: ctx.model?.id,
         canUseEmptySentinels,
         temporalAwareness: options.injection?.temporalAwareness === true,
-        appendCompaction: resolvePiAppendCompaction(ctx),
+        appendCompaction: guardedPiAppendCompaction(ctx, assertCurrentPass),
         readBranchEntries: resolvePiReadBranchEntries(ctx),
         isSubagent: sessionMeta.isSubagent,
         compactionOff: options.compactionOff === true,
         injectionPassSnapshot: piM0M1PassSnapshot
-      });
+      }));
       logTransformTiming(sessionId, "runPipeline", tRunPipeline);
       const postPipelineStart = performance.now();
       const tTransformDecision = performance.now();
       if (strictEntryIds) {
+        assertCurrentPass();
         recordSuccessfulTaggedMessageIds(sessionId, strictEntryIds);
       }
       const piDecisionSnapshotNewestAssistant = result.bustedThisPass ? findNewestPiAssistantEntryId(branchEntries) : undefined;
-      if (piDecisionSnapshotNewestAssistant !== undefined) {
+      const publishTransformDecision = !budget.sideTurn && piDecisionSnapshotNewestAssistant !== undefined ? () => {
         recordPendingPiTransformDecision(sessionId, {
           tsMs: Date.now(),
           decision: schedulerDecision,
@@ -43064,28 +44092,51 @@ function registerPiContextHandler(pi, baseOptions) {
           droppedCount: result.droppedCount,
           inputTokens: usageInputTokens,
           bustedThisPass: true
-        }, piDecisionSnapshotNewestAssistant);
-      }
+        }, piDecisionSnapshotNewestAssistant, budget.assertDecisionPublication);
+      } : undefined;
       logTransformTiming(sessionId, "transformDecisionAndReuseState", tTransformDecision);
       const tHistorianScheduling = performance.now();
-      if (options.historian && !options.compactionOff) {
-        maybeFireHistorian({
-          pi,
-          ctx,
-          sessionId,
-          db: options.db,
-          historian: options.historian,
-          isFirstContextPassForSession,
-          activeTags: result.activeTags,
-          rawMessageProvider,
-          taggerFloor,
-          sessionMeta,
-          liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
-          piUsage,
-          minimumPercentage: usagePercentage,
-          historianStateSnapshot: historianStateForPass,
-          publishedHistoryRide: isCacheBusting
+      const historian = options.historian;
+      budget.stage = "historian scheduling";
+      if (historian && !options.compactionOff && budget.remainingWork() > 0) {
+        guardSqliteTransformPass({
+          assert: budget.assert,
+          remainingMs: () => budget.remainingWork()
         });
+        try {
+          budget.assert();
+          maybeFireHistorian({
+            startGuard: () => {
+              if (!budget.completed)
+                budget.assertOwner();
+              if (budget.abandoned || budget.remainingWork() === 0)
+                throw new PiContextDeadlineError(budget.diagnostic());
+            },
+            pi,
+            ctx,
+            sessionId,
+            db: options.db,
+            historian,
+            isFirstContextPassForSession,
+            activeTags: result.activeTags,
+            rawMessageProvider,
+            taggerFloor,
+            sessionMeta,
+            liveIsRawBranchEstimate: piLiveUsageIsRawBranchEstimate,
+            piUsage,
+            minimumPercentage: usagePercentage,
+            historianStateSnapshot: historianStateForPass,
+            publishedHistoryRide: isCacheBusting
+          });
+        } catch (error) {
+          budget.assertOutcome();
+          sessionLog(sessionId, `historian scheduling skipped: ${String(error)}`);
+        } finally {
+          guardSqliteTransformPass({
+            assert: budget.assertOutcome,
+            remainingMs: budget.remainingOutcome
+          });
+        }
       }
       logTransformTiming(sessionId, "historianScheduling", tHistorianScheduling);
       const tPostTransform = performance.now();
@@ -43120,9 +44171,15 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       logTransformTiming(sessionId, "storedHintReplay", tStoredHintReplay);
       const tAutoSearch = performance.now();
-      if (options.autoSearch?.enabled && !options.compactionOff) {
+      budget.stage = "auto-search";
+      if (options.autoSearch?.enabled && !options.compactionOff && budget.remainingWork() > PI_CONTEXT_BUDGET.searchMs) {
+        guardSqliteTransformPass({
+          assert: budget.assert,
+          remainingMs: () => budget.remainingWork()
+        });
         try {
-          outputMessages = await runAutoSearchHintForPi({
+          outputMessages = await guardAwait(runAutoSearchHintForPi({
+            passGuard,
             sessionId,
             db: options.db,
             messages: outputMessages,
@@ -43137,9 +44194,15 @@ function registerPiContextHandler(pi, baseOptions) {
               visibleMemoryIds: getVisibleMemoryIds(options.db, sessionId) ?? null,
               wordRules: cavemanWordRulesForLanguage(options.language)
             }
-          });
+          }));
         } catch (err) {
+          assertCurrentPass();
           sessionLog(sessionId, `auto-search failed: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          guardSqliteTransformPass({
+            assert: budget.assertOutcome,
+            remainingMs: budget.remainingOutcome
+          });
         }
       }
       logTransformTiming(sessionId, "autoSearch", tAutoSearch);
@@ -43287,6 +44350,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
       const tWorkMetrics = performance.now();
+      budget.stage = "bookkeeping";
       try {
         const metrics = computePiWorkMetrics(outputMessages);
         setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
@@ -43336,19 +44400,27 @@ function registerPiContextHandler(pi, baseOptions) {
       sessionLog(sessionId, `transform completed in ${transformElapsedMs.toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       runPiDebugAssertion(assertTailHygieneLastWriter);
       if (!options.compactionOff && (result.executedWorkThisPass || isCacheBusting || schedulerDecision === "execute")) {
-        const envelope = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(options.db, sessionId));
+        const envelope = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(options.db, sessionId), toolWireSchema);
         const estimate = estimatePiOutgoingInputTokens(outputMessages, envelope, lkgPassSnapshot ? lkgCoordinator.measureOutgoingPrefix(lkgPassSnapshot, outputMessages, (id) => ctx.sessionManager.getEntry?.(id)?.parentId) : undefined, rawFallbackLimit);
         const refusal = outgoingContextRefusal(estimate, rawFallbackLimit, protectedToolTokenCount(getActiveTagsBySession(options.db, sessionId), options.protectedTools, envelope ? calibrationForModelKey(envelope.modelKey) : undefined));
         if (refusal)
           throw contextRefusalError(refusal);
       }
       let serializedOutput;
-      if (!lkgCompactionOff && lkgPassSnapshot) {
+      budget.stage = "LKG/served publication";
+      budget.assertOutcome();
+      guardSqliteTransformPass({
+        assert: budget.assertOutcome,
+        remainingMs: () => Math.max(0, PI_CONTEXT_BUDGET.outcomeMs - budget.elapsed())
+      });
+      if (!budget.sideTurn && !lkgCompactionOff && lkgPassSnapshot) {
         let hostEnvelopeSignature;
         try {
-          hostEnvelopeSignature = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionId))?.envelopeSignature;
+          hostEnvelopeSignature = readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionId), toolWireSchema)?.envelopeSignature;
         } catch {}
+        budget.assertOutcome();
         serializedOutput = lkgCoordinator.captureAppliedPass({
+          assertCurrentPass: budget.assertOutcome,
           hostEnvelopeSignature,
           snapshot: lkgPassSnapshot,
           outputMessages,
@@ -43356,8 +44428,15 @@ function registerPiContextHandler(pi, baseOptions) {
           cacheBusting: result.bustedThisPass
         });
       }
-      capturePiServedArray(sessionId, outputMessages, { serializedOutput });
-      captureOpencodeReasoningBudgetStatus(sessionId, piReasoningStatusMessages(outputMessages), resolveKeepReasoningTokens(options.heuristics?.keepReasoningTokens, resolvePiContextModelKey(ctx)), isPrefixBoundThinkingModel(ctx.model?.provider, ctx.model?.id), sessionDecisionCalibration(options.db, sessionId).proseRatio);
+      budget.assertOutcome();
+      if (!budget.sideTurn)
+        capturePiServedArray(sessionId, outputMessages, {
+          servedTagNumbers: result.servedTagNumbers,
+          serializedOutput,
+          assertCurrentPass: budget.assertOutcome
+        });
+      if (!budget.sideTurn)
+        captureOpencodeReasoningBudgetStatus(sessionId, piReasoningStatusMessages(outputMessages), resolveKeepReasoningTokens(options.heuristics?.keepReasoningTokens, resolvePiContextModelKey(ctx)), isPrefixBoundThinkingModel(ctx.model?.provider, ctx.model?.id), sessionDecisionCalibration(options.db, sessionId).proseRatio);
       if (thinkingBindingRecoveryApplied) {
         try {
           clearThinkingBindingRecoveryIf(options.db, sessionId, thinkingBindingRecoveryApplied.flagTarget);
@@ -43365,14 +44444,34 @@ function registerPiContextHandler(pi, baseOptions) {
           sessionLog(sessionId, `thinking binding recovery cleanup deferred: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
+      budget.assertOutcome();
+      publishTransformDecision?.();
       return { messages: outputMessages };
     } catch (err) {
+      budget.assertOutcome();
+      budget.stage = "recovery";
+      if (err instanceof PiServedIdentityError) {
+        if (sessionIdForError)
+          clearPiLkgSessionState(sessionIdForError);
+        throw new PiStorageBusyError({ cause: err });
+      }
+      if (err instanceof PiLkgAdmissionReplay && sessionIdForError) {
+        budget.assertOutcome();
+        if (!budget.sideTurn)
+          capturePiServedArray(sessionIdForError, err.messages, {
+            assertCurrentPass: budget.assertOutcome
+          });
+        budget.assertOutcome();
+        budget.recovery = "fitting LKG before writer retries";
+        return { messages: err.messages };
+      }
       if ((isFailClosedBlockingError(err) || err instanceof EmergencyFailClosedError) && !baseOptions.compactionOff)
         throw err;
       if (!lkgCompactionOff && sessionIdForError && isProviderOverflowFailClosedProven(sessionIdForError)) {
         throw new EmergencyFailClosedError("Emergency recovery transform failed; refusing an unbounded raw fallback", { cause: err });
       }
       const message = err instanceof Error ? err.message : String(err);
+      budget.failureReason = message;
       const stack = err instanceof Error ? err.stack : undefined;
       const transientStorageFailure = isTransientPiStorageError(err);
       const degradedPass = !lkgCompactionOff;
@@ -43385,14 +44484,21 @@ function registerPiContextHandler(pi, baseOptions) {
             assertPiRawFallbackFits(replay.messages, rawFallbackLimit, (line) => {
               if (sessionIdForError)
                 logPiLkgRecovery(sessionIdForError, line);
-            }, err, readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionIdForError)), replay.measuredPrefix);
+            }, err, readPiLkgFitEnvelope(ctx, pi, resolvePiContextModelKey(ctx), sessionDecisionCalibration(baseOptions.db, sessionIdForError), toolWireSchema), replay.measuredPrefix);
             const reason = piStorageErrorReason(err);
             logPiLkgRecovery(sessionIdForError, `${failureLabel} ${reason}: LKG replay served ${replay.messages.length} messages instead of raw ${rawMessageCount}`);
-            capturePiServedArray(sessionIdForError, replay.messages);
+            budget.assertOutcome();
+            if (!budget.sideTurn)
+              capturePiServedArray(sessionIdForError, replay.messages, {
+                assertCurrentPass: budget.assertOutcome
+              });
+            budget.assertOutcome();
+            budget.recovery = "fitting LKG replay";
             return { messages: replay.messages };
           }
           logPiLkgRecovery(sessionIdForError, `${failureLabel} ${piStorageErrorReason(err)}: LKG unavailable (${replay.reason}); refusing unreduced ${rawMessageCount}-message input`);
         } catch (replayError) {
+          budget.assertOutcome();
           if (replayError instanceof PiStorageBusyError)
             throw replayError;
           logPiLkgRecovery(sessionIdForError, `${failureLabel} ${piStorageErrorReason(err)}: LKG replay unavailable (${replayError instanceof Error ? replayError.message : String(replayError)}); refusing unreduced ${rawMessageCount}-message input`);
@@ -43403,9 +44509,6 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       if (transientStorageFailure)
         throw new PiStorageBusyError({ cause: err });
-      if (sessionIdForError && !transientStorageFailure) {
-        persistLastTransformErrorIfChanged(baseOptions.db, sessionIdForError, summarizeTransformError(err), sessionMetaForPass?.lastTransformError);
-      }
       if (!lkgCompactionOff && sessionIdForError) {
         throw new PiStorageBusyError({
           cause: err instanceof PiDegradedPassError ? err : new PiDegradedPassError("context-handler-failed", {
@@ -43416,6 +44519,23 @@ function registerPiContextHandler(pi, baseOptions) {
       log(`[magic-context][pi] context handler failed (continuing without mutation): ${message}`, stack);
       return;
     }
+  };
+  registerPiGuardedContext(pi, contextHandler, {
+    compactionOff: (ctx) => (baseOptions.resolveForProject?.(ctx.cwd) ?? baseOptions).compactionOff === true,
+    onRefusal: (ctx, budget, message, isCurrent) => {
+      const sessionId = resolveSessionId2(ctx);
+      if (!sessionId)
+        return;
+      withoutSqliteTransformPass(() => setImmediate(() => {
+        if (!isCurrent())
+          return;
+        try {
+          withSqliteBackgroundWriter(() => persistLastTransformErrorIfChanged(baseOptions.db, sessionId, budget.failureReason ?? message));
+        } catch (error) {
+          log(`[magic-context][pi] refused-turn diagnostic not persisted ${budget.diagnostic()}`, error);
+        }
+      }));
+    }
   });
   log("[magic-context][pi] registered context handler (tagging + drops + nudges)");
 }
@@ -43609,12 +44729,15 @@ function spawnPiHistorianRun(args) {
     currentContextLimit,
     fallbackModelId
   } = args;
+  args.startGuard?.();
   const holderId = crypto3.randomUUID();
   const controller = new AbortController;
   historianAbortControllers.set(sessionId, controller);
-  const runPromise = (async () => {
+  const runPromise = withoutSqliteTransformPass(() => (async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
     if (controller.signal.aborted)
       return;
+    args.startGuard?.();
     const lease = acquireCompartmentLease(db, sessionId, holderId);
     if (!lease) {
       sessionLog(sessionId, "historian skipped: compartment lease held by another process");
@@ -43627,6 +44750,9 @@ function spawnPiHistorianRun(args) {
     }
     const renewal = startPiCompartmentLeaseRenewal(db, sessionId, holderId);
     try {
+      const runBoundary = typeof boundarySnapshot === "function" ? boundarySnapshot() : boundarySnapshot;
+      if (!runBoundary)
+        return;
       await runPiHistorian({
         db,
         sessionId,
@@ -43654,7 +44780,7 @@ function spawnPiHistorianRun(args) {
           const window = ctx.modelRegistry?.find(model.slice(0, slash), model.slice(slash + 1))?.contextWindow;
           return isSaneLimit(window) ? window : undefined;
         },
-        boundarySnapshot,
+        boundarySnapshot: runBoundary,
         refreshBoundarySnapshot,
         currentContextLimit,
         historianTimeoutMs: historian.timeoutMs,
@@ -43713,7 +44839,7 @@ function spawnPiHistorianRun(args) {
     } catch (error) {
       sessionLog(sessionId, `pi historian finalizer failed: ${error instanceof Error ? error.message : String(error)}`);
     }
-  });
+  }));
   inFlightHistorian.set(sessionId, runPromise);
   historian.onStatusChange?.(ctx, sessionId);
 }
@@ -43723,6 +44849,13 @@ function resolvePiAppendCompaction(ctx) {
     return;
   return sm.appendCompaction.bind(sm);
 }
+function guardedPiAppendCompaction(ctx, assertCurrentPass) {
+  const append = resolvePiAppendCompaction(ctx);
+  return append ? (...args) => {
+    assertCurrentPass();
+    return append(...args);
+  } : undefined;
+}
 function resolvePiReadBranchEntries(ctx) {
   const sm = ctx.sessionManager;
   if (typeof sm?.getBranch !== "function")
@@ -43821,7 +44954,6 @@ function maybeFireHistorian(args) {
     readMessages: () => readPiSessionMessages(ctx),
     readMessagePage: (afterOrdinal, limit, finalWatermark) => readPiSessionMessagePage(ctx, afterOrdinal, limit, finalWatermark)
   };
-  const unregister = setRawMessageProvider2(sessionId, provider);
   const modelKey = liveModelBySession.get(sessionId);
   const triggerInputs = resolvePiHistorianTriggerInputs({
     db,
@@ -43832,6 +44964,20 @@ function maybeFireHistorian(args) {
   });
   const historianForceMaterializationPercentage = escalationBands(triggerInputs.executeThresholdPercentage).forceMaterializationPercentage;
   const boundaryContextLimit = triggerInputs.contextLimit;
+  if (isHistorianDrainBudgetSpent({
+    db,
+    sessionId,
+    contextLimit: boundaryContextLimit,
+    executeThresholdPercentage: triggerInputs.executeThresholdPercentage,
+    usagePercentage: usage.percentage
+  })) {
+    if (sessionMeta.compartmentInProgress) {
+      updateSessionMeta(db, sessionId, { compartmentInProgress: false });
+      sessionMeta.compartmentInProgress = false;
+    }
+    return;
+  }
+  const unregister = setRawMessageProvider2(sessionId, provider);
   const resolvePiBoundarySnapshot = (emergencyTailScale) => resolveProtectedTailBoundary(resolveBoundaryContext({
     db,
     sessionId,
@@ -43863,16 +45009,19 @@ function maybeFireHistorian(args) {
       }
       const failureCount = historianStateSnapshot.historianFailureCount;
       if (failureCount > 0) {
-        boundarySnapshot = resolveRunnablePiBoundarySnapshot();
-      }
-      const shouldRecoverOnFirstPass = failureCount > 0 && boundarySnapshot !== undefined && hasEligiblePiCompartmentHistory(db, sessionId, boundarySnapshot);
-      if (shouldRecoverOnFirstPass) {
         triggered = true;
-        sessionLog(sessionId, `historian recovery triggered on session load after ${failureCount} failure(s)`);
-        sendPiIgnoredNotification(ctx, `## Historian recovery
+        const prepareRecoveryBoundary = () => {
+          const snapshot = resolveRunnablePiBoundarySnapshot();
+          if (!hasEligiblePiCompartmentHistory(db, sessionId, snapshot))
+            return;
+          sessionLog(sessionId, `historian recovery triggered on session load after ${failureCount} failure(s)`);
+          sendPiIgnoredNotification(ctx, `## Historian recovery
 
 Historian previously failed ${failureCount} time(s), so Magic Context is retrying history comparting immediately after restart.`);
+          return snapshot;
+        };
         spawnPiHistorianRun({
+          startGuard: args.startGuard,
           pi: args.pi,
           ctx,
           sessionId,
@@ -43880,7 +45029,7 @@ Historian previously failed ${failureCount} time(s), so Magic Context is retryin
           historian,
           provider,
           unregister,
-          boundarySnapshot,
+          boundarySnapshot: prepareRecoveryBoundary,
           refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
           currentContextLimit: boundaryContextLimit,
           fallbackModelId: modelKey
@@ -43915,6 +45064,7 @@ Historian previously failed ${failureCount} time(s), so Magic Context is retryin
     triggered = true;
     sessionLog(sessionId, `historian trigger fired (reason=${trigger.reason ?? "unknown"}) usage=${usage.percentage.toFixed(1)}% — spawning subagent`);
     spawnPiHistorianRun({
+      startGuard: args.startGuard,
       pi: args.pi,
       ctx,
       sessionId,
@@ -44034,6 +45184,7 @@ async function runCompactionOffPipeline(args) {
   };
 }
 async function runPipeline(args) {
+  args.assertCurrentPass?.();
   if (args.compactionOff)
     return runCompactionOffPipeline(args);
   const activeThinkingTurn = hasActiveAnthropicThinkingTurn(args.messages, args.resolvedProviderID, args.resolvedModelID);
@@ -44273,12 +45424,22 @@ async function runPipeline(args) {
   let protectionFloorResolution = resolveProtectionFloor();
   const shouldRunHeuristics = args.heuristics !== undefined && isCacheBustingPass && (rideSignals.publishedHistory || args.forceMaterialization === true || hasPendingMaterializeSignal || deferredMaterializeEligible || foldBustsServedPrefixThisPass || firstRenderBust || rideSignals.subagentExecute || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const tFallbackIdentity = performance.now();
+  const preflightRevision = readPiAdoptionRevision(args.db);
   const hasFallbackMessageTags = hasPiFallbackMessageTags2(args.db, args.sessionId);
-  const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver, args.reusableMessageIds, hasFallbackMessageTags);
+  const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver, args.reusableMessageIds, hasFallbackMessageTags, hasFallbackMessageTags ? readPiFallbackFingerprintHeaders(args.db, args.sessionId) : undefined);
+  args.assertCurrentPass?.();
   adoptPiFallbackTags(args.db, args.sessionId, args.tagger, entryFingerprintByMessageId, {
     messages: args.messages,
     resolveStableId: stableIdResolver,
-    hasFallbackMessageTags
+    hasFallbackMessageTags,
+    preflightRevision,
+    rebuildFingerprints: args.reusableMessageIds?.size ? () => {
+      args.assertCurrentPass?.();
+      const full = buildEntryFingerprintMap(args.messages, stableIdResolver, args.reusableMessageIds, true, readPiFallbackFingerprintHeaders(args.db, args.sessionId));
+      for (const [id, fingerprint] of full)
+        entryFingerprintByMessageId.set(id, fingerprint);
+      return entryFingerprintByMessageId;
+    } : undefined
   });
   logTransformTiming(args.sessionId, "fallbackIdentityAndAdoption", tFallbackIdentity);
   afterFallbackAdoptionForTests?.(args.stableIdSchemeCutover === true);
@@ -44294,22 +45455,25 @@ async function runPipeline(args) {
     tagToolTokenCache = new Map;
     piTagToolTokenCacheBySession.set(args.sessionId, tagToolTokenCache);
   }
-  const { targets } = runPersistedReplayStage("tagging-persistence-failure", () => args.tagger.cleanup(args.sessionId), () => tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
-    skipPrefixInjection: !ctxReduceCallable,
-    entryFingerprintByMessageId,
-    reuseMessageIds: textIdentityPlan.reusableMessageIds,
-    textIdentityDriftMessageIds: textIdentityPlan.driftedMessageIds,
-    textIdentitySourceCache: textIdentityPlan.sourceCache,
-    textTokenCache: tagTextTokenCache,
-    toolTokenCache: tagToolTokenCache,
-    onTiming: hasPiTransformTimingObserver() ? (phase, elapsedMs) => {
-      recordPiTransformTiming({
-        sessionId: args.sessionId,
-        stage: `tag:${phase}`,
-        elapsedMs
-      });
-    } : undefined
-  }));
+  const { targets } = runPersistedReplayStage("tagging-persistence-failure", () => args.tagger.cleanup(args.sessionId), () => {
+    args.assertCurrentPass?.();
+    return tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
+      skipPrefixInjection: !ctxReduceCallable,
+      entryFingerprintByMessageId,
+      reuseMessageIds: textIdentityPlan.reusableMessageIds,
+      textIdentityDriftMessageIds: textIdentityPlan.driftedMessageIds,
+      textIdentitySourceCache: textIdentityPlan.sourceCache,
+      textTokenCache: tagTextTokenCache,
+      toolTokenCache: tagToolTokenCache,
+      onTiming: hasPiTransformTimingObserver() ? (phase, elapsedMs) => {
+        recordPiTransformTiming({
+          sessionId: args.sessionId,
+          stage: `tag:${phase}`,
+          elapsedMs
+        });
+      } : undefined
+    });
+  });
   logTransformTiming(args.sessionId, "tagMessages", tTag);
   if (foldBustsServedPrefixThisPass) {
     try {
@@ -44815,6 +45979,7 @@ async function runPipeline(args) {
   let preserveDeferredMaterializationForMarkerDrain = false;
   if (deferredHistoryDrainEligible) {
     try {
+      args.assertCurrentPass?.();
       const pending = getPendingPiCompactionMarkerState(args.db, args.sessionId);
       if (!pending) {
         if (injectionResult?.contentionExhausted === true) {
@@ -44835,6 +46000,7 @@ async function runPipeline(args) {
         preserveDeferredMaterializationForMarkerDrain = true;
         sessionLog(args.sessionId, "Pi compaction-marker drain skipped: sessionManager appendCompaction/getBranch or folding system state unavailable; preserving deferred signals");
       } else {
+        args.assertCurrentPass?.();
         const outcome = applyDeferredPiCompactionMarker({
           db: args.db,
           appendCompaction: args.appendCompaction,
@@ -44877,6 +46043,7 @@ async function runPipeline(args) {
         }
       }
     } catch (err) {
+      args.assertCurrentPass?.();
       sessionLog(args.sessionId, `Pi compaction-marker drain failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
@@ -44959,8 +46126,21 @@ async function runPipeline(args) {
   if (bustedThisPass || isCacheBustingPass) {
     droppedTokens = estimateDroppedTokensFromTagReductions(args.db, args.sessionId, droppedTokenReductions);
   }
+  const visibleCallIds = new Set;
+  for (const message of outputMessages) {
+    if (message.role === "toolResult")
+      visibleCallIds.add(message.toolCallId);
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type === "toolCall")
+          visibleCallIds.add(part.id);
+      }
+    }
+  }
+  const servedTagNumbers = new Set(allTagsForPass.filter((tag) => targets.has(tag.tagNumber) && (tag.type === "message" ? ctxReduceCallable || tag.status !== "active" : tag.type === "tool" && visibleCallIds.has(tag.messageId) && (ctxReduceCallable || tag.status !== "active"))).map((tag) => tag.tagNumber));
   return {
     messages: outputMessages,
+    servedTagNumbers,
     heuristicsExecuted,
     executedWorkThisPass,
     historyInjected: injectionResult?.injected ?? false,
@@ -45170,6 +46350,8 @@ function clearContextHandlerSession(sessionId) {
   deferredHistoryRefreshSessions.delete(sessionId);
   deferredMaterializationSessions.delete(sessionId);
   firstContextPassSeenBySession.delete(sessionId);
+  contextPassGeneration.delete(sessionId);
+  clearPiContextReceipt(sessionId);
   liveModelBySession.delete(sessionId);
   latestAssistantModelTimestampBySession.delete(sessionId);
   taggedStableMessageIdsBySession.delete(sessionId);
@@ -45183,6 +46365,7 @@ function clearContextHandlerSession(sessionId) {
   piTagToolTokenCacheBySession.delete(sessionId);
   piTextIdentitySourceCacheBySession.delete(sessionId);
   piBranchProjectionBySession.delete(sessionId);
+  piAlignmentMismatchLoggedSessions.delete(sessionId);
   clearPiInjectionTokenCountCache(sessionId);
   clearPiTailHygieneContentMemo();
   clearPiChannel1State(sessionId);
@@ -45190,6 +46373,7 @@ function clearContextHandlerSession(sessionId) {
   routinePressureAppliedBySession.delete(sessionId);
   lastSeenProjectIdentityBySession.delete(sessionId);
   persistedProjectIdentityBySession.delete(sessionId);
+  sessionProjectBindingFailureLogAtBySession.delete(sessionId);
   for (const [projectIdentity, sessions] of sessionsByProject) {
     sessions.delete(sessionId);
     if (sessions.size === 0)
@@ -48692,7 +49876,7 @@ function buildStatusViewFor(check, options) {
 // package.json
 var package_default = {
   name: "@retaw106/mmc-pi",
-  version: "2.0.0",
+  version: "2.1.1",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -50525,17 +51709,17 @@ async function bootPiRuntimeWithDeadline(args) {
 }
 
 // src/pi-session-api.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13, realpathSync as realpathSync3, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14, realpathSync as realpathSync3, statSync as statSync7 } from "node:fs";
 import {
   basename as basename2,
   dirname as dirname7,
   extname,
   join as join12,
   relative,
-  resolve as resolve6,
+  resolve as resolve7,
   sep
 } from "node:path";
-import { pathToFileURL } from "node:url";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 var PI_CODING_AGENT_MODULE = "@earendil-works/pi-coding-agent";
 var CODING_AGENT_MODULES = [PI_CODING_AGENT_MODULE];
 var CODING_AGENT_MODULE_LABEL = CODING_AGENT_MODULES.join(" or ");
@@ -50550,7 +51734,7 @@ function isScriptEntry(filePath) {
 }
 function readManifest(pkgJsonPath) {
   try {
-    const pkg = JSON.parse(readFileSync13(pkgJsonPath, "utf8"));
+    const pkg = JSON.parse(readFileSync14(pkgJsonPath, "utf8"));
     return pkg && typeof pkg === "object" ? pkg : null;
   } catch {
     return null;
@@ -50565,7 +51749,7 @@ function isCompiledBunBinary() {
 }
 function resolveRunningEntry() {
   const argv1 = process.argv[1];
-  if (argv1 && existsSync13(argv1) && statSync6(argv1).isFile()) {
+  if (argv1 && existsSync13(argv1) && statSync7(argv1).isFile()) {
     const real = realpathSync3(argv1);
     if (isScriptEntry(real)) {
       return real;
@@ -50626,8 +51810,8 @@ function resolveManifestEntry(found) {
   if (!entryRel.startsWith("./")) {
     throw new Error(`Invalid entry "${entryRel}" in ${found.dir}/package.json: targets must start with "./"`);
   }
-  const root = resolve6(found.dir);
-  const resolved = resolve6(root, entryRel);
+  const root = resolve7(found.dir);
+  const resolved = resolve7(root, entryRel);
   if (resolved !== root && !resolved.startsWith(root + sep)) {
     throw new Error(`Invalid entry "${entryRel}" in ${found.dir}/package.json: target escapes the package root`);
   }
@@ -50660,14 +51844,14 @@ var defaultLoaders = [
       if (TS_ENTRY_PATTERN.test(entry)) {
         const srcEntry = toSourceEntry(entryPath, found.dir);
         if (!srcEntry && TS_ENTRY_PATTERN.test(entryPath) && existsSync13(entryPath)) {
-          return await import(pathToFileURL(entryPath).href);
+          return await import(pathToFileURL3(entryPath).href);
         }
         if (srcEntry && existsSync13(srcEntry)) {
-          return await import(pathToFileURL(srcEntry).href);
+          return await import(pathToFileURL3(srcEntry).href);
         }
         throw new Error(`Pi is running from TypeScript source (${entry}) but no source counterpart of ${entryPath} exists; refusing to load possibly stale build output`);
       }
-      return await import(pathToFileURL(entryPath).href);
+      return await import(pathToFileURL3(entryPath).href);
     }
   },
   {
@@ -50710,7 +51894,7 @@ async function loadDefaultPiSessionApi(loaders) {
     throw new Error("Pi session APIs unavailable: expected SessionManager.listAll on pi-coding-agent");
   }
   const loadEntriesFromFile = mod.loadEntriesFromFile ?? ((filePath) => {
-    const content = readFileSync13(filePath, "utf8");
+    const content = readFileSync14(filePath, "utf8");
     return mod.parseSessionEntries?.(content) ?? [];
   });
   return {
@@ -50747,10 +51931,10 @@ import * as childProcess from "node:child_process";
 import {
   existsSync as existsSync14,
   mkdtempSync,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   realpathSync as realpathSync4,
   rmSync as rmSync2,
-  statSync as statSync7,
+  statSync as statSync8,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { createRequire } from "node:module";
@@ -50758,7 +51942,7 @@ import { homedir as homedir5, tmpdir } from "node:os";
 import {
   basename as basename3,
   dirname as dirname8,
-  isAbsolute as isAbsolute3,
+  isAbsolute as isAbsolute4,
   join as join13,
   resolve as resolvePath,
   sep as sep2
@@ -50772,9 +51956,9 @@ var BUN_VIRTUAL_SCRIPT_PREFIX = "/$bunfs/root/";
 var WINDOWS_PI_EXTENSIONS = [".EXE", ".COM", ".CMD", ".BAT", ".PS1"];
 var DEFAULT_PI_RESOLUTION_FS = {
   existsSync: existsSync14,
-  statSync: statSync7,
+  statSync: statSync8,
   realpathSync: realpathSync4,
-  readFileSync: readFileSync14
+  readFileSync: readFileSync15
 };
 function packageHarnessKind(packageName) {
   return typeof packageName === "string" && PI_CODING_AGENT_PACKAGE_NAMES.has(packageName) ? "pi" : undefined;
@@ -50827,7 +52011,7 @@ function resolvePiBin(found, fs, checkedPaths) {
   const packageRoot = resolvePath(found.dir);
   const candidate = resolvePath(packageRoot, binEntry);
   checkedPaths.push(candidate);
-  if (isAbsolute3(binEntry) || !pathIsInside(packageRoot, candidate)) {
+  if (isAbsolute4(binEntry) || !pathIsInside(packageRoot, candidate)) {
     return null;
   }
   try {
@@ -51046,7 +52230,7 @@ function configurePiSubagentExtensions(extensions) {
 function resolveSubagentExtensionEntry(entry, targetHarness) {
   const trimmed = entry.trim();
   const isNpmSource = trimmed.startsWith("npm:");
-  return !isNpmSource && !isAbsolute3(trimmed) ? resolvePath(getHostAgentSettingsDir(targetHarness), trimmed) : trimmed;
+  return !isNpmSource && !isAbsolute4(trimmed) ? resolvePath(getHostAgentSettingsDir(targetHarness), trimmed) : trimmed;
 }
 var HISTORIAN_AGENTS = new Set([
   "magic-context-historian",
@@ -51857,6 +53041,19 @@ function terminateChild(child) {
   }
 }
 
+// src/timeout.ts
+function withTimeout(p, ms) {
+  let handle;
+  const timeout = new Promise((resolve) => {
+    handle = setTimeout(() => resolve(undefined), ms);
+    handle.unref?.();
+  });
+  return Promise.race([p, timeout]).finally(() => {
+    if (handle)
+      clearTimeout(handle);
+  });
+}
+
 // ../plugin/src/tools/parameter-descriptions.ts
 var FULL_PARAMETER_DESCRIPTIONS = {
   mmc_reduce: {
@@ -51958,7 +53155,7 @@ Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversiz
 
 Finer recovery:
 - verbose=true lists each message separately with its ordinal and a per-part preview (tool calls with output sizes) so you can pick one.
-- message=N returns that one message in full — every text part and every tool call's complete input and output — from stored history. This is the way back to a tool output you released with mmc_reduce; if the message was deleted from history it says so.`;
+- message=N returns that one message in full — every text part and every tool call's complete input and output — from stored history. This is the way back to a tool output you released with mmc_reduce; if the message is no longer in stored history it says so.`;
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
 // ../plugin/src/features/magic-context/tag-input.ts
@@ -52031,7 +53228,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // ../plugin/src/tools/ctx-expand/render.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function isRecord7(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -52120,7 +53317,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);
@@ -52184,7 +53381,7 @@ function renderMessageByOrdinal(sessionId, ordinal) {
   });
   const msg = found[0];
   if (!msg) {
-    return `No message at ordinal ${ordinal} in this session's stored history — it was deleted ` + `(session prune/revert) or the ordinal is wrong, so it can't be recovered. ` + `Re-run the tool if you still need the data.`;
+    return `No message at ordinal ${ordinal} is currently in this session's stored history — ` + `it may have been removed by a session prune/revert, or the ordinal may be wrong. ` + `Re-run the tool if you still need the data.`;
   }
   const rendered = msg.parts.map(renderPartFull).filter((l) => l !== null);
   const lines = [`[${msg.ordinal}] ${roleLabel(msg.role)} — full recovery:`, ""];
@@ -52255,9 +53452,12 @@ 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" && createHash18("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord7(part) && typeof part.text === "string" && createHash19("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.`;
+  if (!selected)
+    return `Tag ${number}'s original text part is no longer in stored history.`;
+  const renderedPart = renderPartFull(selected);
+  return renderedPart !== null ? renderedPart : `Tag ${number}'s stored text part has no renderable content (empty or structural-only); the requested content was not recovered.`;
 }
 
 // ../plugin/src/tools/unwrap-imitated-reduced-args.ts
@@ -52741,6 +53941,9 @@ function createCtxExpandTool(deps) {
         }
         return ok(lines.join(`
 `));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return err(`Error: mmc_expand failed to read this session's stored history: ${message}`);
       } finally {
         unregister();
       }
@@ -54573,7 +55776,7 @@ function logNoProjectIdentityOnce(directory) {
 }
 var loggedPiConfigDirs = new Set;
 function logPiConfigLoad(args) {
-  const key = resolve7(args.dir);
+  const key = resolve8(args.dir);
   if (args.dedupe && loggedPiConfigDirs.has(key))
     return;
   if (args.dedupe) {
@@ -55435,8 +56638,13 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         existingSystemPrompt: event.systemPrompt
       });
       const composedPrompt = composeMagicContextSystemPrompt(event.systemPrompt, block);
+      const promptOptions = event.systemPromptOptions;
+      const hostSections = promptOptions?.sections;
+      if (block && hostSections) {
+        hostSections.magic_context = block;
+      }
       if (!sessionId) {
-        if (block)
+        if (block && !hostSections)
           return { systemPrompt: composedPrompt };
         return;
       }
@@ -55455,6 +56663,9 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
       if (isCacheBusting) {
         clearSystemPromptRefresh(sessionId);
       }
+      if (hostSections) {
+        return;
+      }
       return { systemPrompt: result.systemPrompt };
     } catch (error) {
       warn("failed to build magic-context block:", error);