@cortexkit/pi-magic-context 0.42.0 → 0.42.2

package/dist/index.js

@@ -17,7 +17,6 @@ import {
   resolveModelRefForOmp,
   resolveModelConfigValue,
   resolveModelConfigOrDefault,
-  DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
   DEFAULT_HISTORIAN_TIMEOUT_MS,
   getProtectedTokensTierOverrides,
   sanitizeDiagnosticText,
@@ -109,11 +108,8 @@ import {
   adoptNullOwnerToolTag,
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
-  formatOpenCodeDbMissingStatusLine,
-  formatOpenCodeDbReadFailureStatusLine,
   recordOpenCodeDbReadFailure,
   clearOpenCodeDbReadFailure,
-  getOpenCodeDbReadFailure,
   claimOpenCodeDbDiagnosticOnce,
   Database,
   closeQuietly,
@@ -178,6 +174,7 @@ import {
   escapeXmlContent,
   getModuleNoteEvaluationBridge,
   getContextStoreUuid,
+  drainMirrorPages,
   parseCompartmentOutput,
   resolveWorkspaceShareCategories,
   resolveWorkspaceIdentitySet,
@@ -467,7 +464,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-yb21jtfd.js";
+} from "./index-6zjn0r2z.js";
 import {
   pushNotification2
 } from "./index-b3eqj1g6.js";
@@ -2418,14 +2415,25 @@ function countActiveMemories(db, projectPath) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
   return row?.cnt ?? 0;
 }
+function countLiveMemories(db, projectPath, options = {}) {
+  const unclassified = options.unclassifiedOnly && hasMemoryClassifiedAtColumn(db);
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories
+              WHERE project_path = ?
+                AND status IN ('active','permanent')
+                AND (expires_at IS NULL OR expires_at > ?)
+                ${unclassified ? "AND classified_at IS NULL" : ""}`).get(projectPath, Date.now());
+  return row?.cnt ?? 0;
+}
 function countUnmappedActiveMemories(db, projectPath) {
   const row = db.prepare(`SELECT COUNT(*) AS cnt
                FROM memories m
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
+                AND (m.expires_at IS NULL OR m.expires_at > ?)
                 AND NOT EXISTS (
                     SELECT 1 FROM memory_verifications v WHERE v.memory_id = m.id
-                )`).get(projectPath);
+                )`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countCompartmentsSince(db, projectPath, since) {
@@ -2445,7 +2453,8 @@ function countMappedMemories(db, projectPath) {
                JOIN memory_verifications v ON v.memory_id = m.id
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
-                AND v.file_path <> ''`).get(projectPath);
+                AND (m.expires_at IS NULL OR m.expires_at > ?)
+                AND v.file_path <> ''`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countUnverifiedMappedMemories(db, projectPath) {
@@ -2454,8 +2463,9 @@ function countUnverifiedMappedMemories(db, projectPath) {
                JOIN memory_verifications v ON v.memory_id = m.id
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
+                AND (m.expires_at IS NULL OR m.expires_at > ?)
                 AND v.file_path <> ''
-                AND v.verified_at = 0`).get(projectPath);
+                AND v.verified_at = 0`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
@@ -2463,22 +2473,24 @@ function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
                FROM memories m
               WHERE m.project_path = ?
                 AND m.status IN ('active','permanent')
+                AND (m.expires_at IS NULL OR m.expires_at > ?)
                 AND (
                     SELECT MAX(v.verified_at)
                       FROM memory_verifications v
                      WHERE v.memory_id = m.id
                        AND v.file_path <> ''
-                ) < ?`).get(projectPath, cycleStartAt);
+                ) < ?`).get(projectPath, Date.now(), cycleStartAt);
   return row?.cnt ?? 0;
 }
 function countCueCandidates(db, projectPath) {
   if (!hasMuralCueColumns(db))
-    return countActiveMemories(db, projectPath);
+    return countLiveMemories(db, projectPath);
   const row = db.prepare(`SELECT COUNT(*) AS cnt
                FROM memories
               WHERE project_path = ?
                 AND status IN ('active','permanent')
-                AND (mural_cue IS NULL OR mural_cue_hash IS NULL OR updated_at > mural_cue_at)`).get(projectPath);
+                AND (expires_at IS NULL OR expires_at > ?)
+                AND (mural_cue IS NULL OR mural_cue_hash IS NULL OR updated_at > mural_cue_at)`).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countStalePrimers(db, projectPath) {
@@ -2490,16 +2502,6 @@ function countStalePrimers(db, projectPath) {
                      OR last_observed_at > answer_refreshed_at)`).get(projectPath);
   return row?.cnt ?? 0;
 }
-function countUnclassifiedActiveMemories(db, projectPath) {
-  if (!hasMemoryClassifiedAtColumn(db))
-    return countActiveMemories(db, projectPath);
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM memories
-              WHERE project_path = ?
-                AND status IN ('active','permanent')
-                AND classified_at IS NULL`).get(projectPath);
-  return row?.cnt ?? 0;
-}
 function countPendingSmartNotes(db, projectPath) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM notes WHERE project_path = ? AND type = 'smart' AND status = 'pending'").get(projectPath);
   return row?.cnt ?? 0;
@@ -2515,7 +2517,7 @@ function countActivePrimers(db, projectPath) {
 function getDreamTaskBacklog(db, projectPath, task, options = {}) {
   switch (task) {
     case "map-memories": {
-      const total = countActiveMemories(db, projectPath);
+      const total = countLiveMemories(db, projectPath);
       return { pending: countUnmappedActiveMemories(db, projectPath), total };
     }
     case "verify": {
@@ -2531,16 +2533,19 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
       return { pending, total };
     }
     case "curate": {
-      const total = countActiveMemories(db, projectPath);
+      const total = countLiveMemories(db, projectPath);
       return { pending: total, total };
     }
     case "compress-cues": {
-      const total = countActiveMemories(db, projectPath);
+      const total = countLiveMemories(db, projectPath);
       return { pending: countCueCandidates(db, projectPath), total };
     }
     case "classify-memories": {
-      const total = countActiveMemories(db, projectPath);
-      return { pending: countUnclassifiedActiveMemories(db, projectPath), total };
+      const total = countLiveMemories(db, projectPath);
+      return {
+        pending: countLiveMemories(db, projectPath, { unclassifiedOnly: true }),
+        total
+      };
     }
     case "retrospective": {
       const pending = countProjectSessionsSince(db, projectPath, options.retrospectiveWatermarkMs ?? null);
@@ -2585,15 +2590,15 @@ function evaluateTaskGate(task, ctx) {
     case "map-memories":
       return countUnmappedActiveMemories(db, project) > 0;
     case "verify":
-      return countActiveMemories(db, project) > 0;
+      return countLiveMemories(db, project) > 0;
     case "verify-broad":
-      return getTaskScheduleState(db, project, "verify-broad")?.lastBroadRunAt != null || countActiveMemories(db, project) > 0;
+      return getTaskScheduleState(db, project, "verify-broad")?.lastBroadRunAt != null || countLiveMemories(db, project) > 0;
     case "curate":
       return countActiveMemories(db, project) > 0;
     case "compress-cues":
-      return countActiveMemories(db, project) > 0;
+      return countLiveMemories(db, project) > 0;
     case "classify-memories":
-      return countActiveMemories(db, project) > 0;
+      return countLiveMemories(db, project) > 0;
     case "retrospective":
       return countProjectSessionsSince(db, project, ctx.retrospectiveWatermarkMs ?? null) > 0;
     case "maintain-docs":
@@ -2613,6 +2618,239 @@ function evaluateTaskGate(task, ctx) {
   }
 }
 
+// ../plugin/src/shared/user-facing-codes.ts
+var USER_FACING_FAILURES = {
+  historian_unavailable: {
+    code: "MC-H01",
+    sentence: "History compression could not finish this turn.",
+    action: "It will retry automatically."
+  },
+  recomp_unavailable: {
+    code: "MC-R01",
+    sentence: "History compression could not be rebuilt.",
+    action: "Run /ctx-recomp again."
+  },
+  dream_provider_timeout: {
+    code: "MC-D01",
+    sentence: "Memory maintenance took too long to respond.",
+    action: "Run /ctx-dream again."
+  },
+  dream_provider_error: {
+    code: "MC-D02",
+    sentence: "Memory maintenance could not reach its model.",
+    action: "Check the model connection, then run /ctx-dream again."
+  },
+  dream_empty_completion: {
+    code: "MC-D03",
+    sentence: "Memory maintenance received no usable response.",
+    action: "Run /ctx-dream again."
+  },
+  dream_no_models: {
+    code: "MC-D04",
+    sentence: "Memory maintenance has no model available.",
+    action: "Check the model settings, then run /ctx-dream again."
+  },
+  dream_child_aborted: {
+    code: "MC-D05",
+    sentence: "Memory maintenance was interrupted.",
+    action: "Run /ctx-dream again."
+  },
+  dream_parse_failed: {
+    code: "MC-D06",
+    sentence: "Memory maintenance could not use the model response.",
+    action: "Run /ctx-dream again."
+  },
+  dream_unknown: {
+    code: "MC-D07",
+    sentence: "Memory maintenance could not finish.",
+    action: "Run /ctx-dream again."
+  },
+  embedding_substitution_rejected: {
+    code: "MC-E01",
+    sentence: "Search indexing could not use the selected model.",
+    action: "Check the embedding model setting, then run /ctx-embed start again."
+  },
+  embedding_http_error: {
+    code: "MC-E02",
+    sentence: "The search indexing provider refused the request.",
+    action: "Check the provider connection and credentials, then run /ctx-embed start again."
+  },
+  embedding_transport_error: {
+    code: "MC-E03",
+    sentence: "Search indexing could not reach its provider.",
+    action: "Check the connection, then run /ctx-embed start again."
+  },
+  embedding_invalid_envelope: {
+    code: "MC-E04",
+    sentence: "Search indexing received an unsupported response.",
+    action: "Check the embedding endpoint, then run /ctx-embed start again."
+  },
+  embedding_empty_result: {
+    code: "MC-E05",
+    sentence: "Search indexing received no usable result.",
+    action: "Run /ctx-embed start again."
+  },
+  embedding_certification_refusal: {
+    code: "MC-E06",
+    sentence: "Search indexing is not ready for this provider.",
+    action: "Finish the provider setup, or set a fallback provider in the embedding settings, then run /ctx-embed start again."
+  },
+  embedding_credential_required: {
+    code: "MC-E07",
+    sentence: "Search indexing needs provider credentials.",
+    action: "Sign in to the provider, then run /ctx-embed start again."
+  },
+  embedding_local_binding_missing: {
+    code: "MC-E08",
+    sentence: "Local search indexing is unavailable on this system.",
+    action: "Run `npx @cortexkit/magic-context doctor`, then retry."
+  },
+  embedding_local_fs_unavailable: {
+    code: "MC-E09",
+    sentence: "Local search indexing cannot save its model files.",
+    action: "Update or reinstall Magic Context, then retry."
+  },
+  embedding_local_download_failure: {
+    code: "MC-E10",
+    sentence: "Local search indexing could not download its model.",
+    action: "Check the network connection, then retry."
+  },
+  embedding_local_runtime_error: {
+    code: "MC-E11",
+    sentence: "Local search indexing could not start.",
+    action: "Run `npx @cortexkit/magic-context doctor`, then retry."
+  },
+  embedding_unavailable: {
+    code: "MC-E12",
+    sentence: "Search indexing could not finish.",
+    action: "Run /ctx-embed start again."
+  },
+  status_unavailable: {
+    code: "MC-S01",
+    sentence: "Magic Context status is temporarily unavailable.",
+    action: "Retry /ctx-status in a moment."
+  },
+  transform_update_failed: {
+    code: "MC-S02",
+    sentence: "The last context update did not finish.",
+    action: "Send another message to retry."
+  },
+  configuration_warning: {
+    code: "MC-S03",
+    sentence: "Some configuration settings could not be applied.",
+    action: "Fix the configuration warning shown in /ctx-status diagnostics, then restart."
+  },
+  status_log_unavailable: {
+    code: "MC-S04",
+    sentence: "Some diagnostic details could not be saved.",
+    action: "Retry /ctx-status in a moment."
+  },
+  memory_writes_paused: {
+    code: "MC-C01",
+    sentence: "Memory writes are paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  memory_access_unavailable: {
+    code: "MC-C02",
+    sentence: "Memory access is temporarily unavailable.",
+    action: "Retry in a moment."
+  },
+  note_changes_paused: {
+    code: "MC-C03",
+    sentence: "Note changes are paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  note_access_unavailable: {
+    code: "MC-C04",
+    sentence: "Notes are temporarily unavailable.",
+    action: "Retry in a moment."
+  },
+  context_cleanup_paused: {
+    code: "MC-C05",
+    sentence: "Context cleanup is paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  partial_history_unavailable: {
+    code: "MC-C06",
+    sentence: "Partial history compression is not available in the current mode.",
+    action: "Run /ctx-recomp without a range."
+  },
+  session_upgrade_unavailable: {
+    code: "MC-C07",
+    sentence: "Session upgrade is not available in the current mode.",
+    action: "Run /ctx-recomp instead."
+  },
+  smart_note_conditions_unavailable: {
+    code: "MC-C08",
+    sentence: "Conditional notes are not available in the current mode.",
+    action: "Save a regular note without a condition."
+  },
+  history_compression_paused: {
+    code: "MC-C09",
+    sentence: "History compression is paused while the engine syncs.",
+    action: "Retry in a moment."
+  },
+  context_service_unavailable: {
+    code: "MC-C10",
+    sentence: "Magic Context is temporarily unavailable.",
+    action: "Retry in a moment."
+  }
+};
+function renderUserFacingFailure(key, style = "markdown") {
+  const failure = USER_FACING_FAILURES[key];
+  const action = style === "plain" ? failure.action.replaceAll("`", "") : failure.action;
+  return `${failure.sentence} ${action} (${failure.code})`;
+}
+function userFacingFailureCode(key) {
+  return USER_FACING_FAILURES[key].code;
+}
+var CAPABILITY_FAILURES = {
+  memory_write: "memory_writes_paused",
+  memory_access: "memory_access_unavailable",
+  note_change: "note_changes_paused",
+  note_access: "note_access_unavailable",
+  context_cleanup: "context_cleanup_paused",
+  partial_history: "partial_history_unavailable",
+  session_upgrade: "session_upgrade_unavailable",
+  smart_note_condition: "smart_note_conditions_unavailable",
+  history_compression: "history_compression_paused",
+  context_service: "context_service_unavailable"
+};
+function renderCapabilityRefusal(capability) {
+  return renderUserFacingFailure(CAPABILITY_FAILURES[capability]);
+}
+var DREAM_FAILURE_KEYS = {
+  provider_timeout: "dream_provider_timeout",
+  provider_error: "dream_provider_error",
+  empty_completion: "dream_empty_completion",
+  no_models: "dream_no_models",
+  child_aborted: "dream_child_aborted",
+  parse_failed: "dream_parse_failed",
+  unknown: "dream_unknown"
+};
+var EMBEDDING_FAILURE_KEYS = {
+  substitution_rejected: "embedding_substitution_rejected",
+  http_error: "embedding_http_error",
+  transport_error: "embedding_transport_error",
+  invalid_envelope: "embedding_invalid_envelope",
+  empty_result: "embedding_empty_result",
+  certification_refusal: "embedding_certification_refusal",
+  credential_required: "embedding_credential_required",
+  local_binding_missing: "embedding_local_binding_missing",
+  local_fs_unavailable: "embedding_local_fs_unavailable",
+  local_download_failure: "embedding_local_download_failure",
+  local_runtime_error: "embedding_local_runtime_error"
+};
+function renderDreamFailure(failureClass, style = "markdown") {
+  return renderUserFacingFailure(DREAM_FAILURE_KEYS[failureClass], style);
+}
+function dreamFailureCode(failureClass) {
+  return userFacingFailureCode(DREAM_FAILURE_KEYS[failureClass]);
+}
+function renderEmbeddingFailure(failureClass, style = "markdown") {
+  return renderUserFacingFailure(EMBEDDING_FAILURE_KEYS[failureClass], style);
+}
+
 // ../plugin/src/features/magic-context/dreamer/open-opencode-db.ts
 function openOpenCodeDb() {
   const resolution = resolveOpenCodeDbPath();
@@ -5183,12 +5421,12 @@ async function runClassifyThroughModule(args, chunk, anchors, signal) {
     });
   } catch (error) {
     if (isRustAuthorityDrainingError(error)) {
-      throw new Error("Rust memory authority is not ready; TypeScript fallback is disabled.");
+      throw new Error(renderCapabilityRefusal("memory_write"));
     }
     throw error;
   }
   if (isRustAuthorityDrainingError(applied)) {
-    throw new Error("Rust memory authority is not ready; TypeScript fallback is disabled.");
+    throw new Error(renderCapabilityRefusal("memory_write"));
   }
   const applyResult = applied?.result ?? applied;
   if (!applyResult || typeof applyResult !== "object") {
@@ -6820,6 +7058,116 @@ Output exactly JSON: {"met": false}`;
   }
 }
 
+// ../plugin/src/features/magic-context/dreamer/expire-memories.ts
+var MODULE_ARCHIVE_BATCH_SIZE = 100;
+var EXPIRED_ARCHIVE_REASON = "expired";
+function getExpiredActiveMemoryIds(db, projectIdentity, now = Date.now()) {
+  const rows = db.prepare(`SELECT id
+               FROM memories
+              WHERE project_path = ?
+                AND status = 'active'
+                AND expires_at IS NOT NULL
+                AND expires_at <= ?
+              ORDER BY id`).all(projectIdentity, now);
+  return rows.map((row) => row.id);
+}
+function assertSuccessfulModuleArchive(response) {
+  const result = response && typeof response === "object" && "result" in response ? response.result : response;
+  if (result && typeof result === "object") {
+    const record = result;
+    if (record.ok === false || record.error) {
+      throw new Error("module rejected expired-memory archive");
+    }
+  }
+}
+async function archiveExpiredThroughModule(args) {
+  if (!args.moduleRoute.moduleClient.mirrorPull) {
+    throw new DreamerModuleFailureError("mirror.pull expired archive", new Error("Rust dreamer client omitted the memory mirror route"));
+  }
+  for (let offset = 0;offset < args.expiredContextIds.length; offset += MODULE_ARCHIVE_BATCH_SIZE) {
+    if (!leaseOwnershipMatches(args.db, args.holderId, args.leaseAcquisition.generation, args.leaseKey)) {
+      throw new Error("Dream lease lost before expired-memory archive");
+    }
+    const contextBatch = args.expiredContextIds.slice(offset, offset + MODULE_ARCHIVE_BATCH_SIZE);
+    const identities = getModuleMemoryIdentities(args.db, args.projectIdentity, contextBatch);
+    if (identities.size !== contextBatch.length) {
+      throw new DreamerModuleFailureError("ctx_memory expired archive", new Error("expired memory is missing its module mirror identity"));
+    }
+    const moduleBatch = contextBatch.map((id) => {
+      const identity = identities.get(id);
+      if (!identity)
+        throw new Error(`missing module identity for expired memory ${id}`);
+      return identity.moduleId;
+    });
+    try {
+      const response = await args.moduleRoute.moduleClient.call({
+        sessionId: args.moduleRoute.moduleSessionId,
+        projectRoot: args.moduleRoute.moduleProjectRoot,
+        method: "ctx_memory",
+        body: {
+          name: "ctx_memory",
+          arguments: {
+            action: "archive",
+            memory_project: args.projectIdentity,
+            ids: moduleBatch,
+            reason: EXPIRED_ARCHIVE_REASON,
+            command_id: `${args.moduleRoute.moduleCommandId}:expire:${offset / MODULE_ARCHIVE_BATCH_SIZE}`
+          }
+        }
+      });
+      assertSuccessfulModuleArchive(response);
+    } catch (error) {
+      throw new DreamerModuleFailureError("ctx_memory expired archive", error);
+    }
+  }
+  const mirrorPull = args.moduleRoute.moduleClient.mirrorPull;
+  const drained = await drainMirrorPages({
+    db: args.db,
+    module: {
+      mirrorPull: (request) => mirrorPull({ ...request, projectRoot: args.moduleRoute.moduleProjectRoot })
+    },
+    domain: "memories",
+    limit: 1000
+  });
+  if (!drained.complete) {
+    throw new DreamerModuleFailureError("mirror.pull expired archive", new Error("memory mirror did not reach the module cursor"));
+  }
+  if (!leaseOwnershipMatches(args.db, args.holderId, args.leaseAcquisition.generation, args.leaseKey)) {
+    throw new Error("Dream lease lost during expired-memory archive");
+  }
+  return args.expiredContextIds.length;
+}
+async function archiveExpiredMemories(args) {
+  const expiredContextIds = getExpiredActiveMemoryIds(args.db, args.projectIdentity, args.now);
+  if (expiredContextIds.length === 0) {
+    if (!leaseOwnershipMatches(args.db, args.holderId, args.leaseAcquisition.generation, args.leaseKey)) {
+      throw new Error("Dream lease lost before expired-memory probe");
+    }
+    return 0;
+  }
+  if (args.moduleRoute) {
+    return archiveExpiredThroughModule({
+      ...args,
+      expiredContextIds,
+      moduleRoute: args.moduleRoute
+    });
+  }
+  const selectedIds = new Set(expiredContextIds);
+  return runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const stillExpired = getExpiredActiveMemoryIds(args.db, args.projectIdentity, args.now).filter((id) => selectedIds.has(id));
+    for (const id of stillExpired) {
+      archiveMemory(args.db, id, EXPIRED_ARCHIVE_REASON);
+      queueMemoryMutation(args.db, {
+        projectPath: args.projectIdentity,
+        mutationType: "archive",
+        targetMemoryId: id,
+        queuedAt: args.now
+      });
+    }
+    return stillExpired.length;
+  });
+}
+
 // ../plugin/src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
@@ -8425,14 +8773,7 @@ function parseJsonRecord(value) {
 
 // ../plugin/src/features/magic-context/dreamer/storage-dream-runs.ts
 function formatDreamRunFailure(failure) {
-  const parts = [failure.failure_class];
-  if (failure.model_attempted)
-    parts.push(`model: ${failure.model_attempted}`);
-  if (failure.provider_error)
-    parts.push(failure.provider_error.split(/\r?\n/, 1)[0].trim());
-  else if (failure.timeout_ms !== null)
-    parts.push(`timeout: ${failure.timeout_ms}ms`);
-  return parts.join(" · ");
+  return renderDreamFailure(failure.failure_class);
 }
 var insertDreamRunStatements = new WeakMap;
 var getDreamRunsByProjectStatements = new Map;
@@ -9166,6 +9507,9 @@ function inspectCurateMemoryOperations(messages) {
   }
   return summary;
 }
+function formatExpiredArchiveProgress(count) {
+  return `curate: archived ${count} expired ${count === 1 ? "memory" : "memories"}`;
+}
 function formatCurateMemoryOperations(actions) {
   const actionCounts = new Map;
   for (const action of actions)
@@ -9216,7 +9560,7 @@ function createDreamTaskExecutor(deps) {
     };
     const parent = await resolveParentSessionId();
     let moduleRoute;
-    if (config.task === "map-memories" || config.task === "compress-cues" || config.task === "classify-memories" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
+    if (config.task === "curate" || config.task === "map-memories" || config.task === "compress-cues" || config.task === "classify-memories" || config.task === "verify" || config.task === "verify-broad" || config.task === "retrospective") {
       try {
         moduleRoute = await resolveDreamerModuleRoute({
           db,
@@ -9545,13 +9889,15 @@ function createDreamTaskExecutor(deps) {
         parent,
         recordRun,
         computeMemoryDelta,
-        reportProgress
+        reportProgress,
+        leaseAcquisition,
+        moduleRoute
       });
     } catch (error) {
       const { transient, brief } = classifyFailure(error);
       const failure = dreamRunFailureDetail(error);
       recordRun("failed", brief, { failure });
-      log(`[dreamer] task ${config.task} failed (transient=${transient}): ${brief}`);
+      log(`[dreamer] task ${config.task} failed code=${dreamFailureCode(failure.failure_class)} (transient=${transient}): ${brief}`);
       return {
         status: "failed",
         transient,
@@ -9846,17 +10192,6 @@ async function runAgenticTask(config, ctx, helpers) {
     architecture: existsSync5(`${docsDir}/ARCHITECTURE.md`),
     structure: existsSync5(`${docsDir}/STRUCTURE.md`)
   } : undefined;
-  let curateMemories;
-  if (task === "curate") {
-    curateMemories = loadActiveMemoryPromptMemories(db, projectIdentity);
-    log(`[dreamer] curate pool: in_scope=${curateMemories.length}`);
-  }
-  const taskPrompt = buildDreamTaskPrompt(task, {
-    projectPath: projectIdentity,
-    lastDreamAt: lastRunAt ? String(lastRunAt) : null,
-    existingDocs,
-    curate: curateMemories ? { memories: curateMemories } : undefined
-  });
   const abortController = new AbortController;
   let leaseLost = false;
   const heartbeat = startLeaseHeartbeat(db, holderId, leaseKey, () => {
@@ -9865,7 +10200,37 @@ async function runAgenticTask(config, ctx, helpers) {
   }, ctx.leaseAcquisition);
   let childSessionId = null;
   let promptSettled = false;
+  let expiredArchived = 0;
   try {
+    let curateMemories;
+    if (task === "curate") {
+      expiredArchived = await archiveExpiredMemories({
+        db,
+        projectIdentity,
+        holderId,
+        leaseKey,
+        leaseAcquisition: helpers.leaseAcquisition,
+        moduleRoute: helpers.moduleRoute
+      });
+      if (leaseLost)
+        throw new Error("Dream lease lost during expired-memory archive");
+      curateMemories = loadActiveMemoryPromptMemories(db, projectIdentity);
+      log(`[dreamer] curate pool: in_scope=${curateMemories.length} expired_archived=${expiredArchived}`);
+      if (curateMemories.length === 0 && expiredArchived > 0) {
+        const progress = formatExpiredArchiveProgress(expiredArchived);
+        helpers.recordRun("completed", null, {
+          memoryChanges: helpers.computeMemoryDelta(memoryBefore),
+          progress
+        });
+        return { status: "completed", detail: progress };
+      }
+    }
+    const taskPrompt = buildDreamTaskPrompt(task, {
+      projectPath: projectIdentity,
+      lastDreamAt: lastRunAt ? String(lastRunAt) : null,
+      existingDocs,
+      curate: curateMemories ? { memories: curateMemories } : undefined
+    });
     const createResponse = await createChildSessionWithFence({
       client: deps.client,
       db,
@@ -9957,6 +10322,7 @@ async function runAgenticTask(config, ctx, helpers) {
     }
     const curateOutput = task === "curate" ? run.validated : undefined;
     const progress = [
+      expiredArchived > 0 ? formatExpiredArchiveProgress(expiredArchived) : null,
       curateOutput && curateOutput.memoryOperations.completedActions.length > 0 ? formatCurateMemoryOperations(curateOutput.memoryOperations.completedActions) : null,
       curateRefused > 0 ? `curate: refused ${curateRefused} unsafe mutation(s)` : null
     ].filter((value) => Boolean(value)).join("; ");
@@ -12897,17 +13263,10 @@ Unknown task "${requested}".`,
           projectIdentity: project.projectIdentity
         });
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        sessionLog(project.projectIdentity, `/ctx-dream failed: ${message}`);
+        sessionLog(project.projectIdentity, `/ctx-dream failed code=${userFacingFailureCode("dream_unknown")}`, error);
         sendStatus({
           title: "/ctx-dream",
-          text: [
-            "## /ctx-dream",
-            "",
-            `Dream run failed: ${message}`,
-            "The registered timer will retry due tasks on its next tick."
-          ].join(`
-`),
+          text: renderUserFacingFailure("dream_unknown"),
           level: "error"
         }, {
           projectDir: project.projectDir,
@@ -12922,39 +13281,27 @@ Unknown task "${requested}".`,
 var embedPauseBySession = new Set;
 var embedRunStateBySession = new Map;
 var autoEmbedAttemptedBySession = new Set;
+function getEmbedDrainUiStatus(sessionId, progress) {
+  if (embedPauseBySession.has(sessionId)) {
+    return { status: "paused" };
+  }
+  const activeRun = embedRunStateBySession.get(sessionId);
+  if (activeRun && !activeRun.signal.aborted || progress?.kind === "embed" && progress.phase === "recomp") {
+    return { status: "running" };
+  }
+  if (progress?.kind === "embed" && (progress.phase === "failed" || progress.phase === "skipped") && progress.message) {
+    if (/provider/i.test(progress.message)) {
+      return { status: "stopped", detail: progress.message };
+    }
+  }
+  return { status: "idle" };
+}
 
 // ../plugin/src/hooks/magic-context/format-embed-failure.ts
-function formatEmbedFailureSummary(embedded, remaining, failure) {
-  const compartment = `compartment${embedded === 1 ? "" : "s"}`;
-  if (!failure) {
-    return `Embedded ${embedded} ${compartment}; ${remaining} could not be embedded (the provider returned no result). Run /ctx-embed start again to retry them.`;
-  }
-  const retry = " Run /ctx-embed start again to retry them.";
-  switch (failure.class) {
-    case "substitution_rejected":
-      return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: set embedding.model to the served spelling.`;
-    case "http_error": {
-      const fix = failure.reason.startsWith("HTTP 401") || failure.reason.startsWith("HTTP 403") ? " Fix: check embedding.api_key." : failure.reason.startsWith("HTTP 402") ? " Fix: check provider quota or billing." : failure.reason.startsWith("HTTP 404") ? " Fix: check embedding.endpoint and embedding.model." : failure.retryable ? retry : " Fix: check embedding.endpoint, embedding.model, and credentials.";
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}.${fix}`;
-    }
-    case "invalid_envelope":
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: configure an OpenAI-compatible embedding endpoint that returns data[].embedding.`;
-    case "certification_refusal":
-      return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: recertify SYNAPSE or configure embedding.fallback_provider, then run /ctx-embed start again.`;
-    case "credential_required":
-      return `Embedded ${embedded} ${compartment}; ${remaining} rejected: ${failure.reason}. Fix: reauthenticate SYNAPSE, then run /ctx-embed start again.`;
-    case "local_binding_missing":
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: run \`npx @cortexkit/magic-context@latest doctor\` to verify the WASM fallback. On Intel macOS, onnxruntime-node@1.23.0 may be pinned manually for optional native speed.`;
-    case "local_fs_unavailable":
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: update or reinstall Magic Context so its Node WASM bundle can persist the model, then run /ctx-embed start again.`;
-    case "local_download_failure":
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: check network/proxy access to the model host.${retry}`;
-    case "local_runtime_error":
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}. Fix: run \`npx @cortexkit/magic-context@latest doctor\` for local runtime diagnostics.`;
-    case "empty_result":
-    case "transport_error":
-      return `Embedded ${embedded} ${compartment}; ${remaining} failed: ${failure.reason}.${failure.retryable ? retry : ""}`;
-  }
+function formatEmbedFailureSummary(embedded, remaining, failure, style = "markdown") {
+  const historyBlocks = `history block${embedded === 1 ? "" : "s"}`;
+  const progress = `Indexed ${embedded} ${historyBlocks}; ${remaining} remain.`;
+  return `${progress} ${renderEmbeddingFailure(failure?.class ?? "empty_result", style)}`;
 }
 
 // ../plugin/src/hooks/magic-context/format-embed-status.ts
@@ -13112,7 +13459,7 @@ Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`,
       return {
         text: `## /ctx-embed
 
-${formatEmbedFailureSummary(outcome.embedded, outcome.remaining, outcome.failure)}`,
+${formatEmbedFailureSummary(outcome.embedded, outcome.remaining, outcome.failure, "plain")}`,
         level: "info"
       };
     default:
