@cortexkit/aft-opencode 0.62.0 → 0.63.5

package/src/shared/wake-admission.ts

@@ -0,0 +1,340 @@
+export interface WakeSessionApi {
+  promptAsync(input: unknown): Promise<unknown> | unknown;
+  message?: (input: {
+    path: { id: string; messageID: string };
+    signal?: AbortSignal;
+    throwOnError?: false;
+    responseStyle?: "fields";
+  }) => Promise<unknown> | unknown;
+  messages?: (input: {
+    path: { id: string };
+    query?: { limit?: number };
+    signal?: AbortSignal;
+    throwOnError?: false;
+    responseStyle?: "fields";
+  }) => Promise<unknown> | unknown;
+}
+
+export interface PendingWakeAdmission {
+  messageID: string;
+  taskIDs: readonly string[];
+  status: "submitting" | "unknown" | "pending";
+  observe(info: Record<string, unknown>): void;
+  reconcile(): Promise<void>;
+  cancel(): void;
+}
+
+export class WakeAdmissionRejected extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+  }
+}
+
+interface AdmissionOptions {
+  deliveryID: string;
+  sessionID: string;
+  requestBody: Record<string, unknown> & { messageID: string };
+  sessionApi: WakeSessionApi;
+  pending: Map<string, PendingWakeAdmission>;
+  timeoutMs: number;
+  onRecovery: () => void;
+  onPending: () => void;
+  onLateAcceptance: () => void;
+  taskIDs: readonly string[];
+  onUnknown: (cause: unknown) => void;
+}
+
+interface AdmissionResult {
+  accepted: boolean;
+  pending?: boolean;
+  ambiguous: boolean;
+  turnObserved: boolean;
+}
+
+const READBACK_INTERVAL_MS = 2_000;
+const ADMISSION_RECOVERY_WINDOW_MS = 120_000;
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function responseFailure(response: unknown): string | undefined {
+  const value = record(response);
+  if (value?.error != null)
+    return typeof value.error === "string" ? value.error : JSON.stringify(value.error);
+  if (value?.success === false)
+    return String(value.message ?? "promptAsync returned success=false");
+  return undefined;
+}
+
+/** A recorded user message must contain the submitted model-visible text, not just its id. */
+function containsSubmittedText(
+  value: unknown,
+  sessionID: string,
+  body: Record<string, unknown>,
+): boolean {
+  const message = record(value);
+  const info = record(message?.info);
+  if (info?.role !== "user" || info.id !== body.messageID || info.sessionID !== sessionID)
+    return false;
+  const expected = Array.isArray(body.parts)
+    ? body.parts.map(record).filter((part) => part?.type === "text")
+    : [];
+  const parts = Array.isArray(message?.parts) ? message.parts.map(record) : [];
+  return (
+    expected.length > 0 &&
+    expected.every((part) =>
+      parts.some(
+        (actual) =>
+          actual?.type === "text" &&
+          actual.text === part?.text &&
+          actual.synthetic === true &&
+          actual.ignored !== true,
+      ),
+    )
+  );
+}
+
+/** Bound readback independently; a missing or failed read is never proof of rejection. */
+async function readHostMessage(
+  options: AdmissionOptions,
+  controller: AbortController,
+): Promise<unknown> {
+  const { sessionApi, sessionID, requestBody, timeoutMs } = options;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const read =
+      typeof sessionApi.message === "function"
+        ? Promise.resolve().then(() =>
+            sessionApi.message?.({
+              path: { id: sessionID, messageID: requestBody.messageID },
+              signal: controller.signal,
+              throwOnError: false,
+              responseStyle: "fields",
+            }),
+          )
+        : typeof sessionApi.messages === "function"
+          ? Promise.resolve().then(() =>
+              sessionApi.messages?.({
+                path: { id: sessionID },
+                query: { limit: 50 },
+                signal: controller.signal,
+                throwOnError: false,
+                responseStyle: "fields",
+              }),
+            )
+          : Promise.resolve(undefined);
+    return await Promise.race([
+      read,
+      new Promise<undefined>((resolve) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          resolve(undefined);
+        }, timeoutMs);
+        timer.unref?.();
+      }),
+    ]);
+  } catch {
+    return undefined;
+  } finally {
+    if (timer) clearTimeout(timer);
+    controller.abort();
+  }
+}
+
+/**
+ * The V1 SDK's prompt_async HTTP 204 accepts background prompt work before
+ * the assistant finishes it. For an uncertain response, check the submitted
+ * message's text or assistant child for two minutes. One recovery then reuses
+ * the original messageID and body; that identity is not a deduplication promise.
+ * Each request has its own timeout budget. If recovery is also unproven, keep
+ * the pending wake reminders for the next tool reply/model turn, without a third automatic
+ * submission for this ambiguous delivery.
+ */
+export async function awaitWakeAdmission(options: AdmissionOptions): Promise<AdmissionResult> {
+  let requestController = new AbortController();
+  let requestTimer: ReturnType<typeof setTimeout> | undefined;
+  let recoveryTimer: ReturnType<typeof setTimeout> | undefined;
+  let pollTimer: ReturnType<typeof setTimeout> | undefined;
+  let readController: AbortController | undefined;
+  let readInFlight: Promise<void> | undefined;
+  let readAgain = false;
+  let ambiguous = false;
+  let recovered = false;
+  let completed = false;
+  let returnedPending = false;
+  let finish!: (result: AdmissionResult) => void;
+  let reject!: (error: Error) => void;
+  const result = new Promise<AdmissionResult>((resolve, fail) => {
+    finish = resolve;
+    reject = fail;
+  });
+  const current = () => !completed && options.pending.get(options.deliveryID) === admission;
+  const clearTimers = () => {
+    if (requestTimer) clearTimeout(requestTimer);
+    if (recoveryTimer) clearTimeout(recoveryTimer);
+    if (pollTimer) clearTimeout(pollTimer);
+    requestTimer = recoveryTimer = pollTimer = undefined;
+  };
+  const detach = () => {
+    clearTimers();
+    requestController.abort();
+    readController?.abort();
+    if (options.pending.get(options.deliveryID) === admission)
+      options.pending.delete(options.deliveryID);
+  };
+  const accept = (turnObserved = false) => {
+    if (!current()) return;
+    completed = true;
+    detach();
+    if (returnedPending) options.onLateAcceptance();
+    else finish({ accepted: true, ambiguous, turnObserved });
+  };
+  const leavePending = () => {
+    if (!current() || returnedPending) return;
+    returnedPending = true;
+    admission.status = "pending";
+    clearTimers();
+    requestController.abort();
+    readController?.abort();
+    // Restore queues before resolving, so a host event cannot race their restoration.
+    options.onPending();
+    finish({ accepted: false, pending: true, ambiguous, turnObserved: false });
+  };
+  const admission: PendingWakeAdmission = {
+    messageID: String(options.requestBody.messageID),
+    taskIDs: options.taskIDs,
+    status: "submitting",
+    observe(info) {
+      if (info.sessionID !== options.sessionID) return;
+      if (info.role === "assistant" && info.parentID === admission.messageID) accept(true);
+      else if (info.role === "user" && info.id === admission.messageID) void admission.reconcile();
+    },
+    reconcile() {
+      if (!current() || !ambiguous) return Promise.resolve();
+      if (readInFlight) {
+        readAgain = true;
+        return readInFlight;
+      }
+      readController = new AbortController();
+      readInFlight = readHostMessage(options, readController)
+        .then((response) => {
+          const data = record(response)?.data ?? response;
+          const messages = Array.isArray(data) ? data : [data];
+          if (
+            messages.some((message) =>
+              containsSubmittedText(message, options.sessionID, options.requestBody),
+            )
+          )
+            accept();
+        })
+        .catch(() => undefined)
+        .finally(() => {
+          readInFlight = undefined;
+          if (readAgain && current()) {
+            readAgain = false;
+            void admission.reconcile();
+          }
+        });
+      return readInFlight;
+    },
+    cancel() {
+      if (!current()) return;
+      completed = true;
+      detach();
+      if (!returnedPending) finish({ accepted: false, ambiguous, turnObserved: false });
+    },
+  };
+  options.pending.set(options.deliveryID, admission);
+  const poll = () => {
+    if (!current() || returnedPending) return;
+    void admission.reconcile();
+    pollTimer = setTimeout(poll, READBACK_INTERVAL_MS);
+    pollTimer.unref?.();
+  };
+  const unknown = (cause: unknown) => {
+    if (!current()) return;
+    if (!ambiguous) {
+      ambiguous = true;
+      admission.status = "unknown";
+      if (requestTimer) clearTimeout(requestTimer);
+      requestController.abort();
+      options.onUnknown(cause);
+      poll();
+      recoveryTimer = setTimeout(() => {
+        recoveryTimer = undefined;
+        if (!current() || recovered) return;
+        // Set the guard before invoking callbacks or dispatching the recovery request.
+        recovered = true;
+        options.onRecovery();
+        submit();
+      }, ADMISSION_RECOVERY_WINDOW_MS);
+      recoveryTimer.unref?.();
+    } else if (recovered && !returnedPending) {
+      leavePending();
+    }
+  };
+  const submit = () => {
+    if (!current()) return;
+    requestController = new AbortController();
+    const controller = requestController;
+    if (requestTimer) clearTimeout(requestTimer);
+    requestTimer = setTimeout(() => {
+      controller.abort();
+      unknown(new Error(`session promptAsync injection timed out after ${options.timeoutMs}ms`));
+    }, options.timeoutMs);
+    requestTimer.unref?.();
+    void Promise.resolve()
+      .then(() => {
+        if (!current() || controller.signal.aborted) return undefined;
+        return options.sessionApi.promptAsync({
+          path: { id: options.sessionID },
+          body: options.requestBody,
+          signal: controller.signal,
+          throwOnError: false,
+          responseStyle: "fields",
+        });
+      })
+      .then(
+        (response) => {
+          if (!current()) return;
+          const failure = responseFailure(response);
+          const status = record(record(response)?.response)?.status;
+          const error = record(record(response)?.error);
+          // These SDK error responses come from request validation or a missing
+          // session, which the server checks before scheduling background prompt work.
+          const refused =
+            (status === 400 && error?.name === "BadRequest") ||
+            (status === 404 && error?.name === "NotFoundError");
+          if (refused && !recovered && controller === requestController) {
+            completed = true;
+            detach();
+            reject(
+              new WakeAdmissionRejected(
+                failure ?? `promptAsync rejected (${status})`,
+                status as number,
+              ),
+            );
+          } else if (status === 204 || (status === undefined && !failure)) {
+            accept();
+          } else {
+            // A late rejection of recovery does not prove the original was rejected.
+            if (controller === requestController)
+              unknown(new Error(failure ?? `Unexpected promptAsync status ${status}`));
+          }
+        },
+        (cause) => {
+          if (controller !== requestController) return;
+          unknown(cause);
+        },
+      )
+      .catch(unknown);
+  };
+  submit();
+  return result;
+}

