@wolfx/opencode-magic-context 0.25.0 → 0.26.0-patch.1

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) {
@@ -14836,7 +14825,7 @@ var init_agent_overrides = __esm(() => {
 });
 
 // src/config/schema/magic-context.ts
-var DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE = 65, EXECUTE_THRESHOLD_CAP_MESSAGE = "execute_threshold is capped at 80% for cache safety: a single large agent step can overflow the context window before Magic Context can compact between turns, forcing OpenCode's native compaction (hard to recover from). 80% also leaves headroom below the 85%/95% emergency bands. Use a value between 20 and 80.", DEFAULT_HISTORIAN_TIMEOUT_MS = 300000, DEFAULT_HISTORY_BUDGET_PERCENTAGE = 0.15, DEFAULT_LOCAL_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2", DREAMER_TASKS, DreamingTaskSchema, DEFAULT_DREAMER_TASKS, PiThinkingLevelSchema, DreamerConfigSchema, SidekickConfigSchema, HistorianConfigSchema, BaseEmbeddingConfigSchema, EmbeddingConfigSchema, MagicContextConfigSchema;
+var DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE = 65, EXECUTE_THRESHOLD_CAP_MESSAGE = "execute_threshold is capped at 80% for cache safety: a single large agent step can overflow the context window before Magic Context can compact between turns, forcing OpenCode's native compaction (hard to recover from). 80% also leaves headroom below the 85%/95% emergency bands. Use a value between 20 and 80.", DEFAULT_HISTORIAN_TIMEOUT_MS = 300000, DEFAULT_HISTORY_BUDGET_PERCENTAGE = 0.15, DREAMER_TASKS, DreamingTaskSchema, DEFAULT_DREAMER_TASKS, PiThinkingLevelSchema, DreamerConfigSchema, SidekickConfigSchema, HistorianConfigSchema, BaseEmbeddingConfigSchema, EmbeddingConfigSchema, MagicContextConfigSchema;
 var init_magic_context = __esm(() => {
   init_zod();
   init_agent_overrides();
@@ -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."),
+    provider: exports_external.enum(["openai-compatible", "off"]).default("off").describe("Embedding provider. 'openai-compatible' requires endpoint and model, 'off' disables embeddings (default)."),
+    model: exports_external.string().optional().describe("Embedding model name. Required for openai-compatible."),
     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) => {
@@ -14906,16 +14897,10 @@ var init_magic_context = __esm(() => {
     }
   });
   EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
-    if (data.provider === "local") {
-      return {
-        provider: "local",
-        model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
-        ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
-      };
-    }
     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 +14908,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 } : {}
       };
@@ -14962,8 +14948,7 @@ var init_magic_context = __esm(() => {
       mmap_size_mb: exports_external.number().min(0).max(8192).default(0).describe("Memory-mapped I/O size in MiB (PRAGMA mmap_size). 0 disables mmap (SQLite default). Raising it can cut read overhead on large DBs at the cost of address space. (min 0, max 8192, default 0)")
     }).default({ cache_size_mb: 64, mmap_size_mb: 0 }).describe("SQLite connection tuning for Magic Context's own context.db. These are per-connection PRAGMAs applied at open; they do not change the schema or what is stored."),
     embedding: EmbeddingConfigSchema.default({
-      provider: "local",
-      model: DEFAULT_LOCAL_EMBEDDING_MODEL
+      provider: "off"
     }).describe("Embedding provider configuration"),
     temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add start/end date attributes on compartments. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
     keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
@@ -15284,58 +15269,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)
@@ -15449,15 +15382,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)
@@ -15492,9 +15419,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) {
@@ -15682,7 +15606,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
@@ -15712,9 +15635,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
@@ -16080,6 +16001,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"
   ];
@@ -16129,6 +16052,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"
   };
@@ -149680,6 +149605,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();
 }
@@ -149847,7 +149788,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;
     }
@@ -149965,13 +149906,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;
 });
 
@@ -150716,6 +150658,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;
@@ -151226,6 +151171,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,
@@ -151289,6 +151236,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);
@@ -151440,6 +151404,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");
@@ -151518,6 +151484,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'");
@@ -151603,7 +151585,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 {
@@ -151679,6 +151663,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;
@@ -151698,7 +151683,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();
@@ -151712,6 +151697,7 @@ var init_storage_db = __esm(async () => {
   databases = new Map;
   persistenceByDatabase = new WeakMap;
   persistenceErrorByDatabase = new WeakMap;
+  pathByDatabase = new WeakMap;
   sqlitePragmaConfig = {
     cacheSizeMb: 64,
     mmapSizeMb: 0
@@ -153030,6 +153016,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);
@@ -153434,7 +153455,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) {
@@ -153442,7 +153465,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);
 }
@@ -153491,6 +153514,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));
@@ -153509,18 +153538,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;
     }
