@cortexkit/opencode-magic-context 0.41.3 → 0.41.4

package/src/shared/jsonc-parser.ts

@@ -1,5 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
 
+import {
+    type ParseError,
+    parse as parseJsoncDocument,
+    printParseErrorCode,
+} from "jsonc-parser/lib/esm/main.js";
+// ^ Deep ESM import on purpose, same as jsonc-edit.ts: the package's "main" is a
+// UMD bundle whose runtime-relative requires (`./impl/format`) survive bundling
+// verbatim and crash the plugin at boot. The build:dists load-probe gate exists
+// to catch exactly this; do not import the bare package name.
+
 export function stripJsonComments(content: string): string {
     let result = "";
     let inString = false;
@@ -155,6 +165,89 @@ export function sanitizeParsedJson<T>(
     return sanitized as T;
 }
 
+export interface JsoncParseIssue {
+    line: number;
+    column: number;
+    offset: number;
+    length: number;
+    message: string;
+}
+
+export interface RecoveringJsoncParseResult<T> {
+    value: T;
+    issues: JsoncParseIssue[];
+}
+
+function lineAndColumnAt(content: string, offset: number): { line: number; column: number } {
+    const before = content.slice(0, Math.max(0, offset));
+    const lines = before.split(/\r?\n/);
+    return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
+}
+
+function parseIssue(content: string, error: ParseError): JsoncParseIssue {
+    const location = lineAndColumnAt(content, error.offset);
+    const code = printParseErrorCode(error.error);
+    const message = code.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    return {
+        ...location,
+        offset: error.offset,
+        length: error.length,
+        message,
+    };
+}
+
+/**
+ * Parse JSONC with the same recovery grammar used by the runtime config loaders.
+ * Syntax diagnostics are never discarded: callers must surface every non-empty
+ * `issues` result even when the parser recovered a usable object.
+ */
+function normalizeJsoncParserObjects(
+    value: unknown,
+    options: ParsedJsonSanitizerOptions,
+    path: string[] = [],
+): unknown {
+    if (Array.isArray(value)) {
+        return value.map((entry, index) =>
+            normalizeJsoncParserObjects(entry, options, [...path, String(index)]),
+        );
+    }
+    if (value === null || typeof value !== "object") return value;
+
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        // jsonc-parser assigns an own "__proto__" property through normal JS
+        // assignment, which changes only this parsed object's prototype. Treat
+        // that prototype as the rejected key and copy only its own safe fields.
+        options.onRejectedKey?.([...path, "__proto__"]);
+    }
+    const normalized: Record<string, unknown> = {};
+    for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+        Object.defineProperty(normalized, key, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: normalizeJsoncParserObjects(entry, options, [...path, key]),
+        });
+    }
+    return normalized;
+}
+
+export function parseJsoncRecovering<T = unknown>(
+    content: string,
+    options: ParsedJsonSanitizerOptions = {},
+): RecoveringJsoncParseResult<T> {
+    const errors: ParseError[] = [];
+    const parsed = parseJsoncDocument(content, errors, {
+        allowTrailingComma: true,
+        disallowComments: false,
+        allowEmptyContent: false,
+    }) as T;
+    return {
+        value: sanitizeParsedJson(normalizeJsoncParserObjects(parsed, options) as T, options),
+        issues: errors.map((error) => parseIssue(content, error)),
+    };
+}
+
 export function parseJsonc<T = unknown>(
     content: string,
     options: ParsedJsonSanitizerOptions = {},

package/src/shared/model-suggestion-retry.ts

@@ -3,6 +3,7 @@ import type { createOpencodeClient } from "@opencode-ai/sdk";
 import { detectOverflow } from "../features/magic-context/overflow-detection";
 import { log } from "./logger";
 import type { ModelInput } from "./model-resolution";
+import { sanitizeDiagnosticText } from "./redaction";
 import { parseProviderModel, toModelEntry } from "./resolve-fallbacks";
 
 type Client = ReturnType<typeof createOpencodeClient>;
@@ -100,6 +101,33 @@ export interface ValidatedPromptRetryResult<TOutput, TValidated> {
     attempt: PromptAttemptInfo;
 }
 
+export type PromptFailureClass =
+    | "provider_timeout"
+    | "provider_error"
+    | "empty_completion"
+    | "no_models"
+    | "child_aborted"
+    | "parse_failed"
+    | "unknown";
+
+/** Diagnostic facts retained when a validated child prompt ultimately fails. */
+export interface PromptFailureDetail {
+    failureClass: PromptFailureClass;
+    modelAttempted: string | null;
+    modelsTried: string[];
+    providerError: string | null;
+    timeoutMs: number | null;
+    childSessionId: string | null;
+}
+
+const promptFailureDetails = new WeakMap<object, PromptFailureDetail>();
+
+export function getPromptFailureDetail(error: unknown): PromptFailureDetail | null {
+    return error !== null && typeof error === "object"
+        ? (promptFailureDetails.get(error) ?? null)
+        : null;
+}
+
 export interface ModelSuggestionInfo {
     providerID: string;
     modelID: string;
@@ -279,6 +307,61 @@ function shortErr(error: unknown): string {
     return extractMessage(error);
 }
 
+type PromptFailurePhase = "prompt" | "output" | "validation";
+
+interface FailedAttempt {
+    error: unknown;
+    failureClass: PromptFailureClass;
+    attempt: PromptAttemptInfo;
+}
+
+function classifyPromptFailure(
+    error: unknown,
+    phase: PromptFailurePhase,
+    externalSignal?: AbortSignal,
+): PromptFailureClass {
+    const message = extractMessage(error);
+    if (externalSignal?.aborted || message === "prompt aborted by external signal") {
+        return "child_aborted";
+    }
+    if (/^prompt timed out after \d+ms$/.test(message)) return "provider_timeout";
+    if (phase === "validation") {
+        if (/returned no (?:assistant )?output|no assistant output/i.test(message)) {
+            return "empty_completion";
+        }
+        if (error instanceof Error && error.name === "DreamerProviderOutputFailureError") {
+            return "provider_error";
+        }
+        return "parse_failed";
+    }
+    return phase === "prompt" || phase === "output" ? "provider_error" : "unknown";
+}
+
+function throwWithPromptFailure(
+    legacyError: unknown,
+    failedAttempts: FailedAttempt[],
+    args: PromptArgs,
+    timeoutMs: number,
+): never {
+    const error =
+        legacyError instanceof Error ? legacyError : new Error(extractMessage(legacyError));
+    const last = failedAttempts.at(-1);
+    const failureClass = last?.failureClass ?? "unknown";
+    const providerError =
+        failureClass === "provider_error"
+            ? sanitizeDiagnosticText(shortErr(last?.error ?? legacyError)).slice(0, 500)
+            : null;
+    promptFailureDetails.set(error, {
+        failureClass,
+        modelAttempted: last?.attempt.label ?? null,
+        modelsTried: failedAttempts.map((failure) => failure.attempt.label),
+        providerError,
+        timeoutMs: failureClass === "provider_timeout" ? timeoutMs : null,
+        childSessionId: args.path.id || null,
+    });
+    throw error;
+}
+
 /**
  * Try a single prompt attempt against the supplied body, with the existing
  * single-suggestion retry layered inside (so "did you mean X?" still self-heals
@@ -449,23 +532,43 @@ async function attemptAndValidate<TOutput, TValidated>(
     attempt: PromptAttemptInfo,
     options: ValidatedPromptRetryOptions<TOutput, TValidated>,
 ): Promise<ValidatedPromptRetryResult<TOutput, TValidated>> {
-    await attemptOnce(client, args, timeoutMs, signal, callContext, attempt.label);
-    const output = await options.fetchOutput(args, attempt);
-    const validated = await options.validateOutput(output, attempt);
-    return { output, validated, attempt };
+    try {
+        await attemptOnce(client, args, timeoutMs, signal, callContext, attempt.label);
+    } catch (error) {
+        throw {
+            error,
+            failureClass: classifyPromptFailure(error, "prompt", signal),
+            attempt,
+        } satisfies FailedAttempt;
+    }
+
+    let output: TOutput;
+    try {
+        output = await options.fetchOutput(args, attempt);
+    } catch (error) {
+        throw {
+            error,
+            failureClass: classifyPromptFailure(error, "output", signal),
+            attempt,
+        } satisfies FailedAttempt;
+    }
+
+    try {
+        const validated = await options.validateOutput(output, attempt);
+        return { output, validated, attempt };
+    } catch (error) {
+        throw {
+            error,
+            failureClass: classifyPromptFailure(error, "validation", signal),
+            attempt,
+        } satisfies FailedAttempt;
+    }
 }
 
 /**
- * Run a prompt with model fallback support, but accept an attempt only after the
- * caller validates the model's actual output. This covers "empty success" cases
- * where the provider/OpenCode prompt call completes successfully but the subagent
- * produced no usable assistant text / JSON.
- *
- * The happy path is still one prompt + one caller-owned output fetch: callers
- * should use the returned output instead of fetching messages a second time.
- * Validation failures are retryable across configured fallback models. If every
- * attempt produces invalid output (or otherwise fails retryably), the first
- * failure is re-thrown so callers surface the original failure semantics.
+ * Run a prompt across the configured model chain and retain which attempt failed.
+ * Output validation remains caller-owned so empty completions and malformed
+ * responses can be distinguished from provider transport failures.
  */
 export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = TOutput>(
     client: Client,
@@ -486,7 +589,7 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
             ? `${baseBody.model.providerID}/${baseBody.model.modelID}`
             : "primary";
     const totalAttempts = fallbacks.length + 1;
-
+    const failedAttempts: FailedAttempt[] = [];
     let firstError: unknown = null;
     let lastError: unknown = null;
 
@@ -506,17 +609,21 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
             },
             options,
         );
-    } catch (error) {
-        firstError = error;
-        lastError = error;
-        if (isNonRetryable(error, options.signal)) throw error;
+    } catch (caught) {
+        const failure = caught as FailedAttempt;
+        failedAttempts.push(failure);
+        firstError = failure.error;
+        lastError = failure.error;
+        if (isNonRetryable(failure.error, options.signal)) {
+            throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs);
+        }
 
         if (fallbacks.length === 0) {
-            throw error;
+            throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs);
         }
 
         log(
-            `[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(error)}; trying ${fallbacks.length} fallback(s)`,
+            `[${callContext}] primary (${explicitPrimaryLabel}) failed validation/prompt: ${shortErr(failure.error)}; trying ${fallbacks.length} fallback(s)`,
         );
     }
 
