@cortexkit/opencode-magic-context 0.42.0 → 0.42.2

package/dist/index.js

@@ -296,6 +296,8 @@ import {
   clearDetectedContextLimit,
   getPersistedCompactionMarkerState,
   setPersistedCompactionMarkerState,
+  getDeferredClearedCompactionMarkerState,
+  retireDeferredClearedCompactionMarkerState,
   getStrippedPlaceholderIds,
   applyStrippedPlaceholderDelta,
   removeStrippedPlaceholderId,
@@ -372,6 +374,13 @@ import {
   hasLengthCappedOutput,
   setKeepSubagents,
   teardownChildSession,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  renderCapabilityRefusal,
+  capabilityRefusalCode,
+  renderDreamFailure,
+  dreamFailureCode,
+  renderEmbeddingFailure,
   getCompartmentEvents,
   SYNAPSE_DEFAULT_MODEL,
   toSynapseLaneDescriptor,
@@ -533,7 +542,7 @@ import {
   setRecompTerminal2,
   runManagedRecomp2,
   runManagedUpgrade2
-} from "./index-c9hamh36.js";
+} from "./index-953x7a79.js";
 import {
   stripJsonComments,
   isPrototypePollutionKey,
@@ -9191,7 +9200,13 @@ var HARNESS_KEYS = PER_HARNESS_MODEL_KEYS;
 var HISTORIAN_USER_ONLY_FIELDS = PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution;
 var PROMPT_SURFACE_USER_ONLY_FIELDS = ["guidance_override_path", "tool_descriptions"];
 var AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools"];
-var EMBEDDING_DESTINATION_FIELDS = ["endpoint", "provider", "fallback_provider"];
+var EMBEDDING_USER_ONLY_FIELDS = [
+  "endpoint",
+  "provider",
+  "fallback_provider",
+  "query_instruction",
+  "document_prefix"
+];
 var PERCENTAGE_THRESHOLD_REASON = "security: a repository may only raise compaction thresholds above the user's effective value; it cannot force earlier historian work or cloned-repo cost escalation.";
 var TOKEN_THRESHOLD_REASON = "security: a repository may only raise execute_threshold_tokens above the user's trusted token threshold; it cannot force earlier historian work or cloned-repo cost escalation.";
 var TOKEN_THRESHOLD_INTRODUCTION_REASON = "security: a repository cannot introduce a new execute_threshold_tokens override when the user has no trusted token threshold for that key; that could force earlier historian work or cloned-repo cost escalation.";
@@ -9425,14 +9440,14 @@ function stripUnsafeProjectConfigFields(projectRaw) {
   const embedding = projectRaw.embedding;
   if (isPlainObject(embedding)) {
     const removed = [];
-    for (const field of EMBEDDING_DESTINATION_FIELDS) {
+    for (const field of EMBEDDING_USER_ONLY_FIELDS) {
       if (field in embedding) {
         delete embedding[field];
         removed.push(field);
       }
     }
     if (removed.length > 0) {
-      warnings.push(`Ignoring embedding.${removed.join("/")} from project config ` + "(security: a repository cannot choose where private text is embedded).");
+      warnings.push(`Ignoring embedding.${removed.join("/")} from project config ` + "(security: a repository cannot choose where or how private text is embedded).");
     }
   }
   for (const agentKey of HIDDEN_AGENT_KEYS) {
@@ -14925,12 +14940,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") {
@@ -16880,6 +16895,116 @@ Output exactly JSON: {"met": false}`;
   }
 }
 
+// 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;
+  });
+}
+
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join7 } from "node:path";
@@ -18168,14 +18293,7 @@ function unescapeXml2(value) {
 
 // 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;
@@ -18196,14 +18314,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) {
@@ -18223,7 +18352,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) {
@@ -18232,8 +18362,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) {
@@ -18241,22 +18372,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) {
@@ -18268,16 +18401,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;
@@ -18293,7 +18416,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": {
@@ -18309,16 +18432,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);
@@ -18363,15 +18489,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":
@@ -19109,6 +19235,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)
@@ -19159,7 +19288,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,
@@ -19488,13 +19617,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,
@@ -19789,17 +19920,6 @@ async function runAgenticTask(config, ctx, helpers) {
     architecture: existsSync9(`${docsDir}/ARCHITECTURE.md`),
     structure: existsSync9(`${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, () => {
@@ -19808,7 +19928,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,
@@ -19900,6 +20050,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("; ");
@@ -20916,7 +21067,13 @@ function createDreamTimerModuleClient(moduleClient) {
       }
       return moduleClient.authorityStatus(args);
     } : undefined,
-    call: (args) => moduleClient.call(args)
+    call: (args) => moduleClient.call(args),
+    mirrorPull: moduleClient.mirrorPull ? (args) => {
+      if (!moduleClient.mirrorPull) {
+        throw new Error("Rust module mirror route became unavailable");
+      }
+      return moduleClient.mirrorPull(args);
+    } : undefined
   };
 }
 
@@ -20931,6 +21088,8 @@ var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.truncate",
   "embedding.max_input_tokens",
   "embedding.query_input_type",
+  "embedding.query_instruction",
+  "embedding.document_prefix",
   "embedding.fallback_provider",
   "subc",
   "subc.connection_file",
@@ -21044,6 +21203,8 @@ function fallbackConfig(config, provider) {
   const apiKey = typeof raw.api_key === "string" ? raw.api_key.trim() : "";
   const inputType = typeof raw.input_type === "string" ? raw.input_type.trim() : "";
   const queryInputType = typeof raw.query_input_type === "string" ? raw.query_input_type.trim() : "";
+  const queryInstruction = typeof raw.query_instruction === "string" || raw.query_instruction === false ? raw.query_instruction : undefined;
+  const documentPrefix = typeof raw.document_prefix === "string" ? raw.document_prefix : undefined;
   const truncate = typeof raw.truncate === "string" ? raw.truncate.trim() : "";
   const maxInputTokens = typeof raw.max_input_tokens === "number" ? raw.max_input_tokens : undefined;
   if (provider === "off")
@@ -21056,6 +21217,8 @@ function fallbackConfig(config, provider) {
       ...apiKey ? { api_key: apiKey } : {},
       ...inputType ? { input_type: inputType } : {},
       ...queryInputType ? { query_input_type: queryInputType } : {},
+      ...queryInstruction !== undefined ? { query_instruction: queryInstruction } : {},
+      ...documentPrefix !== undefined ? { document_prefix: documentPrefix } : {},
       ...truncate ? { truncate } : {},
       ...maxInputTokens !== undefined ? { max_input_tokens: maxInputTokens } : {}
     };
@@ -22217,7 +22380,8 @@ function getEmbedDrainUiStatus(sessionId, progress) {
   if (embedPauseBySession.has(sessionId)) {
     return { status: "paused" };
   }
-  if (progress?.kind === "embed" && progress.phase === "recomp") {
+  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) {
@@ -24793,10 +24957,122 @@ function formatCacheTtlDisplay(display) {
 // src/shared/rust-mode-status.ts
 var RUST_MODE_HOST_PATHS_LINE = "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side";
 
-// src/shared/status-detail-text.ts
+// src/shared/status-summary.ts
+function statusSummaryFromDetail(detail) {
+  const compressionState = detail.compaction_enabled === false ? "off" : detail.historianRunning || detail.compartmentInProgress || detail.recompProgress?.phase === "recomp" && detail.recompProgress.kind !== "embed" ? "compressing" : detail.compartmentCount > 0 ? "ready" : "waiting";
+  const warnings = [];
+  if (detail.lastTransformError)
+    warnings.push("transform_update_failed");
+  if ((detail.historianFailureCount ?? 0) > 0)
+    warnings.push("historian_unavailable");
+  if ((detail.configParseFailures?.length ?? 0) > 0)
+    warnings.push("configuration_warning");
+  if (detail.embedding?.state === "stopped")
+    warnings.push("embedding_unavailable");
+  if ((detail.loggerDiagnostics?.swallowedWriteCount ?? 0) > 0) {
+    warnings.push("status_log_unavailable");
+  }
+  return {
+    inputTokens: detail.inputTokens,
+    usableContextTokens: detail.contextLimit,
+    usagePercentage: detail.usagePercentage,
+    cacheLifetime: formatCacheTtlDisplay({
+      value: detail.cacheTtl,
+      source: detail.cacheTtlSource ?? "session",
+      modelKey: detail.cacheTtlModelKey
+    }).replace(/^Cache TTL:\s*/, ""),
+    automaticCompressionThreshold: detail.compaction_enabled === false ? null : detail.executeThreshold,
+    compression: {
+      state: compressionState,
+      historyBlockCount: detail.compartmentCount
+    },
+    reclaimable: {
+      toolOutputCount: detail.tailHygiene?.reclaimableToolOutputCount ?? 0,
+      tokens: detail.tailHygiene?.u ?? 0
+    },
+    memoryCount: detail.memoryCount,
+    noteCount: (detail.sessionNoteCount ?? 0) + (detail.readySmartNoteCount ?? 0),
+    embedding: detail.embedding ?? {
+      state: "waiting",
+      indexed: 0,
+      total: 0
+    },
+    warnings: [...new Set(warnings)]
+  };
+}
 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(`
+`);
+}
+
+// src/shared/status-detail-text.ts
+function formatCount2(value) {
+  return Math.round(value).toLocaleString();
+}
 function formatCacheLane(detail) {
   if (detail.cacheNeverExpires)
     return `never expires; TTL ${detail.cacheTtl}`;
@@ -24807,7 +25083,10 @@ function formatCacheLane(detail) {
   return `live (${Math.round(detail.cacheRemainingMs / 1000)}s remaining); TTL ${detail.cacheTtl}`;
 }
 function formatStatusDetailMarkdown(detail) {
-  const usableLimit = detail.contextLimit > 0 ? `${formatCount(detail.contextLimit)} usable tokens` : "? usable tokens";
+  return renderUserStatusSummary(statusSummaryFromDetail(detail), "markdown");
+}
+function formatStatusDiagnosticsMarkdown(detail) {
+  const usableLimit = detail.contextLimit > 0 ? `${formatCount2(detail.contextLimit)} usable tokens` : "? usable tokens";
   const historianState = detail.historianRunning ? "running" : "idle";
   const historianDetails = [
     detail.boundaryPresent === undefined ? undefined : `boundary ${detail.boundaryPresent ? "present" : "absent"}`,
@@ -24825,19 +25104,19 @@ function formatStatusDetailMarkdown(detail) {
     "",
     `- **Mode:** ${mode}`,
     `- **Active profile:** ${detail.activeProfile ?? "none"}`,
-    `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount(detail.inputTokens)} / ${usableLimit})`,
+    `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount2(detail.inputTokens)} / ${usableLimit})`,
     `- **${formatCacheTtlDisplay({ value: detail.cacheTtl, source: detail.cacheTtlSource ?? "session", modelKey: detail.cacheTtlModelKey })}**; ${formatCacheLane(detail)}`,
     `- **Historian:** ${[historianState, ...historianDetails].join("; ")}`,
     ...detail.hostBackendsModuleSide ? [`- ${RUST_MODE_HOST_PATHS_LINE}`] : [],
-    `- **Memory:** ${formatCount(detail.memoryCount)} active; ${formatCount(detail.memoryBlockCount)} injected`,
-    `- **Tags:** ${formatCount(detail.activeTags)} active, ${formatCount(detail.droppedTags)} dropped; ${formatCount(detail.pendingOpsCount)} pending drops`,
+    `- **Memory:** ${formatCount2(detail.memoryCount)} active; ${formatCount2(detail.memoryBlockCount)} injected`,
+    `- **Tags:** ${formatCount2(detail.activeTags)} active, ${formatCount2(detail.droppedTags)} dropped; ${formatCount2(detail.pendingOpsCount)} pending drops`,
     `- **Execute threshold:** ${detail.executeThreshold.toFixed(1)}%${detail.executeThresholdClamped ? " (clamped)" : ""}`
   ];
   if (detail.recompProgress?.phase === "recomp") {
-    lines.push(`- **${detail.recompProgress.kind === "embed" ? "Embed" : "Historian"} progress:** ${formatCount(detail.recompProgress.processedMessages)} / ${formatCount(detail.recompProgress.totalMessages)}`);
+    lines.push(`- **${detail.recompProgress.kind === "embed" ? "Embed" : "Historian"} progress:** ${formatCount2(detail.recompProgress.processedMessages)} / ${formatCount2(detail.recompProgress.totalMessages)}`);
   }
   if (detail.lastTransformError) {
-    lines.push(`- **Last transform error:** ${detail.lastTransformError}`);
+    lines.push(`- **Warning:** ${renderUserFacingFailure("transform_update_failed")}`);
   }
   return lines.join(`
 `);
@@ -24858,7 +25137,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)
@@ -24872,7 +25152,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) {
@@ -25313,7 +25594,7 @@ function executeStatus(db, sessionId, executeThresholdPercentageConfig = DEFAULT
       `- Drops: ${pendingOps.length}`,
       `- Total queued: ${pendingOps.length}`,
       "",
-      ...meta.lastTransformError ? ["### Last Transform Error", `- ${meta.lastTransformError}`, ""] : [],
+      ...meta.lastTransformError ? ["### Warning", `- ${renderUserFacingFailure("transform_update_failed")}`, ""] : [],
       "### Cache TTL",
       `- ${formatCacheTtlDisplay(ttlDisplay)}`,
       `- Last response: ${meta.lastResponseTime > 0 ? `${Math.round(elapsed / 1000)}s ago` : "never"}`,
@@ -25352,6 +25633,30 @@ ${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;
+    if (display?.diagnostics === false) {
+      return renderUserStatusSummary({
+        inputTokens: displayInputTokens,
+        usableContextTokens: displayContextLimit,
+        usagePercentage: displayPercentage,
+        cacheLifetime: formatCacheTtlDisplay(ttlDisplay).replace(/^Cache TTL:\s*/, ""),
+        automaticCompressionThreshold: display?.compactionEnabled === false ? null : thresholdDetail.percentage,
+        compression: {
+          state: meta.compartmentInProgress ? "compressing" : compartments.length > 0 ? "ready" : "waiting",
+          historyBlockCount: compartments.length
+        },
+        reclaimable: {
+          toolOutputCount: tailHygiene?.reclaimableToolOutputCount ?? 0,
+          tokens: tailHygiene?.u ?? 0
+        },
+        memoryCount: 0,
+        noteCount: 0,
+        embedding: { state: "waiting", indexed: 0, total: 0 },
+        warnings: [
+          ...meta.lastTransformError ? ["transform_update_failed"] : [],
+          ...parseFailureLines.length > 0 ? ["configuration_warning"] : []
+        ]
+      }, "markdown");
+    }
     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`
@@ -25371,14 +25676,14 @@ ${c.content}
     return lines.join(`
 `);
   } catch (error) {
-    sessionLog(sessionId, "ctx-status failed:", error);
-    return `Error: Failed to read context status. ${getErrorMessage(error)}`;
+    sessionLog(sessionId, `ctx-status failed code=${userFacingFailureCode("status_unavailable")}: ${getErrorMessage(error)}`);
+    return `Error: ${renderUserFacingFailure("status_unavailable")}`;
   }
 }
 
 // src/hooks/magic-context/maintenance-authority.ts
-var RUST_SESSION_UPGRADE_REFUSAL = "Session upgrade is unavailable while Rust transform authority is active. The module owns compartment and memory state; switch authority through the documented drain flow before upgrading.";
-var RUST_PARTIAL_RECOMP_REFUSAL = "Partial recomp is unavailable while Rust transform authority is active. The module supports only a full-session recomp; no state was changed.";
+var RUST_SESSION_UPGRADE_REFUSAL = renderCapabilityRefusal("session_upgrade");
+var RUST_PARTIAL_RECOMP_REFUSAL = renderCapabilityRefusal("partial_history");
 
 // src/hooks/magic-context/command-handler.ts
 var recompConfirmationBySession = new Map;
@@ -25449,7 +25754,10 @@ function parseWrapupArgs(raw) {
   return { ok: true, messagesToKeep };
 }
 var commandArgumentValidators = {
-  "ctx-status": (raw) => raw.trim() === "",
+  "ctx-status": (raw) => {
+    const mode = raw.trim().toLowerCase();
+    return mode === "" || mode === "diagnostics";
+  },
   "ctx-recomp": (raw) => parseRecompArgs(raw).kind !== "error",
   "ctx-wrapup": (raw) => parseWrapupArgs(raw).ok,
   "ctx-session-upgrade": (raw) => raw.trim() === "",
@@ -25524,11 +25832,11 @@ ${summary || "Nothing to compact."}`;
       case "retryable":
         return `## Magic Wrapup — Partial
 
-${summary || "Wrapup made progress but stopped before the keep watermark."} Run /ctx-wrapup again to continue.`;
+${renderCapabilityRefusal("history_compression")}`;
       default:
         return `## Magic Wrapup — Failed
 
-${summary || "Wrapup failed; try /ctx-wrapup again."}${rounds > 0 ? ` (${rounds} round${rounds === 1 ? "" : "s"})` : ""}`;
+${renderCapabilityRefusal("history_compression")}`;
     }
   }
   switch (disposition) {
@@ -25539,7 +25847,7 @@ Recomp started. Rebuilding the compressed history from raw session history now;
     case "already_in_progress":
       return `## Magic Recomp — Skipped
 
-Historian recomp is already running for this session. Wait for it to finish, then try /ctx-recomp again.`;
+History compression is already running for this session. Wait for it to finish, then try /ctx-recomp again.`;
     case "nothing_to_do":
       return `## Magic Recomp
 
@@ -25547,7 +25855,7 @@ Nothing to rebuild: this session has no published compartments.`;
     default:
       return `## Magic Recomp — Failed
 
-${summary || "Historian recomp failed; try /ctx-recomp again."}`;
+${renderCapabilityRefusal("history_compression")}`;
   }
 }
 function formatRustStatusText(value) {
@@ -25656,8 +25964,15 @@ Unknown task "${requested}". Valid tasks: ${CANONICAL_DREAM_TASKS.join(", ")}.`,
     formatDreamTaskBacklogs(backlogBefore, backlogTasks)
   ].join(`
 `), dreamNotificationParams);
-  const summary = await deps.dreamer.runManual(task);
-  await deps.sendNotification(sessionId, summarizeManualDream(summary), dreamNotificationParams);
+  try {
+    const summary = await deps.dreamer.runManual(task);
+    await deps.sendNotification(sessionId, summarizeManualDream(summary), dreamNotificationParams);
+  } catch (error) {
+    sessionLog(sessionId, `ctx-dream failed code=${userFacingFailureCode("dream_unknown")}`, error);
+    await deps.sendNotification(sessionId, `## /ctx-dream
+
+${renderUserFacingFailure("dream_unknown")}`, dreamNotificationParams);
+  }
   throwSentinel("CTX-DREAM");
 }
 function createMagicContextCommandHandler(deps) {
@@ -25756,7 +26071,8 @@ Embedding status is unavailable.`;
             });
             result = value.armed === false ? "No pending operations to flush." : "Flushed: Changes take effect on next message.";
           } catch (error) {
-            result = `Error: Failed to flush context operations. ${error instanceof Error ? error.message : String(error)}`;
+            sessionLog(sessionId, `ctx-flush failed code=${capabilityRefusalCode("context_cleanup")}`, error);
+            result = renderCapabilityRefusal("context_cleanup");
           }
         } else {
           result = executeFlush(deps.db, sessionId);
@@ -25769,6 +26085,7 @@ Embedding status is unavailable.`;
         }
       }
       if (isStatus) {
+        const statusDiagnostics = input.arguments.trim().toLowerCase() === "diagnostics";
         let rustStatus;
         if (rustMode) {
           try {
@@ -25782,7 +26099,7 @@ Embedding status is unavailable.`;
           }
         }
         if (isTuiConnected2(sessionId)) {
-          pushNotification2("action", { action: "show-status-dialog" }, sessionId);
+          pushNotification2("action", { action: "show-status-dialog", diagnostics: statusDiagnostics }, sessionId);
           sessionLog(sessionId, "command ctx-status: pushed show-status-dialog to TUI");
           throwSentinel(input.command);
         }
@@ -25792,9 +26109,9 @@ Embedding status is unavailable.`;
           if (rustMode && !rustStatus) {
             combinedStatus = `## Magic Status — Unavailable
 
-Rust module status could not be read. Canonical session usage, tags, and compartments live in mc-store, so context.db mirror values are intentionally omitted.`;
+${renderUserFacingFailure("status_unavailable")}`;
           } else if (detail) {
-            combinedStatus = formatStatusDetailMarkdown(detail);
+            combinedStatus = statusDiagnostics ? formatStatusDiagnosticsMarkdown(detail) : formatStatusDetailMarkdown(detail);
           } else {
             const liveModelKey = deps.getLiveModelKey?.(sessionId);
             const liveContextLimit = deps.getContextLimit?.(sessionId);
@@ -25808,12 +26125,14 @@ Rust module status could not be read. Canonical session usage, tags, and compart
             } : undefined, windowGeometry, tailHygiene, undefined, Boolean(rustMode), {
               cacheTtlConfig: deps.cacheTtlConfig ?? "5m",
               cacheTtlConfigured: deps.cacheTtlConfigured === true,
-              configParseFailures: deps.configParseFailures ?? []
+              configParseFailures: deps.configParseFailures ?? [],
+              diagnostics: statusDiagnostics,
+              compactionEnabled: !deps.compactionOff
             });
-            const moduleStatus = rustStatus ? `
+            const moduleStatus = rustStatus && statusDiagnostics ? `
 
 ${formatRustStatusText(rustStatus)}` : "";
-            const modeStatus = deps.compactionOff ? `**Compaction:** disabled (${COMPACTION_ENABLED_PATH}: false) — native compaction owns the context window.
+            const modeStatus = deps.compactionOff && statusDiagnostics ? `**Compaction:** disabled (${COMPACTION_ENABLED_PATH}: false) — native compaction owns the context window.
 
 ` : "";
             combinedStatus = `${modeStatus}${statusOutput}${moduleStatus}`;
@@ -25822,7 +26141,7 @@ ${formatRustStatusText(rustStatus)}` : "";
           sessionLog(sessionId, "shared ctx-status detail failed; using compatibility text:", error);
           combinedStatus = rustMode ? `## Magic Status — Unavailable
 
-Rust module status failed while formatting. Canonical session usage, tags, and compartments live in mc-store, so context.db mirror values are intentionally omitted.` : executeStatus(deps.db, sessionId);
+${renderUserFacingFailure("status_unavailable")}` : executeStatus(deps.db, sessionId);
         }
         result += result ? `
 
@@ -25853,9 +26172,10 @@ Starting wrapup…`, {});
             }, MAX_WRAPUP_REQUEST_BUDGET_MS);
             result = formatRustOperationMessage("wrapup", value);
           } catch (error) {
+            sessionLog(sessionId, `ctx-wrapup failed code=${capabilityRefusalCode("history_compression")}`, error);
             result = `## Magic Wrapup — Failed
 
-${error instanceof Error ? error.message : String(error)}`;
+${renderCapabilityRefusal("history_compression")}`;
           }
         } else if (!deps.executeWrapup) {
           result = `## Magic Wrapup
@@ -25889,9 +26209,10 @@ ${RUST_PARTIAL_RECOMP_REFUSAL}`;
             });
             result = formatRustOperationMessage("recomp", value);
           } catch (error) {
+            sessionLog(sessionId, `ctx-recomp failed code=${capabilityRefusalCode("history_compression")}`, error);
             result = `## Magic Recomp — Failed
 
-${error instanceof Error ? error.message : String(error)}`;
+${renderCapabilityRefusal("history_compression")}`;
           }
         } else if (isTuiConnected2(sessionId)) {
           pushNotification2("action", { action: "show-recomp-dialog" }, sessionId);
@@ -28697,6 +29018,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
     lastResponseTime: 0,
     lastNudgeTokens: 0,
     lastTransformError: null,
+    historianFailureCount: 0,
     isSubagent: false,
     pendingOps: [],
     contextLimit: 0,
@@ -28742,6 +29064,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
       detail.lastResponseTime = Number(meta.last_response_time ?? 0);
       detail.lastNudgeTokens = Number(meta.last_nudge_tokens ?? 0);
       detail.lastTransformError = meta.last_transform_error ? String(meta.last_transform_error) : null;
+      detail.historianFailureCount = Number(meta.historian_failure_count ?? 0);
       detail.isSubagent = Boolean(meta.is_subagent);
       persistedCacheTtl = typeof meta.cache_ttl === "string" && meta.cache_ttl.length > 0 ? meta.cache_ttl : "5m";
       persistedModelKey = typeof meta.last_observed_model_key === "string" && meta.last_observed_model_key.length > 0 ? meta.last_observed_model_key : null;
@@ -28821,6 +29144,19 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
         detail.cacheExpired = detail.cacheRemainingMs === 0;
       }
     }
