@cortexkit/opencode-magic-context 0.24.1 → 0.26.0

package/src/shared/resolve-fallbacks.test.ts

@@ -1,98 +1,64 @@
 import { describe, expect, test } from "bun:test";
 
-import { DREAMER_AGENT } from "../agents/dreamer";
-import { HISTORIAN_AGENT } from "../agents/historian";
-import { SIDEKICK_AGENT } from "../agents/sidekick";
 import { parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
 
 describe("resolveFallbackChain", () => {
-    test("returns builtin chain when user provides nothing", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, undefined);
-        // Builtin DREAMER_FALLBACK_CHAIN expands to multiple provider/model entries.
-        expect(chain.length).toBeGreaterThan(2);
-        // Every entry must be in "provider/model" form.
-        for (const entry of chain) {
-            expect(entry.indexOf("/")).toBeGreaterThan(0);
-        }
+    // Policy: user-config-only. There is NO builtin provider-agnostic chain —
+    // when the user configures no fallback_models the result is EMPTY, and the
+    // runner's session-model last resort (a model the user actually has) is the
+    // only fallback. A hardcoded chain named providers the user may not have and
+    // produced `Model not found` retry storms.
+    test("returns empty when user provides nothing (no builtin chain)", () => {
+        expect(resolveFallbackChain(undefined)).toEqual([]);
     });
 
-    test("returns builtin chain for empty string", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, "");
-        expect(chain.length).toBeGreaterThan(0);
+    test("returns empty for empty string", () => {
+        expect(resolveFallbackChain("")).toEqual([]);
     });
 
-    test("returns builtin chain for empty array", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, []);
-        expect(chain.length).toBeGreaterThan(0);
+    test("returns empty for empty array", () => {
+        expect(resolveFallbackChain([])).toEqual([]);
     });
 
     test("user-only when user provides valid fallback_models string", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, "anthropic/claude-sonnet-4-6");
-        expect(chain).toEqual(["anthropic/claude-sonnet-4-6"]);
+        expect(resolveFallbackChain("anthropic/claude-sonnet-4-6")).toEqual([
+            "anthropic/claude-sonnet-4-6",
+        ]);
     });
 
     test("user-only when user provides valid fallback_models array", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, [
-            "anthropic/claude-sonnet-4-6",
-            "google/gemini-3-flash",
-        ]);
-        expect(chain).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+        expect(
+            resolveFallbackChain(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]),
+        ).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
     });
 
     test("dedupes user-provided list", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, [
-            "anthropic/claude-sonnet-4-6",
-            "anthropic/claude-sonnet-4-6",
-            "google/gemini-3-flash",
-        ]);
-        expect(chain).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+        expect(
+            resolveFallbackChain([
+                "anthropic/claude-sonnet-4-6",
+                "anthropic/claude-sonnet-4-6",
+                "google/gemini-3-flash",
+            ]),
+        ).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
     });
 
     test("strips invalid 'provider/model' entries", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, [
-            "anthropic/claude-sonnet-4-6",
-            "no-slash-here",
-            "/leading-slash",
-            "trailing-slash/",
-            "",
-            "  ",
-        ]);
-        expect(chain).toEqual(["anthropic/claude-sonnet-4-6"]);
+        expect(
+            resolveFallbackChain([
+                "anthropic/claude-sonnet-4-6",
+                "no-slash-here",
+                "/leading-slash",
+                "trailing-slash/",
+                "",
+                "  ",
+            ]),
+        ).toEqual(["anthropic/claude-sonnet-4-6"]);
     });
 
     test("trims whitespace in user entries", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, [
-            "  anthropic/claude-sonnet-4-6  ",
-            "\tgoogle/gemini-3-flash\n",
-        ]);
-        expect(chain).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
-    });
-
-    test("returns empty array for unknown agent with no user fallbacks", () => {
-        const chain = resolveFallbackChain("unknown-agent", undefined);
-        expect(chain).toEqual([]);
-    });
-
-    test("returns user fallbacks for unknown agent when provided", () => {
-        const chain = resolveFallbackChain("unknown-agent", ["foo/bar"]);
-        expect(chain).toEqual(["foo/bar"]);
-    });
-
-    test("HISTORIAN_AGENT has builtin chain", () => {
-        const chain = resolveFallbackChain(HISTORIAN_AGENT, undefined);
-        expect(chain.length).toBeGreaterThan(0);
-    });
-
-    test("SIDEKICK_AGENT has builtin chain", () => {
-        const chain = resolveFallbackChain(SIDEKICK_AGENT, undefined);
-        expect(chain.length).toBeGreaterThan(0);
-    });
-
-    test("user-only policy: builtin not appended even if user set short list", () => {
-        const chain = resolveFallbackChain(DREAMER_AGENT, ["anthropic/claude-sonnet-4-6"]);
-        expect(chain).toEqual(["anthropic/claude-sonnet-4-6"]);
-        // Confirm length is exactly 1, not user+builtin
-        expect(chain.length).toBe(1);
+        expect(
+            resolveFallbackChain(["  anthropic/claude-sonnet-4-6  ", "\tgoogle/gemini-3-flash\n"]),
+        ).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
     });
 });
 

