@cortexkit/aft-opencode 0.57.2 → 0.58.1

package/src/entry/server-runtime.mjs

@@ -1,19 +1,22 @@
-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 { startOpenCodeLiveConfigReload } from "../config-live-reload.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,59 +25,145 @@ 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,
+  startLiveConfigReload: startOpenCodeLiveConfigReload,
   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,
+    unknownDisabledToolsReporter(notify),
+  );
+  const registeredTools = new Set(Object.keys(tools));
+  const { hashlineEditRegistered } = applyToolSurfaceOverrides(pool, config, registeredTools);
+  reportHashlineDowngrade(config, registeredTools, notify);
+  toolContext.hashlineEffective = hashlineEditRegistered;
+  // Keep this Location's live config keys current when a config file changes.
+  // The finalizer that releases the bridge also stops the watch.
+  const liveConfigReload = dependencies.startLiveConfigReload({
+    directory,
+    initialSources: bootstrap.sources ?? [],
+    initialSourceTexts: bootstrap.sourceTexts,
+    getConfig: () => toolContext.config,
+    setConfig: (next) => {
+      toolContext.config = next;
+    },
+    notify,
+  });
+  return { consumers, pool, tools, liveConfigReload };
+}
+
+/**
+ * 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})`);
   };
-  const tools = dependencies.buildToolMap(toolContext, config);
-  return { consumers, pool, tools };
 }
 
 export function makeServerEffect(overrides = {}) {
@@ -93,14 +182,24 @@ 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.liveConfigReload?.stop();
           runtime.consumers.dispose?.();
           await dependencies.releaseBridge(runtime.pool);
         }),

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);
 
 /**

package/src/shared/read-vision.ts

@@ -0,0 +1,100 @@
+import { resolvePromptContext } from "./last-assistant-model.js";
+
+export const VISION_HOST_TIMEOUT_MS = 1500;
+type Model = { providerID: string; modelID: string };
+type State = {
+  models: Map<string, Model>;
+  history: Map<string, Promise<Model | undefined>>;
+  capabilities: Map<string, Promise<boolean | undefined>>;
+};
+const states = new WeakMap<object, State>();
+function stateFor(client: object): State {
+  let state = states.get(client);
+  if (!state) {
+    state = { models: new Map(), history: new Map(), capabilities: new Map() };
+    states.set(client, state);
+  }
+  return state;
+}
+
+/** Host hooks are authoritative; history is only a fallback before the first hook. */
+export function rememberReadModel(client: object, sessionID: string, model: Model): void {
+  stateFor(client).models.set(sessionID, model);
+}
+
+async function bounded<T>(call: () => Promise<T>): Promise<T | undefined> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(call),
+      new Promise<undefined>((resolve) => {
+        timer = setTimeout(() => resolve(undefined), VISION_HOST_TIMEOUT_MS);
+      }),
+    ]);
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export async function currentSessionVisionCapability(
+  client: object,
+  sessionID: string | undefined,
+): Promise<boolean | undefined> {
+  if (!sessionID) return undefined;
+  const state = stateFor(client);
+  let model = state.models.get(sessionID);
+  if (!model) {
+    let pending = state.history.get(sessionID);
+    if (!pending) {
+      pending = bounded(() => resolvePromptContext(client, sessionID)).then(
+        (context) => context?.model,
+      );
+      state.history.set(sessionID, pending);
+      void pending.finally(() => state.history.delete(sessionID));
+    }
+    const historical = await pending;
+    // A hook may have supplied a newer model while history was in flight.
+    model = state.models.get(sessionID) ?? historical;
+  }
+  if (!model) return undefined;
+  const currentModel = model;
+  const key = JSON.stringify([model.providerID, model.modelID]);
+  let capability = state.capabilities.get(key);
+  if (!capability) {
+    capability = (async () => {
+      const api = (client as { provider?: { list?: () => Promise<unknown> } }).provider;
+      if (!api?.list) return undefined;
+      const list = api.list.bind(api);
+      const listed = record(await bounded(list));
+      const catalog = record(listed?.data) ?? listed;
+      const providers = catalog?.all ?? catalog?.providers;
+      if (!Array.isArray(providers)) return undefined;
+      const provider = providers.map(record).find((entry) => entry?.id === currentModel.providerID);
+      const models = provider?.models;
+      const entry = record(
+        Array.isArray(models)
+          ? models.find((entry) => record(entry)?.id === currentModel.modelID)
+          : record(models)?.[currentModel.modelID],
+      );
+      const inputs = record(entry?.modalities)?.input;
+      return Array.isArray(inputs)
+        ? inputs.includes("image")
+        : typeof entry?.attachment === "boolean"
+          ? entry.attachment
+          : undefined;
+    })();
+    state.capabilities.set(key, capability);
+    // Do not retain transient failures or unknown catalog entries indefinitely.
+    void capability.then((value) => {
+      if (value === undefined) state.capabilities.delete(key);
+    });
+  }
+  return capability;
+}

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;
@@ -125,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> {
@@ -179,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;
   }
@@ -197,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 } : {}),
   };
 }
 
@@ -297,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),
@@ -324,6 +370,9 @@ export function coerceAftStatus(response: Record<string, unknown>): AftStatusSna
     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 }
+      : {}),
   };
 }
 
@@ -356,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) {
@@ -431,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"
@@ -467,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) ? (