@wolfx/pi-magic-context 0.24.0 → 0.25.0

package/dist/index.js

@@ -8275,6 +8275,14 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
       }
       super(typeof filename === "string" ? filename : ":memory:", translated);
     }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
     transaction(fn) {
       const self = this;
       const wrapped = function(...args) {
@@ -141059,6 +141067,8 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
 var encoder = new TextEncoder;
 var TAG_PREFIX_REGEX = /^(?:§\d+§\s*)+/;
 var MALFORMED_TAG_PREFIX_REGEX = /^(?:§\d+">§(?:\d+§)?\s*)+/;
+var DANGLING_TAG_GLOBAL_REGEX = /\u00a7\d+(?!\.\d)[^\s\u00a7\w.]?/g;
+var DANGLING_TAG_PREFIX_REGEX = /^(?:\u00a7\d+(?!\.\d)[^\s\u00a7\w.]?\s*)+/;
 var COMPLETE_TAG_PAIR_GLOBAL_REGEX = /\u00a7\d+\u00a7/g;
 var MALFORMED_TAG_GLOBAL_REGEX = /\u00a7\d+">(?:\u00a7(?:\d+\u00a7)?)?/g;
 var STRAY_SECTION_CHAR_REGEX = /\u00a7/g;
@@ -141071,6 +141081,9 @@ function stripCompleteTagPairsGlobally(value) {
 function stripMalformedTagNotationGlobally(value) {
   return value.replace(MALFORMED_TAG_GLOBAL_REGEX, "");
 }
+function stripDanglingTagNotationGlobally(value) {
+  return value.replace(DANGLING_TAG_GLOBAL_REGEX, "");
+}
 function stripTagSectionCharacters(value) {
   return value.replace(STRAY_SECTION_CHAR_REGEX, "");
 }
@@ -141078,6 +141091,7 @@ function stripPersistedAssistantText(value) {
   let text = stripWellFormedLeadingTagPrefix(value);
   text = stripCompleteTagPairsGlobally(text);
   text = stripMalformedTagNotationGlobally(text);
+  text = stripDanglingTagNotationGlobally(text);
   text = stripTagSectionCharacters(text);
   return text.trim();
 }
@@ -141090,6 +141104,7 @@ function stripTagPrefix(value) {
     const prev = stripped;
     stripped = stripped.replace(MALFORMED_TAG_PREFIX_REGEX, "");
     stripped = stripped.replace(TAG_PREFIX_REGEX, "");
+    stripped = stripped.replace(DANGLING_TAG_PREFIX_REGEX, "");
     if (stripped === prev)
       break;
   }
@@ -141957,6 +141972,7 @@ var SESSION_META_SELECT_COLUMNS = [
   "conversation_tokens",
   "tool_call_tokens",
   "cleared_reasoning_through_tag",
+  "tool_reclaim_watermark",
   "last_todo_state",
   "cached_m0_bytes",
   "cached_m1_bytes",
@@ -142005,6 +142021,7 @@ var META_COLUMNS = {
   conversationTokens: "conversation_tokens",
   toolCallTokens: "tool_call_tokens",
   clearedReasoningThroughTag: "cleared_reasoning_through_tag",
+  toolReclaimWatermark: "tool_reclaim_watermark",
   lastTodoState: "last_todo_state",
   cachedM0Bytes: "cached_m0_bytes",
   cachedM1Bytes: "cached_m1_bytes",
@@ -142073,7 +142090,7 @@ function isSessionMetaRow(row) {
   if (row === null || typeof row !== "object")
     return false;
   const r = row;
-  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state) && isBlobOrNull(r.cached_m0_bytes) && isBlobOrNull(r.cached_m1_bytes) && isNumberOrNull(r.cached_m0_project_memory_epoch) && isStringOrNull(r.cached_m0_workspace_fingerprint) && isNumberOrNull(r.cached_m0_project_user_profile_version) && isNumberOrNull(r.cached_m0_max_compartment_seq) && isNumberOrNull(r.cached_m0_max_memory_id) && isNumberOrNull(r.cached_m0_max_mutation_id) && isNumberOrNull(r.cached_m0_max_memory_mutation_id) && isStringOrNull(r.cached_m0_project_docs_hash) && isNumberOrNull(r.cached_m0_materialized_at) && isNumberOrNull(r.cached_m0_session_facts_version) && isStringOrNull(r.cached_m0_upgrade_state) && isStringOrNull(r.cached_m0_system_hash) && isStringOrNull(r.cached_m0_tool_set_hash) && isStringOrNull(r.cached_m0_model_key) && isStringOrNull(r.last_observed_model_key) && isNumberOrNull(r.last_usage_context_limit) && isNumberOrNull(r.prior_boundary_ordinal) && isNumberOrNull(r.protected_tail_policy_version) && isNumberOrNull(r.protected_tail_drain_window_started_at) && isNumberOrNull(r.protected_tail_drain_tokens) && isNumberOrNull(r.recovery_no_eligible_head_count) && isNumberOrNull(r.force_emergency_bypass_window_start) && isNumberOrNull(r.force_emergency_bypass_used) && isNumberOrNull(r.upgrade_reminded_at) && isNumberOrNull(r.pi_stable_id_scheme);
+  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state) && isBlobOrNull(r.cached_m0_bytes) && isBlobOrNull(r.cached_m1_bytes) && isNumberOrNull(r.cached_m0_project_memory_epoch) && isStringOrNull(r.cached_m0_workspace_fingerprint) && isNumberOrNull(r.cached_m0_project_user_profile_version) && isNumberOrNull(r.cached_m0_max_compartment_seq) && isNumberOrNull(r.cached_m0_max_memory_id) && isNumberOrNull(r.cached_m0_max_mutation_id) && isNumberOrNull(r.cached_m0_max_memory_mutation_id) && isStringOrNull(r.cached_m0_project_docs_hash) && isNumberOrNull(r.cached_m0_materialized_at) && isNumberOrNull(r.cached_m0_session_facts_version) && isStringOrNull(r.cached_m0_upgrade_state) && isStringOrNull(r.cached_m0_system_hash) && isStringOrNull(r.cached_m0_tool_set_hash) && isStringOrNull(r.cached_m0_model_key) && isStringOrNull(r.last_observed_model_key) && isNumberOrNull(r.last_usage_context_limit) && isNumberOrNull(r.prior_boundary_ordinal) && isNumberOrNull(r.protected_tail_policy_version) && isNumberOrNull(r.protected_tail_drain_window_started_at) && isNumberOrNull(r.protected_tail_drain_tokens) && isNumberOrNull(r.recovery_no_eligible_head_count) && isNumberOrNull(r.force_emergency_bypass_window_start) && isNumberOrNull(r.force_emergency_bypass_used) && isNumberOrNull(r.upgrade_reminded_at) && isNumberOrNull(r.pi_stable_id_scheme) && isNumberOrNull(r.tool_reclaim_watermark);
 }
 function getDefaultSessionMeta(sessionId) {
   return {
@@ -142096,6 +142113,7 @@ function getDefaultSessionMeta(sessionId) {
     conversationTokens: 0,
     toolCallTokens: 0,
     clearedReasoningThroughTag: 0,
+    toolReclaimWatermark: 0,
     lastTodoState: "",
     cachedM0Bytes: null,
     cachedM1Bytes: null,
@@ -142159,6 +142177,7 @@ function toSessionMeta(row) {
     conversationTokens: numOrZero(row.conversation_tokens),
     toolCallTokens: numOrZero(row.tool_call_tokens),
     clearedReasoningThroughTag: numOrZero(row.cleared_reasoning_through_tag),
+    toolReclaimWatermark: numOrZero(row.tool_reclaim_watermark),
     lastTodoState: lastTodoStateRaw,
     cachedM0Bytes: toBufferOrNull(row.cached_m0_bytes),
     cachedM1Bytes: toBufferOrNull(row.cached_m1_bytes),
@@ -143598,6 +143617,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "historian_last_failure_at", "INTEGER DEFAULT NULL");
   ensureColumn(db, "session_meta", "system_prompt_hash", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "cleared_reasoning_through_tag", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "tool_reclaim_watermark", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "stripped_placeholder_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "stale_reduce_stripped_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "processed_image_stripped_ids", "TEXT DEFAULT ''");
@@ -146217,6 +146237,7 @@ var SESSION_META_FALLBACK_SELECTS = {
   last_transform_error: "'' AS last_transform_error",
   system_prompt_hash: "'' AS system_prompt_hash",
   last_todo_state: "'' AS last_todo_state",
+  tool_reclaim_watermark: "0 AS tool_reclaim_watermark",
   cached_m0_bytes: "NULL AS cached_m0_bytes",
   cached_m1_bytes: "NULL AS cached_m1_bytes",
   cached_m0_project_memory_epoch: "NULL AS cached_m0_project_memory_epoch",
@@ -146294,6 +146315,14 @@ function updateSessionMeta(db, sessionId, updates) {
     db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")} WHERE session_id = ?`).run(...values, sessionId);
   })();
 }
+function advanceToolReclaimWatermark(db, sessionId, maxTagNumber) {
+  if (maxTagNumber <= 0)
+    return;
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET tool_reclaim_watermark = MAX(COALESCE(tool_reclaim_watermark, 0), ?) WHERE session_id = ?").run(maxTagNumber, sessionId);
+  })();
+}
 // ../plugin/src/features/magic-context/storage-notes.ts
 var NOTE_TYPES = new Set(["session", "smart"]);
 var NOTE_STATUSES = new Set(["active", "pending", "ready", "dismissed"]);
@@ -146668,15 +146697,22 @@ function ownerMessageIdForTagRow(row) {
   }
   return row.message_id.replace(CONTENT_ID_SUFFIX, "");
 }
-function getActiveTagTokenAggregate(db, sessionId) {
-  const row = db.prepare(`SELECT
+function getActiveTagTokenAggregate(db, sessionId, protectedTags = 0) {
+  const toolOutputExpr = protectedTags > 0 ? `COALESCE(SUM(CASE WHEN type = 'tool' AND tag_number < (
+                    SELECT tag_number FROM tags
+                    WHERE session_id = ? AND status = 'active'
+                    ORDER BY tag_number DESC LIMIT 1 OFFSET ?
+                ) THEN COALESCE(token_count, 0) ELSE 0 END), 0)` : `COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)`;
+  const sql = `SELECT
                 COALESCE(SUM(CASE WHEN type != 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)
                     + COALESCE(SUM(COALESCE(reasoning_token_count, 0)), 0) AS conversation,
                 COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) + COALESCE(input_token_count, 0) ELSE 0 END), 0) AS tool_call,
-                COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0) AS tool_output,
+                ${toolOutputExpr} AS tool_output,
                 COALESCE(SUM(CASE WHEN token_count IS NULL THEN 1 ELSE 0 END), 0) AS null_count
              FROM tags
-             WHERE session_id = ? AND status = 'active'`).get(sessionId);
+             WHERE session_id = ? AND status = 'active'`;
+  const params = protectedTags > 0 ? [sessionId, protectedTags - 1, sessionId] : [sessionId];
+  const row = db.prepare(sql).get(...params);
   return {
     conversation: row?.conversation ?? 0,
     toolCall: row?.tool_call ?? 0,
@@ -146684,6 +146720,26 @@ function getActiveTagTokenAggregate(db, sessionId) {
     nullCount: row?.null_count ?? 0
   };
 }
+function getOldestActiveUnprotectedToolTags(db, sessionId, protectedTags = 0, limit = 4) {
+  if (limit <= 0)
+    return [];
+  const boundedLimit = Math.max(1, Math.min(10, Math.floor(limit)));
+  const whereProtected = protectedTags > 0 ? `AND tag_number < (
+                    SELECT tag_number FROM tags
+                    WHERE session_id = ? AND status = 'active'
+                    ORDER BY tag_number DESC LIMIT 1 OFFSET ?
+                )` : "";
+  const params = protectedTags > 0 ? [sessionId, sessionId, protectedTags - 1, boundedLimit] : [sessionId, boundedLimit];
+  const rows = db.prepare(`SELECT tag_number, tool_name
+             FROM tags
+             WHERE session_id = ? AND status = 'active' AND type = 'tool' ${whereProtected}
+             ORDER BY tag_number ASC, id ASC
+             LIMIT ?`).all(...params);
+  return rows.filter((row) => typeof row.tag_number === "number").map((row) => ({
+    tagNumber: row.tag_number,
+    toolName: typeof row.tool_name === "string" ? row.tool_name : null
+  }));
+}
 function getTriggerTagTokenUpperBound(db, sessionId) {
   const row = db.prepare(`SELECT
                 COALESCE(SUM(COALESCE(token_count, 0) + COALESCE(input_token_count, 0) + COALESCE(reasoning_token_count, 0)), 0) AS bound,
@@ -147736,13 +147792,13 @@ async function maybeSendUpgradeReminder(deps, sessionId) {
 init_data_path();
 import * as fs2 from "node:fs";
 import * as path6 from "node:path";
-var ANNOUNCEMENT_VERSION = "0.24.0";
+var ANNOUNCEMENT_VERSION = "0.25.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Searchable session history: ctx_search can now find older discussion by meaning, not just keywords. New history is embedded automatically — to backfill an EXISTING session's older history, run /ctx-embed-history once (it works in the background).",
-  "Cross-project workspaces: group related repos and share project memories across them, with per-category control over what's shared. Set them up in the dashboard's Workspaces panel.",
-  "Pi: fixed sessions overflowing the model context while still showing moderate usage — Pi now sheds context before a tool-heavy turn overflows.",
-  "Fewer prompt-cache busts: doc edits, processed screenshots, and a rebuild-then-bust-again case no longer re-bill large prompt prefixes.",
-  "Setup wizard now lists your actual models with type-ahead instead of fixed recommendations, and explains the historian/dreamer roles (issue #144). Plus a GitHub Copilot tool-pairing fix (#135)."
+  "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."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU";
 var STATE_FILENAME = "last_announced_version";
@@ -148686,7 +148742,7 @@ function enqueueDream(db, projectIdentity, reason, force = false) {
   return db.transaction(() => {
     if (!hasActiveDreamLease(db)) {
       const staleThresholdMs = force ? 2 * 60 * 1000 : 120 * 60 * 1000;
-      db.prepare("DELETE FROM dream_queue WHERE project_path = ? AND started_at IS NOT NULL AND started_at < ?").run([projectIdentity, now - staleThresholdMs]);
+      db.prepare("DELETE FROM dream_queue WHERE project_path = ? AND started_at IS NOT NULL AND started_at < ?").run(projectIdentity, now - staleThresholdMs);
     }
     const existing = db.prepare("SELECT id FROM dream_queue WHERE project_path = ?").get(projectIdentity);
     if (existing) {
@@ -148821,9 +148877,11 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
     });
   } catch (error) {
     if (signal?.aborted) {
+      await abortChildRun(client, args.path.id);
       throw new Error("prompt aborted by external signal");
     }
     if (controller.signal.aborted) {
+      await abortChildRun(client, args.path.id);
       throw new Error(`prompt timed out after ${timeoutMs}ms`);
     }
     throw error;
@@ -148832,6 +148890,13 @@ async function promptWithTimeout(client, args, timeoutMs, signal) {
     signal?.removeEventListener("abort", onExternalAbort);
   }
 }
+async function abortChildRun(client, sessionId) {
+  try {
+    await client.session.abort({ path: { id: sessionId } });
+  } catch (error) {
+    log(`[model-retry] child session abort failed for ${sessionId}: ${String(error)}`);
+  }
+}
 function isNonRetryable(error, externalSignal) {
   if (externalSignal?.aborted)
     return true;
@@ -149688,6 +149753,20 @@ function getDistinctStoredModelIds(db, projectPath) {
   const rows = getDistinctStoredModelIdsStatement(db).all(projectPath);
   return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
 }
+function getMemoryEmbedCoverage(db, projectPath, modelId) {
+  const row = db.prepare(`SELECT
+               COUNT(*) AS total,
+               SUM(CASE WHEN EXISTS (
+                   SELECT 1 FROM memory_embeddings e
+                   WHERE e.memory_id = m.id AND e.model_id = ?
+               ) THEN 1 ELSE 0 END) AS embedded
+             FROM memories m
+             WHERE m.project_path = ? AND m.status = 'active'`).get(modelId, projectPath);
+  return {
+    total: typeof row?.total === "number" ? row.total : 0,
+    embedded: typeof row?.embedded === "number" ? row.embedded : 0
+  };
+}
 
 // ../plugin/src/features/magic-context/memory/embedding-cache.ts
 var DEFAULT_EMBEDDING_CACHE_TTL_MS = 60000;
@@ -166296,6 +166375,7 @@ init_logger();
 // ../plugin/src/features/magic-context/compartment-chunk-embedding.ts
 import { createHash as createHash8 } from "node:crypto";
 var DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS = 512;
+var CHUNK_WINDOW_SAFETY_RATIO = 0.9;
 var loadFtsRowsStatements = new WeakMap;
 var existingHashStatements = new WeakMap;
 var existingHashByProjectStatements = new WeakMap;
@@ -166531,9 +166611,10 @@ function chunkCanonicalText(canonicalText, startOrdinal, endOrdinal, maxInputTok
   if (lines.length === 0 || endOrdinal < startOrdinal)
     return [];
   const normalizedMax = normalizeCompartmentChunkMaxInputTokens(maxInputTokens);
+  const effectiveMax = Math.max(1, Math.floor(normalizedMax * CHUNK_WINDOW_SAFETY_RATIO));
   const fullText = lines.join(`
 `);
-  if (estimateTokens(fullText) <= normalizedMax) {
+  if (estimateTokens(fullText) <= effectiveMax) {
     return [
       {
         windowIndex: 0,
@@ -166571,7 +166652,7 @@ function chunkCanonicalText(canonicalText, startOrdinal, endOrdinal, maxInputTok
     const lineStart = range?.start ?? startOrdinal;
     const lineEnd = range?.end ?? lineStart;
     const lineTokens = estimateTokens(line);
-    if (currentLines.length > 0 && currentTokens + lineTokens > normalizedMax) {
+    if (currentLines.length > 0 && currentTokens + lineTokens > effectiveMax) {
       flush2();
     }
     if (currentLines.length === 0) {
@@ -166727,6 +166808,28 @@ function countUnembeddedSessionCompartments(db, projectPath, sessionId, modelId)
                )`).get(projectPath, sessionId, projectPath, modelId);
   return typeof row?.n === "number" ? row.n : 0;
 }
+function countSessionCompartmentEmbedCoverage(db, projectPath, sessionId, modelId) {
+  const row = db.prepare(`SELECT
+               COUNT(*) AS total,
+               SUM(CASE WHEN EXISTS (
+                   SELECT 1 FROM compartment_chunk_embeddings e
+                   WHERE e.compartment_id = c.id
+                     AND e.project_path = ?
+                     AND e.model_id = ?
+               ) THEN 1 ELSE 0 END) AS embedded
+             FROM compartments c
+             JOIN session_projects sp
+               ON sp.session_id = c.session_id
+              AND sp.harness = c.harness
+              AND sp.project_path = ?
+             WHERE c.session_id = ?
+               AND c.start_message IS NOT NULL
+               AND c.end_message IS NOT NULL`).get(projectPath, modelId, projectPath, sessionId);
+  return {
+    total: typeof row?.total === "number" ? row.total : 0,
+    embedded: typeof row?.embedded === "number" ? row.embedded : 0
+  };
+}
 
 // ../plugin/src/features/magic-context/memory/cosine-similarity.ts
 function cosineSimilarity(a, b) {
@@ -166869,6 +166972,19 @@ async function withQuietConsole(fn) {
     console.error = origError;
   }
 }
+var nativeRuntimeMissing = false;
+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)
@@ -166933,6 +167049,9 @@ class LocalEmbeddingProvider {
     if (this.pipeline) {
       return true;
     }
+    if (nativeRuntimeMissing) {
+      return false;
+    }
     if (this.initPromise) {
       await this.initPromise;
       return this.pipeline !== null;
@@ -166999,7 +167118,12 @@ class LocalEmbeddingProvider {
           await releaseLock();
         }
       } catch (error51) {
-        log("[magic-context] embedding model failed to load:", error51);
+        if (isNativeRuntimeMissingError(error51)) {
+          nativeRuntimeMissing = true;
+          log("[magic-context] local embedding runtime is not installed (onnxruntime-node missing from this install). Local embeddings are disabled. Fix: reinstall the plugin (run `npx @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;
@@ -167171,6 +167295,13 @@ function blockedEmbeddingEndpointReason(endpoint) {
 function normalizeEndpoint2(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
+function embeddingModelsMatch(served, requested) {
+  const a = served.trim().toLowerCase();
+  const b = requested.trim().toLowerCase();
+  if (a.length === 0 || b.length === 0)
+    return true;
+  return a === b || a.includes(b) || b.includes(a);
+}
 var FAILURE_THRESHOLD = 3;
 var FAILURE_WINDOW_MS = 60000;
 var OPEN_DURATION_MS = 5 * 60000;
@@ -167188,6 +167319,7 @@ class OpenAICompatibleEmbeddingProvider {
   failureTimes = [];
   circuitOpenUntil = 0;
   openLogged = false;
+  modelMismatchLogged = false;
   halfOpenProbeInFlight = false;
   constructor(options) {
     this.endpoint = normalizeEndpoint2(options.endpoint);
@@ -167286,6 +167418,15 @@ class OpenAICompatibleEmbeddingProvider {
         this.recordFailure(isProbe);
         return Array.from({ length: texts.length }, () => null);
       }
+      const servedModel = typeof body.model === "string" ? body.model : "";
+      if (this.model && servedModel && !embeddingModelsMatch(servedModel, this.model)) {
+        if (!this.modelMismatchLogged) {
+          log(`[magic-context] embedding endpoint served a DIFFERENT model than requested — refusing the substituted vectors (they have the wrong dimensions/space). requested="${this.model}" served="${servedModel}". The endpoint likely substituted a loaded model; load/select "${this.model}" on the endpoint, or set embedding.model to the served model.`);
+          this.modelMismatchLogged = true;
+        }
+        this.recordFailure(isProbe);
+        return Array.from({ length: texts.length }, () => null);
+      }
       const items = Array.isArray(body.data) ? body.data : [];
       const results = Array.from({ length: texts.length }, (_, index) => {
         const embedding = items[index]?.embedding;
@@ -167496,6 +167637,118 @@ function getDistinctCommitEmbeddingModelIds(db, projectPath) {
   return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
 }
 
+// ../plugin/src/features/magic-context/git-commits/storage-git-commits.ts
+init_logger();
+var insertStatements = new WeakMap;
+var existingShasStatements = new WeakMap;
+var projectCountStatements = new WeakMap;
+var evictStatements = new WeakMap;
+var evictOverflowStatements = new WeakMap;
+var latestCommitTimeStatements = new WeakMap;
+function getInsertStatement(db) {
+  let stmt = insertStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO git_commits (sha, project_path, short_sha, message, author, committed_at, indexed_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(sha) DO UPDATE SET
+                 project_path = excluded.project_path,
+                 short_sha = excluded.short_sha,
+                 message = excluded.message,
+                 author = excluded.author,
+                 committed_at = excluded.committed_at,
+                 indexed_at = excluded.indexed_at
+             WHERE git_commits.message != excluded.message`);
+    insertStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getExistingShasStatement(db) {
+  let stmt = existingShasStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT sha FROM git_commits WHERE project_path = ?");
+    existingShasStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getProjectCountStatement(db) {
+  let stmt = projectCountStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COUNT(*) AS count FROM git_commits WHERE project_path = ?");
+    projectCountStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLatestCommitTimeStatement(db) {
+  let stmt = latestCommitTimeStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT MAX(committed_at) AS latest FROM git_commits WHERE project_path = ?");
+    latestCommitTimeStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getEvictOverflowStatement(db) {
+  let stmt = evictOverflowStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`DELETE FROM git_commits
+             WHERE rowid IN (
+                 SELECT rowid FROM git_commits
+                 WHERE project_path = ?
+                 ORDER BY committed_at DESC, sha DESC
+                 LIMIT -1 OFFSET ?
+             )`);
+    evictOverflowStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function upsertCommits(db, projectPath, commits) {
+  if (commits.length === 0)
+    return { inserted: 0, updated: 0 };
+  const existing = new Set;
+  for (const row of getExistingShasStatement(db).all(projectPath)) {
+    existing.add(row.sha);
+  }
+  let inserted = 0;
+  let updated = 0;
+  const now = Date.now();
+  const insertStmt = getInsertStatement(db);
+  db.transaction(() => {
+    for (const commit of commits) {
+      const result = insertStmt.run(commit.sha, projectPath, commit.shortSha, commit.message, commit.author, commit.committedAtMs, now);
+      if (result.changes > 0) {
+        if (existing.has(commit.sha)) {
+          updated++;
+        } else {
+          inserted++;
+          existing.add(commit.sha);
+        }
+      }
+    }
+  })();
+  return { inserted, updated };
+}
+function getCommitCount(db, projectPath) {
+  const row = getProjectCountStatement(db).get(projectPath);
+  return row?.count ?? 0;
+}
+function getLatestIndexedCommitTimeMs(db, projectPath) {
+  const row = getLatestCommitTimeStatement(db).get(projectPath);
+  return row?.latest ?? null;
+}
+function enforceProjectCap(db, projectPath, maxCommits) {
+  if (maxCommits <= 0)
+    return 0;
+  const count = getCommitCount(db, projectPath);
+  if (count <= maxCommits)
+    return 0;
+  getEvictOverflowStatement(db).run(projectPath, maxCommits);
+  const after = getCommitCount(db, projectPath);
+  const evicted = Math.max(0, count - after);
+  if (evicted > 0) {
+    log(`[git-commits] evicted ${evicted} oldest commits for project ${projectPath} (cap=${maxCommits}, was=${count})`);
+  }
+  return evicted;
+}
+
 // ../plugin/src/features/magic-context/git-commits/sweep-coordinator.ts
 var GIT_SWEEP_COOLDOWN_MS = 10 * 60 * 1000;
 var GIT_SWEEP_LEASE_TTL_MS = 5 * 60 * 1000;
@@ -167690,8 +167943,12 @@ function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
 var OFF_PROVIDER_IDENTITY = "embedding-provider:off";
 var SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
 var CHUNK_DRAIN_BATCH_SIZE = 8;
-var MAX_WINDOWS_PER_EMBED_CALL = 16;
+var MAX_WINDOWS_PER_EMBED_CALL = 2;
 var SESSION_EMBED_LEASE_RENEWAL_MS = 60 * 1000;
+var EMBED_SLICE_RETRY_ATTEMPTS = 3;
+var EMBED_SLICE_RETRY_BASE_MS = 250;
+var EMBED_SLOW_FAILURE_NO_RETRY_MS = 1e4;
+var MAX_CONSECUTIVE_FAILED_BATCHES = 3;
 var projectRegistrations = new Map;
 var loadUnembeddedMemoriesStatements = new WeakMap;
 var globalRegistrationGeneration = 0;
@@ -167768,7 +168025,7 @@ function getChunkEmbeddingModelId(config2, providerIdentity) {
   }
   const chunkIdentity = {
     providerIdentity,
-    chunkerVersion: 1,
+    chunkerVersion: 2,
     maxInputTokens: normalizeCompartmentChunkMaxInputTokens("max_input_tokens" in config2 ? config2.max_input_tokens : undefined),
     truncate: config2.provider === "openai-compatible" ? config2.truncate ?? "" : ""
   };
@@ -167791,7 +168048,9 @@ function snapshotFor(registration) {
     enabled,
     gitCommitEnabled,
     modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId,
-    chunkModelId: registration.observationMode || !providerIsOn ? "off" : registration.chunkModelId
+    chunkModelId: registration.observationMode || !providerIsOn ? "off" : registration.chunkModelId,
+    model: registration.observationMode || !providerIsOn ? "off" : ("model" in registration.config) && registration.config.model.trim() ? registration.config.model.trim() : registration.modelId,
+    provider: registration.observationMode || !providerIsOn ? "off" : registration.config.provider ?? "local"
   };
 }
 function disposeProvider(provider) {
@@ -168002,8 +168261,9 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
 }
 async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates, signal) {
   const noWork = [];
+  const failed = [];
   if (candidates.length === 0)
-    return { embedded: 0, noWork };
+    return { embedded: 0, noWork, failed };
   const maxInputTokens = getProjectEmbeddingMaxInputTokens(projectIdentity);
   const prepared = [];
   for (const candidate of candidates) {
@@ -168020,7 +168280,7 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
     prepared.push({ candidate, windows });
   }
   if (prepared.length === 0)
-    return { embedded: 0, noWork };
+    return { embedded: 0, noWork, failed };
   let embedded = 0;
   let i = 0;
   while (i < prepared.length) {
@@ -168037,35 +168297,60 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
     const texts = [];
     for (const item of slice)
       texts.push(...item.windows.map((w) => w.text));
-    try {
-      const result = await embedBatchForProject(projectIdentity, texts, signal);
-      if (!result)
-        continue;
+    const persistedIds = new Set;
+    for (let attempt = 0;attempt < EMBED_SLICE_RETRY_ATTEMPTS; attempt++) {
       if (signal?.aborted)
         break;
-      let offset = 0;
-      for (const item of slice) {
-        const vectors = result.vectors.slice(offset, offset + item.windows.length);
-        offset += item.windows.length;
-        if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
-          continue;
+      let result = null;
+      const attemptStart = Date.now();
+      try {
+        result = await embedBatchForProject(projectIdentity, texts, signal);
+      } catch (error51) {
+        log("[magic-context] failed to proactively embed compartment chunks:", error51);
+      }
+      if (signal?.aborted)
+        break;
+      if (result) {
+        let offset = 0;
+        for (const item of slice) {
+          const vectors = result.vectors.slice(offset, offset + item.windows.length);
+          offset += item.windows.length;
+          if (persistedIds.has(item.candidate.id))
+            continue;
+          if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
+            continue;
+          }
+          const rows = item.windows.map((window, index) => ({
+            compartmentId: item.candidate.id,
+            sessionId: item.candidate.sessionId,
+            projectPath: projectIdentity,
+            window,
+            modelId,
+            vector: vectors[index]
+          }));
+          replaceCompartmentChunkEmbeddings(db, rows);
+          persistedIds.add(item.candidate.id);
         }
-        const rows = item.windows.map((window, index) => ({
-          compartmentId: item.candidate.id,
-          sessionId: item.candidate.sessionId,
-          projectPath: projectIdentity,
-          window,
-          modelId,
-          vector: vectors[index]
-        }));
-        replaceCompartmentChunkEmbeddings(db, rows);
-        embedded += 1;
       }
-    } catch (error51) {
-      log("[magic-context] failed to proactively embed compartment chunks:", error51);
+      if (persistedIds.size === slice.length)
+        break;
+      if (persistedIds.size > 0)
+        break;
+      if (Date.now() - attemptStart >= EMBED_SLOW_FAILURE_NO_RETRY_MS)
+        break;
+      if (attempt < EMBED_SLICE_RETRY_ATTEMPTS - 1) {
+        await new Promise((resolve4) => setTimeout(resolve4, EMBED_SLICE_RETRY_BASE_MS * 2 ** attempt));
+      }
+    }
+    embedded += persistedIds.size;
+    if (!signal?.aborted) {
+      for (const item of slice) {
+        if (!persistedIds.has(item.candidate.id))
+          failed.push(item.candidate.id);
+      }
     }
   }
-  return { embedded, noWork };
+  return { embedded, noWork, failed };
 }
 async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, options) {
   const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
@@ -168088,9 +168373,11 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
   renewal.unref?.();
   const batchSize = Math.max(1, options?.batchSize ?? CHUNK_DRAIN_BATCH_SIZE);
   const skipIds = [];
+  const failedIds = [];
   let embedded = 0;
   let aborted2 = false;
-  let providerStalled = false;
+  let providerDown = false;
+  let consecutiveFailedBatches = 0;
   try {
     options?.onProgress?.({ embedded, total });
     for (;; ) {
@@ -168098,15 +168385,26 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
         aborted2 = true;
         break;
       }
-      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, skipIds);
+      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, [...skipIds, ...failedIds]);
       if (candidates.length === 0)
         break;
-      const { embedded: n, noWork } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, options?.signal);
+      const {
+        embedded: n,
+        noWork,
+        failed
+      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, options?.signal);
       for (const id of noWork)
         skipIds.push(id);
+      for (const id of failed)
+        failedIds.push(id);
       if (n === 0 && noWork.length === 0) {
-        providerStalled = true;
-        break;
+        consecutiveFailedBatches += 1;
+        if (consecutiveFailedBatches >= MAX_CONSECUTIVE_FAILED_BATCHES) {
+          providerDown = true;
+          break;
+        }
+      } else {
+        consecutiveFailedBatches = 0;
       }
       embedded += n;
       options?.onProgress?.({ embedded: Math.min(embedded, total), total });
@@ -168114,16 +168412,50 @@ async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, opt
     }
   } finally {
     clearInterval(renewal);
-    releaseGitSweepLease(db, projectIdentity, holderId);
+    try {
+      releaseGitSweepLease(db, projectIdentity, holderId);
+    } catch (error51) {
+      log("[magic-context] embed drain: lease release failed (will TTL-expire):", error51);
+    }
   }
   if (aborted2)
-    return { status: "aborted", embedded, total };
-  if (providerStalled) {
+    return { status: "aborted", embedded, total, failed: failedIds.length };
+  if (providerDown || failedIds.length > 0) {
     const remaining = Math.max(0, countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId) - skipIds.length);
-    if (remaining > 0)
-      return { status: "stalled", embedded, total, remaining };
+    if (remaining > 0) {
+      return { status: "stalled", embedded, total, remaining, failed: failedIds.length };
+    }
   }
-  return { status: "done", embedded, total };
+  return { status: "done", embedded, total, failed: failedIds.length };
+}
+function getEmbeddingCoverageStatus(db, projectIdentity, sessionId) {
+  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot?.enabled || snapshot.chunkModelId === "off") {
+    return {
+      enabled: false,
+      model: snapshot?.model ?? "off",
+      provider: snapshot?.provider ?? "off",
+      session: { embedded: 0, total: 0 },
+      memories: { embedded: 0, total: 0 },
+      commits: { embedded: 0, total: 0, gitEnabled: false }
+    };
+  }
+  const session = countSessionCompartmentEmbedCoverage(db, projectIdentity, sessionId, snapshot.chunkModelId);
+  const memories = getMemoryEmbedCoverage(db, projectIdentity, snapshot.modelId);
+  const gitEnabled = snapshot.gitCommitEnabled;
+  const commits = gitEnabled ? {
+    embedded: countEmbeddedCommits(db, projectIdentity),
+    total: getCommitCount(db, projectIdentity),
+    gitEnabled: true
+  } : { embedded: 0, total: 0, gitEnabled: false };
+  return {
+    enabled: true,
+    model: snapshot.model,
+    provider: snapshot.provider,
+    session,
+    memories,
+    commits
+  };
 }
 
 // ../plugin/src/features/magic-context/memory/embedding.ts
@@ -168172,118 +168504,6 @@ async function embedText(text, signal) {
 }
 var SWEEP_MAX_WALL_CLOCK_MS2 = 10 * 60 * 1000;
 
-// ../plugin/src/features/magic-context/git-commits/storage-git-commits.ts
-init_logger();
-var insertStatements = new WeakMap;
-var existingShasStatements = new WeakMap;
-var projectCountStatements = new WeakMap;
-var evictStatements = new WeakMap;
-var evictOverflowStatements = new WeakMap;
-var latestCommitTimeStatements = new WeakMap;
-function getInsertStatement(db) {
-  let stmt = insertStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`INSERT INTO git_commits (sha, project_path, short_sha, message, author, committed_at, indexed_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?)
-             ON CONFLICT(sha) DO UPDATE SET
-                 project_path = excluded.project_path,
-                 short_sha = excluded.short_sha,
-                 message = excluded.message,
-                 author = excluded.author,
-                 committed_at = excluded.committed_at,
-                 indexed_at = excluded.indexed_at
-             WHERE git_commits.message != excluded.message`);
-    insertStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getExistingShasStatement(db) {
-  let stmt = existingShasStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT sha FROM git_commits WHERE project_path = ?");
-    existingShasStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getProjectCountStatement(db) {
-  let stmt = projectCountStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT COUNT(*) AS count FROM git_commits WHERE project_path = ?");
-    projectCountStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getLatestCommitTimeStatement(db) {
-  let stmt = latestCommitTimeStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT MAX(committed_at) AS latest FROM git_commits WHERE project_path = ?");
-    latestCommitTimeStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getEvictOverflowStatement(db) {
-  let stmt = evictOverflowStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`DELETE FROM git_commits
-             WHERE rowid IN (
-                 SELECT rowid FROM git_commits
-                 WHERE project_path = ?
-                 ORDER BY committed_at DESC, sha DESC
-                 LIMIT -1 OFFSET ?
-             )`);
-    evictOverflowStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function upsertCommits(db, projectPath, commits) {
-  if (commits.length === 0)
-    return { inserted: 0, updated: 0 };
-  const existing = new Set;
-  for (const row of getExistingShasStatement(db).all(projectPath)) {
-    existing.add(row.sha);
-  }
-  let inserted = 0;
-  let updated = 0;
-  const now = Date.now();
-  const insertStmt = getInsertStatement(db);
-  db.transaction(() => {
-    for (const commit of commits) {
-      const result = insertStmt.run(commit.sha, projectPath, commit.shortSha, commit.message, commit.author, commit.committedAtMs, now);
-      if (result.changes > 0) {
-        if (existing.has(commit.sha)) {
-          updated++;
-        } else {
-          inserted++;
-          existing.add(commit.sha);
-        }
-      }
-    }
-  })();
-  return { inserted, updated };
-}
-function getCommitCount(db, projectPath) {
-  const row = getProjectCountStatement(db).get(projectPath);
-  return row?.count ?? 0;
-}
-function getLatestIndexedCommitTimeMs(db, projectPath) {
-  const row = getLatestCommitTimeStatement(db).get(projectPath);
-  return row?.latest ?? null;
-}
-function enforceProjectCap(db, projectPath, maxCommits) {
-  if (maxCommits <= 0)
-    return 0;
-  const count = getCommitCount(db, projectPath);
-  if (count <= maxCommits)
-    return 0;
-  getEvictOverflowStatement(db).run(projectPath, maxCommits);
-  const after = getCommitCount(db, projectPath);
-  const evicted = Math.max(0, count - after);
-  if (evicted > 0) {
-    log(`[git-commits] evicted ${evicted} oldest commits for project ${projectPath} (cap=${maxCommits}, was=${count})`);
-  }
-  return evicted;
-}
-
 // ../plugin/src/features/magic-context/git-commits/indexer.ts
 var MS_PER_DAY = 24 * 60 * 60 * 1000;
 var EMBED_BATCH_SIZE = 16;
@@ -169817,87 +170037,229 @@ function registerCtxDreamCommand(pi, deps) {
   });
 }
 
-// src/commands/ctx-embed-history.ts
-function registerCtxEmbedHistoryCommand(pi, deps) {
-  pi.registerCommand("ctx-embed-history", {
-    description: "Embed all of this session's history compartments for semantic search, in one pass",
-    handler: async (_args, ctx) => {
+// ../plugin/src/hooks/magic-context/embed-session-state.ts
+var embedPauseBySession = new Set;
+var embedRunStateBySession = new Map;
+var autoEmbedAttemptedBySession = new Set;
+
+// ../plugin/src/hooks/magic-context/format-embed-status.ts
+function formatEmbedStatusText(coverage, drain) {
+  if (!coverage.enabled) {
+    return "Embedding is off (no provider configured).";
+  }
+  const lines = [];
+  lines.push(`Embedding — model: ${coverage.model} (${coverage.provider})`);
+  lines.push(`This session:  ${coverage.session.embedded} / ${coverage.session.total} compartments embedded`);
+  lines.push(`Project memories:  ${coverage.memories.embedded} / ${coverage.memories.total} embedded`);
+  if (coverage.commits.gitEnabled) {
+    lines.push(`Git commits:  ${coverage.commits.embedded} / ${coverage.commits.total}`);
+  } else {
+    lines.push("Git commits:  0 / 0 (git indexing off)");
+  }
+  let drainLine = "Drain: idle";
+  switch (drain.status) {
+    case "running": {
+      const e = drain.embedded ?? coverage.session.embedded;
+      const t = drain.total ?? coverage.session.total;
+      const failedSuffix = drain.failed && drain.failed > 0 ? ` (${drain.failed} failed)` : "";
+      drainLine = `Drain: running ${e}/${t}${failedSuffix}`;
+      break;
+    }
+    case "paused": {
+      const e = drain.embedded ?? coverage.session.embedded;
+      const t = drain.total ?? coverage.session.total;
+      drainLine = `Drain: paused ${e}/${t}`;
+      break;
+    }
+    case "stopped":
+      drainLine = "Drain: stopped (provider down)";
+      break;
+    default:
+      drainLine = "Drain: idle";
+  }
+  lines.push(drainLine);
+  return lines.join(`
+`);
+}
+
+// src/commands/ctx-embed.ts
+function clearPiEmbedSessionState(sessionId) {
+  embedPauseBySession.delete(sessionId);
+  const ctrl = embedRunStateBySession.get(sessionId);
+  if (ctrl) {
+    ctrl.abort();
+    embedRunStateBySession.delete(sessionId);
+  }
+  autoEmbedAttemptedBySession.delete(sessionId);
+}
+async function runEmbedDrain(db, projectIdentity, sessionId) {
+  const activeCtrl = embedRunStateBySession.get(sessionId);
+  if (activeCtrl && !activeCtrl.signal.aborted) {
+    return {
+      text: `## /ctx-embed
+
+Embedding is already running for this session.`,
+      level: "info"
+    };
+  }
+  embedPauseBySession.delete(sessionId);
+  const prior = embedRunStateBySession.get(sessionId);
+  if (prior)
+    prior.abort();
+  const controller = new AbortController;
+  embedRunStateBySession.set(sessionId, controller);
+  let outcome;
+  try {
+    outcome = await embedSessionCompartmentChunks(db, projectIdentity, sessionId, {
+      signal: controller.signal
+    });
+  } finally {
+    if (embedRunStateBySession.get(sessionId) === controller) {
+      embedRunStateBySession.delete(sessionId);
+    }
+  }
+  switch (outcome.status) {
+    case "nothing":
+      return {
+        text: `## /ctx-embed
+
+All of this session's history is already embedded.`,
+        level: "info"
+      };
+    case "disabled":
+      return {
+        text: `## /ctx-embed
+
+No embedding provider is configured, so there is nothing to embed.`,
+        level: "info"
+      };
+    case "busy":
+      return {
+        text: `## /ctx-embed
+
+Embedding is already running for this project. Try again shortly.`,
+        level: "info"
+      };
+    case "aborted": {
+      const cov = getEmbeddingCoverageStatus(db, projectIdentity, sessionId);
+      return {
+        text: `## /ctx-embed
+
+Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
+        level: "info"
+      };
+    }
+    case "stalled":
+      return {
+        text: `## /ctx-embed
+
+Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"}; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed start again to retry them.`,
+        level: "info"
+      };
+    default:
+      return {
+        text: `## /ctx-embed
+
+Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"} of history for semantic search.`,
+        level: "success"
+      };
+  }
+}
+function registerCtxEmbedCommand(pi, deps) {
+  pi.registerCommand("ctx-embed", {
+    description: "Embedding status, or start/pause history compartment embedding (start | pause)",
+    handler: async (args, ctx) => {
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
         sendCtxStatusMessage(pi, {
-          title: "/ctx-embed-history",
-          text: `## /ctx-embed-history
+          title: "/ctx-embed",
+          text: `## /ctx-embed
 
 No active Pi session is available.`,
           level: "error"
         });
         return;
       }
+      const project = deps.resolveProject?.(ctx) ?? {
+        projectDir: deps.projectDir,
+        projectIdentity: deps.projectIdentity
+      };
+      const sub = args.trim().toLowerCase();
+      if (sub === "pause") {
+        embedPauseBySession.add(sessionId);
+        const ctrl = embedRunStateBySession.get(sessionId);
+        if (ctrl)
+          ctrl.abort();
+        const cov = getEmbeddingCoverageStatus(deps.db, project.projectIdentity, sessionId);
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-embed",
+          text: `## /ctx-embed
+
+Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
+          level: "info"
+        });
+        return;
+      }
       if (deps.memoryEnabled === false) {
         sendCtxStatusMessage(pi, {
-          title: "/ctx-embed-history",
-          text: `## /ctx-embed-history
+          title: "/ctx-embed",
+          text: `## /ctx-embed
 
 Memory is disabled for this project, so there is no semantic embedding to backfill.`,
           level: "info"
         });
         return;
       }
-      const project = deps.resolveProject?.(ctx) ?? {
-        projectDir: deps.projectDir,
-        projectIdentity: deps.projectIdentity
-      };
       await ensureProjectRegisteredFromPiDirectory(project.projectDir, deps.db);
-      const outcome = await embedSessionCompartmentChunks(deps.db, project.projectIdentity, sessionId);
-      const { text, level } = (() => {
-        switch (outcome.status) {
-          case "nothing":
-            return {
-              text: `## /ctx-embed-history
-
-All of this session's history is already embedded.`,
-              level: "info"
-            };
-          case "disabled":
-            return {
-              text: `## /ctx-embed-history
-
-No embedding provider is configured, so there is nothing to embed.`,
-              level: "info"
-            };
-          case "busy":
-            return {
-              text: `## /ctx-embed-history
-
-Embedding is already running for this project — ${outcome.total} compartment${outcome.total === 1 ? "" : "s"} still pending. Try again shortly.`,
-              level: "info"
-            };
-          case "stalled":
-            return {
-              text: `## /ctx-embed-history
-
-Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"}; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed-history again to retry them.`,
-              level: "info"
-            };
-          default:
-            return {
-              text: `## /ctx-embed-history
+      if (sub === "start") {
+        const { text, level } = await runEmbedDrain(deps.db, project.projectIdentity, sessionId);
+        sendCtxStatusMessage(pi, { title: "/ctx-embed", text, level });
+        return;
+      }
+      if (sub !== "") {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-embed",
+          text: "## /ctx-embed\n\nUsage: `/ctx-embed` (status), `/ctx-embed start`, or `/ctx-embed pause`.",
+          level: "info"
+        });
+        return;
+      }
+      const coverage = getEmbeddingCoverageStatus(deps.db, project.projectIdentity, sessionId);
+      const statusText = formatEmbedStatusText(coverage, { status: "idle" });
+      sendCtxStatusMessage(pi, {
+        title: "/ctx-embed",
+        text: `## Embedding Status
 
-Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"} of history for semantic search.`,
-              level: "success"
-            };
-        }
-      })();
-      sendCtxStatusMessage(pi, { title: "/ctx-embed-history", text, level }, {
-        sessionId,
-        projectIdentity: project.projectIdentity,
-        status: outcome.status,
-        embedded: outcome.embedded,
-        total: outcome.total
+${statusText}`,
+        level: "info"
       });
     }
   });
 }
+function maybeAutoEmbedPiSession(deps, sessionId, projectDir, projectIdentity, notify) {
+  if (autoEmbedAttemptedBySession.has(sessionId))
+    return;
+  if (embedPauseBySession.has(sessionId))
+    return;
+  if (deps.memoryEnabled === false)
+    return;
+  autoEmbedAttemptedBySession.add(sessionId);
+  (async () => {
+    try {
+      await new Promise((resolve5) => setTimeout(resolve5, 0));
+      await ensureProjectRegisteredFromPiDirectory(projectDir, deps.db);
+      const coverage = getEmbeddingCoverageStatus(deps.db, projectIdentity, sessionId);
+      if (!coverage.enabled)
+        return;
+      const remaining = coverage.session.total - coverage.session.embedded;
+      if (remaining <= 0)
+        return;
+      notify(`Embedding ${remaining} compartment${remaining === 1 ? "" : "s"} of history in the background…`);
+      const { text } = await runEmbedDrain(deps.db, projectIdentity, sessionId);
+      notify(text.replace(/^## \/ctx-embed\n\n/, ""));
+    } catch {}
+  })();
+}
 
 // ../plugin/src/hooks/magic-context/execute-flush.ts
 init_logger();
@@ -170313,26 +170675,11 @@ function computePiWorkMetrics(sessionEntries) {
 }
 
 // ../plugin/src/hooks/magic-context/apply-operations.ts
-var USER_DROP_PREVIEW_CHARS = 250;
 var RECENT_TOOL_SKELETON_WINDOW = 20;
-function buildReplacementContent(tagId, target) {
-  const role = target.message?.info.role;
-  if (role !== "user") {
-    return `[dropped §${tagId}§]`;
-  }
-  const currentContent = target.getContent?.() ?? "";
-  const originalText = stripTagPrefix(currentContent);
-  if (originalText.length <= USER_DROP_PREVIEW_CHARS) {
-    return `[truncated §${tagId}§]
-${originalText}`;
-  }
-  const hardCut = originalText.slice(0, USER_DROP_PREVIEW_CHARS);
-  const softCutIndex = hardCut.search(/\s\S*$/);
-  const preview = softCutIndex > USER_DROP_PREVIEW_CHARS - 30 ? hardCut.slice(0, softCutIndex) : hardCut;
-  return `[truncated §${tagId}§]
-${preview}…`;
-}
-function applyPendingOperations(sessionId, db, targets, protectedTags = 0, preloadedTags, preloadedPendingOps) {
+function buildReplacementContent(tagId) {
+  return `[dropped §${tagId}§]`;
+}
+function applyPendingOperations(sessionId, db, targets, protectedTags = 0, preloadedTags, preloadedPendingOps, syntheticPendingOps = []) {
   let didMutateMessage = false;
   db.transaction(() => {
     const tags = preloadedTags ?? getTagsBySession(db, sessionId);
@@ -170340,11 +170687,16 @@ function applyPendingOperations(sessionId, db, targets, protectedTags = 0, prelo
     const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
     const protectedTagIds = protectedTags > 0 ? new Set(tags.filter((tag) => tag.status === "active").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, protectedTags)) : new Set;
     const pendingOps = preloadedPendingOps ?? getPendingOps(db, sessionId);
+    const opsToApply = [
+      ...pendingOps.map((op) => ({ op, synthetic: false })),
+      ...syntheticPendingOps.map((op) => ({ op, synthetic: true }))
+    ];
     const skeletonWindow = new Set(tags.filter((tag) => tag.type === "tool").map((tag) => tag.tagNumber).sort((left, right) => right - left).slice(0, RECENT_TOOL_SKELETON_WINDOW));
-    for (const pendingOp of pendingOps) {
+    for (const { op: pendingOp, synthetic } of opsToApply) {
       const tagStatus = tagStatusById.get(pendingOp.tagId);
       if (tagStatus === "compacted" || tagStatus === "dropped") {
-        removePendingOp(db, sessionId, pendingOp.tagId);
+        if (!synthetic)
+          removePendingOp(db, sessionId, pendingOp.tagId);
         continue;
       }
       if (protectedTagIds.has(pendingOp.tagId)) {
@@ -170352,33 +170704,46 @@ function applyPendingOperations(sessionId, db, targets, protectedTags = 0, prelo
       }
       const target = targets.get(pendingOp.tagId);
       const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
+      if (synthetic) {
+        if (!isToolTag || target?.canDrop?.() !== true)
+          continue;
+      }
+      let shouldPersistDrop = false;
       if (isToolTag) {
         if (skeletonWindow.has(pendingOp.tagId)) {
           const truncResult = target?.truncate?.() ?? "absent";
-          if (truncResult === "incomplete") {
+          if (truncResult === "incomplete" || synthetic && truncResult !== "truncated") {
             continue;
           }
           if (truncResult === "truncated") {
             didMutateMessage = true;
           }
           updateTagDropMode(db, sessionId, pendingOp.tagId, "truncated");
+          shouldPersistDrop = true;
         } else {
           const dropResult = target?.drop?.() ?? "absent";
-          if (dropResult === "incomplete") {
+          if (dropResult === "incomplete" || synthetic && dropResult !== "removed") {
             continue;
           }
           if (dropResult === "removed") {
             didMutateMessage = true;
           }
           updateTagDropMode(db, sessionId, pendingOp.tagId, "full");
+          shouldPersistDrop = true;
         }
       } else if (target) {
-        const changed = target.setContent(buildReplacementContent(pendingOp.tagId, target));
+        const changed = target.setContent(buildReplacementContent(pendingOp.tagId));
         if (changed)
           didMutateMessage = true;
+        shouldPersistDrop = true;
+      } else if (!synthetic) {
+        shouldPersistDrop = true;
       }
+      if (!shouldPersistDrop)
+        continue;
       updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
-      removePendingOp(db, sessionId, pendingOp.tagId);
+      if (!synthetic)
+        removePendingOp(db, sessionId, pendingOp.tagId);
     }
   })();
   return didMutateMessage;
@@ -170402,7 +170767,7 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
           }
         }
       } else if (target) {
-        const changed = target.setContent(buildReplacementContent(tag.tagNumber, target));
+        const changed = target.setContent(buildReplacementContent(tag.tagNumber));
         if (changed)
           didMutateMessage = true;
       }
@@ -170690,7 +171055,8 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config2) {
   const result = {
     compressedToLite: 0,
     compressedToFull: 0,
-    compressedToUltra: 0
+    compressedToUltra: 0,
+    mutatedTextTags: 0
   };
   if (!config2.enabled)
     return result;
@@ -170731,7 +171097,9 @@ function applyCavemanCleanup(sessionId, db, targets, tags, config2) {
       const target = targets.get(tag.tagNumber);
       if (!target)
         continue;
-      target.setContent(compressed);
+      const didMutate = target.setContent(compressed);
+      if (didMutate)
+        result.mutatedTextTags += 1;
       updateCavemanDepth(db, sessionId, tag.tagNumber, targetDepth);
       if (targetDepth === DEPTH_LITE)
         result.compressedToLite += 1;
@@ -171109,7 +171477,7 @@ function buildToolArcs(messages) {
   }
   return arcs.sort((a, b) => a.invOrdinal - b.invOrdinal || (a.resOrdinal ?? Number.MAX_SAFE_INTEGER) - (b.resOrdinal ?? Number.MAX_SAFE_INTEGER));
 }
-function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal) {
+function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal, recentOpenArcCutoff) {
   let boundary = candidate;
   for (const arc of arcs) {
     if (arc.resOrdinal !== null) {
@@ -171118,6 +171486,8 @@ function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal) {
       }
       continue;
     }
+    if (arc.invOrdinal < recentOpenArcCutoff)
+      continue;
     if (arc.invOrdinal >= lastCompartmentEndOrdinal + 1 && arc.invOrdinal < boundary) {
       return arc.invOrdinal;
     }
@@ -171355,7 +171725,7 @@ function semanticSnapBoundary(args) {
   return snapped;
 }
 function applyHeadCap(args) {
-  const { index, protectedTailStart, offset, arcs, capTokens } = args;
+  const { index, protectedTailStart, offset, arcs, capTokens, recentOpenArcCutoff } = args;
   if (offset >= protectedTailStart)
     return { eligibleEndOrdinal: offset, oversizeAtomicUnit: false };
   let end = index.findHeadEndForCap(offset, protectedTailStart, capTokens);
@@ -171363,7 +171733,7 @@ function applyHeadCap(args) {
   for (const arc of arcs) {
     const resOrdinal = arc.resOrdinal;
     if (resOrdinal === null) {
-      if (arc.invOrdinal >= offset && arc.invOrdinal < end) {
+      if (arc.invOrdinal >= recentOpenArcCutoff && arc.invOrdinal >= offset && arc.invOrdinal < end) {
         end = Math.min(end, arc.invOrdinal);
       }
       continue;
@@ -171430,7 +171800,14 @@ function resolveProtectedTailBoundary(ctx) {
   }
   if (ctx.mode === "manual-full-recomp") {
     const arcs2 = buildToolArcs(messages);
-    const firstOpenArc = arcs2.find((arc) => arc.resOrdinal === null && arc.invOrdinal >= offset);
+    const recompTarget = deriveProtectedTailTokenTarget({
+      contextLimit: ctx.contextLimit,
+      executeThresholdPercentage: ctx.executeThresholdPercentage,
+      usagePercentage: 0,
+      triggerBudget: ctx.triggerBudget
+    });
+    const recentOpenArcCutoff2 = index.findSuffixStartForTokens(recompTarget.N);
+    const firstOpenArc = arcs2.find((arc) => arc.resOrdinal === null && arc.invOrdinal >= offset && arc.invOrdinal >= recentOpenArcCutoff2);
     const protectedTailStart2 = firstOpenArc?.invOrdinal ?? rawMessageCount + 1;
     const rawRangeFingerprint2 = computeRawRangeFingerprint(messages, offset, protectedTailStart2);
     return {
@@ -171472,13 +171849,14 @@ function resolveProtectedTailBoundary(ctx) {
   const scaledN = ctx.emergencyTailScale ? Math.max(1, Math.floor(target.N * ctx.emergencyTailScale)) : target.N;
   const arcs = buildToolArcs(messages);
   let boundary = index.findSuffixStartForTokens(scaledN);
+  const recentOpenArcCutoff = boundary;
   let boundaryReason = boundary === 1 ? "whole-session-smaller-than-tail" : "size-walk";
   const tokenAtBoundary = index.tokenForOrdinal(boundary);
   if (boundary <= rawMessageCount && tokenAtBoundary > Math.max(2 * scaledN, 64000) && boundary < rawMessageCount) {
     boundary += 1;
     boundaryReason = "huge-message-exception";
   }
-  boundary = fenceBoundaryForToolArcs(boundary, arcs, ctx.lastCompartmentEndOrdinal);
+  boundary = fenceBoundaryForToolArcs(boundary, arcs, ctx.lastCompartmentEndOrdinal, recentOpenArcCutoff);
   const snapped = semanticSnapBoundary({
     messages,
     index,
@@ -171488,7 +171866,7 @@ function resolveProtectedTailBoundary(ctx) {
   });
   if (snapped !== boundary)
     boundaryReason = "semantic-snap";
-  boundary = fenceBoundaryForToolArcs(snapped, arcs, ctx.lastCompartmentEndOrdinal);
+  boundary = fenceBoundaryForToolArcs(snapped, arcs, ctx.lastCompartmentEndOrdinal, recentOpenArcCutoff);
   let runtimeFloor = offset;
   if (ctx.migrationFloorActive)
     runtimeFloor = Math.max(runtimeFloor, ctx.priorBoundaryOrdinal);
@@ -171524,7 +171902,8 @@ function resolveProtectedTailBoundary(ctx) {
     offset,
     arcs,
     lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal,
-    capTokens: perRunCap
+    capTokens: perRunCap,
+    recentOpenArcCutoff
   });
   const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, head.eligibleEndOrdinal);
   return {
@@ -171929,8 +172308,8 @@ var CHANNEL1_SENTINEL = "<system-reminder>";
 var TOKENS_PER_BYTE = 0.25;
 var CHANNEL1_FLOOR_TOKENS = 1e4;
 var CHANNEL1_REFIRE_FLOOR_TOKENS = 1e4;
-function channel1RefireTokens(historyBudgetTokens) {
-  const scaled = Math.round(0.05 * Math.max(0, historyBudgetTokens));
+function channel1RefireTokens(workingWindowTokens) {
+  const scaled = Math.round(0.05 * Math.max(0, workingWindowTokens));
   return Math.max(CHANNEL1_REFIRE_FLOOR_TOKENS, scaled);
 }
 var S_GENTLE = 0.2;
@@ -171946,7 +172325,7 @@ function toolOutputTokens(output) {
   return Math.round(byteSize(output) * TOKENS_PER_BYTE);
 }
 function decideChannel1(input) {
-  const { undroppedTokens, pressure, historyBudgetTokens, hasRecentReduce } = input;
+  const { undroppedTokens, pressure, workingWindowTokens, hasRecentReduce } = input;
   const resetCycle = hasRecentReduce || undroppedTokens < input.lastNudgeUndropped;
   const lastNudge = resetCycle ? 0 : input.lastNudgeUndropped;
   const lastLevel = resetCycle ? "" : input.lastNudgeLevel;
@@ -171961,7 +172340,7 @@ function decideChannel1(input) {
     return quiet();
   if (undroppedTokens < CHANNEL1_FLOOR_TOKENS)
     return quiet();
-  const budget = historyBudgetTokens > 0 ? historyBudgetTokens : undroppedTokens || 1;
+  const budget = workingWindowTokens > 0 ? workingWindowTokens : undroppedTokens || 1;
   const severity = undroppedTokens / budget * pressure;
   if (severity < S_GENTLE)
     return quiet();
@@ -171973,7 +172352,7 @@ function decideChannel1(input) {
   else
     level = "gentle";
   if (lastLevel === "") {
-    if (undroppedTokens < lastNudge + channel1RefireTokens(historyBudgetTokens)) {
+    if (undroppedTokens < lastNudge + channel1RefireTokens(workingWindowTokens)) {
       return quiet();
     }
   } else if (LEVEL_RANK[level] <= LEVEL_RANK[lastLevel]) {
@@ -171998,6 +172377,13 @@ function computePressure(input) {
 function approxThousands(tokens) {
   return `${Math.round(tokens / 1000)}k`;
 }
+function formatOldestReclaimableHint(hint) {
+  if (!hint || hint.length === 0)
+    return "";
+  const rendered = hint.slice(0, 4).map((tag) => `§${tag.tagNumber}§ ${tag.toolName ?? "tool"}`).join(" · ");
+  return rendered.length > 0 ? `
+oldest reclaimable: ${rendered}.` : "";
+}
 var CHANNEL2_USABLE_FRACTION = 1 / 3;
 var CHANNEL2_MIN_RECLAIMABLE = 1e4;
 function shouldTriggerChannel2(input) {
@@ -172007,30 +172393,32 @@ function shouldTriggerChannel2(input) {
     return true;
   return input.reclaimableTokens >= input.usableTokens * CHANNEL2_USABLE_FRACTION;
 }
-function buildChannel2Reminder(undroppedTokens) {
+function buildChannel2Reminder(undroppedTokens, hint) {
   const amount = approxThousands(undroppedTokens);
+  const hintText = formatOldestReclaimableHint(hint);
   return `<system-reminder>
-` + `Routine context housekeeping is near: a large span of this session will be comparted soon, ` + `and ~${amount} tokens of tool output remain unreduced. Drop spent outputs with ctx_reduce ` + `first so the archived span is the part that matters.
+` + `Routine context housekeeping is near: a large span of this session will be comparted soon, ` + `and ~${amount} tokens of tool output remain unreduced. Drop spent outputs with ctx_reduce ` + `first so the archived span is the part that matters.${hintText}
 ` + `</system-reminder>`;
 }
-function buildChannel1Reminder(level, undroppedTokens) {
+function buildChannel1Reminder(level, undroppedTokens, hint) {
   const amount = approxThousands(undroppedTokens);
+  const hintText = formatOldestReclaimableHint(hint);
   let body;
   switch (level) {
     case "gentle":
-      body = `You have ~${amount} tokens of tool output you have not reduced. ` + `Once you are done with earlier outputs, drop them with ctx_reduce to keep context lean.`;
+      body = `You have ~${amount} tokens of tool output you have not reduced. ` + `When you are done with earlier outputs, dropping them with ctx_reduce keeps context lean.`;
       break;
     case "firm":
-      body = `~${amount} tokens of unreduced tool output is accumulating. ` + `Drop what you have already processed with ctx_reduce before continuing.`;
+      body = `~${amount} tokens of unreduced tool output has built up. ` + `At your next natural stopping point, consider dropping what you have already processed with ctx_reduce.`;
       break;
     case "urgent":
-      body = `~${amount} tokens of unreduced tool output remain. ` + `A large span of this session will be comparted soon; drop spent outputs with ctx_reduce first so the archived span is the part that matters.`;
+      body = `~${amount} tokens of unreduced tool output remain, and a large span of this session will be comparted before long. ` + `Consider dropping spent outputs with ctx_reduce so the archived span is the part that matters.`;
       break;
   }
   return `
 
 <system-reminder>
-${body}
+${body}${hintText}
 </system-reminder>`;
 }
 
@@ -172578,6 +172966,41 @@ function renderMemoryBlockV2(memories, wrapper = "project-memory", renderOptions
 `);
 }
 
+// ../plugin/src/hooks/magic-context/tool-reclaim.ts
+function buildSyntheticToolReclaimOps(input) {
+  const watermark = Math.max(0, input.watermark);
+  if (watermark <= 0)
+    return [];
+  const realPendingTagIds = new Set((input.pendingOps ?? []).map((op) => op.tagId));
+  const tags = getActiveTagsBySession(input.db, input.sessionId);
+  const synthetic = [];
+  for (const tag of tags) {
+    if (tag.type !== "tool")
+      continue;
+    if (tag.status !== "active")
+      continue;
+    if (tag.tagNumber > watermark)
+      continue;
+    if (realPendingTagIds.has(tag.tagNumber))
+      continue;
+    if (input.targets.get(tag.tagNumber)?.canDrop?.() !== true)
+      continue;
+    synthetic.push({
+      id: 0,
+      sessionId: input.sessionId,
+      tagId: tag.tagNumber,
+      operation: "drop",
+      queuedAt: 0
+    });
+  }
+  return synthetic;
+}
+function advanceToolReclaimWatermarkToCurrentMax(db, sessionId) {
+  const maxTagNumber = getMaxTagNumberBySession(db, sessionId);
+  advanceToolReclaimWatermark(db, sessionId, maxTagNumber);
+  return maxTagNumber;
+}
+
 // src/context-handler.ts
 init_logger();
 
@@ -172988,7 +173411,7 @@ function tagToolPart(args) {
     const tagged = prependTag(tagId, text);
     args.part.setText(tagged);
   }
-  args.targets.set(tagId, buildToolTarget(args.part, args.message));
+  args.targets.set(tagId, buildToolTarget(args.part, args.message, tagId));
 }
 function setToolContentOrText(part, content) {
   try {
@@ -173028,7 +173451,7 @@ function buildAggregateTarget(tagId, occurrences) {
       return any2 ? "removed" : "absent";
     },
     truncate() {
-      const sentinel = "[truncated]";
+      const sentinel = `[dropped §${tagId}§]`;
       let any2 = false;
       for (const occ of occurrences) {
         if (setToolContentOrText(occ.part, sentinel)) {
@@ -173060,7 +173483,7 @@ function buildTextTarget(part, message) {
     }
   };
 }
-function buildToolTarget(part, message) {
+function buildToolTarget(part, message, tagId) {
   return {
     setContent(content) {
       return setToolContentOrText(part, content);
@@ -173069,11 +173492,11 @@ function buildToolTarget(part, message) {
       return part.getText() ?? null;
     },
     drop() {
-      const replaced = part.replaceWithSentinel(`[dropped §${part.id ?? "?"}§]`);
+      const replaced = part.replaceWithSentinel(`[dropped §${tagId}§]`);
       return replaced ? "removed" : "absent";
     },
     truncate() {
-      const ok = setToolContentOrText(part, "[truncated]");
+      const ok = setToolContentOrText(part, `[dropped §${tagId}§]`);
       return ok ? "truncated" : "absent";
     },
     message: {
@@ -174343,10 +174766,11 @@ function maybeChannel1ReminderForToolResult(args) {
     contextLimit: state.contextLimit,
     executeThresholdPercentage: state.executeThresholdPercentage
   });
+  const workingWindowTokens = Math.round(state.contextLimit * state.executeThresholdPercentage / 100);
   const decision = decideChannel1({
     undroppedTokens,
     pressure,
-    historyBudgetTokens: state.historyBudgetTokens,
+    workingWindowTokens,
     lastNudgeUndropped: getLastNudgeUndropped(db, sessionId),
     lastNudgeLevel: getLastNudgeLevel(db, sessionId),
     hasRecentReduce: false
@@ -174357,9 +174781,10 @@ function maybeChannel1ReminderForToolResult(args) {
     return null;
   return {
     type: "text",
-    text: buildChannel1Reminder(decision.level, decision.undroppedTokens)
+    text: buildChannel1Reminder(decision.level, decision.undroppedTokens, state.oldestReclaimableToolTags)
   };
 }
+var CHANNEL2_NUDGE_CUSTOM_TYPE = "magic-context:ceiling-nudge";
 function maybeDeliverChannel2Pi(pi, db, sessionId, deliverAs = "followUp") {
   let state;
   try {
@@ -174387,9 +174812,12 @@ function maybeDeliverChannel2Pi(pi, db, sessionId, deliverAs = "followUp") {
   if (!casChannel2NudgeState(db, sessionId, "pending", "claimed"))
     return false;
   try {
-    pi.sendUserMessage(buildChannel2Reminder(undropped), {
-      deliverAs
-    });
+    pi.sendMessage({
+      customType: CHANNEL2_NUDGE_CUSTOM_TYPE,
+      content: buildChannel2Reminder(undropped, baseline.oldestReclaimableToolTags),
+      display: false,
+      details: { kind: "channel-2-ceiling-nudge" }
+    }, { deliverAs });
   } catch (error51) {
     try {
       casChannel2NudgeState(db, sessionId, "claimed", "pending");
@@ -174784,10 +175212,14 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, pr
         if (!matched)
           continue;
         const target = targets.get(tag.tagNumber);
-        target?.drop?.();
+        const result = target?.drop?.() ?? "absent";
+        if (result === "incomplete")
+          continue;
         updateTagDropMode(db, sessionId, tag.tagNumber, "full");
         updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-        droppedStaleReduceCalls++;
+        if (result === "removed" || result === "truncated") {
+          droppedStaleReduceCalls++;
+        }
       }
     })();
   }
@@ -174859,7 +175291,9 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, pr
             continue;
           updateTagDropMode(db, sessionId, tag.tagNumber, "full");
           updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
-          deduplicatedTools++;
+          if (result === "removed" || result === "truncated") {
+            deduplicatedTools++;
+          }
         }
       }
     })();
@@ -174868,6 +175302,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, pr
     sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, stale ctx_reduce=${droppedStaleReduceCalls}, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
   }
   let compressedTextTags = 0;
+  let mutatedTextTags = 0;
   if (config2.caveman?.enabled) {
     const cavemanResult = applyCavemanCleanup(sessionId, db, targets, tags, {
       enabled: true,
@@ -174875,13 +175310,15 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, pr
       protectedTags: config2.protectedTags
     });
     compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
+    mutatedTextTags = cavemanResult.mutatedTextTags;
   }
   return {
     droppedTools,
     deduplicatedTools,
     droppedInjections,
     droppedStaleReduceCalls,
-    compressedTextTags
+    compressedTextTags,
+    mutatedTextTags
   };
 }
 function buildMessageIdToMaxTagFromTargets(targets) {
@@ -180258,9 +180695,7 @@ Context is managed for you entirely automatically — there's nothing to prune a
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
 var BASE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
-Use \`ctx_reduce\` to manage context size. It supports one operation:
-- \`drop\`: Remove entirely (best for tool outputs you already acted on).
-Syntax: "3-5", "1,2,9", or "1-5,8,12-15". Last ${protectedTags} tags are protected.
+Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. Marking is NOT an immediate delete — it queues the content, which stays fully visible until space is actually needed (as soon as the next turn if you're already under pressure, much later if not), so mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The last ${protectedTags} tags are protected (marking one just queues it until it ages out). Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
 Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
 ${CTX_NOTE_GUIDANCE}
 Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
@@ -180279,7 +180714,7 @@ Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` su
 \`ctx_search\` returns ranked results from memories, git commits, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
 ${TOOL_HISTORY_GUIDANCE}
 NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.
-NEVER drop user messages — they are short and will be summarized by compartmentalization automatically. Dropping them loses context the historian needs.
+Keep your user's instructions and intent — never drop a user message for its directive, even an old one. But a large block of pasted content inside a user message (logs, data dumps, long code, attachments) is fair to mark discardable once you've extracted what you need — it stays searchable via \`ctx_search\`.
 NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
 var BASE_INTRO_NO_REDUCE = () => `${CTX_NOTE_GUIDANCE}
@@ -181745,7 +182180,7 @@ function registerPiContextHandler(pi, baseOptions) {
           let tailToolTokens;
           let liveTailTokens;
           try {
-            const agg = getActiveTagTokenAggregate(options.db, sessionId);
+            const agg = getActiveTagTokenAggregate(options.db, sessionId, options.protectedTags ?? 20);
             tailToolTokens = agg.toolOutput;
             liveTailTokens = agg.conversation + agg.toolCall;
           } catch {
@@ -181756,6 +182191,7 @@ function registerPiContextHandler(pi, baseOptions) {
           const executeThresholdTokensPi = Math.round((usageContextLimit ?? 0) * resolvedExecuteThresholdPct / 100);
           const usableTokensPi = Math.max(0, executeThresholdTokensPi - usageInputTokens + liveTailTokens);
           resetLastNudgeCycleIfTailShrank(options.db, sessionId, tailToolTokens);
+          const oldestReclaimableToolTags = getOldestActiveUnprotectedToolTags(options.db, sessionId, options.protectedTags ?? 20);
           setPiChannel1Baseline(sessionId, {
             tailToolTokens,
             historyBudgetTokens: historyBudgetTokens ?? 0,
@@ -181764,7 +182200,8 @@ function registerPiContextHandler(pi, baseOptions) {
             lastInputTokens: usageInputTokens,
             turnToolTokens: 0,
             usableTokens: usableTokensPi,
-            reducedSinceRefresh: false
+            reducedSinceRefresh: false,
+            oldestReclaimableToolTags
           });
           if (usageContextLimit && usageContextLimit > 0 && resolvedExecuteThresholdPct > 0) {
             const channel2ShouldTrigger = shouldTriggerChannel2({
@@ -181792,6 +182229,7 @@ function registerPiContextHandler(pi, baseOptions) {
       logTransformTiming(sessionId, "postTransformPhase", tPostTransform);
       sessionLog(sessionId, `transform completed in ${(performance.now() - transformStartTime).toFixed(1)}ms (${outputMessages.length} messages, ${result.targetCount} targets, watermark: ${result.reasoningWatermark})`);
       clearLastTransformErrorIfSet(options.db, sessionId);
+      options.maybeAutoEmbedSession?.(sessionId, projectDirectory, projectIdentity);
       return { messages: outputMessages };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -182098,6 +182536,15 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
     const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.clearReasoningAge, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit);
     if (!trigger.shouldFire) {
       sessionLog(sessionId, `historian trigger eval: shouldFire=false (no trigger condition met)`);
+      try {
+        const overflowState = getOverflowState(db, sessionId);
+        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && !hasRunnableCompartmentWindow(boundarySnapshot)) {
+          clearEmergencyRecovery(db, sessionId);
+          sessionLog(sessionId, `historian: disarming stale emergency recovery — real pressure ${usage.percentage.toFixed(1)}% with no runnable compartment window (would otherwise bump to 95% every pass)`);
+        }
+      } catch (err) {
+        sessionLog(sessionId, `historian: emergency-recovery disarm check failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
       return;
     }
     triggered = true;
@@ -182129,6 +182576,8 @@ async function runPipeline(args) {
   let historyWasConsumedThisPass = false;
   let materializationSatisfiedThisPass = false;
   let pendingOpsAppliedThisPass = false;
+  let pendingOpsDidMutate = false;
+  let heuristicOrReasoningDidMutate = false;
   let suppressDeferredHistoryDrain = false;
   let casLost = false;
   const deferredHistoryWasPendingAtPassStart = deferredHistoryRefreshSessions.has(args.sessionId);
@@ -182214,7 +182663,7 @@ async function runPipeline(args) {
     sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
     try {
       const tApplyPending = performance.now();
-      applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, undefined, pendingOps);
+      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, undefined, pendingOps);
       logTransformTiming(args.sessionId, "applyPendingOperations", tApplyPending);
       executedWorkThisPass = true;
       materializationSatisfiedThisPass = true;
@@ -182298,6 +182747,9 @@ async function runPipeline(args) {
         } : undefined,
         caveman: args.heuristics.caveman
       }, activeTags, stableIdResolver);
+      const heuristicMutationCount = heuristicsResult.droppedTools + heuristicsResult.deduplicatedTools + heuristicsResult.droppedInjections + heuristicsResult.droppedStaleReduceCalls + heuristicsResult.mutatedTextTags;
+      if (heuristicMutationCount > 0)
+        heuristicOrReasoningDidMutate = true;
       heuristicsExecuted = true;
       executedWorkThisPass = true;
       if (hasPendingMaterializeSignal) {
@@ -182306,7 +182758,7 @@ async function runPipeline(args) {
       if (currentTurnId !== null) {
         lastHeuristicsTurnIdBySession.set(args.sessionId, currentTurnId);
       }
-      logTransformTiming(args.sessionId, "applyHeuristicCleanup", tHeuristic, `droppedTools=${heuristicsResult.droppedTools} deduplicatedTools=${heuristicsResult.deduplicatedTools} droppedInjections=${heuristicsResult.droppedInjections} compressedTextTags=${heuristicsResult.compressedTextTags}`);
+      logTransformTiming(args.sessionId, "applyHeuristicCleanup", tHeuristic, `droppedTools=${heuristicsResult.droppedTools} deduplicatedTools=${heuristicsResult.deduplicatedTools} droppedInjections=${heuristicsResult.droppedInjections} staleReduce=${heuristicsResult.droppedStaleReduceCalls} compressedTextTags=${heuristicsResult.compressedTextTags} mutatedTextTags=${heuristicsResult.mutatedTextTags}`);
     } catch (err) {
       sessionLog(args.sessionId, `heuristic cleanup failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -182343,6 +182795,9 @@ async function runPipeline(args) {
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", tClearReasoning);
       logTransformTiming(args.sessionId, "watermarkCleanup", tClearReasoning);
+      if (clearOutcome.cleared > 0 || stripOutcome.stripped > 0) {
+        heuristicOrReasoningDidMutate = true;
+      }
       if (combinedWatermark > prevWatermark || clearOutcome.cleared > 0 || stripOutcome.stripped > 0) {
         executedWorkThisPass = true;
       }
@@ -182350,7 +182805,32 @@ async function runPipeline(args) {
       sessionLog(args.sessionId, `reasoning clearing failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  const toolReclaimExecutePass = args.schedulerDecision === "execute";
+  const alreadyMutatingThisPass = pendingOpsDidMutate || heuristicOrReasoningDidMutate;
+  const emergencyDropEligible = args.forceMaterialization === true || args.contextUsage.percentage >= FORCE_MATERIALIZATION_PERCENTAGE;
+  let autoReclaimTargetCount = 0;
+  let autoReclaimDidMutate = false;
+  if (toolReclaimExecutePass && alreadyMutatingThisPass && !emergencyDropEligible) {
+    const reclaimMeta = getOrCreateSessionMeta(args.db, args.sessionId);
+    const syntheticPendingOps = buildSyntheticToolReclaimOps({
+      db: args.db,
+      sessionId: args.sessionId,
+      targets,
+      watermark: reclaimMeta.toolReclaimWatermark ?? 0,
+      pendingOps
+    });
+    autoReclaimTargetCount = syntheticPendingOps.length;
+    if (syntheticPendingOps.length > 0) {
+      autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.protectedTags, undefined, [], syntheticPendingOps);
+    }
+  }
   transcript.commit();
+  if (toolReclaimExecutePass) {
+    advanceToolReclaimWatermarkToCurrentMax(args.db, args.sessionId);
+  }
+  if (autoReclaimTargetCount > 0) {
+    sessionLog(args.sessionId, `tool reclaim auto-drop: targets=${autoReclaimTargetCount} mutated=${autoReclaimDidMutate}`);
+  }
   const postCommitStableIdByRef = new Map;
   const postCommitEntryIdByRef = new Map;
   for (let i = 0;i < args.messages.length; i++) {
@@ -182634,6 +183114,7 @@ function clearContextHandlerSession(sessionId) {
     rawMessageProviderUnregistersBySession.delete(sessionId);
   }
   clearSessionTracking(sessionId);
+  clearPiEmbedSessionState(sessionId);
 }
 
 // src/commands/ctx-flush.ts
@@ -184478,6 +184959,11 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
             fallbackModelId: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined
           }, parsed.kind === "partial" ? { range: parsed.range } : {});
           if (result.published) {
+            try {
+              clearEmergencyRecovery(deps.db, sessionId);
+            } catch (recoveryError) {
+              sessionLog(sessionId, `/ctx-recomp: clearEmergencyRecovery failed (continuing): ${describeError(recoveryError).brief}`);
+            }
             try {
               stagePiRecompMarker({ db: deps.db, sessionId, ctx });
             } catch (markerError) {
@@ -185131,7 +185617,7 @@ function formatThresholdPercent(value) {
 // package.json
 var package_default = {
   name: "@wolfx/pi-magic-context",
-  version: "0.24.0",
+  version: "0.25.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -185185,8 +185671,8 @@ var package_default = {
     typescript: "^5.8.0"
   },
   peerDependencies: {
-    "@earendil-works/pi-coding-agent": "^0.74.0",
-    "@earendil-works/pi-tui": "^0.74.0"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   exports: {
     ".": {
@@ -185771,9 +186257,184 @@ Older parts of this session are summarized into <compartment> blocks inside <ses
 
 ctx_expand(start=120, end=245)  ← the compartment's own start/end attributes
 
-Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results — expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail — already visible in context, not expandable.`;
+Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results — expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail — already visible in context, not expandable.
+
+Two recovery modes for finer detail:
+- ctx_expand(start=120, end=245, verbose=true) — lists each message SEPARATELY with its ordinal [N] and a per-part preview (each tool call shown with its output size). Use this to find the exact message or tool call you want, then recover it in full by ordinal.
+- ctx_expand(message=138) — returns the FULL untruncated content of the message at that ordinal: every text part, and every tool call's complete input + output, read from stored history. This is the cheap way to get back a tool output you dropped with ctx_reduce — the original is still in storage even though the wire shows [dropped §N§]. If the message was deleted from history (session prune/revert), it says so.`;
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
 
+// ../plugin/src/tools/ctx-expand/render.ts
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function roleLabel(role) {
+  if (role === "assistant")
+    return "A (assistant)";
+  if (role === "user")
+    return "U (user)";
+  return role;
+}
+function truncate2(value, max) {
+  const t = value.trim();
+  return t.length <= max ? t : `${t.slice(0, max)}…`;
+}
+function keyArg(input) {
+  if (!input)
+    return "";
+  for (const k of ["filePath", "path", "pattern", "query", "symbol", "module", "action"]) {
+    const v = input[k];
+    if (typeof v === "string" && v.length > 0)
+      return truncate2(v, 60);
+  }
+  if (typeof input.description === "string")
+    return truncate2(input.description, 60);
+  return "";
+}
+function asToolPart(part) {
+  const type = typeof part.type === "string" ? part.type : "";
+  if (type === "tool") {
+    const state = isRecord3(part.state) ? part.state : null;
+    const output = state && typeof state.output === "string" ? state.output : state && state.output != null ? JSON.stringify(state.output) : null;
+    const metadata = state && isRecord3(state.metadata) ? state.metadata : null;
+    const title = state && typeof state.title === "string" && state.title || metadata && typeof metadata.title === "string" && metadata.title || null;
+    return {
+      name: typeof part.tool === "string" ? part.tool : "tool",
+      callId: typeof part.callID === "string" ? part.callID : "",
+      title,
+      input: state && isRecord3(state.input) ? state.input : null,
+      output
+    };
+  }
+  if (type === "tool_use") {
+    return {
+      name: typeof part.name === "string" ? part.name : "tool",
+      callId: typeof part.id === "string" ? part.id : "",
+      title: null,
+      input: isRecord3(part.input) ? part.input : null,
+      output: null
+    };
+  }
+  if (type === "tool_result") {
+    const content = part.content;
+    const output = typeof content === "string" ? content : content != null ? JSON.stringify(content) : null;
+    return {
+      name: "tool_result",
+      callId: typeof part.tool_use_id === "string" ? part.tool_use_id : "",
+      title: null,
+      input: null,
+      output
+    };
+  }
+  return null;
+}
+function textOf(part) {
+  if (part.type === "text" && typeof part.text === "string")
+    return part.text;
+  return null;
+}
+function reasoningOf(part) {
+  if ((part.type === "reasoning" || part.type === "thinking") && typeof part.text === "string") {
+    return part.text;
+  }
+  return null;
+}
+function renderPartPreview(part) {
+  if (!isRecord3(part))
+    return null;
+  const text = textOf(part);
+  if (text !== null) {
+    const t = truncate2(text, 200);
+    return t.length > 0 ? `    • ${t}` : null;
+  }
+  const tool = asToolPart(part);
+  if (tool) {
+    const arg = keyArg(tool.input);
+    const head = arg ? `${tool.name}(${arg})` : tool.name;
+    return tool.output !== null ? `    • tool ${head} → output ~${estimateTokens(tool.output)} tok` : `    • tool ${head}`;
+  }
+  const reasoning = reasoningOf(part);
+  if (reasoning !== null)
+    return `    • [reasoning] ${truncate2(reasoning, 120)}`;
+  const type = typeof part.type === "string" ? part.type : "part";
+  if (type === "file")
+    return "    • [file]";
+  if (type === "step-start" || type === "step-finish")
+    return null;
+  return `    • [${type}]`;
+}
+function renderPartFull(part) {
+  if (!isRecord3(part))
+    return null;
+  const text = textOf(part);
+  if (text !== null) {
+    return text.trim().length > 0 ? `  [text]
+${text}` : null;
+  }
+  const tool = asToolPart(part);
+  if (tool) {
+    const lines = [];
+    const idSuffix = tool.callId ? ` #${tool.callId}` : "";
+    lines.push(`  [tool: ${tool.name}${idSuffix}]`);
+    if (tool.title && tool.title.trim().length > 0) {
+      lines.push(`  description: ${tool.title.trim()}`);
+    }
+    if (tool.input)
+      lines.push(`  input: ${JSON.stringify(tool.input)}`);
+    if (tool.output !== null)
+      lines.push(`  output:
+${tool.output}`);
+    return lines.join(`
+`);
+  }
+  const type = typeof part.type === "string" ? part.type : "part";
+  if (type === "file") {
+    const name2 = typeof part.filename === "string" && part.filename || typeof part.url === "string" && part.url || "";
+    return `  [file]${name2 ? ` ${name2}` : ""}`;
+  }
+  return null;
+}
+function renderMessageByOrdinal(sessionId, ordinal) {
+  const msg = readRawSessionMessages(sessionId).find((m) => m.ordinal === ordinal);
+  if (!msg) {
+    return `No message at ordinal ${ordinal} in this session's stored history — it was deleted ` + `(session prune/revert) or the ordinal is wrong, so it can't be recovered. ` + `Re-run the tool if you still need the data.`;
+  }
+  const rendered = msg.parts.map(renderPartFull).filter((l) => l !== null);
+  const lines = [`[${msg.ordinal}] ${roleLabel(msg.role)} — full recovery:`, ""];
+  if (rendered.length === 0) {
+    lines.push("  (no recoverable content — message had only structural/reasoning parts)");
+  } else {
+    lines.push(...rendered);
+  }
+  return lines.join(`
+`);
+}
+function renderVerboseRange(sessionId, start, end, tokenBudget) {
+  const messages = readRawSessionMessages(sessionId).filter((m) => m.ordinal >= start && m.ordinal <= end);
+  const out = [];
+  let usedTokens = 0;
+  let lastOrdinal = start - 1;
+  let truncated = false;
+  for (const msg of messages) {
+    const header = `[${msg.ordinal}] ${roleLabel(msg.role)}`;
+    const partLines = msg.parts.map(renderPartPreview).filter((l) => l !== null);
+    const block = partLines.length > 0 ? `${header}
+${partLines.join(`
+`)}` : header;
+    const blockTokens = estimateTokens(block);
+    if (usedTokens + blockTokens > tokenBudget && out.length > 0) {
+      truncated = true;
+      break;
+    }
+    out.push(block);
+    usedTokens += blockTokens;
+    lastOrdinal = msg.ordinal;
+  }
+  return { text: out.join(`
+
+`), lastOrdinal, truncated };
+}
+
 // ../../node_modules/.bun/typebox@1.1.38/node_modules/typebox/build/system/memory/memory.mjs
 var exports_memory = {};
 __export(exports_memory, {
@@ -189839,12 +190500,18 @@ __export(exports_typebox, {
 });
 // src/tools/ctx-expand.ts
 var ParamsSchema = exports_typebox.Object({
-  start: exports_typebox.Number({
+  start: exports_typebox.Optional(exports_typebox.Number({
     description: "Start message ordinal (from compartment start attribute)"
-  }),
-  end: exports_typebox.Number({
+  })),
+  end: exports_typebox.Optional(exports_typebox.Number({
     description: "End message ordinal (from compartment end attribute)"
-  })
+  })),
+  verbose: exports_typebox.Optional(exports_typebox.Boolean({
+    description: "With start/end: list each message separately with its ordinal [N] and per-part preview, so you can recover one in full by ordinal."
+  })),
+  message: exports_typebox.Optional(exports_typebox.Number({
+    description: "Full untruncated recovery of ONE message by its ordinal (text + every tool call's full input/output). Recovers a tool output you dropped with ctx_reduce."
+  }))
 });
 function ok(text) {
   return { content: [{ type: "text", text }], details: undefined };
@@ -189863,22 +190530,41 @@ function createCtxExpandTool(deps) {
     description: CTX_EXPAND_DESCRIPTION,
     parameters: ParamsSchema,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      if (typeof params.start !== "number" || typeof params.end !== "number" || params.start < 1 || params.end < params.start) {
-        return err("Error: start and end must be positive integers with start <= end.");
-      }
       const sessionId = ctx.sessionManager.getSessionId();
       if (!sessionId) {
         return err("Error: no active Pi session.");
       }
-      const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
-      if (lastCompartmentEnd >= 0 && params.start > lastCompartmentEnd) {
-        return ok(`Range ${params.start}-${params.end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`);
-      }
-      const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(params.end, lastCompartmentEnd) : params.end;
       const unregister = setRawMessageProvider(sessionId, {
         readMessages: () => readPiSessionMessages(ctx)
       });
       try {
+        if (typeof params.message === "number" && params.message >= 1) {
+          return ok(renderMessageByOrdinal(sessionId, params.message));
+        }
+        if (typeof params.start !== "number" || typeof params.end !== "number" || params.start < 1 || params.end < params.start) {
+          return err("Error: provide either message=<ordinal>, or start and end (positive integers, start <= end).");
+        }
+        const lastCompartmentEnd = getLastCompartmentEndMessage(deps.db, sessionId);
+        if (lastCompartmentEnd >= 0 && params.start > lastCompartmentEnd) {
+          return ok(`Range ${params.start}-${params.end} is entirely within the live tail (after the last compacted message ${lastCompartmentEnd}); those messages are already visible in context.`);
+        }
+        const effectiveEnd = lastCompartmentEnd >= 0 ? Math.min(params.end, lastCompartmentEnd) : params.end;
+        if (params.verbose === true) {
+          const v = renderVerboseRange(sessionId, params.start, effectiveEnd, CTX_EXPAND_TOKEN_BUDGET);
+          if (!v.text) {
+            return ok(`No messages found in range ${params.start}-${effectiveEnd}. The range may be outside this session's history.`);
+          }
+          const out = [
+            `Messages ${params.start}-${v.lastOrdinal} (verbose). Recover any one in full with ctx_expand(message=<ordinal>):`,
+            "",
+            v.text
+          ];
+          if (v.truncated) {
+            out.push("", `Truncated at message ${v.lastOrdinal} (budget: ~${CTX_EXPAND_TOKEN_BUDGET} tokens). Call again with start=${v.lastOrdinal + 1} end=${effectiveEnd} verbose=true for more.`);
+          }
+          return ok(out.join(`
+`));
+        }
         const chunk = readSessionChunk(sessionId, CTX_EXPAND_TOKEN_BUDGET, params.start, effectiveEnd + 1);
         if (!chunk.text || chunk.messageCount === 0) {
           return ok(`No messages found in range ${params.start}-${params.end}. The range may be outside this session's history.`);
@@ -190597,15 +191283,16 @@ function parseInteger(str) {
 }
 
 // ../plugin/src/tools/ctx-reduce/constants.ts
-var CTX_REDUCE_DESCRIPTION = `Reduce context by dropping tagged content you no longer need.
-Use §N§ identifiers visible in conversation. The \`drop\` param accepts ranges: "3-5", "1,2,9", "1-5,8".
+var CTX_REDUCE_DESCRIPTION = `Mark spent tagged content as discardable to reclaim context space. This is NOT an immediate delete. Use §N§ identifiers visible in the conversation. The \`drop\` param accepts ranges: "3-5", "1,2,9", "1-5,8".
+
+How it works:
+- Marking QUEUES content for release. It stays fully visible to you until context space is actually needed — which may be as soon as the next turn if you are already under pressure, or many turns later if not. So mark spent outputs as soon as you finish with them; don't hoard the call for the end of the turn.
+- The newest tags are protected: marking one just queues it until it ages out of the recent window, so marking recent output is harmless.
+- When content is finally released it becomes a short placeholder, and re-running the tool is the only way to get it back. So mark only what you are genuinely DONE with — the test is "have I extracted what I need from this?", not "is it safe / do I have time before it drops?".
 
-CRITICAL RULES:
-- NEVER blanket-drop large ranges (e.g., "1-50"). Always review what each tag contains first.
-- Only drop tool outputs you have already processed and no longer need.
-- Protected tags are accepted but deferred until they leave the last protected range.
-- Keep recent context — only reduce OLD content that is no longer relevant to current work.
-- Dropped content is gone forever.`;
+Mark discardable once processed: large outputs you've summarized, repeated or redundant dumps, data written to disk, status/log output that only confirmed an expected state.
+Keep: user messages, unresolved errors, raw evidence you haven't extracted yet, and outputs whose exact wording may matter later.
+Never blanket-mark large ranges (e.g. "1-50") — review what each tag holds first.`;
 
 // src/tools/ctx-reduce.ts
 var ParamsSchema4 = exports_typebox.Object({
@@ -191206,7 +191893,21 @@ async function src_default2(pi) {
     },
     historian: hist,
     autoSearch: auto,
-    resolveForProject: resolveContextOptionsForProject
+    resolveForProject: resolveContextOptionsForProject,
+    maybeAutoEmbedSession: (sessionId, dir, identity) => {
+      maybeAutoEmbedPiSession({
+        db: database,
+        projectDir: dir,
+        projectIdentity: identity,
+        memoryEnabled: cfg.memory.enabled
+      }, sessionId, dir, identity, (text) => {
+        pi.sendMessage({
+          customType: "ctx-status",
+          content: text,
+          display: true
+        }, { triggerTurn: false });
+      });
+    }
   });
   function resolveContextOptionsForProject(dir) {
     const cached2 = contextOptionsByDir.get(dir);
@@ -191288,14 +191989,14 @@ async function src_default2(pi) {
     onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
   });
   info("registered /ctx-dream");
-  registerCtxEmbedHistoryCommand(pi, {
+  registerCtxEmbedCommand(pi, {
     db,
     projectDir,
     projectIdentity,
     memoryEnabled: config2.memory.enabled,
     resolveProject: resolveCurrentProject
   });
-  info("registered /ctx-embed-history");
+  info("registered /ctx-embed");
   const dreamerConfig = resolveDreamerFromConfig(config2);
   if (dreamerConfig) {
     registerPiDreamerProject({