@cortexkit/aft-opencode 0.58.2 → 0.60.0

package/src/shared/session-directory.ts

@@ -68,12 +68,14 @@ function isV2PluginContext(client: unknown): client is V2PluginContextShape {
 }
 
 /**
- * How long an OpenCode 2 session lookup may run. The lookup is awaited before
- * the first tool call of a session is routed, so a host that never answers
- * must not hold that call; after this long the call proceeds with the
- * Location's directory instead.
+ * 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 V2_SESSION_LOOKUP_TIMEOUT_MS = 3_000;
+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?: {
@@ -86,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
@@ -114,19 +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;
   }
 
@@ -148,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)}`,
@@ -156,7 +203,6 @@ export async function getSessionDirectory(
     return null;
   }
 
-  setCache(sessionId, dir);
   return dir;
 }
 
@@ -164,12 +210,10 @@ export async function getSessionDirectory(
  * OpenCode 2 lookup: run the context's `session.get` Effect under a timeout and
  * read `location.directory`.
  *
- * Unlike the OpenCode 1 path, a failure or timeout is cached (as `null`), so it
- * is logged once per session and never retried. The fallback is already right:
- * with no cached directory, `projectRootFor` uses the tool call's Location
- * directory for OpenCode 2 runtimes, and OpenCode 2 runs every session inside
- * the Location created for that session's own directory. Retrying would only
- * add up to the timeout to every later tool call while the host misbehaves.
+ * 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,
@@ -196,7 +240,6 @@ async function lookupV2SessionDirectory(
       `[aft-plugin] OpenCode 2 session lookup failed (${failure}); tool paths and bash use the Location directory ${context.location.directory} for this session`,
     );
   }
-  setCache(sessionId, dir);
   return dir;
 }
 
@@ -226,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;
 }
 
@@ -240,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);
 }
 
@@ -302,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;
@@ -63,11 +64,12 @@ export interface StatusBar {
   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.
+   * `no_language_server` means no server is running. `producer_missing`
+   * masks both counts when an expected project producer has failed, even if
+   * another server supplied counts; diagnostics_gaps identifies the failures.
    */