+    if (base.projectIdentity) {
+      try {
+        const coverage = getEmbeddingCoverageStatus(db, base.projectIdentity, sessionId);
+        const runState = getEmbedDrainUiStatus(sessionId, base.recompProgress ?? undefined).status;
+        detail.embedding = {
+          state: !coverage.enabled ? "off" : runState !== "idle" ? runState : coverage.session.total > 0 && coverage.session.embedded >= coverage.session.total ? "ready" : "waiting",
+          indexed: coverage.session.embedded,
+          total: coverage.session.total
+        };
+      } catch {
+        detail.embedding = { state: "waiting", indexed: 0, total: 0 };
+      }
+    }
     try {
       const histTokens = base.compartmentTokens + base.factTokens;
       detail.historyBlockTokens = histTokens;
@@ -29158,7 +29494,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp } = await import("./recomp-orchestrator-3atsasjy.js");
+    const { runManagedRecomp } = await import("./recomp-orchestrator-5g8f5rhy.js");
     const { sendIgnoredMessage } = await import("./send-session-notification-1qeqkswb.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -29177,7 +29513,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade } = await import("./recomp-orchestrator-3atsasjy.js");
+    const { runManagedUpgrade } = await import("./recomp-orchestrator-5g8f5rhy.js");
     const { sendIgnoredMessage } = await import("./send-session-notification-1qeqkswb.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -30225,13 +30561,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);
@@ -30250,6 +30611,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;
@@ -30275,7 +30638,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);
@@ -31759,7 +32126,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
             emergencyReclaimedTokens += estimateEmergencyDropReclaimTokens(tag);
           }
         }