package/src/tui/notification-socket.ts

@@ -49,6 +49,14 @@ const WEB_SOCKET_OPEN = 1;
 const clients = new Map<string, AftRpcClient>();
 const statusInvalidationListeners = new Set<(event: StatusInvalidation) => void>();
 const lastHandledIdBySession = new Map<string, number>();
+const socketEndpoints = new WeakMap<WebSocketLike, AftRpcEndpoint>();
+const CURSOR_CACHE_LIMIT = 200;
+
+function cursorKey(ws: WebSocketLike, sessionId: string): string | null {
+  const endpoint = socketEndpoints.get(ws);
+  // The authentication token distinguishes server instances, even when a new instance reuses the port.
+  return endpoint?.token ? `${endpoint.token}\0${sessionId}` : null;
+}
 
 function defaultWebSocketCtor(): WebSocketFactory | null {
   const ctor = (globalThis as typeof globalThis & { WebSocket?: WebSocketFactory }).WebSocket;
@@ -128,6 +136,7 @@ export function stopAftTuiSocket(): void {
   closeCurrentSocket(false);
   for (const client of clients.values()) client.reset();
   clients.clear();
+  lastHandledIdBySession.clear();
   reconnectAttempt = 0;
 }
 
@@ -250,6 +259,7 @@ async function connect(scope: SocketScope, connectGeneration: number): Promise<v
   }
 
   socket = ws;
