@cortexkit/pi-magic-context 0.49.34 → 0.49.36

package/dist/index.js

@@ -9,15 +9,17 @@ import {
   getMagicContextStorageDir,
   isMagicContextStorageOutsideEngram,
   claimStorageBackupWarningCheck,
-  sanitizeDiagnosticText,
-  hasShareabilitySensitiveText,
   registerStalePluginBuildHost,
   classifyStalePluginBuild,
   importPluginModule,
   log2,
   sessionLog2,
   flushLogger2
-} from "./index-fgs78jyd.js";
+} from "./index-gymgz20n.js";
+import {
+  sanitizeDiagnosticText,
+  hasShareabilitySensitiveText
+} from "./index-dnp1jjar.js";
 import {
   COMPACTION_ENABLED_PATH,
   isDreamerRunnable,
@@ -47,121 +49,6 @@ import {
   cortexKitProjectConfigBasePath,
   migrateMagicContextConfigLocations,
   getProtectedTokensTierOverrides,
-  LkgRecoveryFenceError,
-  clearLkgFenceProcessState,
-  lkgFenceRequiresRebuild,
-  lkgRecoveryFenceUnclean,
-  ownsLkgDirtyFence,
-  invalidateCleanLkgRecoveryFence,
-  markLkgRecoveryDirty,
-  rememberUnpublishedAutoSearchNoHint,
-  getUnpublishedAutoSearchNoHint,
-  forgetUnpublishedAutoSearchNoHint,
-  registerAutoSearchWork,
-  cancelAutoSearchWork,
-  readSessionActivity,
-  observeSessionActivity,
-  backfillSessionActivity,
-  readSessionMeta,
-  getOrCreateSessionMeta,
-  updateSessionMeta,
-  advanceToolReclaimWatermark,
-  retryPendingSessionCleanups,
-  retryPendingRustSessionCleanupsForProject,
-  COMPARTMENT_LEASE_RENEWAL_MS,
-  acquireCompartmentLease,
-  renewCompartmentLease,
-  releaseCompartmentLease,
-  releaseCompartmentLeaseBestEffort,
-  isCompartmentLeaseHeld,
-  isNoContentCompartment,
-  HAS_COMPARTMENT_CONTENT_SQL,
-  queueM0Mutation,
-  getMaxM0MutationId,
-  getCompartments,
-  getLastCompartmentEndMessage,
-  getLastCompartmentEndMessageId,
-  getCompartmentsByEndMessageId,
-  appendCompartments,
-  saveRecompStagingPass,
-  getRecompStaging,
-  clearRecompStaging,
-  getRecompPartialRange,
-  setRecompPartialRange,
-  escapeXmlAttr,
-  escapeXmlContent,
-  getUncoveredCompartmentEndThrough,
-  isPartialCompartmentEnd,
-  readProjectDocsCanonical,
-  providerResponseFailed,
-  isSuccessfulProviderCompletion,
-  requestPendingMaterialization,
-  pendingMaterializationOrigin,
-  hasPendingMaterializationOrigin,
-  clearPendingMaterialization,
-  recordSystemRefreshOwnership,
-  recordSystemPromptForRequest,
-  recordHeldHeadForRequest,
-  bindSystemPromptResponse,
-  acknowledgeSystemPromptDelivery,
-  deferDeliveredSystemRefresh,
-  clearSystemPromptDelivery,
-  saveLkgSlotToDb,
-  loadPersistedLkgSlot,
-  drainStaleLkgSlots,
-  createDbLkgPersistence,
-  replayLkg,
-  registerLkgPersistence,
-  LKG_SNAPSHOT_ARRAY,
-  LKG_SNAPSHOT_OBJECT,
-  LKG_SNAPSHOT_KEY,
-  LKG_SNAPSHOT_STRING,
-  LKG_SNAPSHOT_NUMBER,
-  LKG_SNAPSHOT_BOOLEAN,
-  LKG_SNAPSHOT_NULL,
-  LKG_SNAPSHOT_UNDEFINED,
-  contentSnapshotValue,
-  signatureForFields,
-  lkgContentFields,
-  lkgContentDigestFromFields,
-  isLegacyLkgDigest,
-  legacyLkgDigestFromFields,
-  lkgFieldsMatchDigest,
-  exactReusablePrefix,
-  incrementalLkgContentDigests,
-  lkgSlotRejection,
-  captureSlot,
-  getInMemorySlot,
-  getSlot,
-  dropSlot,
-  TOOL_SWEEP_SCOPED_MARKER,
-  encodePiContentDecision,
-  decodePiContentDecision,
-  getPiContentDecisions,
-  freezePiContentDecision,
-  withNativeReplayWriteBarrier,
-  getNativeReplayState,
-  saveNativeToolInputs,
-  addNativeReasoningIds,
-  copySessionStateForClone,
-  externalHistorianFailureReason,
-  subprocessExitHistorianFailureReason,
-  countHistorianRuns,
-  recordHistorianRun,
-  summarizeImportance,
-  tallyFactsByCategory,
-  queueMemoryMutation,
-  getMemoryMutationsForRender,
-  getMemoryMutationsForRenderByProjects,
-  getMaxMemoryMutationId,
-  getMaxMemoryMutationIdForProjects,
-  GLOBAL_USER_PROFILE_PROJECT_PATH,
-  getProjectState,
-  bumpProjectUserProfileVersion,
-  saveSourceContent,
-  getSourceContents,
-  recordSubagentInvocation,
-  getLatestHistorianInvocationId,
   noteTouchedAt,
   noteNudgePickIndex,
   formatNoteNudge,
@@ -263,7 +150,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-f4fz95fy.js";
+} from "./index-dgqjq8sg.js";
 import"./index-4knyh1kt.js";
 import {
   canonicalModelIdentity,
@@ -288,26 +175,9 @@ import {
   createFailClosedBlockingError,
   isFailClosedBlockingError,
   shouldBypassFailClosedBlock,
-  createFailClosedController,
-  piHarnessKindFromExecutable,
-  getErrorMessage,
-  describeError,
-  startBootDeadline,
-  getSchemaFenceRejection,
-  getMigrationOnOpenRefusal,
-  LATEST_SUPPORTED_VERSION,
-  getDatabasePath,
-  getPersistedSchemaVersion,
-  setSqlitePragmaConfig,
-  applySqliteTuningPragmas,
-  runSqliteOptimize,
-  openDatabase,
-  openCurrentDatabase,
-  openDatabaseAsync,
-  closeDatabase
-} from "./index-np9ryr8y.js";
+  createFailClosedController
+} from "./index-3bb24eb6.js";
 import {
-  sameProjectDirectory,
   pruneMissingProjectIdentities,
   setHomeProjectPermission,
   ProjectIdentityError,
@@ -318,7 +188,7 @@ import {
   resolveProjectIdentityForSession,
   beginBootQuietPeriod,
   scheduleAfterBootQuiet
-} from "./index-48twbev2.js";
+} from "./index-6pk49fc3.js";
 import {
   detectThinkingBindingMismatch,
   detectLatestTurnThinkingMismatch,
@@ -424,7 +294,7 @@ import {
   getSessionWorkMetrics,
   resolveEpochFloorForPass,
   askAnswerLines,
-  retreatPastHostUnservedRows,
+  removeUnsupportedCommitHashes,
   completedToolArcCrossesBoundary,
   estimateTrueRawMessageTokens,
   buildToolArcs,
@@ -483,7 +353,7 @@ import {
   getRawSessionTagKeysThrough2,
   getLegacyProtectedTailStartOrdinal2,
   readSessionChunk2
-} from "./index-eenxm3t3.js";
+} from "./index-mx757f3g.js";
 import {
   UNKNOWN_FIT_RATIO,
   hasMeasuredDecisionCalibration,
@@ -570,7 +440,7 @@ import {
   getToolTagNumberByOwner2,
   getNullOwnerToolTag2,
   adoptNullOwnerToolTag2
-} from "./index-eqw9t2ty.js";
+} from "./index-pwp6zyx3.js";
 import {
   textMentionsRecentCommit,
   hasMeaningfulUserText2,
@@ -582,7 +452,7 @@ import {
   estimateTokens,
   estimateFixedPromptTokens,
   normalizeText
-} from "./index-my0dn413.js";
+} from "./index-wt7vmyj4.js";
 import {
   inRootAsyncContext2,
   Database2,
@@ -602,27 +472,165 @@ import {
   observeTemporalDecisions,
   freezeTemporalDecisions,
   tagIdentityRevisionKey
-} from "./index-c474g0gj.js";
+} from "./index-yacs388s.js";
+import {
+  piHarnessKindFromExecutable,
+  getErrorMessage,
+  describeError,
+  startBootDeadline,
+  getSchemaFenceRejection,
+  getMigrationOnOpenRefusal,
+  LATEST_SUPPORTED_VERSION,
+  getDatabasePath,
+  getPersistedSchemaVersion,
+  setSqlitePragmaConfig,
+  applySqliteTuningPragmas,
+  runSqliteOptimize,
+  openDatabase,
+  openCurrentDatabase,
+  openDatabaseAsync,
+  closeDatabase
+} from "./index-a7sj2bam.js";
+import {
+  LkgRecoveryFenceError,
+  clearLkgFenceProcessState,
+  lkgFenceRequiresRebuild,
+  lkgRecoveryFenceUnclean,
+  ownsLkgDirtyFence,
+  invalidateCleanLkgRecoveryFence,
+  markLkgRecoveryDirty,
+  rememberUnpublishedAutoSearchNoHint,
+  getUnpublishedAutoSearchNoHint,
+  forgetUnpublishedAutoSearchNoHint,
+  registerAutoSearchWork,
+  cancelAutoSearchWork,
+  readSessionActivity,
+  observeSessionActivity,
+  backfillSessionActivity,
+  readSessionMeta,
+  getOrCreateSessionMeta,
+  updateSessionMeta,
+  advanceToolReclaimWatermark,
+  retryPendingSessionCleanups,
+  retryPendingRustSessionCleanupsForProject,
+  COMPARTMENT_LEASE_RENEWAL_MS,
+  acquireCompartmentLease,
+  renewCompartmentLease,
+  releaseCompartmentLease,
+  releaseCompartmentLeaseBestEffort,
+  isCompartmentLeaseHeld,
+  isNoContentCompartment,
+  HAS_COMPARTMENT_CONTENT_SQL,
+  queueM0Mutation,
+  getMaxM0MutationId,
+  getCompartments,
+  getLastCompartmentEndMessage,
+  getLastCompartmentEndMessageId,
+  getCompartmentsByEndMessageId,
+  appendCompartments,
+  saveRecompStagingPass,
+  getRecompStaging,
+  clearRecompStaging,
+  getRecompPartialRange,
+  setRecompPartialRange,
+  escapeXmlAttr,
+  escapeXmlContent,
+  getUncoveredCompartmentEndThrough,
+  isPartialCompartmentEnd,
+  readProjectDocsCanonical,
+  providerResponseFailed,
+  isSuccessfulProviderCompletion,
+  requestPendingMaterialization,
+  pendingMaterializationOrigin,
+  hasPendingMaterializationOrigin,
+  clearPendingMaterialization,
+  recordSystemRefreshOwnership,
+  recordSystemPromptForRequest,
+  recordHeldHeadForRequest,
+  bindSystemPromptResponse,
+  acknowledgeSystemPromptDelivery,
+  deferDeliveredSystemRefresh,
+  clearSystemPromptDelivery,
+  saveLkgSlotToDb,
+  loadPersistedLkgSlot,
+  drainStaleLkgSlots,
+  createDbLkgPersistence,
+  replayLkg,
+  registerLkgPersistence,
+  LKG_SNAPSHOT_ARRAY,
+  LKG_SNAPSHOT_OBJECT,
+  LKG_SNAPSHOT_KEY,
+  LKG_SNAPSHOT_STRING,
+  LKG_SNAPSHOT_NUMBER,
+  LKG_SNAPSHOT_BOOLEAN,
+  LKG_SNAPSHOT_NULL,
+  LKG_SNAPSHOT_UNDEFINED,
+  contentSnapshotValue,
+  signatureForFields,
+  lkgContentFields,
+  lkgContentDigestFromFields,
+  isLegacyLkgDigest,
+  legacyLkgDigestFromFields,
+  lkgFieldsMatchDigest,
+  exactReusablePrefix,
+  incrementalLkgContentDigests,
+  lkgSlotRejection,
+  captureSlot,
+  getInMemorySlot,
+  getSlot,
+  dropSlot,
+  TOOL_SWEEP_SCOPED_MARKER,
+  encodePiContentDecision,
+  decodePiContentDecision,
+  getPiContentDecisions,
+  freezePiContentDecision,
+  withNativeReplayWriteBarrier,
+  getNativeReplayState,
+  saveNativeToolInputs,
+  addNativeReasoningIds,
+  copySessionStateForClone,
+  externalHistorianFailureReason,
+  subprocessExitHistorianFailureReason,
+  countHistorianRuns,
+  recordHistorianRun,
+  summarizeImportance,
+  tallyFactsByCategory,
+  queueMemoryMutation,
+  getMemoryMutationsForRender,
+  getMemoryMutationsForRenderByProjects,
+  getMaxMemoryMutationId,
+  getMaxMemoryMutationIdForProjects,
+  GLOBAL_USER_PROFILE_PROJECT_PATH,
+  getProjectState,
+  bumpProjectUserProfileVersion,
+  saveSourceContent,
+  getSourceContents,
+  recordSubagentInvocation,
+  getLatestHistorianInvocationId
+} from "./index-p9jfa33t.js";
 import {
-  BoundedSessionMap,
   resolveOpenCodeDbPath,
   assertOpenCodeStoreGeneration,
   openCodeDbPathExists,
   recordOpenCodeDbReadFailure,
   clearOpenCodeDbReadFailure,
   claimOpenCodeDbDiagnosticOnce
-} from "./index-23t8ryqw.js";
-import"./index-399p688g.js";
+} from "./index-n0zjvs3h.js";
+import"./index-8sqebjzk.js";
+import {
+  reuseWorker
+} from "./index-wfqysrwq.js";
 import {
   createWorkerShutdown
-} from "./index-54wmg4rj.js";
+} from "./index-x2n261wp.js";
 import {
   RAW_SUMMARY_TEXT_MAX_CHARS2
-} from "./index-6981g1xv.js";
+} from "./index-c1dqxr10.js";
+import"./index-ea37qn4x.js";
 import {
   formatSynapseLaneDescriptor
-} from "./index-gwxaz0z5.js";
-import"./index-bvpar0bg.js";
+} from "./index-rzfr7wdv.js";
+import"./index-ck8wj35v.js";
 import {
   buildCanonicalChunkTextFromFts2,
   buildCompartmentSummaryFallbackText2,
@@ -632,7 +640,7 @@ import {
   replaceCompartmentChunkEmbeddings2,
   deleteChunkEmbedBackoffForSession2,
   chunkWindowSourceKey2
-} from "./index-0gymvr5j.js";
+} from "./index-f9qet7y8.js";
 import {
   recordSessionProjectIdentity,
   GIT_SWEEP_LEASE_RENEWAL_MS,
@@ -641,7 +649,7 @@ import {
   markGitSweepSuccessAndRelease,
   parkGitSweepNonIndexable,
   releaseGitSweepLease
-} from "./index-4zemngt7.js";
+} from "./index-mp0gh04g.js";
 import {
   embedPauseBySession,
   embedRunStateBySession,
@@ -650,33 +658,20 @@ import {
   autoEmbedIdentityBySession,
   autoEmbedRetryAfterBySession,
   invalidateAutoEmbedSession,
-  getEmbedDrainUiStatus,
-  describeShadowBackfillWriteRefusal2,
-  contentSha2562,
-  drainProjectEmbeddingIdentityMaintenance2,
-  drainStaleEmbeddingIdentitiesForProject2,
-  enqueueShadowEmbeddingItems2,
-  getProjectEmbeddingSnapshot2,
-  getProjectChunkEmbeddingModelId2,
-  getProjectEmbeddingMaxInputTokens2,
-  embedTextForProject2,
-  embedBatchForProject2,
-  embedItemsForProject2,
-  embedUnembeddedMemoriesForProject2,
-  drainCommitBacklogForProject2,
-  embedSessionCompartmentChunks2,
-  getEmbeddingCoverageStatus2,
-  getAutoEmbeddingSessionCoverage2
-} from "./index-xn5yh0pn.js";
+  getEmbedDrainUiStatus
+} from "./index-hgd00nas.js";
 import {
   clearCompressionDepth,
   clearCompressionDepthRange,
   cleanSearchText,
   matchedSearchSnippet
-} from "./index-e61zxfts.js";
+} from "./index-kj49vs41.js";
 import {
   rememberV1HiddenRun
 } from "./index-6x556c2q.js";
+import {
+  BoundedSessionMap
+} from "./index-c6wbq66z.js";
 import {
   V2_MEMORY_CATEGORIES
 } from "./index-135e8hvg.js";
@@ -688,7 +683,7 @@ import {
   expandWorkspaceIdentitySetWithAliases,
   sourceNameForMemory,
   computeWorkspaceEpochFingerprint
-} from "./index-pb3ea2tq.js";
+} from "./index-d107f484.js";
 import {
   configureContextDatabasePragmas2
 } from "./index-fapenpch.js";