-      })();
+      }).immediate();
       sessionLog(sessionId, `emergency tiered drop: ${plan.reason}`);
     } else {
       sessionLog(sessionId, `emergency tiered drop skipped: ${plan.reason}`);
@@ -31806,7 +32173,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
           }
         }
       }
-    })();
+    }).immediate();
   }
   const allMessages = Array.from(messageTagNumbers.keys());
   const toolFingerprints = buildToolFingerprints(allMessages);
@@ -31845,7 +32212,7 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
           }
         }
       }
-    })();
+    }).immediate();
   }
   if (droppedTools > 0 || deduplicatedTools > 0 || droppedInjections > 0) {
     sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
@@ -32110,78 +32477,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) {
@@ -32978,7 +33360,8 @@ function runRustModePostprocess(args) {
     db: args.db,
     sessionId: args.sessionId,
     tagger: args.tagger,
-    ctxReduceAvailability: args.ctxReduceAvailability
+    ctxReduceAvailability: args.ctxReduceAvailability,
+    isCacheBustingPass: args.materializedBoundary != null
   });
   for (const anchor of getNoteNudgeAnchors(args.db, args.sessionId)) {
     appendReminderToUserMessageById(args.messages, anchor.messageId, anchor.text);
@@ -33073,6 +33456,13 @@ function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
     updateTagStatus(db, sessionId, tagNumber, "dropped");
 }
 function reconcileMarkerRepresentation(messages, persistedMarkerState, options) {
+  if (persistedMarkerState === null) {
+    if (options.isCacheBustingPass === true) {
+      retireDeferredClearedCompactionMarkerState(options.db, options.sessionId);
+    } else {
+      persistedMarkerState = getDeferredClearedCompactionMarkerState(options.db, options.sessionId);
+    }
+  }
   const retainedMessages = [];
   const staleSummaryIds = new Set;
   for (const message of messages) {
@@ -33770,7 +34160,8 @@ async function runPostTransformPhase(args) {
       db: args.db,
       sessionId: args.sessionId,
       tagger: args.tagger,
-      ctxReduceAvailability: args.ctxReduceAvailability
+      ctxReduceAvailability: args.ctxReduceAvailability,
+      isCacheBustingPass
     });
   }
   const deferredHistoryDrainEligible = historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart && !suppressV12HistoryDrain;