+  socketEndpoints.set(ws, endpoint);
   socketScope = scope;
   helloedScope = null;
 
@@ -335,13 +345,21 @@ async function sendHelloWithFreshToken(
   ) {
     return;
   }
-  sendHello(ws, scope, endpoint?.token ?? null);
+  const connected = socketEndpoints.get(ws);
+  if (!endpoint || endpoint.port !== connected?.port || endpoint.token !== connected.token) {
+    generation += 1;
+    closeCurrentSocket(false);
+    void connect(scope, generation);
+    return;
+  }
+  sendHello(ws, scope, connected.token);
 }
 
 function sendHello(ws: WebSocketLike, scope: SocketScope, token: string | null): void {
   helloedScope = scope;
   if (socket === ws) socketScope = scope;
-  const lastReceivedId = lastHandledIdBySession.get(scope.sessionId) ?? 0;
+  const key = cursorKey(ws, scope.sessionId);
+  const lastReceivedId = key ? (lastHandledIdBySession.get(key) ?? 0) : 0;
   ws.send(
     JSON.stringify({
       type: "hello",
@@ -400,8 +418,16 @@ async function handleSocketMessage(
     ) {
       return;
     }
-    if (consumed && notification.id > (lastHandledIdBySession.get(active) ?? 0)) {
-      lastHandledIdBySession.set(active, notification.id);
+    const key = cursorKey(ws, active);
+    if (consumed && notification.id > (key ? (lastHandledIdBySession.get(key) ?? 0) : 0)) {
+      if (key) {
+        lastHandledIdBySession.delete(key);
+        lastHandledIdBySession.set(key, notification.id);
+        if (lastHandledIdBySession.size > CURSOR_CACHE_LIMIT) {
+          const oldest = lastHandledIdBySession.keys().next().value;
+          if (oldest !== undefined) lastHandledIdBySession.delete(oldest);
+        }
+      }
       try {
         ws.send(JSON.stringify({ type: "ack", lastReceivedId: notification.id }));
       } catch {

package/src/tui/preferences.ts

@@ -39,6 +39,12 @@ export interface AftTuiPrefs {
   startCollapsed: boolean;
   rememberCollapsed: boolean;
   collapsed: boolean | null;
+  /**
+   * Whether OpenCode 2 shows AFT's health line (`AFT E0 W0 | D0 U0 C0 | T0`)
+   * in the prompt footer. Off hides it entirely; the sidebar and the status
+   * dialog are unaffected.
+   */
+  footer: boolean;
   header: {
     label: string;
     showVersion: boolean;
@@ -57,6 +63,7 @@ export const DEFAULT_PREFS: AftTuiPrefs = {
   startCollapsed: false,
   rememberCollapsed: true,
   collapsed: null,
+  footer: true,
   header: { label: "AFT", showVersion: true },
   sections: {
     searchIndex: true,
@@ -99,6 +106,7 @@ export function resolveAftPrefs(root: Record<string, unknown>): AftTuiPrefs {
     startCollapsed: bool(entry.startCollapsed, d.startCollapsed),
     rememberCollapsed: bool(entry.rememberCollapsed, d.rememberCollapsed),
     collapsed: typeof entry.collapsed === "boolean" ? entry.collapsed : null,
+    footer: bool(entry.footer, d.footer),
     header: {
       label: label(header.label, d.header.label, 20),
       showVersion: bool(header.showVersion, d.header.showVersion),
@@ -161,18 +169,14 @@ async function writePreference(pluginKey: string, path: string[], value: JsonVal
   let text: string;
   try {
     text = await readFile(file, "utf8");
-  } catch {
-    text = "";
-  }
-  if (text.trim() === "") text = TEMPLATE;
-
-  let root: Record<string, unknown>;
-  try {
-    const parsed = parse(text);
-    root = isRecord(parsed) ? (parsed as Record<string, unknown>) : {};
-  } catch {
-    root = {};
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    text = TEMPLATE;
   }
+  // Only a missing file can be initialized. Invalid existing bytes may belong to another plugin.
+  const parsed: unknown = parse(text);
+  if (!isRecord(parsed)) throw new Error("TUI preferences must contain an object");
+  const root = parsed;
 
   if (!isRecord(root[pluginKey])) {
     root[pluginKey] = {};
@@ -193,22 +197,52 @@ export function queueTuiPreferenceUpdate(
   path: string[],
   value: JsonValue,
 ): Promise<void> {
-  writeChain = writeChain.then(() => writePreference(pluginKey, path, value)).catch(() => {});
-  return writeChain;
+  const update = writeChain.then(() => writePreference(pluginKey, path, value));
+  // Keep subsequent writes usable while returning the actual failure to this caller.
+  writeChain = update.catch(() => {});
+  return update;
 }
 
 const WATCH_DEBOUNCE_MS = 150;
 
+/**
+ * What the watcher last saw where the preferences file should be: its text,
+ * or FILE_ABSENT once a read has confirmed the file does not exist. A symbol
+ * can never equal any file text, so deleting the file always counts as a
+ * change, even from an empty file.
+ */
+const FILE_ABSENT: unique symbol = Symbol("tui-preferences file absent");
+type WatchedState = string | typeof FILE_ABSENT;
+
+/**
+ * Read the file for the watcher. Returns FILE_ABSENT only for ENOENT; any
+ * other failure (a permission error, a directory at the path) returns null,
+ * meaning "unknown", so a file that is present but momentarily unreadable
+ * never makes callers fall back to defaults.
+ */
+async function readWatchedState(file: string): Promise<WatchedState | null> {
+  try {
+    return await readFile(file, "utf8");
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "ENOENT" ? FILE_ABSENT : null;
+  }
+}
+
+/**
+ * Calls `onChange` after the preferences file's content changes, including
+ * when the file is deleted (callers then read defaults) and when it is
+ * created again.
+ */
 export function watchTuiPreferences(onChange: () => void): () => void {
   const file = getTuiPreferencesFile();
   const name = basename(file);
   let timer: ReturnType<typeof setTimeout> | null = null;
-  let lastSeen: string | null = null;
-  void readFile(file, "utf8")
-    .then((text) => {
-      if (lastSeen === null) lastSeen = text;
-    })
-    .catch(() => {});
+  // null until a read has succeeded or confirmed the file is missing.
+  let lastSeen: WatchedState | null = null;
+  let stopped = false;
+  void readWatchedState(file).then((state) => {
+    if (lastSeen === null && state !== null) lastSeen = state;
+  });
   try {
     const watcher = watch(dirname(file), (_event, filename) => {
       const isOurs =
@@ -217,20 +251,23 @@ export function watchTuiPreferences(onChange: () => void): () => void {
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
         timer = null;
-        void readFile(file, "utf8")
-          .catch(() => null)
-          .then((text) => {
-            if (text === null) return;
-            if (text === lastSeen) return;
-            lastSeen = text;
-            onChange();
-          });
+        void readWatchedState(file).then((state) => {
+          if (stopped || state === null) return;
+          if (state === lastSeen) return;
+          lastSeen = state;
+          onChange();
+        });
       }, WATCH_DEBOUNCE_MS);
     });
-    return () => {
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
       if (timer) clearTimeout(timer);
+      timer = null;
       watcher.close();
     };
+    watcher.on("error", stop);
+    return stop;
   } catch {
     return () => {};
   }
@@ -238,6 +275,6 @@ export function watchTuiPreferences(onChange: () => void): () => void {
 
 export function persistCollapsedIfEnabled(prefs: AftTuiPrefs, collapsed: boolean): void {
   if (prefs.rememberCollapsed) {
-    void queueTuiPreferenceUpdate(PLUGIN_KEY, ["collapsed"], collapsed);
+    void queueTuiPreferenceUpdate(PLUGIN_KEY, ["collapsed"], collapsed).catch(() => {});
   }
 }

package/src/tui/sidebar-view.tsx

@@ -413,6 +413,7 @@ export const AftSidebarPanel = (props: AftSidebarPanelProps) => {
         error: s()?.semantic_index?.error,
         reason: s()?.semantic_index?.reason,
         backend_url: s()?.semantic_index?.backend_url,
+        pending_reason: s()?.semantic_index?.pending_reason,
       }),
     };
   };

package/src/tui/v2.tsx

@@ -9,6 +9,7 @@ import {
   formatStatusDialogMessage,
 } from "../shared/status";
 import { AftRpc } from "./aft-rpc";
+import { readTuiPreferencesFile, resolveAftPrefs, watchTuiPreferences } from "./preferences";
 import {
   AftSidebarPanel,
   createSidebarPreferences,
@@ -250,11 +251,58 @@ function useAftStatus(
   return status;
 }
 
-function FooterStatus(props: { context: V2TuiContext; rpc: AftRpcClient; sessionID?: string }) {
+/**
+ * The `footer` switch from the `aft` entry of `tui-preferences.jsonc`, kept
+ * current while the file is edited, as the sidebar's preferences are.
+ *
+ * It reads as hidden until the file has been read once. Starting from the
+ * default (shown) instead would flash the line on every prompt mount for
+ * someone who turned it off; the read takes milliseconds, and a missing or
+ * unreadable file resolves to the default, so the line still appears for
+ * everyone else.
+ */
+function createFooterVisibility(): () => boolean {
+  const [visible, setVisible] = createSignal(false);
+  // Reads can overlap when the file changes twice in quick succession; only
+  // the most recently started read may set the value.
+  let generation = 0;
+  const reload = async (): Promise<void> => {
+    const current = ++generation;
+    const prefs = resolveAftPrefs(await readTuiPreferencesFile());
+    if (current === generation) setVisible(prefs.footer);
+  };
+  void reload();
+  const unwatch = watchTuiPreferences(() => {
+    void reload();
+  });
+  onCleanup(() => {
+    generation += 1;
+    unwatch();
+  });
+  return visible;
+}
+
+function FooterSegment(props: { context: V2TuiContext; rpc: AftRpcClient; sessionID?: string }) {
   const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
   return <text>{formatAftStatusSegment(status())}</text>;
 }
 
+/**
+ * The prompt footer claim. With `footer: false` it renders no element at all,
+ * so the line takes no space, and the status subscription behind it is torn
+ * down until the switch is turned back on.
+ */
+function FooterStatus(props: { context: V2TuiContext; rpc: AftRpcClient; sessionID?: string }) {
+  const visible = createFooterVisibility();
+  return (
+    <>
+      {visible() ? (
+        <FooterSegment context={props.context} rpc={props.rpc} sessionID={props.sessionID} />
+      ) : null}
+    </>
+  );
+}
+
 function SidebarStatus(props: { context: V2TuiContext; rpc: AftRpcClient; sessionID: string }) {
   const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
   const preferences = createSidebarPreferences();