package/src/shared/resolve-fallbacks.ts

@@ -1,37 +1,27 @@
-import { getAgentFallbackModels } from "./model-requirements";
-
 /**
- * Resolve the final fallback model list to attempt for an OpenCode subagent
- * call.
- *
- * Policy (decided 2026-05-10):
- *   - If user configured explicit `fallback_models` in their magic-context.jsonc
- *     for this agent: use ONLY those. Respects user intent, no surprise
- *     providers.
- *   - If user did NOT configure any: fall back to the plugin's builtin
- *     provider-agnostic chain (`AGENT_MODEL_REQUIREMENTS`).
+ * Resolve the fallback model list to attempt for a hidden-agent (historian /
+ * dreamer / sidekick) call when its configured primary fails.
  *
- * The returned list does NOT include the primary model — it's the ordered
- * list of *alternates* to try after the primary fails. Each entry is
- * "provider/modelID" form.
+ * Policy: ONLY the user's explicitly-configured `fallback_models` for this
+ * agent. There is NO builtin provider-agnostic chain — a hardcoded chain
+ * inevitably names providers the user doesn't have (e.g. a metapi-only user got
+ * a chain of google/github-copilot/opencode entries, every one a
+ * `Model not found` retry), which produced confusing errors and wasted
+ * attempts. If the user configured nothing, this returns an empty list and the
+ * runner's session-model last resort (the model the user is actually using) is
+ * the only fallback.
  *
- * Duplicates and empty strings are filtered. Entries that don't match the
- * "provider/modelID" shape (must contain a "/" with non-empty parts) are
- * also dropped — defensive guard against malformed user config.
+ * The returned list does NOT include the primary model — it's the ordered list
+ * of *alternates* to try after the primary fails. Each entry is
+ * "provider/modelID" form. Duplicates and empty strings are filtered; entries
+ * that don't match the "provider/modelID" shape (a "/" with non-empty parts) are
+ * dropped as a defensive guard against malformed user config.
  */
 export function resolveFallbackChain(
-    agentName: string,
     userFallbacks: readonly string[] | string | undefined,
 ): string[] {
     const userList = normalizeUserFallbacks(userFallbacks);
-
-    if (userList.length > 0) {
-        return dedupe(userList.filter(isValidModelSpec));
-    }
-
-    const builtin = getAgentFallbackModels(agentName);
-    if (!builtin || builtin.length === 0) return [];
-    return dedupe(builtin.filter(isValidModelSpec));
+    return dedupe(userList.filter(isValidModelSpec));
 }
 
 function normalizeUserFallbacks(userFallbacks: readonly string[] | string | undefined): string[] {

package/src/shared/rpc-types.ts

@@ -123,6 +123,17 @@ export interface StatusDetail extends SidebarSnapshot {
     compressionUsage: string | null;
 }
 
+/** Embedding coverage for `/ctx-embed` status (mirrors getEmbeddingCoverageStatus). */
+export interface EmbedDetail {
+    enabled: boolean;
+    model: string;
+    provider: string;
+    session: { embedded: number; total: number };
+    memories: { embedded: number; total: number };
+    commits: { embedded: number; total: number; gitEnabled: boolean };
+    statusText: string;
+}
+
 export interface RpcNotificationMessage {
     id: number;
     type: string;

package/src/shared/sqlite-bind-style.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Guard: SQLite statement binds must use SPREAD positional args
+ * (`stmt.run(a, b)`), never the ARRAY form (`stmt.run([a, b])`).
+ *
+ * Why this is a CI guard, not just a style preference: bun:sqlite (OpenCode)
+ * binds a lone array positionally, but node:sqlite (Pi, OpenCode Desktop) reads
+ * it as NAMED params ("0","1") and throws `Unknown named parameter '0'`. An
+ * array-form bind therefore passes every OpenCode/Bun test yet breaks Pi/Desktop
+ * silently — exactly how issue #151 (/ctx-dream) shipped. The sqlite.ts
+ * chokepoint now normalizes array binds for node:sqlite so it can no longer
+ * CRASH, but the array form is still discouraged: it relies on the shim, reads
+ * inconsistently with the rest of the codebase (all spread), and the guard
+ * catches it at PR time so the shim stays a safety net, not a crutch.
+ */
+
+// Scan EVERY package's src, not just plugin's. pi-plugin and cli have no
+// sqlite.ts of their own — they run on the shared chokepoint — so an array-form
+// bind written in their code would break under node:sqlite (Pi/Desktop) exactly
+// like #151, and the plugin-only scan would never see it. Roots are resolved
+// relative to plugin/src so the guard works from the plugin package.
+const PLUGIN_SRC = join(import.meta.dir, "..");
+const SCAN_ROOTS = [
+    PLUGIN_SRC,
+    join(PLUGIN_SRC, "../../pi-plugin/src"),
+    join(PLUGIN_SRC, "../../cli/src"),
+].filter((dir) => existsSync(dir));
+// The chokepoint itself documents the pattern in prose/comments; the guard's own
+// source mentions it; allow those two (relative to whichever root contains them).
+const ALLOWED = new Set(["shared/sqlite.ts", "shared/sqlite-bind-style.test.ts"]);
+// `stmt.run([` / `.get([` / `.all([` — but `.all([` also matches Promise.all([.
+const BIND_PATTERN = /\.(run|get|all)\(\[/;
+
+function collectTsFiles(dir: string, acc: string[] = []): string[] {
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        const st = statSync(full);
+        if (st.isDirectory()) {
+            collectTsFiles(full, acc);
+        } else if (entry.endsWith(".ts") && !entry.endsWith(".test.ts")) {
+            acc.push(full);
+        }
+    }
+    return acc;
+}
+
+describe("sqlite bind style", () => {
+    it("uses spread positional binds, never the array form", () => {
+        const violations: string[] = [];
+        for (const root of SCAN_ROOTS) {
+            for (const file of collectTsFiles(root)) {
+                const rel = file.slice(root.length + 1);
+                if (ALLOWED.has(rel)) continue;
+                const lines = readFileSync(file, "utf8").split("\n");
+                lines.forEach((line, i) => {
+                    if (!BIND_PATTERN.test(line)) return;
+                    // Promise.all([...]) is not a SQLite statement bind.
+                    if (line.includes("Promise.all(")) return;
+                    // Skip comment lines.
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith("//") || trimmed.startsWith("*")) return;
+                    // Disambiguate which package the hit is in.
+                    const pkg = root.includes("pi-plugin")
+                        ? "pi-plugin"
+                        : root.includes("cli")
+                          ? "cli"
+                          : "plugin";
+                    violations.push(`${pkg}/${rel}:${i + 1}  ${trimmed}`);
+                });
+            }
+        }
+        expect(
+            violations,
+            `Array-form SQLite binds found — use spread positional .run(a, b) ` +
+                `instead of .run([a, b]) (breaks under node:sqlite on Pi/Desktop):\n` +
+                violations.join("\n"),
+        ).toEqual([]);
+    });
+});

package/src/shared/sqlite.ts

@@ -25,12 +25,16 @@
  *   - db.transaction(fn) → wrapped function        ← shimmed for node:sqlite
  *   - db.close()
  *
- * The two backend differences we bridge for node:sqlite:
+ * The three backend differences we bridge for node:sqlite:
  *   1. node:sqlite has no `db.transaction(fn)` helper — we add a savepoint-aware
  *      shim (below) that matches better-sqlite3/bun semantics.
  *   2. node:sqlite's constructor option is `readOnly` (camel-case), not
  *      better-sqlite3/bun's `readonly` — we translate it so call sites are
  *      unchanged.
+ *   3. node:sqlite reads a lone array bind arg (`.run([a,b])`) as NAMED params
+ *      and throws `Unknown named parameter '0'`; bun binds it positionally. We
+ *      normalize it in the `prepare()` override (below) so the bind surface is
+ *      identical (issue #151 / Pi /ctx-dream).
  * Everything else (named params with bare keys, ATTACH under defensive mode,
  * `run()` → {changes,lastInsertRowid}) is identical and was verified directly.
  */
@@ -104,6 +108,31 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
             super(typeof filename === "string" ? filename : ":memory:", translated);
         }
 
+        // Normalize a single ARRAY bind arg to spread positional, matching
+        // bun:sqlite. bun's `.run([a,b])` binds positionally; node:sqlite instead
+        // reads a lone array as NAMED params with keys "0","1" and throws
+        // `Unknown named parameter '0'`. That divergence let an array-form bind
+        // (e.g. `.run([x, y])`) silently work on OpenCode/Bun yet break Pi and
+        // OpenCode Desktop (both node:sqlite) — issue #151 (/ctx-dream). Wrapping
+        // every prepared statement here keeps the two backends' bind surface
+        // truly identical so this whole class is impossible regardless of how a
+        // call site writes its bind. Named-object binds (`.run({k:v})`), no-arg
+        // calls, and already-spread positional args are passed through unchanged;
+        // the normalization only triggers on the exact 1-array shape. Overhead
+        // measured at ~12ns/call against real node:sqlite (negligible).
+        // biome-ignore lint/suspicious/noExplicitAny: node:sqlite StatementSync has no shipped types here.
+        prepare(sql: string): any {
+            const stmt = super.prepare(sql);
+            for (const method of ["run", "get", "all"] as const) {
+                const original = stmt[method].bind(stmt);
+                stmt[method] = (...args: unknown[]): unknown =>
+                    args.length === 1 && Array.isArray(args[0])
+                        ? original(...args[0])
+                        : original(...args);
+            }
+            return stmt;
+        }
+
         // biome-ignore lint/suspicious/noExplicitAny: mirrors better-sqlite3's generic transaction(fn) signature.
         transaction<F extends (...args: any[]) => any>(fn: F): F {
             // biome-ignore lint/suspicious/noExplicitAny: faithful pass-through of this/args to fn.

package/src/shared/tag-transcript.test.ts

@@ -203,7 +203,9 @@ describe("tagTranscript tool aggregation", () => {
             result = targets.get(tag ?? -1)?.truncate?.();
         }).not.toThrow();
         expect(result).toBe("truncated");
-        expect(toolUse.getText()).toBe("[truncated]");
+        // Skeleton-drop now renders the one canonical placeholder, not a
+        // separate "[truncated]" vocabulary.
+        expect(toolUse.getText()).toBe(`[dropped \u00a7${tag}\u00a7]`);
     });
 
     it("drops every contiguous folded tool_result block for the paired callId", () => {

package/src/shared/tag-transcript.ts

@@ -611,7 +611,7 @@ function tagToolPart(args: TagToolPartArgs): void {
         args.part.setText(tagged);
     }
 
-    args.targets.set(tagId, buildToolTarget(args.part, args.message));
+    args.targets.set(tagId, buildToolTarget(args.part, args.message, tagId));
 }
 
 function setToolContentOrText(part: TranscriptPart, content: string): boolean {
@@ -679,10 +679,11 @@ function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): Tag
             return any ? "removed" : "absent";
         },
         truncate(): "truncated" | "absent" {
-            // Truncate BOTH halves. For tool_use, this typically truncates
-            // the args; for tool_result, the output. The sentinel string
-            // matches OpenCode's truncate sentinel exactly.
-            const sentinel = "[truncated]";
+            // Skeleton-drop: replace BOTH halves' content with the one
+            // canonical `[dropped §N§]` placeholder (byte-identical to a full
+            // drop and to OpenCode). Frozen by the dropMode column → replays
+            // the same string every pass. The tool_use call survives intact.
+            const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
             let any = false;
             for (const occ of occurrences) {
                 if (setToolContentOrText(occ.part, sentinel)) {
@@ -739,16 +740,17 @@ function buildTextTarget(
 }
 
 /**
- * TagTarget for a tag-eligible tool part. Tool parts get full-drop
- * (replace with `[dropped §N§]`) or truncated-drop (replace with
- * `[truncated]`) treatment from `applyFlushedStatuses` based on the
- * stored `drop_mode` column. We expose both via the standard target
- * surface; replaceWithSentinel is the canonical mutation, with
- * truncated-drop using the "[truncated]" string.
+ * TagTarget for a tag-eligible tool part. Tool parts get full-drop or
+ * skeleton-drop treatment from `applyFlushedStatuses` based on the stored
+ * `drop_mode` column. Both render the SAME canonical `[dropped §N§]`
+ * placeholder — full-drop replaces the whole pair, skeleton-drop keeps the
+ * tool_use call and replaces only its output. One placeholder string,
+ * byte-identical across passes and across harnesses.
  */
 function buildToolTarget(
     part: TranscriptPart,
     message: { info: { id?: string; role: string } },
+    tagId: number,
 ): TagTarget {
     return {
         setContent(content: string): boolean {
@@ -765,15 +767,15 @@ function buildToolTarget(
             // For Pi the current Transcript contract treats both
             // invocation and result parts symmetrically — both expose
             // setText / setToolOutput.
-            const replaced = part.replaceWithSentinel(`[dropped \u00a7${part.id ?? "?"}\u00a7]`);
+            const replaced = part.replaceWithSentinel(`[dropped \u00a7${tagId}\u00a7]`);
             return replaced ? "removed" : "absent";
         },
         truncate(): "truncated" | "absent" {
-            // Truncate the tool output to a fixed sentinel string. Done
-            // via setToolOutput so the underlying tool_result content
-            // gets the truncation; falls back to setText for cases
-            // where the part type doesn't support setToolOutput.
-            const ok = setToolContentOrText(part, "[truncated]");
+            // Skeleton-drop: replace the tool output with the one canonical
+            // `[dropped §N§]` placeholder (byte-identical to a full drop and to
+            // OpenCode). Frozen by the dropMode column, so it replays the same
+            // string every pass. The tool_use call itself survives intact.
+            const ok = setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`);
             return ok ? "truncated" : "absent";
         },
         message: {

package/src/tui/data/context-db.ts

@@ -5,9 +5,14 @@
 import os from "node:os";
 import path from "node:path";
 import { MagicContextRpcClient } from "../../shared/rpc-client";
-import type { RpcNotificationMessage, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
+import type {
+    EmbedDetail,
+    RpcNotificationMessage,
+    SidebarSnapshot,
+    StatusDetail,
+} from "../../shared/rpc-types";
 
-export type { SidebarSnapshot, StatusDetail };
+export type { EmbedDetail, SidebarSnapshot, StatusDetail };
 
 let rpcClient: MagicContextRpcClient | null = null;
 let rpcGeneration = 0;
@@ -218,6 +223,33 @@ export async function loadStatusDetail(
     }
 }
 
+const EMPTY_EMBED_DETAIL: EmbedDetail = {
+    enabled: false,
+    model: "off",
+    provider: "off",
+    session: { embedded: 0, total: 0 },
+    memories: { embedded: 0, total: 0 },
+    commits: { embedded: 0, total: 0, gitEnabled: false },
+    statusText: "Embedding is off (no provider configured).",
+};
+
+/** Fetch embedding coverage status for `/ctx-embed` via RPC. */
+export async function loadEmbedDetail(sessionId: string, directory: string): Promise<EmbedDetail> {
+    if (!rpcClient) return EMPTY_EMBED_DETAIL;
+    try {
+        const result = await rpcClient.call<EmbedDetail>("embed-detail", {
+            sessionId,
+            directory,
+        });
+        if ((result as unknown as Record<string, unknown>).error) {
+            return EMPTY_EMBED_DETAIL;
+        }
+        return result;
+    } catch {
+        return EMPTY_EMBED_DETAIL;
+    }
+}
+
 /** Get compartment count via RPC. */
 export async function getCompartmentCount(sessionId: string): Promise<number> {
     if (!rpcClient) return 0;

package/src/tui/index.tsx

@@ -6,7 +6,7 @@ import { createMemo } from "solid-js"
 import type { TuiPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import { createSidebarContentSlot, kickRecompProgressRefresh } from "./slots/sidebar-content"
 import packageJson from "../../package.json"
-import { closeRpc, consumeTuiMessages, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadStatusDetail, markAnnounced, markTuiMessagesHandled, requestRecomp, requestUpgrade, type TuiMessage, type StatusDetail } from "./data/context-db"
+import { closeRpc, consumeTuiMessages, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, markAnnounced, markTuiMessagesHandled, requestRecomp, requestUpgrade, type EmbedDetail, type TuiMessage, type StatusDetail } from "./data/context-db"
 import { formatThresholdPercent } from "../shared/format-threshold"
 import { detectConflicts } from "../shared/conflict-detector"
 import { fixConflicts } from "../shared/conflict-fixer"
@@ -353,7 +353,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                         }
                         if (p.phase === "migration") return <R t={t()} l="Status" v={p.note ?? "Migrating memories ⟳"} fg={t().warning} />
                         if (p.phase === "done") return <R t={t()} l="Status" v={`✓ ${verb} complete`} fg={t().accent} />
-                        if (p.phase === "skipped") return <R t={t()} l="Status" v={`${verb} skipped — retry shortly${p.message ? `: ${p.message}` : ""}`} fg={t().textMuted} />
+                        if (p.phase === "skipped") return <R t={t()} l="Status" v={p.message ?? `${verb} stopped early`} fg={t().textMuted} />
                         return <R t={t()} l="Status" v={`✗ ${verb} failed${p.message ? `: ${p.message}` : ""}`} fg={t().error} />
                     })()}
                 </box>
@@ -580,14 +580,53 @@ async function showStatusDialog(api: TuiPluginApi, targetSessionId = getSessionI
     const directory = api.state.path.directory ?? ""
     const modelKey = getModelKeyFromMessages(api, sessionId)
     const detail = await loadStatusDetail(sessionId, directory, modelKey)
-    // Ack only after the dialog is actually shown for the same active session;
-    // route switches while the RPC detail load is in flight must leave it pending.
     if (getSessionId(api) !== sessionId) return false
 
     api.ui.dialog.replace(() => <StatusDialog api={api} s={detail} />)
     return true
 }
 
+const EmbedDialog = (props: { api: TuiPluginApi; detail: EmbedDetail }) => {
+    const theme = createMemo(() => (props.api as any).theme.current)
+    const t = () => theme()
+    const lines = () => props.detail.statusText.split("\n")
+    return (
+        <box flexDirection="column" width="100%" paddingLeft={2} paddingRight={2} paddingTop={1} paddingBottom={1}>
+            <box justifyContent="center" width="100%" marginBottom={1}>
+                <text fg={t().accent}><b>Embedding</b></text>
+            </box>
+            {lines().map((line) => (
+                <text fg={t().text}>{line}</text>
+            ))}
+        </box>
+    )
+}
+
+async function showEmbedDialog(api: TuiPluginApi, targetSessionId = getSessionId(api)): Promise<boolean> {
+    const sessionId = targetSessionId
+    if (!sessionId) {
+        api.ui.toast({ message: "No active session", variant: "warning" })
+        return false
+    }
+    const directory = api.state.path.directory ?? ""
+    const detail = await loadEmbedDetail(sessionId, directory)
+    if (getSessionId(api) !== sessionId) return false
+    api.ui.dialog.replace(() => <EmbedDialog api={api} detail={detail} />)
+    return true
+}
+
+function showResultDialog(api: TuiPluginApi, title: string, message: string): boolean {
+    api.ui.dialog.replace(() => (
+        <api.ui.DialogAlert
+            title={title}
+            message={message}
+            onConfirm={() => {}}
+        />
+    ))
+    return true
+}
+
+
 /**
  * Register Magic Context command palette entries, preferring the v1.14.42+
  * `keymap.registerLayer` API and falling back to the legacy
@@ -842,6 +881,21 @@ const tui: TuiPlugin = async (api, _options, meta) => {
                         if (showUpgradeDialog(api, resume, requestedSessionId)) {
                             handledMessageIds.add(msg.id)
                         }
+                    } else if (action === "show-embed-dialog") {
+                        if (await showEmbedDialog(api, requestedSessionId)) {
+                            handledMessageIds.add(msg.id)
+                        }
+                    } else if (action === "show-flush-dialog") {
+                        const flushMsg = String(msg.payload?.message ?? "Flushed.")
+                        if (showResultDialog(api, "Flush", flushMsg)) {
+                            handledMessageIds.add(msg.id)
+                        }
+                    } else if (action === "show-result-dialog") {
+                        const title = String(msg.payload?.title ?? "Magic Context")
+                        const body = String(msg.payload?.message ?? "")
+                        if (showResultDialog(api, title, body)) {
+                            handledMessageIds.add(msg.id)
+                        }
                     }
                 }
             }

package/src/tui/slots/sidebar-content.tsx

@@ -1,5 +1,5 @@
 /** @jsxImportSource @opentui/solid */
-import { createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
+import { Show, createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 import type { TuiSlotPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import packageJson from "../../../package.json"
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
@@ -394,8 +394,13 @@ const RecompProgressSection = (props: {
             case "done":
                 return { text: `✓ ${verb()} complete`, color: props.theme.success ?? props.theme.accent }
             case "skipped":
-                // Transient (lease busy) — neutral, not an error.
-                return { text: `${verb()} skipped — retry shortly`, color: props.theme.textMuted }
+                // Neutral terse status next to the bold verb header; the full,
+                // self-contained reason (lease-busy "try again shortly" vs a
+                // partial-stall "run /ctx-embed start again") renders on its own
+                // line below. Don't re-prepend verb here (it's already the bold
+                // header — doing so read as "EmbedEmbed"), and don't hardcode
+                // "retry shortly" (wrong for a partial stall).
+                return { text: "stopped", color: props.theme.textMuted }
             case "failed":
                 return { text: `✗ ${verb()} failed`, color: props.theme.error }
         }
@@ -750,9 +755,11 @@ const SidebarContent = (props: {
                             C:{s()?.compartmentCount ?? 0} Q:{s()?.pendingOpsCount ?? 0} N:{s()?.sessionNoteCount ?? 0}
                         </text>
                     </box>
-                    {s()?.recompProgress && (
-                        <RecompProgressSection theme={props.theme} progress={s()!.recompProgress!} />
-                    )}
+                    <Show when={s()?.recompProgress}>
+                        {(progress) => (
+                            <RecompProgressSection theme={props.theme} progress={progress()} />
+                        )}
+                    </Show>
                 </box>
             )}
 
@@ -784,9 +791,11 @@ const SidebarContent = (props: {
             />
 
             {/* Recomp / session-upgrade live progress */}
-            {s()?.recompProgress && (
-                <RecompProgressSection theme={props.theme} progress={s()!.recompProgress!} />
-            )}
+            <Show when={s()?.recompProgress}>
+                {(progress) => (
+                    <RecompProgressSection theme={props.theme} progress={progress()} />
+                )}
+            </Show>
                 </>
             )}