@@ -153528,10 +153569,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,
@@ -153541,6 +153580,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;
@@ -154108,7 +154166,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();
@@ -154127,9 +154185,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
@@ -154247,6 +154308,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);
   })();
 }
@@ -154692,12 +154754,17 @@ function getOldestActiveUnprotectedToolTags(db, sessionId, protectedTags = 0, li
     toolName: typeof row.tool_name === "string" ? row.tool_name : null
   }));
 }
-function getTriggerTagTokenUpperBound(db, sessionId) {
-  const row = db.prepare(`SELECT
+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')`).get(sessionId);
+             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')`;
+  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) {
@@ -154726,10 +154793,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) {
@@ -154888,6 +154957,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);
@@ -155026,7 +155136,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;
@@ -155042,6 +155152,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;
@@ -165462,6 +165573,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/)) {
@@ -165774,386 +165895,16 @@ function getEmbeddingProviderIdentity(config2) {
     endpoint: normalizeEndpoint2(config2.endpoint),
     apiKeyPresent: Boolean(config2.api_key?.trim()),
     inputType: config2.input_type?.trim() || ""
-  } : {
-    provider: "local",
-    model: config2.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
-    endpoint: "",
-    apiKeyPresent: false
-  };
+  } : null;
+  if (!identityInput) {
+    return "embedding-provider:off";
+  }
   return `embedding-provider:${computeNormalizedHash(JSON.stringify(identityInput))}`;
 }
 var init_embedding_identity = __esm(() => {
-  init_magic_context();
   init_normalize_hash();
 });
 
