@cortexkit/aft-opencode 0.57.1 → 0.58.0

package/src/entry/server-runtime.mjs

@@ -1,19 +1,21 @@
-import {
-  acquireBridge,
-  findBinary,
-  releaseBridge,
-  resolveCortexKitStorageRoot,
-} from "@cortexkit/aft-bridge";
+import { acquireBridge, releaseBridge } from "@cortexkit/aft-bridge";
 import { Effect } from "effect";
 
 import {
-  buildConfigTierConfigureParams,
-  loadAftConfig,
-  resolveBridgePoolTransportOptions,
-} from "../config.js";
-import { debug, log } from "../logger.js";
+  applyToolSurfaceOverrides,
+  createProjectAcceptance,
+  createSharedPoolOptions,
+  defaultBridgeBootstrapDependencies,
+  prepareBridgeEnvironment,
+  reportHashlineDowngrade,
+  resolveBootstrapConfig,
+  unknownDisabledToolsReporter,
+} from "../bridge-bootstrap.js";
+import { resolveBridgePoolTransportOptions } from "../config.js";
+import { buildConfigErrorToolMap } from "../config-error-surface.js";
+import { debug, log, warn } from "../logger.js";
 import { resolvePluginVersion } from "../plugin-version.js";
-import { registerAftRpc } from "../rpc/register.js";
+import { registerAftConfigErrorRpc, registerAftRpc } from "../rpc/register.js";
 import { hoistedV2ToolConsumers } from "../tools/hoisted/v2.js";
 import { createV2RuntimeConsumer } from "../wakes/runtime-consumer.js";
 import {
@@ -22,61 +24,134 @@ import {
   registerAftTools,
 } from "../tool-registration.js";
 
+// The bridge environment (binary, storage migration, configure overrides, ONNX
+// Runtime, LSP installs) comes from the bootstrap shared with the OpenCode 1
+// entry; every one of those steps can be replaced here through overrides.
 const defaults = {
-  buildConfigureParams: buildConfigTierConfigureParams,
+  ...defaultBridgeBootstrapDependencies,
   buildToolMap: buildAftToolDefinitions,
   registerTools: registerAftTools,
   registerRpc: registerAftRpc,
+  registerConfigErrorRpc: registerAftConfigErrorRpc,
   toolConsumers: (context) => ({
     ...hoistedV2ToolConsumers(context),
     ...createV2RuntimeConsumer(context),
   }),
   acquireBridge,
-  loadConfig: loadAftConfig,
   releaseBridge,
-  resolveBinary: findBinary,
   resolvePoolOptions: resolveBridgePoolTransportOptions,
-  resolveStorageRoot: resolveCortexKitStorageRoot,
   resolveVersion: () => resolvePluginVersion(import.meta.url),
 };
 
 async function bootLocation(context, location, dependencies) {
   const directory = location.directory;
-  const config = dependencies.loadConfig(directory);
-  if (config.enabled === false) return undefined;
+  // The V2 host has no session UI to deliver startup warnings into, so they
+  // go to the plugin log.
+  const notify = (message) => warn(message);
+  const bootstrap = await resolveBootstrapConfig(directory, notify, dependencies);
+  if (!bootstrap.ok) {
+    // The config error state: register the tool surface with every call
+    // failing, and acquire no bridge.
+    log(`AFT is in the config error state for ${directory}; every tool call will fail`);
+    return {
+      configError: bootstrap.message,
+      consumers: {},
+      pool: null,
+      tools: buildConfigErrorToolMap(
+        bootstrap.config,
+        bootstrap.message,
+        context,
+        dependencies.buildToolMap,
+      ),
+    };
+  }
+  const config = bootstrap.config;
 
-  const storageDir = dependencies.resolveStorageRoot();
-  const configOverrides = dependencies.buildConfigureParams(directory, {
-    bash_permissions: true,
-    harness: "opencode",
-    storage_dir: storageDir,
-  });
-  const binaryPath = await dependencies.resolveBinary(dependencies.resolveVersion());
+  const pluginVersion = dependencies.resolveVersion();
+  const environment = await prepareBridgeEnvironment(
+    { configRoot: directory, lspDirectory: directory, config, pluginVersion, notify },
+    dependencies,
+  );
   const canonicalDirectory = location.project?.canonical ?? directory;
   const consumers = dependencies.toolConsumers(context);
+  // Only a rejected configuration keeps AFT out of a project; there is no
+  // config switch that turns it off.
+  const isProjectEnabled = createProjectAcceptance(directory, dependencies);
+  // getPool is only called on a version mismatch, after the pool exists.
   const pool = await dependencies.acquireBridge(canonicalDirectory, {
     harness: "opencode",
-    binaryPath,
+    binaryPath: environment.binaryPath,
     poolOptions: {
       ...dependencies.resolvePoolOptions(config),
+      ...createSharedPoolOptions({
+        pluginVersion,
+        getPool: () => pool,
+        isProjectEnabled,
+        notifyForRoot: (_projectRoot, message) => notify(message),
+        dependencies,
+      }),
       ...consumers.bridgeOptions,
     },
-    configOverrides,
+    configOverrides: environment.configOverrides,
     subcConnectionFile: config.subc?.connection_file,
   });
+  environment.attach(pool);
   const toolContext = {
     pool,
     client: context,
     config,
     hashlineEffective: openCodeHashlineEffective(config),
-    storageDir,
-    isProjectEnabled: (projectRoot) =>
-      projectRoot === directory ? true : dependencies.loadConfig(projectRoot).enabled !== false,
+    storageDir: environment.storageDir,
+    isProjectEnabled,
   };
-  const tools = dependencies.buildToolMap(toolContext, config);
+  const tools = dependencies.buildToolMap(
+    toolContext,
+    config,
+    unknownDisabledToolsReporter(notify),
+  );
+  const registeredTools = new Set(Object.keys(tools));
+  const { hashlineEditRegistered } = applyToolSurfaceOverrides(pool, config, registeredTools);
+  reportHashlineDowngrade(config, registeredTools, notify);
+  toolContext.hashlineEffective = hashlineEditRegistered;
   return { consumers, pool, tools };
 }
 
+/**
+ * Locations whose runtime is running in this process, by directory, so the
+ * start line can say when the host starts a second Location for a directory
+ * that already has one.
+ */
+const runningByDirectory = new Map();
+let startsInProcess = 0;
+
+/**
+ * The start line names the entry, the Location and how many starts this
+ * process has seen. The V2 host calls the server effect once per Location and
+ * again when it reloads one, so two start lines on one host launch are two
+ * Locations or a reload; with the Location and the matching "stopped" line in
+ * the log, a reader can tell which instead of seeing the same line twice.
+ */
+function logRuntimeStart(location) {
+  startsInProcess += 1;
+  const directory = location.directory;
+  const running = runningByDirectory.get(directory) ?? 0;
+  runningByDirectory.set(directory, running + 1);
+  const id = typeof location.id === "string" ? location.id : "(no id)";
+  const overlap =
+    running > 0
+      ? `; ${running} other Location(s) for this directory still running`
+      : "";
+  log(
+    `AFT V2 runtime starting (server entry, Location ${id} at ${directory}; start ${startsInProcess} in this process${overlap})`,
+  );
+  return () => {
+    const left = (runningByDirectory.get(directory) ?? 1) - 1;
+    if (left > 0) runningByDirectory.set(directory, left);
+    else runningByDirectory.delete(directory);
+    log(`AFT V2 runtime stopped (server entry, Location ${id} at ${directory})`);
+  };
+}
+
 export function makeServerEffect(overrides = {}) {
   const dependencies = { ...defaults, ...overrides };
 
@@ -93,12 +168,21 @@ export function makeServerEffect(overrides = {}) {
       return Effect.void;
     }
 
-    log("AFT V2 runtime starting");
-
     return Effect.gen(function* () {
+      // Logged when the program runs, so every start pairs with the stop its
+      // finalizer logs when the host disposes the Location.
+      const logRuntimeStop = logRuntimeStart(location);
+      yield* Effect.addFinalizer(() => Effect.sync(logRuntimeStop));
       const runtime = yield* Effect.promise(() => bootLocation(context, location, dependencies));
       if (!runtime) return;
 
+      if (runtime.configError !== undefined) {
+        const rpc = yield* dependencies.registerConfigErrorRpc(context, runtime.configError);
+        yield* Effect.addFinalizer(() => Effect.promise(() => rpc.dispose()));
+        yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
+        return;
+      }
+
       yield* Effect.addFinalizer(() =>
         Effect.promise(async () => {
           runtime.consumers.dispose?.();

package/src/logger.ts

@@ -1,12 +1,11 @@
-import { RotatingLogSink, resolveAftLogPath } from "@cortexkit/aft-bridge";
+import { RotatingLogSink, resolvePluginLogPath } from "@cortexkit/aft-bridge";
 
 const TAG = "[aft-plugin]";
 
-// Route test runs to a separate log file so `bun test` never pollutes the
-// live session log that users read to diagnose problems. Bun sets BUN_TEST=1
-// automatically; NODE_ENV=test covers other test harnesses.
-const isTestEnv = process.env.BUN_TEST === "1" || process.env.NODE_ENV === "test";
-const logFile = resolveAftLogPath(isTestEnv ? "aft-plugin-test.log" : "aft-plugin.log");
+// Test runs log to aft-plugin-test.log under the system temp directory, so
+// `bun test` never writes into the live log directory users read to diagnose
+// problems.
+const logFile = resolvePluginLogPath();
 const fileSink = new RotatingLogSink(logFile);
 
 /**
@@ -110,6 +109,19 @@ export function getLogFilePath(): string {
   return logFile;
 }
 
+/**
+ * Write buffered log lines now instead of on the next flush tick. For lines
+ * logged while the host may be about to exit, which would drop anything still
+ * buffered.
+ */
+export function flushLog(): void {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flush();
+}
+
 /**
  * Adapter that exposes this logger as a {@link import("@cortexkit/aft-bridge").Logger}
  * for the shared bridge package. The bridge package never knows about this log

package/src/shared/status.ts

@@ -12,6 +12,31 @@ import {
  */
 export { formatSemanticIndexStatus, type SemanticIndexStatusKind, semanticIndexStatusKind };
 
+/**
+ * What the sidebar and status dialog show before AFT has started for this
+ * project. AFT starts on the first tool call, so until then there is nothing
+ * to report beyond that fact.
+ */
+export const NOT_STARTED_STATUS_TEXT = "Starts on the first tool call.";
+
+/**
+ * The status label for a snapshot's semantic index, including the backend URL
+ * and reason when the embedding backend is unavailable. Every surface that
+ * shows the semantic status goes through this so none of them can drop the
+ * reason and fall back to a bare word.
+ */
+export function formatSemanticIndexLabel(
+  semantic: Pick<
+    AftStatusSnapshot["semantic_index"],
+    "status" | "stage" | "error" | "reason" | "backend_url"
+  >,
+): string {
+  return formatSemanticIndexStatus(semantic.status, semantic.stage, semantic.error, {
+    reason: semantic.reason,
+    backendUrl: semantic.backend_url,
+  });
+}
+
 export interface StatusCompressionAggregate {
   events: number;
   original_tokens: number;
@@ -37,6 +62,12 @@ export interface StatusBar {
   duplicates?: number;
   todos?: number;
   tier2_stale?: boolean;
+  /**
+   * `"no_language_server"` when no language server is running, so errors and
+   * warnings will not arrive until one starts. Absent while the counts are
+   * present or a running server has not reported yet.
+   */
+  diagnostics?: "no_language_server";
 }
 
 export interface AftStatusSnapshot {
@@ -80,6 +111,10 @@ export interface AftStatusSnapshot {
     entries: number | null;
     dimension: number | null;
     error?: string | null;
+    /** Engine's reason when `status === "backend_unavailable"`. */
+    reason?: string | null;
+    /** Configured remote embedding backend URL, when there is one. */
+    backend_url?: string | null;
   };
   disk: {
     storage_dir: string | null;
@@ -109,6 +144,14 @@ export interface AftStatusSnapshot {
   compression?: StatusCompression;
   /** Human health counts. Each unproven category stays absent rather than zero. */
   status_bar?: StatusBar;
+  /**
+   * Per-category health values from the same snapshot. The bridge sends
+   * `status_bar` only once every category has a value; this field carries the
+   * categories that do, so a renderer can show them while one producer (for
+   * example dead-code without a callgraph) is unavailable. Absent when the
+   * bridge predates the field or no category has a value yet.
+   */
+  status_bar_values?: StatusBar;
   /**
    * Human-readable explanation for a synthetic snapshot (e.g.
    * `cache_role === "not_initialized"`). When the plugin returns a placeholder
@@ -117,6 +160,12 @@ export interface AftStatusSnapshot {
    * Empty string when the snapshot is real bridge data.
    */
   message: string;
+  /**
+   * Present only when the plugin is in the config error state: its
+   * configuration could not be used, so no bridge runs and every tool call
+   * fails with this text. `message` then carries its one-line form.
+   */
+  config_error?: string;
 }
 
 function asRecord(value: unknown): Record<string, unknown> {
@@ -171,13 +220,15 @@ function readStatusBar(value: unknown): StatusBar | undefined {
   const unusedExports = readOptionalNumber(bar.unused_exports);
   const duplicates = readOptionalNumber(bar.duplicates);
   const todos = readOptionalNumber(bar.todos);
+  const noLanguageServer = bar.diagnostics === "no_language_server";
   if (
     errors === null &&
     warnings === null &&
     deadCode === null &&
     unusedExports === null &&
     duplicates === null &&
-    todos === null
+    todos === null &&
+    !noLanguageServer
   ) {
     return undefined;
   }
@@ -189,6 +240,7 @@ function readStatusBar(value: unknown): StatusBar | undefined {
     ...(duplicates !== null ? { duplicates } : {}),
     ...(todos !== null ? { todos } : {}),
     ...(bar.tier2_stale === true ? { tier2_stale: true } : {}),
+    ...(noLanguageServer ? { diagnostics: "no_language_server" as const } : {}),
   };
 }
 
@@ -289,6 +341,8 @@ export function coerceAftStatus(response: Record<string, unknown>): AftStatusSna
       entries: readOptionalNumber(semanticIndex.entries),
       dimension: readOptionalNumber(semanticIndex.dimension),
       error: readNullableString(semanticIndex.error),
+      reason: readNullableString(semanticIndex.reason),
+      backend_url: readNullableString(semanticIndex.backend_url),
     },
     disk: {
       storage_dir: readNullableString(disk.storage_dir),
@@ -314,7 +368,11 @@ export function coerceAftStatus(response: Record<string, unknown>): AftStatusSna
     },
     compression: readCompression(response.compression),
     status_bar: readStatusBar(response.status_bar),
+    status_bar_values: readStatusBar(response.status_bar_values),
     message: readString(response.message, ""),
+    ...(typeof response.config_error === "string" && response.config_error.length > 0
+      ? { config_error: response.config_error }
+      : {}),
   };
 }
 
@@ -347,7 +405,7 @@ export function formatStatusDialogMessage(status: AftStatusSnapshot): string {
     `- trigrams: ${formatCount(status.search_index.trigrams)}`,
     "",
     "Semantic index",
-    `- status: ${formatSemanticIndexStatus(status.semantic_index.status, status.semantic_index.stage, status.semantic_index.error)}`,
+    `- status: ${formatSemanticIndexLabel(status.semantic_index)}`,
   );
   const refreshing = formatSemanticRefreshing(status.semantic_index.refreshing_count);
   if (refreshing) {
@@ -422,9 +480,39 @@ export function formatStatusDialogMessage(status: AftStatusSnapshot): string {
   return lines.join("\n");
 }
 
+/**
+ * Opening words of the reason the engine reports when it has turned git off
+ * because Apple's developer tools are missing (MISSING_DEVELOPER_TOOLS_REASON
+ * in crates/aft/src/developer_tools.rs).
+ */
+const GIT_OFF_REASON_PREFIX = "git features are off";
+
+/**
+ * How a surface should head the degraded state. A Mac without developer tools
+ * is the normal state of a fresh machine and everything except git-backed
+ * features works, so that case gets a calm warning mark naming what is off
+ * instead of a capitalised DEGRADED next to the product name, which read as
+ * broken. Any other reason (home directory as project root, too many files)
+ * switches off heavy features and keeps the stronger wording.
+ */
+export function degradedHeaderMarker(reasons: readonly string[]): {
+  /** Short header text: "⚠ git features off" or "DEGRADED". */
+  text: string;
+  /** Section heading for the status dialog. */
+  heading: string;
+  /** True for the git-only case, drawn as plain warning text rather than a badge. */
+  calm: boolean;
+} {
+  if (reasons.length > 0 && reasons.every((reason) => reason.startsWith(GIT_OFF_REASON_PREFIX))) {
+    return { text: "⚠ git features off", heading: "Git features off", calm: true };
+  }
+  return { text: "DEGRADED", heading: "Degraded mode", calm: false };
+}
+
 function appendDegradedStatus(lines: string[], status: AftStatusSnapshot, markdown: boolean): void {
   if (!status.degraded || status.degraded_reasons.length === 0) return;
-  lines.push("", markdown ? "### Degraded mode" : "Degraded mode");
+  const { heading } = degradedHeaderMarker(status.degraded_reasons);
+  lines.push("", markdown ? `### ${heading}` : heading);
   for (const reason of status.degraded_reasons) {
     const detail =
       reason === "home_root"
@@ -458,7 +546,7 @@ export function formatStatusMarkdown(status: AftStatusSnapshot): string {
     `- **Trigrams:** ${formatCount(status.search_index.trigrams)}`,
     "",
     "### Semantic index",
-    `- **Status:** \`${formatSemanticIndexStatus(status.semantic_index.status, status.semantic_index.stage, status.semantic_index.error)}\``,
+    `- **Status:** \`${formatSemanticIndexLabel(status.semantic_index)}\``,
   );
   const refreshing = formatSemanticRefreshing(status.semantic_index.refreshing_count);
   if (refreshing) {

package/src/shared/subagent-detect.ts

@@ -15,7 +15,8 @@
  *   2. Disable auto-promotion: the foreground poll window extends to the
  *      task's full hard-kill timeout instead of the default 5s.
  *
- * Detection is via the OpenCode SDK `client.session.get`. The result is
+ * Detection is via the OpenCode SDK `client.session.get` on OpenCode 1 and
+ * via the plugin context's `session.get` Effect on OpenCode 2. The result is
  * cached per sessionID for the lifetime of the plugin process — subagent
  * identity is sticky (parentID never changes after session creation), so
  * the cache never needs invalidation.
@@ -27,6 +28,8 @@
  *
  * Mirrors the pattern in `session-directory.ts`.
  */
+import { Effect } from "effect";
+
 import { sessionLog, sessionWarn } from "../logger.js";
 
 interface SessionInfo {
@@ -79,6 +82,8 @@ export async function resolveIsSubagent(
     return cached.isSubagent;
   }
 
+  if (isV2PluginContext(client)) return resolveV2(client, sessionId);
+
   const c = client as OpenCodeClientShape;
   const sessionApi = c?.session;
   if (!sessionApi || typeof sessionApi.get !== "function") {
@@ -135,6 +140,56 @@ export async function resolveIsSubagent(
   return isSubagent;
 }
 
+/**
+ * The OpenCode 2 runtime passes its plugin context where the V1 plugin passes
+ * the SDK client (see `entry/server-runtime.mjs`). That context has no SDK
+ * client at all; its `session.get` takes `{ sessionID }` and returns an Effect
+ * that resolves to the bare session record. Calling it the V1 way builds an
+ * Effect that never runs, and awaiting that Effect yields the Effect itself, so
+ * no `parentID` is ever read and every OpenCode 2 session would be cached as
+ * primary. The context is recognised by its `location`, the same capability
+ * the runtime checks before booting.
+ */
+interface V2PluginContextShape {
+  location: { directory: string };
+  session: {
+    get(input: { sessionID: string }): Effect.Effect<SessionInfo | undefined, unknown>;
+  };
+}
+
+function isV2PluginContext(client: unknown): client is V2PluginContextShape {
+  if (!client || typeof client !== "object") return false;
+  const candidate = client as { location?: { directory?: unknown }; session?: { get?: unknown } };
+  return (
+    typeof candidate.location?.directory === "string" &&
+    typeof candidate.session?.get === "function"
+  );
+}
+
+async function resolveV2(context: V2PluginContextShape, sessionId: string): Promise<boolean> {
+  let session: SessionInfo | undefined;
+  try {
+    session = await Effect.runPromise(
+      context.session.get({ sessionID: sessionId }) as Effect.Effect<SessionInfo | undefined>,
+    );
+  } catch (err) {
+    // Same policy as the V1 path: a failed lookup is not cached, and the call
+    // is treated as primary for now so the next tool call can retry.
+    sessionWarn(
+      sessionId,
+      `[subagent-detect] OpenCode 2 session lookup failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return false;
+  }
+  const isSubagent = typeof session?.parentID === "string" && session.parentID.length > 0;
+  sessionLog(
+    sessionId,
+    `[subagent-detect] OpenCode 2 session parentID=${JSON.stringify(session?.parentID)} → isSubagent=${isSubagent}`,
+  );
+  setCache(sessionId, isSubagent);
+  return isSubagent;
+}
+
 function setCache(sessionId: string, isSubagent: boolean): void {
   if (cache.has(sessionId)) cache.delete(sessionId);
   cache.set(sessionId, { isSubagent, recordedAt: Date.now() });

package/src/tui/index.tsx

@@ -11,8 +11,9 @@ import {
   coerceAftStatus,
   formatBytes,
   formatCacheRoleLabel,
-  formatSemanticIndexStatus,
+  formatSemanticIndexLabel,
   formatSemanticRefreshing,
+  NOT_STARTED_STATUS_TEXT,
 } from "../shared/status";
 import {
   createDebouncedStatusRefresh,
@@ -265,10 +266,7 @@ const StatusDialog = (props: StatusDialogProps) => {
           instead of an empty grid of zeros and "unknown" rows. */}
       {status()?.cache_role === "not_initialized" ? (
         <box width="100%" marginTop={1} justifyContent="center">
-          <text fg={t().textMuted}>
-            {status()!.message ||
-              "AFT bridge is now spawned lazily, information here will be populated after first tool call."}
-          </text>
+          <text fg={t().textMuted}>{status()!.message || NOT_STARTED_STATUS_TEXT}</text>
         </box>
       ) : null}
 
@@ -380,11 +378,7 @@ const StatusDialog = (props: StatusDialogProps) => {
             <R
               theme={t()}
               label="Status"
-              value={formatSemanticIndexStatus(
-                status()!.semantic_index.status,
-                status()!.semantic_index.stage,
-                status()!.semantic_index.error,
-              )}
+              value={formatSemanticIndexLabel(status()!.semantic_index)}
               tone={statusTone(status()!.semantic_index.status)}
             />
             {formatSemanticRefreshing(status()!.semantic_index.refreshing_count) ? (

package/src/tui/sidebar-view.tsx

@@ -14,8 +14,10 @@
 import { createMemo, createSignal, onCleanup } from "solid-js";
 import {
   type AftStatusSnapshot,
-  formatSemanticIndexStatus,
+  degradedHeaderMarker,
+  formatSemanticIndexLabel,
   formatSemanticRefreshing,
+  NOT_STARTED_STATUS_TEXT,
   type StatusBar,
   type StatusCompression,
   semanticIndexStatusKind,
@@ -215,10 +217,16 @@ const StatRow = (props: {
     }
   });
 
+  // The label never shrinks and the value wraps in the space left beside it:
+  // left to flexbox, a long value (a semantic index that is unavailable, with
+  // its reason) squeezed the label and drew over it, so "Status" came out as
+  // "Statu" followed by the value.
   return (
     <box width="100%" flexDirection="row" justifyContent="space-between">
-      <text fg={props.palette.textMuted}>{props.label}</text>
-      <text fg={fg()}>
+      <text fg={props.palette.textMuted} flexShrink={0}>
+        {props.label}
+      </text>
+      <text fg={fg()} flexShrink={1} marginLeft={1} wrapMode="word">
         <b>{props.value}</b>
       </text>
     </box>
@@ -397,12 +405,15 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
     return {
       ...display,
       // The error is passed through so a capability failure (a missing ONNX
-      // Runtime) is named here instead of arriving as a bare status word.
-      label: formatSemanticIndexStatus(
-        rawStatus,
-        s()?.semantic_index?.stage,
-        s()?.semantic_index?.error,
-      ),
+      // Runtime) is named here instead of arriving as a bare status word, and
+      // an unreachable backend carries its URL and reason.
+      label: formatSemanticIndexLabel({
+        status: rawStatus,
+        stage: s()?.semantic_index?.stage,
+        error: s()?.semantic_index?.error,
+        reason: s()?.semantic_index?.reason,
+        backend_url: s()?.semantic_index?.backend_url,
+      }),
     };
   };
   const semanticRefreshing = () =>
@@ -459,7 +470,14 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
               </b>
             </text>
           </box>
-          {s()?.degraded && (
+          {s()?.degraded && degradedHeaderMarker(s()?.degraded_reasons ?? []).calm && (
+            <box marginLeft={1}>
+              <text fg={props.palette.warning}>
+                {degradedHeaderMarker(s()?.degraded_reasons ?? []).text}
+              </text>
+            </box>
+          )}
+          {s()?.degraded && !degradedHeaderMarker(s()?.degraded_reasons ?? []).calm && (
             <box
               paddingLeft={1}
               paddingRight={1}
@@ -467,7 +485,7 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
               backgroundColor={props.palette.warning}
             >
               <text fg={badgeForeground(props.palette.warning, props.palette.background)}>
-                <b>DEGRADED</b>
+                <b>{degradedHeaderMarker(s()?.degraded_reasons ?? []).text}</b>
               </text>
             </box>
           )}
@@ -501,10 +519,13 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
           rows so users understand why metrics are blank. */}
       {notInitialized() && (
         <box marginTop={1} width="100%">
-          <text fg={props.palette.textMuted}>
-            {s()!.message ||
-              "AFT bridge is now spawned lazily, information here will be populated after first tool call."}
-          </text>
+          {s()!.config_error ? (
+            // Config error state: no bridge will ever start in this process,
+            // so the placeholder text would mislead; show the error instead.
+            <text fg={props.palette.error}>✖ {s()!.message}</text>
+          ) : (
+            <text fg={props.palette.textMuted}>{s()!.message || NOT_STARTED_STATUS_TEXT}</text>
+          )}
         </box>
       )}