@cortexkit/aft-opencode 0.58.1 → 0.59.0

package/src/shared/session-directory.ts

@@ -19,12 +19,64 @@
  * `packages/opencode/src/session/registry.ts`. Until then this
  * workaround makes AFT robust against the wrong cwd.
  */
+import { Effect } from "effect";
+
 import { sessionWarn } from "../logger.js";
 
 interface SessionInfo {
   directory?: string;
 }
 
+/**
+ * OpenCode 2 passes its plugin context where OpenCode 1 passes the SDK client
+ * (`entry/server-runtime.mjs` hands the context over as `client`). That context
+ * has a different session API, verified against the `v2` branch of the OpenCode repository:
+ *
+ * - `session.get` takes `{ sessionID }` and returns an Effect of `Session.Info`
+ *   (packages/client/src/effect/api/api.ts `SessionGetOperation`,
+ *   packages/plugin/src/effect/plugin.ts `Context`). Calling it the OpenCode 1
+ *   way builds an Effect that never runs, and awaiting an Effect yields the
+ *   Effect itself, so no directory was ever read.
+ * - `Session.Info` has no `directory`; the session's working directory is
+ *   `location.directory`, a required `Location.Ref`
+ *   (packages/schema/src/session.ts `Info`, packages/schema/src/location.ts
+ *   `Ref`). For a session created in a linked git worktree it is that worktree.
+ *
+ * It is told apart from an OpenCode 1 SDK client by having a string
+ * `location.directory` next to a `session.get` function; the OpenCode 2 entry
+ * refuses to boot without that `location`, and `subagent-detect.ts` uses the
+ * same test for its own session lookup.
+ */
+interface V2SessionInfo {
+  location?: { directory?: unknown };
+}
+
+interface V2PluginContextShape {
+  location: { directory: string };
+  session: {
+    get(input: { sessionID: string }): Effect.Effect<V2SessionInfo | 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"
+  );
+}
+
+/**
+ * How long a session lookup may run on either host version. Tool routing
+ * awaits this lookup, so an unresponsive host must not hold the call forever.
+ * After this budget the call proceeds with its own directory instead.
+ */
+export const LOOKUP_TIMEOUT_MS = 1_000;
+export const V2_SESSION_LOOKUP_TIMEOUT_MS = LOOKUP_TIMEOUT_MS;
+/** A failed lookup is provisional; retry later without querying on every call. */
+export const FAILED_LOOKUP_RETRY_MS = 30_000;
+
 interface OpenCodeClientShape {
   session?: {
     get?: (input: {
@@ -36,14 +88,15 @@ interface OpenCodeClientShape {
 }
 
 interface CacheEntry {
-  /** Resolved directory, or `null` if lookup failed and we should not retry. */
+  /** Resolved directory, or `null` while a failed lookup is cooling down. */
   directory: string | null;
-  /** Wall-clock timestamp of the cache entry, used only for LRU eviction. */
+  /** When the answer was recorded; failed lookups become retryable after 30 seconds. */
   recordedAt: number;
 }
 
 const CACHE_MAX_ENTRIES = 200;
 const cache = new Map<string, CacheEntry>();
+const inflight = new Map<string, Promise<string | null>>();
 
 /**
  * Resolve the project directory the session was created with from the SDK's
@@ -64,17 +117,63 @@ export async function getSessionDirectory(
   if (!sessionId) return null;
 
   const cached = cache.get(sessionId);
-  if (cached) {
+  if (
+    cached &&
+    (cached.directory !== null || Date.now() - cached.recordedAt < FAILED_LOOKUP_RETRY_MS)
+  ) {
     // Refresh LRU position
     cache.delete(sessionId);
     cache.set(sessionId, cached);
     return cached.directory;
   }
 
+  const pending = inflight.get(sessionId);
+  if (pending) return pending;
+  const lookup = boundedLookup(client, sessionId, fallbackDirectory).finally(() => {
+    inflight.delete(sessionId);
+  });
+  inflight.set(sessionId, lookup);
+  return lookup;
+}
+
+/** Ignore late answers: a timed-out lookup must not overwrite a later retry. */
+async function boundedLookup(
+  client: unknown,
+  sessionId: string,
+  fallbackDirectory: string,
+): Promise<string | null> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const timeout = new Promise<null>((resolve) => {
+      timer = setTimeout(() => {
+        sessionWarn(
+          sessionId,
+          `[aft-plugin] session lookup did not answer within ${LOOKUP_TIMEOUT_MS}ms; using the call's directory for now`,
+        );
+        resolve(null);
+      }, LOOKUP_TIMEOUT_MS);
+    });
+    const directory = await Promise.race([
+      lookupSessionDirectory(client, sessionId, fallbackDirectory),
+      timeout,
+    ]);
+    setCache(sessionId, directory);
+    return directory;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function lookupSessionDirectory(
+  client: unknown,
+  sessionId: string,
+  fallbackDirectory: string,
+): Promise<string | null> {
+  if (isV2PluginContext(client)) return lookupV2SessionDirectory(client, sessionId);
+
   const c = client as OpenCodeClientShape;
   const sessionApi = c?.session;
   if (!sessionApi || typeof sessionApi.get !== "function") {
-    setCache(sessionId, null);
     return null;
   }
 
@@ -96,7 +195,7 @@ export async function getSessionDirectory(
       dir = session.directory;
     }
   } catch (err) {
-    // Don't poison the cache on transient errors — but do log once.
+    // The bounded caller caches failures briefly so a struggling host is not polled per call.
     sessionWarn(
       sessionId,
       `[aft-plugin] session.get lookup failed: ${err instanceof Error ? err.message : String(err)}`,
@@ -104,7 +203,43 @@ export async function getSessionDirectory(
     return null;
   }
 
-  setCache(sessionId, dir);
+  return dir;
+}
+
+/**
+ * OpenCode 2 lookup: run the context's `session.get` Effect under a timeout and
+ * read `location.directory`.
+ *
+ * The outer bounded lookup applies the same retry policy as OpenCode 1.
+ * The Effect timeout also interrupts the abandoned V2 lookup; fallback remains
+ * the tool call's runtime.directory (the host's Location directory), never
+ * the main checkout.
+ */
+async function lookupV2SessionDirectory(
+  context: V2PluginContextShape,
+  sessionId: string,
+): Promise<string | null> {
+  let dir: string | null = null;
+  let failure: string | undefined;
+  try {
+    const session = await Effect.runPromise(
+      Effect.timeout(
+        context.session.get({ sessionID: sessionId }) as Effect.Effect<V2SessionInfo | undefined>,
+        V2_SESSION_LOOKUP_TIMEOUT_MS,
+      ),
+    );
+    const directory = session?.location?.directory;
+    if (typeof directory === "string" && directory.length > 0) dir = directory;
+    else failure = "the session record has no location.directory";
+  } catch (err) {
+    failure = err instanceof Error ? err.message || err.name : String(err);
+  }
+  if (failure !== undefined) {
+    sessionWarn(
+      sessionId,
+      `[aft-plugin] OpenCode 2 session lookup failed (${failure}); tool paths and bash use the Location directory ${context.location.directory} for this session`,
+    );
+  }
   return dir;
 }
 
@@ -134,6 +269,10 @@ export function getSessionDirectoryCached(
   if (!sessionId) return undefined;
   const cached = cache.get(sessionId);
   if (!cached) return undefined;
+  if (cached.directory === null && Date.now() - cached.recordedAt >= FAILED_LOOKUP_RETRY_MS) {
+    cache.delete(sessionId);
+    return undefined;
+  }
   return cached.directory;
 }
 
@@ -148,7 +287,7 @@ export function warmSessionDirectory(
   fallbackDirectory: string,
 ): void {
   if (!sessionId) return;
-  if (cache.has(sessionId)) return;
+  if (getSessionDirectoryCached(sessionId) !== undefined) return;
   void getSessionDirectory(client, sessionId, fallbackDirectory);
 }
 
@@ -210,5 +349,6 @@ export async function verifySessionDirectory(
 /** Test-only: clear the cache between unit tests. */
 export function _resetSessionDirectoryCacheForTest(): void {
   cache.clear();
+  inflight.clear();
   verifyCache.clear();
 }

package/src/shared/status.ts

@@ -55,6 +55,7 @@ export interface StatusCompression {
  * absence as a clean zero.
  */
 export interface StatusBar {
+  disabled_categories?: string[];
   errors?: number;
   warnings?: number;
   dead_code?: number;
@@ -214,6 +215,9 @@ function readCompression(value: unknown): StatusCompression | undefined {
 function readStatusBar(value: unknown): StatusBar | undefined {
   if (typeof value !== "object" || value === null) return undefined;
   const bar = asRecord(value);
+  const disabled = Array.isArray(bar.disabled_categories)
+    ? bar.disabled_categories.filter((key): key is string => typeof key === "string")
+    : [];
   const errors = readOptionalNumber(bar.errors);
   const warnings = readOptionalNumber(bar.warnings);
   const deadCode = readOptionalNumber(bar.dead_code);
@@ -228,11 +232,13 @@ function readStatusBar(value: unknown): StatusBar | undefined {
     unusedExports === null &&
     duplicates === null &&
     todos === null &&
-    !noLanguageServer
+    !noLanguageServer &&
+    disabled.length === 0
   ) {
     return undefined;
   }
   return {
+    ...(disabled.length > 0 ? { disabled_categories: disabled } : {}),
     ...(errors !== null ? { errors } : {}),
     ...(warnings !== null ? { warnings } : {}),
     ...(deadCode !== null ? { dead_code: deadCode } : {}),
@@ -437,8 +443,10 @@ export function formatStatusDialogMessage(status: AftStatusSnapshot): string {
     lines.push(`- storage dir: ${status.storage_dir ?? status.disk.storage_dir}`);
   }
 
-  if (status.status_bar) {
-    const sb = status.status_bar;
+  const sb = status.status_bar ?? status.status_bar_values;
+  if (sb) {
+    for (const key of sb.disabled_categories ?? [])
+      lines.push(`- ${key.replaceAll("_", " ")}: ○ off`);
     const rows = [
       ["errors", sb.errors],
       ["warnings", sb.warnings],
@@ -594,8 +602,10 @@ export function formatStatusMarkdown(status: AftStatusSnapshot): string {
     lines.push(`- **Storage dir:** \`${status.storage_dir ?? status.disk.storage_dir}\``);
   }
 
-  if (status.status_bar) {
-    const sb = status.status_bar;
+  const sb = status.status_bar ?? status.status_bar_values;
+  if (sb) {
+    for (const key of sb.disabled_categories ?? [])
+      lines.push(`- **${key.replaceAll("_", " ")}:** ○ off`);
     const rows = [
       ["Errors", sb.errors],
       ["Warnings", sb.warnings],

package/src/shared/subagent-detect.ts

@@ -21,10 +21,14 @@
  * identity is sticky (parentID never changes after session creation), so
  * the cache never needs invalidation.
  *
- * Errors are not cached. If the SDK is briefly unavailable on the first
- * call, we retry on the next bash invocation rather than permanently
- * misclassifying. This is cheap because the cache is hit on every
- * subsequent call within the same session.
+ * Every bridge call asks for the role (AFT words its replies by it), so the
+ * lookup must stay cheap and bounded:
+ * - concurrent first calls for one session share a single lookup;
+ * - a lookup that has not answered within LOOKUP_TIMEOUT_MS is abandoned and
+ *   that call proceeds as primary, so a slow host can't delay a read;
+ * - a failed or abandoned lookup is cached as "primary" for
+ *   FAILED_LOOKUP_RETRY_MS, then retried, so a struggling host is not asked on
+ *   every call but the real answer is still picked up later.
  *
  * Mirrors the pattern in `session-directory.ts`.
  */
@@ -48,20 +52,33 @@ interface OpenCodeClientShape {
 
 interface CacheEntry {
   isSubagent: boolean;
-  recordedAt: number;
+  /**
+   * When a provisional "primary" answer (recorded after a failed or timed-out
+   * lookup) stops counting and the host is asked again. Absent for a real
+   * answer, which never changes: a session's parent is fixed at creation.
+   */
+  retryAfter?: number;
 }
 
 const CACHE_MAX_ENTRIES = 200;
+/** Longest a caller waits for the host's session lookup. */
+export const LOOKUP_TIMEOUT_MS = 1_000;
+/** How long a failed or timed-out lookup is answered as "primary" before retrying. */
+export const FAILED_LOOKUP_RETRY_MS = 30_000;
 const cache = new Map<string, CacheEntry>();
+/** One lookup per session at a time; concurrent first calls await it. */
+const inflight = new Map<string, Promise<boolean>>();
+let now: () => number = () => Date.now();
 
 /**
  * Returns `true` when the given session has a non-empty `parentID`
  * (subagent). Returns `false` for primary sessions, when the SDK is
- * unavailable, or when any error occurs — the false default keeps
- * primary sessions working exactly as before.
+ * unavailable, or when the lookup fails or takes longer than
+ * LOOKUP_TIMEOUT_MS; the false default keeps primary sessions working
+ * exactly as before.
  *
- * First call per session: one SDK round-trip. All subsequent calls:
- * O(1) cache lookup.
+ * A known answer is an O(1) cache hit. Otherwise at most one host lookup
+ * per session is in flight, and it is bounded by LOOKUP_TIMEOUT_MS.
  */
 export async function resolveIsSubagent(
   client: unknown,
@@ -74,7 +91,7 @@ export async function resolveIsSubagent(
   }
 
   const cached = cache.get(sessionId);
-  if (cached) {
+  if (cached && (cached.retryAfter === undefined || now() < cached.retryAfter)) {
     // Refresh LRU position. Don't log the hit — it's pure noise; the
     // downstream call sites already log their effective gate decisions.
     cache.delete(sessionId);
@@ -82,6 +99,48 @@ export async function resolveIsSubagent(
     return cached.isSubagent;
   }
 
+  const pending = inflight.get(sessionId);
+  if (pending) return pending;
+  const lookup = boundedLookup(client, sessionId).finally(() => {
+    inflight.delete(sessionId);
+  });
+  inflight.set(sessionId, lookup);
+  return lookup;
+}
+
+/**
+ * Runs the host lookup, giving up after LOOKUP_TIMEOUT_MS. A real answer is
+ * cached for good; a failure or timeout is cached as "primary" until
+ * FAILED_LOOKUP_RETRY_MS has passed. The abandoned host call is left to
+ * settle on its own; its late answer is ignored.
+ */
+async function boundedLookup(client: unknown, sessionId: string): Promise<boolean> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timedOut = new Promise<"timeout">((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), LOOKUP_TIMEOUT_MS);
+  });
+  let answer: boolean | "failed" | "timeout";
+  try {
+    answer = await Promise.race([lookupSession(client, sessionId), timedOut]);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (typeof answer === "boolean") {
+    setCache(sessionId, answer);
+    return answer;
+  }
+  if (answer === "timeout") {
+    sessionWarn(
+      sessionId,
+      `[subagent-detect] session lookup did not answer within ${LOOKUP_TIMEOUT_MS}ms → primary for now`,
+    );
+  }
+  setCache(sessionId, false, now() + FAILED_LOOKUP_RETRY_MS);
+  return false;
+}
+
+/** The host's answer, or "failed" when the lookup threw. Never rejects. */
+async function lookupSession(client: unknown, sessionId: string): Promise<boolean | "failed"> {
   if (isV2PluginContext(client)) return resolveV2(client, sessionId);
 
   const c = client as OpenCodeClientShape;
@@ -93,7 +152,6 @@ export async function resolveIsSubagent(
       sessionId,
       `[subagent-detect] client.session.get unavailable (client=${typeof client}, session=${typeof sessionApi}, get=${typeof sessionApi?.get}) → caching as primary`,
     );
-    setCache(sessionId, false);
     return false;
   }
 
@@ -102,8 +160,6 @@ export async function resolveIsSubagent(
     `[subagent-detect] cache miss, calling client.session.get(id=${sessionId})`,
   );
 
-  let isSubagent = false;
-  let parentIdRaw: unknown;
   try {
     // Call as a method so the SDK's `this._client` reference resolves
     // correctly. Extracting `sessionApi.get` into a local would lose
@@ -119,25 +175,21 @@ export async function resolveIsSubagent(
     // `Session` depending on `ThrowOnError`. Handle both shapes.
     const session: SessionInfo | undefined =
       (result as { data?: SessionInfo } | undefined)?.data ?? (result as SessionInfo | undefined);
-    parentIdRaw = session?.parentID;
-    isSubagent =
+    const parentIdRaw = session?.parentID;
+    const isSubagent =
       session !== undefined && typeof session.parentID === "string" && session.parentID.length > 0;
     sessionLog(
       sessionId,
       `[subagent-detect] SDK returned session=${session !== undefined ? "present" : "undefined"}, parentID=${JSON.stringify(parentIdRaw)} → isSubagent=${isSubagent}`,
     );
+    return isSubagent;
   } catch (err) {
-    // Don't poison the cache on transient errors — but do log once.
-    // Return false so primary-session behavior is preserved.
     sessionWarn(
       sessionId,
       `[subagent-detect] SDK lookup failed: ${err instanceof Error ? err.message : String(err)}`,
     );
-    return false;
+    return "failed";
   }
-
-  setCache(sessionId, isSubagent);
-  return isSubagent;
 }
 
 /**
@@ -166,33 +218,35 @@ function isV2PluginContext(client: unknown): client is V2PluginContextShape {
   );
 }
 
-async function resolveV2(context: V2PluginContextShape, sessionId: string): Promise<boolean> {
+async function resolveV2(
+  context: V2PluginContextShape,
+  sessionId: string,
+): Promise<boolean | "failed"> {
   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.
+    // Same policy as the V1 path: a failed lookup counts as primary only
+    // until FAILED_LOOKUP_RETRY_MS has passed.
     sessionWarn(
       sessionId,
       `[subagent-detect] OpenCode 2 session lookup failed: ${err instanceof Error ? err.message : String(err)}`,
     );
-    return false;
+    return "failed";
   }
   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 {
+function setCache(sessionId: string, isSubagent: boolean, retryAfter?: number): void {
   if (cache.has(sessionId)) cache.delete(sessionId);
-  cache.set(sessionId, { isSubagent, recordedAt: Date.now() });
+  cache.set(sessionId, retryAfter === undefined ? { isSubagent } : { isSubagent, retryAfter });
   if (cache.size > CACHE_MAX_ENTRIES) {
     const oldest = cache.keys().next().value;
     if (oldest !== undefined) cache.delete(oldest);
@@ -202,4 +256,11 @@ function setCache(sessionId: string, isSubagent: boolean): void {
 /** Test-only cache reset. Not exported from the public surface. */
 export function _resetSubagentCacheForTest(): void {
   cache.clear();
+  inflight.clear();
+  now = () => Date.now();
+}
+
+/** Test-only clock override for the failed-lookup retry window. */
+export function _setSubagentClockForTest(clock: () => number): void {
+  now = clock;
 }

package/src/shared/v2-context.ts

@@ -0,0 +1,7 @@
+/** V2 passes a Location-scoped Effect context where V1 passes an SDK client. */
+export function isV2PluginContext(client: unknown): boolean {
+  return (
+    typeof (client as { location?: { directory?: unknown } } | null)?.location?.directory ===
+    "string"
+  );
+}

package/src/tui/aft-rpc.ts

@@ -24,8 +24,18 @@ export const IndexProgress = Schema.Struct({
   total: Schema.optional(Schema.Number),
 });
 
+/**
+ * A one-off notice for the user, shown by the OpenCode 2 TUI as a toast. It
+ * travels over RPC rather than into the session because anything written into
+ * a session (a synthetic record included) is sent to the model on later turns.
+ */
+export const HostToolOverlapNotice = Schema.Struct({
+  message: Schema.String,
+});
+
 export type AftRpcSession = typeof RpcSession.Type;
 export type AftIndexProgress = typeof IndexProgress.Type;
+export type AftHostToolOverlapNotice = typeof HostToolOverlapNotice.Type;
 
 export const AftRpc = Rpc.define({
   id: "aft",
@@ -39,5 +49,6 @@ export const AftRpc = Rpc.define({
     statusInvalidated: { schema: RpcSession },
     showStatusDialog: { schema: RpcSession },
     indexProgress: { schema: IndexProgress },
+    hostToolOverlap: { schema: HostToolOverlapNotice },
   },
 });

package/src/tui/index.tsx

@@ -230,6 +230,7 @@ const StatusDialog = (props: StatusDialogProps) => {
   // The earlier `formatCompressionDialogRows` returned padded strings that
   // looked offset against neighboring sections.
   const compressionAggregateRows = () => formatCompressionSidebarRows(status()?.compression);
+  const statusBar = () => status()?.status_bar ?? status()?.status_bar_values;
 
   return (
     <box
@@ -492,56 +493,59 @@ const StatusDialog = (props: StatusDialogProps) => {
 
       {/* Human health values are optional. Omit a category until the server
           proves it rather than displaying an unproven zero as clean. */}
-      {status()?.status_bar ? (
+      {statusBar() ? (
         <box flexDirection="column" width="100%" marginTop={1}>
           <text fg={t().text}>
-            <b>{status()!.status_bar!.tier2_stale ? "Code Health ~" : "Code Health"}</b>
+            <b>{statusBar()!.tier2_stale ? "Code Health ~" : "Code Health"}</b>
           </text>
-          {status()!.status_bar!.errors !== undefined ? (
+          {(statusBar()!.disabled_categories ?? []).map((key) => (
+            <R theme={t()} label={key.replaceAll("_", " ")} value="○ off" tone="muted" />
+          ))}
+          {statusBar()!.errors !== undefined ? (
             <R
               theme={t()}
               label="Errors"
-              value={formatCountShort(status()!.status_bar!.errors)}
-              tone={status()!.status_bar!.errors! > 0 ? "err" : "muted"}
+              value={formatCountShort(statusBar()!.errors)}
+              tone={statusBar()!.errors! > 0 ? "err" : "muted"}
             />
           ) : null}
-          {status()!.status_bar!.warnings !== undefined ? (
+          {statusBar()!.warnings !== undefined ? (
             <R
               theme={t()}
               label="Warnings"
-              value={formatCountShort(status()!.status_bar!.warnings)}
-              tone={status()!.status_bar!.warnings! > 0 ? "warn" : "muted"}
+              value={formatCountShort(statusBar()!.warnings)}
+              tone={statusBar()!.warnings! > 0 ? "warn" : "muted"}
             />
           ) : null}
-          {status()!.status_bar!.dead_code !== undefined ? (
+          {statusBar()!.dead_code !== undefined ? (
             <R
               theme={t()}
               label="Dead Code"
-              value={formatCountShort(status()!.status_bar!.dead_code)}
+              value={formatCountShort(statusBar()!.dead_code)}
               tone="muted"
             />
           ) : null}
-          {status()!.status_bar!.unused_exports !== undefined ? (
+          {statusBar()!.unused_exports !== undefined ? (
             <R
               theme={t()}
               label="Unused Exports"
-              value={formatCountShort(status()!.status_bar!.unused_exports)}
+              value={formatCountShort(statusBar()!.unused_exports)}
               tone="muted"
             />
           ) : null}
-          {status()!.status_bar!.duplicates !== undefined ? (
+          {statusBar()!.duplicates !== undefined ? (
             <R
               theme={t()}
               label="Duplicates"
-              value={formatCountShort(status()!.status_bar!.duplicates)}
+              value={formatCountShort(statusBar()!.duplicates)}
               tone="muted"
             />
           ) : null}
-          {status()!.status_bar!.todos !== undefined ? (
+          {statusBar()!.todos !== undefined ? (
             <R
               theme={t()}
               label="TODOs"
-              value={formatCountShort(status()!.status_bar!.todos)}
+              value={formatCountShort(statusBar()!.todos)}
               tone="muted"
             />
           ) : null}

package/src/tui/sidebar-view.tsx

@@ -421,7 +421,7 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
   const trigramBytes = () => s()?.disk?.trigram_disk_bytes ?? 0;
   const semanticBytes = () => s()?.disk?.semantic_disk_bytes ?? 0;
   const compressionRows = () => formatCompressionSidebarRows(s()?.compression);
-  const statusBar = () => s()?.status_bar;
+  const statusBar = () => s()?.status_bar ?? s()?.status_bar_values;
 
   const degradedSummary = () => {
     const snap = s();
@@ -653,6 +653,14 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
                 palette={props.palette}
                 title={statusBar()!.tier2_stale ? "Code Health ~" : "Code Health"}
               />
+              {(statusBar()!.disabled_categories ?? []).map((key) => (
+                <StatRow
+                  palette={props.palette}
+                  label={key.replaceAll("_", " ")}
+                  value="○ off"
+                  tone="muted"
+                />
+              ))}
               {statusBar()!.errors !== undefined && (
                 <StatRow
                   palette={props.palette}