@cortexkit/opencode-magic-context 0.24.1 → 0.26.0

package/dist/index.js

@@ -47,20 +47,9 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/agents/dreamer.ts
-var DREAMER_AGENT = "dreamer";
-
 // src/agents/historian.ts
-var exports_historian = {};
-__export(exports_historian, {
-  HISTORIAN_EDITOR_AGENT: () => HISTORIAN_EDITOR_AGENT,
-  HISTORIAN_AGENT: () => HISTORIAN_AGENT
-});
 var HISTORIAN_AGENT = "historian", HISTORIAN_EDITOR_AGENT = "historian-editor";
 
-// src/agents/sidekick.ts
-var SIDEKICK_AGENT = "sidekick";
-
 // src/shared/jsonc-parser.ts
 import { existsSync, readFileSync } from "node:fs";
 function stripJsonComments(content) {
@@ -14879,14 +14868,16 @@ var init_magic_context = __esm(() => {
   }).optional();
   HistorianConfigSchema = AgentOverrideConfigSchema.extend({
     two_pass: exports_external.boolean().default(false).describe("Run a second editor pass over historian output to clean low-signal U: lines and cross-compartment duplicates. Adds ~1 extra API call and ~1.3x cost per historian run. Useful for models without extended thinking support. (default: false)"),
-    thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level passed as --thinking <level> to Pi historian subagent invocations. Required when using reasoning models (e.g. github-copilot/gpt-5.4) because Pi's default thinking-level resolution can pick a value the provider rejects. OpenCode users set variant instead. Valid: off | minimal | low | medium | high | xhigh")
+    thinking_level: PiThinkingLevelSchema.describe("Pi only: explicit thinking level passed as --thinking <level> to Pi historian subagent invocations. Required when using reasoning models (e.g. github-copilot/gpt-5.4) because Pi's default thinking-level resolution can pick a value the provider rejects. OpenCode users set variant instead. Valid: off | minimal | low | medium | high | xhigh"),
+    disallowed_tools: exports_external.array(exports_external.enum(["*", "read", "aft_outline", "aft_zoom", "aft_search"])).default([]).describe(`OpenCode only. Tools to REMOVE from the historian's default allow-list [read, aft_outline, aft_zoom, aft_search]. Applies to both historian and historian-editor agents. Use ["*"] to strip all tool definitions from the model request — this prevents weak instruction-following models (e.g. mistral-small-latest) from entering tool-calling loops. Individual tool names remove just that tool. Note: a user-supplied historian.permission override can re-allow a tool that disallowed_tools removed — disallowed_tools sets the baseline, permission overrides take precedence. (default: [])`)
   }).optional();
   BaseEmbeddingConfigSchema = exports_external.object({
     provider: exports_external.enum(["local", "openai-compatible", "off"]).default("local").describe("Embedding provider. 'local' uses Xenova/all-MiniLM-L6-v2, 'openai-compatible' requires endpoint and model, 'off' disables embeddings."),
     model: exports_external.string().optional().describe("Embedding model name. Required for openai-compatible, ignored for local."),
     endpoint: exports_external.string().optional().describe("API endpoint URL. Required when provider is openai-compatible."),
     api_key: exports_external.string().optional().describe("API key for remote embedding provider (optional)"),
-    input_type: exports_external.string().optional().describe("Optional input_type sent in the embedding request body. Required by some openai-compatible providers (e.g. NVIDIA NIM expects 'query' or 'passage'). Omitted from the request when unset."),
+    input_type: exports_external.string().optional().describe("Default input_type for stored/indexed (passage) embeddings in the request body. Required by some openai-compatible providers (e.g. NVIDIA NIM). Omitted from the request when unset."),
+    query_input_type: exports_external.string().optional().describe("Optional input_type for query (search) embeddings on asymmetric models (e.g. NVIDIA NIM 'query'). When unset, query embeddings use embedding.input_type. Passage/stored content always uses embedding.input_type."),
     truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset."),
     max_input_tokens: exports_external.number().int().positive().optional().describe("Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.")
   }).superRefine((data, ctx) => {
@@ -14916,6 +14907,7 @@ var init_magic_context = __esm(() => {
     if (data.provider === "openai-compatible") {
       const apiKey = data.api_key?.trim();
       const inputType = data.input_type?.trim();
+      const queryInputType = data.query_input_type?.trim();
       const truncate = data.truncate?.trim();
       return {
         provider: "openai-compatible",
@@ -14923,6 +14915,7 @@ var init_magic_context = __esm(() => {
         endpoint: data.endpoint?.trim() ?? "",
         ...apiKey ? { api_key: apiKey } : {},
         ...inputType ? { input_type: inputType } : {},
+        ...queryInputType ? { query_input_type: queryInputType } : {},
         ...truncate ? { truncate } : {},
         ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
       };
@@ -15281,58 +15274,6 @@ var init_logger = __esm(() => {
   }
 });
 
-// src/shared/model-requirements.ts
-function expandFallbackChain(chain) {
-  const models = [];
-  for (const entry of chain) {
-    for (const provider of entry.providers) {
-      models.push(`${provider}/${entry.model}`);
-    }
-  }
-  return models;
-}
-function getAgentFallbackModels(agent) {
-  const requirement = AGENT_MODEL_REQUIREMENTS[agent];
-  if (!requirement)
-    return;
-  return expandFallbackChain(requirement.fallbackChain);
-}
-var HISTORIAN_FALLBACK_CHAIN, DREAMER_FALLBACK_CHAIN, SIDEKICK_FALLBACK_CHAIN, AGENT_MODEL_REQUIREMENTS;
-var init_model_requirements = __esm(() => {
-  HISTORIAN_FALLBACK_CHAIN = [
-    { providers: ["github-copilot", "anthropic", "opencode"], model: "claude-sonnet-4-6" },
-    { providers: ["opencode-go"], model: "minimax-m2.7" },
-    {
-      providers: ["zai-coding-plan", "bailian-coding-plan", "opencode-go", "opencode"],
-      model: "glm-5"
-    },
-    { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4" },
-    { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro" }
-  ];
-  DREAMER_FALLBACK_CHAIN = [
-    { providers: ["github-copilot", "anthropic", "opencode"], model: "claude-sonnet-4-6" },
-    { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-    {
-      providers: ["zai-coding-plan", "bailian-coding-plan", "opencode-go", "opencode"],
-      model: "glm-5"
-    },
-    { providers: ["opencode-go"], model: "minimax-m2.7" },
-    { providers: ["github-copilot", "openai", "opencode"], model: "gpt-5.4-mini" }
-  ];
-  SIDEKICK_FALLBACK_CHAIN = [
-    { providers: ["cerebras"], model: "qwen-3-235b-a22b-instruct-2507" },
-    { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
-    { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4-mini" },
-    { providers: ["opencode"], model: "gpt-5-nano" }
-  ];
-  AGENT_MODEL_REQUIREMENTS = {
-    [HISTORIAN_AGENT]: { fallbackChain: HISTORIAN_FALLBACK_CHAIN },
-    [HISTORIAN_EDITOR_AGENT]: { fallbackChain: HISTORIAN_FALLBACK_CHAIN },
-    [DREAMER_AGENT]: { fallbackChain: DREAMER_FALLBACK_CHAIN },
-    [SIDEKICK_AGENT]: { fallbackChain: SIDEKICK_FALLBACK_CHAIN }
-  };
-});
-
 // src/features/magic-context/overflow-detection.ts
 function extractErrorMessage(error51) {
   if (!error51)
@@ -15446,15 +15387,9 @@ __export(exports_resolve_fallbacks, {
   resolveFallbackChain: () => resolveFallbackChain,
   parseProviderModel: () => parseProviderModel
 });
-function resolveFallbackChain(agentName, userFallbacks) {
+function resolveFallbackChain(userFallbacks) {
   const userList = normalizeUserFallbacks(userFallbacks);
-  if (userList.length > 0) {
-    return dedupe(userList.filter(isValidModelSpec));
-  }
-  const builtin = getAgentFallbackModels(agentName);
-  if (!builtin || builtin.length === 0)
-    return [];
-  return dedupe(builtin.filter(isValidModelSpec));
+  return dedupe(userList.filter(isValidModelSpec));
 }
 function normalizeUserFallbacks(userFallbacks) {
   if (!userFallbacks)
@@ -15489,9 +15424,6 @@ function parseProviderModel(spec) {
     modelID: spec.slice(slash + 1).trim()
   };
 }
-var init_resolve_fallbacks = __esm(() => {
-  init_model_requirements();
-});
 
 // src/shared/model-suggestion-retry.ts
 function extractMessage(error51) {
@@ -15562,9 +15494,11 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
     });
   } catch (error51) {
     if (signal?.aborted) {
+      await abortChildRun(client, args.path.id);
       throw new Error("prompt aborted by external signal");
     }
     if (controller.signal.aborted) {
+      await abortChildRun(client, args.path.id);
       throw new Error(`prompt timed out after ${timeoutMs}ms`);
     }
     throw error51;
@@ -15573,6 +15507,13 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
     signal?.removeEventListener("abort", onExternalAbort);
   }
 }
+async function abortChildRun(client, sessionId) {
+  try {
+    await client.session.abort({ path: { id: sessionId } });
+  } catch (error51) {
+    log(`[model-retry] child session abort failed for ${sessionId}: ${String(error51)}`);
+  }
+}
 function isNonRetryable(error51, externalSignal) {
   if (externalSignal?.aborted)
     return true;
@@ -15670,7 +15611,6 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
 var init_model_suggestion_retry = __esm(() => {
   init_overflow_detection();
   init_logger();
-  init_resolve_fallbacks();
 });
 
 // src/shared/normalize-sdk-response.ts
@@ -15700,9 +15640,7 @@ function normalizeSDKResponse(response, fallback, options) {
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_logger();
-  init_model_requirements();
   init_model_suggestion_retry();
-  init_resolve_fallbacks();
 });
 
 // src/shared/record-type-guard.ts
@@ -15844,7 +15782,7 @@ function isSessionMetaRow(row) {
   if (row === null || typeof row !== "object")
     return false;
   const r = row;
-  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state) && isBlobOrNull(r.cached_m0_bytes) && isBlobOrNull(r.cached_m1_bytes) && isNumberOrNull(r.cached_m0_project_memory_epoch) && isStringOrNull(r.cached_m0_workspace_fingerprint) && isNumberOrNull(r.cached_m0_project_user_profile_version) && isNumberOrNull(r.cached_m0_max_compartment_seq) && isNumberOrNull(r.cached_m0_max_memory_id) && isNumberOrNull(r.cached_m0_max_mutation_id) && isNumberOrNull(r.cached_m0_max_memory_mutation_id) && isStringOrNull(r.cached_m0_project_docs_hash) && isNumberOrNull(r.cached_m0_materialized_at) && isNumberOrNull(r.cached_m0_session_facts_version) && isStringOrNull(r.cached_m0_upgrade_state) && isStringOrNull(r.cached_m0_system_hash) && isStringOrNull(r.cached_m0_tool_set_hash) && isStringOrNull(r.cached_m0_model_key) && isStringOrNull(r.last_observed_model_key) && isNumberOrNull(r.last_usage_context_limit) && isNumberOrNull(r.prior_boundary_ordinal) && isNumberOrNull(r.protected_tail_policy_version) && isNumberOrNull(r.protected_tail_drain_window_started_at) && isNumberOrNull(r.protected_tail_drain_tokens) && isNumberOrNull(r.recovery_no_eligible_head_count) && isNumberOrNull(r.force_emergency_bypass_window_start) && isNumberOrNull(r.force_emergency_bypass_used) && isNumberOrNull(r.upgrade_reminded_at) && isNumberOrNull(r.pi_stable_id_scheme);
+  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state) && isBlobOrNull(r.cached_m0_bytes) && isBlobOrNull(r.cached_m1_bytes) && isNumberOrNull(r.cached_m0_project_memory_epoch) && isStringOrNull(r.cached_m0_workspace_fingerprint) && isNumberOrNull(r.cached_m0_project_user_profile_version) && isNumberOrNull(r.cached_m0_max_compartment_seq) && isNumberOrNull(r.cached_m0_max_memory_id) && isNumberOrNull(r.cached_m0_max_mutation_id) && isNumberOrNull(r.cached_m0_max_memory_mutation_id) && isStringOrNull(r.cached_m0_project_docs_hash) && isNumberOrNull(r.cached_m0_materialized_at) && isNumberOrNull(r.cached_m0_session_facts_version) && isStringOrNull(r.cached_m0_upgrade_state) && isStringOrNull(r.cached_m0_system_hash) && isStringOrNull(r.cached_m0_tool_set_hash) && isStringOrNull(r.cached_m0_model_key) && isStringOrNull(r.last_observed_model_key) && isNumberOrNull(r.last_usage_context_limit) && isNumberOrNull(r.prior_boundary_ordinal) && isNumberOrNull(r.protected_tail_policy_version) && isNumberOrNull(r.protected_tail_drain_window_started_at) && isNumberOrNull(r.protected_tail_drain_tokens) && isNumberOrNull(r.recovery_no_eligible_head_count) && isNumberOrNull(r.force_emergency_bypass_window_start) && isNumberOrNull(r.force_emergency_bypass_used) && isNumberOrNull(r.upgrade_reminded_at) && isNumberOrNull(r.pi_stable_id_scheme) && isNumberOrNull(r.tool_reclaim_watermark);
 }
 function getDefaultSessionMeta(sessionId) {
   return {
@@ -15867,6 +15805,7 @@ function getDefaultSessionMeta(sessionId) {
     conversationTokens: 0,
     toolCallTokens: 0,
     clearedReasoningThroughTag: 0,
+    toolReclaimWatermark: 0,
     lastTodoState: "",
     cachedM0Bytes: null,
     cachedM1Bytes: null,
@@ -15930,6 +15869,7 @@ function toSessionMeta(row) {
     conversationTokens: numOrZero(row.conversation_tokens),
     toolCallTokens: numOrZero(row.tool_call_tokens),
     clearedReasoningThroughTag: numOrZero(row.cleared_reasoning_through_tag),
+    toolReclaimWatermark: numOrZero(row.tool_reclaim_watermark),
     lastTodoState: lastTodoStateRaw,
     cachedM0Bytes: toBufferOrNull(row.cached_m0_bytes),
     cachedM1Bytes: toBufferOrNull(row.cached_m1_bytes),
@@ -16039,6 +15979,7 @@ var init_storage_meta_shared = __esm(() => {
     "conversation_tokens",
     "tool_call_tokens",
     "cleared_reasoning_through_tag",
+    "tool_reclaim_watermark",
     "last_todo_state",
     "cached_m0_bytes",
     "cached_m1_bytes",
@@ -16065,6 +16006,8 @@ var init_storage_meta_shared = __esm(() => {
     "recovery_no_eligible_head_count",
     "force_emergency_bypass_window_start",
     "force_emergency_bypass_used",
+    "emergency_drain_active",
+    "historian_drain_failure_at",
     "upgrade_reminded_at",
     "pi_stable_id_scheme"
   ];
@@ -16087,6 +16030,7 @@ var init_storage_meta_shared = __esm(() => {
     conversationTokens: "conversation_tokens",
     toolCallTokens: "tool_call_tokens",
     clearedReasoningThroughTag: "cleared_reasoning_through_tag",
+    toolReclaimWatermark: "tool_reclaim_watermark",
     lastTodoState: "last_todo_state",
     cachedM0Bytes: "cached_m0_bytes",
     cachedM1Bytes: "cached_m1_bytes",
@@ -16113,6 +16057,8 @@ var init_storage_meta_shared = __esm(() => {
     recoveryNoEligibleHeadCount: "recovery_no_eligible_head_count",
     forceEmergencyBypassWindowStart: "force_emergency_bypass_window_start",
     forceEmergencyBypassUsed: "force_emergency_bypass_used",
+    emergencyDrainActive: "emergency_drain_active",
+    historianDrainFailureAt: "historian_drain_failure_at",
     upgradeRemindedAt: "upgrade_reminded_at",
     piStableIdScheme: "pi_stable_id_scheme"
   };
@@ -16363,6 +16309,14 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
       }
       super(typeof filename === "string" ? filename : ":memory:", translated);
     }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
     transaction(fn) {
       const self = this;
       const wrapped = function(...args) {
@@ -149339,6 +149293,9 @@ function stripCompleteTagPairsGlobally(value) {
 function stripMalformedTagNotationGlobally(value) {
   return value.replace(MALFORMED_TAG_GLOBAL_REGEX, "");
 }
+function stripDanglingTagNotationGlobally(value) {
+  return value.replace(DANGLING_TAG_GLOBAL_REGEX, "");
+}
 function stripTagSectionCharacters(value) {
   return value.replace(STRAY_SECTION_CHAR_REGEX, "");
 }
@@ -149346,6 +149303,7 @@ function stripPersistedAssistantText(value) {
   let text = stripWellFormedLeadingTagPrefix(value);
   text = stripCompleteTagPairsGlobally(text);
   text = stripMalformedTagNotationGlobally(text);
+  text = stripDanglingTagNotationGlobally(text);
   text = stripTagSectionCharacters(text);
   return text.trim();
 }
@@ -149358,6 +149316,7 @@ function stripTagPrefix(value) {
     const prev = stripped;
     stripped = stripped.replace(MALFORMED_TAG_PREFIX_REGEX, "");
     stripped = stripped.replace(TAG_PREFIX_REGEX, "");
+    stripped = stripped.replace(DANGLING_TAG_PREFIX_REGEX, "");
     if (stripped === prev)
       break;
   }
@@ -149379,11 +149338,13 @@ function isThinkingPart(part) {
   const candidate = part;
   return candidate.type === "thinking" || candidate.type === "reasoning";
 }
-var encoder, TAG_PREFIX_REGEX, MALFORMED_TAG_PREFIX_REGEX, COMPLETE_TAG_PAIR_GLOBAL_REGEX, MALFORMED_TAG_GLOBAL_REGEX, STRAY_SECTION_CHAR_REGEX;
+var encoder, TAG_PREFIX_REGEX, MALFORMED_TAG_PREFIX_REGEX, DANGLING_TAG_GLOBAL_REGEX, DANGLING_TAG_PREFIX_REGEX, COMPLETE_TAG_PAIR_GLOBAL_REGEX, MALFORMED_TAG_GLOBAL_REGEX, STRAY_SECTION_CHAR_REGEX;
 var init_tag_content_primitives = __esm(() => {
   encoder = new TextEncoder;
   TAG_PREFIX_REGEX = /^(?:§\d+§\s*)+/;
   MALFORMED_TAG_PREFIX_REGEX = /^(?:§\d+">§(?:\d+§)?\s*)+/;
+  DANGLING_TAG_GLOBAL_REGEX = /\u00a7\d+(?!\.\d)[^\s\u00a7\w.]?/g;
+  DANGLING_TAG_PREFIX_REGEX = /^(?:\u00a7\d+(?!\.\d)[^\s\u00a7\w.]?\s*)+/;
   COMPLETE_TAG_PAIR_GLOBAL_REGEX = /\u00a7\d+\u00a7/g;
   MALFORMED_TAG_GLOBAL_REGEX = /\u00a7\d+">(?:\u00a7(?:\d+\u00a7)?)?/g;
   STRAY_SECTION_CHAR_REGEX = /\u00a7/g;
@@ -149447,12 +149408,13 @@ function setToolContent(part, content) {
     part.content = content;
   }
 }
-function truncateToolPart(part) {
+function truncateToolPart(part, tagId) {
   if (!isRecord(part))
     return;
+  const sentinel = `[dropped §${tagId}§]`;
   if (part.type === "tool" && isRecord(part.state)) {
     const state = part.state;
-    state.output = "[truncated]";
+    state.output = sentinel;
     if (isRecord(state.input)) {
       const inputSize = estimateInputSize(state.input);
       if (inputSize > 500) {
@@ -149462,7 +149424,7 @@ function truncateToolPart(part) {
     return;
   }
   if (part.type === "tool_result") {
-    part.content = "[truncated]";
+    part.content = sentinel;
     return;
   }
   if (part.type === "tool-invocation" && isRecord(part.args)) {
@@ -149579,7 +149541,7 @@ class ToolMutationBatch {
     this.affectedMessages.clear();
   }
 }
-function createToolDropTarget(compositeKey, thinkingParts, index, batch) {
+function createToolDropTarget(compositeKey, thinkingParts, index, batch, tagId) {
   const drop = () => {
     const entry = index.get(compositeKey);
     if (!entry || entry.occurrences.length === 0)
@@ -149600,7 +149562,7 @@ function createToolDropTarget(compositeKey, thinkingParts, index, batch) {
     if (!entry.hasResult)
       return "incomplete";
     for (const occurrence of entry.occurrences) {
-      truncateToolPart(occurrence.part);
+      truncateToolPart(occurrence.part, tagId);
     }
     clearThinkingParts(thinkingParts);
     return "truncated";
@@ -149648,6 +149610,22 @@ var init_tool_drop_target = __esm(() => {
 });
 
 // src/hooks/magic-context/read-session-chunk.ts
+function estimateBlockTokens(blockText) {
+  const cached2 = blockTokenMemo.get(blockText);
+  if (cached2 !== undefined) {
+    blockTokenMemo.delete(blockText);
+    blockTokenMemo.set(blockText, cached2);
+    return cached2;
+  }
+  const count = estimateTokens(blockText);
+  if (blockTokenMemo.size >= BLOCK_TOKEN_MEMO_MAX) {
+    const oldest = blockTokenMemo.keys().next().value;
+    if (oldest !== undefined)
+      blockTokenMemo.delete(oldest);
+  }
+  blockTokenMemo.set(blockText, count);
+  return count;
+}
 function cleanUserText(text) {
   return removeSystemReminders(text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
 }
@@ -149815,7 +149793,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     if (!currentBlock)
       return true;
     const blockText = formatBlock(currentBlock);
-    const blockTokens = estimateTokens(blockText);
+    const blockTokens = estimateBlockTokens(blockText);
     if (totalTokens + blockTokens > tokenBudget && totalTokens > 0) {
       return false;
     }
@@ -149933,13 +149911,14 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     toolOnlyRanges
   };
 }
-var activeRawMessageCache = null, activeAbsoluteCountCache = null, sessionProviders, PROTECTED_TAIL_USER_TURNS = 5;
+var BLOCK_TOKEN_MEMO_MAX = 2048, blockTokenMemo, activeRawMessageCache = null, activeAbsoluteCountCache = null, sessionProviders, PROTECTED_TAIL_USER_TURNS = 5;
 var init_read_session_chunk = __esm(async () => {
   init_read_session_formatting();
   init_tag_part_guards();
   init_tool_drop_target();
   init_read_session_formatting();
   await init_read_session_db();
+  blockTokenMemo = new Map;
   sessionProviders = new Map;
 });
 
@@ -150684,6 +150663,9 @@ function resolveDatabasePath(dbPathOverride) {
   const dbDir = getMagicContextStorageDir();
   return { dbDir, dbPath: join6(dbDir, "context.db") };
 }
+function getDatabasePath(db) {
+  return pathByDatabase.get(db) ?? null;
+}
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   if (existsSync7(targetDbPath))
     return;
@@ -151194,6 +151176,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       recovery_no_eligible_head_count INTEGER NOT NULL DEFAULT 0,
       force_emergency_bypass_window_start INTEGER NOT NULL DEFAULT 0,
       force_emergency_bypass_used INTEGER NOT NULL DEFAULT 0,
+      emergency_drain_active INTEGER NOT NULL DEFAULT 0,
+      historian_drain_failure_at INTEGER NOT NULL DEFAULT 0,
       cached_m0_materialized_at INTEGER,
       cached_m0_session_facts_version INTEGER,
       cached_m0_upgrade_state TEXT,
@@ -151257,6 +151241,23 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     CREATE INDEX IF NOT EXISTS idx_historian_runs_status
       ON historian_runs(status, created_at DESC);
 
+    CREATE TABLE IF NOT EXISTS transform_decisions (
+      session_id         TEXT    NOT NULL,
+      harness            TEXT    NOT NULL DEFAULT 'opencode',
+      message_id         TEXT    NOT NULL,
+      ts_ms              INTEGER NOT NULL,
+      decision           TEXT    NOT NULL,
+      materialized       INTEGER NOT NULL DEFAULT 0,
+      materialize_reason TEXT,
+      emergency          INTEGER NOT NULL DEFAULT 0,
+      dropped_tokens     INTEGER NOT NULL DEFAULT 0,
+      dropped_count      INTEGER NOT NULL DEFAULT 0,
+      input_tokens       INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (session_id, harness, message_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
+      ON transform_decisions(session_id, harness);
+
     CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
     CREATE INDEX IF NOT EXISTS idx_tags_session_message_id ON tags(session_id, message_id);
     CREATE INDEX IF NOT EXISTS idx_pending_ops_session ON pending_ops(session_id);
@@ -151334,6 +151335,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "historian_last_failure_at", "INTEGER DEFAULT NULL");
   ensureColumn(db, "session_meta", "system_prompt_hash", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "cleared_reasoning_through_tag", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "tool_reclaim_watermark", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "stripped_placeholder_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "stale_reduce_stripped_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "processed_image_stripped_ids", "TEXT DEFAULT ''");
@@ -151407,6 +151409,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "recovery_no_eligible_head_count", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "force_emergency_bypass_window_start", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "force_emergency_bypass_used", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "emergency_drain_active", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "historian_drain_failure_at", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "cached_m0_materialized_at", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_session_facts_version", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_upgrade_state", "TEXT");
@@ -151485,6 +151489,22 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         failed_at INTEGER NOT NULL,
         UNIQUE(table_name, row_id)
       );
+      CREATE TABLE IF NOT EXISTS transform_decisions (
+        session_id         TEXT    NOT NULL,
+        harness            TEXT    NOT NULL DEFAULT 'opencode',
+        message_id         TEXT    NOT NULL,
+        ts_ms              INTEGER NOT NULL,
+        decision           TEXT    NOT NULL,
+        materialized       INTEGER NOT NULL DEFAULT 0,
+        materialize_reason TEXT,
+        emergency          INTEGER NOT NULL DEFAULT 0,
+        dropped_tokens     INTEGER NOT NULL DEFAULT 0,
+        dropped_count      INTEGER NOT NULL DEFAULT 0,
+        input_tokens       INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (session_id, harness, message_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
+        ON transform_decisions(session_id, harness);
     `);
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -151570,7 +151590,9 @@ function healNullIntegerColumns(db) {
     ["protected_tail_drain_tokens", 0],
     ["recovery_no_eligible_head_count", 0],
     ["force_emergency_bypass_window_start", 0],
-    ["force_emergency_bypass_used", 0]
+    ["force_emergency_bypass_used", 0],
+    ["emergency_drain_active", 0],
+    ["historian_drain_failure_at", 0]
   ];
   for (const [column, fallback] of columns) {
     try {
@@ -151646,6 +151668,7 @@ function openDatabase(dbPathOrOptions) {
     setDatabase(db);
     loadToolDefinitionMeasurements(db);
     databases.set(dbPath, db);
+    pathByDatabase.set(db, dbPath);
     persistenceByDatabase.set(db, true);
     persistenceErrorByDatabase.delete(db);
     return db;
@@ -151665,7 +151688,7 @@ function getDatabasePersistenceError(db) {
     return null;
   return persistenceErrorByDatabase.get(db) ?? null;
 }
-var databases, persistenceByDatabase, persistenceErrorByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 36, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
+var databases, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 38, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -151679,6 +151702,7 @@ var init_storage_db = __esm(async () => {
   databases = new Map;
   persistenceByDatabase = new WeakMap;
   persistenceErrorByDatabase = new WeakMap;
+  pathByDatabase = new WeakMap;
   sqlitePragmaConfig = {
     cacheSizeMb: 64,
     mmapSizeMb: 0
@@ -152997,6 +153021,41 @@ var init_migrations = __esm(async () => {
                 `);
         }
       }
+    },
+    {
+      version: 37,
+      description: "emergency drain catch-up latch + historian drain failure backoff",
+      up: (db) => {
+        const hasSessionMeta = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_meta'").get();
+        if (!hasSessionMeta)
+          return;
+        ensureColumn(db, "session_meta", "emergency_drain_active", "INTEGER NOT NULL DEFAULT 0");
+        ensureColumn(db, "session_meta", "historian_drain_failure_at", "INTEGER NOT NULL DEFAULT 0");
+      }
+    },
+    {
+      version: 38,
+      description: "durable transform decisions for cache-event cause attribution",
+      up: (db) => {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS transform_decisions (
+                    session_id         TEXT    NOT NULL,
+                    harness            TEXT    NOT NULL DEFAULT 'opencode',
+                    message_id         TEXT    NOT NULL,
+                    ts_ms              INTEGER NOT NULL,
+                    decision           TEXT    NOT NULL,
+                    materialized       INTEGER NOT NULL DEFAULT 0,
+                    materialize_reason TEXT,
+                    emergency          INTEGER NOT NULL DEFAULT 0,
+                    dropped_tokens     INTEGER NOT NULL DEFAULT 0,
+                    dropped_count      INTEGER NOT NULL DEFAULT 0,
+                    input_tokens       INTEGER NOT NULL DEFAULT 0,
+                    PRIMARY KEY (session_id, harness, message_id)
+                );
+                CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
+                    ON transform_decisions(session_id, harness);
+            `);
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -153401,7 +153460,9 @@ function toProtectedTailMeta(row) {
     protectedTailDrainTokens: numberOr(r.protected_tail_drain_tokens, 0),
     recoveryNoEligibleHeadCount: numberOr(r.recovery_no_eligible_head_count, 0),
     forceEmergencyBypassWindowStart: numberOr(r.force_emergency_bypass_window_start, 0),
-    forceEmergencyBypassUsed: numberOr(r.force_emergency_bypass_used, 0)
+    forceEmergencyBypassUsed: numberOr(r.force_emergency_bypass_used, 0),
+    emergencyDrainActive: numberOr(r.emergency_drain_active, 0),
+    historianDrainFailureAt: numberOr(r.historian_drain_failure_at, 0)
   };
 }
 function loadProtectedTailMeta(db, sessionId) {
@@ -153409,7 +153470,7 @@ function loadProtectedTailMeta(db, sessionId) {
   const row = db.prepare(`SELECT prior_boundary_ordinal, protected_tail_policy_version,
                     protected_tail_drain_window_started_at, protected_tail_drain_tokens,
                     recovery_no_eligible_head_count, force_emergency_bypass_window_start,
-                    force_emergency_bypass_used
+                    force_emergency_bypass_used, emergency_drain_active, historian_drain_failure_at
              FROM session_meta WHERE session_id = ?`).get(sessionId);
   return toProtectedTailMeta(row);
 }
@@ -153458,6 +153519,12 @@ function protectedTailWindowBudget(usagePercentage, usable, perRunCap) {
     return Math.min(750000, Math.max(3 * perRunCap, Math.round(0.35 * usable)));
   return Math.min(500000, Math.max(perRunCap, Math.round(0.2 * usable)));
 }
+function emergencyDrainExitThreshold(executeThresholdPercentage) {
+  if (!Number.isFinite(executeThresholdPercentage) || executeThresholdPercentage <= 0) {
+    return EMERGENCY_DRAIN_FALLBACK_EXIT_PERCENTAGE;
+  }
+  return Math.max(0, executeThresholdPercentage - EMERGENCY_DRAIN_EXIT_MARGIN);
+}
 function reserveProtectedTailDrainTokens(args) {
   const now = args.now ?? Date.now();
   const requested = Math.max(0, Math.floor(args.trueRawTokens));
@@ -153476,18 +153543,30 @@ function reserveProtectedTailDrainTokens(args) {
     let meta3 = loadProtectedTailMeta(args.db, args.sessionId);
     if (now - meta3.protectedTailDrainWindowStartedAt > DRAIN_WINDOW_MS) {
       args.db.prepare(`UPDATE session_meta
-                     SET protected_tail_drain_window_started_at = ?, protected_tail_drain_tokens = 0,
-                         force_emergency_bypass_window_start = ?, force_emergency_bypass_used = 0
-                     WHERE session_id = ?`).run(now, now, args.sessionId);
+                     SET protected_tail_drain_window_started_at = ?, protected_tail_drain_tokens = 0
+                     WHERE session_id = ?`).run(now, args.sessionId);
       meta3 = loadProtectedTailMeta(args.db, args.sessionId);
     }
+    const exitThreshold = emergencyDrainExitThreshold(args.executeThresholdPercentage);
+    let latchActiveSince = meta3.emergencyDrainActive;
+    if (args.usagePercentage >= EMERGENCY_DRAIN_ENTER_PERCENTAGE) {
+      if (latchActiveSince <= 0)
+        latchActiveSince = now;
+    } else if (latchActiveSince > 0) {
+      const expired = now - latchActiveSince > EMERGENCY_DRAIN_MAX_LATCH_MS;
+      if (args.usagePercentage < exitThreshold || expired)
+        latchActiveSince = 0;
+    }
+    if (latchActiveSince !== meta3.emergencyDrainActive) {
+      args.db.prepare("UPDATE session_meta SET emergency_drain_active = ? WHERE session_id = ?").run(latchActiveSince, args.sessionId);
+    }
+    const latchActive = latchActiveSince > 0;
     const budget = protectedTailWindowBudget(args.usagePercentage, args.usable, args.perRunCap);
     const remaining = Math.max(0, budget - meta3.protectedTailDrainTokens);
     let reserved = Math.min(requested, args.perRunCap, remaining);
     let bypass = false;
-    const bypassWindowExpired = now - meta3.forceEmergencyBypassWindowStart > DRAIN_WINDOW_MS;
-    const bypassUsed = bypassWindowExpired ? 0 : meta3.forceEmergencyBypassUsed;
-    if (reserved <= 0 && args.usagePercentage >= 95 && bypassUsed === 0) {
+    const inFailureBackoff = meta3.historianDrainFailureAt > 0 && now - meta3.historianDrainFailureAt < EMERGENCY_DRAIN_FAILURE_BACKOFF_MS;
+    if (reserved <= 0 && latchActive && !inFailureBackoff) {
       reserved = Math.min(requested, args.perRunCap);
       bypass = true;
     }
@@ -153495,10 +153574,8 @@ function reserveProtectedTailDrainTokens(args) {
       return;
     args.db.prepare(`UPDATE session_meta
                  SET protected_tail_drain_window_started_at = CASE WHEN protected_tail_drain_window_started_at = 0 THEN ? ELSE protected_tail_drain_window_started_at END,
-                     protected_tail_drain_tokens = COALESCE(protected_tail_drain_tokens, 0) + ?,
-                     force_emergency_bypass_window_start = CASE WHEN ? THEN ? ELSE force_emergency_bypass_window_start END,
-                     force_emergency_bypass_used = CASE WHEN ? THEN 1 ELSE force_emergency_bypass_used END
-                 WHERE session_id = ?`).run(now, reserved, bypass ? 1 : 0, now, bypass ? 1 : 0, args.sessionId);
+                     protected_tail_drain_tokens = COALESCE(protected_tail_drain_tokens, 0) + ?
+                 WHERE session_id = ?`).run(now, reserved, args.sessionId);
     result = {
       ok: true,
       reservedTokens: reserved,
@@ -153508,6 +153585,25 @@ function reserveProtectedTailDrainTokens(args) {
   })();
   return result;
 }
+function clearEmergencyDrainLatch(db, sessionId) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET emergency_drain_active = 0 WHERE session_id = ?").run(sessionId);
+  })();
+}
+function recordHistorianDrainFailure(db, sessionId, now) {
+  const ts = now ?? Date.now();
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET historian_drain_failure_at = ? WHERE session_id = ?").run(ts, sessionId);
+  })();
+}
+function clearHistorianDrainFailure(db, sessionId) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET historian_drain_failure_at = 0 WHERE session_id = ?").run(sessionId);
+  })();
+}
 function rollbackProtectedTailDrainReservation(db, reservation) {
   if (!reservation || reservation.tokens <= 0)
     return;
@@ -154075,7 +154171,7 @@ function setSessionWorkMetrics(db, sessionId, newWorkTokens, totalInputTokens) {
          SET new_work_tokens = ?, total_input_tokens = ?
          WHERE session_id = ?`).run(Math.max(0, Math.floor(newWorkTokens)), Math.max(0, Math.floor(totalInputTokens)), sessionId);
 }
-var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS, DEFAULT_PROTECTED_TAIL_META, DRAIN_WINDOW_MS;
+var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS, DEFAULT_PROTECTED_TAIL_META, DRAIN_WINDOW_MS, EMERGENCY_DRAIN_ENTER_PERCENTAGE = 95, EMERGENCY_DRAIN_EXIT_MARGIN = 10, EMERGENCY_DRAIN_FALLBACK_EXIT_PERCENTAGE = 55, EMERGENCY_DRAIN_FAILURE_BACKOFF_MS = 60000, EMERGENCY_DRAIN_MAX_LATCH_MS;
 var init_storage_meta_persisted = __esm(() => {
   init_logger();
   init_storage_meta_shared();
@@ -154094,9 +154190,12 @@ var init_storage_meta_persisted = __esm(() => {
     protectedTailDrainTokens: 0,
     recoveryNoEligibleHeadCount: 0,
     forceEmergencyBypassWindowStart: 0,
-    forceEmergencyBypassUsed: 0
+    forceEmergencyBypassUsed: 0,
+    emergencyDrainActive: 0,
+    historianDrainFailureAt: 0
   };
   DRAIN_WINDOW_MS = 10 * 60 * 1000;
+  EMERGENCY_DRAIN_MAX_LATCH_MS = 30 * 60 * 1000;
 });
 
 // src/features/magic-context/resolve-subagent-fallback.ts
@@ -154123,7 +154222,8 @@ var exports_storage_meta_session = {};
 __export(exports_storage_meta_session, {
   updateSessionMeta: () => updateSessionMeta,
   getOrCreateSessionMeta: () => getOrCreateSessionMeta,
-  clearSession: () => clearSession
+  clearSession: () => clearSession,
+  advanceToolReclaimWatermark: () => advanceToolReclaimWatermark
 });
 import { Buffer as Buffer3 } from "node:buffer";
 function getSessionMetaSelectColumns(db) {
@@ -154184,6 +154284,14 @@ function updateSessionMeta(db, sessionId, updates) {
     db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")} WHERE session_id = ?`).run(...values, sessionId);
   })();
 }
+function advanceToolReclaimWatermark(db, sessionId, maxTagNumber) {
+  if (maxTagNumber <= 0)
+    return;
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET tool_reclaim_watermark = MAX(COALESCE(tool_reclaim_watermark, 0), ?) WHERE session_id = ?").run(maxTagNumber, sessionId);
+  })();
+}
 function clearSession(db, sessionId) {
   db.transaction(() => {
     db.prepare("DELETE FROM pending_ops WHERE session_id = ?").run(sessionId);
@@ -154205,6 +154313,7 @@ function clearSession(db, sessionId) {
     db.prepare("DELETE FROM subagent_invocations WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM historian_runs WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM plugin_messages WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM transform_decisions WHERE session_id = ?").run(sessionId);
     clearIndexedMessages(db, sessionId);
   })();
 }
@@ -154222,6 +154331,7 @@ var init_storage_meta_session = __esm(async () => {
     last_transform_error: "'' AS last_transform_error",
     system_prompt_hash: "'' AS system_prompt_hash",
     last_todo_state: "'' AS last_todo_state",
+    tool_reclaim_watermark: "0 AS tool_reclaim_watermark",
     cached_m0_bytes: "NULL AS cached_m0_bytes",
     cached_m1_bytes: "NULL AS cached_m1_bytes",
     cached_m0_project_memory_epoch: "NULL AS cached_m0_project_memory_epoch",
@@ -154629,12 +154739,37 @@ function getActiveTagTokenAggregate(db, sessionId, protectedTags = 0) {
     nullCount: row?.null_count ?? 0
   };
 }
-function getTriggerTagTokenUpperBound(db, sessionId) {
-  const row = db.prepare(`SELECT
+function getOldestActiveUnprotectedToolTags(db, sessionId, protectedTags = 0, limit = 4) {
+  if (limit <= 0)
+    return [];
+  const boundedLimit = Math.max(1, Math.min(10, Math.floor(limit)));
+  const whereProtected = protectedTags > 0 ? `AND tag_number < (
+                    SELECT tag_number FROM tags
+                    WHERE session_id = ? AND status = 'active'
+                    ORDER BY tag_number DESC LIMIT 1 OFFSET ?
+                )` : "";
+  const params = protectedTags > 0 ? [sessionId, sessionId, protectedTags - 1, boundedLimit] : [sessionId, boundedLimit];
+  const rows = db.prepare(`SELECT tag_number, tool_name
+             FROM tags
+             WHERE session_id = ? AND status = 'active' AND type = 'tool' ${whereProtected}
+             ORDER BY tag_number ASC, id ASC
+             LIMIT ?`).all(...params);
+  return rows.filter((row) => typeof row.tag_number === "number").map((row) => ({
+    tagNumber: row.tag_number,
+    toolName: typeof row.tool_name === "string" ? row.tool_name : null
+  }));
+}
+function getTriggerTagTokenUpperBound(db, sessionId, floor = 0) {
+  const sql = floor > 0 ? `SELECT
+                COALESCE(SUM(COALESCE(token_count, 0) + COALESCE(input_token_count, 0) + COALESCE(reasoning_token_count, 0)), 0) AS bound,
+                COALESCE(SUM(CASE WHEN token_count IS NULL THEN 1 ELSE 0 END), 0) AS null_count
+             FROM tags
+             WHERE session_id = ? AND status IN ('active', 'dropped') AND tag_number >= ?` : `SELECT
                 COALESCE(SUM(COALESCE(token_count, 0) + COALESCE(input_token_count, 0) + COALESCE(reasoning_token_count, 0)), 0) AS bound,
                 COALESCE(SUM(CASE WHEN token_count IS NULL THEN 1 ELSE 0 END), 0) AS null_count
              FROM tags
-             WHERE session_id = ? AND status IN ('active', 'dropped')`).get(sessionId);
+             WHERE session_id = ? AND status IN ('active', 'dropped')`;
+  const row = floor > 0 ? db.prepare(sql).get(sessionId, floor) : db.prepare(sql).get(sessionId);
   return { bound: row?.bound ?? 0, nullCount: row?.null_count ?? 0 };
 }
 function getActiveTagTokenTotalsByMessage(db, sessionId) {
@@ -154663,10 +154798,12 @@ function getActiveTagTokenTotalsByMessage(db, sessionId) {
   }
   return out;
 }
-function getAllStatusTagTokenTotalsFlat(db, sessionId) {
-  const rows = db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
-             FROM tags
-             WHERE session_id = ?`).all(sessionId);
+function getAllStatusTagTokenTotalsFlat(db, sessionId, floor = 0) {
+  const rows = floor > 0 ? db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
+                       FROM tags
+                       WHERE session_id = ? AND tag_number >= ?`).all(sessionId, floor) : db.prepare(`SELECT type, message_id, tool_owner_message_id, token_count, input_token_count, reasoning_token_count
+                       FROM tags
+                       WHERE session_id = ?`).all(sessionId);
   const totals = new Map;
   const nullMessageIds = new Set;
   for (const row of rows) {
@@ -154825,6 +154962,47 @@ function getTagNumberByMessageId(db, sessionId, messageId) {
   const row = getTagNumberByMessageIdStatement(db).get(sessionId, messageId);
   return isTagNumberRow(row) ? row.tag_number : null;
 }
+function isMinTagNumberRow(row) {
+  return row !== null && typeof row === "object" && "m" in row;
+}
+function getMinMessageTagNumberForRawId(db, sessionId, rawId) {
+  if (rawId.includes(":"))
+    return null;
+  let stmt = getMinMessageTagNumberForRawIdStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT MIN(tag_number) AS m FROM tags WHERE session_id = ? AND message_id >= ? AND message_id < ?");
+    getMinMessageTagNumberForRawIdStatements.set(db, stmt);
+  }
+  const row = stmt.get(sessionId, `${rawId}:`, `${rawId};`);
+  return isMinTagNumberRow(row) && typeof row.m === "number" ? row.m : null;
+}
+function deriveTagLoadFloor(db, sessionId, rawIds) {
+  let min = Number.POSITIVE_INFINITY;
+  let probes = 0;
+  let hits = 0;
+  let skippedBeforeFirstHit = 0;
+  for (const rawId of rawIds) {
+    if (typeof rawId !== "string" || rawId.length === 0)
+      continue;
+    if (probes >= TAGGER_FLOOR_MAX_PROBES)
+      break;
+    probes++;
+    const m = getMinMessageTagNumberForRawId(db, sessionId, rawId);
+    if (m === null) {
+      if (hits === 0)
+        skippedBeforeFirstHit++;
+      continue;
+    }
+    if (m < min)
+      min = m;
+    if (++hits >= TAGGER_FLOOR_SCAN_MESSAGES)
+      break;
+  }
+  if (!Number.isFinite(min))
+    return 0;
+  const margin = TAGGER_FLOOR_SAFETY_MARGIN + skippedBeforeFirstHit * TAGGER_FLOOR_PER_SKIP_MARGIN;
+  return Math.max(0, min - margin);
+}
 function getTagsBySession(db, sessionId) {
   const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC`).all(sessionId).filter(isTagRow);
   return rows.map(toTagEntry);
@@ -154963,7 +155141,7 @@ function deleteToolTagsByOwner(db, sessionId, ownerMsgId) {
   const result = getDeleteToolTagsByOwnerStatement(db).run(sessionId, ownerMsgId);
   return result.changes ?? 0;
 }
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, CONTENT_ID_SUFFIX, updateTagTokenCountStatements, updateTagInputTokenCountStatements, getOwnerScopedToolTagNumbersStatements, TAG_SELECT_COLUMNS = "id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth, tool_owner_message_id", getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, CONTENT_ID_SUFFIX, updateTagTokenCountStatements, updateTagInputTokenCountStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, TAGGER_FLOOR_SCAN_MESSAGES = 8, TAGGER_FLOOR_MAX_PROBES = 64, TAGGER_FLOOR_SAFETY_MARGIN = 256, TAGGER_FLOOR_PER_SKIP_MARGIN = 64, TAG_SELECT_COLUMNS = "id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth, tool_owner_message_id", getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(() => {
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
@@ -154979,6 +155157,7 @@ var init_storage_tags = __esm(() => {
   updateTagTokenCountStatements = new WeakMap;
   updateTagInputTokenCountStatements = new WeakMap;
   getOwnerScopedToolTagNumbersStatements = new WeakMap;
+  getMinMessageTagNumberForRawIdStatements = new WeakMap;
   getActiveTagsBySessionStatements = new WeakMap;
   getMaxDroppedTagNumberStatements = new WeakMap;
   getToolTagNumberByOwnerStatements = new WeakMap;
@@ -163972,6 +164151,58 @@ var init_safe_notification_target = __esm(() => {
   DEFAULT_TITLE_RE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
 });
 
+// src/shared/rpc-notifications.ts
+var exports_rpc_notifications = {};
+__export(exports_rpc_notifications, {
+  pushNotification: () => pushNotification,
+  isTuiConnected: () => isTuiConnected,
+  drainNotifications: () => drainNotifications
+});
+function pushNotification(type, payload, sessionId) {
+  queue.push({ id: nextNotificationId++, type, payload, sessionId });
+  if (queue.length > 100) {
+    const newestPerSession = new Map;
+    for (const n of queue) {
+      const prev = newestPerSession.get(n.sessionId);
+      if (prev === undefined || n.id > prev) {
+        newestPerSession.set(n.sessionId, n.id);
+      }
+    }
+    const mustKeep = new Set(newestPerSession.values());
+    const byNewest = [...queue].sort((a, b) => b.id - a.id);
+    const kept = [];
+    for (const n of byNewest) {
+      if (kept.length < 50 || mustKeep.has(n.id))
+        kept.push(n);
+    }
+    queue = kept.sort((a, b) => a.id - b.id);
+  }
+}
+function drainNotifications(lastReceivedId = 0, sessionId) {
+  const now = Date.now();
+  lastDrainAtAny = now;
+  if (sessionId !== undefined)
+    lastDrainAtBySession.set(sessionId, now);
+  const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
+  if (lastReceivedId > 0) {
+    queue = queue.filter((notification) => !(notification.id <= lastReceivedId && matchesClient(notification)));
+  }
+  return queue.filter((notification) => notification.id > lastReceivedId && matchesClient(notification));
+}
+function isTuiConnected(sessionId) {
+  const now = Date.now();
+  if (sessionId !== undefined) {
+    const at = lastDrainAtBySession.get(sessionId) ?? 0;
+    return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS;
+  }
+  return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS;
+}
+var queue, nextNotificationId = 1, lastDrainAtBySession, lastDrainAtAny = 0, TUI_CONNECTED_WINDOW_MS = 3000;
+var init_rpc_notifications = __esm(() => {
+  queue = [];
+  lastDrainAtBySession = new Map;
+});
+
 // src/plugin/conflict-warning-hook.ts
 var exports_conflict_warning_hook = {};
 __export(exports_conflict_warning_hook, {
@@ -164306,6 +164537,9 @@ async function sendStartupAnnouncement(client, directory, version2, features, fo
   if (!sessionId) {
     return;
   }
+  const { isTuiConnected: isTuiConnected2 } = await Promise.resolve().then(() => (init_rpc_notifications(), exports_rpc_notifications));
+  if (isTuiConnected2(sessionId) || isTuiConnected2())
+    return;
   if (await waitForSafeNotificationTarget(client, sessionId) === "skip")
     return;
   const bullets = features.map((line) => `  • ${line}`).join(`
@@ -164528,6 +164762,20 @@ function getDistinctStoredModelIds(db, projectPath) {
   const rows = getDistinctStoredModelIdsStatement(db).all(projectPath);
   return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
 }
+function getMemoryEmbedCoverage(db, projectPath, modelId) {
+  const row = db.prepare(`SELECT
+               COUNT(*) AS total,
+               SUM(CASE WHEN EXISTS (
+                   SELECT 1 FROM memory_embeddings e
+                   WHERE e.memory_id = m.id AND e.model_id = ?
+               ) THEN 1 ELSE 0 END) AS embedded
+             FROM memories m
+             WHERE m.project_path = ? AND m.status = 'active'`).get(modelId, projectPath);
+  return {
+    total: typeof row?.total === "number" ? row.total : 0,
+    embedded: typeof row?.embedded === "number" ? row.embedded : 0
+  };
+}
 var saveEmbeddingStatements, loadAllEmbeddingsStatements, deleteEmbeddingStatements, getStoredModelIdStatements, clearAllEmbeddingsStatements, getDistinctStoredModelIdsStatements;
 var init_storage_memory_embeddings = __esm(() => {
   saveEmbeddingStatements = new WeakMap;
@@ -165330,6 +165578,16 @@ function buildCanonicalChunkTextFromFts(db, sessionId, startOrdinal, endOrdinal)
   return lines.join(`
 `);
 }
+function buildCompartmentSummaryFallbackText(db, compartmentId) {
+  const row = db.prepare("SELECT title, p1, content FROM compartments WHERE id = ?").get(compartmentId);
+  if (!row)
+    return "";
+  const title = typeof row.title === "string" ? row.title.trim() : "";
+  const p1 = typeof row.p1 === "string" ? row.p1.trim() : "";
+  const body = p1.length > 0 ? p1 : typeof row.content === "string" ? row.content.trim() : "";
+  return [title, body].filter((s) => s.length > 0).join(`
+`);
+}
 function canonicalizeInMemoryChunkTextForEmbedding(chunkText, startOrdinal, endOrdinal) {
   const lines = [];
   for (const rawLine of chunkText.split(/\r?\n/)) {
@@ -165572,6 +165830,28 @@ function countUnembeddedSessionCompartments(db, projectPath, sessionId, modelId)
                )`).get(projectPath, sessionId, projectPath, modelId);
   return typeof row?.n === "number" ? row.n : 0;
 }
+function countSessionCompartmentEmbedCoverage(db, projectPath, sessionId, modelId) {
+  const row = db.prepare(`SELECT
+               COUNT(*) AS total,
+               SUM(CASE WHEN EXISTS (
+                   SELECT 1 FROM compartment_chunk_embeddings e
+                   WHERE e.compartment_id = c.id
+                     AND e.project_path = ?
+                     AND e.model_id = ?
+               ) THEN 1 ELSE 0 END) AS embedded
+             FROM compartments c
+             JOIN session_projects sp
+               ON sp.session_id = c.session_id
+              AND sp.harness = c.harness
+              AND sp.project_path = ?
+             WHERE c.session_id = ?
+               AND c.start_message IS NOT NULL
+               AND c.end_message IS NOT NULL`).get(projectPath, modelId, projectPath, sessionId);
+  return {
+    total: typeof row?.total === "number" ? row.total : 0,
+    embedded: typeof row?.embedded === "number" ? row.embedded : 0
+  };
+}
 var DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS = 512, CHUNK_WINDOW_SAFETY_RATIO = 0.9, loadFtsRowsStatements, existingHashStatements, existingHashByProjectStatements, deleteByCompartmentStatements, insertEmbeddingStatements, distinctModelStatements, clearProjectStatements, clearProjectModelStatements, searchRowsStatements, searchRowsByModelStatements, backfillCandidateStatements, sessionBackfillCandidateStatements;
 var init_compartment_chunk_embedding = __esm(() => {
   init_read_session_formatting();
@@ -165729,6 +166009,18 @@ async function withQuietConsole(fn) {
     console.error = origError;
   }
 }
+function isNativeRuntimeMissingError(error51) {
+  const message = error51 instanceof Error ? error51.message : String(error51 ?? "");
+  const lower = message.toLowerCase();
+  const code = error51?.code;
+  const name2 = error51?.name;
+  if (code === "ERR_DLOPEN_FAILED" && lower.includes("onnxruntime")) {
+    return true;
+  }
+  if (!lower.includes("onnxruntime-node"))
+    return false;
+  return code === "ERR_MODULE_NOT_FOUND" || name2 === "ResolveMessage" || lower.includes("cannot find package") || lower.includes("cannot find module") || lower.includes("err_module_not_found");
+}
 function isTransientLoadError(error51) {
   const message = error51 instanceof Error ? error51.message : String(error51 ?? "");
   if (!message)
@@ -165793,6 +166085,9 @@ class LocalEmbeddingProvider {
     if (this.pipeline) {
       return true;
     }
+    if (nativeRuntimeMissing) {
+      return false;
+    }
     if (this.initPromise) {
       await this.initPromise;
       return this.pipeline !== null;
@@ -165859,7 +166154,12 @@ class LocalEmbeddingProvider {
           await releaseLock();
         }
       } catch (error51) {
-        log("[magic-context] embedding model failed to load:", error51);
+        if (isNativeRuntimeMissingError(error51)) {
+          nativeRuntimeMissing = true;
+          log("[magic-context] local embedding runtime is not installed (onnxruntime-node missing from this install). Local embeddings are disabled. Fix: reinstall the plugin (run `npx @cortexkit/magic-context@latest doctor --force`), or configure an `openai-compatible`/`ollama` embedding endpoint instead. Existing memories are unaffected.");
+        } else {
+          log("[magic-context] embedding model failed to load:", error51);
+        }
         this.pipeline = null;
       } finally {
         this.initPromise = null;
@@ -165885,7 +166185,7 @@ class LocalEmbeddingProvider {
       waiter();
     }
   }
-  async embed(text, signal) {
+  async embed(text, signal, _purpose) {
     if (signal?.aborted)
       return null;
     if (this.disposing)
@@ -165911,7 +166211,7 @@ class LocalEmbeddingProvider {
       this.finishInFlight();
     }
   }
-  async embedBatch(texts, signal) {
+  async embedBatch(texts, signal, _purpose) {
     if (texts.length === 0) {
       return [];
     }
@@ -165970,7 +166270,7 @@ class LocalEmbeddingProvider {
     return this.pipeline !== null;
   }
 }
-var LOCK_POLL_MS = 150, STALE_LOCK_MS, MAX_LOCK_WAIT_MS;
+var LOCK_POLL_MS = 150, STALE_LOCK_MS, MAX_LOCK_WAIT_MS, nativeRuntimeMissing = false;
 var init_embedding_local = __esm(() => {
   init_magic_context();
   init_data_path();
@@ -166055,6 +166355,7 @@ class OpenAICompatibleEmbeddingProvider {
   model;
   apiKey;
   inputType;
+  queryInputType;
   truncate;
   initialized = false;
   failureTimes = [];
@@ -166067,6 +166368,7 @@ class OpenAICompatibleEmbeddingProvider {
     this.model = options.model?.trim() ?? "";
     this.apiKey = options.apiKey?.trim() ?? "";
     this.inputType = options.inputType?.trim() ?? "";
+    this.queryInputType = options.queryInputType?.trim() ?? "";
     this.truncate = options.truncate?.trim() ?? "";
     this.maxInputTokens = typeof options.maxInputTokens === "number" && Number.isFinite(options.maxInputTokens) ? Math.max(1, Math.floor(options.maxInputTokens)) : 512;
     this.modelId = getEmbeddingProviderIdentity({
@@ -166094,11 +166396,17 @@ class OpenAICompatibleEmbeddingProvider {
     this.initialized = true;
     return true;
   }
-  async embed(text, signal) {
-    const [embedding] = await this.embedBatch([text], signal);
+  resolveInputTypeForPurpose(purpose = "passage") {
+    if (purpose === "query") {
+      return this.queryInputType || this.inputType;
+    }
+    return this.inputType;
+  }
+  async embed(text, signal, purpose) {
+    const [embedding] = await this.embedBatch([text], signal, purpose);
     return embedding ?? null;
   }
-  async embedBatch(texts, signal) {
+  async embedBatch(texts, signal, purpose) {
     if (texts.length === 0) {
       return [];
     }
@@ -166124,6 +166432,7 @@ class OpenAICompatibleEmbeddingProvider {
       if (signal) {
         signal.addEventListener("abort", onOuterAbort, { once: true });
       }
+      const inputTypeForRequest = this.resolveInputTypeForPurpose(purpose);
       const response = await fetch(`${this.endpoint}/embeddings`, {
         method: "POST",
         headers: {
@@ -166133,7 +166442,7 @@ class OpenAICompatibleEmbeddingProvider {
         body: JSON.stringify({
           model: this.model,
           input: texts,
-          ...this.inputType ? { input_type: this.inputType } : {},
+          ...inputTypeForRequest ? { input_type: inputTypeForRequest } : {},
           ...this.truncate ? { truncate: this.truncate } : {}
         }),
         redirect: "error",
@@ -166384,6 +166693,121 @@ var init_storage_git_commit_embeddings = __esm(() => {
   distinctModelIdStatements = new WeakMap;
 });
 
+// src/features/magic-context/git-commits/storage-git-commits.ts
+function getInsertStatement(db) {
+  let stmt = insertStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO git_commits (sha, project_path, short_sha, message, author, committed_at, indexed_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(sha) DO UPDATE SET
+                 project_path = excluded.project_path,
+                 short_sha = excluded.short_sha,
+                 message = excluded.message,
+                 author = excluded.author,
+                 committed_at = excluded.committed_at,
+                 indexed_at = excluded.indexed_at
+             WHERE git_commits.message != excluded.message`);
+    insertStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getExistingShasStatement(db) {
+  let stmt = existingShasStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT sha FROM git_commits WHERE project_path = ?");
+    existingShasStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getProjectCountStatement(db) {
+  let stmt = projectCountStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COUNT(*) AS count FROM git_commits WHERE project_path = ?");
+    projectCountStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLatestCommitTimeStatement(db) {
+  let stmt = latestCommitTimeStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT MAX(committed_at) AS latest FROM git_commits WHERE project_path = ?");
+    latestCommitTimeStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getEvictOverflowStatement(db) {
+  let stmt = evictOverflowStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`DELETE FROM git_commits
+             WHERE rowid IN (
+                 SELECT rowid FROM git_commits
+                 WHERE project_path = ?
+                 ORDER BY committed_at DESC, sha DESC
+                 LIMIT -1 OFFSET ?
+             )`);
+    evictOverflowStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function upsertCommits(db, projectPath, commits) {
+  if (commits.length === 0)
+    return { inserted: 0, updated: 0 };
+  const existing = new Set;
+  for (const row of getExistingShasStatement(db).all(projectPath)) {
+    existing.add(row.sha);
+  }
+  let inserted = 0;
+  let updated = 0;
+  const now = Date.now();
+  const insertStmt = getInsertStatement(db);
+  db.transaction(() => {
+    for (const commit of commits) {
+      const result = insertStmt.run(commit.sha, projectPath, commit.shortSha, commit.message, commit.author, commit.committedAtMs, now);
+      if (result.changes > 0) {
+        if (existing.has(commit.sha)) {
+          updated++;
+        } else {
+          inserted++;
+          existing.add(commit.sha);
+        }
+      }
+    }
+  })();
+  return { inserted, updated };
+}
+function getCommitCount(db, projectPath) {
+  const row = getProjectCountStatement(db).get(projectPath);
+  return row?.count ?? 0;
+}
+function getLatestIndexedCommitTimeMs(db, projectPath) {
+  const row = getLatestCommitTimeStatement(db).get(projectPath);
+  return row?.latest ?? null;
+}
+function enforceProjectCap(db, projectPath, maxCommits) {
+  if (maxCommits <= 0)
+    return 0;
+  const count = getCommitCount(db, projectPath);
+  if (count <= maxCommits)
+    return 0;
+  getEvictOverflowStatement(db).run(projectPath, maxCommits);
+  const after = getCommitCount(db, projectPath);
+  const evicted = Math.max(0, count - after);
+  if (evicted > 0) {
+    log(`[git-commits] evicted ${evicted} oldest commits for project ${projectPath} (cap=${maxCommits}, was=${count})`);
+  }
+  return evicted;
+}
+var insertStatements, existingShasStatements, projectCountStatements, evictStatements, evictOverflowStatements, latestCommitTimeStatements;
+var init_storage_git_commits = __esm(() => {
+  init_logger();
+  insertStatements = new WeakMap;
+  existingShasStatements = new WeakMap;
+  projectCountStatements = new WeakMap;
+  evictStatements = new WeakMap;
+  evictOverflowStatements = new WeakMap;
+  latestCommitTimeStatements = new WeakMap;
+});
+
 // src/features/magic-context/git-commits/sweep-coordinator.ts
 function runImmediate2(db, body) {
   db.exec("BEGIN IMMEDIATE");
@@ -166595,6 +167019,7 @@ function resolveEmbeddingConfig(config2) {
   if (config2.provider === "openai-compatible") {
     const apiKey = config2.api_key?.trim();
     const inputType = config2.input_type?.trim();
+    const queryInputType = config2.query_input_type?.trim();
     const truncate = config2.truncate?.trim();
     return {
       provider: "openai-compatible",
@@ -166602,6 +167027,7 @@ function resolveEmbeddingConfig(config2) {
       endpoint: config2.endpoint.trim(),
       ...apiKey ? { api_key: apiKey } : {},
       ...inputType ? { input_type: inputType } : {},
+      ...queryInputType ? { query_input_type: queryInputType } : {},
       ...truncate ? { truncate } : {},
       ...config2.max_input_tokens ? {
         max_input_tokens: normalizeCompartmentChunkMaxInputTokens(config2.max_input_tokens)
@@ -166623,6 +167049,7 @@ function createProvider(config2) {
       model: config2.model,
       apiKey: config2.api_key,
       inputType: config2.input_type,
+      queryInputType: config2.query_input_type,
       truncate: config2.truncate,
       maxInputTokens: config2.max_input_tokens
     });
@@ -166677,7 +167104,9 @@ function snapshotFor(registration) {
     enabled,
     gitCommitEnabled,
     modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId,
-    chunkModelId: registration.observationMode || !providerIsOn ? "off" : registration.chunkModelId
+    chunkModelId: registration.observationMode || !providerIsOn ? "off" : registration.chunkModelId,
+    model: registration.observationMode || !providerIsOn ? "off" : ("model" in registration.config) && registration.config.model.trim() ? registration.config.model.trim() : registration.modelId,
+    provider: registration.observationMode || !providerIsOn ? "off" : registration.config.provider ?? "local"
   };
 }
 function disposeProvider(provider) {
@@ -166803,7 +167232,7 @@ function getOrCreateProjectProvider(registration) {
   registration.provider = provider;
   return provider;
 }
-async function embedTextForProject(projectIdentity, text, signal) {
+async function embedTextForProject(projectIdentity, text, signal, purpose = "passage") {
   const registration = projectRegistrations.get(projectIdentity);
   if (!registration)
     return null;
@@ -166812,7 +167241,7 @@ async function embedTextForProject(projectIdentity, text, signal) {
   const provider = getOrCreateProjectProvider(registration);
   if (!provider)
     return null;
-  const vector = await provider.embed(text, signal);
+  const vector = await provider.embed(text, signal, purpose);
   if (!vector)
     return null;
   const current = projectRegistrations.get(projectIdentity);
@@ -166821,7 +167250,7 @@ async function embedTextForProject(projectIdentity, text, signal) {
   }
   return { vector, modelId, generation };
 }
-async function embedBatchForProject(projectIdentity, texts, signal) {
+async function embedBatchForProject(projectIdentity, texts, signal, purpose = "passage") {
   if (texts.length === 0) {
     const registration2 = projectRegistrations.get(projectIdentity);
     if (!registration2 || registration2.observationMode)
@@ -166837,7 +167266,7 @@ async function embedBatchForProject(projectIdentity, texts, signal) {
   const provider = getOrCreateProjectProvider(registration);
   if (!provider)
     return null;
-  const vectors = await provider.embedBatch(texts, signal);
+  const vectors = await provider.embedBatch(texts, signal, purpose);
   const current = projectRegistrations.get(projectIdentity);
   if (!current || current.generation !== generation || current.runtimeFingerprint !== runtimeFingerprint) {
     return null;
@@ -166888,12 +167317,13 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
 }
 async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates, signal) {
   const noWork = [];
+  const failed = [];
   if (candidates.length === 0)
-    return { embedded: 0, noWork };
+    return { embedded: 0, noWork, failed };
   const maxInputTokens = getProjectEmbeddingMaxInputTokens(projectIdentity);
   const prepared = [];
   for (const candidate of candidates) {
-    const canonicalText = buildCanonicalChunkTextFromFts(db, candidate.sessionId, candidate.startMessage, candidate.endMessage);
+    const canonicalText = buildCanonicalChunkTextFromFts(db, candidate.sessionId, candidate.startMessage, candidate.endMessage) || buildCompartmentSummaryFallbackText(db, candidate.id);
     if (canonicalText.length === 0) {
       noWork.push(candidate.id);
       continue;
@@ -166906,7 +167336,7 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
     prepared.push({ candidate, windows });
   }
   if (prepared.length === 0)
-    return { embedded: 0, noWork };
+    return { embedded: 0, noWork, failed };
   let embedded = 0;
   let i = 0;
   while (i < prepared.length) {
@@ -166923,35 +167353,60 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
     const texts = [];
     for (const item of slice)
       texts.push(...item.windows.map((w) => w.text));
-    try {
-      const result = await embedBatchForProject(projectIdentity, texts, signal);
-      if (!result)
-        continue;
+    const persistedIds = new Set;
+    for (let attempt = 0;attempt < EMBED_SLICE_RETRY_ATTEMPTS; attempt++) {
       if (signal?.aborted)
         break;
-      let offset = 0;
-      for (const item of slice) {
-        const vectors = result.vectors.slice(offset, offset + item.windows.length);
-        offset += item.windows.length;
-        if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
-          continue;
+      let result = null;
+      const attemptStart = Date.now();
+      try {
+        result = await embedBatchForProject(projectIdentity, texts, signal);
+      } catch (error51) {
+        log("[magic-context] failed to proactively embed compartment chunks:", error51);
+      }
+      if (signal?.aborted)
+        break;
+      if (result) {
+        let offset = 0;
+        for (const item of slice) {
+          const vectors = result.vectors.slice(offset, offset + item.windows.length);
+          offset += item.windows.length;
+          if (persistedIds.has(item.candidate.id))
+            continue;
+          if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
+            continue;
+          }
+          const rows = item.windows.map((window, index) => ({
+            compartmentId: item.candidate.id,
+            sessionId: item.candidate.sessionId,
+            projectPath: projectIdentity,
+            window,
+            modelId,
+            vector: vectors[index]
+          }));
+          replaceCompartmentChunkEmbeddings(db, rows);
+          persistedIds.add(item.candidate.id);
         }
-        const rows = item.windows.map((window, index) => ({
-          compartmentId: item.candidate.id,
-          sessionId: item.candidate.sessionId,
-          projectPath: projectIdentity,
-          window,
-          modelId,
-          vector: vectors[index]
-        }));
-        replaceCompartmentChunkEmbeddings(db, rows);
-        embedded += 1;
       }
-    } catch (error51) {
-      log("[magic-context] failed to proactively embed compartment chunks:", error51);
+      if (persistedIds.size === slice.length)
+        break;
+      if (persistedIds.size > 0)
+        break;
+      if (Date.now() - attemptStart >= EMBED_SLOW_FAILURE_NO_RETRY_MS)
+        break;
+      if (attempt < EMBED_SLICE_RETRY_ATTEMPTS - 1) {
+        await new Promise((resolve7) => setTimeout(resolve7, EMBED_SLICE_RETRY_BASE_MS * 2 ** attempt));
+      }
+    }
+    embedded += persistedIds.size;
+    if (!signal?.aborted) {
+      for (const item of slice) {
+        if (!persistedIds.has(item.candidate.id))
+          failed.push(item.candidate.id);
+      }
     }
   }
-  return { embedded, noWork };
+  return { embedded, noWork, failed };
 }
 async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, options) {
   const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
@@ -166974,9 +167429,11 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   renewal.unref?.();
   const batchSize = Math.max(1, options?.batchSize ?? CHUNK_DRAIN_BATCH_SIZE);
   const skipIds = [];
+  const failedIds = [];
   let embedded = 0;
   let aborted2 = false;
-  let providerStalled = false;
+  let providerDown = false;
+  let consecutiveFailedBatches = 0;
   try {
     options?.onProgress?.({ embedded, total });
     for (;; ) {
@@ -166984,15 +167441,26 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
         aborted2 = true;
         break;
       }
-      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, skipIds);
+      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, [...skipIds, ...failedIds]);
       if (candidates.length === 0)
         break;
-      const { embedded: n, noWork } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, options?.signal);
+      const {
+        embedded: n,
+        noWork,
+        failed
+      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, options?.signal);
       for (const id of noWork)
         skipIds.push(id);
+      for (const id of failed)
+        failedIds.push(id);
       if (n === 0 && noWork.length === 0) {
-        providerStalled = true;
-        break;
+        consecutiveFailedBatches += 1;
+        if (consecutiveFailedBatches >= MAX_CONSECUTIVE_FAILED_BATCHES) {
+          providerDown = true;
+          break;
+        }
+      } else {
+        consecutiveFailedBatches = 0;
       }
       embedded += n;
       options?.onProgress?.({ embedded: Math.min(embedded, total), total });
@@ -167000,23 +167468,58 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
     }
   } finally {
     clearInterval(renewal);
-    releaseGitSweepLease(db, projectIdentity, holderId);
+    try {
+      releaseGitSweepLease(db, projectIdentity, holderId);
+    } catch (error51) {
+      log("[magic-context] embed drain: lease release failed (will TTL-expire):", error51);
+    }
   }
   if (aborted2)
-    return { status: "aborted", embedded, total };
-  if (providerStalled) {
+    return { status: "aborted", embedded, total, failed: failedIds.length };
+  if (providerDown || failedIds.length > 0) {
     const remaining = Math.max(0, countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId) - skipIds.length);
-    if (remaining > 0)
-      return { status: "stalled", embedded, total, remaining };
+    if (remaining > 0) {
+      return { status: "stalled", embedded, total, remaining, failed: failedIds.length };
+    }
   }
-  return { status: "done", embedded, total };
+  return { status: "done", embedded, total, failed: failedIds.length };
 }
-var OFF_PROVIDER_IDENTITY = "embedding-provider:off", SWEEP_MAX_WALL_CLOCK_MS, CHUNK_DRAIN_BATCH_SIZE = 8, MAX_WINDOWS_PER_EMBED_CALL = 16, SESSION_EMBED_LEASE_RENEWAL_MS, projectRegistrations, loadUnembeddedMemoriesStatements, globalRegistrationGeneration = 0, testProviderFactory = null;
+function getEmbeddingCoverageStatus(db, projectIdentity, sessionId) {
+  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot?.enabled || snapshot.chunkModelId === "off") {
+    return {
+      enabled: false,
+      model: snapshot?.model ?? "off",
+      provider: snapshot?.provider ?? "off",
+      session: { embedded: 0, total: 0 },
+      memories: { embedded: 0, total: 0 },
+      commits: { embedded: 0, total: 0, gitEnabled: false }
+    };
+  }
+  const session = countSessionCompartmentEmbedCoverage(db, projectIdentity, sessionId, snapshot.chunkModelId);
+  const memories = getMemoryEmbedCoverage(db, projectIdentity, snapshot.modelId);
+  const gitEnabled = snapshot.gitCommitEnabled;
+  const commits = gitEnabled ? {
+    embedded: countEmbeddedCommits(db, projectIdentity),
+    total: getCommitCount(db, projectIdentity),
+    gitEnabled: true
+  } : { embedded: 0, total: 0, gitEnabled: false };
+  return {
+    enabled: true,
+    model: snapshot.model,
+    provider: snapshot.provider,
+    session,
+    memories,
+    commits
+  };
+}
+var OFF_PROVIDER_IDENTITY = "embedding-provider:off", SWEEP_MAX_WALL_CLOCK_MS, CHUNK_DRAIN_BATCH_SIZE = 8, MAX_WINDOWS_PER_EMBED_CALL = 2, SESSION_EMBED_LEASE_RENEWAL_MS, EMBED_SLICE_RETRY_ATTEMPTS = 3, EMBED_SLICE_RETRY_BASE_MS = 250, EMBED_SLOW_FAILURE_NO_RETRY_MS = 1e4, MAX_CONSECUTIVE_FAILED_BATCHES = 3, projectRegistrations, loadUnembeddedMemoriesStatements, globalRegistrationGeneration = 0, testProviderFactory = null;
 var init_project_embedding_registry = __esm(() => {
   init_magic_context();
   init_logger();
   init_compartment_chunk_embedding();
   init_storage_git_commit_embeddings();
+  init_storage_git_commits();
   init_sweep_coordinator();
   init_embedding_cache();
   init_embedding_identity();
@@ -167041,6 +167544,7 @@ function createProvider2(config2) {
       model: config2.model,
       apiKey: config2.api_key,
       inputType: config2.input_type,
+      queryInputType: config2.query_input_type,
       truncate: config2.truncate,
       maxInputTokens: config2.max_input_tokens
     });
@@ -167297,58 +167801,6 @@ var init_models_dev_cache = __esm(() => {
   init_logger();
 });
 
-// src/shared/rpc-notifications.ts
-var exports_rpc_notifications = {};
-__export(exports_rpc_notifications, {
-  pushNotification: () => pushNotification,
-  isTuiConnected: () => isTuiConnected,
-  drainNotifications: () => drainNotifications
-});
-function pushNotification(type, payload, sessionId) {
-  queue2.push({ id: nextNotificationId++, type, payload, sessionId });
-  if (queue2.length > 100) {
-    const newestPerSession = new Map;
-    for (const n of queue2) {
-      const prev = newestPerSession.get(n.sessionId);
-      if (prev === undefined || n.id > prev) {
-        newestPerSession.set(n.sessionId, n.id);
-      }
-    }
-    const mustKeep = new Set(newestPerSession.values());
-    const byNewest = [...queue2].sort((a, b) => b.id - a.id);
-    const kept = [];
-    for (const n of byNewest) {
-      if (kept.length < 50 || mustKeep.has(n.id))
-        kept.push(n);
-    }
-    queue2 = kept.sort((a, b) => a.id - b.id);
-  }
-}
-function drainNotifications(lastReceivedId = 0, sessionId) {
-  const now = Date.now();
-  lastDrainAtAny = now;
-  if (sessionId !== undefined)
-    lastDrainAtBySession.set(sessionId, now);
-  const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
-  if (lastReceivedId > 0) {
-    queue2 = queue2.filter((notification) => !(notification.id <= lastReceivedId && matchesClient(notification)));
-  }
-  return queue2.filter((notification) => notification.id > lastReceivedId && matchesClient(notification));
-}
-function isTuiConnected(sessionId) {
-  const now = Date.now();
-  if (sessionId !== undefined) {
-    const at = lastDrainAtBySession.get(sessionId) ?? 0;
-    return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS;
-  }
-  return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS;
-}
-var queue2, nextNotificationId = 1, lastDrainAtBySession, lastDrainAtAny = 0, TUI_CONNECTED_WINDOW_MS = 3000;
-var init_rpc_notifications = __esm(() => {
-  queue2 = [];
-  lastDrainAtBySession = new Map;
-});
-
 // src/features/magic-context/compartment-embedding.ts
 async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compartments) {
   if (compartments.length === 0)
@@ -167357,7 +167809,7 @@ async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compar
   for (const compartment of compartments) {
     try {
       const fromMemory = compartment.sourceChunkText ? canonicalizeInMemoryChunkTextForEmbedding(compartment.sourceChunkText, compartment.startMessage, compartment.endMessage) : "";
-      const canonicalText = fromMemory || buildCanonicalChunkTextFromFts(db, sessionId, compartment.startMessage, compartment.endMessage);
+      const canonicalText = fromMemory || buildCanonicalChunkTextFromFts(db, sessionId, compartment.startMessage, compartment.endMessage) || buildCompartmentSummaryFallbackText(db, compartment.id);
       if (canonicalText.length === 0)
         continue;
       const windows = chunkCanonicalText(canonicalText, compartment.startMessage, compartment.endMessage, maxInputTokens);
@@ -170557,29 +171009,12 @@ function resolveHistorianContextLimit(historianModelOverride) {
     return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
   }
   if (typeof historianModelOverride === "string" && historianModelOverride.trim() !== "") {
-    console.warn(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using fallback chain for chunk-budget derivation.`);
-  }
-  const chain = AGENT_MODEL_REQUIREMENTS[HISTORIAN_AGENT]?.fallbackChain;
-  if (!chain || chain.length === 0)
-    return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
-  const expanded = expandFallbackChain(chain);
-  let minLimit;
-  for (const key of expanded) {
-    const [providerID, ...rest] = key.split("/");
-    const modelID = rest.join("/");
-    if (!providerID || !modelID)
-      continue;
-    const limit = getSdkContextLimit(providerID, modelID);
-    if (typeof limit !== "number" || limit <= 0)
-      continue;
-    if (minLimit === undefined || limit < minLimit)
-      minLimit = limit;
+    console.warn(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
   }
-  return minLimit ?? DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
+  return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
 }
 var TRIGGER_BUDGET_PERCENTAGE = 0.05, TRIGGER_BUDGET_MIN = 5000, TRIGGER_BUDGET_MAX = 50000, HISTORIAN_CHUNK_PERCENTAGE = 0.25, HISTORIAN_CHUNK_MIN = 8000, HISTORIAN_CHUNK_MAX = 50000, DEFAULT_HISTORIAN_CONTEXT_FALLBACK = 128000;
 var init_derive_budgets = __esm(() => {
-  init_model_requirements();
   init_models_dev_cache();
 });
 
@@ -170900,7 +171335,7 @@ function buildToolArcs(messages) {
   }
   return arcs.sort((a, b) => a.invOrdinal - b.invOrdinal || (a.resOrdinal ?? Number.MAX_SAFE_INTEGER) - (b.resOrdinal ?? Number.MAX_SAFE_INTEGER));
 }
-function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal) {
+function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal, recentOpenArcCutoff) {
   let boundary = candidate;
   for (const arc of arcs) {
     if (arc.resOrdinal !== null) {
@@ -170909,6 +171344,8 @@ function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal) {
       }
       continue;
     }
+    if (arc.invOrdinal < recentOpenArcCutoff)
+      continue;
     if (arc.invOrdinal >= lastCompartmentEndOrdinal + 1 && arc.invOrdinal < boundary) {
       return arc.invOrdinal;
     }
@@ -171148,7 +171585,7 @@ function semanticSnapBoundary(args) {
   return snapped;
 }
 function applyHeadCap(args) {
-  const { index, protectedTailStart, offset, arcs, capTokens } = args;
+  const { index, protectedTailStart, offset, arcs, capTokens, recentOpenArcCutoff } = args;
   if (offset >= protectedTailStart)
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit: false };
   let end = index.findHeadEndForCap(offset, protectedTailStart, capTokens);
@@ -171156,7 +171593,7 @@ function applyHeadCap(args) {
   for (const arc of arcs) {
     const resOrdinal = arc.resOrdinal;
     if (resOrdinal === null) {
-      if (arc.invOrdinal >= offset && arc.invOrdinal < end) {
+      if (arc.invOrdinal >= recentOpenArcCutoff && arc.invOrdinal >= offset && arc.invOrdinal < end) {
         end = Math.min(end, arc.invOrdinal);
       }
       continue;
@@ -171223,7 +171660,14 @@ function resolveProtectedTailBoundary(ctx) {
   }
   if (ctx.mode === "manual-full-recomp") {
     const arcs2 = buildToolArcs(messages);
-    const firstOpenArc = arcs2.find((arc) => arc.resOrdinal === null && arc.invOrdinal >= offset);
+    const recompTarget = deriveProtectedTailTokenTarget({
+      contextLimit: ctx.contextLimit,
+      executeThresholdPercentage: ctx.executeThresholdPercentage,
+      usagePercentage: 0,
+      triggerBudget: ctx.triggerBudget
+    });
+    const recentOpenArcCutoff2 = index.findSuffixStartForTokens(recompTarget.N);
+    const firstOpenArc = arcs2.find((arc) => arc.resOrdinal === null && arc.invOrdinal >= offset && arc.invOrdinal >= recentOpenArcCutoff2);
     const protectedTailStart2 = firstOpenArc?.invOrdinal ?? rawMessageCount + 1;
     const rawRangeFingerprint2 = computeRawRangeFingerprint(messages, offset, protectedTailStart2);
     return {
@@ -171265,13 +171709,14 @@ function resolveProtectedTailBoundary(ctx) {
   const scaledN = ctx.emergencyTailScale ? Math.max(1, Math.floor(target.N * ctx.emergencyTailScale)) : target.N;
   const arcs = buildToolArcs(messages);
   let boundary = index.findSuffixStartForTokens(scaledN);
+  const recentOpenArcCutoff = boundary;
   let boundaryReason = boundary === 1 ? "whole-session-smaller-than-tail" : "size-walk";
   const tokenAtBoundary = index.tokenForOrdinal(boundary);
   if (boundary <= rawMessageCount && tokenAtBoundary > Math.max(2 * scaledN, 64000) && boundary < rawMessageCount) {
     boundary += 1;
     boundaryReason = "huge-message-exception";
   }
-  boundary = fenceBoundaryForToolArcs(boundary, arcs, ctx.lastCompartmentEndOrdinal);
+  boundary = fenceBoundaryForToolArcs(boundary, arcs, ctx.lastCompartmentEndOrdinal, recentOpenArcCutoff);
   const snapped = semanticSnapBoundary({
     messages,
     index,
@@ -171281,7 +171726,7 @@ function resolveProtectedTailBoundary(ctx) {
   });
   if (snapped !== boundary)
     boundaryReason = "semantic-snap";
-  boundary = fenceBoundaryForToolArcs(snapped, arcs, ctx.lastCompartmentEndOrdinal);
+  boundary = fenceBoundaryForToolArcs(snapped, arcs, ctx.lastCompartmentEndOrdinal, recentOpenArcCutoff);
   let runtimeFloor = offset;
   if (ctx.migrationFloorActive)
     runtimeFloor = Math.max(runtimeFloor, ctx.priorBoundaryOrdinal);
@@ -171317,7 +171762,8 @@ function resolveProtectedTailBoundary(ctx) {
     offset,
     arcs,
     lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal,
-    capTokens: perRunCap
+    capTokens: perRunCap,
+    recentOpenArcCutoff
   });
   const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, head.eligibleEndOrdinal);
   return {
@@ -171368,7 +171814,7 @@ function resolveBoundaryContext(args) {
   }
   let storedTokenTotals;
   try {
-    storedTokenTotals = getAllStatusTagTokenTotalsFlat(args.db, args.sessionId).totals;
+    storedTokenTotals = getAllStatusTagTokenTotalsFlat(args.db, args.sessionId, args.taggerFloor ?? 0).totals;
   } catch (error51) {
     sessionLog(args.sessionId, "protected-tail stored-token map unavailable (live fallback):", error51);
   }
@@ -173572,6 +174018,7 @@ async function runCompartmentAgent(deps) {
         const count = recordHighPressureNoEligibleHead(db, boundarySnapshot);
         sessionLog(sessionId, `historian high-pressure no-op: recovery remains armed (noEligibleHeadCount=${count})`);
       }
+      clearEmergencyDrainLatch(db, sessionId);
       telemetry.status = "noop";
       telemetry.failureReason = "nothing to compact before protected tail";
       rollbackDrainReservation();
@@ -173586,7 +174033,8 @@ async function runCompartmentAgent(deps) {
       trueRawTokens: boundarySnapshot.trueRawEligibleTokens,
       usagePercentage: boundarySnapshot.usagePercentage,
       usable,
-      perRunCap
+      perRunCap,
+      executeThresholdPercentage: boundarySnapshot.executeThresholdPercentage
     });
     if (!reserve.ok) {
       sessionLog(sessionId, `historian rate-limit skip: ${reserve.skippedReason ?? "quota exhausted"}`);
@@ -173605,6 +174053,7 @@ async function runCompartmentAgent(deps) {
       } else {
         recordHighPressureNoEligibleHead(db, boundarySnapshot);
       }
+      clearEmergencyDrainLatch(db, sessionId);
       telemetry.status = "noop";
       telemetry.failureReason = "chunk empty after filtering";
       rollbackDrainReservation();
@@ -173712,6 +174161,7 @@ ${chunkText}`,
       }
       appendCompartments(db, sessionId, persistedCompartments);
       clearHistorianFailureState(db, sessionId);
+      clearHistorianDrainFailure(db, sessionId);
       recordProtectedTailPublicationFloor(db, sessionId, lastCompartmentEnd + 1);
       clearEmergencyRecovery(db, sessionId);
       drainReservation = null;
@@ -173815,8 +174265,11 @@ ${chunkText}`,
     }
   } finally {
     if (!completedSuccessfully) {
-      if (!retainDrainReservationForRetryThrottle)
+      if (!retainDrainReservationForRetryThrottle) {
         rollbackDrainReservation();
+      } else {
+        recordHistorianDrainFailure(db, sessionId);
+      }
       updateSessionMeta(db, sessionId, { compartmentInProgress: false });
     }
     recordTelemetry();
@@ -176958,7 +177411,6 @@ var init_memory_migration = __esm(async () => {
   init_shared();
   init_assistant_message_extractor();
   init_logger();
-  init_resolve_fallbacks();
   init_project_identity();
   init_storage_memory();
   await init_storage();
@@ -177274,15 +177726,15 @@ function shouldShowAnnouncement() {
   }
   return state.version !== ANNOUNCEMENT_VERSION;
 }
-var ANNOUNCEMENT_VERSION = "0.24.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
+var ANNOUNCEMENT_VERSION = "0.26.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
 var init_announcement = __esm(() => {
   init_data_path();
   ANNOUNCEMENT_FEATURES = [
-    "Searchable session history: ctx_search can now find older discussion by meaning, not just keywords. New history is embedded automatically — to backfill an EXISTING session's older history, run /ctx-embed-history once (it works in the background).",
-    "Cross-project workspaces: group related repos and share project memories across them, with per-category control over what's shared. Set them up in the dashboard's Workspaces panel.",
-    "Pi: fixed sessions overflowing the model context while still showing moderate usage — Pi now sheds context before a tool-heavy turn overflows.",
-    "Fewer prompt-cache busts: doc edits, processed screenshots, and a rebuild-then-bust-again case no longer re-bill large prompt prefixes.",
-    "Setup wizard now lists your actual models with type-ahead instead of fixed recommendations, and explains the historian/dreamer roles (issue #144). Plus a GitHub Copilot tool-pairing fix (#135)."
+    "Faster on large sessions: per-message transform overhead is at least 2x lower on typical passes and up to ~10x lower when history summarization fires (no more multi-second pause on big sessions).",
+    "No more surprise models: the built-in fallback chain is gone. Hidden agents only use the model (and fallback_models) you configure — no confusing 'model not found' for providers you never set up. `doctor` now records every historian run so real failures are visible.",
+    "Anthropic thinking-block fix: clearing old reasoning no longer risks a stale-signature rejection on Claude / Bedrock / proxied-Claude routes. Plus fewer prompt-cache busts.",
+    "Community fixes: TUI crash on the upgrade progress panel (#168), historian.disallowed_tools for weak models that loop on tool calls (#166), and a Pi-only config key leak (#167).",
+    "New: doctor migrate-session re-homes a session (and optionally its memories) to another project, with a dry-run preview."
   ];
 });
 
@@ -177355,6 +177807,9 @@ var init_tui_config = __esm(() => {
   import_comment_json4 = __toESM(require_src2(), 1);
   PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 });
+
+// src/agents/dreamer.ts
+var DREAMER_AGENT = "dreamer";
 // src/agents/permissions.ts
 function buildAllowOnlyPermission(allowedTools) {
   const permission = { "*": "deny" };
@@ -177364,6 +177819,11 @@ function buildAllowOnlyPermission(allowedTools) {
   return permission;
 }
 var HISTORIAN_ALLOWED_TOOLS = ["read", "aft_outline", "aft_zoom", "aft_search"];
+function applyDisallowedTools(defaults, disallowed) {
+  if (disallowed.includes("*"))
+    return [];
+  return defaults.filter((t) => !disallowed.includes(t));
+}
 var DREAMER_ALLOWED_TOOLS = [
   "read",
   "grep",
@@ -177379,6 +177839,10 @@ var DREAMER_ALLOWED_TOOLS = [
   "ctx_note"
 ];
 var SIDEKICK_ALLOWED_TOOLS = ["ctx_search", "aft_outline", "aft_zoom"];
+
+// src/agents/sidekick.ts
+var SIDEKICK_AGENT = "sidekick";
+
 // src/config/index.ts
 init_jsonc_parser();
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
@@ -178077,9 +178541,9 @@ function getMagicContextBuiltinCommands() {
       template: "ctx-dream",
       description: "Run the hidden dreamer maintenance pass for this project now"
     },
-    "ctx-embed-history": {
-      template: "ctx-embed-history",
-      description: "Embed all of this session's history compartments for semantic search, in one pass"
+    "ctx-embed": {
+      template: "ctx-embed",
+      description: "Embedding status, or start/pause history compartment embedding (start | pause)"
     }
   };
 }
@@ -178328,6 +178792,7 @@ ${modeIntro}
 4. **Write or update** using the Write tool. Always write to project root, NOT to .planning/.
 
 ### Rules
+- **NEVER touch protected regions**: any content between \`<!-- mc:protected START ... -->\` and \`<!-- mc:protected END -->\` is hand-authored and cache-critical. Reproduce it BYTE-FOR-BYTE in your rewrite — do not edit, reword, reorder, summarize, trim, or drop a single line of it, and keep the marker comments themselves. Only a human edits that region.
 - **Be prescriptive**: "Use X pattern" not "X pattern is used"
 - **Always include file paths** in backticks
 - **Write current state only**: no temporal language, no history
@@ -178464,7 +178929,6 @@ init_project_identity();
 init_shared();
 init_assistant_message_extractor();
 init_logger();
-init_resolve_fallbacks();
 init_subagent_token_capture();
 await init_storage();
 
@@ -178486,7 +178950,7 @@ function stripThinkingBlocks(text) {
 
 // src/features/magic-context/sidekick/agent.ts
 async function runSidekick(deps) {
-  const fallbackModels = resolveFallbackChain(SIDEKICK_AGENT, deps.config.fallback_models);
+  const fallbackModels = resolveFallbackChain(deps.config.fallback_models);
   let agentSessionId = null;
   const startedAt = Date.now();
   let invocationRecorded = false;
@@ -178576,6 +179040,11 @@ init_project_identity();
 import { createHash as createHash6 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
+
+// src/features/magic-context/memory/relocate-memory.ts
+var memoryCopyColumnsCache = new WeakMap;
+
+// src/features/magic-context/v22-deferred-backfill.ts
 var BATCH_SIZE = 25;
 var YIELD_EVERY_N_ROWS = 5;
 var BACKFILL_META_KEY = "v22_legacy_memory_backfill";
@@ -179410,6 +179879,7 @@ function createLiveSessionState() {
 
 // src/index.ts
 init_conflict_warning_hook();
+
 // src/features/magic-context/dreamer/storage-dream-state.ts
 var getDreamStateStatements = new WeakMap;
 var setDreamStateStatements = new WeakMap;
@@ -179547,7 +180017,7 @@ function enqueueDream(db, projectIdentity, reason, force = false) {
   return db.transaction(() => {
     if (!hasActiveDreamLease(db)) {
       const staleThresholdMs = force ? 2 * 60 * 1000 : 120 * 60 * 1000;
-      db.prepare("DELETE FROM dream_queue WHERE project_path = ? AND started_at IS NOT NULL AND started_at < ?").run([projectIdentity, now - staleThresholdMs]);
+      db.prepare("DELETE FROM dream_queue WHERE project_path = ? AND started_at IS NOT NULL AND started_at < ?").run(projectIdentity, now - staleThresholdMs);
     }
     const existing = db.prepare("SELECT id FROM dream_queue WHERE project_path = ?").get(projectIdentity);
     if (existing) {
@@ -179603,21 +180073,21 @@ function clearStaleEntries(db, maxAgeMs, projectIdentity) {
   return result.changes;
 }
 // src/features/magic-context/dreamer/runner.ts
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join16 } from "node:path";
 init_shared();
 init_assistant_message_extractor();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join16 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
+import { readFileSync as readFileSync11 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join15, relative as relative2 } from "node:path";
 init_read_session_formatting();
 init_shared();
 init_assistant_message_extractor();
 init_logger();
-import { readFileSync as readFileSync11 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join15, relative as relative2 } from "node:path";
 init_subagent_token_capture();
 init_aft_availability();
 init_project_key_files();
@@ -181242,120 +181712,7 @@ ${body}` : subject;
 init_logger();
 init_embedding();
 init_storage_git_commit_embeddings();
-
-// src/features/magic-context/git-commits/storage-git-commits.ts
-init_logger();
-var insertStatements = new WeakMap;
-var existingShasStatements = new WeakMap;
-var projectCountStatements = new WeakMap;
-var evictStatements = new WeakMap;
-var evictOverflowStatements = new WeakMap;
-var latestCommitTimeStatements = new WeakMap;
-function getInsertStatement(db) {
-  let stmt = insertStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`INSERT INTO git_commits (sha, project_path, short_sha, message, author, committed_at, indexed_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?)
-             ON CONFLICT(sha) DO UPDATE SET
-                 project_path = excluded.project_path,
-                 short_sha = excluded.short_sha,
-                 message = excluded.message,
-                 author = excluded.author,
-                 committed_at = excluded.committed_at,
-                 indexed_at = excluded.indexed_at
-             WHERE git_commits.message != excluded.message`);
-    insertStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getExistingShasStatement(db) {
-  let stmt = existingShasStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT sha FROM git_commits WHERE project_path = ?");
-    existingShasStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getProjectCountStatement(db) {
-  let stmt = projectCountStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT COUNT(*) AS count FROM git_commits WHERE project_path = ?");
-    projectCountStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getLatestCommitTimeStatement(db) {
-  let stmt = latestCommitTimeStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT MAX(committed_at) AS latest FROM git_commits WHERE project_path = ?");
-    latestCommitTimeStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getEvictOverflowStatement(db) {
-  let stmt = evictOverflowStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`DELETE FROM git_commits
-             WHERE rowid IN (
-                 SELECT rowid FROM git_commits
-                 WHERE project_path = ?
-                 ORDER BY committed_at DESC, sha DESC
-                 LIMIT -1 OFFSET ?
-             )`);
-    evictOverflowStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function upsertCommits(db, projectPath, commits) {
-  if (commits.length === 0)
-    return { inserted: 0, updated: 0 };
-  const existing = new Set;
-  for (const row of getExistingShasStatement(db).all(projectPath)) {
-    existing.add(row.sha);
-  }
-  let inserted = 0;
-  let updated = 0;
-  const now = Date.now();
-  const insertStmt = getInsertStatement(db);
-  db.transaction(() => {
-    for (const commit of commits) {
-      const result = insertStmt.run(commit.sha, projectPath, commit.shortSha, commit.message, commit.author, commit.committedAtMs, now);
-      if (result.changes > 0) {
-        if (existing.has(commit.sha)) {
-          updated++;
-        } else {
-          inserted++;
-          existing.add(commit.sha);
-        }
-      }
-    }
-  })();
-  return { inserted, updated };
-}
-function getCommitCount(db, projectPath) {
-  const row = getProjectCountStatement(db).get(projectPath);
-  return row?.count ?? 0;
-}
-function getLatestIndexedCommitTimeMs(db, projectPath) {
-  const row = getLatestCommitTimeStatement(db).get(projectPath);
-  return row?.latest ?? null;
-}
-function enforceProjectCap(db, projectPath, maxCommits) {
-  if (maxCommits <= 0)
-    return 0;
-  const count = getCommitCount(db, projectPath);
-  if (count <= maxCommits)
-    return 0;
-  getEvictOverflowStatement(db).run(projectPath, maxCommits);
-  const after = getCommitCount(db, projectPath);
-  const evicted = Math.max(0, count - after);
-  if (evicted > 0) {
-    log(`[git-commits] evicted ${evicted} oldest commits for project ${projectPath} (cap=${maxCommits}, was=${count})`);
-  }
-  return evicted;
-}
-
-// src/features/magic-context/git-commits/indexer.ts
+init_storage_git_commits();
 var MS_PER_DAY = 24 * 60 * 60 * 1000;
 var EMBED_BATCH_SIZE = 16;
 var EMBED_MAX_PER_SWEEP = 500;
@@ -181593,12 +181950,12 @@ function searchGitCommitsSync(db, projectPath, query, options) {
 
 // src/features/magic-context/git-commits/index.ts
 init_storage_git_commit_embeddings();
+init_storage_git_commits();
 init_sweep_coordinator();
 
 // src/plugin/dream-timer.ts
 init_embedding();
 init_logger();
-init_resolve_fallbacks();
 await init_storage();
 var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
 var activeTimer = null;
@@ -181701,7 +182058,7 @@ async function sweepProject(reg, origin, db, gitCommitEnabled = getProjectEmbedd
       experimentalPinKeyFiles: reg.experimentalPinKeyFiles,
       projectIdentity: reg.projectIdentity,
       sessionDirectoryOverride: reg.directory,
-      fallbackModels: resolveFallbackChain(DREAMER_AGENT, reg.dreamerConfig.fallback_models)
+      fallbackModels: resolveFallbackChain(reg.dreamerConfig.fallback_models)
     });
   } catch (error51) {
     log(`[dreamer] timer-triggered queue processing failed for ${reg.projectIdentity}:`, error51);
@@ -182151,10 +182508,9 @@ function makeToolCompositeKey(ownerMsgId, callId) {
 }
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
 var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
+var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
 var PROBE_DATA_VERSION_SQL = "PRAGMA main.data_version";
-var PROBE_TOTAL_CHANGES_SQL = "SELECT total_changes() AS tc";
 var probeDataVersionStatements = new WeakMap;
-var probeTotalChangesStatements = new WeakMap;
 function getProbeDataVersionStatement(db) {
   let stmt = probeDataVersionStatements.get(db);
   if (!stmt) {
@@ -182163,14 +182519,6 @@ function getProbeDataVersionStatement(db) {
   }
   return stmt;
 }
-function getProbeTotalChangesStatement(db) {
-  let stmt = probeTotalChangesStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(PROBE_TOTAL_CHANGES_SQL);
-    probeTotalChangesStatements.set(db, stmt);
-  }
-  return stmt;
-}
 function isAssignmentRow(row) {
   if (row === null || typeof row !== "object") {
     return false;
@@ -182363,20 +182711,18 @@ function createTagger() {
   }
   function probeSignature(db) {
     const dvRow = getProbeDataVersionStatement(db).get();
-    const tcRow = getProbeTotalChangesStatement(db).get();
     return {
-      dataVersion: dvRow?.data_version ?? 0,
-      totalChanges: tcRow?.tc ?? 0
+      dataVersion: dvRow?.data_version ?? 0
     };
   }
-  function initFromDb(sessionId, db) {
+  function initFromDb(sessionId, db, floor = 0) {
     const probe = probeSignature(db);
     const cached2 = loadSignatures.get(sessionId);
-    if (cached2 !== undefined && cached2.db === db && cached2.dataVersion === probe.dataVersion && cached2.totalChanges === probe.totalChanges) {
+    if (cached2 !== undefined && cached2.db === db && cached2.dataVersion === probe.dataVersion && cached2.floor === floor) {
       return;
     }
     const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
-    const assignmentRows = db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId).filter(isAssignmentRow);
+    const assignmentRows = (floor > 0 ? db.prepare(GET_ASSIGNMENTS_SCOPED_SQL).all(sessionId, floor) : db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId)).filter(isAssignmentRow);
     const sessionAssignments = getSessionAssignments(sessionId);
     sessionAssignments.clear();
     let maxTagNumber = 0;
@@ -182397,7 +182743,7 @@ function createTagger() {
     loadSignatures.set(sessionId, {
       db,
       dataVersion: probe.dataVersion,
-      totalChanges: probe.totalChanges
+      floor
     });
   }
   function cleanup(sessionId) {
@@ -182420,13 +182766,13 @@ function createTagger() {
     cleanup
   };
 }
+
 // src/hooks/magic-context/hook.ts
 init_magic_context();
 init_project_identity();
 init_project_embedding_registry();
 await init_storage();
 init_logger();
-init_resolve_fallbacks();
 init_rpc_notifications();
 
 // src/hooks/magic-context/command-handler.ts
@@ -182477,6 +182823,7 @@ await __promiseAll([
 // src/hooks/magic-context/compartment-trigger.ts
 init_compartment_storage();
 init_logger();
+init_read_session_true_raw_tokens();
 await __promiseAll([
   init_storage(),
   init_protected_tail_boundary(),
@@ -182491,6 +182838,38 @@ var TAIL_SIZE_TRIGGER_MULTIPLIER = 3;
 var FORCE_COMPARTMENT_PERCENTAGE = 80;
 var BLOCK_UNTIL_DONE_PERCENTAGE = 95;
 var FORCE_MATERIALIZE_PERCENTAGE = 85;
+var CONTENT_TAG_OWNER_SUFFIX = /:(?:p|file)\d+$/;
+function tagOwnerMessageId(row) {
+  if (row.type === "tool")
+    return row.tool_owner_message_id ?? row.message_id;
+  return row.message_id.replace(CONTENT_TAG_OWNER_SUFFIX, "");
+}
+function getActiveOrDroppedTagOwnerMessageIds(db, sessionId, floor = 0) {
+  const rows = floor > 0 ? db.prepare(`SELECT type, message_id, tool_owner_message_id
+                       FROM tags
+                       WHERE session_id = ? AND status IN ('active', 'dropped') AND tag_number >= ?`).all(sessionId, floor) : db.prepare(`SELECT type, message_id, tool_owner_message_id
+                       FROM tags
+                       WHERE session_id = ? AND status IN ('active', 'dropped')`).all(sessionId);
+  const owners = new Set;
+  for (const row of rows)
+    owners.add(tagOwnerMessageId(row));
+  return owners;
+}
+function estimateUntaggedInMemoryTailUpperBound(db, sessionId, inMemoryTail, taggerFloor = 0) {
+  const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
+  const coveredOwnerMessageIds = getActiveOrDroppedTagOwnerMessageIds(db, sessionId, taggerFloor);
+  let total = 0;
+  for (const message of inMemoryTail.messages) {
+    if (message.ordinal <= lastCompartmentEnd)
+      continue;
+    if (coveredOwnerMessageIds.has(message.id))
+      continue;
+    total += estimateTrueRawMessageTokens(message, {
+      providerShapeVersion: "opencode-v1"
+    }).total;
+  }
+  return total;
+}
 function buildTriggerInMemoryTail(db, sessionId, messages) {
   if (messages.length === 0)
     return;
@@ -182562,7 +182941,7 @@ function resolveBoundaryContextLimit(usage, fallbackContextLimit) {
   }
   return 128000;
 }
-function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail) {
+function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor = 0) {
   return withRawSessionMessageCache(() => {
     try {
       const memoryPrimed = inMemoryTail ? primeInMemoryTailRawMessageCache({
@@ -182591,7 +182970,8 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
         contextLimit: resolveBoundaryContextLimit(usage, contextLimit),
         executeThresholdPercentage,
         usage,
-        usageSource: "live"
+        usageSource: "live",
+        taggerFloor
       });
       const hasProtectedEligibleHead = boundary.offset < boundary.protectedTailStart;
       if (!hasProtectedEligibleHead) {
@@ -182622,7 +183002,7 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThr
     }
   });
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, clearReasoningAge, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, clearReasoningAge, commitClusterTrigger, preloadedActiveTags, contextLimit, inMemoryTail, taggerFloorOverride) {
   if (sessionMeta.compartmentInProgress) {
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
@@ -182636,14 +183016,17 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       inMemoryTail = undefined;
     }
   }
+  const taggerFloor = taggerFloorOverride !== undefined && taggerFloorOverride > 0 ? taggerFloorOverride : inMemoryTail ? deriveTagLoadFloor(db, sessionId, inMemoryTail.messages.map((m) => m.id)) : 0;
   const proactiveFloorForGate = getProactiveCompartmentTriggerPercentage(executeThresholdPercentage);
-  if (!inMemoryTail && usage.percentage < proactiveFloorForGate) {
+  if (usage.percentage < proactiveFloorForGate) {
     try {
-      const { bound, nullCount } = getTriggerTagTokenUpperBound(db, sessionId);
+      const { bound: persistedBound, nullCount } = getTriggerTagTokenUpperBound(db, sessionId, taggerFloor);
       if (nullCount === 0) {
-        const eligibleUpperBound = bound;
+        const untaggedUpperBound = inMemoryTail ? estimateUntaggedInMemoryTailUpperBound(db, sessionId, inMemoryTail, taggerFloor) : 0;
+        const eligibleUpperBound = persistedBound + untaggedUpperBound;
         if (eligibleUpperBound < triggerBudget) {
-          sessionLog(sessionId, `compartment trigger: cheap-skip at ${usage.percentage.toFixed(1)}% (below proactive floor ${proactiveFloorForGate}%) — live-tail upper bound ${eligibleUpperBound} < triggerBudget ${triggerBudget}; no size trigger possible, skipped full raw read`);
+          const memorySuffix = inMemoryTail ? ` (persisted=${persistedBound}, untagged-memory≤${untaggedUpperBound})` : "";
+          sessionLog(sessionId, `compartment trigger: cheap-skip at ${usage.percentage.toFixed(1)}% (below proactive floor ${proactiveFloorForGate}%) — live-tail upper bound ${eligibleUpperBound}${memorySuffix} < triggerBudget ${triggerBudget}; no size trigger possible, skipped full raw read`);
           return { shouldFire: false };
         }
       }
@@ -182651,7 +183034,7 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       sessionLog(sessionId, `compartment trigger: cheap-gate skipped (falling through to full read): ${error51 instanceof Error ? error51.message : String(error51)}`);
     }
   }
-  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail);
+  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor);
   if (!tailInfo.hasNewRawHistory) {
     try {
       const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
@@ -183017,7 +183400,7 @@ function createMagicContextCommandHandler(deps) {
   const isAugCommand = (command) => command === "ctx-aug";
   const isDreamCommand = (command) => command === "ctx-dream";
   const isSessionUpgradeCommand = (command) => command === "ctx-session-upgrade";
-  const isEmbedHistoryCommand = (command) => command === "ctx-embed-history";
+  const isEmbedCommand = (command) => command === "ctx-embed";
   return {
     "command.execute.before": async (input, _output, _params) => {
       const isStatus = isStatusCommand(input.command);
@@ -183026,8 +183409,8 @@ function createMagicContextCommandHandler(deps) {
       const isAug = isAugCommand(input.command);
       const isDream = isDreamCommand(input.command);
       const isSessionUpgrade = isSessionUpgradeCommand(input.command);
-      const isEmbedHistory = isEmbedHistoryCommand(input.command);
-      if (!isStatus && !isFlush && !isRecomp && !isAug && !isDream && !isSessionUpgrade && !isEmbedHistory) {
+      const isEmbed = isEmbedCommand(input.command);
+      if (!isStatus && !isFlush && !isRecomp && !isAug && !isDream && !isSessionUpgrade && !isEmbed) {
         return;
       }
       const sessionId = input.sessionID;
@@ -183040,15 +183423,50 @@ function createMagicContextCommandHandler(deps) {
         await executeDreaming(deps, sessionId);
         return;
       }
-      if (isEmbedHistory) {
-        const summary = deps.executeEmbedHistory ? await deps.executeEmbedHistory(sessionId) : "Semantic embedding is not configured for this project, so there is nothing to embed.";
-        await deps.sendNotification(sessionId, summary, {});
-        throwSentinel(input.command);
+      if (isEmbed) {
+        const sub = input.arguments.trim().toLowerCase();
+        if (sub === "pause") {
+          const summary = deps.pauseEmbedDrain ? deps.pauseEmbedDrain(sessionId) : "Embedding pause is unavailable.";
+          if (isTuiConnected(sessionId)) {
+            pushNotification("action", { action: "show-result-dialog", title: "Embed", message: summary }, sessionId);
+          } else {
+            await deps.sendNotification(sessionId, summary, {});
+          }
+          throwSentinel(input.command);
+        }
+        if (sub === "start") {
+          const summary = deps.executeEmbedHistory ? await deps.executeEmbedHistory(sessionId) : "Semantic embedding is not configured for this project, so there is nothing to embed.";
+          if (isTuiConnected(sessionId)) {
+            pushNotification("action", { action: "show-result-dialog", title: "Embed", message: summary }, sessionId);
+          } else {
+            await deps.sendNotification(sessionId, summary, {});
+          }
+          throwSentinel(input.command);
+        }
+        if (sub !== "") {
+          await deps.sendNotification(sessionId, "Usage: `/ctx-embed` (status), `/ctx-embed start`, or `/ctx-embed pause`.", {});
+          throwSentinel(input.command);
+        }
+        if (isTuiConnected(sessionId)) {
+          pushNotification("action", { action: "show-embed-dialog" }, sessionId);
+          sessionLog(sessionId, "command ctx-embed: pushed show-embed-dialog to TUI");
+          throwSentinel(input.command);
+        }
+        result = deps.getEmbedStatusText ? `## Embedding Status
+
+${deps.getEmbedStatusText(sessionId)}` : `## Embedding Status
+
+Embedding status is unavailable.`;
       }
       if (isFlush) {
         result = executeFlush(deps.db, sessionId);
         clearCachedM0M1(deps.db, sessionId);
         deps.onFlush?.(sessionId);
+        if (isTuiConnected(sessionId)) {
+          pushNotification("action", { action: "show-flush-dialog", message: result }, sessionId);
+          sessionLog(sessionId, "command ctx-flush: pushed show-flush-dialog to TUI");
+          throwSentinel(input.command);
+        }
       }
       if (isStatus) {
         if (isTuiConnected(sessionId)) {
@@ -183175,6 +183593,34 @@ ${snap.error}`;
 // src/hooks/magic-context/hook.ts
 init_derive_budgets();
 
+// src/hooks/magic-context/embed-session-state.ts
+var embedPauseBySession = new Set;
+var embedRunStateBySession = new Map;
+var autoEmbedAttemptedBySession = new Set;
+function getEmbedDrainUiStatus(sessionId, progress) {
+  if (embedPauseBySession.has(sessionId)) {
+    return { status: "paused" };
+  }
+  if (progress?.kind === "embed" && progress.phase === "recomp") {
+    return { status: "running" };
+  }
+  if (progress?.kind === "embed" && (progress.phase === "failed" || progress.phase === "skipped") && progress.message) {
+    if (/provider/i.test(progress.message)) {
+      return { status: "stopped", detail: progress.message };
+    }
+  }
+  return { status: "idle" };
+}
+function clearEmbedSessionState(sessionId) {
+  embedPauseBySession.delete(sessionId);
+  const ctrl = embedRunStateBySession.get(sessionId);
+  if (ctrl) {
+    ctrl.abort();
+    embedRunStateBySession.delete(sessionId);
+  }
+  autoEmbedAttemptedBySession.delete(sessionId);
+}
+
 // src/features/magic-context/message-index-async.ts
 init_logger();
 await init_message_index();
@@ -183323,9 +183769,142 @@ function clearSessionTracking(sessionId) {
 // src/hooks/magic-context/event-handler.ts
 init_overflow_detection();
 init_storage_meta_persisted();
+await init_storage();
+
+// src/features/magic-context/transform-decision-log.ts
+await __promiseAll([
+  init_sqlite(),
+  init_storage_db()
+]);
+var canonicalReasons = new Set([
+  "system_hash",
+  "model_change",
+  "project_memory_epoch",
+  "ttl_idle",
+  "explicit_flush",
+  "max_mutation_id",
+  "first_render",
+  "pressure_refold",
+  "upgrade_state",
+  "cached_m1_missing"
+]);
+var piReasonAliases = {
+  project_memory_change: "project_memory_epoch",
+  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 writerOverrideForTests = null;
+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 clearTransformDecisionSession(sessionId) {
+  pendingDecisionBySession.delete(sessionId);
+  pendingPiDecisionBySession.delete(sessionId);
+  lastBoundMessageIdBySession.delete(sessionId);
+  scheduledWriteTokensBySession.delete(sessionId);
+}
+function recordPendingTransformDecision(sessionId, decision) {
+  if (!decision.bustedThisPass) {
+    pendingDecisionBySession.delete(sessionId);
+    return;
+  }
+  pendingDecisionBySession.set(sessionId, decision);
+}
+function scheduleOpenCodeTransformDecisionWrite(args) {
+  const pending = pendingDecisionBySession.get(args.sessionId);
+  if (!pending)
+    return false;
+  if (lastBoundMessageIdBySession.get(args.sessionId) === args.messageId) {
+    return false;
+  }
+  const dbPath = getDatabasePath(args.db);
+  if (!dbPath)
+    return false;
+  lastBoundMessageIdBySession.set(args.sessionId, args.messageId);
+  pendingDecisionBySession.delete(args.sessionId);
+  const token = addScheduledWriteToken(args.sessionId);
+  setTimeout(() => {
+    try {
+      if (!hasScheduledWriteToken(args.sessionId, token))
+        return;
+      writeTransformDecisionBestEffort(dbPath, {
+        ...pending,
+        sessionId: args.sessionId,
+        harness: "opencode",
+        messageId: args.messageId,
+        inputTokens: args.inputTokens
+      });
+    } finally {
+      deleteScheduledWriteToken(args.sessionId, token);
+    }
+  }, 0);
+  return true;
+}
+function addScheduledWriteToken(sessionId) {
+  const token = Symbol(sessionId);
+  let tokens = scheduledWriteTokensBySession.get(sessionId);
+  if (!tokens) {
+    tokens = new Set;
+    scheduledWriteTokensBySession.set(sessionId, tokens);
+  }
+  tokens.add(token);
+  return token;
+}
+function hasScheduledWriteToken(sessionId, token) {
+  return scheduledWriteTokensBySession.get(sessionId)?.has(token) === true;
+}
+function deleteScheduledWriteToken(sessionId, token) {
+  const tokens = scheduledWriteTokensBySession.get(sessionId);
+  if (!tokens)
+    return;
+  tokens.delete(token);
+  if (tokens.size === 0)
+    scheduledWriteTokensBySession.delete(sessionId);
+}
+function writeTransformDecisionBestEffort(dbPath, row) {
+  try {
+    const writer = writerOverrideForTests ?? writeTransformDecisionRow;
+    writer(dbPath, row);
+  } catch {}
+}
+function writeTransformDecisionRow(dbPath, row) {
+  const db = new Database(dbPath);
+  try {
+    db.exec("PRAGMA busy_timeout=0");
+    db.prepare(`INSERT OR REPLACE INTO transform_decisions (
+                session_id, harness, message_id, ts_ms, decision, materialized,
+                materialize_reason, emergency, dropped_tokens, dropped_count, input_tokens
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.sessionId, row.harness, row.messageId, row.tsMs, row.decision, row.materialized ? 1 : 0, row.materializeReason, row.emergency ? 1 : 0, Math.max(0, Math.floor(row.droppedTokens)), Math.max(0, Math.floor(row.droppedCount)), Math.max(0, Math.floor(row.inputTokens)));
+  } finally {
+    closeQuietly(db);
+  }
+}
+
+// src/hooks/magic-context/event-handler.ts
 init_logger();
 init_models_dev_cache();
-await init_storage();
 
 // src/hooks/magic-context/channel2-delivery.ts
 init_storage_meta_persisted();
@@ -183535,6 +184114,13 @@ function computePressure(input) {
 function approxThousands(tokens) {
   return `${Math.round(tokens / 1000)}k`;
 }
+function formatOldestReclaimableHint(hint) {
+  if (!hint || hint.length === 0)
+    return "";
+  const rendered = hint.slice(0, 4).map((tag) => `§${tag.tagNumber}§ ${tag.toolName ?? "tool"}`).join(" · ");
+  return rendered.length > 0 ? `
+oldest reclaimable: ${rendered}.` : "";
+}
 var CHANNEL2_USABLE_FRACTION = 1 / 3;
 var CHANNEL2_MIN_RECLAIMABLE = 1e4;
 function shouldTriggerChannel2(input) {
@@ -183544,14 +184130,16 @@ function shouldTriggerChannel2(input) {
     return true;
   return input.reclaimableTokens >= input.usableTokens * CHANNEL2_USABLE_FRACTION;
 }
-function buildChannel2Reminder(undroppedTokens) {
+function buildChannel2Reminder(undroppedTokens, hint) {
   const amount = approxThousands(undroppedTokens);
+  const hintText = formatOldestReclaimableHint(hint);
   return `<system-reminder>
-` + `Routine context housekeeping is near: a large span of this session will be comparted soon, ` + `and ~${amount} tokens of tool output remain unreduced. Drop spent outputs with ctx_reduce ` + `first so the archived span is the part that matters.
+` + `Routine context housekeeping is near: a large span of this session will be comparted soon, ` + `and ~${amount} tokens of tool output remain unreduced. Drop spent outputs with ctx_reduce ` + `first so the archived span is the part that matters.${hintText}
 ` + `</system-reminder>`;
 }
-function buildChannel1Reminder(level, undroppedTokens) {
+function buildChannel1Reminder(level, undroppedTokens, hint) {
   const amount = approxThousands(undroppedTokens);
+  const hintText = formatOldestReclaimableHint(hint);
   let body;
   switch (level) {
     case "gentle":
@@ -183567,7 +184155,7 @@ function buildChannel1Reminder(level, undroppedTokens) {
   return `
 
 <system-reminder>
-${body}
+${body}${hintText}
 </system-reminder>`;
 }
 
@@ -183621,10 +184209,10 @@ async function maybeDeliverChannel2(sessionId, deps) {
   try {
     const client3 = getLiveServerClient(serverUrl, deps.directory);
     const promptContext = await resolvePromptContext(client3, sessionId);
-    const reminder = buildChannel2Reminder(deps.reclaimableTokens);
+    const reminder = buildChannel2Reminder(deps.reclaimableTokens, deps.oldestReclaimableToolTags);
     const body = {
       noReply: false,
-      parts: [{ type: "text", text: reminder }]
+      parts: [{ type: "text", text: reminder, synthetic: true }]
     };
     if (promptContext?.agent)
       body.agent = promptContext.agent;
@@ -183720,11 +184308,13 @@ function getMessageUpdatedAssistantInfo(properties) {
   }
   const tokens = isRecord(info.tokens) ? info.tokens : undefined;
   const cache = tokens && isRecord(tokens.cache) ? tokens.cache : undefined;
+  const time3 = isRecord(info.time) ? info.time : undefined;
   return {
     role: "assistant",
     finish: typeof info.finish === "string" ? info.finish : undefined,
     sessionID: info.sessionID,
     messageID: typeof info.id === "string" ? info.id : undefined,
+    completedAt: typeof time3?.completed === "number" ? time3.completed : undefined,
     providerID: typeof info.providerID === "string" ? info.providerID : undefined,
     modelID: typeof info.modelID === "string" ? info.modelID : undefined,
     tokens: {
@@ -183787,8 +184377,8 @@ init_project_identity();
 import * as crypto2 from "node:crypto";
 init_session_project_storage();
 init_storage_meta_persisted();
-init_logger();
 await init_storage();
+init_logger();
 
 // src/hooks/magic-context/boundary-execution.ts
 var FORCE_MATERIALIZE_PERCENTAGE2 = 85;
@@ -184082,7 +184672,8 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config2) {
   const result = {
     compressedToLite: 0,
     compressedToFull: 0,
-    compressedToUltra: 0
+    compressedToUltra: 0,
+    mutatedTextTags: 0
   };
   if (!config2.enabled)
     return result;
@@ -184123,7 +184714,9 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config2) {
       const target = targets.get(tag.tagNumber);
       if (!target)
         continue;
-      target.setContent(compressed);
+      const didMutate = target.setContent(compressed);
+      if (didMutate)
+        result.mutatedTextTags += 1;
       updateCavemanDepth(db, sessionId, tag.tagNumber, targetDepth);
       if (targetDepth === DEPTH_LITE)
         result.compressedToLite += 1;
@@ -184711,28 +185304,6 @@ function stripInlineThinking(messages, messageTagNumbers, clearReasoningAge) {
   }
   return stripped;
 }
-function truncateErroredTools(messages, watermark, messageTagNumbers) {
-  let truncated = 0;
-  for (let i = 0;i < messages.length; i++) {
-    const maxTag = messageTagNumbers.get(messages[i]) ?? 0;
-    if (maxTag > watermark) {
-      continue;
-    }
-    for (const part of messages[i].parts) {
-      if (!isRecord(part) || part.type !== "tool" || !isRecord(part.state)) {
-        continue;
-      }
-      if (part.state.status !== "error") {
-        continue;
-      }
-      if (typeof part.state.error === "string" && part.state.error.length > 100) {
-        part.state.error = `${part.state.error.slice(0, 100)}... [truncated]`;
-        truncated++;
-      }
-    }
-  }
-  return truncated;
-}
 var REASONING_IGNORED_PART_TYPES = new Set([
   "step-start",
   "step-finish",
@@ -184843,6 +185414,7 @@ function stripProcessedImages(messages, frozenIds, options) {
 init_temporal_awareness();
 
 // src/hooks/magic-context/transform-compartment-phase.ts
+init_compartment_storage();
 init_logger();
 await __promiseAll([
   init_storage(),
@@ -184851,9 +185423,29 @@ await __promiseAll([
 init_send_session_notification();
 await __promiseAll([
   init_inject_compartments(),
-  init_protected_tail_boundary()
+  init_protected_tail_boundary(),
+  init_read_session_chunk()
 ]);
-async function runCompartmentPhase(args) {
+function runCompartmentPhase(args) {
+  const historianRunnable = args.historianRunnable !== false;
+  const willReadRawHistory = historianRunnable && args.canRunCompartments && getActiveCompartmentRun(args.sessionId) === undefined && (args.sessionMeta.compartmentInProgress || !args.skipAwaitForThisPass && args.contextUsage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE);
+  if (!willReadRawHistory) {
+    return runCompartmentPhaseImpl(args);
+  }
+  return withRawSessionMessageCache(() => {
+    try {
+      primeTailRawMessageCache({
+        sessionId: args.resolvedSessionId,
+        lastCompartmentEnd: getLastCompartmentEndMessage(args.db, args.resolvedSessionId),
+        anchorMessageId: getLastCompartmentEndMessageId(args.db, args.resolvedSessionId)
+      });
+    } catch (error51) {
+      sessionLog(args.sessionId, "compartment phase: tail prime failed (non-fatal):", error51);
+    }
+    return runCompartmentPhaseImpl(args);
+  });
+}
+async function runCompartmentPhaseImpl(args) {
   let pendingCompartmentInjection = args.pendingCompartmentInjection;
   let compartmentInProgress = args.sessionMeta.compartmentInProgress;
   let published = false;
@@ -185150,78 +185742,11 @@ function appendReminderToUserMessage(message, reminder) {
 
 // src/hooks/magic-context/apply-operations.ts
 await init_storage();
-
-// src/hooks/magic-context/system-injection-stripper.ts
-var SYSTEM_INJECTION_MARKERS = [
-  "<!-- OMO_INTERNAL_INITIATOR -->",
-  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
-  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
-  "[Category+Skill Reminder]",
-  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
-  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
-  "[EMERGENCY CONTEXT WINDOW WARNING]",
-  "Unstable background agent appears idle",
-  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
-];
-var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
-var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
-function stripSystemInjection(text) {
-  let hasInjection = false;
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (text.includes(marker)) {
-      hasInjection = true;
-      break;
-    }
-  }
-  if (SYSTEM_REMINDER_REGEX.test(text))
-    hasInjection = true;
-  SYSTEM_REMINDER_REGEX.lastIndex = 0;
-  if (!hasInjection)
-    return null;
-  let cleaned = text;
-  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
-  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
-  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
-      continue;
-    const idx = cleaned.indexOf(marker);
-    if (idx === -1)
-      continue;
-    const blockEnd = cleaned.indexOf(`
-
-`, idx + marker.length);
-    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
-  }
-  return cleaned.trim();
-}
-
-// src/hooks/magic-context/apply-operations.ts
-init_tag_part_guards();
-var USER_DROP_PREVIEW_CHARS = 250;
 var RECENT_TOOL_SKELETON_WINDOW = 20;
-function buildReplacementContent(tagId, target) {
-  const role = target.message?.info.role;
-  if (role !== "user") {
-    return `[dropped §${tagId}§]`;
-  }
-  const currentContent = target.getContent?.() ?? "";
-  const strippedInjection = stripSystemInjection(currentContent);
-  if (strippedInjection !== null && stripTagPrefix(strippedInjection).trim().length === 0) {
-    return `[dropped §${tagId}§]`;
-  }
-  const originalText = stripTagPrefix(currentContent);
-  if (originalText.length <= USER_DROP_PREVIEW_CHARS) {
-    return `[truncated §${tagId}§]
-${originalText}`;
-  }
-  const hardCut = originalText.slice(0, USER_DROP_PREVIEW_CHARS);
-  const softCutIndex = hardCut.search(/\s\S*$/);
-  const preview = softCutIndex > USER_DROP_PREVIEW_CHARS - 30 ? hardCut.slice(0, softCutIndex) : hardCut;
-  return `[truncated §${tagId}§]
-${preview}…`;
-}
-function applyPendingOperations(sessionId, db, targets, protectedTags = 0, preloadedTags, preloadedPendingOps) {
+function buildReplacementContent(tagId) {
+  return `[dropped §${tagId}§]`;
+}
+function applyPendingOperations(sessionId, db, targets, protectedTags = 0, preloadedTags, preloadedPendingOps, syntheticPendingOps = []) {
   let didMutateMessage = false;
   db.transaction(() => {
     const tags = preloadedTags ?? getTagsBySession(db, sessionId);
@@ -185229,11 +185754,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTags = 0, prelo
     const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
     const protectedTagIds = protectedTags > 0 ? new Set(tags.filter((tag) => tag.status === "active").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, protectedTags)) : new Set;
     const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+    const opsToApply = [
+      ...pendingOps.map((op) => ({ op, synthetic: false })),
+      ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
+    ];
     const skeletonWindow = new Set(tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW));
-    for (const pendingOp of pendingOps) {
+    for (const { op: pendingOp, synthetic } of opsToApply) {
       const tagStatus = tagStatusById.get(pendingOp.tagId);
       if (tagStatus === "compacted" || tagStatus === "dropped") {
-        removePendingOp(db, sessionId, pendingOp.tagId);
+        if (!synthetic)
+          removePendingOp(db, sessionId, pendingOp.tagId);
         continue;
       }
       if (protectedTagIds.has(pendingOp.tagId)) {
@@ -185241,33 +185771,46 @@ function applyPendingOperations(sessionId, db, targets, protectedTags = 0, prelo
       }
       const target = targets.get(pendingOp.tagId);
       const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
+      if (synthetic) {
+        if (!isToolTag || target?.canDrop?.() !== true)
+          continue;
+      }
+      let shouldPersistDrop = false;
       if (isToolTag) {
         if (skeletonWindow.has(pendingOp.tagId)) {
           const truncResult = target?.truncate?.() ?? "absent";
-          if (truncResult === "incomplete") {
+          if (truncResult === "incomplete" || synthetic && truncResult !== "truncated") {
             continue;
           }
           if (truncResult === "truncated") {
             didMutateMessage = true;
           }
           updateTagDropMode(db, sessionId, pendingOp.tagId, "truncated");
+          shouldPersistDrop = true;
         } else {
           const dropResult = target?.drop?.() ?? "absent";
-          if (dropResult === "incomplete") {
+          if (dropResult === "incomplete" || synthetic && dropResult !== "removed") {
             continue;
           }
           if (dropResult === "removed") {
             didMutateMessage = true;
           }
           updateTagDropMode(db, sessionId, pendingOp.tagId, "full");
+          shouldPersistDrop = true;
         }
       } else if (target) {
-        const changed = target.setContent(buildReplacementContent(pendingOp.tagId, target));
+        const changed = target.setContent(buildReplacementContent(pendingOp.tagId));
         if (changed)
           didMutateMessage = true;
+        shouldPersistDrop = true;
+      } else if (!synthetic) {
+        shouldPersistDrop = true;
       }
+      if (!shouldPersistDrop)
+        continue;
       updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
-      removePendingOp(db, sessionId, pendingOp.tagId);
+      if (!synthetic)
+        removePendingOp(db, sessionId, pendingOp.tagId);
     }
   })();
   return didMutateMessage;
@@ -185291,7 +185834,7 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
           }
         }
       } else if (target) {
-        const changed = target.setContent(buildReplacementContent(tag.tagNumber, target));
+        const changed = target.setContent(buildReplacementContent(tag.tagNumber));
         if (changed)
           didMutateMessage = true;
       }
@@ -185468,6 +186011,7 @@ function createExistingTagResolver(sessionId, tagger, db) {
         return;
       }
       updateTagMessageId(db, sessionId, fallback.tagNumber, currentContentId);
+      tagger.unbindTag(sessionId, fallback.contentId);
       tagger.bindTag(sessionId, currentContentId, fallback.tagNumber);
       usedTagNumbers.add(fallback.tagNumber);
       return fallback.tagNumber;
@@ -185488,7 +186032,45 @@ function logTransformTiming(sessionId, stage, startMs, extra) {
 }
 
 // src/hooks/magic-context/tag-messages.ts
-function deriveToolOwnerMessageId(sessionId, db, message, obs, unpaired) {
+var TOOL_OWNER_CACHE_KEY_SEP = "\x00";
+function makeToolOwnerCacheKey(sessionId, callId) {
+  return `${sessionId}${TOOL_OWNER_CACHE_KEY_SEP}${callId}`;
+}
+function getCachedCandidateToolOwners(db, sessionId, callId, cache, onLookup) {
+  const key = makeToolOwnerCacheKey(sessionId, callId);
+  const cached2 = cache.candidateOwnersByCallId.get(key);
+  if (cached2 !== undefined)
+    return cached2;
+  onLookup?.({ kind: "candidates", callId });
+  const candidates = getCandidateToolOwners(db, sessionId, callId);
+  cache.candidateOwnersByCallId.set(key, candidates);
+  return candidates;
+}
+function getCachedMessageTimesFromOpenCodeDb(sessionId, messageIds, cache, onLookup) {
+  const uncached = [...new Set(messageIds)].filter((id) => !cache.messageTimesById.has(id));
+  if (uncached.length > 0) {
+    onLookup?.({ kind: "messageTimes", messageIds: uncached });
+    const resolved = getMessageTimesFromOpenCodeDb(sessionId, uncached);
+    for (const id of uncached) {
+      cache.messageTimesById.set(id, resolved.get(id) ?? null);
+    }
+  }
+  const times = new Map;
+  for (const id of messageIds) {
+    const time3 = cache.messageTimesById.get(id);
+    if (typeof time3 === "number")
+      times.set(id, time3);
+  }
+  return times;
+}
+function invalidateCachedCandidateToolOwnersIfNewOwner(cache, sessionId, callId, ownerMsgId) {
+  const key = makeToolOwnerCacheKey(sessionId, callId);
+  const cached2 = cache.candidateOwnersByCallId.get(key);
+  if (cached2 !== undefined && !cached2.includes(ownerMsgId)) {
+    cache.candidateOwnersByCallId.delete(key);
+  }
+}
+function deriveToolOwnerMessageId(sessionId, db, message, obs, unpaired, cache, onFallbackLookup) {
   const messageId = typeof message.info.id === "string" ? message.info.id : "";
   if (obs.kind === "invocation") {
     if (messageId) {
@@ -185508,10 +186090,10 @@ function deriveToolOwnerMessageId(sessionId, db, message, obs, unpaired) {
       return popped;
   }
   if (messageId) {
-    const candidates = getCandidateToolOwners(db, sessionId, obs.callId);
+    const candidates = getCachedCandidateToolOwners(db, sessionId, obs.callId, cache, onFallbackLookup);
     if (candidates.length > 0) {
       const ids = [...candidates, messageId];
-      const times = getMessageTimesFromOpenCodeDb(sessionId, ids);
+      const times = getCachedMessageTimesFromOpenCodeDb(sessionId, ids, cache, onFallbackLookup);
       const persisted = pickNearestPriorOwner(candidates, messageId, times);
       if (persisted !== null)
         return persisted;
@@ -185592,6 +186174,7 @@ function extractToolTagMetadata(part) {
 }
 function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const skipPrefixInjection = options.skipPrefixInjection === true;
+  const onToolOwnerFallbackLookup = options.onToolOwnerFallbackLookup;
   const targets = new Map;
   const reasoningByMessage = new Map;
   const messageTagNumbers = new Map;
@@ -185599,6 +186182,10 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const toolThinkingByCallId = new Map;
   const toolCallIndex = new Map;
   const unpairedInvocations = new Map;
+  const ownerDerivationCache = {
+    candidateOwnersByCallId: new Map,
+    messageTimesById: new Map
+  };
   const ownerByPartKey = new Map;
   const batch = new ToolMutationBatch(messages);
   const assignments = tagger.getAssignments(sessionId);
@@ -185639,7 +186226,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
       const toolObservation = extractToolCallObservation(part);
       if (toolObservation) {
         const _tDerive = performance.now();
-        const ownerMsgId = deriveToolOwnerMessageId(sessionId, db, message, toolObservation, unpairedInvocations);
+        const ownerMsgId = deriveToolOwnerMessageId(sessionId, db, message, toolObservation, unpairedInvocations, ownerDerivationCache, onToolOwnerFallbackLookup);
         accDerive += performance.now() - _tDerive;
         const compositeKey = makeToolCompositeKey(ownerMsgId, toolObservation.callId);
         const entry = toolCallIndex.get(compositeKey) ?? {
@@ -185658,6 +186245,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           if (orphan !== null) {
             const claimed = adoptNullOwnerToolTag(db, orphan.id, ownerMsgId);
             if (claimed) {
+              invalidateCachedCandidateToolOwnersIfNewOwner(ownerDerivationCache, sessionId, toolObservation.callId, ownerMsgId);
               tagger.bindToolTag(sessionId, toolObservation.callId, ownerMsgId, orphan.tagNumber);
               existingTagId = orphan.tagNumber;
             } else {
@@ -185665,6 +186253,13 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
             }
           }
         }
+        if (existingTagId === undefined) {
+          const persisted = getToolTagNumberByOwner(db, sessionId, toolObservation.callId, ownerMsgId);
+          if (persisted !== null) {
+            tagger.bindToolTag(sessionId, toolObservation.callId, ownerMsgId, persisted);
+            existingTagId = persisted;
+          }
+        }
         if (existingTagId !== undefined) {
           toolTagByCallId.set(compositeKey, existingTagId);
           messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, existingTagId));
@@ -185737,6 +186332,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
           inputTokenCount,
           reasoningTokenCount: reasoningTokens
         }));
+        invalidateCachedCandidateToolOwnersIfNewOwner(ownerDerivationCache, sessionId, toolPart.callID, ownerMsgId);
         accAssignToolTag += performance.now() - _tAssignTool;
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         if (!skipPrefixInjection) {
@@ -185808,7 +186404,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   logTransformTiming(sessionId, "tag.saveSource", performance.now() - accSaveSource);
   for (const [compositeKey, tagId] of toolTagByCallId) {
     const thinkingParts = toolThinkingByCallId.get(compositeKey) ?? [];
-    targets.set(tagId, createToolDropTarget(compositeKey, thinkingParts, toolCallIndex, batch));
+    targets.set(tagId, createToolDropTarget(compositeKey, thinkingParts, toolCallIndex, batch, tagId));
   }
   const hasRecentReduceCall = lastReduceMessageIndex >= 0 && messages.length - lastReduceMessageIndex <= RECENT_REDUCE_LOOKBACK;
   return {
@@ -186735,7 +187331,7 @@ async function runAutoSearchHint(args) {
       embeddingEnabled,
       gitCommitsEnabled,
       embedQuery: async (text, signal) => {
-        const result = await embedTextForProject(options.projectPath, text, signal);
+        const result = await embedTextForProject(options.projectPath, text, signal, "query");
         return result?.vector ?? null;
       },
       isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
@@ -186916,6 +187512,51 @@ function planEmergencyDrop(input) {
   };
 }
 
+// src/hooks/magic-context/system-injection-stripper.ts
+var SYSTEM_INJECTION_MARKERS = [
+  "<!-- OMO_INTERNAL_INITIATOR -->",
+  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
+  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
+  "[Category+Skill Reminder]",
+  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
+  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
+  "[EMERGENCY CONTEXT WINDOW WARNING]",
+  "Unstable background agent appears idle",
+  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
+];
+var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
+var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
+function stripSystemInjection(text) {
+  let hasInjection = false;
+  for (const marker of SYSTEM_INJECTION_MARKERS) {
+    if (text.includes(marker)) {
+      hasInjection = true;
+      break;
+    }
+  }
+  if (SYSTEM_REMINDER_REGEX.test(text))
+    hasInjection = true;
+  SYSTEM_REMINDER_REGEX.lastIndex = 0;
+  if (!hasInjection)
+    return null;
+  let cleaned = text;
+  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
+  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
+  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
+  for (const marker of SYSTEM_INJECTION_MARKERS) {
+    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
+      continue;
+    const idx = cleaned.indexOf(marker);
+    if (idx === -1)
+      continue;
+    const blockEnd = cleaned.indexOf(`
+
+`, idx + marker.length);
+    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
+  }
+  return cleaned.trim();
+}
+
 // src/hooks/magic-context/heuristic-cleanup.ts
 init_tag_part_guards();
 var DEDUP_SAFE_TOOLS = new Set([
@@ -186934,6 +187575,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
   const maxTag = getMaxTagNumberBySession(db, sessionId);
   const protectedCutoff = maxTag - config2.protectedTags;
   let droppedTools = 0;
+  let emergencyDroppedTools = 0;
   let deduplicatedTools = 0;
   let droppedInjections = 0;
   if (config2.emergency) {
@@ -186965,6 +187607,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
             updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
             updateTagDropMode(db, sessionId, tag.tagNumber, "full");
             droppedTools++;
+            emergencyDroppedTools++;
           }
         }
         setEmergencyDropSample(db, sessionId, emergency.currentTotalInputTokens);
@@ -187043,7 +187686,9 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
             continue;
           updateTagDropMode(db, sessionId, tag.tagNumber, "full");
           updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-          deduplicatedTools++;
+          if (result === "removed" || result === "truncated") {
+            deduplicatedTools++;
+          }
         }
       }
     })();
@@ -187052,6 +187697,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
   }
   let compressedTextTags = 0;
+  let mutatedTextTags = 0;
   if (config2.caveman?.enabled) {
     const cavemanResult = applyCavemanCleanup(sessionId, db, targets, tags, {
       enabled: true,
@@ -187059,8 +187705,16 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
       protectedTags: config2.protectedTags
     });
     compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
+    mutatedTextTags = cavemanResult.mutatedTextTags;
   }
-  return { droppedTools, deduplicatedTools, droppedInjections, compressedTextTags };
+  return {
+    droppedTools,
+    deduplicatedTools,
+    droppedInjections,
+    emergencyDroppedTools,
+    compressedTextTags,
+    mutatedTextTags
+  };
 }
 function extractToolInfo(part) {
   if (part.type === "tool" && typeof part.tool === "string" && DEDUP_SAFE_TOOLS.has(part.tool)) {
@@ -187234,6 +187888,42 @@ function isTodoItem(value) {
   return typeof todo.content === "string" && typeof todo.status === "string" && (todo.priority === undefined || typeof todo.priority === "string");
 }
 
+// src/hooks/magic-context/tool-reclaim.ts
+await init_storage();
+function buildSyntheticToolReclaimOps(input) {
+  const watermark = Math.max(0, input.watermark);
+  if (watermark <= 0)
+    return [];
+  const realPendingTagIds = new Set((input.pendingOps ?? []).map((op) => op.tagId));
+  const tags = getActiveTagsBySession(input.db, input.sessionId);
+  const synthetic = [];
+  for (const tag of tags) {
+    if (tag.type !== "tool")
+      continue;
+    if (tag.status !== "active")
+      continue;
+    if (tag.tagNumber > watermark)
+      continue;
+    if (realPendingTagIds.has(tag.tagNumber))
+      continue;
+    if (input.targets.get(tag.tagNumber)?.canDrop?.() !== true)
+      continue;
+    synthetic.push({
+      id: 0,
+      sessionId: input.sessionId,
+      tagId: tag.tagNumber,
+      operation: "drop",
+      queuedAt: 0
+    });
+  }
+  return synthetic;
+}
+function advanceToolReclaimWatermarkToCurrentMax(db, sessionId) {
+  const maxTagNumber = getMaxTagNumberBySession(db, sessionId);
+  advanceToolReclaimWatermark(db, sessionId, maxTagNumber);
+  return maxTagNumber;
+}
+
 // src/hooks/magic-context/transform-postprocess-phase.ts
 var DEGRADE_CACHE_WARNING_THRESHOLD = 10;
 var degradedCacheCountBySession = new BoundedSessionMap(100);
@@ -187250,7 +187940,6 @@ async function runPostTransformPhase(args) {
   const emergencyDropEligible = args.contextUsage.percentage >= args.forceMaterializationPercentage;
   const activeCompartmentRun = args.canRunCompartments ? getActiveCompartmentRun(args.sessionId) : undefined;
   const compartmentRunning = args.canRunCompartments && !args.awaitedCompartmentRun && activeCompartmentRun !== undefined;
-  const emergencyBypassCompartmentGate = forceMaterialization;
   const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   const materializationRequested = isExplicitFlush || deferredMaterialize;
   const m0M1EnabledForFold = args.fullFeatureMode && args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory);
@@ -187262,11 +187951,12 @@ async function runPostTransformPhase(args) {
     projectDirectory: args.m0M1.projectDirectory,
     hardSignals: args.m0M1.hardSignals
   }).value : false;
+  const bypassCompartmentGate = forceMaterialization || m0HardFoldThisPass;
   const shouldReadPendingOps = materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || m0HardFoldThisPass || compartmentRunning;
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
-  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || m0HardFoldThisPass) && (!compartmentRunning || emergencyBypassCompartmentGate);
-  const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (materializationRequested || forceMaterialization || m0HardFoldThisPass || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || m0HardFoldThisPass) && (!compartmentRunning || bypassCompartmentGate);
+  const shouldRunHeuristics = (!compartmentRunning || bypassCompartmentGate) && (materializationRequested || forceMaterialization || m0HardFoldThisPass || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = shouldApplyPendingOps || shouldRunHeuristics;
   const canUseEmptySentinels = modelAcceptsEmptyContent(args.resolvedProviderID);
   if (shouldRunHeuristics) {
@@ -187278,8 +187968,9 @@ async function runPostTransformPhase(args) {
     sessionLog(args.sessionId, `transform: skipping heuristics (already ran for turn ${args.currentTurnId})`);
   }
   if (compartmentRunning && hasPendingUserOps) {
-    if (emergencyBypassCompartmentGate) {
-      sessionLog(args.sessionId, `transform: emergency bypass — applying ${pendingOps.length} pending ops while compartment agent runs (${args.contextUsage.percentage.toFixed(1)}%)`);
+    if (bypassCompartmentGate) {
+      const bypassReason = forceMaterialization ? "emergency >=85%" : "m0 hard fold";
+      sessionLog(args.sessionId, `transform: compartment-gate bypass (${bypassReason}) — applying ${pendingOps.length} pending ops while compartment agent runs (${args.contextUsage.percentage.toFixed(1)}%)`);
     } else {
       sessionLog(args.sessionId, "transform: deferring pending ops — compartment agent in progress");
     }
@@ -187288,12 +187979,24 @@ async function runPostTransformPhase(args) {
   let deferredMaterializedSuccessfully = false;
   let heuristicsRanSuccessfully = false;
   let pendingOpsRanSuccessfully = false;
+  let pendingOpsDidMutate = false;
+  let heuristicOrReasoningDidMutate = false;
+  let droppedCount = 0;
+  const droppedTokens = 0;
+  let emergency = false;
+  let m0RematerializedThisPass = false;
+  let m0MaterializeReason = null;
+  let m0M1InjectedThisPass = false;
+  let autoReclaimDidMutateThisPass = false;
   try {
     if (shouldApplyPendingOps) {
       const applyReason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
       sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
       const tApply = performance.now();
-      applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, pendingOps);
+      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, pendingOps);
+      if (pendingOpsDidMutate) {
+        droppedCount += pendingOps.length;
+      }
       logTransformTiming(args.sessionId, "applyPendingOperations", tApply);
     }
     if (shouldRunHeuristics) {
@@ -187311,9 +188014,12 @@ async function runPostTransformPhase(args) {
         } : undefined,
         caveman: cavemanConfig
       }, heuristicTags);
-      logTransformTiming(args.sessionId, "applyHeuristicCleanup", t5, `droppedTools=${cleanup.droppedTools} deduplicatedTools=${cleanup.deduplicatedTools} droppedInjections=${cleanup.droppedInjections} compressedTextTags=${cleanup.compressedTextTags}`);
+      logTransformTiming(args.sessionId, "applyHeuristicCleanup", t5, `droppedTools=${cleanup.droppedTools} deduplicatedTools=${cleanup.deduplicatedTools} droppedInjections=${cleanup.droppedInjections} compressedTextTags=${cleanup.compressedTextTags} mutatedTextTags=${cleanup.mutatedTextTags}`);
+      const heuristicMutationCount = cleanup.droppedTools + cleanup.deduplicatedTools + cleanup.droppedInjections + cleanup.mutatedTextTags;
+      droppedCount += cleanup.droppedTools + cleanup.deduplicatedTools + cleanup.droppedInjections + cleanup.mutatedTextTags;
+      emergency ||= cleanup.emergencyDroppedTools > 0;
       const t7 = performance.now();
-      const clearedReasoning = clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge);
+      const clearedReasoning = canUseEmptySentinels ? clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge) : 0;
       if (canUseEmptySentinels) {
         stripClearedReasoning(args.messages);
       }
@@ -187337,6 +188043,8 @@ async function runPostTransformPhase(args) {
         }
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", t7);
+      heuristicOrReasoningDidMutate = heuristicMutationCount + clearedReasoning + strippedInline > 0;
+      droppedCount += clearedReasoning + strippedInline;
       if (pendingMaterializationAtPassStart) {
         args.pendingMaterializationSessions.delete(args.sessionId);
       }
@@ -187347,7 +188055,35 @@ async function runPostTransformPhase(args) {
     if (args.schedulerDecision === "execute" && !materializationRequested) {
       updateSessionMeta(args.db, args.sessionId, { lastResponseTime: Date.now() });
     }
+    const toolReclaimExecutePass = args.schedulerDecision === "execute";
+    const alreadyMutatingThisPass = pendingOpsDidMutate || heuristicOrReasoningDidMutate;
+    let autoReclaimTargetCount = 0;
+    let autoReclaimDidMutate = false;
+    if (toolReclaimExecutePass && alreadyMutatingThisPass && !emergencyDropEligible) {
+      const syntheticPendingOps = buildSyntheticToolReclaimOps({
+        db: args.db,
+        sessionId: args.sessionId,
+        targets: args.targets,
+        watermark: args.sessionMeta.toolReclaimWatermark ?? 0,
+        pendingOps
+      });
+      autoReclaimTargetCount = syntheticPendingOps.length;
+      if (syntheticPendingOps.length > 0) {
+        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, [], syntheticPendingOps);
+        if (autoReclaimDidMutate) {
+          droppedCount += syntheticPendingOps.length;
+          autoReclaimDidMutateThisPass = true;
+        }
+      }
+    }
     args.batch?.finalize();
+    if (toolReclaimExecutePass) {
+      const maxTagNumber = advanceToolReclaimWatermarkToCurrentMax(args.db, args.sessionId);
+      args.sessionMeta.toolReclaimWatermark = Math.max(args.sessionMeta.toolReclaimWatermark ?? 0, maxTagNumber);
+    }
+    if (autoReclaimTargetCount > 0) {
+      sessionLog(args.sessionId, `tool reclaim auto-drop: targets=${autoReclaimTargetCount} mutated=${autoReclaimDidMutate}`);
+    }
     logTransformTiming(args.sessionId, "batchFinalize:heuristics", performance.now());
     if (args.sessionMeta.lastTransformError !== null) {
       updateSessionMeta(args.db, args.sessionId, { lastTransformError: null });
@@ -187359,11 +188095,6 @@ async function runPostTransformPhase(args) {
         deferredMaterializedSuccessfully = true;
       heuristicsRanSuccessfully = true;
     }
-    if (args.watermark > 0) {
-      const tWatermarkCleanup = performance.now();
-      truncateErroredTools(args.messages, args.watermark, args.messageTagNumbers);
-      logTransformTiming(args.sessionId, "watermarkCleanup", tWatermarkCleanup);
-    }
     if (shouldApplyPendingOps) {
       pendingOpsRanSuccessfully = true;
     }
@@ -187422,6 +188153,9 @@ async function runPostTransformPhase(args) {
         hardSignals: args.m0M1.hardSignals
       });
       if (result.injected) {
+        m0M1InjectedThisPass = true;
+        m0RematerializedThisPass ||= result.m0RematerializedThisPass;
+        m0MaterializeReason = result.decision.reason ?? m0MaterializeReason;
         sessionLog(args.sessionId, `transform: injected m[0]/m[1] (rematerialized=${result.m0RematerializedThisPass}, reason=${result.decision.reason ?? "cache_hit"})`);
       }
     } catch (error51) {
@@ -187630,7 +188364,19 @@ async function runPostTransformPhase(args) {
       sessionLog(args.sessionId, `sticky-injection GC: pruned ${prunedAnchors} note-nudge anchor(s), ${prunedDecisions} auto-search decision(s)`);
     }
   }
-  return { explicitMaterializedSuccessfully, deferredMaterializedSuccessfully };
+  const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? "explicit_flush" : null);
+  const materialized = m0RematerializedThisPass || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
+  const bustedThisPass = args.didMutateFromFlushedStatuses || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
+  return {
+    explicitMaterializedSuccessfully,
+    deferredMaterializedSuccessfully,
+    materialized,
+    materializeReason,
+    droppedTokens,
+    droppedCount,
+    emergency,
+    bustedThisPass
+  };
 }
 function checkM0MutationDriftAndSignal(args) {
   const currentMaxMutationId = getMaxM0MutationId(args.db, args.sessionId) ?? 0;
@@ -187665,6 +188411,12 @@ function clearMessageTokensCache(sessionId, messageId) {
     cache.delete(messageId);
 }
 var recordedSessionProjectIdentity = new BoundedSessionMap(MESSAGE_TOKENS_CACHE_MAX);
+function deriveTaggerLoadFloor(messages, sessionId, db) {
+  return deriveTagLoadFloor(db, sessionId, function* () {
+    for (const message of messages)
+      yield message.info?.id;
+  }());
+}
 function findLastAssistantModel2(messages) {
   for (let i = messages.length - 1;i >= 0; i--) {
     const info = messages[i].info;
@@ -187687,6 +188439,7 @@ function createTransform(deps) {
       return;
     }
     const resolvedSessionId = sessionId;
+    clearOpenCodePendingTransformDecision(sessionId);
     logTransformTiming(sessionId, "findSessionId", startTime, `messages=${messages.length}`);
     const db = deps.db;
     if (deps.client !== undefined) {
@@ -187989,12 +188742,16 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       recordSessionProjectIdentity(db, sessionId, sessionProjectIdentity);
       recordedSessionProjectIdentity.set(sessionId, sessionProjectIdentity);
     }
+    const taggerFloor = deriveTaggerLoadFloor(messages, sessionId, db);
+    if (taggerFloor === 0 && messages.length > 0) {
+      sessionLog(sessionId, `tag floor: 0 (full-scan fallback) — no leading wire message resolved a tag across ${messages.length} msgs`);
+    }
     let triggerBoundarySnapshot;
     if (fullFeatureMode && historianRunnable && !sessionMeta.compartmentInProgress) {
       const tTrigger = performance.now();
       try {
         const inMemoryTail = buildTriggerInMemoryTail(db, sessionId, extractInMemoryMessageViews(messages));
-        const triggerResult = checkCompartmentTrigger(db, sessionId, sessionMeta, boundaryUsageForProtectedTail, sessionMeta.lastContextPercentage, boundaryExecuteThreshold, deriveTriggerBudget(boundaryContextLimit, boundaryExecuteThreshold), deps.clearReasoningAge, deps.commitClusterTrigger, undefined, boundaryContextLimit, inMemoryTail);
+        const triggerResult = checkCompartmentTrigger(db, sessionId, sessionMeta, boundaryUsageForProtectedTail, sessionMeta.lastContextPercentage, boundaryExecuteThreshold, deriveTriggerBudget(boundaryContextLimit, boundaryExecuteThreshold), deps.clearReasoningAge, deps.commitClusterTrigger, undefined, boundaryContextLimit, inMemoryTail, taggerFloor);
         if (triggerResult.shouldFire) {
           sessionLog(sessionId, `compartment trigger: firing (reason=${triggerResult.reason})`);
           updateSessionMeta(db, sessionId, { compartmentInProgress: true });
@@ -188036,7 +188793,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     try {
       const t0 = performance.now();
       const tInitFromDb = performance.now();
-      deps.tagger.initFromDb(sessionId, db);
+      deps.tagger.initFromDb(sessionId, db, taggerFloor);
       logTransformTiming(sessionId, "tag.initFromDb", tInitFromDb);
       const skipPrefixInjection = !ctxReduceEnabledEffective;
       const result = tagMessages(sessionId, messages, deps.tagger, db, {
@@ -188088,7 +188845,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const persistedReasoningWatermark = sessionMeta?.clearedReasoningThroughTag ?? 0;
     if (persistedReasoningWatermark > 0) {
       const tReplay = performance.now();
-      const replayed = replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark);
+      const replayed = canUseEmptySentinels ? replayClearedReasoning(messages, reasoningByMessage, messageTagNumbers, persistedReasoningWatermark) : 0;
       const replayedInline = replayStrippedInlineThinking(messages, messageTagNumbers, persistedReasoningWatermark);
       if (replayed > 0 || replayedInline > 0) {
         sessionLog(sessionId, `reasoning replay: cleared=${replayed} inlineStripped=${replayedInline} (watermark=${persistedReasoningWatermark})`);
@@ -188186,7 +188943,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const wasEmergencyBlock = contextUsageEarly.percentage >= FORCE_MATERIALIZE_PERCENTAGE && compartmentPhase.justAwaitedPublication;
     const historyRebuiltThisPass = wasEmergencyBlock ? compartmentPhase.rebuiltHistoryThisPass : rebuiltHistoryFromInitialPrepare || compartmentPhase.rebuiltHistoryThisPass;
     const tPostProcess = performance.now();
-    await runPostTransformPhase({
+    const postTransformResult = await runPostTransformPhase({
       sessionId,
       db,
       messages,
@@ -188240,6 +188997,19 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         hardSignals: m0HardSignals
       }
     });
+    if (postTransformResult.bustedThisPass) {
+      recordPendingTransformDecision(sessionId, {
+        tsMs: Date.now(),
+        decision: schedulerDecision,
+        materialized: postTransformResult.materialized,
+        materializeReason: normalizeMaterializeReason("opencode", postTransformResult.materializeReason, postTransformResult.materialized),
+        emergency: postTransformResult.emergency,
+        droppedTokens: postTransformResult.droppedTokens,
+        droppedCount: postTransformResult.droppedCount,
+        inputTokens: contextUsage.inputTokens,
+        bustedThisPass: true
+      });
+    }
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
     const msgTokens = getMessageTokensCache(sessionId);
     let storedByMessage;
@@ -188390,6 +189160,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         const executeThresholdTokens = Math.round((resolvedContextLimit ?? 0) * resolvedExecuteThresholdPct / 100);
         const usableTokens = Math.max(0, executeThresholdTokens - contextUsage.inputTokens + liveTailTokens);
         resetLastNudgeCycleIfTailShrank(db, sessionId, tailToolTokens);
+        const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags(db, sessionId, deps.protectedTags);
         deps.channel1StateBySession.set(sessionId, {
           tailToolTokens,
           historyBudgetTokens: historyBudgetTokens ?? 0,
@@ -188398,9 +189169,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
           lastInputTokens: contextUsage.inputTokens,
           turnToolTokens: 0,
           usableTokens,
-          reducedSinceRefresh: false
+          reducedSinceRefresh: false,
+          oldestReclaimableToolTags
         });
-        const channel2MetricsKnown = fullFeatureMode && resolvedContextLimit !== undefined && resolvedContextLimit > 0 && resolvedExecuteThresholdPct > 0;
+        const channel2MetricsKnown = resolvedContextLimit !== undefined && resolvedContextLimit > 0 && resolvedExecuteThresholdPct > 0;
         if (channel2MetricsKnown) {
           const channel2ShouldTrigger = shouldTriggerChannel2({
             reclaimableTokens: tailToolTokens,
@@ -188424,6 +189196,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     }
     const elapsed = (performance.now() - startTime).toFixed(1);
     sessionLog(sessionId, `transform completed in ${elapsed}ms (${messages.length} messages, ${targets.size} targets, watermark: ${watermark})`);
+    deps.maybeAutoEmbedSession?.(sessionId);
   };
 }
 function resolveHistoryBudgetTokens(historyBudgetPercentage, contextUsage, executeThresholdPercentage, modelKey, executeThresholdTokens, resolvedContextLimit) {
@@ -188469,18 +189242,14 @@ function evictExpiredUsageEntries(contextUsageMap) {
 }
 async function deliverChannel2IfPending(deps, sessionId) {
   try {
-    try {
-      const meta3 = getOrCreateSessionMeta(deps.db, sessionId);
-      if (meta3.isSubagent)
-        return;
-    } catch {}
     const baseline = deps.channel1StateBySession?.get(sessionId);
     await maybeDeliverChannel2(sessionId, {
       db: deps.db,
       serverUrl: deps.serverUrl,
       directory: deps.directory ?? ".",
       reclaimableTokens: baseline ? baseline.tailToolTokens + baseline.turnToolTokens : undefined,
-      usableTokens: baseline?.usableTokens
+      usableTokens: baseline?.usableTokens,
+      oldestReclaimableToolTags: baseline?.oldestReclaimableToolTags
     });
   } catch (error51) {
     sessionLog(sessionId, "channel2 delivery wrapper failed (ignored):", error51);
@@ -188622,6 +189391,15 @@ function createEventHandler2(deps) {
         info.tokens?.cache?.write
       ];
       const hasUsageTokens = usageTokens.some((value) => typeof value === "number" && value > 0);
+      const terminalAssistantUpdate = info.messageID !== undefined && hasUsageTokens && (typeof info.finish === "string" || typeof info.completedAt === "number");
+      if (terminalAssistantUpdate && info.messageID) {
+        scheduleOpenCodeTransformDecisionWrite({
+          db: deps.db,
+          sessionId: info.sessionID,
+          messageId: info.messageID,
+          inputTokens: (info.tokens?.input ?? 0) + (info.tokens?.cache?.read ?? 0) + (info.tokens?.cache?.write ?? 0)
+        });
+      }
       sessionLog(info.sessionID, `event message.updated: provider=${info.providerID} model=${info.modelID} hasUsageTokens=${hasUsageTokens} tokens.input=${info.tokens?.input} cache.read=${info.tokens?.cache?.read} cache.write=${info.tokens?.cache?.write}`);
       const hasKnownUsage = hasUsageTokens || deps.contextUsageMap.has(info.sessionID);
       if (!hasKnownUsage) {
@@ -188779,6 +189557,7 @@ function createEventHandler2(deps) {
       deps.onSessionDeleted?.(sessionId);
       deps.contextUsageMap.delete(sessionId);
       deps.tagger.cleanup(sessionId);
+      clearTransformDecisionSession(sessionId);
       clearMessageTokensCache(sessionId);
       invalidateTrueRawTokenCache({ sessionId, reason: "session.deleted" });
       return;
@@ -188786,6 +189565,46 @@ function createEventHandler2(deps) {
   };
 }
 
+// src/hooks/magic-context/format-embed-status.ts
+function formatEmbedStatusText(coverage, drain) {
+  if (!coverage.enabled) {
+    return "Embedding is off (no provider configured).";
+  }
+  const lines = [];
+  lines.push(`Embedding — model: ${coverage.model} (${coverage.provider})`);
+  lines.push(`This session:  ${coverage.session.embedded} / ${coverage.session.total} compartments embedded`);
+  lines.push(`Project memories:  ${coverage.memories.embedded} / ${coverage.memories.total} embedded`);
+  if (coverage.commits.gitEnabled) {
+    lines.push(`Git commits:  ${coverage.commits.embedded} / ${coverage.commits.total}`);
+  } else {
+    lines.push("Git commits:  0 / 0 (git indexing off)");
+  }
+  let drainLine = "Drain: idle";
+  switch (drain.status) {
+    case "running": {
+      const e = drain.embedded ?? coverage.session.embedded;
+      const t = drain.total ?? coverage.session.total;
+      const failedSuffix = drain.failed && drain.failed > 0 ? ` (${drain.failed} failed)` : "";
+      drainLine = `Drain: running ${e}/${t}${failedSuffix}`;
+      break;
+    }
+    case "paused": {
+      const e = drain.embedded ?? coverage.session.embedded;
+      const t = drain.total ?? coverage.session.total;
+      drainLine = `Drain: paused ${e}/${t}`;
+      break;
+    }
+    case "stopped":
+      drainLine = "Drain: stopped (provider down)";
+      break;
+    default:
+      drainLine = "Drain: idle";
+  }
+  lines.push(drainLine);
+  return lines.join(`
+`);
+}
+
 // src/hooks/magic-context/hook.ts
 await __promiseAll([
   init_inject_compartments(),
@@ -189003,7 +189822,7 @@ function maybeInjectChannel1Nudge(args, sessionId, tool, output) {
   setLastNudgeLevel(args.db, sessionId, decision.nextLastNudgeLevel);
   if (!decision.fire)
     return;
-  out.output += buildChannel1Reminder(decision.level, decision.undroppedTokens);
+  out.output += buildChannel1Reminder(decision.level, decision.undroppedTokens, state.oldestReclaimableToolTags);
   sessionLog(sessionId, `channel1 nudge fired: level=${decision.level} undropped~${Math.round(decision.undroppedTokens / 1000)}k tool=${tool}`);
 }
 function createToolExecuteAfterHook(args) {
@@ -189075,9 +189894,7 @@ Context is managed for you entirely automatically — there's nothing to prune a
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
 var BASE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
-Use \`ctx_reduce\` to manage context size. It supports one operation:
-- \`drop\`: Remove entirely (best for tool outputs you already acted on).
-Syntax: "3-5", "1,2,9", or "1-5,8,12-15". Last ${protectedTags} tags are protected.
+Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. Marking is NOT an immediate delete — it queues the content, which stays fully visible until space is actually needed (as soon as the next turn if you're already under pressure, much later if not), so mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The last ${protectedTags} tags are protected (marking one just queues it until it ages out). Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
 Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
 ${CTX_NOTE_GUIDANCE}
 Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
@@ -189096,7 +189913,7 @@ Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` su
 \`ctx_search\` returns ranked results from memories, git commits, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
 ${TOOL_HISTORY_GUIDANCE}
 NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.
-NEVER drop user messages — they are short and will be summarized by compartmentalization automatically. Dropping them loses context the historian needs.
+Keep your user's instructions and intent — never drop a user message for its directive, even an old one. But a large block of pasted content inside a user message (logs, data dumps, long code, attachments) is fair to mark discardable once you've extracted what you need — it stays searchable via \`ctx_search\`.
 NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
 var BASE_INTRO_NO_REDUCE = () => `${CTX_NOTE_GUIDANCE}
@@ -189444,7 +190261,7 @@ function createMagicContextHook(deps) {
   }
   let lastScheduleCheckMs = 0;
   const getHistorianChunkTokens = () => deriveHistorianChunkTokens(resolveHistorianContextLimit(deps.config.historian?.model));
-  const historianFallbackModels = resolveFallbackChain(HISTORIAN_AGENT, deps.config.historian?.fallback_models);
+  const historianFallbackModels = resolveFallbackChain(deps.config.historian?.fallback_models);
   const historyRefreshSessions = deps.liveSessionState?.historyRefreshSessions ?? new Set;
   const deferredHistoryRefreshSessions = deps.liveSessionState?.deferredHistoryRefreshSessions ?? new Set;
   try {
@@ -189517,29 +190334,55 @@ function createMagicContextHook(deps) {
     ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
     getNotificationParams: (sid) => getLiveNotificationParams(sid, liveModelBySession, variantBySession, agentBySession)
   });
-  const executeEmbedHistory = async (sessionId) => {
+  const executeEmbedHistory = async (sessionId, options) => {
     if (deps.config.memory?.enabled === false) {
       return "Memory is disabled for this project, so there is no semantic embedding to backfill.";
     }
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
+    const active = embedRunStateBySession.get(sessionId);
+    if (active && !active.signal.aborted && !options?.signal) {
+      return "Embedding is already running for this session.";
+    }
     await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
     const sessionProjectIdentity = resolveProjectIdentity(directory);
-    setRecompStarting({ recompProgressBySession }, sessionId, "Embedding history…", "embed");
-    const outcome = await embedSessionCompartmentChunks(db, sessionProjectIdentity, sessionId, {
-      onProgress: ({ embedded, total }) => {
-        const cur = recompProgressBySession.get(sessionId);
-        if (!cur || cur.phase !== "recomp")
-          return;
-        recompProgressBySession.set(sessionId, {
-          ...cur,
-          processedMessages: embedded,
-          totalMessages: total,
-          updatedAt: Date.now()
-        });
+    embedPauseBySession.delete(sessionId);
+    const prior = embedRunStateBySession.get(sessionId);
+    if (prior)
+      prior.abort();
+    const controller = new AbortController;
+    embedRunStateBySession.set(sessionId, controller);
+    const signal = options?.signal ?? controller.signal;
+    if (!options?.silent) {
+      setRecompStarting({ recompProgressBySession }, sessionId, "Embedding history…", "embed");
+    }
+    let runFailed = 0;
+    let outcome;
+    try {
+      outcome = await embedSessionCompartmentChunks(db, sessionProjectIdentity, sessionId, {
+        signal,
+        onProgress: ({ embedded, total }) => {
+          const cur = recompProgressBySession.get(sessionId);
+          if (!cur || cur.phase !== "recomp")
+            return;
+          recompProgressBySession.set(sessionId, {
+            ...cur,
+            processedMessages: embedded,
+            totalMessages: total,
+            updatedAt: Date.now()
+          });
+        }
+      });
+    } finally {
+      if (embedRunStateBySession.get(sessionId) === controller) {
+        embedRunStateBySession.delete(sessionId);
       }
-    });
+    }
+    if ("failed" in outcome)
+      runFailed = outcome.failed;
     const terminal = (phase, message) => {
-      setRecompTerminal({ recompProgressBySession }, sessionId, phase, message);
+      if (!options?.silent) {
+        setRecompTerminal({ recompProgressBySession }, sessionId, phase, message);
+      }
       return message;
     };
     switch (outcome.status) {
@@ -189548,15 +190391,78 @@ function createMagicContextHook(deps) {
       case "disabled":
         return terminal("skipped", "No embedding provider is configured, so there is nothing to embed.");
       case "busy":
-        return terminal("skipped", `Embedding is already running for this project — ${outcome.total} compartment${outcome.total === 1 ? "" : "s"} still pending. Try again shortly.`);
-      case "aborted":
-        return terminal("done", `Embedded ${outcome.embedded} of ${outcome.total} compartments before stopping.`);
+        return terminal("skipped", "Embedding is already running for this project. Try again shortly.");
+      case "aborted": {
+        const cov = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
+        const msg = `Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`;
+        return terminal("skipped", msg);
+      }
       case "stalled":
-        return terminal("skipped", `Embedded ${outcome.embedded} compartments; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed-history again to retry them.`);
+        return terminal("skipped", `Embedded ${outcome.embedded} compartments; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed start again to retry them.`);
       default:
-        return terminal("done", `Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"} of history for semantic search.`);
+        return terminal("done", `Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"} of history for semantic search${runFailed > 0 ? ` (${runFailed} failed)` : ""}.`);
     }
   };
+  const pauseEmbedDrain = (sessionId) => {
+    embedPauseBySession.add(sessionId);
+    const ctrl = embedRunStateBySession.get(sessionId);
+    if (ctrl)
+      ctrl.abort();
+    const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
+    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const cov = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
+    return `Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`;
+  };
+  const getEmbedStatusText = (sessionId) => {
+    const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
+    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
+    const progress = recompProgressBySession.get(sessionId);
+    const drainUi = getEmbedDrainUiStatus(sessionId, progress);
+    return formatEmbedStatusText(coverage, {
+      status: drainUi.status,
+      embedded: progress?.processedMessages,
+      total: progress?.totalMessages
+    });
+  };
+  const maybeAutoEmbedSession = (sessionId) => {
+    if (autoEmbedAttemptedBySession.has(sessionId))
+      return;
+    if (embedPauseBySession.has(sessionId))
+      return;
+    if (deps.config.memory?.enabled === false)
+      return;
+    autoEmbedAttemptedBySession.add(sessionId);
+    const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
+    (async () => {
+      try {
+        await new Promise((resolve7) => setTimeout(resolve7, 0));
+        await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
+        const sessionProjectIdentity = resolveProjectIdentity(directory);
+        const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
+        if (!coverage.enabled)
+          return;
+        const remaining = coverage.session.total - coverage.session.embedded;
+        if (remaining <= 0)
+          return;
+        const notifyParams = getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession);
+        if (!isTuiConnected(sessionId)) {
+          const startMsg = `Embedding ${remaining} compartment${remaining === 1 ? "" : "s"} of history in the background…`;
+          await sendIgnoredMessage(deps.client, sessionId, startMsg, {
+            ...notifyParams
+          });
+        }
+        const summary = await executeEmbedHistory(sessionId);
+        if (!isTuiConnected(sessionId)) {
+          await sendIgnoredMessage(deps.client, sessionId, summary, {
+            ...notifyParams
+          });
+        }
+      } catch (error51) {
+        log("[magic-context] auto-embed drain failed:", error51);
+      }
+    })();
+  };
   const sidekickRunnable = isSidekickRunnable(deps.config);
   const sidekickConfig = sidekickRunnable ? deps.config.sidekick : undefined;
   const transform2 = createTransform({
@@ -189618,7 +190524,8 @@ function createMagicContextHook(deps) {
     cavemanTextCompression: ctxReduceEnabled === false && deps.config.caveman_text_compression?.enabled === true ? {
       enabled: true,
       minChars: deps.config.caveman_text_compression.min_chars ?? 500
-    } : undefined
+    } : undefined,
+    maybeAutoEmbedSession
   });
   const eventHandler = createEventHandler2({
     contextUsageMap,
@@ -189647,6 +190554,7 @@ function createMagicContextHook(deps) {
       recompProgressBySession.delete(sessionId);
       internalChildSessions.delete(sessionId);
       channel1StateBySession.delete(sessionId);
+      clearEmbedSessionState(sessionId);
     }
   });
   const runDreamQueueInBackground = () => {
@@ -189681,7 +190589,7 @@ function createMagicContextHook(deps) {
         token_budget: dreaming.pin_key_files.token_budget,
         min_reads: dreaming.pin_key_files.min_reads
       } : undefined,
-      fallbackModels: resolveFallbackChain(DREAMER_AGENT, dreaming.fallback_models),
+      fallbackModels: resolveFallbackChain(dreaming.fallback_models),
       projectIdentity: projectPath
     }).catch((error51) => {
       log("[dreamer] scheduled queue processing failed:", error51);
@@ -189712,6 +190620,8 @@ function createMagicContextHook(deps) {
     executeRecomp: historianRunnable ? async (sessionId, options) => runManagedRecomp(buildManagedRecompCtx(sessionId), sessionId, options) : undefined,
     runUpgrade: historianRunnable ? async (sessionId) => runManagedUpgrade(buildManagedRecompCtx(sessionId), sessionId) : undefined,
     executeEmbedHistory,
+    pauseEmbedDrain,
+    getEmbedStatusText,
     sendNotification: async (sessionId, text, params) => {
       await sendIgnoredMessage(deps.client, sessionId, text, {
         ...getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession),
@@ -189738,7 +190648,7 @@ function createMagicContextHook(deps) {
         token_budget: dreamerConfig.pin_key_files.token_budget,
         min_reads: dreamerConfig.pin_key_files.min_reads
       } : undefined,
-      fallbackModels: resolveFallbackChain(DREAMER_AGENT, dreamerConfig.fallback_models)
+      fallbackModels: resolveFallbackChain(dreamerConfig.fallback_models)
     } : undefined
   });
   const systemPromptHash = createSystemPromptHashHandler({
@@ -189923,6 +190833,7 @@ function truncateError(name2, code, message, maxLen = 240) {
 
 // src/plugin/rpc-handlers.ts
 init_project_identity();
+init_project_embedding_registry();
 init_tool_definition_tokens();
 await init_storage();
 
@@ -190643,6 +191554,26 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config2, liveSess
   }
   return detail;
 }
+function buildEmbedDetail(db, sessionId, dir, liveSessionState) {
+  const projectIdentity = resolveProjectIdentity(dir);
+  const coverage = getEmbeddingCoverageStatus(db, projectIdentity, sessionId);
+  const progress = liveSessionState.recompProgressBySession.get(sessionId);
+  const drainUi = getEmbedDrainUiStatus(sessionId, progress);
+  const statusText = formatEmbedStatusText(coverage, {
+    status: drainUi.status,
+    embedded: progress?.processedMessages,
+    total: progress?.totalMessages
+  });
+  return {
+    enabled: coverage.enabled,
+    model: coverage.model,
+    provider: coverage.provider,
+    session: coverage.session,
+    memories: coverage.memories,
+    commits: coverage.commits,
+    statusText
+  };
+}
 function registerRpcHandlers(rpcServer, args) {
   const { directory, config: config2, liveSessionState } = args;
   const rawConfig = config2;
@@ -190665,6 +191596,19 @@ function registerRpcHandlers(rpcServer, args) {
       return { error: "unavailable" };
     return buildStatusDetail(db, sessionId, dir, modelKey, rawConfig, liveSessionState, injectionBudgetTokens);
   });
+  rpcServer.handle("embed-detail", async (params) => {
+    const sessionId = String(params.sessionId ?? "");
+    const dir = String(params.directory ?? directory);
+    const db = getDb();
+    if (!db || !sessionId)
+      return { error: "unavailable" };
+    try {
+      return buildEmbedDetail(db, sessionId, dir, liveSessionState);
+    } catch (err) {
+      log("[rpc] embed-detail error:", err);
+      return { error: "unavailable" };
+    }
+  });
   rpcServer.handle("compartment-count", async (params) => {
     const sessionId = String(params.sessionId ?? "");
     const db = getDb();
@@ -190679,8 +191623,7 @@ function registerRpcHandlers(rpcServer, args) {
   });
   const buildManagedCtx = async (db) => {
     const { deriveHistorianChunkTokens: deriveHistorianChunkTokens2, resolveHistorianContextLimit: resolveHistorianContextLimit2 } = await Promise.resolve().then(() => (init_derive_budgets(), exports_derive_budgets));
-    const { resolveFallbackChain: resolveFallbackChain2 } = await Promise.resolve().then(() => (init_resolve_fallbacks(), exports_resolve_fallbacks));
-    const { HISTORIAN_AGENT: HISTORIAN_AGENT2 } = await Promise.resolve().then(() => exports_historian);
+    const { resolveFallbackChain: resolveFallbackChain2 } = await Promise.resolve().then(() => exports_resolve_fallbacks);
     const DEFAULT_HISTORIAN_TIMEOUT_MS2 = 600000;
     return {
       client: args.client,
@@ -190691,7 +191634,7 @@ function registerRpcHandlers(rpcServer, args) {
       historianTimeoutMs: config2.historian_timeout_ms ?? DEFAULT_HISTORIAN_TIMEOUT_MS2,
       memoryEnabled: config2.memory?.enabled ?? true,
       autoPromote: config2.memory?.auto_promote ?? true,
-      fallbackModels: resolveFallbackChain2(HISTORIAN_AGENT2, config2.historian?.fallback_models),
+      fallbackModels: resolveFallbackChain2(config2.historian?.fallback_models),
       runMigration: config2.memory?.enabled !== false && !!config2.historian?.model,
       userMemoriesEnabled: config2.dreamer?.user_memories?.enabled === true,
       historianTwoPass: config2.historian?.two_pass === true,
@@ -190787,27 +191730,225 @@ Older parts of this session are summarized into <compartment> blocks inside <ses
 
 ctx_expand(start=120, end=245)  ← the compartment's own start/end attributes
 
-Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results — expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail — already visible in context, not expandable.`;
+Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results — expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail — already visible in context, not expandable.
+
+Two recovery modes for finer detail:
+- ctx_expand(start=120, end=245, verbose=true) — lists each message SEPARATELY with its ordinal [N] and a per-part preview (each tool call shown with its output size). Use this to find the exact message or tool call you want, then recover it in full by ordinal.
+- ctx_expand(message=138) — returns the FULL untruncated content of the message at that ordinal: every text part, and every tool call's complete input + output, read from stored history. This is the cheap way to get back a tool output you dropped with ctx_reduce — the original is still in storage even though the wire shows [dropped §N§]. If the message was deleted from history (session prune/revert), it says so.`;
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
+// src/tools/ctx-expand/render.ts
+init_read_session_formatting();
+await init_read_session_chunk();
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function roleLabel(role) {
+  if (role === "assistant")
+    return "A (assistant)";
+  if (role === "user")
+    return "U (user)";
+  return role;
+}
+function truncate2(value, max) {
+  const t = value.trim();
+  return t.length <= max ? t : `${t.slice(0, max)}…`;
+}
+function keyArg(input) {
+  if (!input)
+    return "";
+  for (const k of ["filePath", "path", "pattern", "query", "symbol", "module", "action"]) {
+    const v = input[k];
+    if (typeof v === "string" && v.length > 0)
+      return truncate2(v, 60);
+  }
+  if (typeof input.description === "string")
+    return truncate2(input.description, 60);
+  return "";
+}
+function asToolPart(part) {
+  const type = typeof part.type === "string" ? part.type : "";
+  if (type === "tool") {
+    const state = isRecord3(part.state) ? part.state : null;
+    const output = state && typeof state.output === "string" ? state.output : state && state.output != null ? JSON.stringify(state.output) : null;
+    const metadata = state && isRecord3(state.metadata) ? state.metadata : null;
+    const title = state && typeof state.title === "string" && state.title || metadata && typeof metadata.title === "string" && metadata.title || null;
+    return {
+      name: typeof part.tool === "string" ? part.tool : "tool",
+      callId: typeof part.callID === "string" ? part.callID : "",
+      title,
+      input: state && isRecord3(state.input) ? state.input : null,
+      output
+    };
+  }
+  if (type === "tool_use") {
+    return {
+      name: typeof part.name === "string" ? part.name : "tool",
+      callId: typeof part.id === "string" ? part.id : "",
+      title: null,
+      input: isRecord3(part.input) ? part.input : null,
+      output: null
+    };
+  }
+  if (type === "tool_result") {
+    const content = part.content;
+    const output = typeof content === "string" ? content : content != null ? JSON.stringify(content) : null;
+    return {
+      name: "tool_result",
+      callId: typeof part.tool_use_id === "string" ? part.tool_use_id : "",
+      title: null,
+      input: null,
+      output
+    };
+  }
+  return null;
+}
+function textOf(part) {
+  if (part.type === "text" && typeof part.text === "string")
+    return part.text;
+  return null;
+}
+function reasoningOf(part) {
+  if ((part.type === "reasoning" || part.type === "thinking") && typeof part.text === "string") {
+    return part.text;
+  }
+  return null;
+}
+function renderPartPreview(part) {
+  if (!isRecord3(part))
+    return null;
+  const text = textOf(part);
+  if (text !== null) {
+    const t = truncate2(text, 200);
+    return t.length > 0 ? `    • ${t}` : null;
+  }
+  const tool = asToolPart(part);
+  if (tool) {
+    const arg = keyArg(tool.input);
+    const head = arg ? `${tool.name}(${arg})` : tool.name;
+    return tool.output !== null ? `    • tool ${head} → output ~${estimateTokens(tool.output)} tok` : `    • tool ${head}`;
+  }
+  const reasoning = reasoningOf(part);
+  if (reasoning !== null)
+    return `    • [reasoning] ${truncate2(reasoning, 120)}`;
+  const type = typeof part.type === "string" ? part.type : "part";
+  if (type === "file")
+    return "    • [file]";
+  if (type === "step-start" || type === "step-finish")
+    return null;
+  return `    • [${type}]`;
+}
+function renderPartFull(part) {
+  if (!isRecord3(part))
+    return null;
+  const text = textOf(part);
+  if (text !== null) {
+    return text.trim().length > 0 ? `  [text]
+${text}` : null;
+  }
+  const tool = asToolPart(part);
+  if (tool) {
+    const lines = [];
+    const idSuffix = tool.callId ? ` #${tool.callId}` : "";
+    lines.push(`  [tool: ${tool.name}${idSuffix}]`);
+    if (tool.title && tool.title.trim().length > 0) {
+      lines.push(`  description: ${tool.title.trim()}`);
+    }
+    if (tool.input)
+      lines.push(`  input: ${JSON.stringify(tool.input)}`);
+    if (tool.output !== null)
+      lines.push(`  output:
+${tool.output}`);
+    return lines.join(`
+`);
+  }
+  const type = typeof part.type === "string" ? part.type : "part";
+  if (type === "file") {
+    const name2 = typeof part.filename === "string" && part.filename || typeof part.url === "string" && part.url || "";
+    return `  [file]${name2 ? ` ${name2}` : ""}`;
+  }
+  return null;
+}
+function renderMessageByOrdinal(sessionId, ordinal) {
+  const msg = readRawSessionMessages(sessionId).find((m) => m.ordinal === ordinal);
+  if (!msg) {
+    return `No message at ordinal ${ordinal} in this session's stored history — it was deleted ` + `(session prune/revert) or the ordinal is wrong, so it can't be recovered. ` + `Re-run the tool if you still need the data.`;
+  }
+  const rendered = msg.parts.map(renderPartFull).filter((l) => l !== null);
+  const lines = [`[${msg.ordinal}] ${roleLabel(msg.role)} — full recovery:`, ""];
+  if (rendered.length === 0) {
+    lines.push("  (no recoverable content — message had only structural/reasoning parts)");
+  } else {
+    lines.push(...rendered);
+  }
+  return lines.join(`
+`);
+}
+function renderVerboseRange(sessionId, start, end, tokenBudget) {
+  const messages = readRawSessionMessages(sessionId).filter((m) => m.ordinal >= start && m.ordinal <= end);
+  const out = [];
+  let usedTokens = 0;
+  let lastOrdinal = start - 1;
+  let truncated = false;
+  for (const msg of messages) {
+    const header = `[${msg.ordinal}] ${roleLabel(msg.role)}`;
+    const partLines = msg.parts.map(renderPartPreview).filter((l) => l !== null);
+    const block = partLines.length > 0 ? `${header}
+${partLines.join(`
+`)}` : header;
+    const blockTokens = estimateTokens(block);
+    if (usedTokens + blockTokens > tokenBudget && out.length > 0) {
+      truncated = true;
+      break;
+    }
+    out.push(block);
+    usedTokens += blockTokens;
+    lastOrdinal = msg.ordinal;
+  }
+  return { text: out.join(`
+
+`), lastOrdinal, truncated };
+}
+
 // src/tools/ctx-expand/tools.ts
 function createCtxExpandTool(deps) {
   return tool({
     description: CTX_EXPAND_DESCRIPTION,
     args: {
-      start: tool.schema.number().describe(`First message ordinal to expand — a compartment's start="N" attribute, or an ordinal from a ctx_search message hit`),
-      end: tool.schema.number().describe(`Last message ordinal to expand (inclusive) — a compartment's end="M" attribute`)
+      start: tool.schema.number().optional().describe(`First message ordinal to expand — a compartment's start="N" attribute, or an ordinal from a ctx_search message hit`),
+      end: tool.schema.number().optional().describe(`Last message ordinal to expand (inclusive) — a compartment's end="M" attribute`),
+      verbose: tool.schema.boolean().optional().describe("With start/end: list each message separately with its ordinal [N] and per-part preview (each tool call shown with its output size), so you can pick one to recover in full by ordinal."),
+      message: tool.schema.number().optional().describe("Full untruncated recovery of ONE message by its ordinal (every text part + every tool call's complete input/output). Use an ordinal from a compartment, ctx_search hit, or verbose range. Recovers a tool output you dropped with ctx_reduce.")
     },
     async execute(args, toolContext) {
       const sessionId = toolContext.sessionID;
+      if (typeof args.message === "number" && args.message >= 1) {
+        return renderMessageByOrdinal(sessionId, args.message);
+      }
       if (!args.start || !args.end || args.start < 1 || args.end < args.start) {
-        return "Error: start and end must be positive integers with start <= end.";
+        return "Error: provide either message=<ordinal>, or start and end (positive integers, start <= end).";
       }
       const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
       if (lastCompartmentEnd >= 0 && args.start > lastCompartmentEnd) {
         return `Range ${args.start}-${args.end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`;
       }
       const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(args.end, lastCompartmentEnd) : args.end;
+      if (args.verbose === true) {
+        const v = renderVerboseRange(sessionId, args.start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
+        if (!v.text) {
+          return `No messages found in range ${args.start}-${effectiveEnd}. The range may be outside this session's history.`;
+        }
+        const out = [
+          `Messages ${args.start}-${v.lastOrdinal} (verbose). Recover any one in full with ctx_expand(message=<ordinal>):`,
+          "",
+          v.text
+        ];
+        if (v.truncated) {
+          out.push("", `Truncated at message ${v.lastOrdinal} (budget: ~${CTX_EXPAND_TOKEN_BUDGET} tokens). Call again with start=${v.lastOrdinal + 1} end=${effectiveEnd} verbose=true for more.`);
+        }
+        return out.join(`
+`);
+      }
       const chunk = readSessionChunk(sessionId, CTX_EXPAND_TOKEN_BUDGET, args.start, effectiveEnd + 1);
       if (!chunk.text || chunk.messageCount === 0) {
         return `No messages found in range ${args.start}-${args.end}. The range may be outside this session's history.`;
@@ -190845,6 +191986,7 @@ Actions:
 Example: ctx_memory(action="write", category="CONSTRAINTS", content="Pi stores sessions as JSONL under ~/.pi/agent/sessions/, not SQLite")`;
 var DEFAULT_SEARCH_LIMIT2 = 10;
 // src/tools/ctx-memory/tools.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
 init_memory();
 init_embedding();
 init_embedding_cache();
@@ -190852,7 +191994,6 @@ init_normalize_hash();
 init_workspaces();
 init_logger();
 await init_storage();
-import { tool as tool2 } from "@opencode-ai/plugin";
 
 // src/tools/ctx-memory/types.ts
 var CTX_MEMORY_ACTIONS = ["write", "archive", "update", "merge"];
@@ -191501,15 +192642,16 @@ function createCtxNoteTools(deps) {
   };
 }
 // src/tools/ctx-reduce/constants.ts
-var CTX_REDUCE_DESCRIPTION = `Reduce context by dropping tagged content you no longer need.
-Use §N§ identifiers visible in conversation. The \`drop\` param accepts ranges: "3-5", "1,2,9", "1-5,8".
-
-CRITICAL RULES:
-- NEVER blanket-drop large ranges (e.g., "1-50"). Always review what each tag contains first.
-- Only drop tool outputs you have already processed and no longer need.
-- Protected tags are accepted but deferred until they leave the last protected range.
-- Keep recent context — only reduce OLD content that is no longer relevant to current work.
-- Dropped content is gone forever.`;
+var CTX_REDUCE_DESCRIPTION = `Mark spent tagged content as discardable to reclaim context space. This is NOT an immediate delete. Use §N§ identifiers visible in the conversation. The \`drop\` param accepts ranges: "3-5", "1,2,9", "1-5,8".
+
+How it works:
+- Marking QUEUES content for release. It stays fully visible to you until context space is actually needed — which may be as soon as the next turn if you are already under pressure, or many turns later if not. So mark spent outputs as soon as you finish with them; don't hoard the call for the end of the turn.
+- The newest tags are protected: marking one just queues it until it ages out of the recent window, so marking recent output is harmless.
+- When content is finally released it becomes a short placeholder, and re-running the tool is the only way to get it back. So mark only what you are genuinely DONE with — the test is "have I extracted what I need from this?", not "is it safe / do I have time before it drops?".
+
+Mark discardable once processed: large outputs you've summarized, repeated or redundant dumps, data written to disk, status/log output that only confirmed an expected state.
+Keep: user messages, unresolved errors, raw evidence you haven't extracted yet, and outputs whose exact wording may matter later.
+Never blanket-mark large ranges (e.g. "1-50") — review what each tag holds first.`;
 // src/tools/ctx-reduce/tools.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
 
@@ -191776,7 +192918,7 @@ function createCtxSearchTool(deps) {
         memoryEnabled,
         embeddingEnabled,
         embedQuery: async (text, signal) => {
-          const result = await embedTextForProject(projectPath, text, signal);
+          const result = await embedTextForProject(projectPath, text, signal, "query");
           return result?.vector ?? null;
         },
         isEmbeddingRuntimeEnabled: () => embeddingEnabled === true,
@@ -191879,7 +193021,6 @@ function createToolRegistry(args) {
 init_conflict_detector();
 init_data_path();
 init_logger();
-init_model_requirements();
 init_models_dev_cache();
 
 // src/shared/rpc-server.ts
@@ -192092,6 +193233,9 @@ class MagicContextRpcServer {
 }
 
 // src/index.ts
+var HISTORIAN_MAX_STEPS = 40;
+var SIDEKICK_MAX_STEPS = 40;
+var DREAMER_MAX_STEPS = 150;
 var plugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
   setSqlitePragmaConfig({
@@ -192308,12 +193452,13 @@ var plugin = async (ctx) => {
       await hooks.magicContext?.["experimental.text.complete"]?.(input, output);
     },
     config: async (config2) => {
-      const buildHiddenAgentConfig = (agentId, prompt, allowedTools, overrides) => {
+      const buildHiddenAgentConfig = (prompt, allowedTools, maxSteps, overrides) => {
         const { permission: overridePermission, ...restOverrides } = overrides ?? {};
         const basePermission = buildAllowOnlyPermission(allowedTools);
         return {
           prompt,
-          ...getAgentFallbackModels(agentId) ? { fallback_models: getAgentFallbackModels(agentId) } : {},
+          steps: maxSteps,
+          maxSteps,
           ...restOverrides,
           permission: {
             ...basePermission,
@@ -192335,6 +193480,7 @@ var plugin = async (ctx) => {
           max_runtime_minutes: _max,
           tasks: _tasks,
           task_timeout_minutes: _tto,
+          thinking_level: _thinkingLevel,
           ...agentOverrides
         } = pluginConfig.dreamer;
         return agentOverrides;
@@ -192343,20 +193489,28 @@ var plugin = async (ctx) => {
         const {
           timeout_ms: _timeoutMs,
           system_prompt: _systemPrompt,
+          thinking_level: _thinkingLevel,
           ...agentOverrides
         } = pluginConfig.sidekick;
         return agentOverrides;
       })() : undefined;
       const historianAgentOverrides = pluginConfig.historian ? (() => {
-        const { two_pass: _twoPass, ...agentOverrides } = pluginConfig.historian;
+        const {
+          two_pass: _twoPass,
+          disallowed_tools: _disallowedTools,
+          thinking_level: _thinkingLevel,
+          ...agentOverrides
+        } = pluginConfig.historian;
         return agentOverrides;
       })() : undefined;
+      const historianDisallowed = pluginConfig.historian?.disallowed_tools ?? [];
+      const historianAllowedTools = applyDisallowedTools(HISTORIAN_ALLOWED_TOOLS, historianDisallowed);
       config2.agent = {
         ...config2.agent ?? {},
-        [DREAMER_AGENT]: buildHiddenAgentConfig(DREAMER_AGENT, DREAMER_SYSTEM_PROMPT, DREAMER_ALLOWED_TOOLS, dreamerAgentOverrides),
-        [HISTORIAN_AGENT]: buildHiddenAgentConfig(HISTORIAN_AGENT, COMPARTMENT_AGENT_SYSTEM_PROMPT, HISTORIAN_ALLOWED_TOOLS, historianAgentOverrides),
-        [HISTORIAN_EDITOR_AGENT]: buildHiddenAgentConfig(HISTORIAN_EDITOR_AGENT, HISTORIAN_EDITOR_SYSTEM_PROMPT, HISTORIAN_ALLOWED_TOOLS, historianAgentOverrides),
-        [SIDEKICK_AGENT]: buildHiddenAgentConfig(SIDEKICK_AGENT, SIDEKICK_SYSTEM_PROMPT, SIDEKICK_ALLOWED_TOOLS, sidekickAgentOverrides)
+        [DREAMER_AGENT]: buildHiddenAgentConfig(DREAMER_SYSTEM_PROMPT, DREAMER_ALLOWED_TOOLS, DREAMER_MAX_STEPS, dreamerAgentOverrides),
+        [HISTORIAN_AGENT]: buildHiddenAgentConfig(COMPARTMENT_AGENT_SYSTEM_PROMPT, historianAllowedTools, HISTORIAN_MAX_STEPS, historianAgentOverrides),
+        [HISTORIAN_EDITOR_AGENT]: buildHiddenAgentConfig(HISTORIAN_EDITOR_SYSTEM_PROMPT, historianAllowedTools, HISTORIAN_MAX_STEPS, historianAgentOverrides),
+        [SIDEKICK_AGENT]: buildHiddenAgentConfig(SIDEKICK_SYSTEM_PROMPT, SIDEKICK_ALLOWED_TOOLS, SIDEKICK_MAX_STEPS, sidekickAgentOverrides)
       };
     }
   };