@cortexkit/opencode-magic-context 0.41.2 → 0.41.4

package/src/shared/model-resolution.ts

@@ -1,4 +1,4 @@
-export type ModelHarness = "opencode" | "pi";
+export type ModelHarness = "opencode" | "pi" | "omp";
 
 export interface ResolvedModelEntry {
     /** Canonical provider/model reference used for identity and model selection. */
@@ -27,6 +27,14 @@ function hasOwn(record: ConfigRecord, key: string): boolean {
     return Object.hasOwn(record, key);
 }
 
+function resolveHarnessBlock(
+    container: ConfigRecord | undefined,
+    harness: ModelHarness,
+): ConfigRecord | undefined {
+    const selected = harness === "omp" ? (container?.omp ?? container?.pi) : container?.[harness];
+    return asRecord(selected);
+}
+
 /**
  * Collapses the string and object spellings of a harness model entry into the
  * same model identity. Qualifiers stay separate because they alter an attempt,
@@ -98,15 +106,15 @@ export interface ResolvedHistorianModel {
 }
 
 /**
- * Resolve historian model attempts from exactly one harness block. Flat keys
- * and the other harness are deliberately never consulted after cutover.
+ * Resolve historian model attempts from the selected harness block. OMP uses
+ * its own block when present and falls back to Pi when it is absent.
  */
 export function resolveHistorianModel(
     config: unknown,
     harness: ModelHarness,
 ): ResolvedHistorianModel {
     const historian = asRecord(asRecord(config)?.historian);
-    const block = asRecord(historian?.[harness]);
+    const block = resolveHarnessBlock(historian, harness);
     if (!block) return { fallbacks: [] };
 
     return {
@@ -139,7 +147,7 @@ export function resolveDreamerTaskModel(args: {
     muralModel?: unknown;
 }): ResolvedDreamerTaskModel {
     const dreamer = asRecord(asRecord(args.config)?.dreamer);
-    const harnessBlock = asRecord(dreamer?.[args.harness]);
+    const harnessBlock = resolveHarnessBlock(dreamer, args.harness);
     const taskBlock = asRecord(asRecord(harnessBlock?.tasks)?.[args.task]);
     const schedulingTask = asRecord(asRecord(dreamer?.tasks)?.[args.task]);
     if (!harnessBlock) {
@@ -211,6 +219,7 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
         thinking_level: _thinking,
         opencode,
         pi,
+        omp,
         tasks,
         ...rest
     } = source;

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/prompt-surface-runtime.ts

@@ -2,7 +2,6 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 
 import {
-    type ConfigHarness,
     cortexKitUserConfigBasePath,
     resolveLegacyConfigSourcesForHarness,
 } from "../config/migrate-config-location";
@@ -13,6 +12,7 @@ import {
     CTX_REDUCE_LIGHT_DESCRIPTION,
     CTX_SEARCH_LIGHT_DESCRIPTION,
 } from "../tools/light-descriptions";
+import type { HarnessId } from "./harness";
 import { piModelRefToCanonical } from "./harness-provider-map";
 import { detectConfigFile } from "./jsonc-parser";
 import {
@@ -88,7 +88,7 @@ export interface PromptSurfaceRuntime {
 }
 
 export interface CreatePromptSurfaceRuntimeOptions {
-    harness?: ConfigHarness;
+    harness?: HarnessId;
     directory?: string;
     /** Explicit test/integration seam; production derives the USER config directory. */
     userConfigDirectory?: string;
@@ -105,7 +105,7 @@ function resolveUserConfigDirectory(options: CreatePromptSurfaceRuntimeOptions):
     if (options.harness) {
         const legacy = resolveLegacyConfigSourcesForHarness(
             options.directory ?? process.cwd(),
-            options.harness,
+            options.harness === "omp" ? "pi" : options.harness,
         ).user.find((source) => existsSync(source.path));
         if (legacy) return dirname(legacy.path);
     }

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

@@ -62,6 +62,7 @@ import {
     byteSize,
     prependTag,
     stripTagPrefix,
+    stripWellFormedLeadingTagPrefix,
 } from "../hooks/magic-context/tag-content-primitives";
 import type { TagTarget } from "../hooks/magic-context/tag-messages";
 import type { Transcript, TranscriptPart } from "./transcript";
@@ -183,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 {
@@ -243,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)
@@ -344,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) {
@@ -462,6 +468,7 @@ export function tagTranscript(
                         toolName: null,
                         inputByteSize: reusableAccounting.inputByteSize,
                         inputTokenCount: reusableAccounting.inputTokenCount,
+                        requiresToolArcSkeleton: messageHasNativeReasoning,
                     };
                     if (part.kind === "tool_result") {
                         text = part.getText() ?? "";
@@ -526,6 +533,7 @@ export function tagTranscript(
                         inputTokenCount:
                             persistedAccounting?.inputTokenCount ??
                             (part.kind === "tool_use" ? firstInputTokenCount : null),
+                        requiresToolArcSkeleton: messageHasNativeReasoning,
                     };
                     if (part.kind === "tool_result") {
                         applyGrownToolResultAccounting({
@@ -677,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;
 }
 
@@ -814,6 +829,16 @@ interface TagTextPartArgs {
 function tagTextPart(args: TagTextPartArgs): void {
     const identityStart = args.timing ? performance.now() : 0;
     const text = args.part.getText() ?? "";
+    // Pi and OMP can expose provider framing as assistant text blocks. Treat a
+    // previously prefixed blank as blank too, so MC never turns inert framing
+    // into a tag-bearing part that later strip logic could mistake for content.
+    if (
+        args.message.info.role === "assistant" &&
+        stripWellFormedLeadingTagPrefix(text).trim().length === 0
+    ) {
+        if (args.timing) args.timing.identity += performance.now() - identityStart;
+        return;
+    }
     const contentId = args.contentId;
     const reusableTagId = args.reuseIdentity
         ? args.tagger.getTag(args.sessionId, contentId, "message")
@@ -999,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;
 
@@ -1079,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/shared/transcript.ts

@@ -1,3 +1,5 @@
+import type { HarnessId } from "./harness";
+
 /**
  * Harness-agnostic transcript interface.
  *
@@ -229,7 +231,7 @@ export interface Transcript {
      *   compaction marker injection).
      * - Test assertions confirming the right adapter ran.
      */
-    readonly harness: "opencode" | "pi";
+    readonly harness: HarnessId;
 
     /**
      * Commit accumulated mutations to the underlying source array.

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} />