@@ -712,39 +707,8 @@ import {
   getActivePrimers,
   createPrimer,
   updatePrimerSupport,
-  updatePrimerAnswer,
-  USER_FACING_FAILURES,
-  renderUserFacingFailure,
-  userFacingFailureCode,
-  renderCapabilityRefusal,
-  renderDreamFailure,
-  dreamFailureCode,
-  renderEmbeddingFailure,
-  renderSingleStoreMigrationRequiredRefusal,
-  SingleStoreMigrationRequiredError,
-  projectNeedsSingleStoreMigration,
-  promoteSessionFactsDurable,
-  embedPromotedFacts,
-  recordMemoryMapping,
-  recordMemoryVerifications,
-  getUnmappedMemoryIds,
-  clearMemoryVerifications,
-  getMemoryVerifications,
-  resolveGitTopLevel,
-  readGitHead,
-  readGitChangedFilesSince,
-  readGitFileChangeTimesSince,
-  verificationFileExists,
-  normalizeVerificationFiles,
-  indexCommitsForProject,
-  embedUnembeddedCommits,
-  getMessageIndexEpoch,
-  isMessageIndexSearchable,
-  scheduleReconciliation,
-  scheduleIncrementalIndex,
-  scheduleClearAndReindex,
-  clearSessionTracking
-} from "./index-g2tfayfc.js";
+  updatePrimerAnswer
+} from "./index-w26zvs1q.js";
 import {
   setEmbeddingSessionBusy2,
   isEmbeddingHostBusy2
@@ -765,6 +729,7 @@ import {
   getMemoriesByProjects2,
   getMaxMemoryIdForProjects2,
   getMemoryById2,
+  updateMemoryVerification2,
   setMemoryClassification2,
   archiveMemory2,
   getMemoryCountsByStatus2
@@ -777,11 +742,63 @@ import {
 } from "./index-q1yc6bs0.js";
 import {
   getCachedLocalEmbeddingPooling
-} from "./index-wqpjhx1p.js";
+} from "./index-2qqsnh1b.js";
+import {
+  describeShadowBackfillWriteRefusal2,
+  contentSha2562,
+  drainProjectEmbeddingIdentityMaintenance2,
+  drainStaleEmbeddingIdentitiesForProject2,
+  enqueueShadowEmbeddingItems2,
+  getProjectEmbeddingSnapshot2,
+  getProjectChunkEmbeddingModelId2,
+  getProjectEmbeddingMaxInputTokens2,
+  embedTextForProject2,
+  embedBatchForProject2,
+  embedItemsForProject2,
+  embedUnembeddedMemoriesForProject2,
+  drainCommitBacklogForProject2,
+  embedSessionCompartmentChunks2,
+  getEmbeddingCoverageStatus2,
+  getAutoEmbeddingSessionCoverage2
+} from "./index-z7dktknj.js";
 import {
   cosineSimilarity
-} from "./index-9xd7qveg.js";
-import"./index-6wdwv3a6.js";
+} from "./index-jbkwszd5.js";
+import {
+  USER_FACING_FAILURES,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  renderCapabilityRefusal,
+  renderDreamFailure,
+  dreamFailureCode,
+  renderEmbeddingFailure,
+  renderSingleStoreMigrationRequiredRefusal,
+  SingleStoreMigrationRequiredError,
+  projectNeedsSingleStoreMigration,
+  promoteSessionFactsDurable,
+  embedPromotedFacts,
+  recordMemoryMapping,
+  recordMemoryVerifications,
+  getUnmappedMemoryIds,
+  clearMemoryVerifications,
+  getMemoryVerifications,
+  resolveGitTopLevel,
+  readGitHead,
+  readGitChangedFilesSince,
+  readGitFileChangeTimesSince,
+  verificationFileExists,
+  normalizeVerificationFiles,
+  indexCommitsForProject,
+  embedUnembeddedCommits,
+  getMessageIndexEpoch,
+  isMessageIndexSearchable,
+  scheduleReconciliation,
+  scheduleIncrementalIndex,
+  scheduleClearAndReindex,
+  clearSessionTracking,
+  createAutoSearchDiagnostics
+} from "./index-f6y7mdq9.js";
+import"./index-y90fxz4t.js";
 import {
   DREAMER_PRIMER_INVESTIGATOR_ALLOWED_TOOLS,
   buildHiddenAgentRegistrations,
@@ -808,19 +825,26 @@ import {
   drainPiTagSnapshotSession,
   assertPiTagSnapshotReady,
   ensurePiTagSnapshotReady
-} from "./index-0mc0vv97.js";
-import"./index-jn44h81p.js";
+} from "./index-wwsfevck.js";
+import"./index-cq71g4dk.js";
 import"./index-1cvyaw9a.js";
-import"./index-cj3bkd16.js";
+import"./index-gxqmh9hq.js";
+import"./index-ry84c8dr.js";
 import {
   __toESM
 } from "./index-22jkk6wg.js";
+import {
+  retreatPastHostUnservedRows
+} from "./index-by1bzjcd.js";
 import {
   computeNormalizedHash
 } from "./index-9x1f96r8.js";
 import {
   normalizeProtectedToolName
 } from "./index-674f6qs2.js";