@@ -14007,78 +14354,93 @@ function buildReplacementContent(tagId) {
 }
 function applyPendingOperations(sessionId, db, targets, protectedTagIds, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set) {
   let didMutateMessage = false;
-  db.transaction(() => {
-    const tags = preloadedTags ?? getTagsBySession(db, sessionId);
-    const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
-    const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
-    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 { op: pendingOp, synthetic } of opsToApply) {
-      const tagStatus = tagStatusById.get(pendingOp.tagId);
-      if (tagStatus === "compacted" || tagStatus === "dropped") {
-        if (!synthetic)
-          removePendingOp(db, sessionId, pendingOp.tagId);
-        continue;
-      }
-      if (protectedTagIds.has(pendingOp.tagId)) {
-        continue;
-      }
-      const target = targets.get(pendingOp.tagId);
-      const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
-      if (synthetic) {
-        if (!isToolTag || target?.canDrop?.() !== true)
+  let admitted = false;
+  let startedAt = 0;
+  try {
+    db.transaction(() => {
+      admitted = true;
+      startedAt = performance.now();
+      const tags = preloadedTags ?? getTagsBySession(db, sessionId);
+      const tagStatusById = new Map(tags.map((tag) => [tag.tagNumber, tag.status]));
+      const tagTypeById = new Map(tags.map((tag) => [tag.tagNumber, tag.type]));
+      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 { op: pendingOp, synthetic } of opsToApply) {
+        const tagStatus = tagStatusById.get(pendingOp.tagId);
+        if (tagStatus === "compacted" || tagStatus === "dropped") {
+          if (!synthetic)
+            removePendingOp(db, sessionId, pendingOp.tagId);
           continue;
-      }
-      let shouldPersistDrop = false;
-      if (isToolTag) {
-        if (editMarkerTagIds.has(pendingOp.tagId)) {
-          const markResult = target?.editMarker?.() ?? "absent";
-          if (markResult === "incomplete" || markResult === "absent") {
-            continue;
-          }
-          didMutateMessage = true;
-          updateTagDropMode(db, sessionId, pendingOp.tagId, "edit_marker");
-          shouldPersistDrop = true;
-        } else if (skeletonWindow.has(pendingOp.tagId)) {
-          const truncResult = target?.truncate?.() ?? "absent";
-          if (truncResult === "incomplete" || synthetic && truncResult !== "truncated") {
+        }
+        if (protectedTagIds.has(pendingOp.tagId)) {
+          continue;
+        }
+        const target = targets.get(pendingOp.tagId);
+        const isToolTag = tagTypeById.get(pendingOp.tagId) === "tool";
+        if (synthetic) {
+          if (!isToolTag || target?.canDrop?.() !== true)
             continue;
-          }
-          if (truncResult === "truncated") {
+        }
+        let shouldPersistDrop = false;
+        if (isToolTag) {
+          if (editMarkerTagIds.has(pendingOp.tagId)) {
+            const markResult = target?.editMarker?.() ?? "absent";
+            if (markResult === "incomplete" || markResult === "absent") {
+              continue;
+            }
             didMutateMessage = true;
+            updateTagDropMode(db, sessionId, pendingOp.tagId, "edit_marker");
+            shouldPersistDrop = true;
+          } else if (skeletonWindow.has(pendingOp.tagId)) {
+            const truncResult = target?.truncate?.() ?? "absent";
+            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" || synthetic && dropResult !== "removed") {
+              continue;
+            }
+            if (dropResult === "removed") {
+              didMutateMessage = true;
+            }
+            updateTagDropMode(db, sessionId, pendingOp.tagId, "full");
+            shouldPersistDrop = true;
           }
-          updateTagDropMode(db, sessionId, pendingOp.tagId, "truncated");
-          shouldPersistDrop = true;
-        } else {
-          const dropResult = target?.drop?.() ?? "absent";
-          if (dropResult === "incomplete" || synthetic && dropResult !== "removed") {
-            continue;
-          }
-          if (dropResult === "removed") {
+        } else if (target) {
+          const changed = target.setContent(buildReplacementContent(pendingOp.tagId));
+          if (changed)
             didMutateMessage = true;
-          }
-          updateTagDropMode(db, sessionId, pendingOp.tagId, "full");
+          shouldPersistDrop = true;
+        } else if (!synthetic) {
           shouldPersistDrop = true;
         }
-      } else if (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");
+        if (!synthetic)
+          removePendingOp(db, sessionId, pendingOp.tagId);
       }
-      if (!shouldPersistDrop)
-        continue;
-      updateTagStatus(db, sessionId, pendingOp.tagId, "dropped");
-      if (!synthetic)
-        removePendingOp(db, sessionId, pendingOp.tagId);
+    }).immediate();
+  } catch (error) {
+    if (!admitted && /database (?:table )?is locked|sqlite_(busy|locked)/i.test(String(error))) {
+      sessionLog(sessionId, "pending operations write admission busy; retaining prior bytes for retry");
+      return false;
     }
-  })();
+    throw error;
+  } finally {
+    if (admitted)
+      logSlowWriteTransaction("apply_pending_operations", startedAt);
+  }
   return didMutateMessage;
 }
 function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
@@ -16253,11 +16615,16 @@ function buildAggregateTarget(tagId, occurrences, requiresToolArcSkeleton) {
       const complete = occurrences.some((occ) => occ.kind === "tool_use") && occurrences.some((occ) => occ.kind === "tool_result");
       if (!complete)
         return "incomplete";
-      if (!requiresToolArcSkeleton && occurrences.every((occ) => occ.part.remove && occ.part.canRemove?.() !== false)) {
-        let removed = false;
-        for (const occ of occurrences)
-          removed = occ.part.remove?.() || removed;
-        return removed ? "removed" : "absent";
+      if (!requiresToolArcSkeleton) {
+        const authorization = occurrences.map((occ) => occ.part.canRemove?.());
+        if (authorization.includes("defer"))
+          return "incomplete";
+        if (occurrences.every((occ, index) => occ.part.remove && authorization[index] !== false)) {
+          let removed = false;
+          for (const occ of occurrences)
+            removed = occ.part.remove?.() || removed;
+          return removed ? "removed" : "absent";
+        }
       }
       const sentinel = `[dropped §${tagId}§]`;
       let any = false;
@@ -17836,24 +18203,9 @@ function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, se
   };
 }
 var HISTORIAN_PERSISTENT_FAILURE_THRESHOLD = 3;
-function buildHistorianFailureNotice(failureCount, lastError) {
-  if (failureCount >= HISTORIAN_PERSISTENT_FAILURE_THRESHOLD) {
-    return [
-      "## Magic Context — history comparting needs attention",
-      "",
-      `Magic Context has been unable to compart this session's history ${failureCount} times in a row. This usually means the configured historian model is misconfigured or unreachable (Magic Context already retried every fallback model automatically).`,
-      "",
-      `Last error: ${lastError}`,
-      "",
-      "Check your historian model in magic-context.jsonc, then restart. Your conversation keeps working normally in the meantime — this only affects how older history is summarized."
-    ].join(`
-`);
-  }
-  return [
-    "## Magic Context",
-    "",
-    "Hit a transient issue comparting history this turn — Magic Context will retry automatically on the next turn. Nothing is lost and your conversation continues normally. You'll only be alerted again if this keeps happening."
-  ].join(`
+function buildHistorianFailureNotice(failureCount, _lastError) {
+  const heading = failureCount >= HISTORIAN_PERSISTENT_FAILURE_THRESHOLD ? "## Magic Context — History compression" : "## Magic Context";
+  return [heading, "", renderUserFacingFailure("historian_unavailable")].join(`
 `);
 }
 function buildHistorianRepairPrompt(originalPrompt, previousOutput, validationError, language) {
@@ -20916,7 +21268,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
             emergencyDroppedTools++;
           }
         }
-      })();
+      }).immediate();
       sessionLog(sessionId, `emergency tiered drop: ${plan.reason}`);
     } else {
       sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
@@ -20945,7 +21297,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           droppedStaleReduceCalls++;
         }
       }
-    })();
+    }).immediate();
   }
   if (routine) {
     db.transaction(() => {
@@ -20982,7 +21334,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           }
         }
       }
-    })();
+    }).immediate();
   }
   const toolFingerprints = routine ? buildPiToolFingerprints(piMessages, resolveStableId) : new Map;
   if (toolFingerprints.size > 0) {
@@ -21020,7 +21372,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           }
         }
       }
-    })();
+    }).immediate();
   }
   if (droppedTools > 0 || deduplicatedTools > 0 || droppedInjections > 0 || droppedStaleReduceCalls > 0) {
     sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, stale ctx_reduce=${droppedStaleReduceCalls}, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
@@ -23356,6 +23708,23 @@ function applyNativeReasoningReplayPi(args, saved) {
     args.messages[index] = message;
   return nextIds.size;
 }
+function authorizePiToolRemoval(args) {
+  if (!args.saved)
+    return false;
+  if (args.saved.get(args.callId) === NATIVE_TOOL_REMOVAL_MARKER)
+    return true;
+  if (!args.canApply)
+    return false;
+  try {
+    saveNativeToolInputs(args.db, args.sessionId, new Map([[args.callId, NATIVE_TOOL_REMOVAL_MARKER]]));
+    args.saved.set(args.callId, NATIVE_TOOL_REMOVAL_MARKER);
+    return true;
+  } catch (error) {
+    sessionLog(args.sessionId, `tool arc removal persistence failed; retaining pair: ${String(error)}`);
+    const priorDrop = args.db.prepare("SELECT 1 FROM tags WHERE session_id = ? AND type = 'tool' AND message_id = ? AND status = 'dropped' LIMIT 1").get(args.sessionId, args.callId);
+    return priorDrop ? false : "defer";
+  }
+}
 
 // src/note-visibility-pi.ts
 var NOTE_TOOL_NAME = "ctx_note";
@@ -23515,13 +23884,38 @@ function parsePersistedLkgSlot(row) {
   const jsonPrefix = record.json_prefix;
   const lastInputMessageId = record.last_input_message_id;
   const capturedAt = record.captured_at;
-  const inputIdSeq = parseStringArray(record.input_id_seq);
+  let inputIdsRaw = record.input_id_seq;
+  let piOutputEntryIds;
+  if (typeof inputIdsRaw === "string") {
+    try {
+      const metadata = JSON.parse(inputIdsRaw);
+      if (metadata && !Array.isArray(metadata) && metadata.version === 1 && Array.isArray(metadata.piOutputEntryIds)) {
+        if (!metadata.piOutputEntryIds.every((id) => id === null || typeof id === "string" && id.length > 0))
+          return;
+        piOutputEntryIds = metadata.piOutputEntryIds;
+        inputIdsRaw = JSON.stringify(metadata.inputIds);
+      }
+    } catch {
+      return;
+    }
+  }
+  const inputIdSeq = parseStringArray(inputIdsRaw);
   const inputContentDigests = parseStringArray(record.input_content_digests);
   const modelKey = parseNullableString(record.model_key);
   const providerKey = parseNullableString(record.provider_key);
   if (typeof jsonPrefix !== "string" || typeof lastInputMessageId !== "string" || lastInputMessageId.length === 0 || typeof capturedAt !== "number" || !Number.isFinite(capturedAt) || inputIdSeq === null || inputContentDigests === null || inputContentDigests.length !== inputIdSeq.length || modelKey === undefined || providerKey === undefined) {
     return;
   }
+  if (piOutputEntryIds) {
+    try {
+      const output = JSON.parse(jsonPrefix);
+      const inputs = new Set(inputIdSeq);
+      if (!Array.isArray(output) || output.length !== piOutputEntryIds.length || piOutputEntryIds.some((id) => id !== null && !inputs.has(id)))
+        return;
+    } catch {
+      return;
+    }
+  }
   let inputContentSignatures;
   if (record.input_content_signatures !== null && record.input_content_signatures !== undefined) {
     const parsed = parseStringArray(record.input_content_signatures);
@@ -23540,6 +23934,8 @@ function parsePersistedLkgSlot(row) {
   };
   if (inputContentSignatures)
     slot.inputContentSignatures = inputContentSignatures;
+  if (piOutputEntryIds)
+    slot.piOutputEntryIds = piOutputEntryIds;
   const rowVersion = parseNullableInteger(record.row_version);
   if (rowVersion !== undefined)
     slot.rowVersion = rowVersion;
@@ -23565,7 +23961,11 @@ function saveLkgSlotToDb(db, sessionId, slot) {
                 provider_key = excluded.provider_key,
                 captured_at = excluded.captured_at,
                 row_version = excluded.row_version,
-                capture_sequence = excluded.capture_sequence`).run(sessionId, slot.jsonPrefix, JSON.stringify(slot.inputIdSeq), JSON.stringify(slot.inputContentDigests), slot.inputContentSignatures ? JSON.stringify(slot.inputContentSignatures) : null, slot.lastInputMessageId, slot.modelKey, slot.providerKey, slot.capturedAt, slot.rowVersion ?? null, slot.captureSequence ?? null);
+                capture_sequence = excluded.capture_sequence`).run(sessionId, slot.jsonPrefix, JSON.stringify(slot.piOutputEntryIds ? {
+      version: 1,
+      inputIds: slot.inputIdSeq,
+      piOutputEntryIds: slot.piOutputEntryIds
+    } : slot.inputIdSeq), JSON.stringify(slot.inputContentDigests), slot.inputContentSignatures ? JSON.stringify(slot.inputContentSignatures) : null, slot.lastInputMessageId, slot.modelKey, slot.providerKey, slot.capturedAt, slot.rowVersion ?? null, slot.captureSequence ?? null);
     return true;
   } catch (error) {
     sessionLog(sessionId, "LKG snapshot persistence failed (in-memory slot retained):", error);
@@ -23624,7 +24024,8 @@ function registerLkgPersistence(backend) {
 }
 function slotBytes(slot) {
   const digestBytes = slot.inputContentDigests.reduce((total, digest) => total + 2 * digest.length, 0);
-  return 2 * slot.jsonPrefix.length + digestBytes + LKG_METADATA_BYTES;
+  const ownershipBytes = slot.piOutputEntryIds?.reduce((total, id) => total + (id?.length ?? 0) * 2 + 8, 0) ?? 0;
+  return 2 * slot.jsonPrefix.length + digestBytes + ownershipBytes + LKG_METADATA_BYTES;
 }
 var LKG_SNAPSHOT_ARRAY = Symbol("array");
 var LKG_SNAPSHOT_OBJECT = Symbol("object");
@@ -23785,6 +24186,7 @@ function captureSlot(sessionId, slot) {
   const entry = {
     slot: {
       ...slot,
+      ...slot.piOutputEntryIds ? { piOutputEntryIds: [...slot.piOutputEntryIds] } : {},
       inputIdSeq: [...slot.inputIdSeq],
       inputContentDigests: [...slot.inputContentDigests],
       inputContentSignatures: slot.inputContentSignatures ? [...slot.inputContentSignatures] : undefined
@@ -23823,6 +24225,7 @@ function installHydratedSlot(sessionId, slot) {
   const entry = {
     slot: {
       ...slot,
+      ...slot.piOutputEntryIds ? { piOutputEntryIds: [...slot.piOutputEntryIds] } : {},
       inputIdSeq: [...slot.inputIdSeq],
       inputContentDigests: [...slot.inputContentDigests],
       inputContentSignatures: slot.inputContentSignatures ? [...slot.inputContentSignatures] : undefined
@@ -23855,6 +24258,7 @@ function hydrateSlotFromPersistence(sessionId) {
 function copySlotForRead(slot) {
   return {
     ...slot,
+    ...slot.piOutputEntryIds ? { piOutputEntryIds: [...slot.piOutputEntryIds] } : {},
     inputIdSeq: [...slot.inputIdSeq],
     inputContentDigests: [...slot.inputContentDigests],
     inputContentSignatures: slot.inputContentSignatures ? [...slot.inputContentSignatures] : undefined
@@ -24333,16 +24737,13 @@ function snapshotInputs(messages, entryIds) {
   }
   const inputs = [];
   const seen = new Set;
-  for (let index = firstStableIndex;index < entryIds.length; index += 1) {
-    const id = entryIds[index];
-    if (typeof id !== "string" || id.length === 0) {
-      return { inputs: [], failure: "lkg_entry_id_gap" };
-    }
-    if (seen.has(id))
-      return { inputs: [], failure: "lkg_duplicate_entry_id" };
+  for (let index = 0;index < entryIds.length; index += 1) {
     const fields = lkgContentFields(messages[index]);
     if (!fields)
       return { inputs: [], failure: "lkg_content_snapshot_failed" };
+    const id = entryIds[index] || `pi-lkg-unmapped:${lkgContentDigestFromFields(fields)}`;
+    if (seen.has(id))
+      return { inputs: [], failure: "lkg_duplicate_entry_id" };
     seen.add(id);
     inputs.push({ id, messageIndex: index, fields });
   }
@@ -24438,6 +24839,29 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
     if (snapshot.replayAnchorInputIndex === null || snapshot.pristineTail === null) {
       return { ok: false, reason: "lkg_miss" };
     }
+    const slot = getSlot(snapshot.sessionId);
+    const start = slot?.inputIdSeq.indexOf(snapshot.inputs[0]?.id ?? "") ?? -1;
+    if (slot && start > 0) {
+      const ownership = slot.piOutputEntryIds;
+      if (!ownership)
+        return { ok: false, reason: "lkg_output_mapping_unavailable" };
+      if (slot.modelKey !== snapshot.modelKey || slot.providerKey !== snapshot.providerKey)
+        return { ok: false, reason: "lkg_model_mismatch" };
+      const surviving = snapshot.inputs.slice(0, snapshot.replayAnchorInputIndex + 1);
+      if (surviving.length !== slot.inputIdSeq.length - start || surviving.some((input, index) => input.id !== slot.inputIdSeq[start + index]))
+        return { ok: false, reason: "lkg_invalidated_reshape" };
+      if (surviving.some((input, index) => lkgContentDigestFromFields(input.fields) !== slot.inputContentDigests[start + index]))
+        return { ok: false, reason: "lkg_content_mismatch" };
+      const removed = new Set(slot.inputIdSeq.slice(0, start));
+      const prefix = JSON.parse(slot.jsonPrefix);
+      return {
+        ok: true,
+        messages: [
+          ...prefix.filter((_, index) => ownership[index] === null || !removed.has(ownership[index] ?? "")),
+          ...snapshot.pristineTail
+        ]
+      };
+    }
     const entry = {
       pristineTail: snapshot.pristineTail,
       entryInputIds: snapshot.inputs.map((input) => input.id),
@@ -24474,6 +24898,22 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
       return;
     }
     const state = stateFor(snapshot.sessionId);
+    const idsByDigest = new Map;
+    if (!args.outputEntryIds)
+      for (const input of snapshot.inputs) {
+        const digest = lkgContentDigestFromFields(input.fields);
+        idsByDigest.set(digest, idsByDigest.has(digest) ? undefined : input.id);
+      }
+    const inferredIds = args.outputEntryIds ?? args.outputMessages.map((message) => {
+      const fields = lkgContentFields(message);
+      if (!fields)
+        return;
+      const digest = lkgContentDigestFromFields(fields);
+      return idsByDigest.get(digest);
+    });
+    const outputIds = args.outputEntryIds ?? inferredIds;
+    const inputIds = new Set(snapshot.inputs.map((input) => input.id));
+    const ownership = outputIds.length === args.outputMessages.length && outputIds.every((id) => id === null || typeof id === "string" && inputIds.has(id)) ? [...outputIds] : undefined;
     state.captureSequence += 1;
     const plan = {
       sessionId: snapshot.sessionId,
@@ -24514,6 +24954,7 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
         reusedPrefix = incremental.reusedPrefix;
         const slot = {
           jsonPrefix: plan.jsonPrefix,
+          piOutputEntryIds: ownership,
           inputIdSeq,
           inputContentDigests: incremental.digests,
           inputContentSignatures,
@@ -24561,6 +25002,24 @@ function createPiLkgCoordinator(db, scheduleCapture = (capture) => setImmediate(
   };
   return { beginPass, replay, captureAppliedPass };
 }
+function resolvePiLkgOutputEntryIds(messages, syntheticLeadingCount, entryId) {
+  const ids = messages.map((message, index) => index < syntheticLeadingCount ? null : isRecord(message) ? entryId(message) : undefined);
+  const syntheticOwners = new Map;
+  for (let index = 0;index < messages.length; index++) {
+    const message = messages[index];
+    const owner = ids[index];
+    if (typeof owner !== "string" || !isRecord(message) || message.role !== "assistant" || !Array.isArray(message.content))
+      continue;
+    for (const part of message.content) {
+      if (isRecord(part) && part.type === "toolCall" && part.syntheticTodoMarker === true && typeof part.id === "string")
+        syntheticOwners.set(part.id, syntheticOwners.has(part.id) ? undefined : owner);
+    }
+  }
+  return ids.map((id, index) => {
+    const message = messages[index];
+    return id === undefined && isRecord(message) && message.role === "toolResult" && message.syntheticTodoMarker === true && typeof message.toolCallId === "string" ? syntheticOwners.get(message.toolCallId) : id;
+  });
+}
 
 // src/pi-pressure.ts
 function extractAssistantUsage(message) {
@@ -26405,7 +26864,9 @@ function createPiAssistantPart(working, messageIndex, partIndex, markDirty) {
     canRemove() {
       const message = working[messageIndex];
       const part = message.content[partIndex];
-      return part?.type === "toolCall" && canRemoveNativeToolCall(message, part.id) && toolRemovalAuthorization.get(working)?.(part.id) !== false;
+      if (part?.type !== "toolCall" || !canRemoveNativeToolCall(message, part.id))
+        return false;
+      return toolRemovalAuthorization.get(working)?.(part.id) ?? true;
     },
     remove() {
       return markToolRemoval(working, messageIndex, partIndex);
@@ -27439,6 +27900,9 @@ function registerPiContextHandler(pi, baseOptions) {
         modelKey: lkgModelKey,
         providerKey: lkgProviderKey
       });
+      const lkgInputIdByRef = new Map;
+      for (const input of lkgPassSnapshot.inputs)
+        lkgInputIdByRef.set(event.messages[input.messageIndex], input.id);
       const thinkingBindingRecoveryApplied = applyPiThinkingBindingRecovery({
         db: options.db,
         sessionId,
@@ -27747,6 +28211,7 @@ function registerPiContextHandler(pi, baseOptions) {
         projectDirectory,
         sessionMeta,
         messages: event.messages,
+        lkgEntryIds: event.messages.map((message) => lkgInputIdByRef.get(message)),
         smartDrops: options.smartDrops === true,
         protectedTags: options.protectedTags ?? 20,
         protectedTokens: options.protectedTokens,
@@ -28026,6 +28491,7 @@ function registerPiContextHandler(pi, baseOptions) {
         lkgCoordinator.captureAppliedPass({
           snapshot: lkgPassSnapshot,
           outputMessages,
+          outputEntryIds: resolvePiLkgOutputEntryIds(outputMessages, result.syntheticLeadingCount, (message) => result.postCommitEntryIdByRef.get(message) ?? result.lkgEntryIdByRef.get(message)),
           cacheBusting: result.bustedThisPass
         });
       }
@@ -28586,7 +29052,8 @@ async function runCompactionOffPipeline(args) {
       protectedTagNumbers: new Set,
       pendingDropTagNumbers: new Set
     },
-    postCommitEntryIdByRef: new Map
+    postCommitEntryIdByRef: new Map,
+    lkgEntryIdByRef: new Map
   };
 }
 async function runPipeline(args) {
@@ -28628,22 +29095,13 @@ async function runPipeline(args) {
   const tTranscriptBuild = performance.now();
   const transcript = createPiTranscript(args.messages, args.sessionId, args.entryIds, {
     preserveReasoningToolArcs: args.reasoningClearing?.preserveReasoningToolArcs,
-    authorizeToolRemoval: (callId) => {
-      if (!nativeRemovalInputs)
-        return false;
-      if (nativeRemovalInputs.get(callId) === NATIVE_TOOL_REMOVAL_MARKER)
-        return true;
-      if (!isCacheBustingPass)
-        return false;
-      try {
-        saveNativeToolInputs(args.db, args.sessionId, new Map([[callId, NATIVE_TOOL_REMOVAL_MARKER]]));
-        nativeRemovalInputs.set(callId, NATIVE_TOOL_REMOVAL_MARKER);
-        return true;
-      } catch (error) {
-        sessionLog(args.sessionId, `tool arc removal persistence failed; retaining pair: ${String(error)}`);
-        return false;
-      }
-    }
+    authorizeToolRemoval: (callId) => authorizePiToolRemoval({
+      db: args.db,
+      sessionId: args.sessionId,
+      callId,
+      saved: nativeRemovalInputs,
+      canApply: isCacheBustingPass
+    })
   });
   logTransformTiming(args.sessionId, "transcriptBuild", tTranscriptBuild);
   const workingMessages = transcript.getWorkingMessages();
@@ -29189,6 +29647,7 @@ async function runPipeline(args) {
   const tPostCommitStableIdMaps = performance.now();
   const postCommitStableIdByRef = new Map;
   const postCommitEntryIdByRef = new Map;
+  const lkgEntryIdByRef = new Map;
   for (let i = 0;i < args.messages.length; i++) {
     const m = args.messages[i];
     if (!m || typeof m !== "object")
@@ -29196,6 +29655,9 @@ async function runPipeline(args) {
     const id = resolvePiStableId(m, i, args.entryIds, args.entryIdByRef ?? undefined);
     if (id)
       postCommitStableIdByRef.set(m, id);
+    const lkgId = args.lkgEntryIds?.[i];
+    if (lkgId)
+      lkgEntryIdByRef.set(m, lkgId);
     const realId = args.entryIds?.[i];
     if (typeof realId === "string" && realId.length > 0) {
       postCommitEntryIdByRef.set(m, realId);
@@ -29360,7 +29822,8 @@ async function runPipeline(args) {
     reasoningWatermark: args.sessionMeta.clearedReasoningThroughTag ?? 0,
     activeTags,
     channelBaselineSnapshot,
-    postCommitEntryIdByRef
+    postCommitEntryIdByRef,
+    lkgEntryIdByRef
   };
 }
 var AUTO_SEARCH_NO_HINT_REASONS = new Set([
@@ -30269,10 +30732,10 @@ Found ${existingStaging.compartments.length} staged compartment(s) from ${existi
           }
         }
       }
+      sessionLog(sessionId, `recomp partial code=${userFacingFailureCode("recomp_unavailable")} reason="${reason}"`);
       return [
-        `Persisted ${promoted.compartments.length} compartment${promoted.compartments.length === 1 ? "" : "s"} from ${passCount} successful pass${passCount === 1 ? "" : "es"}.`,
-        `Covered raw history 1-${lastCompartmentEnd} out of ${rawMessageCount} total messages.`,
-        `Remaining messages ${lastCompartmentEnd + 1}-${protectedTailStart - 1} were not rebuilt (${reason}).`
+        `Rebuilt ${promoted.compartments.length} history block${promoted.compartments.length === 1 ? "" : "s"} across ${passCount} successful pass${passCount === 1 ? "" : "es"}.`,
+        renderUserFacingFailure("recomp_unavailable")
       ].join(`
 `);
     }
@@ -30297,11 +30760,10 @@ Recomp stopped because raw history ${offset}-${protectedTailStart - 1} could not
 
 ${partial}`;
         }
+        sessionLog(sessionId, `recomp failed code=${userFacingFailureCode("recomp_unavailable")} reason="${chunkCoverageError}"`);
         return `## Magic Recomp — Failed
 
-Recomp stopped because the raw chunk could not be represented safely: ${chunkCoverageError}
-
-Nothing was written.`;
+${renderUserFacingFailure("recomp_unavailable")}`;
       }
       const references = buildReferenceBlocks({
         sessionId,
@@ -30343,11 +30805,10 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         callbacks: {
           onRepairRetry: async (error) => {
             emitProgress(`Repair retry (pass ${passCount + 1})…`);
+            sessionLog(sessionId, `recomp retry code=${userFacingFailureCode("recomp_unavailable")} reason="${error}"`);
             await sendStatusNotification(client, sessionId, `## Magic Recomp
 
-Historian pass ${passCount + 1}, attempt ${passAttempt} is continuing with a repair retry for messages ${chunk.startIndex}-${chunk.endIndex}.
-
-The previous output did not validate: ${error}`, notifParams());
+History compression is retrying this pass. ${renderUserFacingFailure("recomp_unavailable")}`, notifParams());
           },
           onModelFallback: (modelId, index, total) => {
             const short = modelId.includes("/") ? modelId.split("/").pop() : modelId;
@@ -30362,9 +30823,7 @@ The previous output did not validate: ${error}`, notifParams());
           if (smallerChunk.messageCount > 0 && smallerChunk.endIndex < chunk.endIndex) {
             await sendStatusNotification(client, sessionId, `## Magic Recomp
 
-Historian pass ${passCount + 1}, attempt ${passAttempt} is continuing with a smaller chunk ending at ${smallerChunk.endIndex} because messages ${chunk.startIndex}-${chunk.endIndex} could not be validated.
-
-Validator result: ${validatedPass.error}`, notifParams());
+History compression is retrying with a smaller set of messages. ${renderUserFacingFailure("recomp_unavailable")}`, notifParams());
             currentTokenBudget = reducedBudget;
             passAttempt += 1;
             continue;