-// src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync as mkdirSync3 } from "node:fs";
-import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname4, join as join13 } from "node:path";
-import { pathToFileURL } from "node:url";
-async function acquireModelLoadLock(lockPath) {
-  const waitStart = Date.now();
-  while (true) {
-    try {
-      const handle = await open(lockPath, "wx");
-      try {
-        await handle.writeFile(`pid=${process.pid} started=${Date.now()}
-`);
-      } catch {}
-      await handle.close();
-      return async () => {
-        try {
-          await unlink(lockPath);
-        } catch {}
-      };
-    } catch (error51) {
-      const code = error51.code;
-      if (code !== "EEXIST" && code !== "EPERM") {
-        throw error51;
-      }
-      try {
-        const info = await stat(lockPath);
-        if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
-          log(`[magic-context] embedding-load lock stale (>${STALE_LOCK_MS}ms), taking over`);
-          try {
-            await unlink(lockPath);
-          } catch {}
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() - waitStart > MAX_LOCK_WAIT_MS) {
-        throw new Error(`[magic-context] embedding-load lock wait exceeded ${MAX_LOCK_WAIT_MS}ms; another process is still loading the model. Skipping this init attempt to avoid an unsynchronized native load.`);
-      }
-      await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_MS));
-    }
-  }
-}
-function startLockHeartbeat(lockPath) {
-  const HEARTBEAT_MS = Math.floor(STALE_LOCK_MS / 3);
-  const timer = setInterval(() => {
-    writeFile(lockPath, `pid=${process.pid} alive=${Date.now()}
-`).catch(() => {});
-  }, HEARTBEAT_MS);
-  timer.unref?.();
-  return () => clearInterval(timer);
-}
-async function injectWasmOrtForElectron() {
-  if (typeof process === "undefined" || !process.versions?.electron) {
-    return false;
-  }
-  try {
-    const ortWebSpec = `onnxruntime-${"web"}`;
-    const ortWeb = await import(ortWebSpec);
-    try {
-      const { createRequire: createRequireFn } = await import("node:module");
-      const requireFn = createRequireFn(import.meta.url);
-      const pkgPath = requireFn.resolve("onnxruntime-web/package.json");
-      const distDir = join13(dirname4(pkgPath), "dist");
-      const wasmPathsPrefix = `${pathToFileURL(distDir).href}/`;
-      if (ortWeb.env?.wasm) {
-        ortWeb.env.wasm.wasmPaths = wasmPathsPrefix;
-      }
-    } catch (pathError) {
-      log("[magic-context] could not resolve local onnxruntime-web/dist, falling back to default WASM paths:", pathError instanceof Error ? pathError.message : String(pathError));
-    }
-    globalThis[Symbol.for("onnxruntime")] = ortWeb;
-    log("[magic-context] Electron detected — using onnxruntime-web (WASM) for embeddings (bypasses onnxruntime-node native load)");
-    return true;
-  } catch (error51) {
-    log("[magic-context] failed to inject onnxruntime-web for Electron — letting transformers fall back to native:", error51 instanceof Error ? error51.message : String(error51));
-    return false;
-  }
-}
-async function withQuietConsole(fn) {
-  const origWarn = console.warn;
-  const origError = console.error;
-  const redirect = (...args) => {
-    const message = args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
-    log(`[transformers] ${message}`);
-  };
-  console.warn = redirect;
-  console.error = redirect;
-  try {
-    return await fn();
-  } finally {
-    console.warn = origWarn;
-    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)
-    return false;
-  const lower = message.toLowerCase();
-  return lower.includes("protobuf parsing failed") || lower.includes("unable to get model file path or buffer") || lower.includes("ebusy") || lower.includes("resource busy") || lower.includes("resource temporarily unavailable");
-}
-function isArrayLikeNumber(value) {
-  if (typeof value !== "object" || value === null || !("length" in value)) {
-    return false;
-  }
-  const arr = value;
-  if (typeof arr.length !== "number") {
-    return false;
-  }
-  return arr.length === 0 || typeof arr[0] === "number";
-}
-function toFloat32Array3(values) {
-  return values instanceof Float32Array ? new Float32Array(values) : Float32Array.from(Array.from(values));
-}
-function extractBatchEmbeddings(result, expectedCount) {
-  const { data } = result;
-  if (Array.isArray(data) && data.length === expectedCount && data.every((entry) => typeof entry !== "number" && isArrayLikeNumber(entry))) {
-    return data.map((entry) => toFloat32Array3(entry));
-  }
-  if (!isArrayLikeNumber(data)) {
-    log("[magic-context] embedding batch returned unexpected data shape");
-    return Array.from({ length: expectedCount }, () => null);
-  }
-  const flatData = toFloat32Array3(data);
-  const dimension = result.dims?.at(-1) ?? flatData.length / expectedCount;
-  if (!Number.isInteger(dimension) || dimension <= 0 || flatData.length !== expectedCount * dimension) {
-    log("[magic-context] embedding batch returned invalid dimensions");
-    return Array.from({ length: expectedCount }, () => null);
-  }
-  const embeddings = [];
-  for (let index = 0;index < expectedCount; index++) {
-    embeddings.push(flatData.slice(index * dimension, (index + 1) * dimension));
-  }
-  return embeddings;
-}
-
-class LocalEmbeddingProvider {
-  modelId;
-  maxInputTokens;
-  model;
-  pipeline = null;
-  initPromise = null;
-  inFlight = 0;
-  disposing = false;
-  disposePromise = null;
-  inFlightWaiters = [];
-  constructor(model = DEFAULT_LOCAL_EMBEDDING_MODEL, maxInputTokens = 512) {
-    this.model = model;
-    this.maxInputTokens = maxInputTokens;
-    this.modelId = getEmbeddingProviderIdentity({ provider: "local", model });
-  }
-  async initialize() {
-    if (this.disposing) {
-      return false;
-    }
-    if (this.pipeline) {
-      return true;
-    }
-    if (nativeRuntimeMissing) {
-      return false;
-    }
-    if (this.initPromise) {
-      await this.initPromise;
-      return this.pipeline !== null;
-    }
-    this.initPromise = (async () => {
-      try {
-        if (this.disposing) {
-          return;
-        }
-        await injectWasmOrtForElectron();
-        const transformersSpec = "@huggingface/transformers";
-        const transformersModule = await import(transformersSpec);
-        const env = transformersModule.env;
-        const LogLevel = transformersModule.LogLevel;
-        if (LogLevel && "ERROR" in LogLevel) {
-          env.logLevel = LogLevel.ERROR;
-        }
-        const modelCacheDir = join13(getMagicContextStorageDir(), "models");
-        try {
-          mkdirSync3(modelCacheDir, { recursive: true });
-          env.cacheDir = modelCacheDir;
-        } catch {
-          log("[magic-context] could not create model cache dir, using library default");
-        }
-        const createPipeline = transformersModule.pipeline;
-        const lockPath = join13(modelCacheDir, ".load.lock");
-        const releaseLock = await acquireModelLoadLock(lockPath);
-        const stopHeartbeat = startLockHeartbeat(lockPath);
-        try {
-          const MAX_ATTEMPTS = 3;
-          let lastError;
-          for (let attempt = 1;attempt <= MAX_ATTEMPTS; attempt++) {
-            try {
-              const pipeline = await withQuietConsole(() => createPipeline("feature-extraction", this.model, {
-                dtype: "fp32"
-              }));
-              if (this.disposing) {
-                await pipeline.dispose?.();
-                this.pipeline = null;
-              } else {
-                this.pipeline = pipeline;
-              }
-              lastError = undefined;
-              break;
-            } catch (error51) {
-              lastError = error51;
-              if (!isTransientLoadError(error51) || attempt === MAX_ATTEMPTS) {
-                break;
-              }
-              const delayMs = 300 * attempt + Math.floor(Math.random() * 200);
-              log(`[magic-context] embedding model load attempt ${attempt}/${MAX_ATTEMPTS} failed transiently, retrying in ${delayMs}ms`);
-              await new Promise((resolve6) => setTimeout(resolve6, delayMs));
-            }
-          }
-          if (this.pipeline) {
-            log(`[magic-context] embedding model loaded: ${this.model}`);
-          } else if (this.disposing) {
-            return;
-          } else {
-            throw lastError ?? new Error("unknown embedding load failure");
-          }
-        } finally {
-          stopHeartbeat();
-          await releaseLock();
-        }
-      } catch (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 @wolfx/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;
-      }
-    })();
-    await this.initPromise;
-    return this.pipeline !== null;
-  }
-  waitForInFlightToDrain() {
-    if (this.inFlight === 0) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve6) => {
-      this.inFlightWaiters.push(resolve6);
-    });
-  }
-  finishInFlight() {
-    this.inFlight = Math.max(0, this.inFlight - 1);
-    if (this.inFlight !== 0)
-      return;
-    const waiters = this.inFlightWaiters.splice(0);
-    for (const waiter of waiters) {
-      waiter();
-    }
-  }
-  async embed(text, signal) {
-    if (signal?.aborted)
-      return null;
-    if (this.disposing)
-      return null;
-    this.inFlight += 1;
-    try {
-      if (!await this.initialize()) {
-        return null;
-      }
-      const pipeline = this.pipeline;
-      if (!pipeline) {
-        return null;
-      }
-      const result = await withQuietConsole(() => pipeline(text, {
-        pooling: "mean",
-        normalize: true
-      }));
-      return extractBatchEmbeddings(result, 1)[0] ?? null;
-    } catch (error51) {
-      log("[magic-context] embedding failed:", error51);
-      return null;
-    } finally {
-      this.finishInFlight();
-    }
-  }
-  async embedBatch(texts, signal) {
-    if (texts.length === 0) {
-      return [];
-    }
-    if (signal?.aborted) {
-      return Array.from({ length: texts.length }, () => null);
-    }
-    if (this.disposing) {
-      return Array.from({ length: texts.length }, () => null);
-    }
-    this.inFlight += 1;
-    try {
-      if (!await this.initialize()) {
-        return Array.from({ length: texts.length }, () => null);
-      }
-      const pipeline = this.pipeline;
-      if (!pipeline) {
-        return Array.from({ length: texts.length }, () => null);
-      }
-      const result = await withQuietConsole(() => pipeline(texts, {
-        pooling: "mean",
-        normalize: true
-      }));
-      return extractBatchEmbeddings(result, texts.length);
-    } catch (error51) {
-      log("[magic-context] embedding batch failed:", error51);
-      return Array.from({ length: texts.length }, () => null);
-    } finally {
-      this.finishInFlight();
-    }
-  }
-  async dispose() {
-    if (this.disposePromise) {
-      return this.disposePromise;
-    }
-    this.disposing = true;
-    this.disposePromise = (async () => {
-      if (this.initPromise) {
-        await this.initPromise;
-      }
-      await this.waitForInFlightToDrain();
-      const pipelineToDispose = this.pipeline;
-      this.pipeline = null;
-      this.initPromise = null;
-      if (!pipelineToDispose) {
-        return;
-      }
-      try {
-        await pipelineToDispose.dispose?.();
-      } catch (error51) {
-        log("[magic-context] embedding model dispose failed:", error51);
-      }
-    })();
-    return this.disposePromise;
-  }
-  isLoaded() {
-    return this.pipeline !== null;
-  }
-}
-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();
-  init_logger();
-  init_embedding_identity();
-  STALE_LOCK_MS = 3 * 60000;
-  MAX_LOCK_WAIT_MS = 5 * 60000;
-});
-
 // src/features/magic-context/memory/embedding-ssrf.ts
 function isLinkLocalIpv4(host) {
   return /^169\.254\.\d{1,3}\.\d{1,3}$/.test(host);
@@ -166229,6 +165980,7 @@ class OpenAICompatibleEmbeddingProvider {
   model;
   apiKey;
   inputType;
+  queryInputType;
   truncate;
   initialized = false;
   failureTimes = [];
@@ -166241,6 +165993,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({
@@ -166268,11 +166021,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 [];
     }
@@ -166298,6 +166057,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: {
@@ -166307,7 +166067,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",
@@ -166872,18 +166632,13 @@ var init_session_project_storage = __esm(() => {
 // src/features/magic-context/project-embedding-registry.ts
 import { createHash as createHash9, randomUUID } from "node:crypto";
 function resolveEmbeddingConfig(config2) {
-  if (!config2 || config2.provider === "local") {
-    return {
-      provider: "local",
-      model: config2?.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
-      ...config2?.max_input_tokens ? {
-        max_input_tokens: normalizeCompartmentChunkMaxInputTokens(config2.max_input_tokens)
-      } : {}
-    };
+  if (!config2 || config2.provider === "off") {
+    return { provider: "off" };
   }
   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",
@@ -166891,6 +166646,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)
@@ -166912,11 +166668,12 @@ 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
     });
   }
-  return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
+  return null;
 }
 function stableStringify2(value) {
   if (Array.isArray(value)) {
@@ -166968,7 +166725,7 @@ function snapshotFor(registration) {
     modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId,
     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"
+    provider: registration.observationMode || !providerIsOn ? "off" : registration.config.provider ?? "off"
   };
 }
 function disposeProvider(provider) {
@@ -167094,7 +166851,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;
@@ -167103,7 +166860,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);
@@ -167112,7 +166869,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)
@@ -167128,7 +166885,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;
@@ -167185,7 +166942,7 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
   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;
@@ -167377,7 +167134,6 @@ function getEmbeddingCoverageStatus(db, projectIdentity, sessionId) {
 }
 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();
@@ -167385,7 +167141,6 @@ var init_project_embedding_registry = __esm(() => {
   init_sweep_coordinator();
   init_embedding_cache();
   init_embedding_identity();
-  init_embedding_local();
   init_embedding_openai();
   init_storage_memory_embeddings();
   init_session_project_storage();
@@ -167406,11 +167161,12 @@ 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
     });
   }
-  return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
+  return null;
 }
 function getOrCreateProvider() {
   if (provider) {
@@ -167434,17 +167190,14 @@ async function embedText(text, signal) {
 }
 var DEFAULT_EMBEDDING_CONFIG, embeddingConfig, provider = null, loadUnembeddedMemoriesStatements2, SWEEP_MAX_WALL_CLOCK_MS2;
 var init_embedding = __esm(() => {
-  init_magic_context();
   init_logger();
   init_compartment_chunk_embedding();
   init_embedding_identity();
-  init_embedding_local();
   init_embedding_openai();
   init_storage_memory_embeddings();
   init_project_embedding_registry();
   DEFAULT_EMBEDDING_CONFIG = {
-    provider: "local",
-    model: DEFAULT_LOCAL_EMBEDDING_MODEL
+    provider: "off"
   };
   embeddingConfig = DEFAULT_EMBEDDING_CONFIG;
   loadUnembeddedMemoriesStatements2 = new WeakMap;
@@ -167525,13 +167278,13 @@ var init_storage_memory_fts = __esm(() => {
 });
 
 // src/shared/models-dev-cache.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync, writeFileSync } from "node:fs";
-import { join as join14 } from "node:path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync9, renameSync, writeFileSync } from "node:fs";
+import { join as join13 } from "node:path";
 function isSaneLimit(limit) {
   return typeof limit === "number" && limit >= MIN_SANE_LIMIT && limit <= MAX_SANE_LIMIT;
 }
 function persistFilePath() {
-  return join14(getMagicContextStorageDir(), `model-context-limits-${getHarness()}.json`);
+  return join13(getMagicContextStorageDir(), `model-context-limits-${getHarness()}.json`);
 }
 function loadPersistedApiCacheOnce() {
   if (persistSeedLoaded || apiCache !== null)
@@ -167561,7 +167314,7 @@ function persistApiCache() {
   }
   try {
     const dir = getMagicContextStorageDir();
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
     const target = persistFilePath();
     const tmp = `${target}.${process.pid}.tmp`;
     writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8", mode: 384 });
@@ -167670,7 +167423,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);
@@ -167715,7 +167468,7 @@ var init_compartment_embedding = __esm(() => {
 });
 
 // src/features/magic-context/compaction-marker.ts
-import { join as join15 } from "node:path";
+import { join as join14 } from "node:path";
 function randomBase62(length) {
   const chars = [];
   for (let i = 0;i < length; i++) {
@@ -167735,7 +167488,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join15(getDataDir(), "opencode", "opencode.db");
+  return join14(getDataDir(), "opencode", "opencode.db");
 }
 function isOpenCodeSchemaCompatible(db, dbPath) {
   if (cachedSchemaCompatible?.path === dbPath) {
@@ -167877,7 +167630,7 @@ var init_compaction_marker = __esm(async () => {
 });
 
 // src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join16 } from "node:path";
+import { join as join15 } from "node:path";
 function validatePendingTarget(db, sessionId, pending) {
   const ocMessage = getOpenCodeMessageById(sessionId, pending.endMessageId);
   if (!ocMessage) {
@@ -167986,7 +167739,7 @@ function removeCompactionMarkerForSession(db, sessionId) {
   }
 }
 function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join16(getDataDir(), "opencode", "opencode.db");
+  const opencodeDbPath = join15(getDataDir(), "opencode", "opencode.db");
   let opencodeDb;
   try {
     opencodeDb = new Database(opencodeDbPath, { readonly: true });
@@ -168383,8 +168136,8 @@ var init_compartment_runner_validation = __esm(async () => {
 });
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join17 } from "node:path";
+import { mkdirSync as mkdirSync4, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join16 } from "node:path";
 function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
 }
@@ -168686,10 +168439,10 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 function dumpHistorianResponse(sessionId, directory, label, text) {
   try {
     const dumpDir = historianResponseDumpDir(directory);
-    mkdirSync5(dumpDir, { recursive: true });
+    mkdirSync4(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join17(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join16(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync2(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -168812,7 +168565,7 @@ function insertCompartmentEvents(db, sessionId, events, compartmentIds) {
 var init_compartment_events = () => {};
 
 // src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
 function cleanupHistorianStateFile(path6) {
   if (!path6)
     return;
@@ -169150,7 +168903,7 @@ var init_decay_render = __esm(() => {
 
 // src/hooks/magic-context/key-files-block.ts
 import { readFileSync as readFileSync10, realpathSync as realpathSync4 } from "node:fs";
-import { join as join18, sep as sep2 } from "node:path";
+import { join as join17, sep as sep2 } from "node:path";
 function staleKey(update) {
   return `${update.projectPath}\x00${update.path}\x00${update.generatedAtWitness}\x00${update.staleReason}`;
 }
@@ -169205,7 +168958,7 @@ function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBud
     let nextStale = null;
     let observed = false;
     try {
-      const absPath = join18(projectPath, row.path);
+      const absPath = join17(projectPath, row.path);
       const real = realpathSync4(absPath);
       if (!isUnderResolvedRoot(projectRoot, real)) {
         nextStale = "missing";
@@ -170870,29 +170623,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();
 });
 
@@ -171692,7 +171428,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);
   }
@@ -173896,6 +173632,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();
@@ -173910,7 +173647,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"}`);
@@ -173929,6 +173667,7 @@ async function runCompartmentAgent(deps) {
       } else {
         recordHighPressureNoEligibleHead(db, boundarySnapshot);
       }
+      clearEmergencyDrainLatch(db, sessionId);
       telemetry.status = "noop";
       telemetry.failureReason = "chunk empty after filtering";
       rollbackDrainReservation();
@@ -174036,6 +173775,7 @@ ${chunkText}`,
       }
       appendCompartments(db, sessionId, persistedCompartments);
       clearHistorianFailureState(db, sessionId);
+      clearHistorianDrainFailure(db, sessionId);
       recordProtectedTailPublicationFloor(db, sessionId, lastCompartmentEnd + 1);
       clearEmergencyRecovery(db, sessionId);
       drainReservation = null;
@@ -174139,8 +173879,11 @@ ${chunkText}`,
     }
   } finally {
     if (!completedSuccessfully) {
-      if (!retainDrainReservationForRetryThrottle)
+      if (!retainDrainReservationForRetryThrottle) {
         rollbackDrainReservation();
+      } else {
+        recordHistorianDrainFailure(db, sessionId);
+      }
       updateSessionMeta(db, sessionId, { compartmentInProgress: false });
     }
     recordTelemetry();
@@ -176354,15 +176097,15 @@ var require_windows = __commonJS((exports, module) => {
     }
     return false;
   }
-  function checkStat(stat2, path6, options) {
-    if (!stat2.isSymbolicLink() && !stat2.isFile()) {
+  function checkStat(stat, path6, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
       return false;
     }
     return checkPathExt(path6, options);
   }
   function isexe(path6, options, cb) {
-    fs2.stat(path6, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, path6, options));
+    fs2.stat(path6, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path6, options));
     });
   }
   function sync(path6, options) {
@@ -176376,20 +176119,20 @@ var require_mode = __commonJS((exports, module) => {
   isexe.sync = sync;
   var fs2 = __require("fs");
   function isexe(path6, options, cb) {
-    fs2.stat(path6, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, options));
+    fs2.stat(path6, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
     });
   }
   function sync(path6, options) {
     return checkStat(fs2.statSync(path6), options);
   }
-  function checkStat(stat2, options) {
-    return stat2.isFile() && checkMode(stat2, options);
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
   }
-  function checkMode(stat2, options) {
-    var mod = stat2.mode;
-    var uid = stat2.uid;
-    var gid = stat2.gid;
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
     var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
     var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
     var u = parseInt("100", 8);
@@ -177254,7 +176997,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();
@@ -177570,17 +177312,20 @@ function shouldShowAnnouncement() {
   }
   return state.version !== ANNOUNCEMENT_VERSION;
 }
-var ANNOUNCEMENT_VERSION = "0.25.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 = [
-    "Old tool output is now reclaimed automatically: once a file read / search / command output has gone a full execute cycle unused, it's dropped on the next one — no need to call ctx_reduce for stale results.",
-    "Recover anything that was dropped: ctx_expand({ message: N }) returns a dropped message's full content (every tool call's input + output) from storage. ctx_expand({ start, end, verbose: true }) lists a range message-by-message to find it.",
-    "Searchable history made reliable: /ctx-embed shows embedding coverage and runs a resilient backfill (retries transient failures, no longer bails on the first hiccup); the active session now auto-embeds in the background. ctx_reduce guidance also reframed as deferred + recoverable so models trim spent output earlier.",
-    "Pi: fixed /ctx-dream (was failing with 'Unknown named parameter') and local-embedding load failures on Windows/Desktop (#151, #128).",
-    "Runaway background agents on weak/local models are now capped and force-stopped (#154, #152). Plus several prompt-cache busts removed."
+    "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."
   ];
 });
+
+// src/agents/dreamer.ts
+var DREAMER_AGENT = "dreamer";
 // src/agents/permissions.ts
 function buildAllowOnlyPermission(allowedTools) {
   const permission = { "*": "deny" };
@@ -177590,6 +177335,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",
@@ -177605,6 +177355,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";
@@ -178558,6 +178312,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
@@ -178694,7 +178449,6 @@ init_project_identity();
 init_shared();
 init_assistant_message_extractor();
 init_logger();
-init_resolve_fallbacks();
 init_subagent_token_capture();
 await init_storage();
 
@@ -178716,7 +178470,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;
@@ -178806,6 +178560,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";
@@ -179043,6 +178802,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;
@@ -179236,21 +178996,21 @@ function clearStaleEntries(db, maxAgeMs, projectIdentity) {
   return result.changes;
 }
 // src/features/magic-context/dreamer/runner.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join12 } from "node:path";
 init_shared();
 init_assistant_message_extractor();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join12 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join11, relative as relative2 } from "node:path";
 init_read_session_formatting();
 init_shared();
 init_assistant_message_extractor();
 init_logger();
-import { readFileSync as readFileSync8 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join11, relative as relative2 } from "node:path";
 init_subagent_token_capture();
 init_aft_availability();
 init_project_key_files();
@@ -181119,7 +180879,6 @@ 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;
@@ -181222,7 +180981,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);
@@ -181671,10 +181430,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) {
@@ -181683,14 +181441,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;
@@ -181883,20 +181633,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;
@@ -181917,7 +181665,7 @@ function createTagger() {
     loadSignatures.set(sessionId, {
       db,
       dataVersion: probe.dataVersion,
-      totalChanges: probe.totalChanges
+      floor
     });
   }
   function cleanup(sessionId) {
@@ -181940,13 +181688,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
@@ -181997,6 +181745,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(),
@@ -182011,6 +181760,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;
@@ -182082,7 +181863,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({
@@ -182111,7 +181892,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) {
@@ -182142,7 +181924,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 };
@@ -182156,14 +181938,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 };
         }
       }
@@ -182171,7 +181956,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);
@@ -182906,9 +182691,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();
@@ -183312,11 +183230,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: {
@@ -183379,8 +183299,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;
@@ -184416,6 +184336,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(),
@@ -184424,9 +184345,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;
@@ -184992,6 +184933,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;
@@ -185012,7 +184954,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) {
@@ -185032,10 +185012,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;
@@ -185116,6 +185096,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;
@@ -185123,6 +185104,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);
@@ -185163,7 +185148,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) ?? {
@@ -185182,6 +185167,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 {
@@ -185189,6 +185175,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));
@@ -185261,6 +185254,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) {
@@ -186259,7 +186253,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,
@@ -186503,6 +186497,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) {
@@ -186534,6 +186529,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);
@@ -186637,6 +186633,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
     droppedTools,
     deduplicatedTools,
     droppedInjections,
+    emergencyDroppedTools,
     compressedTextTags,
     mutatedTextTags
   };
@@ -186865,7 +186862,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);
@@ -186877,11 +186873,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) {
@@ -186893,8 +186890,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");
     }
@@ -186905,12 +186903,22 @@ async function runPostTransformPhase(args) {
   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();
       pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, pendingOps);
+      if (pendingOpsDidMutate) {
+        droppedCount += pendingOps.length;
+      }
       logTransformTiming(args.sessionId, "applyPendingOperations", tApply);
     }
     if (shouldRunHeuristics) {
@@ -186930,8 +186938,10 @@ async function runPostTransformPhase(args) {
       }, heuristicTags);
       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);
       }