-  diagnostics?: "no_language_server";
+  diagnostics?: "no_language_server" | "producer_missing";
+  diagnostics_gaps?: Array<{ language: string; producer: string; root: string }>;
 }
 
 export interface AftStatusSnapshot {
@@ -214,6 +216,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);
@@ -221,6 +226,22 @@ function readStatusBar(value: unknown): StatusBar | undefined {
   const duplicates = readOptionalNumber(bar.duplicates);
   const todos = readOptionalNumber(bar.todos);
   const noLanguageServer = bar.diagnostics === "no_language_server";
+  const producerMissing = bar.diagnostics === "producer_missing";
+  const diagnosticsGaps = Array.isArray(bar.diagnostics_gaps)
+    ? bar.diagnostics_gaps
+        .map(asRecord)
+        .filter(
+          (gap) =>
+            typeof gap.language === "string" &&
+            typeof gap.producer === "string" &&
+            typeof gap.root === "string",
+        )
+        .map((gap) => ({
+          language: gap.language as string,
+          producer: gap.producer as string,
+          root: gap.root as string,
+        }))
+    : [];
   if (
     errors === null &&
     warnings === null &&
@@ -228,11 +249,14 @@ function readStatusBar(value: unknown): StatusBar | undefined {
     unusedExports === null &&
     duplicates === null &&
     todos === null &&
-    !noLanguageServer
+    !noLanguageServer &&
+    !producerMissing &&
+    disabled.length === 0
   ) {
     return undefined;
   }
   return {
+    ...(disabled.length > 0 ? { disabled_categories: disabled } : {}),
     ...(errors !== null ? { errors } : {}),
     ...(warnings !== null ? { warnings } : {}),
     ...(deadCode !== null ? { dead_code: deadCode } : {}),
@@ -241,6 +265,9 @@ function readStatusBar(value: unknown): StatusBar | undefined {
     ...(todos !== null ? { todos } : {}),
     ...(bar.tier2_stale === true ? { tier2_stale: true } : {}),
     ...(noLanguageServer ? { diagnostics: "no_language_server" as const } : {}),
+    ...(producerMissing
+      ? { diagnostics: "producer_missing" as const, diagnostics_gaps: diagnosticsGaps }
+      : {}),
   };
 }
 
@@ -437,8 +464,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 +623,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/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}

package/src/tui/v2-status.ts

@@ -1,6 +1,7 @@
 import { type AftStatusSnapshot, degradedHeaderMarker, type StatusBar } from "../shared/status";
 
-function count(value: number | undefined): string {
+function count(value: number | undefined, off = false): string {
+  if (off) return "○";
   return value === undefined ? "?" : String(value);
 }
 
@@ -10,6 +11,8 @@ function count(value: number | undefined): string {
  * indefinitely.
  */
 function diagnosticsPart(bar: StatusBar): string {
+  if (bar.disabled_categories?.includes("diagnostics")) return "E○ W○";
+  if (bar.diagnostics === "producer_missing") return "E? W?";
   if (
     bar.errors === undefined &&
     bar.warnings === undefined &&
@@ -36,8 +39,8 @@ export function formatAftStatusSegment(status: AftStatusSnapshot | null): string
   const stale = bar.tier2_stale ? "~" : "";
   return (
     `AFT ${diagnosticsPart(bar)} | ` +
-    `${stale}D${count(bar.dead_code)} U${count(bar.unused_exports)} ` +
-    `C${count(bar.duplicates)} | T${count(bar.todos)}`
+    `${stale}D${count(bar.dead_code, bar.disabled_categories?.includes("dead_code"))} U${count(bar.unused_exports, bar.disabled_categories?.includes("unused_exports"))} ` +
+    `C${count(bar.duplicates, bar.disabled_categories?.includes("duplicates"))} | T${count(bar.todos, bar.disabled_categories?.includes("todos"))}`
   );
 }
 
@@ -53,8 +56,8 @@ function healthSummary(bar: StatusBar | undefined): string {
   const stale = bar.tier2_stale ? "~" : "";
   return (
     `${diagnosticsPart(bar)} ` +
-    `${stale}D${count(bar.dead_code)} U${count(bar.unused_exports)} ` +
-    `C${count(bar.duplicates)} T${count(bar.todos)}`
+    `${stale}D${count(bar.dead_code, bar.disabled_categories?.includes("dead_code"))} U${count(bar.unused_exports, bar.disabled_categories?.includes("unused_exports"))} ` +
+    `C${count(bar.duplicates, bar.disabled_categories?.includes("duplicates"))} T${count(bar.todos, bar.disabled_categories?.includes("todos"))}`
   );
 }
 

package/src/tui/v2.tsx

@@ -28,6 +28,11 @@ type AftRpcClient = {
       handler: (event: { data: { sessionID?: string } }) => void | Promise<void>,
       options?: { signal?: AbortSignal },
     ): () => void;
+    on(
+      name: "hostToolOverlap",
+      handler: (event: { data: { message: string } }) => void | Promise<void>,
+      options?: { signal?: AbortSignal },
+    ): () => void;
   };
 };
 
@@ -87,6 +92,14 @@ type V2TuiContext = {
   };
   ui: {
     dialog: { alert(input: { title: string; message: string }): Promise<void> };
+    toast?: {
+      show(input: {
+        title?: string;
+        message: string;
+        variant?: "info" | "success" | "warning" | "error";
+        duration?: number;
+      }): void;
+    };
     router: { current(): { type: string; sessionID?: string } };
     slot(claim: {
       append: "app" | "prompt.footer.status" | "sidebar.content";
@@ -316,6 +329,39 @@ function AftStatusCommands(props: { context: V2TuiContext; rpc: AftRpcClient })
   return null;
 }
 
+/** How long the built-in tool overlap toast stays up: long enough to read the command. */
+const HOST_TOOL_OVERLAP_TOAST_MS = 15_000;
+
+/**
+ * Show a server's one-off built-in tool overlap notice as a toast. A toast
+ * reaches the person at the terminal and nothing else. The current server no
+ * longer sends this notice: on OpenCode 2 AFT registers its command and patch
+ * tools as `shell` and `patch`, replacing the host's built-ins instead of
+ * sitting beside them. The subscription stays so a TUI still shows the notice
+ * from an older AFT server running in the same host during an upgrade. A host
+ * without a toast surface shows nothing.
+ */
+export function subscribeV2HostToolOverlapToast(
+  context: Pick<V2TuiContext, "ui">,
+  rpc: AftRpcClient,
+  options?: { signal?: AbortSignal },
+): () => void {
+  return rpc.events.on(
+    "hostToolOverlap",
+    (event) => {
+      const toast = context.ui.toast;
+      if (typeof toast?.show !== "function") return;
+      toast.show({
+        title: "AFT",
+        message: event.data.message,
+        variant: "warning",
+        duration: HOST_TOOL_OVERLAP_TOAST_MS,
+      });
+    },
+    options,
+  );
+}
+
 export async function setupV2Tui(context: V2TuiContext): Promise<() => void> {
   const rpc = context.client.rpc(AftRpc);
   const controller = new AbortController();
@@ -343,10 +389,14 @@ export async function setupV2Tui(context: V2TuiContext): Promise<() => void> {
     (event) => showStatusDialog(context, rpc, event.data.sessionID ?? activeSessionID(context)),
     { signal: controller.signal },
   );
+  const stopOverlapToasts = subscribeV2HostToolOverlapToast(context, rpc, {
+    signal: controller.signal,
+  });
 
   return () => {
     controller.abort();
     stopDialogEvents();
+    stopOverlapToasts();
     for (const cleanup of slotCleanups) cleanup();
   };
 }

package/src/tui-compiled/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 },
   },
 });