@@ -38238,37 +38629,10 @@ function createEventHandler2(deps) {
 }
 
 // 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)}`;
 }
 
 // src/hooks/magic-context/text-complete.ts
@@ -40702,13 +41066,9 @@ function normalizeCategory(category) {
   const trimmed = category?.trim();
   return trimmed ? trimmed : undefined;
 }
-function memoryAuthorityRefusal(args, cause) {
-  const readiness = "Rust memory authority is not ready.";
-  const refusal = (args.action === "write" || args.action === "update" || args.action === "merge") && typeof args.content === "string" ? `Error: ${readiness} Write REFUSED and NOT saved; RESEND the same call after authority is ready; the Rust module typically recovers in seconds-to-minutes.
-Content to resend:
-${args.content}` : `Error: ${readiness} Request REFUSED and NOT applied; RESEND the same call after authority is ready; the Rust module typically recovers in seconds-to-minutes.`;
-  return cause ? `${cause}
-${refusal}` : refusal;
+function memoryAuthorityRefusal(args) {
+  const isMutation = args.action !== undefined && ["write", "update", "archive", "merge"].includes(args.action);
+  return renderCapabilityRefusal(isMutation ? "memory_write" : "memory_access");
 }
 function moduleMemoryText(response, args) {
   let value = response;
@@ -40990,14 +41350,14 @@ function createCtxMemoryTool(deps) {
           }) ?? null;
         } catch (error) {
           if (marker) {
-            const detail = error instanceof Error ? error.message : String(error);
-            return memoryAuthorityRefusal(args, `Error: Rust memory authority is unavailable. ${detail}`);
+            sessionLog(toolContext.sessionID, "ctx_memory capability refusal", error);
+            return memoryAuthorityRefusal(args);
           }
         }
         if (authorityState === "MODULE") {
           const memoryBackend = deps.rustToolBackends?.memory;
           if (!memoryBackend) {
-            return "Error: Rust memory authority is active, but this module transport does not support ctx_memory.";
+            return memoryAuthorityRefusal(args);
           }
           try {
             const commandId = toolCallIdFromContext(toolContext);
@@ -41024,13 +41384,13 @@ function createCtxMemoryTool(deps) {
               ids: moduleArgs.ids,
               reason: moduleArgs.reason
             }), moduleArgs);
