@retaw106/mmc-oc 2.3.0 → 2.4.0

package/dist/{context-wt7g4f8k.js → context-c72brxe5.js}

@@ -34,6 +34,19 @@ import {
   resolveProjectIdentityForSession,
   normalizeStoredProjectPath,
   storedPathBelongsToIdentity,
+  parseProviderModel,
+  modelBodyField,
+  toModelEntry,
+  HiddenCompletionRefusal,
+  HIDDEN_HISTORIAN_AGENT,
+  resolveHistorianStepCap,
+  HIDDEN_RUN_DISPOSED_REASON,
+  noteChildOfDisposedInstance,
+  hiddenChildPermissions,
+  registerHiddenChildAgents,
+  HiddenAgentStepLimit,
+  HiddenChildHook,
+  isNonRetryable,
   V2_MEMORY_CATEGORIES,
   CATEGORY_PRIORITY,
   computeNormalizedHash,
@@ -97,6 +110,7 @@ import {
   HYGIENE_PROVIDER_UNITS_VERSION,
   sessionDecisionCalibration,
   transitionSessionHygieneUnits,
+  readEpochFloorSnapshot,
   getProtectionWindowForSession,
   ReplayDocumentError,
   readReplayEnvelope,
@@ -183,6 +197,7 @@ import {
   clearSession,
   requestPendingMaterialization,
   pendingMaterializationOrigin,
+  hasPendingMaterializationOrigin,
   clearPendingMaterialization,
   recordSystemPromptForRequest,
   recordHeldHeadForRequest,
@@ -242,18 +257,10 @@ import {
   sourceNameForMemory,
   rebaseSessionCoordinatesAsync,
   renderUserFacingFailure,
+  userFacingFailureCode,
   renderCapabilityRefusal,
-  HiddenCompletionRefusal,
-  HIDDEN_HISTORIAN_AGENT,
-  resolveHistorianStepCap,
-  hiddenChildPermissions,
-  registerHiddenChildAgents,
-  HiddenAgentStepLimit,
-  HiddenChildHook,
-  parseProviderModel,
-  toModelEntry,
   ACTIVE_TOOL_IDS,
-  promptSurfaceHashMaterial,
+  systemPromptFingerprint,
   createPromptSurfaceRuntime,
   createPromptSurfaceGuidanceEpochCache,
   getOpenCodeDbPath,
@@ -294,7 +301,7 @@ import {
   recordHighPressureNoEligibleHead,
   getActiveCompartmentRun,
   startCompartmentAgent
-} from "./index-kw21z5pe.js";
+} from "./index-kahkxcqw.js";
 import {
   getHarness,
   getDataDir,
@@ -326,6 +333,16 @@ import {
 import {
   normalizeProtectedToolName,
   mergeProtectedTools,
+  detectLatestTurnThinkingMismatch,
+  isPrefixBoundThinkingModel,
+  detectOverflow,
+  stripWellFormedLeadingTagPrefix,
+  stripPersistedAssistantText,
+  byteSize,
+  stripTagPrefix,
+  peelLeadingMcTagNotation,
+  prependTag,
+  isThinkingPart,
   isRecord,
   protectedToolTagNumbers,
   protectedToolTokenCount,
@@ -335,13 +352,7 @@ import {
   preloadTokenizer,
   estimateTokens,
   estimateFixedPromptTokens,
-  stripWellFormedLeadingTagPrefix,
-  stripPersistedAssistantText,
-  byteSize,
-  stripTagPrefix,
-  peelLeadingMcTagNotation,
-  prependTag,
-  isThinkingPart,
+  currentReclaimableToolOutputCount,
   contentTagOwnerMessageId,
   estimateImageTokensFromDataUrl,
   estimateToolAttachmentImageTokens,
@@ -374,6 +385,7 @@ import {
   getPendingOpsCount,
   clearPendingOps,
   removePendingOp,
+  tagRevisionKey,
   tagIdentityRevisionKey,
   getRecentTagOwnerMessageIds,
   AGE_RECLAIM_MIN_TOKENS,
@@ -390,6 +402,7 @@ import {
   backfillTagTokenCounts,
   insertTag,
   updateTagStatus,
+  markTagDropped,
   markWhitespaceAssistantTagInert,
   getInertWhitespaceAssistantTags,
   getInertWhitespaceAssistantTagsByNumbers,
@@ -431,13 +444,11 @@ import {
   recordToolDefinition,
   getMeasuredToolDefinitionTokens,
   describeFinalWireTail,
+  estimatePartImageTokens,
   estimateMessageTokens,
   wireContentBytes,
   createFinalWireUsageTracker,
   estimateFinalWireInputTokens,
-  detectLatestTurnThinkingMismatch,
-  isPrefixBoundThinkingModel,
-  detectOverflow,
   modelAcceptsEmptyContent,
   isAnthropicFamilyRoute,
   neutralizeDroppedReasoningPart,
@@ -463,9 +474,14 @@ import {
   primeTailRawMessageCache2,
   primeInMemoryTailRawMessageCache2,
   readRawSessionMessageIdOrdinalsForRange2,
+  hasRawSessionMessageById2,
   readRawSessionMessageById2,
   readSessionChunk2
-} from "./index-z2w1eq3y.js";
+} from "./index-48e9znrc.js";
+import {
+  normalizeModelEntry2,
+  resolveHistorianModel2
+} from "./index-azbmnekv.js";
 import {
   getSqliteMemoryStats,
   withSqliteBackgroundWriter,
@@ -476,7 +492,7 @@ import {
   withAsyncPrivilegedWriter,
   indexCoordinationInput,
   withIndexChunk
-} from "./index-czba8tw3.js";
+} from "./index-dwh99z66.js";
 import {
   canonicalModelIdentity,
   piModelRefToCanonical,
@@ -493,7 +509,7 @@ import {
   latestRealUserTurnIdFromOpenCodeDb,
   getMessageTimesFromOpenCodeDb,
   findLastAssistantModelFromOpenCodeDb
-} from "./index-18yrysyj.js";
+} from "./index-ykq24x1n.js";
 import {
   registerNotificationSink2,
   pushNotification2,
@@ -506,10 +522,7 @@ import {
   getErrorMessage,
   flushIgnoredMessages2,
   sendStatusNotification2
-} from "./index-a5mw0xp3.js";
-import {
-  resolveHistorianModel2
-} from "./index-z2g20msd.js";
+} from "./index-r7s7d350.js";
 import {
   logSlowWriteTransaction
 } from "./index-yjv8dpht.js";
@@ -3159,6 +3172,40 @@ function currentPluginConfigReader(directory) {
   return pluginReaders.get(directory);
 }
 
+// src/features/magic-context/memory-maintainer/model-chain.ts
+var MAINTENANCE_MODEL_UNCONFIGURED_MESSAGE = "memory maintenance has no primary model configured — set maintenance.model or historian.model in the user-level mmc config (fallback_models alone does not enable maintenance; the session model is never inherited)";
+function inheritMaintenanceModelConfig(config) {
+  const { maintenance, historian } = config;
+  if (maintenance.model !== undefined || historian?.model === undefined)
+    return maintenance;
+  const entry = typeof historian.model === "string" ? { model: historian.model } : historian.model;
+  return {
+    ...maintenance,
+    model: {
+      ...entry,
+      variant: entry.variant ?? historian.variant,
+      thinking_level: entry.thinking_level ?? historian.thinking_level
+    },
+    fallback_models: maintenance.fallback_models ?? historian.fallback_models
+  };
+}
+function resolveMaintenanceModelChain(config, harness) {
+  const primary = normalizeModelEntry2(config.model, harness);
+  if (!primary)
+    return;
+  const fallbacks = [];
+  for (const entry of config.fallback_models ?? []) {
+    const resolved = normalizeModelEntry2(entry, harness);
+    if (resolved)
+      fallbacks.push(resolved);
+  }
+  return { primary, fallbacks };
+}
+function hasMaintenancePrimary(config) {
+  const primary = toModelEntry(config.model);
+  return primary !== undefined && primary.model.trim().length > 0;
+}
+
 // src/features/magic-context/memory-maintainer/dream-state.ts
 var getDreamStateStatements = new WeakMap;
 var setDreamStateStatements = new WeakMap;
@@ -4500,6 +4547,7 @@ async function executeGuardedRun(opts, holderId, leaseKey, acquisition) {
       pending,
       fullPool: roundState.snapshot,
       shouldContinue: () => meter.shouldContinue(),
+      remainingWallMs: () => Math.max(0, config.budgets.wallMs - meter.getState().spent.wallMs),
       recordUsage: (delta) => meter.recordUsage(delta),
       recordToolStep: () => meter.recordToolStep(),
       refuseToolStep: () => meter.refuseToolStep()
@@ -4798,49 +4846,86 @@ function transcriptFromCompletion(completion, createdAt) {
     }
   ];
 }
-async function runOc2MaintenancePhase(ctx, phase, deps, stageAManifest = "") {
-  if (!deps.executor)
-    return emptyPhaseResult();
-  const agentId = phase === "A" ? MEMORY_MAINTAINER_A_AGENT : MEMORY_MAINTAINER_B_AGENT;
-  const system = phase === "A" ? MEMORY_MAINTAINER_A_SYSTEM_PROMPT : MEMORY_MAINTAINER_B_SYSTEM_PROMPT;
-  const basePrompt = buildPhasePrompt(ctx, phase, deps, stageAManifest);
-  let manifestText = "";
-  let messages;
-  for (let round = 0;round < 2; round += 1) {
-    const decision = ctx.shouldContinue();
-    if (decision === "stop")
-      break;
-    const prompt = decision === "finalize" ? `${MEMORY_MAINTAINER_FINALIZE_INSTRUCTION}
-
-${basePrompt}` : basePrompt;
+async function attemptPhaseModelChain(ctx, phase, executor, deps, agentId, system, prompt) {
+  const chain = [deps.modelChain.primary, ...deps.modelChain.fallbacks];
+  let lastError;
+  for (let index = 0;index < chain.length; index += 1) {
+    const entry = toModelEntry(chain[index]);
+    if (!entry || entry.model.trim().length === 0)
+      continue;
+    if (!parseProviderModel(entry.model)) {
+      if (index === 0) {
+        throw new Error(`memory maintenance: primary model "${entry.model}" is not in provider/model form — the hidden executor cannot use it and no model substitution is allowed`);
+      }
+      log(`[magic-context][maintenance] phase ${phase}: dropping invalid fallback spec: ${entry.model}`);
+      continue;
+    }
+    if (index > 0) {
+      if (ctx.shouldContinue() !== "continue")
+        throw lastError;
+      log(`[magic-context][maintenance] phase ${phase}: switching to fallback model ${entry.model} (attempt ${index + 1}/${chain.length})`);
+    }
     const identity = {
       parentSessionId: deps.parentSessionId(),
       kind: "memory-maintenance",
       agent: agentId,
       system,
-      timeoutMs: deps.budget.wallMs,
+      model: entry,
+      timeoutMs: Math.max(1000, Math.min(deps.budget.wallMs, ctx.remainingWallMs())),
       title: `magic-context-maintainer-${phase.toLowerCase()}`,
       directory: deps.directory() ?? ""
     };
-    const handle = await deps.executor.open(identity);
-    let completion;
+    const handle = await executor.open(identity);
     let promptSettled = false;
     try {
       const request = {
         path: { id: handle.id },
-        body: { parts: [{ type: "text", text: prompt }] }
+        body: {
+          parts: [{ type: "text", text: prompt }],
+          ...modelBodyField(entry)
+        }
       };
-      await deps.executor.attempt(handle, request);
-      completion = await deps.executor.collect(handle, 50);
+      try {
+        await executor.attempt(handle, request);
+      } catch (error) {
+        lastError = error;
+        if (index >= chain.length - 1 || isNonRetryable(error))
+          throw error;
+        log(`[magic-context][maintenance] phase ${phase}: model ${entry.model} failed: ${error instanceof Error ? error.message : String(error)}; trying next fallback`);
+        continue;
+      }
+      const completion = await executor.collect(handle, 50);
       promptSettled = true;
+      return completion;
     } finally {
-      await deps.executor.close(handle, {
+      await executor.close(handle, {
         promptSettled,
         privacySensitive: false,
         context: "memory-maintenance",
         log: (message) => log(`[magic-context][maintenance] ${message}`)
       });
     }
+  }
+  if (lastError !== undefined)
+    throw lastError;
+  return;
+}
+async function runOc2MaintenancePhase(ctx, phase, deps, stageAManifest = "") {
+  if (!deps.executor)
+    return emptyPhaseResult();
+  const agentId = phase === "A" ? MEMORY_MAINTAINER_A_AGENT : MEMORY_MAINTAINER_B_AGENT;
+  const system = phase === "A" ? MEMORY_MAINTAINER_A_SYSTEM_PROMPT : MEMORY_MAINTAINER_B_SYSTEM_PROMPT;
+  const basePrompt = buildPhasePrompt(ctx, phase, deps, stageAManifest);
+  let manifestText = "";
+  let messages;
+  for (let round = 0;round < 2; round += 1) {
+    const decision = ctx.shouldContinue();
+    if (decision === "stop")
+      break;
+    const prompt = decision === "finalize" ? `${MEMORY_MAINTAINER_FINALIZE_INSTRUCTION}
+
+${basePrompt}` : basePrompt;
+    const completion = await attemptPhaseModelChain(ctx, phase, deps.executor, deps, agentId, system, prompt);
     if (completion) {
       const inputTotal = completion.usage.input + completion.usage.cacheRead + completion.usage.cacheWrite;
       ctx.recordUsage({ inputTokens: inputTotal, outputTokens: completion.usage.output });
@@ -4898,9 +4983,18 @@ function createOc2MaintenanceRunFactory(options) {
       if (!options.executor) {
         throw new Error("memory maintenance: no hidden completion executor wired");
       }
+      const chain = resolveMaintenanceModelChain(options.config(), "opencode");
+      if (!chain) {
+        throw new Error(MAINTENANCE_MODEL_UNCONFIGURED_MESSAGE);
+      }
+      const primarySpec = toModelEntry(chain.primary)?.model ?? "";
+      if (!parseProviderModel(primarySpec)) {
+        throw new Error(`memory maintenance: primary model "${primarySpec}" is not in provider/model form — the hidden executor cannot use it and no model substitution is allowed`);
+      }
       const cfg = options.config();
       const phaseDeps = {
         executor: options.executor,
+        modelChain: chain,
         budget: cfg.budgets,
         parentSessionId: () => signals.parentSessionId,
         directory: () => signals.directory,
@@ -6160,6 +6254,20 @@ function resolveTodowriteAvailability(sessionId) {
 }
 
 // src/hooks/magic-context/degraded-pass-refusal.ts
+function describeDegradedPassFailure(site, cause) {
+  const details = [site];
+  const seen = new Set;
+  while (cause !== undefined && cause !== null && !seen.has(cause)) {
+    seen.add(cause);
+    const current = cause;
+    const detail = typeof current.site === "string" ? current.site : typeof current.message === "string" ? current.message : String(cause);
+    if (!details.includes(detail))
+      details.push(detail);
+    cause = current.cause;
+  }
+  return `Magic Context could not safely prepare this turn [${userFacingFailureCode("transform_pass_degraded")}] (${details.join(": ")}). This request was not sent.`;
+}
+
 class DegradedPassRefusalError extends Error {
   site;
   code = "DEGRADED_PASS_REFUSAL";
@@ -6167,7 +6275,7 @@ class DegradedPassRefusalError extends Error {
   estimatedTokens;
   contextLimitTokens;
   constructor(site, options) {
-    super(renderUserFacingFailure("transform_pass_degraded", "plain"), {
+    super(describeDegradedPassFailure(site, options?.cause), {
       cause: options?.cause
     });
     this.site = site;
@@ -8776,7 +8884,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
     setChannel1NudgeState(args.db, sessionId, nextNudgeState);
     return;
   }
-  out.output += buildChannel1Reminder(decision.level, decision.undroppedTokens, reclaimableToolOutputCount(state.baselineParts), state.oldestReclaimableToolTags, decision.sticky);
+  out.output += buildChannel1Reminder(decision.level, decision.undroppedTokens, currentReclaimableToolOutputCount(state), state.oldestReclaimableToolTags, decision.sticky);
   setChannel1NudgeState(args.db, sessionId, {
     ...nextNudgeState,
     ordinal: state.realUserTurnCount
@@ -10008,9 +10116,6 @@ class StorageBusyRefusalError extends Error {
   }
 }
 
-// src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash3 } from "node:crypto";
-
 // src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
 
@@ -10152,6 +10257,90 @@ ${BASE_INTRO(memoryEnabled, temporalAwarenessEnabled)}${cavemanWarning}
 ${SELF_TAG_GUIDANCE}${languageGuidance}`;
 }
 
+// src/features/magic-context/transform-decision-log.ts
+var canonicalReasons = new Set([
+  "system_hash",
+  "model_change",
+  "ttl_idle",
+  "explicit_flush",
+  "max_mutation_id",
+  "first_render",
+  "pressure_refold",
+  "upgrade_state",
+  "cached_m1_missing",
+  "project_change",
+  "compartment_render_epoch",
+  "m1_delta",
+  "ttl_expiry",
+  "epoch_change",
+  "coverage_fold",
+  "profile_transition",
+  "host_compaction"
+]);
+var piReasonAliases = {
+  pending_mutations: "max_mutation_id",
+  renderer_upgrade: "upgrade_state",
+  cache_invalid: "cached_m1_missing",
+  drift: "pressure_refold"
+};
+var sharedReasonAliases = {
+  model_key: "model_change",
+  pressure: "pressure_refold"
+};
+var pendingDecisionBySession = new Map;
+var pendingPiDecisionBySession = new Map;
+var lastBoundMessageIdBySession = new Map;
+var scheduledWriteTokensBySession = new Map;
+var systemHashChangedSessions = new Set;
+var piSystemHashChangedSessions = new Set;
+var unbustedPassBySession = new Map;
+var newestInputAssistantBySession = new Map;
+var stagedV2DecisionBySession = new Map;
+function normalizeMaterializeReason(harness, reason, rematerialized) {
+  const raw = typeof reason === "string" ? reason.trim() : "";
+  if (raw.length > 0) {
+    const alias = sharedReasonAliases[raw] ?? (harness === "pi" ? piReasonAliases[raw] : undefined) ?? undefined;
+    if (alias)
+      return alias;
+    if (canonicalReasons.has(raw))
+      return raw;
+    return null;
+  }
+  return rematerialized ? "pressure_refold" : null;
+}
+function clearOpenCodePendingTransformDecision(sessionId, inputMessages) {
+  pendingDecisionBySession.delete(sessionId);
+  unbustedPassBySession.delete(sessionId);
+  if (!inputMessages)
+    return;
+  let newestAssistant = "";
+  for (const message of inputMessages) {
+    const id = message.info?.id;
+    if (message.info?.role !== "assistant" || typeof id !== "string")
+      continue;
+    if (id > newestAssistant)
+      newestAssistant = id;
+  }
+  newestInputAssistantBySession.set(sessionId, newestAssistant);
+}
+function noteSystemPromptHashChange(sessionId) {
+  systemHashChangedSessions.add(sessionId);
+}
+function noteOpenCodeUnbustedPass(sessionId, decision) {
+  unbustedPassBySession.set(sessionId, decision);
+}
+var IDLE_EXPIRY_REASONS = new Set([
+  "ttl_idle",
+  "ttl_expiry"
+]);
+function recordPendingTransformDecision(sessionId, decision) {
+  if (!decision.bustedThisPass) {
+    pendingDecisionBySession.delete(sessionId);
+    return;
+  }
+  pendingDecisionBySession.set(sessionId, decision);
+}
+
 // src/hooks/magic-context/system-prompt-dates.ts
 function replaceHostDates(prompt, replace) {
   const fields = /<(plugin-env|environment|env)>[\s\S]*?<\/\1>|Today's date: [^\r\n<]+/g;
@@ -10398,7 +10587,7 @@ function createSystemPromptHashHandler(deps) {
     const dates = systemPromptDates(liveSystemContent, stickyDate);
     const currentDate = dates.live;
     const stableCandidate = dates.stable;
-    const stableCandidateHash = createHash3("md5").update(promptSurfaceHashMaterial(stableCandidate, promptSurface.preset)).digest("hex");
+    const stableCandidateHash = systemPromptFingerprint(stableCandidate, promptSurface.preset);
     const contentOrPresetChanged = hasPersistedHash && stableCandidateHash !== previousHash;
     const rewritePermission = systemDateRefreshPermission(deps.historyRefreshSessions, dateRequest);
     let deferredDateRefresh = false;
@@ -10412,7 +10601,7 @@ function createSystemPromptHashHandler(deps) {
         try {
           const content = liveElements.join(`
 `);
-          const hash = createHash3("md5").update(promptSurfaceHashMaterial(content, promptSurface.preset)).digest("hex");
+          const hash = systemPromptFingerprint(content, promptSurface.preset);
           updateSessionMeta(deps.db, sessionId, {
             systemPromptHash: hash,
             cachedM0SystemHash: hash,
@@ -10452,7 +10641,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (!availability.frozen || !modelKey)
       return;
-    const currentHash = createHash3("md5").update(promptSurfaceHashMaterial(systemContent, promptSurface.preset)).digest("hex");
+    const currentHash = systemPromptFingerprint(systemContent, promptSurface.preset);
     recordSystemPromptForRequest(sessionId, currentLkgRequestIdentity(sessionId), currentHash, deps.db, previousHash !== currentHash ? !deps.historyRefreshSessions.has(sessionId) : undefined, deps.historyRefreshSessions, deps.pendingMaterializationSessions);
     if (!sessionMetaEarly) {
       return;
@@ -10460,6 +10649,7 @@ function createSystemPromptHashHandler(deps) {
     const sessionMeta = sessionMetaEarly;
     if (previousHash !== "" && previousHash !== "0" && previousHash !== currentHash) {
       sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${systemContent.length}), ${idleCacheExpired ? "adopting on idle-expired request" : requestMessagesFinal ? "adopting on the request whose messages are already final" : "triggering flush"}`);
+      noteSystemPromptHashChange(sessionId);
       if (!adoptSystemChange) {
         deps.historyRefreshSessions.add(sessionId);
         deps.systemPromptRefreshSessions.add(sessionId);
@@ -10520,10 +10710,16 @@ class MaintenanceLauncher {
   constructor(deps) {
     this.deps = deps;
   }
+  modelConfigured() {
+    return hasMaintenancePrimary(this.deps.getConfig().maintenance);
+  }
   maybeLaunch(signals) {
     if (!this.deps.getConfig().maintenance.enabled) {
       return { launched: false, reason: "maintenance-disabled" };
     }
+    if (!this.modelConfigured()) {
+      return { launched: false, reason: "maintenance-model-unconfigured" };
+    }
     if (this.runInFlight) {
       return { launched: false, reason: "run-in-flight-local" };
     }
@@ -10553,6 +10749,9 @@ class MaintenanceLauncher {
     if (!this.deps.getConfig().maintenance.enabled) {
       return { launched: false, reason: "maintenance-disabled" };
     }
+    if (!this.modelConfigured()) {
+      return { launched: false, reason: "maintenance-model-unconfigured" };
+    }
     if (this.runInFlight) {
       return { launched: false, reason: "run-in-flight-local" };
     }
@@ -10692,63 +10891,6 @@ function hasRecordedSessionProjectIdentity(db, sessionId) {
   return row?.found === 1;
 }
 
-// src/features/magic-context/transform-decision-log.ts
-var canonicalReasons = new Set([
-  "system_hash",
-  "model_change",
-  "ttl_idle",
-  "explicit_flush",
-  "max_mutation_id",
-  "first_render",
-  "pressure_refold",
-  "upgrade_state",
-  "cached_m1_missing",
-  "project_change",
-  "compartment_render_epoch",
-  "m1_delta",
-  "ttl_expiry",
-  "epoch_change",
-  "coverage_fold",
-  "profile_transition",
-  "host_compaction"
-]);
-var piReasonAliases = {
-  pending_mutations: "max_mutation_id",
-  renderer_upgrade: "upgrade_state",
-  cache_invalid: "cached_m1_missing",
-  drift: "pressure_refold"
-};
-var sharedReasonAliases = {
-  model_key: "model_change",
-  pressure: "pressure_refold"
-};
-var pendingDecisionBySession = new Map;
-var pendingPiDecisionBySession = new Map;
-var lastBoundMessageIdBySession = new Map;
-var scheduledWriteTokensBySession = new Map;
-function normalizeMaterializeReason(harness, reason, rematerialized) {
-  const raw = typeof reason === "string" ? reason.trim() : "";
-  if (raw.length > 0) {
-    const alias = sharedReasonAliases[raw] ?? (harness === "pi" ? piReasonAliases[raw] : undefined) ?? undefined;
-    if (alias)
-      return alias;
-    if (canonicalReasons.has(raw))
-      return raw;
-    return null;
-  }
-  return rematerialized ? "pressure_refold" : null;
-}
-function clearOpenCodePendingTransformDecision(sessionId) {
-  pendingDecisionBySession.delete(sessionId);
-}
-function recordPendingTransformDecision(sessionId, decision) {
-  if (!decision.bustedThisPass) {
-    pendingDecisionBySession.delete(sessionId);
-    return;
-  }
-  pendingDecisionBySession.set(sessionId, decision);
-}
-
 // src/hooks/magic-context/cache-busting-signals.ts
 function canConsumeDeferredOnThisPass(args) {
   if (args.justAwaitedPublication)
@@ -11422,12 +11564,12 @@ function buildTriggerInMemoryTail(db, sessionId, messages) {
 function getProactiveCompartmentTriggerPercentage(executeThresholdPercentage) {
   return Math.max(0, executeThresholdPercentage - PROACTIVE_TRIGGER_OFFSET_PERCENTAGE);
 }
-function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, keepReasoningTokens, clearedReasoningThroughTag, canClearReasoning, liveBudgetCutoff) {
+function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, keepReasoningTokens, clearedReasoningThroughTag, canClearReasoning, liveBudgetCutoff, eligiblePendingDropTagIds) {
   const totalActiveBytes = activeTags.reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   if (totalActiveBytes === 0)
     return null;
   let droppableBytes = 0;
-  const pendingDrops = getPendingOps(db, sessionId).filter((op) => op.operation === "drop");
+  const pendingDrops = getPendingOps(db, sessionId).filter((op) => op.operation === "drop" && eligiblePendingDropTagIds?.has(op.tagId) === true);
   const pendingDropTagIds = new Set(pendingDrops.map((op) => op.tagId));
   if (pendingDrops.length > 0) {
     droppableBytes += activeTags.filter((tag) => pendingDropTagIds.has(tag.tagNumber)).reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
@@ -11555,7 +11697,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
 function formatProjectedPostDropPercentage(value) {
   return value === null ? "none" : `${value.toFixed(1)}%`;
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, storedTotalsExcludeToolTags) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, keepReasoningTokens, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride, reasoningProjection, reclaimRide, eligiblePendingDropTagIds, storedTotalsExcludeToolTags) {
   if (sessionMeta.compartmentInProgress) {
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -11619,7 +11761,7 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     return { shouldFire: false };
   }
   const canClearReasoning = reasoningProjection?.canClearReasoning ?? modelAcceptsEmptyContent(reasoningProjection?.providerID);
-  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff);
+  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), keepReasoningTokens, sessionMeta.clearedReasoningThroughTag, canClearReasoning, reasoningProjection?.budgetCutoff, eligiblePendingDropTagIds);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
   const rideLabel = reclaimRide ? reclaimRideLabel(reclaimRide) : "ride=none";
   const dropsCanLand = reclaimRide !== undefined && hasReclaimRide(reclaimRide);
@@ -11703,6 +11845,12 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
   };
 }
 
+// src/hooks/magic-context/compartment-trigger-error.ts
+function recordCompartmentTriggerError(passOutcome, sessionId, error, log = sessionLog) {
+  passOutcome.record("compartment-trigger-failure");
+  log(sessionId, "compartment trigger failed (non-fatal):", error);
+}
+
 // src/hooks/magic-context/pass-outcome.ts
 var PASS_DEGRADATION_EFFECTS = {
   "store-generation-rebase-failure": "changes-request",
@@ -11763,6 +11911,37 @@ function createPassOutcome() {
   };
 }
 
+// src/hooks/magic-context/render-options.ts
+function createM0RenderOptions(controls, contextUsage, modelKey, resolvedContextLimit, projectPath) {
+  return {
+    projectPath: controls.memoryConfig?.enabled ? projectPath : undefined,
+    memoryEnabled: controls.memoryConfig?.enabled,
+    memoryInjectionBudgetTokens: controls.memoryConfig?.injectionBudgetTokens,
+    temporalAwareness: controls.experimentalTemporalAwareness,
+    historyBudgetTokens: resolveHistoryBudgetTokens(controls.historyBudgetPercentage, contextUsage, controls.executeThresholdPercentage, modelKey, controls.executeThresholdTokens, resolvedContextLimit),
+    historyBudgetPolicyIdentity: historyBudgetPolicyIdentity(controls.historyBudgetPercentage, controls.executeThresholdPercentage, modelKey, controls.executeThresholdTokens)
+  };
+}
+function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
+  if (!historyBudgetPercentage) {
+    return;
+  }
+  let contextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
+  if (contextLimit <= 0) {
+    if (contextUsage.percentage <= 0) {
+      return;
+    }
+    contextLimit = contextUsage.inputTokens / (contextUsage.percentage / 100);
+  }
+  if (!Number.isFinite(contextLimit) || contextLimit <= 0) {
+    return;
+  }
+  return Math.floor(contextLimit * (resolveExecuteThreshold(executeThresholdPercentage ?? 65, modelKey, 65, {
+    tokensConfig: executeThresholdTokens,
+    contextLimit
+  }) / 100) * historyBudgetPercentage);
+}
+
 // src/hooks/magic-context/temporal-served-projection.ts
 function readLkgTemporalDecisions(db, sessionId, runtime) {
   const slot = getInMemorySlot(sessionId) ?? loadPersistedLkgSlot(db, sessionId);
@@ -11955,6 +12134,13 @@ async function runCompartmentPhaseImpl(args) {
     return snapshot !== null && hasRunnableCompartmentWindow(snapshot);
   }
   async function awaitCompartmentRun(activeRun, reason) {
+    await Promise.resolve();
+    if (activeRun.inlineJoinTimedOutBudgetMs !== undefined && !activeRun.settled) {
+      historianJoinTimedOut = true;
+      historianJoinBudgetMs = activeRun.inlineJoinTimedOutBudgetMs;
+      sessionLog(args.sessionId, "transform: compartment inline join budget already exhausted for this run — not waiting again");
+      return "timed_out";
+    }
     sessionLog(args.sessionId, reason);
     const timeoutMs = resolveHistorianInlineJoinBudget(args.historianTimeoutMs);
     historianJoinBudgetMs = timeoutMs;
@@ -11970,6 +12156,7 @@ async function runCompartmentPhaseImpl(args) {
         clearTimeout(timer);
     }
     if (result === "timeout") {
+      activeRun.inlineJoinTimedOutBudgetMs = timeoutMs;
       historianJoinTimedOut = true;
       sessionLog(args.sessionId, `transform: compartment await timed out after ${timeoutMs}ms — proceeding without waiting`);
       return "timed_out";
@@ -12177,6 +12364,76 @@ function resolveSchedulerDecision(scheduler, sessionMeta, contextUsage, sessionI
   }
 }
 
+// src/hooks/magic-context/pending-drop-eligibility.ts
+function pendingDropVeto(tagNumber, target, protectedTagIds) {
+  if (protectedTagIds.has(tagNumber))
+    return "protected";
+  if (target?.thinkingDropProtected)
+    return "active_thinking";
+  return null;
+}
+function capturePendingDropEligibility(targets, protectedTagIds) {
+  const eligible = new Set;
+  for (const [number, target] of targets) {
+    if (pendingDropVeto(number, target, protectedTagIds))
+      continue;
+    if (target.drop) {
+      if (target.canDrop?.() === true)
+        eligible.add(number);
+    } else {
+      const content = target.getContent?.();
+      if (typeof content === "string" && content.length > `[dropped §${number}§]`.length)
+        eligible.add(number);
+    }
+  }
+  return eligible;
+}
+function pendingDropEligibilityKey(db, sessionId, input, protectionInputs) {
+  const digests = input.map((message) => message.contentDigest?.() ?? null);
+  if (digests.some((digest) => digest === null))
+    return null;
+  const revision = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(tagRevisionKey(sessionId));
+  if (!revision?.value)
+    return null;
+  return JSON.stringify([
+    input.map((message, index) => [
+      message.id,
+      message.role,
+      message.synthetic,
+      digests[index]
+    ]),
+    revision.value,
+    readEpochFloorSnapshot(db, sessionId),
+    sessionDecisionCalibration(db, sessionId).toolsRatio,
+    loadProtectedTailMeta(db, sessionId),
+    [...getMergedReasoningStrippedIds(db, sessionId)].sort(),
+    [...getReasoningRemovalState(db, sessionId).messageIds].sort(),
+    protectionInputs
+  ]);
+}
+function createPendingDropEligibilityCache() {
+  const sessions = new Map;
+  return {
+    read(sessionId, key) {
+      const previous = sessions.get(sessionId);
+      if (key === null || previous?.key !== key) {
+        sessions.delete(sessionId);
+        return;
+      }
+      return previous.eligible;
+    },
+    record(sessionId, key, eligible) {
+      sessions.delete(sessionId);
+      if (key === null)
+        return;
+      const oldest = sessions.keys().next().value;
+      if (sessions.size >= 64 && oldest !== undefined)
+        sessions.delete(oldest);
+      sessions.set(sessionId, { key, eligible: new Set(eligible) });
+    }
+  };
+}
+
 // src/hooks/magic-context/apply-operations.ts
 var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
@@ -12285,7 +12542,7 @@ function renderConvertedToolSkeletons(targets, converted) {
   }
   return didMutate;
 }
-function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete) {
+function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set, onTagReduced, onBatchComplete, onEligibilitySnapshot) {
   let didMutateMessage = false;
   let diagnostics;
   const reject = (reason) => {
@@ -12300,6 +12557,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
     }).immediate();
     {
       const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+      onEligibilitySnapshot?.(capturePendingDropEligibility(targets, protectedTagIds));
       const neededTagNumbers = new Set(pendingOps.map((op) => op.tagId));
       for (const op of syntheticPendingOps)
         neededTagNumbers.add(op.tagId);
@@ -12336,13 +12594,10 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
             removePendingOp(db, sessionId, pendingOp.tagId);
           continue;
         }
-        if (protectedTagIds.has(pendingOp.tagId)) {
-          reject("protected");
-          continue;
-        }
         const target = targets.get(pendingOp.tagId);
-        if (target?.thinkingDropProtected) {
-          reject("active_thinking");
+        const veto = pendingDropVeto(pendingOp.tagId, target, protectedTagIds);
+        if (veto) {
+          reject(veto);
           continue;
         }
         const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
@@ -12362,9 +12617,7 @@ function applyPendingOperations(sessionId, db, targets, protectedTagIds, preload
           try {
             db.transaction(() => {
               startedAt = performance.now();
-              if (mode)
-                updateTagDropMode(db, sessionId, pendingOp.tagId, mode);
-              updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
+              markTagDropped(db, sessionId, pendingOp.tagId, mode);
               if (!synthetic)
                 removePendingOp(db, sessionId, pendingOp.tagId);
             }).immediate();
@@ -13774,7 +14027,7 @@ function buildEditSupersessionReclaim(input) {
       seenFile.add(filePath);
       continue;
     }
-    if (input.recentMessageIds && (tag.toolOwnerMessageId === null || input.recentMessageIds.has(tag.toolOwnerMessageId))) {
+    if (tag.tagNumber > input.watermark || input.recentMessageIds && (tag.toolOwnerMessageId === null || input.recentMessageIds.has(tag.toolOwnerMessageId))) {
       continue;
     }
     if (realPendingTagIds.has(tag.tagNumber))
@@ -13822,6 +14075,51 @@ async function waitForTagOwners(db, sessionId, ratio, _waitMs = 250) {
   return prewarmTagOwners(db, sessionId, ratio);
 }
 
+// src/shared/reclaim-distance.ts
+var RECLAIM_DISTANCE_USER_TURNS = 3;
+var RECLAIM_DISTANCE_WINDOW_FRACTION = 0.25;
+function isReclaimUserTurn(args) {
+  return args.role === "user" && !args.syntheticHead && !args.synthetic && !args.ignored && args.parts.some((part) => {
+    if (part.synthetic || part.ignored)
+      return false;
+    if (part.kind !== "text" && part.kind !== "image" && part.kind !== "file")
+      return false;
+    if (part.kind !== "text")
+      return true;
+    return stripReclaimMcText(part.text ?? "").trim().length > 0;
+  });
+}
+function stripReclaimMcText(text) {
+  return text.replace(/^§\d+§\s*/, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, (reminder) => /^(?:Your next step: call ctx_reduce on the outputs you've already used|Still unstamped:|Housekeeping: .* are reclaimable\. Stamp each output with ctx_reduce|.* are reclaimable\. Make a ctx_reduce pass now|.* are still unstamped\. Call ctx_reduce now)/.test(reminder.slice("<system-reminder>".length).trimStart()) ? "" : reminder).replace(/<instruction name="deferred_notes">[\s\S]*?<\/instruction>/g, "");
+}
+function farBehindToolBookmark(entries, usableWindow) {
+  let newerTurns = 0;
+  let newerTokens = 0;
+  const farTags = [];
+  let firstYoungTag = Infinity;
+  const seenOutputs = new Set;
+  const tokenDistance = usableWindow > 0 && Number.isFinite(usableWindow) ? usableWindow * RECLAIM_DISTANCE_WINDOW_FRACTION : Infinity;
+  for (let index = entries.length - 1;index >= 0; index--) {
+    const entry = entries[index];
+    if (!entry)
+      continue;
+    const tag = entry.toolOutputTag;
+    if (tag !== undefined && !seenOutputs.has(tag)) {
+      seenOutputs.add(tag);
+      if (newerTurns >= RECLAIM_DISTANCE_USER_TURNS || newerTokens >= tokenDistance) {
+        farTags.push(tag);
+      } else {
+        firstYoungTag = Math.min(firstYoungTag, tag);
+      }
+    }
+    if (entry.userTurn)
+      newerTurns++;
+    if (Number.isFinite(entry.tokens) && entry.tokens > 0)
+      newerTokens += entry.tokens;
+  }
+  return farTags.reduce((bookmark, tag) => tag < firstYoungTag ? Math.max(bookmark, tag) : bookmark, 0);
+}
+
 // src/hooks/magic-context/tool-reclaim.ts
 function buildSyntheticToolReclaimOps(input) {
   const watermark = Math.max(0, input.watermark);
@@ -13853,10 +14151,74 @@ function buildSyntheticToolReclaimOps(input) {
   }
   return synthetic;
 }
-function advanceToolReclaimWatermarkToCurrentMax(db, sessionId) {
-  const maxTagNumber = getMaxTagNumberBySession(db, sessionId);
-  advanceToolReclaimWatermark(db, sessionId, maxTagNumber);
-  return maxTagNumber;
+function advanceToolReclaimWatermarkByDistance(db, sessionId, entries, usableWindow) {
+  const bookmark = farBehindToolBookmark(entries, usableWindow);
+  advanceToolReclaimWatermark(db, sessionId, bookmark);
+  return bookmark;
+}
+function toolReclaimDistanceEntries(messages, targets) {
+  const outputTags = new Map;
+  for (const [tag, target] of targets) {
+    for (const location of target.mutationParts ?? []) {
+      const part = distancePart(location.part);
+      if (part.kind === "tool_result" || part.kind === "tool")
+        outputTags.set(location.part, tag);
+    }
+  }
+  const entries = [];
+  for (const message of messages) {
+    const parts = message.parts.map(distancePart);
+    let userTurn = isReclaimUserTurn({ ...message.info, parts });
+    for (const [index, part] of parts.entries()) {
+      const authored = isReclaimUserTurn({ role: "user", parts: [part] });
+      entries.push({
+        tokens: message.info.syntheticHead ? 0 : estimateTokens(stripReclaimMcText(part.text ?? "")) + part.imageTokens,
+        userTurn: userTurn && authored,
+        toolOutputTag: outputTags.get(message.parts[index])
+      });
+      if (authored)
+        userTurn = false;
+    }
+  }
+  return entries;
+}
+function distancePart(raw) {
+  if (!raw || typeof raw !== "object")
+    return { kind: "structural", imageTokens: 0 };
+  const part = raw;
+  const provenance = { synthetic: part.synthetic === true, ignored: part.ignored === true };
+  if (typeof part.getText === "function") {
+    const text = part.getText();
+    return {
+      ...provenance,
+      kind: String(part.kind),
+      text: typeof text === "string" ? text : undefined,
+      imageTokens: typeof part.imageTokens === "function" ? Number(part.imageTokens()) : 0
+    };
+  }
+  const metadata = { ...provenance, imageTokens: estimatePartImageTokens(raw) };
+  if (part.type === "tool") {
+    const state = part.state;
+    return {
+      ...metadata,
+      kind: "tool",
+      text: `${JSON.stringify(state?.input ?? {})}
+${typeof state?.output === "string" ? state.output : JSON.stringify(state?.output ?? "")}`
+    };
+  }
+  if (part.type === "tool_use")
+    return { ...metadata, kind: "tool_use", text: JSON.stringify(part.input ?? {}) };
+  if (part.type === "tool_result")
+    return {
+      ...metadata,
+      kind: "tool_result",
+      text: typeof part.content === "string" ? part.content : JSON.stringify(part.content ?? "")
+    };
+  return {
+    ...metadata,
+    kind: String(part.type),
+    text: typeof part.text === "string" ? part.text : typeof part.thinking === "string" ? part.thinking : undefined
+  };
 }
 
 // src/hooks/magic-context/transform-postprocess-phase.ts
@@ -14187,6 +14549,25 @@ function finalizeMessageRepresentation(messages, resolvedProviderID, options) {
   }
   return { clearedParts, mergedReasoningParts };
 }
+function legacyPublishedHeadChanged(args) {
+  if (!args.pendingCompartmentInjection || !args.readLastServedMessages)
+    return false;
+  const served = args.readLastServedMessages();
+  if (served === null)
+    return true;
+  const previous = served[0];
+  if (!Array.isArray(previous?.parts) || !args.pendingCompartmentInjection)
+    return false;
+  const text = previous.parts.find((part) => typeof part === "object" && part !== null && ("type" in part) && part.type === "text" && ("text" in part))?.text;
+  if (typeof text !== "string")
+    return false;
+  const block = `<session-history>
+${args.pendingCompartmentInjection.block}
+</session-history>`;
+  return text !== block && !text.startsWith(`${block}
+
+`);
+}
 async function runPostTransformPhase(args) {
   const tPostprocessSetup = performance.now();
   const compactionOff = args.compactionOff === true;
@@ -14390,11 +14771,6 @@ async function runPostTransformPhase(args) {
     }
     sessionLog(args.sessionId, `m[0] HARD fold decision: reason=${m0MaterializeReason ?? foldDueDecision.reason ?? (foldExecutedThisPass ? "drift" : "soft_refresh")} executed=${foldExecutedThisPass} bustsServedPrefix=${foldBustsServedPrefixThisPass}`);
   }
-  if (args.normalizeRecoveryTail && (foldBustsServedPrefixThisPass || firstRenderBust)) {
-    args.normalizeRecoveryTail();
-    args.tags = getTagsBySession(args.db, args.sessionId);
-    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
-  }
   logTransformTiming(args.sessionId, "pp.prefixPreflight", tPostprocessSetup, `foldExecuted=${foldExecutedThisPass} m1Refreshed=${publishedM1RefreshedThisPass}`);
   const tPassDecisions = performance.now();
   const frontToolCandidates = args.tags.filter((tag) => tag.type === "tool" && tag.status === "active" && args.targets.get(tag.tagNumber)?.canDrop?.());
@@ -14421,13 +14797,19 @@ async function runPostTransformPhase(args) {
     subagentExecute: !args.fullFeatureMode && args.schedulerDecision === "execute",
     hardFold: foldBustsServedPrefixThisPass || firstRenderBust || idleExpiryRebuild,
     force: emergencyDropEligible && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
-    explicitFlush: isExplicitFlush || deferredMaterialize && !prefixPreflightFailed,
-    publishedHistory: publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && (args.historyRebuiltThisPass || args.rebuiltHistoryFromInitialPrepare || args.canConsumeDeferredLate && args.deferredHistoryWasPendingAtPassStart)
+    explicitFlush: isExplicitFlush && hasPendingMaterializationOrigin(args.pendingMaterializationSessions, args.sessionId, "user_flush"),
+    publishedHistory: !prefixPreflightFailed && (publishedM1RefreshedThisPass || !m0M1EnabledForFold && (args.pendingCompartmentInjection?.compartmentCount ?? 0) > 0 && legacyPublishedHeadChanged(args))
   };
   const publishedWorkDrainAllowed = !compactionOff && (!activeThinkingPrefixHold || firstRenderBust || idleExpiryRebuild || emergencyDropEligible) && hasReclaimRide(rideSignals);
   const shouldApplyPendingOps = publishedWorkDrainAllowed;
   const shouldRunHeuristics = !compactionOff && publishedWorkDrainAllowed && (rideSignals.publishedHistory || materializationRequested || forceMaterialization || foldBustsServedPrefixThisPass || firstRenderBust || heldIdleExpiryRebuild || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = publishedWorkDrainAllowed;
+  if (args.normalizeRecoveryTail && isCacheBustingPass) {
+    args.normalizeRecoveryTail();
+    args.tags = getTagsBySession(args.db, args.sessionId);
+    newTargets = protectNewTagMutations(args.messages, args.targets, retainedThinking, args.thinkingBindingRecoveryEnabledForModel === true);
+  }
+  const reclaimDistance = isCacheBustingPass ? toolReclaimDistanceEntries(args.messages, args.targets) : [];
   const canEditWholePrefix = isCacheBustingPass && !activeThinkingPrefixHold;
   const previousTemporalDecisions = args.temporalCandidates && !compactionOff ? new Map([
     ...args.temporalObservedDecisions ?? [],
@@ -14570,7 +14952,7 @@ async function runPostTransformPhase(args) {
       pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, newTargets, new Set([
         ...args.contextUsage.percentage >= 95 ? [] : args.protectedTagIds,
         ...protectedToolTags
-      ]), undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
+      ]), undefined, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction), undefined, args.onPendingDropEligibility);
       if (pendingOpsDidMutate) {
         droppedCount += pendingOps.length;
         for (const pendingOp of pendingOps) {
@@ -14773,6 +15155,7 @@ async function runPostTransformPhase(args) {
           }
         }
         const editReclaim = buildEditSupersessionReclaim({
+          watermark: args.sessionMeta.toolReclaimWatermark ?? 0,
           db: args.db,
           sessionId: args.sessionId,
           targets: newTargets,
@@ -14811,7 +15194,7 @@ async function runPostTransformPhase(args) {
     const tBatchFinalize = performance.now();
     args.batch?.finalize();
     if (toolReclaimApplicationOpportunity) {
-      const maxTagNumber = advanceToolReclaimWatermarkToCurrentMax(args.db, args.sessionId);
+      const maxTagNumber = advanceToolReclaimWatermarkByDistance(args.db, args.sessionId, reclaimDistance, args.usableWindow);
       args.sessionMeta.toolReclaimWatermark = Math.max(args.sessionMeta.toolReclaimWatermark ?? 0, maxTagNumber);
     }
     if (autoReclaimTargetCount > 0) {
@@ -15444,6 +15827,7 @@ async function runPostTransformPhase(args) {
         const hygieneCalibration = sessionDecisionCalibration(args.db, args.sessionId);
         const hygieneUnitsVersion = transitionSessionHygieneUnits(args.db, args.sessionId, bustedThisPass, hygieneCalibration);
         const baseline = refreshTailHygieneBaseline({
+          opencode2: args.opencode2,
           messages: args.messages,
           tags,
           protectedTagNumbers: args.protectedTagNumbers,
@@ -15459,7 +15843,7 @@ async function runPostTransformPhase(args) {
           sessionLog(args.sessionId, formatTailHygienePrefixMismatch(baseline.lastPrefixMismatch, baseline.baselineGeneration));
         }
         const tTailState = performance.now();
-        const structuralSignature = tailHygieneStructuralSignature(args.messages);
+        const structuralSignature = tailHygieneStructuralSignature(args.messages, args.opencode2);
         const effective = effectiveTailHygiene(baseline);
         const durableGrace = baseline.evaluable && !baseline.generationInvalidated ? captureChannel1PostReduceGraceBaseline(args.db, args.sessionId, effective.u) : getChannel1NudgeState(args.db, args.sessionId);
         baseline.channel1PostReduceGrace = durableGrace.postReduceGracePending || durableGrace.postReduceGraceBaselineU !== undefined ? {
@@ -15471,7 +15855,7 @@ async function runPostTransformPhase(args) {
           ...baseline,
           usableWindow: args.usableWindow,
           realUserTurnCount: countRealUserMessages(args.messages),
-          reducedSinceRefresh: baseline.baselineGeneration !== previous?.baselineGeneration ? false : previous?.reducedSinceRefresh ?? false,
+          reducedSinceRefresh: baseline.baselineGeneration !== previous?.baselineGeneration || (previous?.generationInvalidated === true || previous?.evaluable === false) && baseline.evaluable && !baseline.generationInvalidated ? false : previous?.reducedSinceRefresh ?? false,
           agentDropsAppliedThisPass: pendingOpsDidMutate,
           oldestReclaimableToolTags: postprocessOldestTags(args.db, args.sessionId, args.protectedTagNumbers)
         });
@@ -15509,7 +15893,7 @@ async function runPostTransformPhase(args) {
   const tTailGuard = performance.now();
   if (assertedBaseline) {
     try {
-      const servedSignature = tailHygieneStructuralSignature(args.messages);
+      const servedSignature = tailHygieneStructuralSignature(args.messages, args.opencode2);
       if (!sameTailHygieneStructuralSignature(assertedBaseline.structuralSignature, servedSignature)) {
         sessionLog(args.sessionId, `ERROR [tail-hygiene-last-writer-mismatch]: served messages changed after tail-hygiene baseline refresh (expected messages=${assertedBaseline.structuralSignature.messageCount}, parts=[${assertedBaseline.structuralSignature.partCounts.join(",")}], bytes=${assertedBaseline.structuralSignature.totalBytes}; actual messages=${servedSignature.messageCount}, parts=[${servedSignature.partCounts.join(",")}], bytes=${servedSignature.totalBytes})`);
       }
@@ -15517,6 +15901,7 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, "ERROR [tail-hygiene-last-writer-check-failed]: structural production guard failed open:", error);
     }
     assertTailHygieneContentUnchangedIfEnabled({
+      opencode2: args.opencode2,
       messages: args.messages,
       tags: assertedBaseline.tags,
       protectedTagNumbers: assertedBaseline.protectedTagNumbers,
@@ -15584,15 +15969,27 @@ class UnmanagedOverWindowError extends Error {
 }
 
 // src/hooks/magic-context/unresolved-history-boundary.ts
+function storedHistoryBoundaryPresence(db, sessionId) {
+  try {
+    const row = db.prepare("SELECT cached_m0_last_baseline_end_message_id AS id FROM session_meta WHERE session_id = ?").get(sessionId);
+    return row?.id ? hasRawSessionMessageById2(sessionId, row.id) : undefined;
+  } catch {
+    return;
+  }
+}
+
 class UnresolvedHistoryBoundaryError extends Error {
   estimatedTokens;
   contextLimitTokens;
+  boundaryPresent;
   code = "UNRESOLVED_HISTORY_BOUNDARY";
   recoverable = true;
-  constructor(estimatedTokens, contextLimitTokens) {
-    super(renderUserFacingFailure("history_boundary_unresolved", "plain"));
+  constructor(estimatedTokens, contextLimitTokens, boundaryPresent) {
+    const reason = boundaryPresent === true ? "The boundary row is present in the host store but out of order relative to the loaded history. " : boundaryPresent === false ? "The boundary row is missing from the host store. " : "";
+    super(reason + renderUserFacingFailure("history_boundary_unresolved", "plain"));
     this.estimatedTokens = estimatedTokens;
     this.contextLimitTokens = contextLimitTokens;
+    this.boundaryPresent = boundaryPresent;
     this.name = "UnresolvedHistoryBoundaryError";
   }
 }
@@ -15676,6 +16073,7 @@ function resolveTransformHostSeams(deps) {
   };
 }
 function createTransform(deps) {
+  const pendingDropEligibility = createPendingDropEligibilityCache();
   registerSystemDateRefresh(deps.historyRefreshSessions);
   const finalWireUsage = createFinalWireUsageTracker();
   const host = resolveTransformHostSeams(deps);
@@ -15726,7 +16124,7 @@ function createTransform(deps) {
       return historianRun?.toastDurationMs === undefined ? params : { ...params, toastDurationMs: historianRun.toastDurationMs };
     };
     beginLkgPass(sessionId);
-    clearOpenCodePendingTransformDecision(sessionId);
+    clearOpenCodePendingTransformDecision(sessionId, messages);
     const db = deps.db;
     try {
       const tPrepare = performance.now();
@@ -16080,9 +16478,10 @@ function createTransform(deps) {
     const persistedUsageFreshForBoundary = persistedUsageBeforeResets && Date.now() - persistedUsageBeforeResets.updatedAt <= 10 * 60 * 1000 && (persistedUsageBeforeResets.lastObservedModelKey === null || currentModelKeyForBoundary === undefined || piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) === piModelRefToCanonical(currentModelKeyForBoundary)) && (resolvedContextLimit === undefined || persistedUsageBeforeResets.lastUsageContextLimit === 0 || persistedUsageBeforeResets.lastUsageContextLimit === resolvedContextLimit) ? persistedUsageBeforeResets.usage : null;
     const boundaryUsageForProtectedTail = persistedUsageFreshForBoundary ?? contextUsageEarly;
     const boundaryUsageSource = persistedUsageFreshForBoundary ? "persisted" : "live";
-    const historyPolicyIdentity = historyBudgetPolicyIdentity(deps.historyBudgetPercentage, deps.executeThresholdPercentage, currentModelKeyForBoundary, deps.executeThresholdTokens);
     const historyContextLimit = resolvedContextLimit ?? (currentModelKeyForBoundary && persistedUsageBeforeResets?.lastObservedModelKey && piModelRefToCanonical(currentModelKeyForBoundary) === piModelRefToCanonical(persistedUsageBeforeResets.lastObservedModelKey) && persistedUsageBeforeResets.lastUsageContextLimit > 0 ? persistedUsageBeforeResets.lastUsageContextLimit : undefined);
-    const historyBudgetTokens = resolveHistoryBudgetTokens(deps.historyBudgetPercentage, contextUsageEarly, deps.executeThresholdPercentage, deps.getModelKey?.(sessionId), deps.executeThresholdTokens, historyContextLimit);
+    const memoryProjectDirectory = compartmentDirectory || process.cwd();
+    const renderOptions = createM0RenderOptions(deps, contextUsageEarly, currentModelKeyForBoundary, historyContextLimit, deps.memoryConfig?.enabled ? resolveProjectIdentityForSession(memoryProjectDirectory, deps.allowHomeProject) : undefined);
+    const { historyBudgetTokens, projectPath: projectIdentity } = renderOptions;
     const emergencyCeilingLimit = thresholdContextLimit ?? 0;
     const emergencyCeilingTokens = Number.isFinite(emergencyCeilingLimit) && emergencyCeilingLimit > 0 ? Math.floor(emergencyCeilingLimit * (effectiveExecuteThresholdPercentage / 100)) : undefined;
     const schedulerDecision = compactionOff ? "defer" : resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId), resolvedContextLimit);
@@ -16215,8 +16614,6 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       });
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
-    const memoryProjectDirectory = compartmentDirectory || process.cwd();
-    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentityForSession(memoryProjectDirectory, deps.allowHomeProject) : undefined;
     if (deps.memoryConfig?.enabled) {
       maybeSendProjectIdentityWarning(deps, sessionId, memoryProjectDirectory, notificationParams);
     }
@@ -16237,6 +16634,18 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     prewarmTagOwners(db, sessionId, ownerRatio);
     const tagOwnersReady = isTagOwnerSummaryReady(db, sessionId, ownerRatio);
     let triggerBoundarySnapshot;
+    const dropProjectionEmergency = contextUsageEarly.percentage >= 95;
+    const dropProjectionKey = () => pendingDropEligibilityKey(db, sessionId, lkgInput, {
+      currentTurnId,
+      model: modelForBudget,
+      protectedTokens: deps.protectedTokens,
+      protectedTokenTierOverrides: deps.protectedTokenTierOverrides,
+      protectedTools: deps.protectedTools,
+      keepReasoningTokens: deps.keepReasoningTokens,
+      usableSoft: windowGeometry?.usableSoft ?? boundaryContextLimit,
+      emergency: dropProjectionEmergency,
+      clearedReasoningThroughTag: sessionMeta?.clearedReasoningThroughTag
+    });
     if (fullFeatureMode && !compactionOff && historianRunnable && tagOwnersReady && !sessionMeta.compartmentInProgress) {
       const tTrigger = performance.now();
       try {
@@ -16249,7 +16658,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           force: contextUsageEarly.percentage >= forceMaterializationPercentage && (contextUsageEarly.percentage >= 95 || getEmergencyInputSample(db, sessionId) === 0),
           explicitFlush: deps.pendingMaterializationSessions.has(sessionId),
           publishedHistory: isCacheBusting
-        });
+        }, pendingDropEligibility.read(sessionId, dropProjectionKey()));
         if (triggerResult.shouldFire) {
           sessionLog(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
           updateSessionMeta(db, sessionId, { compartmentInProgress: true });
@@ -16257,8 +16666,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           triggerBoundarySnapshot = triggerResult.boundarySnapshot;
         }
       } catch (error) {
-        passOutcome.record("compartment-trigger-failure");
-        sessionLog(sessionId, "compartment trigger failed (non-fatal):", error);
+        recordCompartmentTriggerError(passOutcome, sessionId, error);
       }
       logTransformTiming(sessionId, "compartmentTrigger", tTrigger);
     }
@@ -16498,12 +16906,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       db,
       sessionId,
       state: sessionMeta,
-      projectPath: projectIdentity,
       projectDirectory: sessionDirectory,
-      memoryEnabled: deps.memoryConfig?.enabled,
-      memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
-      historyBudgetTokens,
-      historyBudgetPolicyIdentity: historyPolicyIdentity,
+      ...renderOptions,
       hardSignals: m0HardSignals
     }).value;
     const protectionCacheBustingPass = !compactionOff && (schedulerDecision === "execute" || isCacheBusting || contextUsage.percentage >= forceMaterializationPercentage || deps.pendingMaterializationSessions.has(sessionId) || canConsumeDeferredLate && deferredMaterializationSessions.has(sessionId) || protectionFoldWillBust);
@@ -16615,6 +17019,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       keepReasoningTokens: resolveKeepReasoningTokens(deps.keepReasoningTokens, currentModelKeyForBoundary),
       resolvedModelID: modelForBudget?.modelID,
       protectedTagIds,
+      onPendingDropEligibility: (eligible) => pendingDropEligibility.record(sessionId, dropProjectionKey(), eligible),
       protectedTagNumbers,
       protectedCutoff,
       protectedCount: protectionWindow.status.protectedCount,
@@ -16642,13 +17047,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       passOutcome,
       historyRefreshSessions: deps.historyRefreshSessions,
       m0M1: {
-        projectPath: projectIdentity,
         projectDirectory: sessionDirectory,
-        memoryEnabled: deps.memoryConfig?.enabled,
-        memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
-        historyBudgetTokens,
-        historyBudgetPolicyIdentity: historyPolicyIdentity,
-        temporalAwareness: deps.experimentalTemporalAwareness,
+        ...renderOptions,
         hardSignals: m0HardSignals
       }
     });
@@ -16716,7 +17116,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         });
         if (untrimmed.tokens > boundaryContextLimit) {
           sessionLog(sessionId, `history boundary unresolved: prefix trim refused and the untrimmed request estimate ${untrimmed.tokens} (trusted=${untrimmed.trusted}) exceeds the context limit ${boundaryContextLimit}; not sending it`);
-          throw new UnresolvedHistoryBoundaryError(untrimmed.tokens, boundaryContextLimit);
+          throw new UnresolvedHistoryBoundaryError(untrimmed.tokens, boundaryContextLimit, storedHistoryBoundaryPresence(db, sessionId));
         }
       }
       if (unmanagedOverWindowPass) {
@@ -16893,6 +17293,24 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         bustedThisPass: true,
         lkgFrozenReleaseReason: recoveryReleaseReason
       });
+    } else {
+      noteOpenCodeUnbustedPass(sessionId, {
+        tsMs: Date.now(),
+        decision: schedulerDecision,
+        materialized: postTransformResult.materialized,
+        materializeReason: normalizeMaterializeReason("opencode", postTransformResult.materializeReason, postTransformResult.materialized),
+        systemHashPrev: postTransformResult.systemHashPrev,
+        systemHashNew: postTransformResult.systemHashNew,
+        m0ToolSetHashPrev: postTransformResult.m0ToolSetHashPrev,
+        m0ToolSetHashNew: postTransformResult.m0ToolSetHashNew,
+        m0ModelKeyPrev: postTransformResult.m0ModelKeyPrev,
+        m0ModelKeyNew: postTransformResult.m0ModelKeyNew,
+        emergency: postTransformResult.emergency,
+        droppedTokens: postTransformResult.droppedTokens,
+        droppedCount: postTransformResult.droppedCount,
+        inputTokens: contextUsage.inputTokens,
+        bustedThisPass: false
+      });
     }
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
     const msgTokens = getMessageTokensCache(sessionId);
@@ -17047,11 +17465,19 @@ function clearMaintenanceSystemSnapshot(sessionId) {
 function readMaintenanceSystemSnapshot(sessionId) {
   return maintenanceSystemSnapshotBySession.get(sessionId);
 }
+var maintenanceModelUnconfiguredNoted = new Set;
+function noteMaintenanceModelUnconfigured(projectPath, sessionId) {
+  if (maintenanceModelUnconfiguredNoted.has(projectPath))
+    return;
+  maintenanceModelUnconfiguredNoted.add(projectPath);
+  sessionLog(sessionId, "memory maintenance skipped: neither maintenance.model nor historian.model is configured (set either in the user-level mmc config; the session model is never inherited)");
+}
 function createMaintenanceTailLauncher(deps) {
   const buildLauncher = (projectPath) => (deps.launcherFactory ?? ((db, path) => getMaintenanceLauncher(db, path, {
     getConfig: () => ({
       maintenance: {
-        enabled: deps.getMaintenanceConfig?.()?.enabled ?? false
+        enabled: deps.getMaintenanceConfig?.()?.enabled ?? false,
+        model: deps.getMaintenanceConfig?.()?.model
       }
     }),
     runFactory: (signals) => {
@@ -17089,6 +17515,10 @@ function createMaintenanceTailLauncher(deps) {
           return;
         if (!deps.hiddenCompletionExecutor)
           return;
+        if (!hasMaintenancePrimary(maintenance)) {
+          noteMaintenanceModelUnconfigured(projectPath, input.sessionId);
+          return;
+        }
         const poolCount = countMaintenancePool(deps.db, projectPath);
         const hostSystemText = readMaintenanceSystemSnapshot(input.sessionId);
         buildLauncher(projectPath).maybeLaunch({
@@ -17107,25 +17537,6 @@ function createMaintenanceTailLauncher(deps) {
     }
   };
 }
-function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
-  if (!historyBudgetPercentage) {
-    return;
-  }
-  let contextLimit = resolvedContextLimit && resolvedContextLimit > 0 ? resolvedContextLimit : 0;
-  if (contextLimit <= 0) {
-    if (contextUsage.percentage <= 0) {
-      return;
-    }
-    contextLimit = contextUsage.inputTokens / (contextUsage.percentage / 100);
-  }
-  if (!Number.isFinite(contextLimit) || contextLimit <= 0) {
-    return;
-  }
-  return Math.floor(contextLimit * (resolveExecuteThreshold(executeThresholdPercentage ?? 65, modelKey, 65, {
-    tokensConfig: executeThresholdTokens,
-    contextLimit
-  }) / 100) * historyBudgetPercentage);
-}
 
 // src/plugin/rpc-handlers.ts
 import { once } from "node:events";
@@ -17376,6 +17787,7 @@ function runManualMaintenanceCommand(args) {
   }
   const explanations = {
     "maintenance-disabled": "memory maintenance is disabled (maintenance.enabled: false)",
+    "maintenance-model-unconfigured": "memory maintenance has no primary model configured — set maintenance.model in the user-level mmc config (fallback_models alone does not enable maintenance; the chain never inherits the historian or session model)",
     "run-in-flight-local": "a maintenance run is already in flight; next_due_at is due now, so the launcher retries on the next pass",
     "empty-pool": "memory pool is empty (no active/permanent rows) — nothing to maintain"
   };
@@ -18261,7 +18673,7 @@ function registerRpcHandlers(rpcServer, args) {
   });
   const buildManagedCtx = async (db) => {
     const { deriveHistorianChunkTokens, resolveHistorianContextLimit } = await import("./derive-budgets-s1p37t2g.js");
-    const { resolveHistorianModel } = await import("./model-resolution-wazv26n0.js");
+    const { resolveHistorianModel } = await import("./model-resolution-cvyrrcjw.js");
     const DEFAULT_HISTORIAN_TIMEOUT_MS = 600000;
     const runConfig = historianRunConfig(config, currentPluginConfigReader(directory)?.poll().effective ?? config);
     const historianModel = resolveHistorianModel(runConfig, "opencode");
@@ -18290,8 +18702,8 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-wrjy3qym.js");
-    const { sendIgnoredMessage } = await import("./send-session-notification-cz6ev088.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-k760qy1n.js");
+    const { sendIgnoredMessage } = await import("./send-session-notification-njjf3b4s.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     if (!args.client && !args.hiddenCompletionExecutor) {
       return {
@@ -18340,7 +18752,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = readDatabase();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedWrapup } = await import("./wrapup-orchestrator-bmybc5p5.js");
+    const { runManagedWrapup } = await import("./wrapup-orchestrator-b2gswatj.js");
     const model = liveSessionState.liveModelBySession.get(sessionId);
     const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
     const ctx = {
@@ -18372,11 +18784,14 @@ function registerRpcHandlers(rpcServer, args) {
     const raw = String(params.subcommand ?? "status").toLowerCase();
     const action = raw === "run" || raw === "resume" ? raw : "status";
     if (action === "run") {
-      const maintenance = config.maintenance;
+      const maintenance = inheritMaintenanceModelConfig(config);
       const hostSystemText = readMaintenanceSystemSnapshot(sessionId);
       const launcher = getMaintenanceLauncher(db, projectPath, {
         getConfig: () => ({
-          maintenance: { enabled: maintenance?.enabled ?? false }
+          maintenance: {
+            enabled: maintenance?.enabled ?? false,
+            model: maintenance?.model
+          }
         }),
         nowMs: Date.now,
         runFactory: createOc2MaintenanceRunFactory({
@@ -18384,7 +18799,7 @@ function registerRpcHandlers(rpcServer, args) {
           projectPath,
           executor: args.hiddenCompletionExecutor,
           config: () => {
-            const slice = config.maintenance;
+            const slice = inheritMaintenanceModelConfig(config);
             if (!slice) {
               throw new Error("memory maintenance config unavailable");
             }
@@ -19153,8 +19568,8 @@ var v2CompactionMarkerStrategy = {
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/v2/fold/owner.ts
-import { createHash as createHash4 } from "node:crypto";
-var foldDigest = (value) => createHash4("sha256").update(value).digest("hex");
+import { createHash as createHash3 } from "node:crypto";
+var foldDigest = (value) => createHash3("sha256").update(value).digest("hex");
 
 class FoldOwner {
   storage;
@@ -20869,6 +21284,25 @@ async function cleanupLegacyHiddenChildren(db, remove, note, options = {}) {
 }
 
 // src/v2/hidden-completion.ts
+var DEFAULT_DISPOSE_DRAIN_MS = 2000;
+async function settleWithin(work, ms) {
+  let timer;
+  try {
+    await Promise.race([
+      work.then(() => {
+        return;
+      }, () => {
+        return;
+      }),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, Math.max(0, ms));
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 var POLL_INTERVAL_MS = 200;
 function modelKey(model) {
   return `${model.providerID}/${model.modelID}`;
@@ -20968,6 +21402,9 @@ function isProviderFailure(error) {
 }
 async function awaitAssistantRow(openReader, readSessionError, localFailure, childID, afterSeq, deadline, signal) {
   for (;; ) {
+    const refusedBefore = localFailure();
+    if (refusedBefore)
+      throw refusedBefore;
     const { assistant, idle } = withReader(openReader, (reader) => ({
       assistant: reader.latestAssistant(childID),
       idle: reader.latestIdle(childID)
@@ -21043,6 +21480,9 @@ async function createV2HiddenCompletionExecutor(host, options) {
   const generation = options.generation ?? "opencode2";
   const roleTails = new Map;
   const note = options.log ?? log;
+  let disposed;
+  const openRuns = new Set;
+  const inFlight = new Set;
   const removeSession = host.removeSession;
   if (!removeSession)
     throw new Error("Magic Context requires OpenCode 2.0.22 session.remove");
@@ -21079,7 +21519,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
       const entry = rows.find((row) => row && typeof row === "object" && row.providerID === model.providerID && row.id === model.modelID);
       if (!entry)
         return model;
-      if (entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
+      if (Array.isArray(entry.variants) ? entry.variants.some((variant) => variant?.id === model.variant) : entry.variants && typeof entry.variants === "object" && Object.hasOwn(entry.variants, model.variant))
         return model;
       const key = `${model.providerID}/${model.modelID}:${model.variant}`;
       if (!warnedVariants.has(key)) {
@@ -21137,10 +21577,17 @@ async function createV2HiddenCompletionExecutor(host, options) {
   return {
     capabilities: V2_HIDDEN_EXECUTOR_CAPABILITIES,
     async open(identity) {
+      if (disposed)
+        throw disposed;
       const role = roleFor(identity);
-      const releaseRole = await acquireRole(role);
+      const releaseStore = options.holdStore?.() ?? (() => {});
+      let releaseRole;
       let openedChild;
+      let opened;
       try {
+        releaseRole = await acquireRole(role);
+        if (disposed)
+          throw disposed;
         await options.ensureAgent?.();
         const head = await resolveHead(identity);
         const active = await lifecycle.open(identity, role, head);
@@ -21151,17 +21598,25 @@ async function createV2HiddenCompletionExecutor(host, options) {
           role,
           child: active,
           releaseRole,
+          releaseStore,
           failed: false,
           unsettledFailure: false,
           retired: false
         };
         runs.set(handle, run);
+        opened = run;
+        openRuns.add(run);
+        if (disposed)
+          noteChildOfDisposedInstance(active.id);
         await switchChildModel(run, head);
         return handle;
       } catch (error) {
         if (openedChild)
           lifecycle.retire(openedChild, "hidden-run-open-failed");
-        releaseRole();
+        if (opened)
+          openRuns.delete(opened);
+        releaseRole?.();
+        releaseStore();
         throw error;
       }
     },
@@ -21169,6 +21624,15 @@ async function createV2HiddenCompletionExecutor(host, options) {
       const run = runs.get(handle);
       if (!run)
         throw new Error("Unknown hidden completion run");
+      const refuseDisposed = () => {
+        if (!disposed)
+          return;
+        run.failed = true;
+        run.unsettledFailure = true;
+        retire(run, "plugin-instance-disposed");
+        throw disposed;
+      };
+      refuseDisposed();
       if (request.signal?.aborted) {
         await interruptAndRetire(run, "aborted-before-prompt");
         throw new Error("Hidden completion prompt aborted");
@@ -21183,6 +21647,7 @@ async function createV2HiddenCompletionExecutor(host, options) {
         handle.childSessionId = run.child.id;
       }
       await switchChildModel(run, requested);
+      refuseDisposed();
       const baseline = withReader(options.openReader, (reader) => reader.latestSequence(run.child.id));
       const marker = `mc:hidden:${crypto.randomUUID()}:${crypto.randomUUID()}`;
       run.completion = undefined;
@@ -21208,6 +21673,28 @@ async function createV2HiddenCompletionExecutor(host, options) {
         interruptAndRetire(run, "prompt-timeout").finally(() => abortReject(new Error("Hidden completion prompt timed out")));
       }, Math.max(0, deadline - Date.now()));
       request.signal?.addEventListener("abort", onAbort, { once: true });
+      let settle;
+      const entry = {
+        cancel: async (refusal) => {
+          attempt.refusal ??= refusal;
+          noteChildOfDisposedInstance(run.child.id);
+          try {
+            await interruptAndRetire(run, "plugin-instance-disposed");
+          } catch (error) {
+            note(`[magic-context] hidden child ${run.child.id} could not be interrupted on dispose: ${errorText(error)}`);
+          } finally {
+            abortReject(refusal);
+          }
+        },
+        reject: (refusal) => {
+          attempt.refusal ??= refusal;
+          abortReject(refusal);
+        },
+        settled: new Promise((resolve) => {
+          settle = resolve;
+        })
+      };
+      inFlight.add(entry);
       try {
         await Promise.race([
           host.prompt({ sessionID: run.child.id, text: marker }),
@@ -21278,6 +21765,8 @@ async function createV2HiddenCompletionExecutor(host, options) {
         clearTimeout(deadlineTimer);
         request.signal?.removeEventListener("abort", onAbort);
         options.hook.releaseAttempt(marker);
+        inFlight.delete(entry);
+        settle();
       }
     },
     async collect(handle) {
@@ -21299,9 +21788,27 @@ async function createV2HiddenCompletionExecutor(host, options) {
         }
       } finally {
         runs.delete(handle);
+        openRuns.delete(run);
         run.releaseRole();
+        run.releaseStore();
       }
       await lifecycle.finish(run.child, run.retired);
+    },
+    async dispose() {
+      disposed ??= new HiddenCompletionRefusal("hidden_instance_disposed", HIDDEN_RUN_DISPOSED_REASON, true);
+      const refusal = disposed;
+      for (const run of openRuns)
+        noteChildOfDisposedInstance(run.child.id);
+      const entries = [...inFlight];
+      if (entries.length === 0)
+        return;
+      note(`[magic-context] plugin instance disposed with ${entries.length} hidden run(s) in flight; cancelling them`);
+      const bound = options.disposeDrainMs ?? DEFAULT_DISPOSE_DRAIN_MS;
+      const deadline = Date.now() + bound;
+      await settleWithin(Promise.allSettled(entries.map((entry) => entry.cancel(refusal))), bound);
+      for (const entry of entries)
+        entry.reject(refusal);
+      await settleWithin(Promise.allSettled(entries.map((entry) => entry.settled)), deadline - Date.now());
     }
   };
 }
@@ -21588,9 +22095,9 @@ function hiddenTerminalError(event) {
 }
 
 // src/v2/hooks/lkg-system.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function identity(slot) {
-  return createHash5("sha256").update(JSON.stringify({
+  return createHash4("sha256").update(JSON.stringify({
     capturedAt: slot.capturedAt,
     captureSequence: slot.captureSequence,
     rowVersion: slot.rowVersion,
@@ -22553,7 +23060,7 @@ function resolveCtxExpandMode(args, domain) {
 }
 
 // src/tools/ctx-expand/render.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -22777,7 +23284,7 @@ function renderItemByTag(db, sessionId, number, textIndexDomain = "part") {
   const index = scoped ? Number(scoped[2]) : 0;
   const piText = message.parts.filter((part) => isRecord4(part) && part.type === "text");
   const part = message.parts[index];
-  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash6("sha256").update(part.text).digest("hex") === derived[3]) : [];
+  const matching = derived ? piText.filter((part) => isRecord4(part) && typeof part.text === "string" && createHash5("sha256").update(part.text).digest("hex") === derived[3]) : [];
   const selected = derived ? matching[Number(derived[4])] : textIndexDomain === "text" ? piText[index] : part;
   if (!selected)
     return `Tag ${number}'s original text part is no longer in stored history.`;
@@ -24128,6 +24635,7 @@ function persistV2UsageReading(args) {
 
 // src/v2/hooks/context.ts
 var HIDDEN_SESSION_ERROR_GRACE_MS = 50;
+var STORE_POOL_DISPOSE_WAIT_MS = 1000;
 
 class V2LkgAdmissionReplay extends Error {
 }
@@ -24467,6 +24975,7 @@ async function registerContext(context) {
       ensureAgent: () => hiddenAgentsReady ??= context.agent.reload(),
       modelCatalog: () => Promise.resolve(context.model.list()),
       openReader: openStoreReader,
+      holdStore: () => readerPool.hold(),
       resolveStepCap: resolveHiddenStepCap
     });
   };
@@ -25073,7 +25582,7 @@ async function registerContext(context) {
         sessionDirectoryBySession: sessionDirectories,
         projectPath: directory,
         agentBySession: agents,
-        maintenanceConfig: config.maintenance ? () => config.maintenance : undefined,
+        maintenanceConfig: config.maintenance ? () => inheritMaintenanceModelConfig(config) : undefined,
         hiddenCompletionExecutor,
         historianRunnable: !compactionOff && hiddenCompletionExecutor !== undefined && config.historian?.disable !== true,
         historianModel: historianModels.primary,
@@ -25386,6 +25895,7 @@ ${baseline}
   }, 0);
   return {
     async dispose() {
+      await hiddenCompletionExecutor?.dispose();
       rpcStopped = true;
       rpcServer.stop();
       tools?.dispose();
@@ -25396,7 +25906,8 @@ ${baseline}
         release();
       rawProviders.clear();
       restoredRows.clear();
-      readerPool.close();
+      if (!await readerPool.closeWhenIdle(STORE_POOL_DISPOSE_WAIT_MS))
+        log(`[magic-context] v2 store reader pool still held by ${readerPool.holdCount()} hidden run(s) at dispose; it closes when they finish`);
       clearSyntheticCandidates(context);
     }
   };