@@ -557,22 +664,30 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
                 `[${callContext}] fallback succeeded with ${label} (attempt ${i + 2}/${fallbacks.length + 1})`,
             );
             return result;
-        } catch (error) {
-            if (firstError === null) firstError = error;
-            lastError = error;
-            if (isNonRetryable(error, options.signal)) throw error;
+        } catch (caught) {
+            const failure = caught as FailedAttempt;
+            failedAttempts.push(failure);
+            lastError = failure.error;
+            if (isNonRetryable(failure.error, options.signal)) {
+                throwWithPromptFailure(failure.error, failedAttempts, args, timeoutMs);
+            }
 
             const remaining = fallbacks.length - i - 1;
             if (remaining > 0) {
                 log(
-                    `[${callContext}] ${label} failed validation/prompt: ${shortErr(error)}; ${remaining} fallback(s) left`,
+                    `[${callContext}] ${label} failed validation/prompt: ${shortErr(failure.error)}; ${remaining} fallback(s) left`,
                 );
             }
         }
     }
 
     log(
-        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
+        `[${callContext}] all models exhausted; tried: ${failedAttempts.map((failure) => failure.attempt.label).join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
+    );
+    throwWithPromptFailure(
+        firstError ?? lastError ?? new Error("All fallback models failed validation"),
+        failedAttempts,
+        args,
+        timeoutMs,
     );
-    throw firstError ?? lastError ?? new Error("All fallback models failed validation");
 }

package/src/shared/pi-executable.ts

@@ -0,0 +1,20 @@
+export type PiExecutableHarnessKind = "pi" | "omp";
+
+/** Executable images recognized as Pi-compatible hosts. */
+export const PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
+
+/** Classify a process title or executable path using the shared Pi image vocabulary. */
+export function piHarnessKindFromExecutable(
+    value: string | undefined,
+): PiExecutableHarnessKind | undefined {
+    const executable = (value ?? "")
+        .trim()
+        .replace(/^['"]|['"]$/g, "")
+        .replaceAll("\\", "/")
+        .split("/")
+        .at(-1)
+        ?.toLowerCase()
+        .replace(/\.(?:exe|cmd)$/, "");
+    if (!executable || !PI_IMAGE_NAMES.has(executable)) return undefined;
+    return executable === "pi" ? "pi" : "omp";
+}

package/src/shared/rpc-types.ts

@@ -7,6 +7,7 @@ import type {
     DreamTaskBacklogMap,
     DreamTaskProgress,
 } from "../features/magic-context/dreamer/task-registry";
+import type { ConfigParseFailure } from "./config-diagnostics";
 import type { LoggerDiagnostics } from "./logger";
 
 export interface TailHygieneStatus {
@@ -181,6 +182,11 @@ export interface StatusDetail extends SidebarSnapshot {
      *  (only meaningful when lastResponseTime > 0); N = live countdown. */
     cacheRemainingMs: number;
     cacheExpired: boolean;
+    /** Reports whether the displayed TTL came from config, persisted session metadata,
+     *  or the default; cache scheduling still uses the TTL stored in session metadata. */
+    cacheTtlSource?: "config" | "session" | "default";
+    cacheTtlModelKey?: string;
+    configParseFailures?: ConfigParseFailure[];
     /** True when cacheTtl is "never" — the idle-TTL heuristic is disabled on
      *  this lane. Redundant with cacheTtlMs === -1; kept as the readable form. */
     cacheNeverExpires?: boolean;

package/src/shared/rpc-utils.ts

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { log } from "./logger";
+import { PI_IMAGE_NAMES, piHarnessKindFromExecutable } from "./pi-executable";
 
 export type ProcessKind = "OpenCode server" | "OpenCode instance (TUI/CLI)" | "Pi" | "process";
 
@@ -102,8 +103,6 @@ const PI_HARNESS_ARC_MARKERS = [
     "cljs/dist",
     "dist/bundle/cli",
 ];
-const PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
-
 let rpcIdentityReadFileSync: typeof readFileSync = readFileSync;
 let rpcIdentityExecFileSync: typeof execFileSync = execFileSync;
 let rpcIdentityProcessKill: typeof process.kill = process.kill;
@@ -346,7 +345,7 @@ function commandHasOpenCodeExecutable(tokens: readonly string[]): number {
 function commandHasPiExecutable(tokens: readonly string[]): boolean {
     for (let index = 0; index < tokens.length; index += 1) {
         const executable = executableName(tokens[index]).replace(/\.(?:exe|cmd)$/, "");
-        if (["pi", "omp", "oh-my-pi"].includes(executable)) return true;
+        if (piHarnessKindFromExecutable(executable) !== undefined) return true;
         if (["node", "bun", "deno"].includes(executable)) {
             const script = executableName(tokens[index + 1]).replace(/\.(?:exe|cmd)$/, "");
             if (

package/src/shared/status-detail-text.test.ts

@@ -18,6 +18,7 @@ const STATUS_FIXTURE: StatusDetail = {
     sessionNoteCount: 1,
     readySmartNoteCount: 2,
     cacheTtl: "5m",
+    cacheTtlSource: "session",
     lastTransformError: null,
     lastDreamerRunAt: null,
     projectIdentity: "/repo",
@@ -73,7 +74,7 @@ describe("formatStatusDetailMarkdown", () => {
 - **Mode:** Magic Context compaction
 - **Active profile:** work
 - **Usage:** 75.0% (96,000 / 128,000 usable tokens)
-- **Cache lane:** live (42s remaining); TTL 5m
+- **Cache TTL: 5m (session)**; live (42s remaining); TTL 5m
 - **Historian:** running; boundary present; coverage 12
 - **Memory:** 8 active; 3 injected
 - **Tags:** 4 active, 1 dropped; 2 pending drops

package/src/shared/status-detail-text.ts

@@ -1,3 +1,5 @@
+import { formatCacheTtlDisplay } from "./cache-ttl-display";
+import { formatConfigParseStatusLine } from "./config-diagnostics";
 import type { StatusDetail } from "./rpc-types";
 import { RUST_MODE_HOST_PATHS_LINE } from "./rust-mode-status";
 
@@ -33,12 +35,14 @@ export function formatStatusDetailMarkdown(detail: StatusDetail): string {
             : "Magic Context compaction";
 
     const lines = [
+        ...(detail.configParseFailures ?? []).map(formatConfigParseStatusLine),
+        ...((detail.configParseFailures?.length ?? 0) > 0 ? [""] : []),
         "## Magic Context Status",
         "",
         `- **Mode:** ${mode}`,
         `- **Active profile:** ${detail.activeProfile ?? "none"}`,
         `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount(detail.inputTokens)} / ${usableLimit})`,
-        `- **Cache lane:** ${formatCacheLane(detail)}`,
+        `- **${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`,

package/src/shared/tag-transcript.ts

@@ -184,6 +184,8 @@ interface ToolAggregate {
     inputByteSize: number;
     /** Persisted input-token count, or null for a legacy/unobserved invocation. */
     inputTokenCount: number | null;
+    /** At least one assistant-side occurrence shares its message with native reasoning. */
+    requiresToolArcSkeleton: boolean;
 }
 
 function textIdentityDigest(value: string): string {
@@ -244,6 +246,8 @@ export function tagTranscript(
         let textOrdinal = 0;
         let toolResultOrdinal = 0;
         const parts = message.parts;
+        const messageHasNativeReasoning =
+            message.info.role === "assistant" && parts.some((part) => part.kind === "thinking");
         const contentDerivedTextIds =
             messageId !== undefined && options.textIdentityDriftMessageIds?.has(messageId) === true
                 ? buildContentDerivedTextIds(messageId, parts)
@@ -345,6 +349,7 @@ export function tagTranscript(
                 const existing = toolAggregates.get(aggregateKey);
                 if (existing) {
                     existing.occurrences.push({ message, part, kind: part.kind });
+                    existing.requiresToolArcSkeleton ||= messageHasNativeReasoning;
                     const canReuseIdentity = reuseIdentity && existing.identityReusable;
                     let text = "";
                     if (canReuseIdentity) {
@@ -463,6 +468,7 @@ export function tagTranscript(
                         toolName: null,
                         inputByteSize: reusableAccounting.inputByteSize,
                         inputTokenCount: reusableAccounting.inputTokenCount,
+                        requiresToolArcSkeleton: messageHasNativeReasoning,
                     };
                     if (part.kind === "tool_result") {
                         text = part.getText() ?? "";
@@ -527,6 +533,7 @@ export function tagTranscript(
                         inputTokenCount:
                             persistedAccounting?.inputTokenCount ??
                             (part.kind === "tool_use" ? firstInputTokenCount : null),
+                        requiresToolArcSkeleton: messageHasNativeReasoning,
                     };
                     if (part.kind === "tool_result") {
                         applyGrownToolResultAccounting({
@@ -678,7 +685,14 @@ function applyToolPrefixAndTarget(args: ApplyToolPrefixAndTargetArgs): void {
         if (args.timing) args.timing.prefix += performance.now() - prefixStart;
     }
     const targetStart = args.timing ? performance.now() : 0;
-    args.targets.set(args.tagId, buildAggregateTarget(args.tagId, args.aggregate.occurrences));
+    args.targets.set(
+        args.tagId,
+        buildAggregateTarget(
+            args.tagId,
+            args.aggregate.occurrences,
+            args.aggregate.requiresToolArcSkeleton,
+        ),
+    );
     if (args.timing) args.timing.targets += performance.now() - targetStart;
 }
 
@@ -1010,7 +1024,11 @@ function setToolContentOrText(part: TranscriptPart, content: string): boolean {
  *
  * Mirrors OpenCode's createToolDropTarget semantics in tool-drop-target.ts.
  */
-function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): TagTarget {
+function buildAggregateTarget(
+    tagId: number,
+    occurrences: ToolOccurrence[],
+    requiresToolArcSkeleton: boolean,
+): TagTarget {
     const role = occurrences[0]?.message.info.role ?? "user";
     const messageId = occurrences[0]?.message.info.id;
 
@@ -1090,6 +1108,7 @@ function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): Tag
         canDrop(): boolean {
             return occurrences.length > 0;
         },
+        requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence
         // carries the arguments). Used by smart-drops supersession selection.
         readInput(): Record<string, unknown> | null {

package/src/tui/index.tsx

@@ -10,6 +10,8 @@ import {
 import packageJson from "../../package.json"
 import { closeRpc, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, requestRecomp, requestUpgrade, type EmbedDetail, type StatusDetail } from "./data/context-db"
 import { startNotificationSocket, stopNotificationSocket, type SocketNotification } from "./data/notification-socket"
+import { formatCacheTtlDisplay } from "../shared/cache-ttl-display"
+import { formatConfigParseStatusLine } from "../shared/config-diagnostics"
 import { formatThresholdPercent } from "../shared/format-threshold"
 import { formatTailHygiene } from "../shared/tail-hygiene-status"
 import { RUST_MODE_HOST_PATHS_LINE } from "../shared/rust-mode-status"
@@ -228,6 +230,10 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 <text fg={t().textMuted}>v{packageJson.version}</text>
             </box>
 
+            {s().configParseFailures.map((failure) => (
+                <text fg={t().error}>{formatConfigParseStatusLine(failure)}</text>
+            ))}
+
             <box flexDirection="row" justifyContent="space-between" width="100%">
                 {compactionOff() ? (
                     <text fg={t().accent}>
@@ -378,7 +384,15 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                             <box marginTop={1}>
                                 <text fg={t().text}><b>Cache TTL</b></text>
                             </box>
-                            <R t={t()} l="Configured" v={s().cacheTtl} />
+                            <R
+                                t={t()}
+                                l="Configured"
+                                v={formatCacheTtlDisplay({
+                                    value: s().cacheTtl,
+                                    source: s().cacheTtlSource,
+                                    modelKey: s().cacheTtlModelKey,
+                                }).replace(/^Cache TTL: /, "")}
+                            />
                             <R t={t()} l="Last response" v={s().lastResponseTime > 0 ? `${Math.round(elapsed() / 1000)}s ago` : "never"} />
                             <R t={t()} l="Remaining" v={s().cacheExpired ? "expired" : s().cacheNeverExpires ? "never (MC never assumes expiry — external cache-keep)" : `${Math.round(s().cacheRemainingMs / 1000)}s`} fg={s().cacheExpired ? t().warning : t().textMuted} />
                             <R t={t()} l="Auto-execute" v={s().cacheExpired ? "yes (expired)" : s().cacheNeverExpires ? `at ≥${formatThresholdPercent(s().executeThreshold)}%` : `at TTL or ≥${formatThresholdPercent(s().executeThreshold)}%`} fg={t().textMuted} />