-            return text ?? "Error: Rust module returned an invalid ctx_memory response.";
+            return text ?? memoryAuthorityRefusal(args);
           } catch (error) {
             if (isRustAuthorityDrainingError(error)) {
               return memoryAuthorityRefusal(args);
             }
-            const detail = error instanceof Error ? error.message : String(error);
-            return memoryAuthorityRefusal(args, `Error: Rust module ctx_memory failed. ${detail}`);
+            sessionLog(toolContext.sessionID, "ctx_memory capability refusal", error);
+            return memoryAuthorityRefusal(args);
           }
         }
         if (marker || authorityState === "PREPARING" || authorityState === "DRAINING") {
@@ -41961,14 +42321,9 @@ ${footer}` : ""}`);
   }
   return sections;
 }
-function noteAuthorityRefusal(args, action) {
-  const readiness = "Rust notes authority is not ready.";
-  if ((action === "write" || action === "update") && typeof args.content === "string") {
-    return `Error: ${readiness} Write REFUSED and NOT saved; RESEND after authority is ready.
-Content to resend:
-${args.content}`;
-  }
-  return `Error: ${readiness} Request REFUSED and NOT applied; RESEND after authority is ready.`;
+function noteAuthorityRefusal(_args, action) {
+  const isMutation = action === "write" || action === "update" || action === "dismiss";
+  return renderCapabilityRefusal(isMutation ? "note_change" : "note_access");
 }
 function moduleNoteText(response, args, action) {
   let value = response;
@@ -42066,19 +42421,20 @@ function createCtxNoteTool(deps) {
           });
         } catch (error) {
           if (marker) {
-            return `Error: Rust notes authority is unavailable. ${error instanceof Error ? error.message : String(error)}`;
+            sessionLog(sessionId, "ctx_note capability refusal", error);
+            return noteAuthorityRefusal(args, action);
           }
         }
       }
       if (notesAuthority === "MODULE") {
         const rustNote = deps.rustToolBackends?.note;
         if (!rustNote || !projectIdentity) {
-          return "Error: Rust notes authority is active, but this module transport does not support ctx_note.";
+          return noteAuthorityRefusal(args, action);
         }
         let compilation;
         if ((action === "write" || action === "update") && surfaceCondition) {
           if (deps.rustToolBackends?.noteEvaluationAvailable?.(projectIdentity) !== true) {
-            return "Error: Smart-note evaluation is unavailable for this Rust-authority project; the note was not written.";
+            return renderCapabilityRefusal("smart_note_condition");
           }
           compilation = await compileSurfaceCondition(surfaceCondition, {
             projectPath: toolContext.directory
@@ -42104,7 +42460,7 @@ function createCtxNoteTool(deps) {
         try {
           const text = moduleNoteText(await rustNote(request), args, action);
           if (text === null) {
-            return "Error: Rust module returned an invalid ctx_note response.";
+            return noteAuthorityRefusal(args, action);
           }
           if (text.startsWith("Error:"))
             return text;
@@ -42119,7 +42475,8 @@ wake plane active — create a scheduled wake instead; stored as a plain note.`;
           if (isRustAuthorityDrainingError(error)) {
             return noteAuthorityRefusal(args, action);
           }
-          return `Error: Rust module ctx_note failed. ${error instanceof Error ? error.message : String(error)}`;
+          sessionLog(sessionId, "ctx_note capability refusal", error);
+          return noteAuthorityRefusal(args, action);
         }
       }
       if (marker || notesAuthority === "PREPARING" || notesAuthority === "DRAINING") {
@@ -42375,7 +42732,8 @@ function createCtxReduceTool(deps) {
             const error = record && "error" in record ? record.error : undefined;
             const errorRecord = error !== null && typeof error === "object" ? error : undefined;
             const message = (typeof error === "string" && error.trim() ? error : undefined) ?? (typeof errorRecord?.message === "string" && errorRecord.message.trim() ? errorRecord.message : undefined) ?? (typeof record?.message === "string" && record.message.trim() ? record.message : "module rejected agent_drops.append");
-            return `Error: Failed to queue ctx_reduce operations. ${message}`;
+            sessionLog(sessionId, "ctx_reduce capability refusal", message);
+            return renderCapabilityRefusal("context_cleanup");
           }
           const queued = typeof record.queued === "number" ? record.queued : 0;
           if (queued <= 0) {
@@ -42383,7 +42741,8 @@ function createCtxReduceTool(deps) {
           }
           return `Queued: drop ${formatRawDropForAck(args.drop)}.`;
         } catch (error) {
-          return `Error: Failed to queue ctx_reduce operations. ${getErrorMessage(error)}`;
+          sessionLog(sessionId, "ctx_reduce capability refusal", error);
+          return renderCapabilityRefusal("context_cleanup");
         }
       }
       let dropIds = [];
@@ -43454,6 +43813,9 @@ var server = async (ctx) => {
         return;
       recordToolDefinition(lastChatContext.providerID, lastChatContext.modelID, lastChatContext.agentName, typedInput.toolID, typeof typedOutput.description === "string" ? typedOutput.description : "", typedOutput.parameters);
     },
+    "tool.execute.before": async (input, output) => {
+      await magicContextRuntime.magicContext?.["tool.execute.before"]?.(input, output);
+    },
     "tool.execute.after": async (input, output) => {
       await magicContextRuntime.magicContext?.["tool.execute.after"]?.(input, output);
     },