+import {
+  sameProjectDirectory
+} from "./index-wrr9rp9a.js";
 import {
   closeQuietly,
   isKnownAutocommit
@@ -828,7 +852,7 @@ import {
 import {
   logSlowWriteTransaction,
   WriteTransactionSteps
-} from "./index-hqw0rt9k.js";
+} from "./index-0wtm7g7f.js";
 import {
   setStoragePrivatePermissionEnforcement,
   ensureStorageDirectorySync,
@@ -3560,7 +3584,7 @@ function startHostStallProfilerSwitch() {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.49.34",
+  version: "0.49.36",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -3679,6 +3703,158 @@ var package_default = {
 
 // src/clone-inheritance.ts
 import { open, stat } from "node:fs/promises";
+
+// src/drop-branches-pi.ts
+var KEY = "piDropBranches";
+var installed = new WeakSet;
+function trackPiDropLeaf(db, sessionId, leaf) {
+  if (!installed.has(db)) {
+    db.exec(`
+			CREATE TEMP TABLE IF NOT EXISTS pi_drop_leaf (session_id TEXT PRIMARY KEY, leaf TEXT);
+			CREATE TEMP TRIGGER IF NOT EXISTS pi_drop_queued AFTER INSERT ON main.pending_ops
+			WHEN NEW.operation = 'drop' AND EXISTS (SELECT 1 FROM pi_drop_leaf WHERE session_id = NEW.session_id AND leaf IS NOT NULL)
+			BEGIN
+				UPDATE session_meta SET deferred_execute_state = json_set(
+					COALESCE(NULLIF(deferred_execute_state, ''), '{}'),
+					'$.${KEY}.pending."' || NEW.tag_id || '"',
+					(SELECT leaf FROM pi_drop_leaf WHERE session_id = NEW.session_id))
+				WHERE session_id = NEW.session_id;
+			END;
+			CREATE TEMP TRIGGER IF NOT EXISTS pi_drop_applied AFTER UPDATE OF status ON main.tags
+			WHEN NEW.status = 'dropped' AND OLD.status != 'dropped'
+				AND EXISTS (SELECT 1 FROM pi_drop_leaf WHERE session_id = NEW.session_id AND leaf IS NOT NULL)
+			BEGIN
+				UPDATE session_meta SET deferred_execute_state = json_remove(json_set(
+					COALESCE(NULLIF(deferred_execute_state, ''), '{}'),
+					'$.${KEY}.drops."' || NEW.tag_number || '"',
+					COALESCE(json_extract(deferred_execute_state, '$.${KEY}.pending."' || NEW.tag_number || '"'),
+						(SELECT leaf FROM pi_drop_leaf WHERE session_id = NEW.session_id))),
+					'$.${KEY}.pending."' || NEW.tag_number || '"')
+				WHERE session_id = NEW.session_id;
+			END;
+			CREATE TEMP TRIGGER IF NOT EXISTS pi_drop_retired AFTER UPDATE OF status ON main.tags
+			WHEN NEW.status = 'compacted'
+			BEGIN
+				UPDATE session_meta SET deferred_execute_state = json_remove(
+					COALESCE(NULLIF(deferred_execute_state, ''), '{}'),
+					'$.${KEY}.drops."' || NEW.tag_number || '"', '$.${KEY}.pending."' || NEW.tag_number || '"')
+				WHERE session_id = NEW.session_id AND json_type(deferred_execute_state, '$.${KEY}') = 'object';
+			END;
+		`);
+    installed.add(db);
+  }
+  ensureSessionMetaRow(db, sessionId);
+  db.prepare("INSERT INTO pi_drop_leaf VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET leaf = excluded.leaf").run(sessionId, leaf);
+}
+function state(db, sessionId) {
+  const row = db.prepare("SELECT deferred_execute_state AS state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const value = row?.state ? JSON.parse(row.state) : {};
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid session metadata JSON");
+  return value;
+}
+function journal(value) {
+  const result = { drops: {}, pending: {} };
+  if (!value || typeof value !== "object")
+    return result;
+  for (const kind of ["drops", "pending"]) {
+    const entries = value[kind];
+    if (!entries || typeof entries !== "object")
+      continue;
+    for (const [tag, leaf] of Object.entries(entries)) {
+      if (/^\d+$/.test(tag) && typeof leaf === "string" && leaf)
+        result[kind][tag] = leaf;
+    }
+  }
+  return result;
+}
+function save(db, sessionId, document, value) {
+  document[KEY] = value;
+  db.prepare("UPDATE session_meta SET deferred_execute_state = ? WHERE session_id = ?").run(JSON.stringify(document), sessionId);
+}
+function piDropBranchIds(entries) {
+  const ids = new Set;
+  let parent = null;
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object")
+      return null;
+    const row = entry;
+    if (typeof row.id !== "string" || !row.id || row.parentId !== parent || ids.has(row.id))
+      return null;
+    ids.add(row.id);
+    parent = row.id;
+  }
+  return ids;
+}
+function cancelPiAbandonedPendingDrops(db, sessionId, ids) {
+  if (!ids)
+    return 0;
+  const abandoned = (saved) => Object.entries(saved.pending).filter(([, leaf]) => !ids.has(leaf));
+  if (!abandoned(journal(state(db, sessionId)[KEY])).length)
+    return 0;
+  return db.transaction(() => {
+    const document = state(db, sessionId);
+    const saved = journal(document[KEY]);
+    const offPending = abandoned(saved);
+    if (!offPending.length)
+      return 0;
+    for (const [tag] of offPending) {
+      db.prepare("DELETE FROM pending_ops WHERE session_id = ? AND tag_id = ?").run(sessionId, Number(tag));
+      delete saved.pending[tag];
+    }
+    save(db, sessionId, document, saved);
+    return offPending.length;
+  }).immediate();
+}
+function reconcilePiDropBranches(db, sessionId, ids, canRebuild) {
+  if (!canRebuild || !ids)
+    return 0;
+  return db.transaction(() => {
+    const document = state(db, sessionId);
+    const saved = journal(document[KEY]);
+    const offBranch = Object.entries(saved.drops).filter(([, leaf]) => !ids.has(leaf));
+    if (!offBranch.length)
+      return 0;
+    const native = getNativeReplayState(db, sessionId);
+    let restored = 0;
+    for (const [tag] of offBranch) {
+      const row = db.prepare("UPDATE tags SET status = 'active', drop_mode = 'full' WHERE session_id = ? AND tag_number = ? AND status = 'dropped' RETURNING message_id, type").get(sessionId, Number(tag));
+      if (row) {
+        restored++;
+        if (row.type === "tool")
+          native.toolInputs.delete(row.message_id);
+      }
+      delete saved.drops[tag];
+    }
+    if (restored && !updateReplayDocument(db, sessionId, (doc) => {
+      if (doc.piNative === undefined)
+        return false;
+      if (!doc.piNative || typeof doc.piNative !== "object" || Array.isArray(doc.piNative))
+        throw new Error("Invalid Pi native replay state");
+      doc.piNative = {
+        ...doc.piNative,
+        toolInputs: Object.fromEntries(native.toolInputs)
+      };
+      return true;
+    }))
+      throw new Error("Cannot persist restored Pi tool inputs");
+    save(db, sessionId, document, saved);
+    return restored;
+  }).immediate();
+}
+function copyPiDropBranches(db, source, destination) {
+  const sourceJournal = journal(state(db, source)[KEY]);
+  const tags = new Set(db.prepare("SELECT tag_number FROM tags WHERE session_id = ?").all(destination).map((row) => String(row.tag_number)));
+  for (const kind of ["drops", "pending"]) {
+    for (const tag of Object.keys(sourceJournal[kind]))
+      if (!tags.has(tag))
+        delete sourceJournal[kind][tag];
+  }
+  ensureSessionMetaRow(db, destination);
+  save(db, destination, state(db, destination), sourceJournal);
+}
+
+// src/clone-inheritance.ts
 var CONTENT_ID_SUFFIX = /:(?:p|file)\d+$/;
 var BARE_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var loggedCloneStartFailures = new Set;
@@ -3863,9 +4039,14 @@ async function inheritPiCloneSession(event, ctx, deps, isStartup) {
       throw new Error("Pi clone branch is unavailable");
     }
     stage = "copy-state";
+    const filter = createCloneFilter(branchEntries);
     const result = copySessionStateForClone(deps.db, sourceSessionId, destinationSessionId, {
-      ...createCloneFilter(branchEntries),
-      requireEmptyDestinationMeta: isStartup
+      ...filter,
+      requireEmptyDestinationMeta: isStartup,
+      selectPendingPiMarker: (raw, compartments) => {
+        copyPiDropBranches(deps.db, sourceSessionId, destinationSessionId);
+        return filter.selectPendingPiMarker(raw, compartments);
+      }
     });
     if (result.kind === "destination-not-empty") {
       writeLog(`[magic-context][pi] clone-inheritance: skipped source=${sourceSessionId} dest=${destinationSessionId} stage=destination-guard reason=destination-not-empty`);
@@ -4169,12 +4350,17 @@ function countCompartmentsSince(db, projectPath, since) {
   return row?.cnt ?? 0;
 }
 function countProjectSessionsSince(db, projectPath, since) {
-  const row = since === null ? db.prepare("SELECT COUNT(*) AS cnt FROM session_projects WHERE project_path = ?").get(projectPath) : db.prepare(`SELECT COUNT(*) AS cnt FROM session_projects sp
-                        LEFT JOIN schema_migrations_meta activity
-                          ON activity.key = 'retrospective_activity:' || sp.session_id
-                        LEFT JOIN message_history_index history ON history.session_id = sp.session_id
-                       WHERE sp.project_path = ?
-                         AND COALESCE(CAST(activity.value AS INTEGER), history.updated_at) > ?`).get(projectPath, since);
+  const scope = `FROM session_projects sp
+        LEFT JOIN session_meta m ON m.session_id = sp.session_id
+       WHERE sp.project_path = ? AND sp.harness = ?
+         AND COALESCE(m.is_subagent, 0) = 0`;
+  const row = since === null ? db.prepare(`SELECT COUNT(*) AS cnt ${scope}`).get(projectPath, getHarness2()) : db.prepare(`SELECT COUNT(*) AS cnt ${scope}
+                          AND COALESCE(
+                              (SELECT CAST(value AS INTEGER) FROM schema_migrations_meta
+                               WHERE key = 'retrospective_activity:' || sp.session_id),
+                              (SELECT updated_at FROM message_history_index
+                               WHERE session_id = sp.session_id AND harness = sp.harness)
+                          ) > ?`).get(projectPath, getHarness2(), since);
   return row?.cnt ?? 0;
 }
 function countMappedMemories(db, projectPath) {
@@ -4187,6 +4373,10 @@ function countMappedMemories(db, projectPath) {
                 AND v.file_path <> ''`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
+var CURRENT_VERIFY_SKIP_SQL = `COALESCE(CASE WHEN json_valid(m.metadata_json) THEN
+    json_extract(m.metadata_json, '$.dreamerVerifySkip.contentHash') = m.normalized_hash
+    AND json_type(m.metadata_json, '$.dreamerVerifySkip.fingerprint') = 'text'
+    ELSE 0 END, 0)`;
 function countUnverifiedMappedMemories(db, projectPath) {
   const row = db.prepare(`SELECT COUNT(DISTINCT m.id) AS cnt
                FROM memories m
@@ -4195,7 +4385,8 @@ function countUnverifiedMappedMemories(db, projectPath) {
                 AND m.status IN ('active','permanent')
                 AND (m.expires_at IS NULL OR m.expires_at > ?)
                 AND v.file_path <> ''
-                AND v.verified_at = 0`).get(projectPath, Date.now());
+                AND v.verified_at = 0
+                AND NOT (${CURRENT_VERIFY_SKIP_SQL})`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
@@ -4204,6 +4395,7 @@ function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
                 AND (m.expires_at IS NULL OR m.expires_at > ?)
+                AND NOT (${CURRENT_VERIFY_SKIP_SQL})
                 AND (
                     SELECT MAX(v.verified_at)
                       FROM memory_verifications v
@@ -4312,7 +4504,7 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
     case "verify-broad": {
       const total = countMappedMemories(db, projectPath);
       const cycleStartAt = getTaskScheduleState(db, projectPath, "verify-broad")?.lastBroadRunAt;
-      const pending = cycleStartAt == null ? total : countBroadCycleCandidates(db, projectPath, cycleStartAt);
+      const pending = countBroadCycleCandidates(db, projectPath, cycleStartAt ?? Number.MAX_SAFE_INTEGER);
       return { pending, total };
     }
     case "curate": {
@@ -4439,6 +4631,7 @@ function getDreamTaskBacklogs(db, projectPath, tasks = CANONICAL_DREAM_TASKS, op
   }
   const optionKey = (value) => value === undefined ? "omitted" : value === null ? "null" : `number:${value}`;
   const key = JSON.stringify([
+    getHarness2(),
     projectPath,
     tasks,
     optionKey(options.lastRunAt),
@@ -4528,7 +4721,7 @@ function openOpenCodeDb() {
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
 
 // ../plugin/src/agents/dreamer.ts
@@ -4551,7 +4744,7 @@ var DREAMER_REVIEWER_AGENT = "dreamer-reviewer";
 // ../plugin/src/features/magic-context/schema-fence-probe.ts
 var STALE_CHILD_SPAWN_FAILURE = "stale_schema_fence";
 var STALE_CHILD_SPAWN_LATCH_THRESHOLD = 2;
-var state = {
+var state2 = {
   consecutiveFailures: 0,
   totalFailures: 0,
   latched: false,
@@ -4559,23 +4752,23 @@ var state = {
   failure: null
 };
 function recordStaleFence(persistedVersion, supportedVersion, reason = "newer_schema") {
-  state.consecutiveFailures += 1;
-  state.totalFailures += 1;
-  const latched = state.consecutiveFailures >= STALE_CHILD_SPAWN_LATCH_THRESHOLD;
-  state.latched ||= latched;
+  state2.consecutiveFailures += 1;
+  state2.totalFailures += 1;
+  const latched = state2.consecutiveFailures >= STALE_CHILD_SPAWN_LATCH_THRESHOLD;
+  state2.latched ||= latched;
   const failure = {
     failureClass: STALE_CHILD_SPAWN_FAILURE,
     reason,
     persistedVersion,
     supportedVersion,
-    consecutiveFailures: state.consecutiveFailures,
-    totalFailures: state.totalFailures,
-    latched: state.latched
+    consecutiveFailures: state2.consecutiveFailures,
+    totalFailures: state2.totalFailures,
+    latched: state2.latched
   };
-  state.failure = failure;
-  const shouldSurface = state.latched && !state.noticeEmitted;
+  state2.failure = failure;
+  const shouldSurface = state2.latched && !state2.noticeEmitted;
   if (shouldSurface)
-    state.noticeEmitted = true;
+    state2.noticeEmitted = true;
   return { allowSpawn: false, failure, shouldSurface };
 }
 function probeChildSpawnFence(db) {
@@ -4594,9 +4787,9 @@ function probeChildSpawnFence(db) {
   } catch {
     return recordStaleFence(LATEST_SUPPORTED_VERSION, LATEST_SUPPORTED_VERSION, "read_error");
   }
-  state.consecutiveFailures = 0;
-  state.latched = false;
-  state.noticeEmitted = false;
+  state2.consecutiveFailures = 0;
+  state2.latched = false;
+  state2.noticeEmitted = false;
   return { allowSpawn: true };
 }
 
@@ -5791,6 +5984,18 @@ function messageId(message) {
   const id = infoOf(message).id;
   return typeof id === "string" ? id : null;
 }
+function recordedAssistantError(message) {
+  const info = infoOf(message);
+  if (info.error != null)
+    return info.error;
+  if (isSettledAssistant(message))
+    return;
+  const parts = message?.parts;
+  if (!Array.isArray(parts))
+    return;
+  const retry = parts.slice().reverse().find((part) => part !== null && typeof part === "object" && part.type === "retry");
+  return retry?.error ?? undefined;
+}
 function isSettledAssistant(message) {
   const info = infoOf(message);
   if (info.role !== "assistant")
@@ -5906,6 +6111,22 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
   let completionBaseline = new Set((await readMessages(session, sessionId, dir, signal)).map(messageId).filter((id) => id !== null));
   const initialBaseline = new Set(completionBaseline);
   activeSessionErrors.set(sessionId, undefined);
+  const failForHostError = async (hostError) => {
+    await abortChildRun(client, sessionId);
+    const error = new Error(`Host recorded session error: ${describeAssistantError(hostError)}`);
+    Object.assign(error, {
+      name: "DreamerProviderOutputFailureError",
+      transient: true,
+      [HOST_SESSION_ERROR]: true,
+      hostError
+    });
+    annotateSubagentInvocationError(error, {
+      attemptedModel: requestModelRef(request),
+      modelConfigKey: options.modelConfigKey,
+      hostError
+    });
+    throw error;
+  };
   try {
     let sent;
     try {
@@ -5940,22 +6161,17 @@ async function promptAsyncAndWaitForIdle(client, request, options = {}) {
       await sleep(pollIntervalMs, signal);
       const hostError = activeSessionErrors.get(sessionId);
       if (hostError !== undefined) {
-        const error = new Error(`Host recorded session error: ${describeAssistantError(hostError)}`);
-        Object.assign(error, {
-          name: "DreamerProviderOutputFailureError",
-          transient: true,
-          [HOST_SESSION_ERROR]: true,
-          hostError
-        });
-        annotateSubagentInvocationError(error, {
-          attemptedModel: requestModelRef(request),
-          modelConfigKey: options.modelConfigKey,
-          hostError
-        });
-        throw error;
+        await failForHostError(hostError);
       }
       const status = await readStatus(session, sessionId, dir, signal);
       const messages = await readMessages(session, sessionId, dir, signal);
+      const latestAssistant = messages.slice().reverse().find((message) => {
+        const id = messageId(message);
+        return id !== null && !completionBaseline.has(id) && infoOf(message).role === "assistant";
+      });
+      const assistantError = recordedAssistantError(latestAssistant);
+      if (assistantError !== undefined)
+        await failForHostError(assistantError);
       if (!sawOutput && messages.some((message) => {
         const id = messageId(message);
         return id !== null && !initialBaseline.has(id) && showsModelOutput(message);
@@ -7235,6 +7451,15 @@ function validateHistorianOutput(text, sessionId, chunk, _priorCompartments, seq
       error: "Historian terminal boundary splits a completed tool invocation/result arc"
     });
   }
+  for (const compartment of mapped.compartments) {
+    const supported = new Set(chunk.lines.filter((line) => line.ordinal >= compartment.startMessage && line.ordinal <= compartment.endMessage).flatMap((line) => line.commitHashes ?? []));
+    for (const field of ["title", "content", "p1", "p2", "p3", "p4"]) {
+      const value = compartment[field];
+      if (typeof value === "string") {
+        compartment[field] = removeUnsupportedCommitHashes(value, supported);
+      }
+    }
+  }
   return finish({
     ok: true,
     compartments: mapped.compartments,
@@ -9551,6 +9776,7 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
     async attempt(handle, request) {
       if (!client)
         throw new Error("Hidden completion client is unavailable");
+      hostErrors.delete(handle.id);
       const identity = runIdentities.get(handle.id);
       const requestedModel = request.body?.model;
       const requestedRef = requestedModel && typeof requestedModel.providerID === "string" && typeof requestedModel.modelID === "string" ? `${requestedModel.providerID}/${requestedModel.modelID}` : undefined;
@@ -9593,9 +9819,9 @@ function createV1HiddenCompletionExecutor(client, db, directory) {
       });
       const assistantFailure = extractLatestAssistantFailure(messages);
       const hostError = hostErrors.get(handle.id);
-      if (assistantFailure) {
-        const finish = assistantFailure.finish ? ` (finish=${assistantFailure.finish})` : "";
-        const error = new Error(`Historian host recorded an assistant error${finish}: ${describeAssistantFailure(assistantFailure.error)}`, hostError === undefined ? undefined : { cause: hostError });
+      if (assistantFailure || hostError !== undefined) {
+        const finish = assistantFailure?.finish ? ` (finish=${assistantFailure.finish})` : "";
+        const error = new Error(`Historian host recorded an assistant error${finish}: ${describeAssistantFailure(assistantFailure?.error ?? hostError)}`, hostError === undefined ? undefined : { cause: hostError });
         annotateSubagentInvocationError(error, {
           attemptedModel: handle.attemptedModel,
           modelConfigKey: handle.modelConfigKey,
@@ -16574,7 +16800,7 @@ function insertDreamRun(db, run) {
 }
 
 // ../plugin/src/features/magic-context/dreamer/verify.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // ../plugin/src/features/magic-context/dreamer/verify-diff.ts
 import { execFile as execFile3 } from "node:child_process";
@@ -16695,7 +16921,56 @@ Read only these changed line ranges if they may affect the claim.`
 }
 
 // ../plugin/src/features/magic-context/dreamer/verify-gate.ts
+import path12 from "node:path";
+
+// ../plugin/src/features/magic-context/dreamer/verify-state.ts
+import { createHash as createHash9 } from "node:crypto";
+import { readFile, realpath as realpath2 } from "node:fs/promises";
 import path11 from "node:path";
+function verificationMetadata(memory) {
+  try {
+    const parsed = JSON.parse(memory.metadataJson ?? "{}");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+      return parsed;
+  } catch {}
+  return {};
+}
+async function verificationFilesFingerprint(directory, files) {
+  const root = await resolveGitTopLevel(directory) ?? path11.resolve(directory);
+  const hash = createHash9("sha256");
+  for (const file of [...new Set(files)].sort()) {
+    const absolute = path11.resolve(root, file);
+    const withinRoot = (candidate) => {
+      const relative = path11.relative(root, candidate);
+      return relative !== ".." && !relative.startsWith(`..${path11.sep}`) && !path11.isAbsolute(relative);
+    };
+    if (!withinRoot(absolute))
+      return null;
+    hash.update(JSON.stringify(file));
+    try {
+      if (!withinRoot(await realpath2(absolute)))
+        return null;
+      hash.update(createHash9("sha256").update(await readFile(absolute)).digest("hex"));
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        return null;
+      hash.update("missing");
+    }
+  }
+  return hash.digest("hex");
+}
+function recordVerificationVerdict(db, memory, verdict, at, fingerprint = null) {
+  const metadata = verificationMetadata(memory);
+  delete metadata.dreamerVerifySkip;
+  if (verdict === "skip" && fingerprint) {
+    metadata.dreamerVerifySkip = { contentHash: memory.normalizedHash, fingerprint, at };
+  }
+  metadata.dreamerVerifyVerdict = verdict;
+  metadata.dreamerVerifyAttemptedAt = at;
+  db.prepare("UPDATE memories SET metadata_json = ? WHERE id = ?").run(JSON.stringify(metadata), memory.id);
+}
+
+// ../plugin/src/features/magic-context/dreamer/verify-gate.ts
 function minOf(values) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
@@ -16727,7 +17002,22 @@ async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject2(args.db, args.projectIdentity);
   const verById = getMemoryVerifications(args.db, active.map((m) => m.id));
-  const candidates = active.filter((m) => (verById.get(m.id)?.files.length ?? 0) > 0);
+  const candidates = [];
+  const unchangedSkippedIds = [];
+  const changedSkippedIds = new Set;
+  for (const memory of active) {
+    const files = verById.get(memory.id)?.files ?? [];
+    if (!files.length)
+      continue;
+    const skip = verificationMetadata(memory).dreamerVerifySkip;
+    if (skip && skip.contentHash === memory.normalizedHash && typeof skip.fingerprint === "string" && skip.fingerprint === await verificationFilesFingerprint(args.projectDirectory, files)) {
+      unchangedSkippedIds.push(memory.id);
+    } else {
+      candidates.push(memory);
+      if (skip)
+        changedSkippedIds.add(memory.id);
+    }
+  }
   const toPrompt = (m) => {
     const verifiedAt = verById.get(m.id)?.verifiedAt ?? 0;
     let verifiedCommit = null;
@@ -16754,7 +17044,7 @@ async function partitionVerifyScope(args) {
       leaseKey: args.leaseKey,
       runStartedAt
     });
-    const broadCandidates = candidates.filter((m) => (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
+    const broadCandidates = candidates.filter((m) => changedSkippedIds.has(m.id) || (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
       const verifiedAtA = verById.get(a.id)?.verifiedAt ?? 0;
       const verifiedAtB = verById.get(b.id)?.verifiedAt ?? 0;
       return verifiedAtA - verifiedAtB || a.id - b.id;
@@ -16765,7 +17055,10 @@ async function partitionVerifyScope(args) {
       mode: "broad",
       inScope: broadCandidates.map(toPrompt),
       inScopeIds: broadCandidates.map((m) => m.id),
-      skippedIds: candidates.filter((m) => !broadIds.has(m.id)).map((m) => m.id),
+      skippedIds: [
+        ...unchangedSkippedIds,
+        ...candidates.filter((m) => !broadIds.has(m.id)).map((m) => m.id)
+      ],
       broadCycleStartAt,
       reason: `broad cycle (${broadCandidates.length} remain; started ${broadCycleStartAt})`
     };
@@ -16776,7 +17069,7 @@ async function partitionVerifyScope(args) {
       mode: "incremental",
       inScope: [],
       inScopeIds: [],
-      skippedIds: [],
+      skippedIds: unchangedSkippedIds,
       reason: "no file-mapped memories in scope"
     };
   }
@@ -16785,11 +17078,11 @@ async function partitionVerifyScope(args) {
     mode,
     inScope: candidates.map(toPrompt),
     inScopeIds: candidates.map((m) => m.id),
-    skippedIds: [],
+    skippedIds: unchangedSkippedIds,
     reason
   });
   const resolvedGitRoot = await resolveGitTopLevel(args.projectDirectory);
-  const gitRoot = resolvedGitRoot ?? path11.resolve(args.projectDirectory);
+  const gitRoot = resolvedGitRoot ?? path12.resolve(args.projectDirectory);
   const verifiedTimes = candidates.map((m) => verById.get(m.id)?.verifiedAt ?? 0).filter((t) => t > 0);
   const sinceMs = verifiedTimes.length > 0 ? minOf(verifiedTimes) : runStartedAt;
   const changeTimes = await readGitFileChangeTimesSince(args.projectDirectory, sinceMs, resolvedGitRoot ?? undefined);
@@ -16799,11 +17092,11 @@ async function partitionVerifyScope(args) {
   const head = await readGitHead(args.projectDirectory);
   const uncommitted = head ? await readGitChangedFilesSince(args.projectDirectory, head, resolvedGitRoot ?? undefined) ?? new Set : new Set;
   const inScope = [];
-  const skippedIds = [];
+  const skippedIds = [...unchangedSkippedIds];
   for (const m of candidates) {
     const v = verById.get(m.id);
     const verifiedAt = v?.verifiedAt ?? 0;
-    if (verifiedAt === 0) {
+    if (verifiedAt === 0 || changedSkippedIds.has(m.id)) {
       inScope.push(toPrompt(m));
       continue;
     }
@@ -17173,6 +17466,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
   let budgetFinalized = false;
   let failedCompletion;
   let headAtPrompt = null;
+  const skipSnapshots = new Map;
   const onBudgetUpdate = (state) => {
     budgetFinalized ||= state.finalizeFired;
     args.onBudgetUpdate?.({
@@ -17189,6 +17483,11 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     });
   };
   try {
+    if (!args.moduleRoute) {
+      for (const memory of batch) {
+        skipSnapshots.set(memory.id, await raceWithSignal(verificationFilesFingerprint(args.sessionDirectory, memory.mappedFiles), batchSignal));
+      }
+    }
     headAtPrompt = await raceWithSignal(readGitHead(args.sessionDirectory), batchSignal);
     const evidence = !args.forceBroad && batch.every((m) => m.verifiedAt) ? await raceWithSignal(buildVerifyDiffEvidence(args.sessionDirectory, batch), batchSignal) : null;
     const prompt = buildVerifyPrompt(args.projectIdentity, await raceWithSignal(seedVerifyCandidates(batch, args.sessionDirectory), batchSignal), evidence);
@@ -17230,7 +17529,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
         tokens: run.completion.usage
       });
       reportUsage(run.completion.messages ?? [], run.childSessionId, run.completion.usage.input + (run.completion.usage.cacheRead ?? 0) + (run.completion.usage.cacheWrite ?? 0));
-      return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+      return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized, skipSnapshots);
     }
     const client = args.client;
     if (!client)
@@ -17290,7 +17589,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     promptSettled = true;
     recordInvocation4(args, startedAt, { status: "completed", messages: run.output });
     reportUsage(run.output, agentSessionId);
-    return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized);
+    return await applyParsedVerifyManifest(args, batch, run.validated, evidence?.head ?? headAtPrompt, budgetFinalized, skipSnapshots);
   } catch (error) {
     const desc = describeError(error);
     const providerFailure = error instanceof DreamerProviderOutputFailureError ? error : undefined;
@@ -17310,7 +17609,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     if (interrupted) {
       const text = verifyAssistantText(messages) ?? failedCompletion?.text ?? "";
       const recovered = parsePartialVerifyManifest(text, new Set(batch.map((m) => m.id)));
-      const counts = await applyParsedVerifyManifest(args, batch, recovered, headAtPrompt, true);
+      const counts = await applyParsedVerifyManifest(args, batch, recovered, headAtPrompt, true, skipSnapshots);
       return {
         ...counts,
         timedOut: !(error instanceof DreamTokenBudgetExceeded),
@@ -17342,7 +17641,7 @@ async function verifyOneBatch(args, batch, sliceMs, signal) {
     signal.removeEventListener("abort", abort);
   }
 }
-async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false) {
+async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budgetFinalized = false, skipSnapshots) {
   const batchIds = new Set(batch.map((m) => m.id));
   const batchById = new Map(batch.map((memory) => [memory.id, memory]));
   const valid = {
@@ -17421,6 +17720,15 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
     }
     writes.push({ kind: "archive", id: a.id, reason: a.reason });
   }
+  if (!args.moduleRoute) {
+    for (const entry of valid.skipped) {
+      const original = batchById.get(entry.id);
+      if (!original)
+        continue;
+      const fingerprint = skipSnapshots ? skipSnapshots.get(entry.id) ?? null : await verificationFilesFingerprint(args.sessionDirectory, original.mappedFiles);
+      writes.push({ kind: "skip", id: entry.id, fingerprint });
+    }
+  }
   let verified = 0;
   let updated = 0;
   let archived = 0;
@@ -17450,7 +17758,7 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           name: "memory.set_verification",
           arguments: {
             memory_project: args.projectIdentity,
-            command_id: `${args.moduleRoute.moduleCommandId}:${createHash9("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
+            command_id: `${args.moduleRoute.moduleCommandId}:${createHash10("sha256").update(rows.map((row) => row.memory_id).join(",")).digest("hex").slice(0, 16)}`,
             rows
           }
         }
@@ -17482,9 +17790,17 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
         continue;
       if (w.kind === "verify") {
         recordMemoryVerifications(args.db, w.id, w.files, now);
-        if (verifiedHead)
-          recordVerifiedCommit(args.db, memory, now, verifiedHead);
+        updateMemoryVerification2(args.db, w.id, "verified");
+        recordVerificationVerdict(args.db, memory, "verified", now);
+        const verifiedMemory = getMemoryById2(args.db, w.id);
+        if (verifiedHead && verifiedMemory)
+          recordVerifiedCommit(args.db, verifiedMemory, now, verifiedHead);
         verified += 1;
+      } else if (w.kind === "skip") {
+        if (memory.content !== batchById.get(w.id)?.content)
+          continue;
+        updateMemoryVerification2(args.db, w.id, "unverified");
+        recordVerificationVerdict(args.db, memory, "skip", now, w.fingerprint);
       } else if (w.kind === "update") {
         const duplicate = getMemoryByHash2(args.db, memory.projectPath, memory.category, w.hash);
         if (duplicate && duplicate.id !== memory.id) {
@@ -17493,6 +17809,8 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
           continue;
         }
         rewriteMemoryContent(args.db, memory, w.content, w.hash);
+        updateMemoryVerification2(args.db, w.id, "unverified");
+        recordVerificationVerdict(args.db, memory, "update", now);
         queueMemoryMutation(args.db, {
           projectPath: args.projectIdentity,
           mutationType: "update",
@@ -17503,6 +17821,8 @@ async function applyParsedVerifyManifest(args, batch, parsed, headAtPrompt, budg
         updated += 1;
       } else {
         archiveMemory2(args.db, w.id, w.reason);
+        updateMemoryVerification2(args.db, w.id, "stale");
+        recordVerificationVerdict(args.db, memory, "archive", now);
         queueMemoryMutation(args.db, {
           projectPath: args.projectIdentity,
           mutationType: "archive",
@@ -18296,7 +18616,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash10("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash11("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -20396,16 +20716,17 @@ function resolvePiInvocation(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
   const resolvePackageJson = options.resolvePackageJson ?? defaultResolvePiPackageJson;
+  const scriptRuntime = isGenericRuntimeExecutable(execPath) ? execPath : "node";
   const running = resolvePiCliFromRunningEntry(currentScript, fs);
   const checkedPaths = [...running.checkedPaths];
   if (running.cliPath) {
     return {
-      command: execPath,
+      command: scriptRuntime,
       prefixArgs: [running.cliPath],
       targetHarness: running.targetHarness ?? piHarnessKindFromExecutable(running.cliPath) ?? resolvePiHarnessKind()
     };
   }
-  if (!isGenericRuntimeExecutable(execPath)) {
+  if (piHarnessKindFromExecutable(execPath) !== undefined || !isGenericRuntimeExecutable(execPath) && currentScript?.startsWith(BUN_VIRTUAL_SCRIPT_PREFIX)) {
     return {
       command: execPath,
       prefixArgs: [],
@@ -20415,7 +20736,7 @@ function resolvePiInvocation(options = {}) {
   const bundled = resolveBundledPiCli(currentScript, fs, resolvePackageJson, checkedPaths);
   if (bundled.cliPath) {
     return {
-      command: execPath,
+      command: scriptRuntime,
       prefixArgs: [bundled.cliPath],
       targetHarness: bundled.targetHarness ?? piHarnessKindFromExecutable(bundled.cliPath) ?? resolvePiHarnessKind()
     };
@@ -24734,6 +25055,50 @@ function prepareLegacyToolSkeletonConversions(db, sessionId, targets, options =
     }
   };
 }
+function prepareAgedToolSkeletonConversions(db, sessionId, targets, options = {}) {
+  const candidates = [...targets.keys()].sort((a, b) => a - b);
+  const readRows = (connection) => {
+    const window = getNewestToolTagNumbers2(connection, sessionId, RECENT_TOOL_SKELETON_WINDOW);
+    const recent = new Set(window);
+    const statement = connection.prepare(`SELECT tag_number AS tagNumber, drop_mode AS dropMode, message_id AS callId
+             FROM tags WHERE session_id = ? AND tag_number = ?
+               AND type = 'tool' AND status = 'dropped'
+               AND drop_mode IN ('truncated', 'skeleton_real', 'skeleton_stripped')`);
+    const rows = candidates.filter((id) => !recent.has(id)).flatMap((id) => {
+      const row = statement.get(sessionId, id);
+      return row ? [row] : [];
+    });
+    return { window, rows };
+  };
+  const snapshot = readRows(db);
+  options.prepareRemovals?.(snapshot.rows);
+  const converted = new Map;
+  const plannedRemovals = new Set;
+  for (const row of snapshot.rows) {
+    const target = targets.get(row.tagNumber);
+    if (target?.thinkingDropProtected || target?.thinkingRewriteProtected || target?.identityRepairProtected)
+      continue;
+    if (target?.canDrop?.() !== true || target.prepareDrop?.() === false)
+      continue;
+    if (target.requiresToolArcSkeleton) {
+      const owners = target.mutationParts ? target.mutationParts.map(({ message }) => message).filter((message) => message.info.role === "assistant") : target.message ? [target.message] : [];
+      if (owners.length === 0 || owners.some((message) => !options.thinkingStrippedIds?.has(message.info.id ?? "")))
+        continue;
+    }
+    if (target.cannotRemove?.() === true || target.wouldStrandConversationEnd?.(plannedRemovals) === true)
+      continue;
+    converted.set(row.tagNumber, "full");
+    target.notePlannedRemoval?.(plannedRemovals);
+  }
+  return {
+    converted,
+    isCurrent: (connection) => JSON.stringify(readRows(connection)) === JSON.stringify(snapshot),
+    persist: (connection) => {
+      for (const tagNumber of converted.keys())
+        updateTagDropMode2(connection, sessionId, tagNumber, "full");
+    }
+  };
+}
 var PENDING_OPERATION_CHUNK_SIZE = 64;
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
@@ -25623,7 +25988,9 @@ function resolveProtectedTailBoundary(ctx) {
   const offset = Math.max(1, ctx.lastCompartmentEndOrdinal + 1);
   const absoluteMessageCount = getCachedAbsoluteMessageCount2(ctx.sessionId) ?? getRawSessionMessageOrdinalCount2(ctx.sessionId);
   const messages = readRawSessionMessageRange2(ctx.sessionId, Math.max(1, offset - 1), absoluteMessageCount);
-  const storedTotals = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages) ?? ctx.storedTokenTotals;
+  const storedWeights = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages);
+  const storedTotals = storedWeights?.totals ?? ctx.storedTokenTotals;
+  const storedRemovedTotals = storedWeights?.summaryRemovedTotals ?? ctx.storedSummaryRemovedTokenTotals;
   const index = buildTrueRawTokenIndex(ctx.sessionId, messages, {
     providerShapeVersion: ctx.providerShapeVersion,
     cacheNamespace: ctx.cacheNamespace,
@@ -25634,6 +26001,14 @@ function resolveProtectedTailBoundary(ctx) {
       return v === undefined ? null : v;
     } : undefined
   });
+  const summaryRemovedIndex = buildTrueRawTokenIndex(ctx.sessionId, messages, {
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    calibration: ctx.calibration,
+    absoluteMessageCount,
+    measure: "summary-removed",
+    storedTotalForMessage: storedRemovedTotals ? (m) => storedRemovedTotals.get(m.id) ?? null : undefined
+  });
   const rawMessageCount = index.rawMessageCount;
   const usagePercentage = clampPercentage(ctx.usage?.percentage ?? 0);
   const usageInputTokens = Math.max(0, Math.round(ctx.usage?.inputTokens ?? 0));
@@ -25665,6 +26040,7 @@ function resolveProtectedTailBoundary(ctx) {
       createdAt,
       rawRangeFingerprint: "",
       trueRawEligibleTokens: 0,
+      summaryRemovedEligibleTokens: 0,
       oversizeAtomicUnit: false,
       boundaryReason: "empty-session"
     };
@@ -25708,6 +26084,7 @@ function resolveProtectedTailBoundary(ctx) {
       createdAt,
       rawRangeFingerprint,
       trueRawEligibleTokens: index.rangeTokens(offset, protectedTailStart),
+      summaryRemovedEligibleTokens: summaryRemovedIndex.rangeTokens(offset, protectedTailStart),
       oversizeAtomicUnit: false,
       boundaryReason: firstOpenArc ? "open-tool-arc" : "manual-full-recomp"
     };
@@ -25784,7 +26161,7 @@ function resolveProtectedTailBoundary(ctx) {
     observeDiagnostics: (value) => {
       headDiagnostics = value;
     },
-    index,
+    index: summaryRemovedIndex,
     protectedTailStart,
     offset,
     arcs,
@@ -25823,6 +26200,7 @@ function resolveProtectedTailBoundary(ctx) {
     createdAt,
     rawRangeFingerprint,
     trueRawEligibleTokens: index.rangeTokens(offset, eligibleEndOrdinal),
+    summaryRemovedEligibleTokens: summaryRemovedIndex.rangeTokens(offset, eligibleEndOrdinal),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
     boundaryReason,
     diagnostics: boundaryDiagnostics({
@@ -25870,8 +26248,11 @@ function resolveBoundaryContext(args) {
   const calibration = sessionDecisionCalibration(args.db, args.sessionId);
   const storedTokenTotalsForMessages = (messageIds, messages = []) => {
     try {
-      const totals = getAllStatusTagTokenTotalsFlat2(args.db, args.sessionId, args.taggerFloor ?? 0, calibration, messageIds).totals;
-      return omitIncompleteFileTokenTotals(args.db, args.sessionId, messages, totals);
+      const weights = getAllStatusTagTokenTotalsFlat2(args.db, args.sessionId, args.taggerFloor ?? 0, calibration, messageIds);
+      return {
+        totals: omitIncompleteFileTokenTotals(args.db, args.sessionId, messages, weights.totals),
+        summaryRemovedTotals: weights.summaryRemovedTotals
+      };
     } catch (error) {
       sessionLog2(args.sessionId, "protected-tail stored-token map unavailable (live fallback):", error);
       return;
@@ -25907,7 +26288,9 @@ function resolveWrapupProtectedTailBoundary(args) {
   const offset = Math.max(1, ctx.lastCompartmentEndOrdinal + 1);
   const absoluteMessageCount = getCachedAbsoluteMessageCount2(ctx.sessionId) ?? getRawSessionMessageOrdinalCount2(ctx.sessionId);
   const messages = readRawSessionMessageRange2(ctx.sessionId, Math.max(1, offset - 1), absoluteMessageCount);
-  const storedTotals = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages) ?? ctx.storedTokenTotals;
+  const storedWeights = ctx.storedTokenTotalsForMessages?.(messages.map((m) => m.id), messages);
+  const storedTotals = storedWeights?.totals ?? ctx.storedTokenTotals;
+  const storedRemovedTotals = storedWeights?.summaryRemovedTotals ?? ctx.storedSummaryRemovedTokenTotals;
   const index = buildTrueRawTokenIndex(ctx.sessionId, messages, {
     providerShapeVersion: ctx.providerShapeVersion,
     cacheNamespace: ctx.cacheNamespace,
@@ -25918,6 +26301,14 @@ function resolveWrapupProtectedTailBoundary(args) {
       return value === undefined ? null : value;
     } : undefined
   });
+  const summaryRemovedIndex = buildTrueRawTokenIndex(ctx.sessionId, messages, {
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    calibration: ctx.calibration,
+    absoluteMessageCount,
+    measure: "summary-removed",
+    storedTotalForMessage: storedRemovedTotals ? (m) => storedRemovedTotals.get(m.id) ?? null : undefined
+  });
   const rawMessageCount = index.rawMessageCount;
   const anchorRawMessageCount = Math.max(0, Math.min(rawMessageCount, Math.floor(args.anchorRawMessageCount ?? rawMessageCount)));
   const usagePercentage = clampPercentage(ctx.usage?.percentage ?? 0);
@@ -25979,7 +26370,7 @@ function resolveWrapupProtectedTailBoundary(args) {
     observeDiagnostics: (value) => {
       headDiagnostics = value;
     },
-    index,
+    index: summaryRemovedIndex,
     protectedTailStart: targetProtectedTailStart,
     offset,
     arcs: buildToolArcs(messages),
@@ -26016,6 +26407,7 @@ function resolveWrapupProtectedTailBoundary(args) {
     createdAt,
     rawRangeFingerprint,
     trueRawEligibleTokens: index.rangeTokens(offset, targetProtectedTailStart),
+    summaryRemovedEligibleTokens: summaryRemovedIndex.rangeTokens(offset, eligibleEndOrdinal),
     oversizeAtomicUnit: head.oversizeAtomicUnit,
     boundaryReason,
     diagnostics: boundaryDiagnostics({
@@ -27440,6 +27832,52 @@ ${typeof state?.output === "string" ? state.output : JSON.stringify(state?.outpu
   };
 }
 
+// ../plugin/src/hooks/magic-context/transform-context-state.ts
+var usageRefusals = new WeakMap;
+function recordUsageRefusal(db, sessionId, refusedAt = Date.now()) {
+  let sessions = usageRefusals.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    usageRefusals.set(db, sessions);
+  }
+  if (!sessions.has(sessionId))
+    sessions.set(sessionId, refusedAt);
+}
+function shouldResetRefusedUsage(db, sessionId, meta, liveReading) {
+  const refusals = usageRefusals.get(db);
+  const refusedAt = refusals?.get(sessionId);
+  if (refusedAt === undefined)
+    return false;
+  const readingAt = liveReading?.hasUsageTokens ? liveReading.updatedAt : meta.lastResponseTime;
+  if (readingAt > refusedAt) {
+    refusals?.delete(sessionId);
+    return false;
+  }
+  const now = Date.now();
+  const foldedAt = meta.cachedM0MaterializedAt ?? 0;
+  if (foldedAt > refusedAt && foldedAt <= now)
+    return true;
+  return !!db.prepare("SELECT 1 FROM compartments WHERE session_id = ? AND harness = ? AND created_at > ? AND created_at <= ? LIMIT 1").get(sessionId, getHarness2(), refusedAt, now);
+}
+function resolveUnknownUsageFromWireEstimate(input) {
+  if (input.usage.inputTokens > 0 || !input.pricedPass)
+    return input.usage;
+  const wireTokens = input.wireEstimateTokens;
+  if (typeof wireTokens !== "number" || !Number.isFinite(wireTokens) || wireTokens <= 0) {
+    return input.usage;
+  }
+  const providerTokens = input.providerProvenInputTokens;
+  const providerLimit = input.providerProvenLimitTokens;
+  const canUseProviderMass = input.wireEstimateTrusted === false && typeof providerTokens === "number" && Number.isFinite(providerTokens) && providerTokens > 0 && typeof providerLimit === "number" && Number.isFinite(providerLimit) && providerLimit > 0;
+  const tokens = canUseProviderMass ? Math.max(wireTokens, providerTokens) : wireTokens;
+  const limit = input.usableHardLimit;
+  const estimatedPercentage = typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? tokens / limit * 100 : input.usage.percentage;
+  return {
+    inputTokens: tokens,
+    percentage: Math.max(input.usage.percentage, estimatedPercentage)
+  };
+}
+
 // ../plugin/src/hooks/magic-context/transform-stage-logger.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var SLOW_STAGE_MS = 100;
@@ -27497,7 +27935,7 @@ function recoveryReasoningPrefixes(messages, partsKey) {
 }
 
 // ../plugin/src/shared/tag-transcript.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function buildPersistedDropTargets(transcript, tags, options = {}) {
   const targets = new Map;
   const tools = new Map(tags.filter((tag) => tag.type === "tool").map((tag) => [makeToolCompositeKey(tag.toolOwnerMessageId ?? "", tag.messageId), tag]));
@@ -27580,7 +28018,7 @@ function buildPersistedDropTargets(transcript, tags, options = {}) {
   return targets;
 }
 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() ?? ""));
@@ -28536,6 +28974,32 @@ function selectAutoSearchResults(results, threshold) {
   return results.filter((result) => relevance(result) >= threshold).sort((left, right) => relevance(right) - relevance(left));
 }
 
+// ../plugin/src/hooks/magic-context/auto-search-observation.ts
+var disabledTurns = new WeakMap;
+function logDisabledAutoSearch(db, sessionId, messageId, threshold, startedAt) {
+  const sessions = disabledTurns.get(db) ?? new Map;
+  disabledTurns.set(db, sessions);
+  if (sessions.get(sessionId) === messageId)
+    return;
+  sessions.set(sessionId, messageId);
+  observeAutoSearch(sessionId, threshold, startedAt).finish("disabled");
+}
+function observeAutoSearch(sessionId, threshold, startedAt) {
+  const diagnostics = createAutoSearchDiagnostics(threshold);
+  let logged = false;
+  return {
+    diagnostics,
+    finish(outcome, reason) {
+      if (logged)
+        return;
+      logged = true;
+      const lanes = Object.entries(diagnostics.lanes).map(([lane, value]) => `${lane}:${value.top?.toFixed(3) ?? "none"}`).join(",");
+      const nearMisses = Object.values(diagnostics.lanes).reduce((sum, lane) => sum + lane.nearMisses, 0);
+      sessionLog2(sessionId, `auto-search: decision outcome=${outcome}${reason ? ` reason=${reason}` : ""} lanes=${lanes || "none"} nearMisses=${nearMisses} threshold=${threshold} pool=${diagnostics.pool} rows=${diagnostics.poolRows ?? "unknown"} workerStarted=${diagnostics.workerStarted ?? "unknown"} peek=${diagnostics.peek} elapsedMs=${Math.round(performance.now() - startedAt)}`);
+    }
+  };
+}
+
 // ../plugin/src/hooks/magic-context/auto-search-worker-client.ts
 import { Worker } from "node:worker_threads";
 var pendingRegistrations = new WeakMap;
@@ -28682,7 +29146,7 @@ async function acquireSearchWorker(db, key, entry, input, signal) {
     }
     const fresh = !slot;
     if (!slot) {
-      const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { ...input, persistent: true } }));
+      const worker = inRootAsyncContext2(() => input.job === "backfill" && entry.href === defaultAutoSearchWorkerEntry().href ? reuseWorker(entry, { workerData: input }) : new Worker(entry, { workerData: { ...input, persistent: true } }));
       const shutdown = createWorkerShutdown(worker, "auto-search", AUTO_SEARCH_WORKER_CLOSE_DEADLINE_MS);
       slot = {
         worker,
@@ -28760,6 +29224,7 @@ function queueAutoSearchBackfill(db, sessionId, projectPath, query) {
   pending.set(key, work);
   return work;
 }
+var nextSearchJobId = 0;
 async function executeAutoSearchWorker(db, sessionId, projectPath, query, options, entry, job) {
   if (options.signal?.aborted)
     return [];
@@ -28773,12 +29238,14 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     readMessages: _readMessages,
     searchMessageHistory: _searchMessageHistory,
     stepTimings: _stepTimings,
+    onAutoSearchDiagnostics: _onAutoSearchDiagnostics,
     ...serializable
   } = options;
   const lifecycle = registerAutoSearchWork(sessionId);
   const signal = deadlineSignal ? AbortSignal.any([deadlineSignal, lifecycle.signal]) : lifecycle.signal;
   const snapshot = getProjectEmbeddingSnapshot2(projectPath);
   const input = {
+    jobId: ++nextSearchJobId,
     job,
     path,
     harness: getHarness2(),
@@ -28814,6 +29281,11 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     throw new AutoSearchBusyError;
   }
   const { slot, fresh } = lease;
+  if (options.autoSearchDiagnostics) {
+    options.autoSearchDiagnostics.workerStarted = fresh;
+    if (fresh)
+      options.autoSearchDiagnostics.pool = "cold";
+  }
   const worker = slot.worker;
   const detachable = job === "search" && entry.href === defaultAutoSearchWorkerEntry().href;
   const startedAt = performance.now();
@@ -28893,6 +29365,17 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
     const onMessage = async (reply) => {
       if (released)
         return;
+      if (entry.href === defaultAutoSearchWorkerEntry().href && reply.jobId !== input.jobId)
+        return;
+      if (reply.kind === "diagnostics") {
+        if (!settled && options.autoSearchDiagnostics) {
+          const workerStarted = options.autoSearchDiagnostics.workerStarted;
+          Object.assign(options.autoSearchDiagnostics, reply.diagnostics, {
+            workerStarted
+          });
+        }
+        return;
+      }
       if (reply.kind === "result" || reply.kind === "error") {
         if (detachedAt !== undefined) {
           logLateSearch(sessionId, performance.now() - detachedAt, detachedAt - startedAt, ownerVectorMs, reply.kind === "result" ? reply.timings : undefined, reply.kind === "error");
@@ -28911,7 +29394,7 @@ async function executeAutoSearchWorker(db, sessionId, projectPath, query, option
       }
       if (reply.kind === "messages" || reply.kind === "accepted")
         return;
-      const response = { id: reply.id };
+      const response = { id: reply.id, jobId: input.jobId };
       if (!signal.aborted) {
         const requestedAt = performance.now();
         try {
@@ -29096,8 +29579,6 @@ async function runAutoSearchHintForPi(args) {
     const timestamp = message.timestamp;
     return `test-entry-${index}:${typeof timestamp === "number" ? timestamp : "no-ts"}`;
   }) : args.entryIds;
-  if (!options.enabled)
-    return messages;
   const strictResolutionFailed = entryIds === null;
   const effectiveEntryIds = strictResolutionFailed ? messages.map((message) => {
     const id = message.id;
@@ -29107,6 +29588,11 @@ async function runAutoSearchHintForPi(args) {
   if (found === null)
     return messages;
   const { message: userMsg, messageId: userMsgId } = found;
+  if (!options.enabled) {
+    if (found.index === messages.length - 1)
+      logDisabledAutoSearch(db, sessionId, userMsgId, options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD, startedAt);
+    return messages;
+  }
   await wait(coalesceAutoSearchTurn(db, sessionId, userMsgId, async (lifecycleSignal) => {
     args.passGuard?.assert();
     if (lifecycleSignal.aborted)
@@ -29133,10 +29619,12 @@ async function runAutoSearchHintForPi(args) {
       return messages;
     if (!isUsableProjectIdentity(options.projectPath))
       return messages;
+    const observation = observeAutoSearch(sessionId, options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD, startedAt);
     const snapshot = getProjectEmbeddingSnapshot2(options.projectPath);
     if (!snapshot) {
       queueAutoSearchRegistration(db, options.projectPath, args.ensureProjectRegistered);
       persistAutoSearchSkip(db, sessionId, userMsgId, "empty");
+      observation.finish("no-candidates", "unregistered");
       return messages;
     }
     const writeNoHintAndReconcile = async (reason) => {
@@ -29149,17 +29637,20 @@ async function runAutoSearchHintForPi(args) {
       args.passGuard?.assert();
       if (outcome === null) {
         persistAutoSearchSkip(db, sessionId, userMsgId);
+        observation.finish("timeout");
         return;
       }
-      if (!outcome.ok)
+      if (!outcome.ok) {
+        observation.finish("error", outcome.kind);
         return;
+      }
       if (outcome.kind === "already-present" && outcome.decision.decision === "hint") {
         appendHintToUserMessage(userMsg, outcome.decision.text);
       }
+      observation.finish(outcome.decision.decision === "hint" ? "attached" : reason === "below-threshold" ? "below-threshold" : reason === "error" ? "error" : "no-candidates", reason);
     };
     const rawPartsText = collectUserPromptParts(userMsg);
     if (hasStackedAugmentation(rawPartsText)) {
-      sessionLog2(sessionId, "auto-search: skipping — user message already carries augmentation/hint");
       await writeNoHintAndReconcile("stacked");
       return messages;
     }
@@ -29179,6 +29670,7 @@ async function runAutoSearchHintForPi(args) {
         const embeddingEnabled = snapshot ? snapshot.historyEnabled : true;
         const gitCommitsEnabled = snapshot?.gitCommitEnabled ?? false;
         const searchOptions = {
+          autoSearchDiagnostics: observation.diagnostics,
           limit: 10,
           maxMessageOrdinal: Math.max(0, getLastCompartmentEndMessage(db, sessionId)),
           excludeMessageId: userMsgId,
@@ -29207,11 +29699,10 @@ async function runAutoSearchHintForPi(args) {
       if (lifecycleSignal.aborted)
         return messages;
       if (error instanceof AutoSearchBusyError) {
-        sessionLog2(sessionId, "auto-search: an earlier search of this session is still running, skipping hint for this turn");
+        observation.finish("timeout", "worker-busy");
         persistAutoSearchSkip(db, sessionId, userMsgId);
         return messages;
       }
-      log2(`[auto-search] unified search failed for session ${sessionId} (no-hint frozen for this turn): ${error instanceof Error ? error.message : String(error)}`);
       await writeNoHintAndReconcile("error");
       return messages;
     }
@@ -29220,7 +29711,7 @@ async function runAutoSearchHintForPi(args) {
       return messages;
     try {
       if (results === null) {
-        sessionLog2(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn`);
+        observation.finish("timeout");
         persistAutoSearchSkip(db, sessionId, userMsgId);
         return messages;
       }
@@ -29231,7 +29722,6 @@ async function runAutoSearchHintForPi(args) {
       const scoreThreshold = options.scoreThreshold ?? DEFAULT_SCORE_THRESHOLD;
       results = selectAutoSearchResults(results, scoreThreshold);
       if (results.length === 0) {
-        sessionLog2(sessionId, `auto-search: no fragment meets relevance threshold ${scoreThreshold}`);
         await writeNoHintAndReconcile("below-threshold");
         return messages;
       }
@@ -29255,14 +29745,17 @@ ${hintText}`;
       args.passGuard?.assert();
       if (outcome === null) {
         persistAutoSearchSkip(db, sessionId, userMsgId);
+        observation.finish("timeout");
         return messages;
       }
-      if (!outcome.ok)
+      if (!outcome.ok) {
+        observation.finish("error", outcome.kind);
         return messages;
+      }
       if (outcome.decision.decision === "hint") {
         appendHintToUserMessage(userMsg, outcome.decision.text);
       }
-      sessionLog2(sessionId, `auto-search: attached hint to ${userMsgId} (${results.length} fragments, top relevance ${(results[0].relevanceScore ?? results[0].score).toFixed(3)})`);
+      observation.finish(outcome.decision.decision === "hint" ? "attached" : "no-candidates");
       return messages;
     } finally {
       if (!lifecycleSignal.aborted && results !== null) {
@@ -29410,7 +29903,7 @@ function persistFilteredNoise(db, sessionId, chunk, eligibleEnd) {
 }
 
 // src/pi-history-retirement.ts
-var KEY = "piHistorianRetirement";
+var KEY2 = "piHistorianRetirement";
 function readState(db, sessionId) {
   const row = db.prepare("SELECT deferred_execute_state AS state FROM session_meta WHERE session_id = ?").get(sessionId);
   const state = row?.state ? JSON.parse(row.state) : {};
@@ -29419,24 +29912,24 @@ function readState(db, sessionId) {
   return state;
 }
 function readPiHistoryRetirement(db, sessionId) {
-  const target = readState(db, sessionId)[KEY];
+  const target = readState(db, sessionId)[KEY2];
   return typeof target === "string" && target.length > 0 ? target : null;
 }
 function queuePiHistoryRetirement(db, sessionId, throughMessageId) {
   ensureSessionMetaRow(db, sessionId);
   const state = readState(db, sessionId);
-  state[KEY] = throughMessageId;
+  state[KEY2] = throughMessageId;
   db.prepare("UPDATE session_meta SET deferred_execute_state = ? WHERE session_id = ?").run(JSON.stringify(state), sessionId);
 }
 function acknowledgePiHistoryRetirement(db, sessionId, publishedEnd, ordinalOf) {
   const state = readState(db, sessionId);
-  const target = state[KEY];
+  const target = state[KEY2];
   if (typeof target !== "string")
     return;
   const ordinal = ordinalOf(target);
   if (ordinal === undefined || ordinal > publishedEnd)
     return;
-  delete state[KEY];
+  delete state[KEY2];
   db.prepare("UPDATE session_meta SET deferred_execute_state = ? WHERE session_id = ?").run(JSON.stringify(state), sessionId);
 }
 
@@ -29965,7 +30458,7 @@ async function runPiHistorian(deps) {
         db,
         sessionId,
         runId: crypto2.randomUUID(),
-        trueRawTokens: boundarySnapshot.trueRawEligibleTokens,
+        trueRawTokens: boundarySnapshot.summaryRemovedEligibleTokens,
         usagePercentage: boundarySnapshot.usagePercentage,
         usable,
         perRunCap,
@@ -32010,12 +32503,28 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
     const priorInputSample = getEmergencyInputSample(db, sessionId);
     const candidateTags = tags.filter((t) => t.status === "active" && t.type === "tool" && targets.get(t.tagNumber)?.canDrop?.());
     const recentTags = new Set(candidateTags.slice().sort((a, b) => b.tagNumber - a.tagNumber).slice(0, 20).map((tag) => tag.tagNumber));
-    const calibration = sessionDecisionCalibration(db, sessionId);
+    const calibration = emergency.fitCalibration ?? sessionDecisionCalibration(db, sessionId);
     const tPrepare = performance.now();
     config.prepareToolRemovalMeasurements?.(tags.flatMap((tag) => tag.status === "active" && tag.type === "tool" && tag.messageId && targets.get(tag.tagNumber)?.measureReclaim ? [tag.messageId] : []));
     logStep("prepareNativeRemovals", tPrepare);
     const tMeasure = performance.now();
-    const activeTags = tags.filter((t) => t.status === "active").map((tag) => measureEmergencyTag(tag, targets.get(tag.tagNumber), calibration, targets.get(tag.tagNumber)?.requiresToolArcSkeleton === true || (emergency.usagePercentage ?? 0) < 95 && recentTags.has(tag.tagNumber) && hasSmallToolInput(targets.get(tag.tagNumber))));
+    const activeTags = tags.filter((t) => t.status === "active").map((tag) => {
+      const target = targets.get(tag.tagNumber);
+      const imageTokens = emergency.serializedImageTokens?.get(tag.messageId) ?? 0;
+      const observation = target?.measureReclaim;
+      const measuredTarget = imageTokens && observation ? {
+        ...target,
+        measureReclaim(skeleton) {
+          const measured = observation(skeleton);
+          return measured ? {
+            ...measured,
+            beforeTools: measured.beforeTools + imageTokens,
+            afterTools: measured.afterTools + (target.canDrop?.() ? 0 : imageTokens)
+          } : measured;
+        }
+      } : target;
+      return measureEmergencyTag(tag, measuredTarget, calibration, targets.get(tag.tagNumber)?.requiresToolArcSkeleton === true || (emergency.usagePercentage ?? 0) < 95 && recentTags.has(tag.tagNumber) && hasSmallToolInput(targets.get(tag.tagNumber)));
+    });
     const byTag = new Map(activeTags.map((tag) => [tag.tagNumber, tag]));
     const droppableTags = candidateTags.flatMap((tag) => {
       const measured = byTag.get(tag.tagNumber);
@@ -35316,6 +35825,118 @@ function authorizePiToolRemoval(args) {
   }
 }
 
+// src/native-replay-tag-provenance-pi.ts
+import { createHash as createHash13 } from "node:crypto";
+var PI_NATIVE_TAG_STRIP_PROVENANCE = "magicContextNativeTagStrips";
+function nativeResponseTagStripKey(id, phase, text) {
+  return createHash13("sha256").update(JSON.stringify([id, phase, text])).digest("hex");
+}
+function ownsNativeResponseTagStrip(decisions, id, phase, text) {
+  if (!isRecord(decisions) || phase !== undefined && phase !== "commentary" && phase !== "final_answer")
+    return false;
+  return Object.entries(decisions).some(([key, original]) => typeof original === "string" && /^§\d+§ /u.test(original) && original.replace(/^§\d+§ /u, "") === text && nativeResponseTagStripKey(id, phase, original) === key);
+}
+
+// src/native-replay-tags-pi.ts
+var FIELD = "piResponsesTagStrips";
+var TAG = /^§\d+§ /u;
+function readDecisions(value) {
+  if (value === undefined)
+    return new Set;
+  if (!Array.isArray(value) || !value.every((key) => typeof key === "string" && /^[a-f0-9]{64}$/u.test(key)))
+    throw new Error("Invalid persisted Responses tag strips");
+  return new Set(value);
+}
+function signature(part) {
+  if (!isRecord(part) || typeof part.textSignature !== "string")
+    return;
+  try {
+    const value = JSON.parse(part.textSignature);
+    if (isRecord(value) && value.v === 1 && typeof value.id === "string" && value.id.length > 0 && (value.phase === undefined || value.phase === "commentary" || value.phase === "final_answer"))
+      return { id: value.id, phase: value.phase };
+  } catch {}
+}
+function applyNativeResponseTagReplayPi(args) {
+  let saved;
+  const added = new Set;
+  const pending = new Map;
+  for (const [index, message] of args.messages.entries()) {
+    if (!isRecord(message) || message.role !== "assistant" || !Array.isArray(message.content) || ![
+      "openai-responses",
+      "azure-openai-responses",
+      "openai-codex-responses"
+    ].includes(String(message.api)))
+      continue;
+    const payload = message.providerPayload;
+    if (!isRecord(payload) || payload.type !== "openaiResponsesHistory" || payload.dt !== true || !Array.isArray(payload.items))
+      continue;
+    if (saved === undefined) {
+      try {
+        saved = readDecisions(readReplayEnvelope(args.db, args.sessionId)[FIELD]);
+      } catch (error) {
+        sessionLog2(args.sessionId, `native tag replay unavailable; retaining native history: ${String(error)}`);
+        return 0;
+      }
+    }
+    if (!args.canApply && saved.size === 0)
+      return 0;
+    const frozen = saved;
+    const content = message.content;
+    const nativeItems = payload.items;
+    const decisions = {};
+    let changed = false;
+    const items = nativeItems.map((item) => {
+      if (!isRecord(item) || item.type !== "message" || item.role !== "assistant" || item.phase !== undefined && item.phase !== "commentary" && item.phase !== "final_answer" || !Array.isArray(item.content) || item.content.length !== 1)
+        return item;
+      const output = item.content[0];
+      if (!isRecord(output) || output.type !== "output_text" || typeof output.text !== "string" || !TAG.test(output.text))
+        return item;
+      if (nativeItems.filter((other) => isRecord(other) && other.id === item.id && other.phase === item.phase).length !== 1)
+        return item;
+      const key = nativeResponseTagStripKey(item.id, item.phase, output.text);
+      if (!frozen.has(key)) {
+        if (!args.canApply)
+          return item;
+        const blocks = content.filter((block) => {
+          const identity = signature(block);
+          return identity && identity.id === item.id && identity.phase === item.phase;
+        });
+        const block = blocks[0];
+        if (blocks.length !== 1 || !isRecord(block) || block.type !== "text" || typeof block.text !== "string" || block.text.replace(TAG, "") !== output.text.replace(TAG, ""))
+          return item;
+        added.add(key);
+      }
+      decisions[key] = output.text;
+      changed = true;
+      return {
+        ...item,
+        content: [{ ...output, text: output.text.replace(TAG, "") }]
+      };
+    });
+    if (changed)
+      pending.set(index, {
+        ...message,
+        [PI_NATIVE_TAG_STRIP_PROVENANCE]: decisions,
+        providerPayload: { ...payload, items }
+      });
+  }
+  if (added.size > 0) {
+    const persisted = updateReplayDocument(args.db, args.sessionId, (doc) => {
+      const decisions = readDecisions(doc[FIELD]);
+      for (const key of added)
+        decisions.add(key);
+      doc.version = 2;
+      doc[FIELD] = [...decisions];
+      return true;
+    });
+    if (!persisted)
+      throw new Error("Could not persist Responses tag strips");
+  }
+  for (const [index, message] of pending)
+    args.messages[index] = message;
+  return added.size;
+}
+
 // src/note-visibility-pi.ts
 var NOTE_TOOL_NAME = "ctx_note";
 var READ_ACTION = "read";
@@ -36633,7 +37254,7 @@ function piWithoutDateReminders(payload, api, cwd, developerRole, includesPrepar
     const text = google ? singleText(row.parts) : api === "bedrock-converse-stream" ? singleText(row.content) : api.endsWith("responses") ? singleText(row.content, "input_text") ?? (api === "openai-codex-responses" ? row.content : undefined) : row.content;
     if (piDateReminderText(text, cwd)) {
       const keys = google ? ["role", "parts"] : api.endsWith("responses") ? ["role", "content", "type"] : ["role", "content"];
-      const role = api === "ollama-chat" ? "system" : api === "openai-completions" && developerRole ? "developer" : "user";
+      const role = api === "ollama-chat" ? "system" : api === "openai-codex-responses" || api === "openai-completions" && developerRole ? "developer" : "user";
       if (!firstUser || row.role !== role || Object.keys(row).some((key) => !keys.includes(key)) || row.type !== undefined && row.type !== "message")
         return;
       if (!removed) {
@@ -36846,7 +37467,7 @@ function coldReplayable(items) {
   }
   return reasoning;
 }
-function piResponsesAssistantTexts(value, model, host, alternatives) {
+function piResponsesAssistantTexts(value, model, host, alternatives, frozenTagStrips) {
   const message = object10(value);
   if (!message || !Array.isArray(message.content))
     return;
@@ -36890,6 +37511,14 @@ function piResponsesAssistantTexts(value, model, host, alternatives) {
   const payload = object10(message.providerPayload);
   if (message.api !== model?.api || typeof model?.id !== "string" || typeof model?.provider !== "string" || message.model !== model?.id || (payload?.provider ?? message.provider) !== model?.provider || payload?.type !== "openaiResponsesHistory" || payload.dt !== true || !Array.isArray(payload.items))
     return texts;
+  if (host === "omp" && model.api === "openai-codex-responses" && texts.every((text) => !/\S/u.test(JSON.parse(text)[0])) && payload.items.every((value) => {
+    const item = object10(value);
+    return item?.type === "reasoning" || item?.type === "message" && item.role === "assistant" && Array.isArray(item.content) && item.content.every((value) => {
+      const part = object10(value);
+      return part?.type === "output_text" && typeof part.text === "string" && !/\S/u.test(part.text);
+    });
+  }))
+    return [];
   const replay = [];
   let bound = 0;
   let output = false;
@@ -36900,6 +37529,7 @@ function piResponsesAssistantTexts(value, model, host, alternatives) {
   ].includes(model?.api ?? "");
   let unsigned = false;
   let rewrittenText = false;
+  let allUnsignedFrozen = true;
   for (const value of payload.items) {
     const item = object10(value);
     if (item?.type === "reasoning")
@@ -36929,6 +37559,7 @@ function piResponsesAssistantTexts(value, model, host, alternatives) {
         if (!allowUnsigned || "textSignature" in block || stripped !== block.text.replace(/^§\d+§ /u, ""))
           return texts;
         unsigned = true;
+        allUnsignedFrozen &&= part.text === block.text && ownsNativeResponseTagStrip(frozenTagStrips, item.id, item.phase, part.text);
         rewrittenText ||= part.text !== stripped;
       }
       bound++;
@@ -36940,7 +37571,7 @@ function piResponsesAssistantTexts(value, model, host, alternatives) {
     for (const text of itemTexts)
       replay.push(textIdentity2(wellFormed2(text), item.phase));
   }
-  if (!output || bound !== blocks.length || unsigned && !rewrittenText)
+  if (!output || bound !== blocks.length || unsigned && !rewrittenText && !allUnsignedFrozen)
     return texts;
   if (unsigned && alternatives) {
     alternatives.fallback = texts;
@@ -37555,7 +38186,7 @@ function buildPiPreparedStructure(messages, model, prepareUser, host = "omp") {
         continue;
       }
       const alternatives = {};
-      const texts = piResponsesAssistantTexts(projectedMessages[index], model, host, alternatives);
+      const texts = piResponsesAssistantTexts(projectedMessages[index], model, host, alternatives, object11(projectedMessages[index])?.[PI_NATIVE_TAG_STRIP_PROVENANCE]);
       if (!texts) {
         responsesMessages = undefined;
         break;
@@ -37986,13 +38617,16 @@ function countAnthropicOptionalAlignments(plan, base, wire, compare, reminders,
 function piPreparedStructureMismatch(payload, prepared, onImageTrim) {
   const plan = prepared && dateReminderPlans.get(prepared);
   try {
-    const messages = plan ? object11(payload)?.messages : undefined;
+    const body = plan ? object11(payload) : undefined;
+    const messages = body?.messages ?? body?.input;
     if (Array.isArray(messages)) {
       for (const value of messages) {
         const message = object11(value);
         if (message?.role !== "system" && message?.role !== "developer")
           break;
-        if (piDateReminderWireText(message.content, plan?.cwd) !== undefined)
+        const content = message.content;
+        const inputText = Array.isArray(content) && content.length === 1 && object11(content[0])?.type === "input_text" ? object11(content[0])?.text : undefined;
+        if (piDateReminderWireText(content, plan?.cwd) !== undefined || piDateReminderText(inputText, plan?.cwd))
           return "comparison=role";
       }
     }
@@ -40059,9 +40693,9 @@ function createPiFallbackIndex() {
 }
 
 // src/pi-fit-reclaim.ts
-import { createHash as createHash12, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash14, randomUUID as randomUUID4 } from "node:crypto";
 var pendingInput = new Set;
-var KEY2 = "piUpperEstimateReclaim";
+var KEY3 = "piUpperEstimateReclaim";
 function piFitOverflowPossible(args) {
   if (!args.hasUI && args.inputTokens <= 0 || args.recoveryArmed || args.forceMaterialization || args.imported || args.coldInjection || args.cacheBusting || pendingInput.has(args.sessionId))
     return true;
@@ -40095,7 +40729,7 @@ function piUpperReclaimCursor(args) {
     sessionId: args.sessionId,
     modelKey: args.modelKey,
     contextWindow: args.contextWindow ?? null,
-    head: head ? createHash12("sha256").update(JSON.stringify([
+    head: head ? createHash14("sha256").update(JSON.stringify([
       Buffer.from(head.cachedM0Bytes ?? []).toString("base64"),
       Buffer.from(head.cachedM1Bytes ?? []).toString("base64"),
       head.cachedM0MuralDataUrl ?? null
@@ -40113,18 +40747,18 @@ function canReclaim(previous, cursor) {
 function shouldReclaimPiUpperEstimate(db, cursor) {
   if (!cursor)
     return false;
-  return canReclaim(claimFrom(readReplayEnvelope(db, cursor.sessionId)[KEY2], cursor.sessionId), cursor);
+  return canReclaim(claimFrom(readReplayEnvelope(db, cursor.sessionId)[KEY3], cursor.sessionId), cursor);
 }
 function reservePiUpperEstimateReclaim(db, cursor) {
   const reservation = randomUUID4();
   return db.transaction(() => {
     let claimed = false;
     if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-      claimed = canReclaim(claimFrom(doc[KEY2], cursor.sessionId), cursor);
+      claimed = canReclaim(claimFrom(doc[KEY3], cursor.sessionId), cursor);
       if (!claimed)
         return false;
       doc.version = 2;
-      doc[KEY2] = { ...cursor, reservation };
+      doc[KEY3] = { ...cursor, reservation };
       return true;
     }))
       throw new Error("Could not reserve upper-estimate reclaim");
@@ -40136,10 +40770,10 @@ function recordPiUpperEstimateReclaim(db, cursor, reservation) {
   if (!owner)
     return;
   if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-    if (claimFrom(doc[KEY2], cursor.sessionId)?.reservation !== owner)
+    if (claimFrom(doc[KEY3], cursor.sessionId)?.reservation !== owner)
       return false;
     doc.version = 2;
-    doc[KEY2] = cursor;
+    doc[KEY3] = cursor;
     return true;
   }))
     throw new Error("Could not persist upper-estimate reclaim cursor");
@@ -40148,19 +40782,19 @@ function recordPiUpperEstimateReclaim(db, cursor, reservation) {
 function releasePiUpperEstimateReclaim(db, cursor, reservation) {
   withoutSqliteTransformPass2(() => withSqliteTurnDeadline2(() => 0, () => {
     if (!updateReplayDocument(db, cursor.sessionId, (doc) => {
-      if (claimFrom(doc[KEY2], cursor.sessionId)?.reservation !== reservation)
+      if (claimFrom(doc[KEY3], cursor.sessionId)?.reservation !== reservation)
         return false;
-      delete doc[KEY2];
+      delete doc[KEY3];
       return true;
     }))
       throw new Error("Could not release upper-estimate reclaim");
   }));
 }
 function resetPiUpperEstimateReclaim(db, sessionId) {
-  if (!claimFrom(readReplayEnvelope(db, sessionId)[KEY2], sessionId))
+  if (!claimFrom(readReplayEnvelope(db, sessionId)[KEY3], sessionId))
     return;
   if (!updateReplayDocument(db, sessionId, (doc) => {
-    delete doc[KEY2];
+    delete doc[KEY3];
     return true;
   }))
     throw new Error("Could not clear upper-estimate reclaim cursor");
@@ -40182,7 +40816,7 @@ async function waitForPiHistorianInTurn(sessionId, remainingMs, wait) {
 }
 
 // src/pi-lkg-fit-envelope.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
   try {
     if (!modelKey || typeof pi.getAllTools !== "function")
@@ -40244,7 +40878,7 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
       refusalToolDefinitionTokens,
       toolDefinitionsMeasured: refusalToolDefinitionTokens !== undefined,
       envelopeBytes: Buffer.byteLength(envelopeJson),
-      envelopeSignature: activeNames ? createHash13("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 {
@@ -40253,13 +40887,13 @@ function readPiLkgFitEnvelope(ctx, pi, modelKey, frozen, wireSchema) {
 }
 
 // src/pi-message-identity.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 
 // src/pi-tool-identity.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 
 // src/served-array-ledger.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import {
   closeSync as closeSync2,
   fstatSync,
@@ -40269,7 +40903,7 @@ import {
   readSync as readSync2,
   statSync as statSync6
 } from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // src/pi-served-identities.ts
 class PiServedEnvelopeUnavailable extends Error {
@@ -40537,20 +41171,20 @@ function getPiLastServedArray(sessionId) {
   return previous ? `[${previous.serializedMessages.join(",")}]` : undefined;
 }
 function sha256(value) {
-  return createHash14("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);
   return `${readable || "session"}-${sha256(sessionId).slice(0, 12)}`;
 }
 function getPiServedArrayLedgerPath(sessionId, storageDir = getMagicContextStorageDir()) {
-  return path12.join(storageDir, LEDGER_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+  return path13.join(storageDir, LEDGER_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
 function getPiServedArrayBodyPath(sessionId, storageDir = getMagicContextStorageDir()) {
-  return path12.join(storageDir, BODY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+  return path13.join(storageDir, BODY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
 function getPiServedTagNumbersPath(sessionId, storageDir = getMagicContextStorageDir()) {
-  return path12.join(storageDir, IDENTITY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
+  return path13.join(storageDir, IDENTITY_DIRECTORY, `${safeSessionFileStem(sessionId)}.jsonl`);
 }
 function fullBodyCaptureEnabled() {
   const value = process.env[PI_SERVED_ARRAY_BODY_CAPTURE_ENV]?.trim().toLowerCase();
@@ -40599,7 +41233,7 @@ function recordWriteFailure(error) {
 }
 function appendPendingLines(filePath, lines) {
   try {
-    ensureStorageDirectorySync(path12.dirname(filePath));
+    ensureStorageDirectorySync(path13.dirname(filePath));
     repairZeroTail(filePath);
     writeStorageFileSync(filePath, lines.join(""), {
       encoding: "utf8",
@@ -40706,7 +41340,7 @@ function capturePiServedArray(sessionId, messages, options = {}) {
     const identityPath = getPiServedTagNumbersPath(sessionId, storageDir);
     if (newNumbers.length) {
       identityPersistenceFailed = true;
-      ensureStorageDirectorySync(path12.dirname(identityPath));
+      ensureStorageDirectorySync(path13.dirname(identityPath));
       options.assertCurrentPass?.();
       repairZeroTail(identityPath, !!options.db);
       writeStorageFileSync(identityPath, `${JSON.stringify({ version: 1, session_id: sessionId, tag_numbers: newNumbers })}
@@ -40822,7 +41456,7 @@ function readPiServedCachedArray(sessionId) {
   const memory = getPiLastServedArray(sessionId);
   const slot = memory === undefined ? getSlot(sessionId) : undefined;
   const jsonPrefix = memory ?? slot?.jsonPrefix;
-  if (jsonPrefix === undefined || createHash15("sha256").update(jsonPrefix).digest("hex") !== getPiLastServedDigest(sessionId))
+  if (jsonPrefix === undefined || createHash17("sha256").update(jsonPrefix).digest("hex") !== getPiLastServedDigest(sessionId))
     return;
   let parsed;
   try {
@@ -40846,7 +41480,7 @@ function piMessageEntryFingerprint(message) {
   const m = message;
   if (typeof m.role !== "string")
     return null;
-  const contentHash = createHash16("sha256").update(stableStringify(m.content)).digest("hex");
+  const contentHash = createHash18("sha256").update(stableStringify(m.content)).digest("hex");
   return JSON.stringify([
     typeof m.responseId === "string" ? m.responseId : null,
     typeof m.timestamp === "number" || typeof m.timestamp === "string" ? m.timestamp : null,
@@ -40898,6 +41532,83 @@ function piCachedMessageSurvivor(sessionId, fingerprint, ordinal, rows) {
   return carriers.length === 1 ? winner.tagNumber : undefined;
 }
 
+// src/pi-overflow-recovery.ts
+function piRecoveryFitCalibration(calibration) {
+  return calibration.seeded ? calibration : { toolsRatio: UNKNOWN_FIT_RATIO, proseRatio: UNKNOWN_FIT_RATIO };
+}
+function piRecoveryToolImageTokens(messages) {
+  const counts = new Map;
+  const seen = new Set;
+  for (const value of messages) {
+    const message = value;
+    if (message?.role !== "toolResult" || !message.toolCallId || !Array.isArray(message.content))
+      continue;
+    if (seen.has(message.toolCallId)) {
+      counts.delete(message.toolCallId);
+      continue;
+    }
+    seen.add(message.toolCallId);
+    for (const part of message.content) {
+      if (part?.type === "image")
+        counts.set(message.toolCallId, (counts.get(message.toolCallId) ?? 0) + estimateTokens(JSON.stringify(part)));
+    }
+  }
+  return counts;
+}
+function estimatePiOverflowRecoveryInputTokens(messages, envelope) {
+  if (!envelope || !estimatePiOutgoingInputTokens([], envelope).trusted)
+    return;
+  const raw = tokenizePiMessages([...messages]);
+  for (const value of messages) {
+    if (!value || typeof value !== "object")
+      return;
+    const message = value;
+    if (message.role === "system") {
+      if (typeof message.content === "string")
+        continue;
+      if (!Array.isArray(message.content) || !message.content.every((part) => part?.type === "text" && typeof part.text === "string"))
+        return;
+      continue;
+    }
+    if (!["user", "assistant", "toolResult", "custom"].includes(message.role ?? ""))
+      return;
+    if (typeof message.content === "string")
+      continue;
+    if (!Array.isArray(message.content))
+      return;
+    for (const value of message.content) {
+      if (!value || typeof value !== "object")
+        return;
+      const part = value;
+      if (part.type === "image") {
+        if (typeof part.data !== "string")
+          return;
+        const delta = estimateTokens(JSON.stringify(part)) - PI_IMAGE_TOKENS;
+        if (message.role === "toolResult")
+          raw.toolCall += delta;
+        else
+          raw.conversation += delta;
+      } else if (!["text", "thinking", "redacted_thinking", "toolCall"].includes(part.type ?? ""))
+        return;
+    }
+  }
+  return providerMass({
+    system: envelope.systemTokens,
+    tools: envelope.toolDefinitionTokens + raw.toolCall,
+    prose: raw.conversation
+  }, envelope.calibration ?? calibrationForModelKey(envelope.modelKey), true);
+}
+function resolvePiOverflowRecoveryUsage(args) {
+  if (!args.pricedPass || !args.providerOverflow || args.usage.inputTokens > 0)
+    return args.usage;
+  return resolveUnknownUsageFromWireEstimate({
+    usage: args.usage,
+    pricedPass: args.pricedPass,
+    wireEstimateTokens: estimatePiOverflowRecoveryInputTokens(args.messages, args.envelope),
+    usableHardLimit: args.usableHardLimit
+  });
+}
+
 // src/pi-pressure.ts
 var MAX_UNKNOWN_PI_INPUT_TOKENS = 3000000;
 function piPressureEvidenceLimit(geometry) {
@@ -43526,7 +44237,8 @@ function convertLocatedPiUserEntry(branchEntries, messageId, ordinalOffset = 0)
       const converted = convertEntriesToRawMessages(branchEntries.slice(start, index + 1)).find((message) => message.id === messageId);
       return converted ? { ...converted, ordinal: rawOrdinal } : null;
     }
-    pendingToolStart = -1;
+    if (role === "user" || role === "assistant")
+      pendingToolStart = -1;
   }
   return null;
 }
@@ -44894,16 +45606,18 @@ function adoptPiFallbackTags(db, sessionId, tagger, fingerprintById, options = {
 var EMPTY_PI_HISTORIAN_STATE_SNAPSHOT = {
   detectedContextLimit: 0,
   needsEmergencyRecovery: false,
+  emergencyRecoveryOrigin: null,
   historianFailureCount: 0
 };
 function loadPiHistorianStateSnapshot(db, sessionId) {
-  const row = db.prepare(`SELECT detected_context_limit, needs_emergency_recovery,
+  const row = db.prepare(`SELECT detected_context_limit, needs_emergency_recovery, emergency_recovery_origin,
 			        historian_failure_count
 			   FROM session_meta
 			  WHERE session_id = ?`).get(sessionId);
   return {
     detectedContextLimit: typeof row?.detected_context_limit === "number" && row.detected_context_limit > 0 ? row.detected_context_limit : 0,
     needsEmergencyRecovery: typeof row?.needs_emergency_recovery === "number" && row.needs_emergency_recovery > 0,
+    emergencyRecoveryOrigin: row?.emergency_recovery_origin === "provider_overflow" || row?.emergency_recovery_origin === "proactive_model_shrink" ? row.emergency_recovery_origin : null,
     historianFailureCount: typeof row?.historian_failure_count === "number" && row.historian_failure_count >= 0 ? row.historian_failure_count : 0
   };
 }
@@ -44926,6 +45640,13 @@ function registerPiContextHandler(pi, baseOptions) {
     }
     return s;
   };
+  pi.on("tool_call", (event, ctx) => {
+    if (event.toolName !== "ctx_reduce")
+      return;
+    const sessionId = resolveSessionId2(ctx);
+    if (sessionId)
+      trackPiDropLeaf(baseOptions.db, sessionId, ctx.sessionManager.getLeafId());
+  });
   pi.on("session_tree", (event, ctx) => {
     if (event.oldLeafId === event.newLeafId)
       return;
@@ -45274,6 +45995,7 @@ function registerPiContextHandler(pi, baseOptions) {
           commitPiCompactionModeRecord(options.db, sessionId, compactionTransition.recordToWrite);
         }
       }
+      const usageResetAfterRefusal = shouldResetRefusedUsage(options.db, sessionId, sessionMetaForUsage);
       const usageReset = {
         lastContextPercentage: 0,
         lastInputTokens: 0,
@@ -45296,8 +46018,8 @@ function registerPiContextHandler(pi, baseOptions) {
         sessionMetaForUsage.lastInputTokens = 0;
         sessionMetaForUsage.observedSafeInputTokens = 0;
         sessionMetaForUsage.cacheAlertSent = false;
-      } else if (isFirstContextPassForSession && sessionMetaForUsage.lastContextPercentage > 0) {
-        sessionLog2(sessionId, `transform: first pass reset — percentage=${sessionMetaForUsage.lastContextPercentage.toFixed(1)}% tokens=${sessionMetaForUsage.lastInputTokens} — clearing stale usage state`);
+      } else if ((isFirstContextPassForSession || usageResetAfterRefusal) && sessionMetaForUsage.lastContextPercentage > 0) {
+        sessionLog2(sessionId, `transform: ${isFirstContextPassForSession ? "first pass" : "refused turn recovery"} reset — percentage=${sessionMetaForUsage.lastContextPercentage.toFixed(1)}% tokens=${sessionMetaForUsage.lastInputTokens} — clearing stale usage state`);
         updateSessionMeta(options.db, sessionId, {
           lastContextPercentage: 0,
           lastInputTokens: 0
@@ -45312,7 +46034,7 @@ function registerPiContextHandler(pi, baseOptions) {
         usagePercentage = sessionMetaForUsage.lastContextPercentage;
         usageInputTokens = sessionMetaForUsage.lastInputTokens;
         usedPersistedUsage = true;
-      } else {
+      } else if (!usageResetAfterRefusal) {
         usagePercentage = typeof piUsage?.percent === "number" ? piUsage.percent : 0;
         usageInputTokens = typeof piUsage?.tokens === "number" ? piUsage.tokens : 0;
       }
@@ -45380,7 +46102,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       let fallbackInputTokens;
       const suspectReading = Math.max(usageInputTokens, piUsage?.tokens ?? 0);
-      if (suspectReading > providerInputLimit || piProviderUsageWasRejected(sessionId)) {
+      if (usageResetAfterRefusal || suspectReading > providerInputLimit || piProviderUsageWasRejected(sessionId)) {
         if (suspectReading > providerInputLimit)
           noteRejectedPiUsage(sessionId, suspectReading, providerInputLimit, "transform");
         const replay = !lkgCompactionOff && lkgPassSnapshot ? lkgCoordinator.replay(lkgPassSnapshot, (id) => ctx.sessionManager.getEntry?.(id)?.parentId) : undefined;
@@ -45397,7 +46119,7 @@ function registerPiContextHandler(pi, baseOptions) {
         persistedFromLive: !usedPersistedUsage,
         persistedPercentage: usagePercentage,
         persistedInputTokens: usageInputTokens,
-        liveInputTokens: piUsage?.tokens,
+        liveInputTokens: usageResetAfterRefusal ? undefined : piUsage?.tokens,
         usableContextLimit: usageContextLimit
       }));
       const realUsagePercentageBeforeEmergencyBump = usagePercentage;
@@ -45527,6 +46249,8 @@ function registerPiContextHandler(pi, baseOptions) {
         maintainExecuteFloorMark(options.db, sessionId, promptId, usagePercentage < effectiveExecuteThresholdPercentage);
       }
       const pipelineArgs = {
+        providerOverflowRecovery: emergencyRecoveryArmed && historianStateForPass.emergencyRecoveryOrigin === "provider_overflow",
+        dropBranchEntries: branchEntries ?? undefined,
         recoveryPrefix: recovery.prefix,
         recoveryRebuildReason: recovery.rebuildReason,
         assertCurrentPass,
@@ -45803,6 +46527,21 @@ function registerPiContextHandler(pi, baseOptions) {
           });
         }
       }
+      if (options.autoSearch && !options.autoSearch.enabled && !options.compactionOff && result.prefixMutationAllowed) {
+        await runAutoSearchHintForPi({
+          sessionId,
+          db: options.db,
+          messages: outputMessages,
+          entryIds: strictEntryIds,
+          entryIdByRef: result.postCommitEntryIdByRef,
+          options: {
+            enabled: false,
+            scoreThreshold: options.autoSearch.scoreThreshold,
+            minPromptChars: options.autoSearch.minPromptChars,
+            projectPath: projectIdentity
+          }
+        });
+      }
       logTransformTiming(sessionId, "autoSearch", tAutoSearch);
       const tTodoCapture = performance.now();
       const injectTodo = () => {
@@ -45887,100 +46626,102 @@ function registerPiContextHandler(pi, baseOptions) {
         if (result.syntheticLeadingCount < 0)
           result.syntheticLeadingCount = prefix.length;
       }
-      const tChannelAccounting = performance.now();
-      try {
-        const sessionMetaForCh1 = sessionMeta;
-        if (!options.compactionOff && !sessionMetaForCh1.isSubagent) {
-          const { tags, protectedTagNumbers, pendingDropTagNumbers } = result.channelBaselineSnapshot;
-          const stableId = (message) => message && typeof message === "object" ? result.postCommitEntryIdByRef.get(message) : undefined;
-          const hygieneCalibration = sessionDecisionCalibration(options.db, sessionId);
-          const hygieneUnitsVersion = transitionSessionHygieneUnits(options.db, sessionId, result.bustedThisPass, hygieneCalibration);
-          const previousBaseline = getPiChannel1Baseline(sessionId);
-          const baseline = refreshPiTailHygieneBaseline({
-            messages: outputMessages,
-            providerApi: ctx.model?.api,
-            tags,
-            tagCacheKey: result.channelBaselineSnapshot.tagCacheKey,
-            protectedTagNumbers,
-            protectedTools: options.protectedTools,
-            pendingDropTagNumbers,
-            stableId,
-            protectedToolTags: protectedToolTagNumbers(result.channelBaselineSnapshot.activeTags, options.protectedTools),
-            syntheticLeadingCount: result.syntheticLeadingCount,
-            cacheBusting: result.bustedThisPass,
-            previous: previousBaseline,
-            calibration: hygieneUnitsVersion >= HYGIENE_PROVIDER_UNITS_VERSION ? hygieneCalibration : undefined,
-            hygieneUnitsVersion
-          });
-          const effective = effectivePiTailHygiene(baseline);
-          if (baseline.lastPrefixMismatch) {
-            sessionLog2(sessionId, formatTailHygienePrefixMismatch(baseline.lastPrefixMismatch, baseline.baselineGeneration));
-          }
-          const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(options.db, sessionId, effective.u) : getChannel1NudgeState(options.db, sessionId);
-          baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
-            pending: durableGrace.postReduceGracePending === true,
-            baselineU: durableGrace.postReduceGraceBaselineU,
-            preReduceLevel: durableGrace.postReduceGracePreLevel ?? durableGrace.level
-          } : undefined;
-          const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags2(options.db, sessionId, protectedTagNumbers);
-          const channelState = {
-            ...baseline,
-            usableWindow: usageContextLimit ?? 0,
-            realUserTurnCount: baseline.realUserTurnCount,
-            reducedSinceRefresh: false,
-            agentDropsAppliedThisPass: result.agentDropsAppliedThisPass,
-            oldestReclaimableToolTags
-          };
-          setPiChannel1Baseline(sessionId, channelState);
-          const channel2Evaluation = evaluateChannel2(channelState);
-          if (channel2Evaluation.evaluable) {
-            try {
-              rearmChannel2AfterMeasuredCollapse({
-                db: options.db,
-                sessionId,
-                baseline: channelState,
-                rebuilding: result.bustedThisPass,
-                previous: previousBaseline
-              });
-            } catch (error) {
-              sessionLog2(sessionId, `pi channel2 U-collapse reset failed: ${error instanceof Error ? error.message : String(error)}`);
+      const publishFinalRequestAccounting = () => {
+        const tChannelAccounting = performance.now();
+        try {
+          const sessionMetaForCh1 = sessionMeta;
+          if (!options.compactionOff && !sessionMetaForCh1.isSubagent) {
+            const { tags, protectedTagNumbers, pendingDropTagNumbers } = result.channelBaselineSnapshot;
+            const stableId = (message) => message && typeof message === "object" ? result.postCommitEntryIdByRef.get(message) : undefined;
+            const hygieneCalibration = sessionDecisionCalibration(options.db, sessionId);
+            const hygieneUnitsVersion = transitionSessionHygieneUnits(options.db, sessionId, result.bustedThisPass, hygieneCalibration);
+            const previousBaseline = getPiChannel1Baseline(sessionId);
+            const baseline = refreshPiTailHygieneBaseline({
+              messages: outputMessages,
+              providerApi: ctx.model?.api,
+              tags,
+              tagCacheKey: result.channelBaselineSnapshot.tagCacheKey,
+              protectedTagNumbers,
+              protectedTools: options.protectedTools,
+              pendingDropTagNumbers,
+              stableId,
+              protectedToolTags: protectedToolTagNumbers(result.channelBaselineSnapshot.activeTags, options.protectedTools),
+              syntheticLeadingCount: result.syntheticLeadingCount,
+              cacheBusting: result.bustedThisPass,
+              previous: previousBaseline,
+              calibration: hygieneUnitsVersion >= HYGIENE_PROVIDER_UNITS_VERSION ? hygieneCalibration : undefined,
+              hygieneUnitsVersion
+            });
+            const effective = effectivePiTailHygiene(baseline);
+            if (baseline.lastPrefixMismatch) {
+              sessionLog2(sessionId, formatTailHygienePrefixMismatch(baseline.lastPrefixMismatch, baseline.baselineGeneration));
             }
-            if (channel2Evaluation.shouldTrigger) {
-              casChannel2NudgeState(options.db, sessionId, "", "pending");
-            } else {
-              casChannel2NudgeState(options.db, sessionId, "pending", "");
+            const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(options.db, sessionId, effective.u) : getChannel1NudgeState(options.db, sessionId);
+            baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
+              pending: durableGrace.postReduceGracePending === true,
+              baselineU: durableGrace.postReduceGraceBaselineU,
+              preReduceLevel: durableGrace.postReduceGracePreLevel ?? durableGrace.level
+            } : undefined;
+            const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags2(options.db, sessionId, protectedTagNumbers);
+            const channelState = {
+              ...baseline,
+              usableWindow: usageContextLimit ?? 0,
+              realUserTurnCount: baseline.realUserTurnCount,
+              reducedSinceRefresh: false,
+              agentDropsAppliedThisPass: result.agentDropsAppliedThisPass,
+              oldestReclaimableToolTags
+            };
+            setPiChannel1Baseline(sessionId, channelState);
+            const channel2Evaluation = evaluateChannel2(channelState);
+            if (channel2Evaluation.evaluable) {
+              try {
+                rearmChannel2AfterMeasuredCollapse({
+                  db: options.db,
+                  sessionId,
+                  baseline: channelState,
+                  rebuilding: result.bustedThisPass,
+                  previous: previousBaseline
+                });
+              } catch (error) {
+                sessionLog2(sessionId, `pi channel2 U-collapse reset failed: ${error instanceof Error ? error.message : String(error)}`);
+              }
+              if (channel2Evaluation.shouldTrigger) {
+                casChannel2NudgeState(options.db, sessionId, "", "pending");
+              } else {
+                casChannel2NudgeState(options.db, sessionId, "pending", "");
+              }
             }
+            assertTailHygieneLastWriter = () => assertPiTailHygieneContentUnchanged({
+              messages: outputMessages,
+              tags,
+              protectedTagNumbers,
+              pendingDropTagNumbers,
+              stableId,
+              syntheticLeadingCount: result.syntheticLeadingCount,
+              expectedSignature: baseline.contentSignature
+            });
+          } else {
+            clearPiChannel1State(sessionId);
           }
-          assertTailHygieneLastWriter = () => assertPiTailHygieneContentUnchanged({
-            messages: outputMessages,
-            tags,
-            protectedTagNumbers,
-            pendingDropTagNumbers,
-            stableId,
-            syntheticLeadingCount: result.syntheticLeadingCount,
-            expectedSignature: baseline.contentSignature
-          });
-        } else {
-          clearPiChannel1State(sessionId);
+        } catch (err) {
+          const stale = getPiChannel1Baseline(sessionId);
+          if (stale) {
+            stale.evaluable = false;
+            stale.generationInvalidated = true;
+          }
+          sessionLog2(sessionId, `channel1 baseline / channel2 trigger failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-      } catch (err) {
-        const stale = getPiChannel1Baseline(sessionId);
-        if (stale) {
-          stale.evaluable = false;
-          stale.generationInvalidated = true;
+        logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
+        const tWorkMetrics = performance.now();
+        budget.stage = "bookkeeping";
+        try {
+          const metrics = computePiWorkMetrics(outputMessages);
+          setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
+        } catch (err) {
+          sessionLog2(sessionId, `work-metrics update failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-        sessionLog2(sessionId, `channel1 baseline / channel2 trigger failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      logTransformTiming(sessionId, "channelNudgeAccounting", tChannelAccounting);
-      const tWorkMetrics = performance.now();
-      budget.stage = "bookkeeping";
-      try {
-        const metrics = computePiWorkMetrics(outputMessages);
-        setSessionWorkMetrics(options.db, sessionId, metrics.newWorkTokens, metrics.totalInputTokens);
-      } catch (err) {
-        sessionLog2(sessionId, `work-metrics update failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      logTransformTiming(sessionId, "workMetrics", tWorkMetrics);
+        logTransformTiming(sessionId, "workMetrics", tWorkMetrics);
+      };
       const tStableIdSchemePersist = performance.now();
       if (stableIdSchemeCutover && !options.compactionOff) {
         persistStableIdSchemeForRun(options.db, sessionId, {
@@ -46064,6 +46805,18 @@ function registerPiContextHandler(pi, baseOptions) {
           throw contextRefusalError("The request remains over the model window after stripping signed thinking and reclaiming context");
         if (getHarness2() === "pi") {
           const fitCase = classifyPiOutgoingFit(estimate, outgoingFitLimit);
+          const recoverUnknownUsage = usageInputTokens <= 0 && result.prefixBustPermitted && emergencyRecoveryArmed && historianStateForPass.emergencyRecoveryOrigin === "provider_overflow";
+          let unknownUsageRecovered = false;
+          const recoveryUsage = resolvePiOverflowRecoveryUsage({
+            usage: pipelineArgs.contextUsage,
+            pricedPass: result.prefixBustPermitted,
+            providerOverflow: recoverUnknownUsage,
+            messages: outputMessages,
+            envelope,
+            usableHardLimit: outgoingFitLimit
+          });
+          if (recoverUnknownUsage && (!(recoveryUsage.inputTokens > 0) || !((emergencyCeilingTokens ?? 0) > 0) || !Number.isFinite(outgoingFitLimit) || !((outgoingFitLimit ?? 0) > 0)))
+            throw contextRefusalError("Provider overflow recovery has unknown-usage: a complete outgoing request estimate and context limit are required before retrying");
           const currentUpperCursor = () => piUpperReclaimCursor({
             sessionId,
             modelKey: resolvePiContextModelKey(ctx) ?? null,
@@ -46073,24 +46826,25 @@ function registerPiContextHandler(pi, baseOptions) {
             snapshot: lkgPassSnapshot,
             input: inputForFitReclaim ?? event.messages
           });
-          const upperCursor = fitCase === "upper-estimate-pressure" ? currentUpperCursor() : undefined;
+          const upperCursor = fitCase === "upper-estimate-pressure" && !recoverUnknownUsage ? currentUpperCursor() : undefined;
           if (fitCase === "over-window-proof") {
             requestPiFitReclaimInput(sessionId);
           }
           if (fitCase === "fits-or-unknown")
             clearPiFitReclaimInput(sessionId);
           const upperPassEligible = schedulerDecision === "execute" || result.bustedThisPass || result.prefixRebuildAlreadyPriced || isCacheBusting || forceMaterialization || isEmergency;
-          const reclaimHeld = fitCase === "upper-estimate-pressure" && (result.strictThinkingKept || !upperPassEligible || !shouldReclaimPiUpperEstimate(options.db, upperCursor));
+          const reclaimHeld = !recoverUnknownUsage && fitCase === "upper-estimate-pressure" && (result.strictThinkingKept || !upperPassEligible || !shouldReclaimPiUpperEstimate(options.db, upperCursor));
           if (reclaimHeld)
             sessionLog2(sessionId, "outgoing fit: upper-estimate-pressure; reclaim held by signed prefix, deferred pass or used session latch");
           if (fitCase === "upper-estimate-pressure" && !reclaimHeld && !inputForFitReclaim)
             requestPiFitReclaimInput(sessionId);
-          if (fitCase !== "fits-or-unknown" && !reclaimHeld && !fitReclaimedThisPass && !inputForFitReclaim)
+          if ((fitCase !== "fits-or-unknown" || recoverUnknownUsage) && !reclaimHeld && !fitReclaimedThisPass && !inputForFitReclaim)
             inputForFitReclaim = restorePiLkgInputForFit(lkgPassSnapshot, branchEntries);
-          if (fitCase !== "fits-or-unknown" && !reclaimHeld && !fitReclaimedThisPass && inputForFitReclaim) {
+          if ((fitCase !== "fits-or-unknown" || recoverUnknownUsage) && !reclaimHeld && !fitReclaimedThisPass && inputForFitReclaim) {
             const reservation = upperCursor ? reservePiUpperEstimateReclaim(options.db, upperCursor) : undefined;
             if (!upperCursor || reservation) {
               let reclaimCompleted = false;
+              const recoveryRetryStart = performance.now();
               try {
                 sessionLog2(sessionId, `outgoing fit: ${fitCase}; attempting emergency reclaim`);
                 if (fitCase === "over-window-proof" && !ctx.hasUI && historian) {
@@ -46133,7 +46887,7 @@ function registerPiContextHandler(pi, baseOptions) {
                   schedulerDecision: "execute",
                   schedulerDeferReason: null,
                   forceMaterialization: true,
-                  upperEstimateOnly: fitCase === "upper-estimate-pressure",
+                  upperEstimateOnly: !recoverUnknownUsage && fitCase === "upper-estimate-pressure",
                   forceSignedRebuildForFit: fitCase === "over-window-proof",
                   isCacheBusting: historyRefreshSessions.has(sessionId) || deferredHistoryRefreshSessions.has(sessionId),
                   injectionPassSnapshot: options.injection ? createPiM0M1PassSnapshot({
@@ -46142,13 +46896,13 @@ function registerPiContextHandler(pi, baseOptions) {
                     compactionOff: false,
                     sessionMeta: freshMeta
                   }) : undefined,
-                  contextUsage: {
-                    percentage: usagePercentage,
-                    inputTokens: usageInputTokens
-                  }
+                  contextUsage: recoverUnknownUsage ? recoveryUsage : pipelineArgs.contextUsage
                 }));
                 outputMessages = result.messages;
                 observePipelineResultForTests(sessionId, result);
+                unknownUsageRecovered = recoverUnknownUsage;
+                if (recoverUnknownUsage)
+                  sessionLog2(sessionId, `overflow unknown-usage recovery: inputTokens=${recoveryUsage.inputTokens} retryMs=${(performance.now() - recoveryRetryStart).toFixed(1)}`);
                 injectTodo();
                 if (upperCursor)
                   recordPiUpperEstimateReclaim(options.db, currentUpperCursor() ?? upperCursor, reservation);
@@ -46170,6 +46924,8 @@ function registerPiContextHandler(pi, baseOptions) {
               }
             }
           }
+          if (recoverUnknownUsage && !unknownUsageRecovered)
+            throw contextRefusalError("Provider overflow recovery has unknown-usage: a pristine request is required for emergency reclaim");
         }
         const refusal = outgoingContextRefusal(estimate, rawFallbackLimit, protectedToolTokenCount(getActiveTagsBySession2(options.db, sessionId), options.protectedTools, envelope ? calibrationForModelKey(envelope.modelKey) : undefined));
         if (refusal)
@@ -46177,6 +46933,7 @@ function registerPiContextHandler(pi, baseOptions) {
         if (getHarness2() === "pi" && classifyPiOutgoingFit(estimate, outgoingFitLimit) === "over-window-proof")
           throw new PiDegradedPassError("outgoing-over-window");
       }
+      publishFinalRequestAccounting();
       let serializedOutput;
       let numbersCommitted = false;
       budget.stage = "LKG/served publication";
@@ -46400,6 +47157,8 @@ function registerPiContextHandler(pi, baseOptions) {
       const sessionId = resolveSessionId2(ctx);
       if (!sessionId)
         return;
+      if (!budget.sideTurn)
+        recordUsageRefusal(baseOptions.db, sessionId);
       withoutSqliteTransformPass2(() => setImmediate(() => {
         if (!isCurrent())
           return;
@@ -46486,6 +47245,7 @@ function ensureRunnablePiBoundaryForTests(snapshot) {
     protectedTailStart: endOrdinal,
     eligibleEndOrdinal: endOrdinal,
     trueRawEligibleTokens: Math.max(1, snapshot.trueRawEligibleTokens),
+    summaryRemovedEligibleTokens: Math.max(1, snapshot.summaryRemovedEligibleTokens),
     rawRangeFingerprint: ""
   };
 }
@@ -47091,6 +47851,10 @@ async function runPipeline(args) {
   args.assertCurrentPass?.();
   if (args.compactionOff)
     return runCompactionOffPipeline(args);
+  const dropBranchEntries = args.dropBranchEntries;
+  const dropBranchIds = dropBranchEntries ? piDropBranchIds(dropBranchEntries) : null;
+  trackPiDropLeaf(args.db, args.sessionId, dropBranchIds ? [...dropBranchIds].at(-1) ?? null : null);
+  cancelPiAbandonedPendingDrops(args.db, args.sessionId, dropBranchIds);
   const thinkingRecovery = prepareLatestThinkingRecovery({
     db: args.db,
     sessionId: args.sessionId,
@@ -47521,9 +48285,11 @@ async function runPipeline(args) {
   afterFallbackAdoptionForTests?.(args.stableIdSchemeCutover === true);
   const textIdentityPlan = buildPiTextIdentityPlan(args.db, args.sessionId, args.tagger, transcript, args.reusableMessageIds);
   const tTag = performance.now();
+  const strippedSubagentThinking = args.sessionMeta.isSubagent && (!thinkingRecovery.restore || rewritingSignedPrefix) ? frozenBindingEntryIds(args.db, args.sessionId) : new Set;
   const mutationView = transcript.messages.map((message) => ({
     ...message,
-    parts: message.parts
+    parts: message.parts,
+    requiresToolArcSkeleton: strippedSubagentThinking.has(message.info.id ?? "") ? false : message.requiresToolArcSkeleton
   }));
   const recoveryNormalized = !!args.recoveryPrefix && (isCacheBustingPass || identityRebuild);
   const taggingView = args.recoveryPrefix && !recoveryNormalized ? mutationView.filter((message) => !args.recoveryPrefix?.untaggedInputIds.has(message.info.id ?? "")) : mutationView;
@@ -47625,40 +48391,67 @@ async function runPipeline(args) {
       message.content = content;
     });
   }
-  const tLegacyToolConversion = performance.now();
-  if (foldBustsServedPrefixThisPass) {
-    const savedRemovalInputs = nativeRemovalInputs;
-    try {
-      nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
-      let converted = 0;
-      args.db.transaction(() => removalBatch((flush) => {
-        converted = convertLegacyToolSkeletons(args.db, args.sessionId, targets, {
-          prepareRemovals: (rows) => preparePiToolRemovalChecks({
-            db: args.db,
-            rows,
-            targets,
-            messages: args.messages,
-            prepare: transcript.prepareToolRemovalMeasurements
-          }),
-          keepFullDrop: (callId) => nativeRemovalInputs === undefined || callId !== null && authorizePiToolRemoval({
-            db: args.db,
-            sessionId: args.sessionId,
-            callId,
-            saved: nativeRemovalInputs,
-            canApply: false
-          }) === true
-        }).size;
-        flush();
-      })).immediate();
-      if (converted > 0) {
-        sessionLog2(args.sessionId, `pi HARD fold converted ${converted} legacy dropped-tool skeleton(s) to real-or-absent`);
+  const applyExistingToolConversions = () => {
+    const tLegacyToolConversion = performance.now();
+    if (foldBustsServedPrefixThisPass) {
+      const savedRemovalInputs = nativeRemovalInputs;
+      try {
+        nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
+        let converted = 0;
+        args.db.transaction(() => removalBatch((flush) => {
+          converted = convertLegacyToolSkeletons(args.db, args.sessionId, targets, {
+            prepareRemovals: (rows) => preparePiToolRemovalChecks({
+              db: args.db,
+              rows,
+              targets,
+              messages: args.messages,
+              prepare: transcript.prepareToolRemovalMeasurements
+            }),
+            keepFullDrop: (callId) => nativeRemovalInputs === undefined || callId !== null && authorizePiToolRemoval({
+              db: args.db,
+              sessionId: args.sessionId,
+              callId,
+              saved: nativeRemovalInputs,
+              canApply: false
+            }) === true
+          }).size;
+          flush();
+        })).immediate();
+        if (converted > 0) {
+          sessionLog2(args.sessionId, `pi HARD fold converted ${converted} legacy dropped-tool skeleton(s) to real-or-absent`);
+        }
+      } catch (error) {
+        nativeRemovalInputs = savedRemovalInputs;
+        sessionLog2(args.sessionId, `pi legacy dropped-tool skeleton conversion failed (kept legacy bytes): ${error instanceof Error ? error.message : String(error)}`);
       }
-    } catch (error) {
-      nativeRemovalInputs = savedRemovalInputs;
-      sessionLog2(args.sessionId, `pi legacy dropped-tool skeleton conversion failed (kept legacy bytes): ${error instanceof Error ? error.message : String(error)}`);
     }
-  }
-  logTransformTiming(args.sessionId, "convertLegacyToolSkeletons", tLegacyToolConversion);
+    logTransformTiming(args.sessionId, "convertLegacyToolSkeletons", tLegacyToolConversion);
+    if (args.sessionMeta.isSubagent && isCacheBustingPass && !protectedSignedPrefix && !args.compactionOff) {
+      const savedRemovalInputs = nativeRemovalInputs;
+      try {
+        nativeRemovalInputs = savedRemovalInputs && new Map(savedRemovalInputs);
+        const converted = args.db.transaction(() => removalBatch((flush) => {
+          const conversions = prepareAgedToolSkeletonConversions(args.db, args.sessionId, newTargets, {
+            prepareRemovals: (rows) => preparePiToolRemovalChecks({
+              db: args.db,
+              rows,
+              targets: newTargets,
+              messages: args.messages,
+              prepare: transcript.prepareToolRemovalMeasurements
+            })
+          });
+          conversions.persist(args.db);
+          flush();
+          return conversions.converted.size;
+        })).immediate();
+        if (converted > 0)
+          recordFirstApplicationWireEdit(true);
+      } catch (error) {
+        nativeRemovalInputs = savedRemovalInputs;
+        throw error;
+      }
+    }
+  };
   try {
     if (!args.sessionMeta.isSubagent) {
       const hasRecentCommit = detectRecentCommit(args.messages);
@@ -47675,16 +48468,23 @@ async function runPipeline(args) {
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
   const shouldReadPendingOps = !args.compactionOff && (publishedWorkDrainAllowed || args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || foldExecutedThisPass || firstRenderBust);
-  const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
-  const tReclaimDistance = performance.now();
-  const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(mutationView, targets) : [];
-  logTransformTiming(args.sessionId, "toolReclaimDistanceEntries", tReclaimDistance);
-  const protectedToolTags = protectedToolTagNumbers(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTools);
-  for (const number of identityAdoption.protectedTagNumbers)
-    protectedToolTags.add(number);
-  const protectionWindowForPass = getProtectionWindowForSession(args.db, args.sessionId, protectionFloorResolution.floor);
-  const protectedTagNumbersForPass = usesTokenProtection ? protectionWindowForPass.protectedTagNumbers : newestActiveTagNumbersByCount(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTags);
-  const pendingOperationTags = pendingOps.length > 0 ? getTagsForPendingOperations2(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), usesTokenProtection ? 0 : args.protectedTags, RECENT_TOOL_SKELETON_WINDOW) : [];
+  const readPendingDropState = () => {
+    const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
+    const protectedToolTags = protectedToolTagNumbers(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTools);
+    for (const number of identityAdoption.protectedTagNumbers)
+      protectedToolTags.add(number);
+    const protectionWindowForPass = getProtectionWindowForSession(args.db, args.sessionId, protectionFloorResolution.floor);
+    const protectedTagNumbersForPass = usesTokenProtection ? protectionWindowForPass.protectedTagNumbers : newestActiveTagNumbersByCount(getActiveTagsBySession2(args.db, args.sessionId), args.protectedTags);
+    const pendingOperationTags = pendingOps.length > 0 ? getTagsForPendingOperations2(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), usesTokenProtection ? 0 : args.protectedTags, RECENT_TOOL_SKELETON_WINDOW) : [];
+    return {
+      pendingOps,
+      protectedToolTags,
+      protectionWindowForPass,
+      protectedTagNumbersForPass,
+      pendingOperationTags
+    };
+  };
+  const executeReclaimSnapshot = readPendingDropState();
   if (!args.sessionMeta.isSubagent && args.schedulerDecision === "execute") {
     args.evaluateHistorianBeforeReclaim?.({
       activeTags: getActiveTagsBySession2(args.db, args.sessionId),
@@ -47701,12 +48501,12 @@ async function runPipeline(args) {
     reclaimableTokens: estimateExecuteReclaimTokens({
       db: args.db,
       sessionId: args.sessionId,
-      pendingOps,
-      tags: pendingOperationTags,
+      pendingOps: executeReclaimSnapshot.pendingOps,
+      tags: executeReclaimSnapshot.pendingOperationTags,
       targets: newTargets,
       protectedTagIds: new Set([
-        ...protectedTagNumbersForPass,
-        ...protectedToolTags
+        ...executeReclaimSnapshot.protectedTagNumbersForPass,
+        ...executeReclaimSnapshot.protectedToolTags
       ]),
       probePreparation: (targets) => {
         const saved = nativeRemovalInputs;
@@ -47742,6 +48542,23 @@ async function runPipeline(args) {
     stripUnheldSignedTurnOnBust();
     applyTemporalOnRide();
   }
+  if (reconcilePiDropBranches(args.db, args.sessionId, dropBranchIds, isCacheBustingPass && !protectedSignedPrefix)) {
+    args.tagger.cleanup(args.sessionId);
+    args.tagger.initFromDb(args.sessionId, args.db);
+    nativeRemovalInputs = getNativeReplayState(args.db, args.sessionId).toolInputs;
+    recordFirstApplicationWireEdit(true);
+  }
+  applyExistingToolConversions();
+  const {
+    pendingOps,
+    protectedToolTags,
+    protectionWindowForPass,
+    protectedTagNumbersForPass,
+    pendingOperationTags
+  } = readPendingDropState();
+  const tReclaimDistance = performance.now();
+  const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(mutationView, targets) : [];
+  logTransformTiming(args.sessionId, "toolReclaimDistanceEntries", tReclaimDistance);
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
@@ -47882,6 +48699,8 @@ async function runPipeline(args) {
   if (shouldRunHeuristics && args.heuristics) {
     try {
       const tHeuristic = performance.now();
+      const providerOverflow = args.providerOverflowRecovery === true;
+      const recoveryCalibration = sessionDecisionCalibration(args.db, args.sessionId);
       const independentMutationBeforeHeuristics = pendingOpsDidMutate || systemPrefixChangedThisPass || foldBustsServedPrefixThisPass || identityRebuild || firstRenderBust || heldIdleExpiryRebuild;
       if (args.forceMaterialization === true && independentMutationBeforeHeuristics && getEmergencyInputSample(args.db, args.sessionId) > 0) {
         clearEmergencyDropSample(args.db, args.sessionId);
@@ -47899,7 +48718,9 @@ async function runPipeline(args) {
           currentTotalInputTokens: args.contextUsage.inputTokens,
           ceilingTokens: args.emergencyCeilingTokens,
           usagePercentage: args.contextUsage.percentage,
-          passAlreadyPriced: independentMutationBeforeHeuristics
+          passAlreadyPriced: independentMutationBeforeHeuristics,
+          serializedImageTokens: providerOverflow ? piRecoveryToolImageTokens(workingMessages) : undefined,
+          fitCalibration: providerOverflow ? piRecoveryFitCalibration(recoveryCalibration) : undefined
         } : undefined,
         caveman: args.isSubagent ? undefined : args.heuristics?.caveman
       }, activeTags, stableIdResolver));
@@ -48175,6 +48996,13 @@ async function runPipeline(args) {
   const tTranscriptCommit = performance.now();
   transcript.commit();
   logTransformTiming(args.sessionId, "transcriptCommit", tTranscriptCommit);
+  if (applyNativeResponseTagReplayPi({
+    db: args.db,
+    sessionId: args.sessionId,
+    messages: args.messages,
+    canApply: isCacheBustingPass
+  }) > 0)
+    recordFirstApplicationWireEdit(true);
   let nativeInputs;
   let nativeReasoningIds;
   try {