@@ -30381,7 +30840,8 @@ Validator result: ${validatedPass.error}`, notifParams());
           chunkEndOrdinal: chunk.endIndex,
           compartmentsProduced: 0
         });
-        const partial = await promoteAndFinalize(`historian failed to validate messages ${chunk.startIndex}-${chunk.endIndex}: ${validatedPass.error}`);
+        sessionLog(sessionId, `recomp failed code=${userFacingFailureCode("recomp_unavailable")} reason="${validatedPass.error}" messageRange=${chunk.startIndex}-${chunk.endIndex}`);
+        const partial = await promoteAndFinalize(`history model response did not validate for messages ${chunk.startIndex}-${chunk.endIndex}`);
         if (partial) {
           return `## Magic Recomp — Partial
 
@@ -30389,9 +30849,7 @@ ${partial}`;
         }
         return `## Magic Recomp — Failed
 
-Recomp failed while rebuilding messages ${chunk.startIndex}-${chunk.endIndex}: ${validatedPass.error}
-
-Nothing was written.`;
+${renderUserFacingFailure("recomp_unavailable")}`;
       }
       {
         const passComps = validatedPass.compartments ?? [];
@@ -30442,11 +30900,10 @@ Recomp made no forward progress after messages ${chunk.startIndex}-${chunk.endIn
     const mergedValidationError = validateStoredCompartments(candidateCompartments);
     if (mergedValidationError) {
       clearRecompStaging(db, sessionId);
+      sessionLog(sessionId, `recomp failed code=${userFacingFailureCode("recomp_unavailable")} reason="${mergedValidationError}"`);
       return `## Magic Recomp — Failed
 
-Recomp completed ${passCount} pass${passCount === 1 ? "" : "es"} but produced an invalid final compartment set: ${mergedValidationError}
-
-Nothing was written.`;
+${renderUserFacingFailure("recomp_unavailable")}`;
     }
     saveRecompStagingPass(db, sessionId, passCount, candidateCompartments, candidateFacts);
     const lastCompartmentEnd = candidateCompartments[candidateCompartments.length - 1]?.endMessage ?? 0;
@@ -30498,11 +30955,10 @@ Another process acquired the compartment-state lease before recomp could publish
 `);
   } catch (error) {
     const message = getErrorMessage(error);
+    sessionLog(sessionId, `recomp failed code=${userFacingFailureCode("recomp_unavailable")} reason="${message}"`);
     return `## Magic Recomp — Failed
 
-Recomp failed unexpectedly: ${message}
-
-Staging data preserved for resume on next attempt.`;
+${renderUserFacingFailure("recomp_unavailable")}`;
   } finally {
     updateSessionMeta(db, sessionId, { compartmentInProgress: false });
     cleanupHistorianStateFile(currentStateFilePath);
@@ -30720,11 +31176,10 @@ Recomp stopped because raw history ${offset}-${snapEnd} could not be turned into
       }
       const chunkCoverageError = validateChunkCoverage(chunk);
       if (chunkCoverageError) {
+        log(`[magic-context] partial recomp failed session=${sessionId} code=${userFacingFailureCode("recomp_unavailable")} reason="${chunkCoverageError}"`);
         return `## Magic Recomp — Failed
 
-Partial recomp stopped because the raw chunk could not be represented safely: ${chunkCoverageError}
-
-Original state preserved (staging kept for retry).`;
+${renderUserFacingFailure("recomp_unavailable")}`;
       }
       const references = buildReferenceBlocks({
         sessionId,
@@ -30764,11 +31219,10 @@ Historian pass ${passCount + 1}, attempt ${passAttempt} started for messages ${c
         language: deps.language,
         callbacks: {
           onRepairRetry: async (error) => {
+            log(`[magic-context] partial recomp retry session=${sessionId} code=${userFacingFailureCode("recomp_unavailable")} reason="${error}"`);
             await sendStatusNotification(client, sessionId, `## Magic Recomp — Partial
 
-Historian pass ${passCount + 1}, attempt ${passAttempt} is continuing with a repair retry for messages ${chunk.startIndex}-${chunk.endIndex}.
-
-The previous output did not validate: ${error}`, notifParams());
+History compression is retrying this pass. ${renderUserFacingFailure("recomp_unavailable")}`, notifParams());
           }
         }
       });
@@ -30779,19 +31233,16 @@ The previous output did not validate: ${error}`, notifParams());
           if (smallerChunk.messageCount > 0 && smallerChunk.endIndex < chunk.endIndex) {
             await sendStatusNotification(client, sessionId, `## Magic Recomp — Partial
 
-Historian pass ${passCount + 1}, attempt ${passAttempt} is continuing with a smaller chunk ending at ${smallerChunk.endIndex} because messages ${chunk.startIndex}-${chunk.endIndex} could not be validated.
-
-Validator result: ${validatedPass.error}`, notifParams());
+History compression is retrying with a smaller set of messages. ${renderUserFacingFailure("recomp_unavailable")}`, notifParams());
             currentTokenBudget = reducedBudget;
             passAttempt += 1;
             continue;
           }
         }
+        log(`[magic-context] partial recomp failed session=${sessionId} code=${userFacingFailureCode("recomp_unavailable")} reason="${validatedPass.error}" messageRange=${chunk.startIndex}-${chunk.endIndex}`);
         return `## Magic Recomp — Failed
 
-Partial recomp failed while rebuilding messages ${chunk.startIndex}-${chunk.endIndex}: ${validatedPass.error}
-
-Original state preserved (staging kept for retry).`;
+${renderUserFacingFailure("recomp_unavailable")}`;
       }
       candidateCompartments = [
         ...candidateCompartments,
@@ -30826,11 +31277,10 @@ Partial recomp completed historian passes but the final compartment set failed v
 `);
   } catch (error) {
     const message = getErrorMessage(error);
+    log(`[magic-context] partial recomp failed session=${sessionId} code=${userFacingFailureCode("recomp_unavailable")} reason="${message}"`);
     return `## Magic Recomp — Failed
 
-Partial recomp failed unexpectedly: ${message}
-
-Staging preserved for resume on next attempt.`;
+${renderUserFacingFailure("recomp_unavailable")}`;
   } finally {
     updateSessionMeta(db, sessionId, { compartmentInProgress: false });
     const leftoverStaging = getRecompStaging(db, sessionId);
@@ -31952,6 +32402,78 @@ ${migrationSummary}` : "",
   });
 }
 
+// src/dialogs/status-dialog.ts
+import {
+  matchesKey as matchesKey2,
+  truncateToWidth,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+
+// ../plugin/src/shared/format-bytes.ts
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+// ../plugin/src/hooks/magic-context/m0-token-breakdown.ts
+function computeM0BlockTokens(db, sessionId, args) {
+  const {
+    m0Text,
+    projectIdentity,
+    injectionBudgetTokens,
+    memoryBlockCount,
+    compartmentTokensOverride
+  } = args;
+  const docsBlock = extractM0Block(m0Text, "project-docs");
+  const docsTokens = docsBlock ? estimateTokens(docsBlock) : 0;
+  const profileBlock = extractM0Block(m0Text, "user-profile");
+  const profileTokens = profileBlock ? estimateTokens(profileBlock) : 0;
+  let memoryTokens = 0;
+  let memoryFromM0 = false;
+  const memoryBlock = extractM0Block(m0Text, "project-memory");
+  if (memoryBlock) {
+    memoryTokens = estimateTokens(memoryBlock);
+    memoryFromM0 = true;
+  }
+  const muralTokens = m0Text.includes("<memory-mural>") ? 1521 : 0;
+  let compartmentTokens = 0;
+  const historyBlock = extractM0Block(m0Text, "session-history");
+  if (typeof compartmentTokensOverride === "number" && Number.isFinite(compartmentTokensOverride) && compartmentTokensOverride >= 0) {
+    compartmentTokens = compartmentTokensOverride;
+  } else if (historyBlock) {
+    compartmentTokens = estimateTokens(historyBlock);
+  } else {
+    try {
+      const compRows = db.prepare("SELECT content, title, start_message, end_message FROM compartments WHERE session_id = ?").all(sessionId);
+      for (const c of compRows) {
+        compartmentTokens += estimateTokens(`## ${c.start_message}-${c.end_message} · ${c.title}
+${c.content}
+`);
+      }
+    } catch {}
+  }
+  if (!memoryFromM0 && memoryBlockCount > 0 && projectIdentity) {
+    try {
+      const memories = getMemoriesByProject(db, projectIdentity, ["active", "permanent"]);
+      const selected = injectionBudgetTokens ? trimMemoriesToBudgetV2(sessionId, memories, injectionBudgetTokens).renderOrder : memories;
+      const block = renderMemoryBlockV2(selected);
+      memoryTokens = block ? estimateTokens(block) : 0;
+    } catch {
+      memoryTokens = 0;
+    }
+  }
+  return {
+    docsTokens,
+    profileTokens,
+    memoryTokens,
+    muralTokens,
+    compartmentTokens,
+    factTokens: 0
+  };
+}
+
 // ../plugin/src/shared/cache-ttl-display.ts
 function resolveCacheTtlDisplay(args) {
   if (args.sessionModelKey && (!args.modelKey || args.sessionModelKey === args.modelKey) || !args.modelKey && !args.sessionModelKey && args.sessionValue !== "5m") {
@@ -32005,8 +32527,75 @@ function formatThresholdClampNote(opts) {
   return ` [clamped: ${opts.configuredValue}% > ${opts.maxPercentage}%]`;
 }
 
-// ../plugin/src/shared/rust-mode-status.ts
-var RUST_MODE_HOST_PATHS_LINE = "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side";
+// ../plugin/src/shared/status-summary.ts
+function formatCount(value) {
+  return Math.round(value).toLocaleString();
+}
+function compressionText(summary) {
+  const historyBlocks = `${summary.compression.historyBlockCount} history block${summary.compression.historyBlockCount === 1 ? "" : "s"}`;
+  switch (summary.compression.state) {
+    case "off":
+      return "Off";
+    case "compressing":
+      return `Compressing history · ${historyBlocks}`;
+    case "ready":
+      return `Ready · ${historyBlocks}`;
+    case "waiting":
+      return "Waiting for enough conversation history";
+  }
+}
+function reclaimableText(summary) {
+  const count = Math.max(0, Math.floor(summary.reclaimable.toolOutputCount));
+  if (count === 0)
+    return "none";
+  const outputs = `${count} spent tool output${count === 1 ? "" : "s"}`;
+  return `${outputs} (~${Math.round(Math.max(0, summary.reclaimable.tokens) / 1000)}k tokens)`;
+}
+function embeddingText(summary) {
+  if (summary.embedding.state === "off")
+    return "Off";
+  const coverage = `${formatCount(summary.embedding.indexed)} / ${formatCount(summary.embedding.total)} history blocks indexed`;
+  switch (summary.embedding.state) {
+    case "running":
+      return `Running · ${coverage}`;
+    case "paused":
+      return `Paused · ${coverage}`;
+    case "stopped":
+      return `Paused after an issue · ${coverage}`;
+    case "ready":
+      return `Ready · ${coverage}`;
+    case "waiting":
+      return `Waiting · ${coverage}`;
+  }
+}
+function renderUserStatusSummary(summary, style) {
+  const context = `${summary.usagePercentage.toFixed(1)}% of usable context (${formatCount(summary.inputTokens)} / ${summary.usableContextTokens > 0 ? formatCount(summary.usableContextTokens) : "?"} tokens)`;
+  const values = [
+    ["Context", context],
+    ["Cache lifetime", summary.cacheLifetime],
+    [
+      "Automatic compression",
+      summary.automaticCompressionThreshold === null ? "Off" : `at ${summary.automaticCompressionThreshold.toFixed(1)}% of usable context`
+    ],
+    ["History compression", compressionText(summary)],
+    ["Reclaimable", reclaimableText(summary)],
+    [
+      "Memory",
+      `${formatCount(summary.memoryCount)} memories · ${formatCount(summary.noteCount)} notes`
+    ],
+    ["Search indexing", embeddingText(summary)]
+  ];
+  const lines = style === "markdown" ? [
+    "## Magic Context Status",
+    "",
+    ...values.map(([label, value]) => `- **${label}:** ${value}`)
+  ] : ["Magic Context Status", ...values.map(([label, value]) => `${label}: ${value}`)];
+  for (const warning of summary.warnings) {
+    lines.push(style === "markdown" ? `- **Warning:** ${renderUserFacingFailure(warning)}` : `Warning: ${renderUserFacingFailure(warning)}`);
+  }
+  return lines.join(`
+`);
+}
 
 // ../plugin/src/shared/tail-hygiene-status.ts
 function finiteNumber(value, fallback = 0) {
@@ -32023,7 +32612,8 @@ function resolveTailHygieneStatus(tsBaseline, rustBaseline) {
       evaluable: rustBaseline.evaluable === true,
       generationInvalidated: rustBaseline.generation_invalidated === true,
       baselineGeneration: Math.max(0, finiteNumber(rustBaseline.baseline_generation)),
-      computedAt: Math.max(0, finiteNumber(rustBaseline.computed_at_ms))
+      computedAt: Math.max(0, finiteNumber(rustBaseline.computed_at_ms)),
+      reclaimableToolOutputCount: Math.max(0, Math.floor(finiteNumber(rustBaseline.reclaimable_tool_output_count)))
     };
   }
   if (tsBaseline === undefined)
@@ -32037,7 +32627,8 @@ function resolveTailHygieneStatus(tsBaseline, rustBaseline) {
     evaluable: tsBaseline.evaluable && !tsBaseline.generationInvalidated,
     generationInvalidated: tsBaseline.generationInvalidated,
     baselineGeneration: Math.max(0, tsBaseline.baselineGeneration),
-    computedAt: Math.max(0, tsBaseline.computedAt)
+    computedAt: Math.max(0, tsBaseline.computedAt),
+    reclaimableToolOutputCount: tsBaseline.baselineParts.filter((part) => part.kind === "toolOutput" && part.uTokens > 0).length
   };
 }
 function formatTailHygiene(status) {
@@ -32045,223 +32636,10 @@ function formatTailHygiene(status) {
   const state = status.evaluable ? "" : " · held until baseline refresh";
   return `${percentage}% · ${status.u.toLocaleString()} / ${status.t.toLocaleString()} tok${state}`;
 }
-
-// ../plugin/src/shared/format-bytes.ts
-function formatBytes(bytes) {
-  if (bytes < 1024)
-    return `${bytes}B`;
-  if (bytes < 1024 * 1024)
-    return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-// ../plugin/src/hooks/magic-context/execute-status.ts
-function formatExecuteThreshold(detail, contextLimit) {
-  const { percentage, mode } = detail;
-  const clampNote = formatThresholdClampNote({
-    clamped: detail.clamped,
-    mode,
-    configuredValue: detail.configuredValue,
-    contextLimit,
-    maxPercentage: MAX_EXECUTE_THRESHOLD
-  });
-  if (mode === "tokens" && contextLimit > 0) {
-    const tokens = Math.floor(percentage / 100 * contextLimit);
-    return `${tokens.toLocaleString()} tokens (${percentage.toFixed(1)}% of ${contextLimit.toLocaleString()}) [token-mode]${clampNote}`;
-  }
-  if (contextLimit > 0) {
-    const tokens = Math.floor(percentage / 100 * contextLimit);
-    return `${percentage}% (${tokens.toLocaleString()} of ${contextLimit.toLocaleString()})${clampNote}`;
-  }
-  return `${percentage}%${clampNote}`;
-}
-function executeStatus(db, sessionId, executeThresholdPercentageConfig = DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, liveModelKey, historyBudgetPercentage, commitClusterTrigger, executeThresholdTokens, contextLimit, dreamer, windowGeometry, tailHygiene, contextUsage, rustMode = false, display) {
-  const thresholdDetail = resolveExecuteThresholdDetail(executeThresholdPercentageConfig, liveModelKey, DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE, {
-    tokensConfig: executeThresholdTokens,
-    contextLimit,
-    sessionId
-  });
-  const executeThresholdPercentage = thresholdDetail.percentage;
-  const openCodeDbResolution = resolveOpenCodeDbPath();
-  const openCodeDbReadFailure = getOpenCodeDbReadFailure();
-  const openCodeDbStatusLine = !openCodeDbPathExists(openCodeDbResolution) ? formatOpenCodeDbMissingStatusLine(openCodeDbResolution) : openCodeDbReadFailure?.path === openCodeDbResolution.path ? formatOpenCodeDbReadFailureStatusLine(openCodeDbReadFailure) : null;
-  try {
-    const meta = getOrCreateSessionMeta(db, sessionId);
-    const tags = getTagsBySession(db, sessionId);
-    const pendingOps = getPendingOps(db, sessionId);
-    const protectionWindow = getProtectionWindowForSession(db, sessionId);
-    const activeTags = tags.filter((t) => t.status === "active");
-    const droppedTags = tags.filter((t) => t.status === "dropped");
-    const totalBytes = activeTags.reduce((sum, t) => sum + t.byteSize, 0);
-    const ttlDisplay = resolveCacheTtlDisplay({
-      configured: display?.cacheTtlConfig ?? "5m",
-      configuredExplicitly: display?.cacheTtlConfigured === true,
-      modelKey: liveModelKey,
-      sessionValue: meta.cacheTtl,
-      sessionModelKey: meta.lastObservedModelKey
-    });
-    let ttlMs;
-    try {
-      ttlMs = parseCacheTtl(ttlDisplay.value);
-    } catch (error) {
-      sessionLog(sessionId, `invalid cache_ttl "${ttlDisplay.value}" in ctx-status; falling back to default 5m`, error);
-      ttlMs = parseCacheTtl("5m");
-    }
-    const elapsed = Date.now() - meta.lastResponseTime;
-    const remainingMs = Math.max(0, ttlMs - elapsed);
-    const cacheExpired = remainingMs === 0 && meta.lastResponseTime > 0;
-    const proactiveCompartmentTrigger = getProactiveCompartmentTriggerPercentage(executeThresholdPercentage);
-    const displayInputTokens = contextUsage?.inputTokens ?? meta.lastInputTokens;
-    const displayPercentage = contextUsage?.percentage ?? meta.lastContextPercentage;
-    const displayContextLimit = contextLimit && contextLimit > 0 ? contextLimit : displayPercentage > 0 ? Math.round(displayInputTokens / (displayPercentage / 100)) : 0;
-    const parseFailureLines = (display?.configParseFailures ?? []).map(formatConfigParseStatusLine);
-    const lines = [
-      ...openCodeDbStatusLine ? [openCodeDbStatusLine, ""] : [],
-      ...parseFailureLines,
-      ...parseFailureLines.length > 0 ? [""] : [],
-      "## Magic Status",
-      "",
-      `**Session:** ${sessionId}`,
-      `**Tag counter:** ${meta.counter}`,
-      "",
-      "### Tags",
-      `- Active: ${activeTags.length} (~${formatBytes(totalBytes)})`,
-      `- Dropped: ${droppedTags.length}`,
-      `- Total: ${tags.length}`,
-      "",
-      "### Pending Queue",
-      `- Drops: ${pendingOps.length}`,
-      `- Total queued: ${pendingOps.length}`,
-      "",
-      ...meta.lastTransformError ? ["### Last Transform Error", `- ${meta.lastTransformError}`, ""] : [],
-      "### Cache TTL",
-      `- ${formatCacheTtlDisplay(ttlDisplay)}`,
-      `- Last response: ${meta.lastResponseTime > 0 ? `${Math.round(elapsed / 1000)}s ago` : "never"}`,
-      `- Remaining: ${cacheExpired ? "expired" : ttlMs === Number.POSITIVE_INFINITY ? "never (MC never assumes expiry — external cache-keep)" : `${Math.round(remainingMs / 1000)}s`}`,
-      `- Queue will auto-execute: ${cacheExpired ? "yes (cache expired)" : ttlMs === Number.POSITIVE_INFINITY ? `when context >= ${executeThresholdPercentage}%` : `when TTL expires or context >= ${executeThresholdPercentage}%`}`,
-      "",
-      "### Execute Threshold",
-      `- Execute threshold: ${formatExecuteThreshold(thresholdDetail, displayContextLimit)}`,
-      `- Last input tokens: ${displayInputTokens.toLocaleString()} tokens`,
-      "",
-      `**Protected tool tags:** ${protectionWindow.status.protectedCount} (${protectionWindow.status.protectedMass.toLocaleString()} tokens)`,
-      `**Protection floor:** ${protectionWindow.status.floor.toLocaleString()} tokens`,
-      `**Subagent session:** ${meta.isSubagent}`
-    ];
-    const storage = getMagicContextStorageResolution();
-    lines.push("", `**Storage:** ${storage.path} (${storage.source})`);
-    if (rustMode)
-      lines.push("", "### Rust Mode", `- ${RUST_MODE_HOST_PATHS_LINE}`);
-    if (tailHygiene !== undefined) {
-      lines.push("", "### Tail Hygiene", `- Reclaimable / eligible: ${formatTailHygiene(tailHygiene)}`, "- Reasoning is excluded from both terms.");
-    }
-    if (dreamer?.backlog && Object.keys(dreamer.backlog).length > 0) {
-      lines.push("", "### Dreamer", ...dreamer.progress ? [
-        `- Running: ${dreamer.progress.task} — ${dreamer.progress.processed}/${dreamer.progress.total} processed`
-      ] : [], ...formatDreamTaskBacklogs(dreamer.backlog).split("\\n"));
-    }
-    if (displayPercentage > 0 || displayInputTokens > 0) {
-      lines.push("", "### Context Usage", `- Last percentage: ${displayPercentage.toFixed(1)}%`, `- Last input tokens: ${displayInputTokens.toLocaleString()}`, `- Resolved context limit: ${displayContextLimit > 0 ? displayContextLimit.toLocaleString() : "unknown"}`, ...windowGeometry ? [`- ${formatWindowDerivationLine(displayInputTokens, windowGeometry)}`] : [], `- Proactive compartment evaluation: ${proactiveCompartmentTrigger}%`, `- Post-drop target for historian: ${(executeThresholdPercentage * POST_DROP_TARGET_RATIO).toFixed(0)}% (${executeThresholdPercentage}% * ${POST_DROP_TARGET_RATIO})`, `- Commit cluster trigger: ${commitClusterTrigger?.enabled !== false ? `enabled (min ${commitClusterTrigger?.min_clusters ?? 3} clusters)` : "disabled"}, tail-size trigger: > 3x compartment budget`);
-    }
-    const compartments = getCompartments(db, sessionId);
-    let historyBlockTokens = 0;
-    for (const c of compartments) {
-      historyBlockTokens += estimateTokens(`## ${c.startMessage}-${c.endMessage} · ${c.title}
-${c.content}
-`);
-    }
-    const budgetTokens = historyBudgetPercentage && displayContextLimit > 0 ? Math.floor(displayContextLimit * (Math.min(executeThresholdPercentage, 80) / 100) * historyBudgetPercentage) : null;
-    const budgetUsage = budgetTokens ? (historyBlockTokens / budgetTokens * 100).toFixed(0) : null;
-    lines.push("", "### History Compression", `- Compartments: ${compartments.length}`, `- History block: ~${historyBlockTokens.toLocaleString()} tokens`, ...budgetTokens ? [
-      `- History budget: ~${budgetTokens.toLocaleString()} tokens (${budgetUsage}% used)`,
-      `- Older compartments demote tiers automatically at render time to fit the budget`
-    ] : [`- History budget: not configured (history_budget_percentage not set)`]);
-    if (pendingOps.length > 0) {
-      lines.push("", "### Queued Operations");
-      for (const op of pendingOps) {
-        lines.push(`- §${op.tagId}§ → ${op.operation}`);
-      }
-    }
-    if (dreamer?.backlog && Object.keys(dreamer.backlog).length > 0) {
-      lines.push("", "### Dreamer Backlog", formatDreamTaskBacklogs(dreamer.backlog));
-    }
-    if (dreamer?.progress) {
-      lines.push("", "### Dreamer Progress", `- ${dreamer.progress.task}: ${dreamer.progress.processed}/${dreamer.progress.total} processed this run`);
-    }
-    return lines.join(`
-`);
-  } catch (error) {
-    sessionLog(sessionId, "ctx-status failed:", error);
-    return `Error: Failed to read context status. ${getErrorMessage(error)}`;
-  }
-}
-
-// src/dialogs/status-dialog.ts
-import {
-  matchesKey as matchesKey2,
-  truncateToWidth,
-  visibleWidth
-} from "@earendil-works/pi-tui";
-
-// ../plugin/src/hooks/magic-context/m0-token-breakdown.ts
-function computeM0BlockTokens(db, sessionId, args) {
-  const {
-    m0Text,
-    projectIdentity,
-    injectionBudgetTokens,
-    memoryBlockCount,
-    compartmentTokensOverride
-  } = args;
-  const docsBlock = extractM0Block(m0Text, "project-docs");
-  const docsTokens = docsBlock ? estimateTokens(docsBlock) : 0;
-  const profileBlock = extractM0Block(m0Text, "user-profile");
-  const profileTokens = profileBlock ? estimateTokens(profileBlock) : 0;
-  let memoryTokens = 0;
-  let memoryFromM0 = false;
-  const memoryBlock = extractM0Block(m0Text, "project-memory");
-  if (memoryBlock) {
-    memoryTokens = estimateTokens(memoryBlock);
-    memoryFromM0 = true;
-  }
-  const muralTokens = m0Text.includes("<memory-mural>") ? 1521 : 0;
-  let compartmentTokens = 0;
-  const historyBlock = extractM0Block(m0Text, "session-history");
-  if (typeof compartmentTokensOverride === "number" && Number.isFinite(compartmentTokensOverride) && compartmentTokensOverride >= 0) {
-    compartmentTokens = compartmentTokensOverride;
-  } else if (historyBlock) {
-    compartmentTokens = estimateTokens(historyBlock);
-  } else {
-    try {
-      const compRows = db.prepare("SELECT content, title, start_message, end_message FROM compartments WHERE session_id = ?").all(sessionId);
-      for (const c of compRows) {
-        compartmentTokens += estimateTokens(`## ${c.start_message}-${c.end_message} · ${c.title}
-${c.content}
-`);
-      }
-    } catch {}
-  }
-  if (!memoryFromM0 && memoryBlockCount > 0 && projectIdentity) {
-    try {
-      const memories = getMemoriesByProject(db, projectIdentity, ["active", "permanent"]);
-      const selected = injectionBudgetTokens ? trimMemoriesToBudgetV2(sessionId, memories, injectionBudgetTokens).renderOrder : memories;
-      const block = renderMemoryBlockV2(selected);
-      memoryTokens = block ? estimateTokens(block) : 0;
-    } catch {
-      memoryTokens = 0;
-    }
-  }
-  return {
-    docsTokens,
-    profileTokens,
-    memoryTokens,
-    muralTokens,
-    compartmentTokens,
-    factTokens: 0
-  };
-}
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.42.0",
+  version: "0.42.2",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -32292,7 +32670,7 @@ var package_default = {
     build: "tsc -p ../retina-local-fs/tsconfig.build.json && rm -f dist/index.js dist/subagent-entry.js dist/historian-calibration-extension.js dist/transformers-web.js dist/transformers-node-wasm.js dist/*-*.js && bun build ../plugin/src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun ../plugin/scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts src/subagent-entry.ts src/historian-calibration-extension.ts --outdir dist --target node --format esm --splitting --external @earendil-works/pi-coding-agent --external @earendil-works/pi-tui --external onnxruntime-node --external onnxruntime-web --external sharp --external node:sqlite",
     "build:e2e-argv": "bun build src/subagent-runner.ts --outfile ../../tests/docker/.generated/subagent-runner-e2e.mjs --target node --format esm --external node:sqlite",
     typecheck: "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit",
-    test: "bun install --frozen-lockfile && bun test",
+    test: "bun install --frozen-lockfile && bun test --parallel --timeout 30000",
     lint: "biome check src",
     "lint:fix": "biome check --write src",
     format: "biome format --write src",
@@ -32366,7 +32744,7 @@ var COLORS = {
   toolDefs: "#f472b6"
 };
 var REFRESH_INTERVAL_MS = 1000;
-async function showStatusDialog(pi, ctx, deps) {
+async function showStatusDialog(pi, ctx, deps, initialDiagnostics = false) {
   const sessionId = resolveSessionId(ctx);
   if (!sessionId)
     throw new Error("No active Pi session is available.");
@@ -32377,7 +32755,8 @@ async function showStatusDialog(pi, ctx, deps) {
     sessionId,
     theme,
     tui,
-    done
+    done,
+    initialDiagnostics
   }), {
     overlay: true,
     overlayOptions: { anchor: "center", width: 78 }
@@ -32389,8 +32768,10 @@ class StatusDialogComponent {
   detail;
   refreshTimer = null;
   closed = false;
+  diagnostics;
   constructor(props) {
     this.props = props;
+    this.diagnostics = props.initialDiagnostics;
     this.detail = buildPiStatusDetail(props.pi, props.ctx, props.deps, props.sessionId);
     this.refreshTimer = setInterval(() => {
       if (this.closed)
@@ -32402,6 +32783,11 @@ class StatusDialogComponent {
     }, REFRESH_INTERVAL_MS);
   }
   handleInput(data) {
+    if (matchesKey2(data, "d")) {
+      this.diagnostics = !this.diagnostics;
+      this.props.tui.requestRender();
+      return;
+    }
     if (matchesKey2(data, "escape") || matchesKey2(data, "ctrl+c") || matchesKey2(data, "return")) {
       this.close();
     }
@@ -32419,7 +32805,7 @@ class StatusDialogComponent {
   invalidate() {}
   render(width) {
     const innerWidth = Math.max(20, width - 4);
-    const inner = renderInner(this.detail, this.props.theme, innerWidth);
+    const inner = renderInner(this.detail, this.props.theme, innerWidth, this.diagnostics);
     return drawBorder(inner, width, this.props.theme);
   }
   dispose() {
@@ -32429,10 +32815,70 @@ class StatusDialogComponent {
     }
   }
 }
-function renderInner(s, theme, innerWidth) {
+function formatPiStatusSummary(s) {
+  const warnings = [];
+  if (s.lastTransformError)
+    warnings.push("transform_update_failed");
+  if (s.historianFailureCount > 0)
+    warnings.push("historian_unavailable");
+  if (s.configParseFailures.length > 0 || s.hasDeprecatedProtectedTags) {
+    warnings.push("configuration_warning");
+  }
+  if (s.embedding.state === "stopped")
+    warnings.push("embedding_unavailable");
+  return renderUserStatusSummary({
+    inputTokens: s.inputTokens,
+    usableContextTokens: s.contextLimit,
+    usagePercentage: s.usagePercentage,
+    cacheLifetime: formatCacheTtlDisplay({
+      value: s.cacheTtl,
+      source: s.cacheTtlSource,
+      modelKey: s.cacheTtlModelKey
+    }).replace(/^Cache TTL:\s*/, ""),
+    automaticCompressionThreshold: s.compactionEnabled ? s.executeThreshold : null,
+    compression: {
+      state: s.historianRunning ? "compressing" : s.compartmentCount > 0 ? "ready" : "waiting",
+      historyBlockCount: s.compartmentCount
+    },
+    reclaimable: {
+      toolOutputCount: s.tailHygiene?.reclaimableToolOutputCount ?? 0,
+      tokens: s.tailHygiene?.u ?? 0
+    },
+    memoryCount: s.memoryCount,
+    noteCount: s.sessionNoteCount + s.readySmartNoteCount,
+    embedding: s.embedding,
+    warnings
+  }, "plain");
+}
+function formatPiStatusDiagnostics(s) {
+  const summary = formatPiStatusSummary(s).replace("Magic Context Status", "Magic Context Diagnostics");
+  return [
+    summary,
+    "",
+    `Session: ${s.sessionId}`,
+    `Active profile: ${s.activeProfile ?? "none"}`,
+    `Work tokens: ${fmt2(s.newWorkTokens)} new · ${fmt2(s.totalInputTokens)} total input`,
+    ...s.tailHygiene ? [`Hygiene: ${formatTailHygiene(s.tailHygiene)}`] : [],
+    `Tags: ${s.activeTags} active · ${s.droppedTags} dropped · ${s.totalTags} total`,
+    `Pending drops: ${s.pendingOpsCount}`,
+    `Protected tokens: ${fmt2(s.protectedTokens.protectedMass)} (${s.protectedTokens.protectedCount} tags / floor ${fmt2(s.protectedTokens.floor)})`,
+    `History block tokens: ${fmt2(s.historyBlockTokens)}`,
+    `Compression budget: ${s.compressionBudget ? `${fmt2(s.compressionBudget)} (${s.compressionUsage} used)` : "unavailable"}`,
+    `Subagent: ${s.isSubagent ? "yes" : "no"}`
+  ].join(`
+`);
+}
+function renderInner(s, theme, innerWidth, diagnostics) {
   const pctColor = s.usagePercentage >= 80 ? "error" : s.usagePercentage >= 65 ? "warning" : "accent";
   const lines = [];
   lines.push(`${theme.fg("accent", theme.bold("⚡ Magic Context Status"))}   ${theme.fg("muted", `v${package_default.version}`)}`);
+  lines.push(theme.fg("muted", `[D] Diagnostics: ${diagnostics ? "on" : "off"}`));
+  if (!diagnostics) {
+    lines.push("", ...formatPiStatusSummary(s).split(`
+`).slice(1));
+    lines.push("", theme.fg("muted", "Press D for diagnostics · Escape to close"));
+    return lines;
+  }
   lines.push("");
   for (const failure of s.configParseFailures) {
     lines.push(theme.fg("error", formatConfigParseStatusLine(failure)));
@@ -32484,9 +32930,9 @@ function renderInner(s, theme, innerWidth) {
   })}`);
   lines.push(`Protected tokens ${fmt2(s.protectedTokens.protectedMass)} tok (${s.protectedTokens.protectedCount} tags / floor ${fmt2(s.protectedTokens.floor)}) · Subagent ${s.isSubagent ? "yes" : "no"} · History block ~${fmt2(s.historyBlockTokens)} tok${s.compressionBudget ? ` · Budget ~${fmt2(s.compressionBudget)} tok (${s.compressionUsage} used)` : ""}`);
   if (s.lastTransformError)
-    lines.push(theme.fg("error", `⚠ ${s.lastTransformError}`));
+    lines.push(theme.fg("error", renderUserFacingFailure("transform_update_failed")));
   if (s.historianLastError)
-    lines.push(theme.fg("error", `⚠ ${s.historianLastError}`));
+    lines.push(theme.fg("error", renderUserFacingFailure("historian_unavailable")));
   lines.push("");
   lines.push(theme.fg("muted", "Press Escape to close"));
   return lines;
@@ -32606,6 +33052,17 @@ ${safeStringify(tool.parameters)}`);
   const cacheRemainingMs = neverExpires ? Number.POSITIVE_INFINITY : meta.lastResponseTime > 0 ? Math.max(0, cacheTtlMs - elapsed) : cacheTtlMs;
   const cacheExpired = meta.lastResponseTime > 0 && cacheRemainingMs === 0;
   const historyBlockTokens = compartmentTokens + factTokens;
+  const embeddingCoverage = safeRead(() => getEmbeddingCoverageStatus(deps.db, deps.projectIdentity, sessionId), {
+    enabled: false,
+    model: "off",
+    provider: "off",
+    session: { embedded: 0, total: 0 },
+    memories: { embedded: 0, total: 0 },
+    commits: { embedded: 0, total: 0, gitEnabled: false },
+    shadowBackfillStalls: []
+  });
+  const embeddingRunState = getEmbedDrainUiStatus(sessionId, undefined).status;
+  const embeddingState = !embeddingCoverage.enabled ? "off" : embeddingRunState !== "idle" ? embeddingRunState : embeddingCoverage.session.total > 0 && embeddingCoverage.session.embedded >= embeddingCoverage.session.total ? "ready" : "waiting";
   const historyBudgetPercentage = deps.historyBudgetPercentage ?? 0.15;
   const compressionBudget = contextLimit > 0 ? Math.floor(contextLimit * (Math.min(threshold.percentage, 80) / 100) * historyBudgetPercentage) : null;
   return {
@@ -32615,6 +33072,10 @@ ${safeStringify(tool.parameters)}`);
     inputTokens,
     systemPromptTokens,
     compartmentCount: compartments.length,
+    lastCompartmentRange: (() => {
+      const last = compartments.at(-1);
+      return last ? `${last.startMessage}-${last.endMessage}` : null;
+    })(),
     memoryCount: safeRead(() => getMemoryCount(deps.db, deps.projectIdentity), 0),
     memoryBlockCount,
     sessionNoteCount: safeRead(() => getNotes(deps.db, {
@@ -32629,6 +33090,7 @@ ${safeStringify(tool.parameters)}`);
     }).length, 0),
     pendingOpsCount: pendingOps,
     historianRunning: meta.compartmentInProgress,
+    timesExecuteThresholdReached: meta.timesExecuteThresholdReached,
     historianFailureCount: Number(metaRow?.historian_failure_count ?? 0),
     historianLastFailureAt: typeof metaRow?.historian_last_failure_at === "number" ? metaRow.historian_last_failure_at : null,
     historianLastError: metaRow?.historian_last_error ?? null,
@@ -32670,7 +33132,19 @@ ${safeStringify(tool.parameters)}`);
     totalInputTokens: workMetrics.totalInputTokens,
     upgradeNeededCount: safeRead(() => countCompartmentsNeedingUpgrade(deps.db, sessionId), 0),
     recompInFlight: isPiRecompInFlight(sessionId),
-    hasDeprecatedProtectedTags: deps.hasDeprecatedProtectedTags ?? false
+    hasDeprecatedProtectedTags: deps.hasDeprecatedProtectedTags ?? false,
+    compactionEnabled: deps.compactionEnabled ?? true,
+    dreamer: {
+      enabled: deps.dreamer?.runnable === true,
+      scheduleSummary: deps.dreamer?.scheduleSummary ?? null,
+      lastRunAt: safeRead(() => getMostRecentTaskRunAt(deps.db, deps.projectIdentity), null),
+      backlog: safeRead(() => getDreamTaskBacklogs(deps.db, deps.projectIdentity, CANONICAL_DREAM_TASKS), {})
+    },
+    embedding: {
+      state: embeddingState,
+      indexed: embeddingCoverage.session.embedded,
+      total: embeddingCoverage.session.total
+    }
   };
 }
 function safeStringify(value) {
@@ -32806,8 +33280,18 @@ function relTime(ts) {
 function registerCtxStatusCommand(pi, deps) {
   pi.registerCommand("ctx-status", {
     description: "Show Magic Context status for the current Pi session",
-    handler: async (_args, ctx) => {
+    handler: async (args, ctx) => {
       const sendStatus = createCtxStatusSender(pi, ctx);
+      const mode = args.trim().toLowerCase();
+      if (mode !== "" && mode !== "diagnostics") {
+        sendStatus({
+          title: "/ctx-status",
+          text: "Usage: /ctx-status [diagnostics]",
+          level: "info"
+        });
+        return;
+      }
+      const diagnostics = mode === "diagnostics";
       const runtimeDeps = deps.resolveStatusDeps?.(ctx) ?? deps;
       const projectIdentity = runtimeDeps.resolveProject?.(ctx).projectIdentity ?? runtimeDeps.projectIdentity;
       const currentDeps = { ...runtimeDeps, projectIdentity };
@@ -32824,41 +33308,12 @@ No active Pi session is available.`,
       }
       try {
         if (ctx.hasUI) {
-          await showStatusDialog(pi, ctx, currentDeps);
+          await showStatusDialog(pi, ctx, currentDeps, diagnostics);
           return;
         }
-        const usage = ctx.getContextUsage?.();
-        const modelKey = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
-        let detectedContextLimit;
-        try {
-          const detected = getOverflowState(currentDeps.db, sessionId).detectedContextLimit;
-          if (detected > 0)
-            detectedContextLimit = detected;
-        } catch {}
-        const meta = getOrCreateSessionMeta(currentDeps.db, sessionId);
-        const windowGeometry = resolvePiWindowGeometry({
-          rawContextWindow: usage?.contextWindow ?? ctx.model?.contextWindow,
-          rawContextWindowSource: usage?.contextWindow === undefined ? "catalog" : "observed",
-          model: ctx.model,
-          detectedContextLimit,
-          persistedInputTokens: meta.lastInputTokens,
-          persistedPercentage: meta.lastContextPercentage
-        });
-        const usableContextLimit = windowGeometry?.usableSoft;
-        const pressure = resolvePiPressureSnapshot({
-          persistedPercentage: meta.lastContextPercentage,
-          persistedInputTokens: meta.lastInputTokens,
-          liveInputTokens: usage?.tokens,
-          usableContextLimit
-        });
-        const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usableContextLimit, {
-          backlog: getDreamTaskBacklogs(currentDeps.db, currentDeps.projectIdentity, CANONICAL_DREAM_TASKS)
-        }, windowGeometry, resolveTailHygieneStatus(getPiChannel1Baseline(sessionId)), pressure, false, {
-          cacheTtlConfig: currentDeps.cacheTtlConfig ?? "5m",
-          cacheTtlConfigured: currentDeps.cacheTtlConfigured === true,
-          configParseFailures: currentDeps.configParseFailures ?? []
-        });
-        const details = buildStatusDetails(currentDeps, sessionId);
+        const statusDetail = buildPiStatusDetail(pi, ctx, currentDeps, sessionId);
+        const statusText = diagnostics ? formatPiStatusDiagnostics(statusDetail) : formatPiStatusSummary(statusDetail);
+        const details = buildStatusDetails(currentDeps, statusDetail);
         const profileStatus = currentDeps.activeProfile ?? "none";
         const storage = getMagicContextStorageResolution();
         const deprecationNotice = currentDeps.hasDeprecatedProtectedTags ? `
@@ -32866,68 +33321,47 @@ No active Pi session is available.`,
 ⚠️ Config: "protected_tags" is deprecated and ignored; use "protected_tokens" instead.` : "";
         sendStatus({
           title: "/ctx-status",
-          text: `${statusText}${deprecationNotice}
+          text: diagnostics ? `${statusText}${deprecationNotice}
 
 Active profile: ${profileStatus}
 
-Storage: ${storage.path} (${storage.source})`,
+Storage: ${storage.path} (${storage.source})` : statusText,
           level: "info",
           rpcDisplay: "dialog"
         }, details);
       } catch (error) {
+        sessionLog(sessionId, `ctx-status failed code=${userFacingFailureCode("status_unavailable")}`, error);
         sendStatus({
           title: "/ctx-status",
-          text: `## Magic Status — Failed
-
-${describeError(error).brief}`,
+          text: renderUserFacingFailure("status_unavailable"),
           level: "error"
         });
       }
     }
   });
 }
-function buildStatusDetails(deps, sessionId) {
-  const meta = getOrCreateSessionMeta(deps.db, sessionId);
-  const tags = getTagsBySession(deps.db, sessionId);
-  const activeTags = tags.filter((tag) => tag.status === "active");
-  const droppedTags = tags.filter((tag) => tag.status === "dropped");
-  const compartments = getCompartments(deps.db, sessionId);
-  const lastCompartment = compartments[compartments.length - 1];
-  const totalBytes = activeTags.reduce((sum, tag) => sum + tag.byteSize, 0);
+function buildStatusDetails(deps, status) {
   return {
-    sessionId,
+    sessionId: status.sessionId,
     projectIdentity: deps.projectIdentity,
-    activeProfile: deps.activeProfile ?? null,
-    activeTags: activeTags.length,
-    droppedTags: droppedTags.length,
-    totalBytes,
-    pendingOps: getPendingOps(deps.db, sessionId).length,
-    lastExecuteThreshold: meta.timesExecuteThresholdReached,
-    compartmentCount: compartments.length,
-    lastCompartmentRange: lastCompartment ? `${lastCompartment.startMessage}-${lastCompartment.endMessage}` : null,
-    memoryCount: getMemoryCount(deps.db, deps.projectIdentity),
-    noteCount: getNotes(deps.db, { sessionId, type: "session", status: "active" }).length + getNotes(deps.db, {
-      projectPath: deps.projectIdentity,
-      type: "smart",
-      status: ["pending", "ready"]
-    }).length,
-    dreamer: {
-      enabled: deps.dreamer?.runnable === true,
-      scheduleSummary: deps.dreamer?.scheduleSummary ?? null,
-      backlog: getDreamTaskBacklogs(deps.db, deps.projectIdentity, CANONICAL_DREAM_TASKS),
-      lastRunAt: getMostRecentTaskRunAt(deps.db, deps.projectIdentity)
-    },
-    historian: readHistorianState(deps.db, sessionId, meta)
-  };
-}
-function readHistorianState(db, sessionId, meta) {
-  const row = db.prepare("SELECT historian_failure_count, historian_last_error, historian_last_failure_at FROM session_meta WHERE session_id = ?").get(sessionId);
-  return {
-    lastFireCount: meta.timesExecuteThresholdReached,
-    inProgress: meta.compartmentInProgress,
-    lastFailureAt: typeof row?.historian_last_failure_at === "number" ? row.historian_last_failure_at : null,
-    lastError: row?.historian_last_error ?? null,
-    failureCount: row?.historian_failure_count ?? 0
+    activeProfile: status.activeProfile,
+    activeTags: status.activeTags,
+    droppedTags: status.droppedTags,
+    totalBytes: status.activeBytes,
+    pendingOps: status.pendingOpsCount,
+    lastExecuteThreshold: status.timesExecuteThresholdReached,
+    compartmentCount: status.compartmentCount,
+    lastCompartmentRange: status.lastCompartmentRange,
+    memoryCount: status.memoryCount,
+    noteCount: status.sessionNoteCount + status.readySmartNoteCount,
+    dreamer: status.dreamer,
+    historian: {
+      lastFireCount: status.timesExecuteThresholdReached,
+      inProgress: status.historianRunning,
+      lastFailureAt: status.historianLastFailureAt,
+      lastError: status.historianLastError,
+      failureCount: status.historianFailureCount
+    }
   };
 }
 
@@ -34280,6 +34714,7 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
     cacheTtlConfigured: bootProjectDeps.cacheTtlConfigured,
     configParseFailures: bootProjectDeps.configParseFailures,
     hasDeprecatedProtectedTags: bootProjectDeps.hasDeprecatedProtectedTags,
+    compactionEnabled: isCompactionEnabled(bootProjectDeps.config),
     resolveStatusDeps: (ctx) => {
       const current = resolveCurrentProjectDeps(ctx);
       return {
@@ -34299,7 +34734,8 @@ async function startPiMagicContextRuntime(pi, database, dbPath) {
         cacheTtlConfig: current.config.cache_ttl,
         cacheTtlConfigured: current.cacheTtlConfigured,
         configParseFailures: current.configParseFailures,
-        hasDeprecatedProtectedTags: current.hasDeprecatedProtectedTags
+        hasDeprecatedProtectedTags: current.hasDeprecatedProtectedTags,
+        compactionEnabled: isCompactionEnabled(current.config)
       };
     }
   });