@cortexkit/opencode-magic-context 0.42.0 → 0.42.1

package/dist/index.js

@@ -372,6 +372,13 @@ import {
   hasLengthCappedOutput,
   setKeepSubagents,
   teardownChildSession,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  renderCapabilityRefusal,
+  capabilityRefusalCode,
+  renderDreamFailure,
+  dreamFailureCode,
+  renderEmbeddingFailure,
   getCompartmentEvents,
   SYNAPSE_DEFAULT_MODEL,
   toSynapseLaneDescriptor,
@@ -533,7 +540,7 @@ import {
   setRecompTerminal2,
   runManagedRecomp2,
   runManagedUpgrade2
-} from "./index-c9hamh36.js";
+} from "./index-1q9kay7n.js";
 import {
   stripJsonComments,
   isPrototypePollutionKey,
@@ -9191,7 +9198,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 +9438,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 +14938,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") {
@@ -18168,14 +18181,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;
@@ -19494,7 +19500,7 @@ function createDreamTaskExecutor(deps) {
       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,
@@ -20931,6 +20937,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 +21052,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 +21066,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 +22229,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 +24806,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 +24932,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 +24953,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 +24986,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 +25001,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 +25443,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 +25482,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 +25525,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 +25603,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 +25681,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 +25696,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 +25704,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 +25813,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 +25920,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 +25934,7 @@ Embedding status is unavailable.`;
         }
       }
       if (isStatus) {
+        const statusDiagnostics = input.arguments.trim().toLowerCase() === "diagnostics";
         let rustStatus;
         if (rustMode) {
           try {
@@ -25782,7 +25948,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 +25958,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 +25974,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 +25990,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 +26021,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 +26058,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 +28867,7 @@ function buildStatusDetail(db, sessionId, directory, modelKey, config, liveSessi
     lastResponseTime: 0,
     lastNudgeTokens: 0,
     lastTransformError: null,
+    historianFailureCount: 0,
     isSubagent: false,
     pendingOps: [],
     contextLimit: 0,
@@ -28742,6 +28913,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 +28993,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 +29343,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-m33b3rk9.js");
     const { sendIgnoredMessage } = await import("./send-session-notification-1qeqkswb.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -29177,7 +29362,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-m33b3rk9.js");
     const { sendIgnoredMessage } = await import("./send-session-notification-1qeqkswb.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -38238,37 +38423,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 +40860,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 +41144,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 +41178,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 +42115,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 +42215,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 +42254,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 +42269,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 +42526,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 +42535,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 +43607,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);
     },