@@ -186956,6 +186966,7 @@ async function runPostTransformPhase(args) {
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", t7);
       heuristicOrReasoningDidMutate = heuristicMutationCount + clearedReasoning + strippedInline > 0;
+      droppedCount += clearedReasoning + strippedInline;
       if (pendingMaterializationAtPassStart) {
         args.pendingMaterializationSessions.delete(args.sessionId);
       }
@@ -186981,6 +186992,10 @@ async function runPostTransformPhase(args) {
       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();
@@ -187060,6 +187075,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) {
@@ -187268,7 +187286,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;
@@ -187303,6 +187333,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;
@@ -187325,6 +187361,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) {
@@ -187627,12 +187664,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 });
@@ -187674,7 +187715,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, {
@@ -187726,7 +187767,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})`);
@@ -187824,7 +187865,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,
@@ -187878,6 +187919,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;
@@ -188259,6 +188313,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) {
@@ -188416,6 +188479,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;
@@ -189143,7 +189207,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 {
@@ -189471,7 +189535,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);
@@ -189530,7 +189594,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({
@@ -190506,8 +190570,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,
@@ -190518,7 +190581,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,
@@ -190870,6 +190933,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();
@@ -190877,7 +190941,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"];
@@ -191802,7 +191865,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,
@@ -191905,14 +191968,13 @@ function createToolRegistry(args) {
 init_conflict_detector();
 init_data_path();
 init_logger();
-init_model_requirements();
 init_models_dev_cache();
 
 // src/shared/rpc-server.ts
 init_logger();
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import {
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync7,
   readdirSync,
   readFileSync as readFileSync12,
   renameSync as renameSync2,
@@ -191920,20 +191982,20 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash13 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join19 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash13("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
-  return join20(storageDir, "rpc", projectHash(directory));
+  return join19(storageDir, "rpc", projectHash(directory));
 }
 function rpcPortFilePath(storageDir, directory, pid = process.pid) {
-  return join20(rpcPortDir(storageDir, directory), `port-${pid}.json`);
+  return join19(rpcPortDir(storageDir, directory), `port-${pid}.json`);
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
@@ -192017,8 +192079,8 @@ class MagicContextRpcServer {
         this.server = server2;
         try {
           this.warnIfOtherLiveInstance();
-          const dir = dirname5(this.portFilePath);
-          mkdirSync8(dir, { recursive: true, mode: 448 });
+          const dir = dirname4(this.portFilePath);
+          mkdirSync7(dir, { recursive: true, mode: 448 });
           const tmpPath = `${this.portFilePath}.tmp`;
           writeFileSync5(tmpPath, JSON.stringify({
             port: this.port,
@@ -192313,14 +192375,13 @@ var plugin = async (ctx) => {
       await hooks.magicContext?.["experimental.text.complete"]?.(input, output);
     },
     config: async (config2) => {
-      const buildHiddenAgentConfig = (agentId, prompt, allowedTools, maxSteps, overrides) => {
+      const buildHiddenAgentConfig = (prompt, allowedTools, maxSteps, overrides) => {
         const { permission: overridePermission, ...restOverrides } = overrides ?? {};
         const basePermission = buildAllowOnlyPermission(allowedTools);
         return {
           prompt,
           steps: maxSteps,
           maxSteps,
-          ...getAgentFallbackModels(agentId) ? { fallback_models: getAgentFallbackModels(agentId) } : {},
           ...restOverrides,
           permission: {
             ...basePermission,
@@ -192342,6 +192403,7 @@ var plugin = async (ctx) => {
           max_runtime_minutes: _max,
           tasks: _tasks,
           task_timeout_minutes: _tto,
+          thinking_level: _thinkingLevel,
           ...agentOverrides
         } = pluginConfig.dreamer;
         return agentOverrides;
@@ -192350,20 +192412,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, DREAMER_MAX_STEPS, dreamerAgentOverrides),
-        [HISTORIAN_AGENT]: buildHiddenAgentConfig(HISTORIAN_AGENT, COMPARTMENT_AGENT_SYSTEM_PROMPT, HISTORIAN_ALLOWED_TOOLS, HISTORIAN_MAX_STEPS, historianAgentOverrides),
-        [HISTORIAN_EDITOR_AGENT]: buildHiddenAgentConfig(HISTORIAN_EDITOR_AGENT, HISTORIAN_EDITOR_SYSTEM_PROMPT, HISTORIAN_ALLOWED_TOOLS, HISTORIAN_MAX_STEPS, historianAgentOverrides),
-        [SIDEKICK_AGENT]: buildHiddenAgentConfig(SIDEKICK_AGENT, SIDEKICK_SYSTEM_PROMPT, SIDEKICK_ALLOWED_TOOLS, SIDEKICK_MAX_STEPS, 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)
       };
     }
   };