talon-agent 3.34.1 → 3.36.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Dylan Neve
+Copyright (c) 2026 Dylan Neve
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -11,7 +11,6 @@
 [![Backends](https://img.shields.io/badge/backends-Claude_%7C_Kilo_%7C_OpenCode_%7C_Codex_%7C_OpenAI_Agents-D97706)](#backends)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![CI](https://github.com/dylanneve1/talon/actions/workflows/ci.yml/badge.svg)](https://github.com/dylanneve1/talon/actions/workflows/ci.yml)
-[![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-db61a2?logo=githubsponsors&logoColor=white)](https://github.com/sponsors/dylanneve1)
 
 Multi-platform agentic AI harness. Runs on **Telegram**, **WhatsApp**, **Discord**, **Microsoft Teams**, the **Terminal**, and a **cross-platform Desktop/Mobile companion app** (Flutter), with a pluggable backend (**Claude Agent SDK**, **Kilo**, **OpenCode**, **Codex**, or **OpenAI Agents**) and full tool access through MCP.
 
@@ -560,15 +559,6 @@ smoke-tests the CLI and the MCP supervisor from it.
 
 ---
 
-## Support
-
-Talon is free and MIT-licensed, built and maintained in the open. If it's useful to you, sponsoring helps cover hosting and model costs and funds continued development — and keeps it free for everyone.
-
-**[❤️ Sponsor Talon on GitHub](https://github.com/sponsors/dylanneve1)**
-
-Even a one-time tip makes a difference, and every sponsor is appreciated. Starring the repo helps too.
-
----
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.34.1",
+  "version": "3.36.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -106,8 +106,8 @@
     "@grammyjs/transformer-throttler": "^1.2.1",
     "@kilocode/sdk": "^7.2.22",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openai/agents": "^0.17.0",
-    "@openai/codex-sdk": "^0.153.2",
+    "@openai/agents": "^0.18.0",
+    "@openai/codex-sdk": "^0.154.0",
     "@opencode-ai/sdk": "^1.17.4",
     "@playwright/mcp": "0.0.80",
     "@types/cross-spawn": "^6.0.6",

package/src/backend/codex/auth.ts

@@ -43,6 +43,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { TalonError } from "../../core/errors.js";
 
 /** Detected auth mode. */
 type CodexAuthMode = "api-key" | "chatgpt" | "none";
@@ -321,7 +322,9 @@ export function isChatGptModelMismatchError(message: string): boolean {
  *   - Error text contains `"Codex Exec exited"` (SDK's wrapper);
  *   - Error text contains `"Reading prompt from stdin"` (CLI banner);
  *   - Error text does NOT contain the explicit mismatch phrase (the
- *     other detector handles that case).
+ *     other detector handles that case);
+ *   - Error text does NOT carry the OAuth refresh failure (an expired
+ *     login exits with the same banner — `isCodexRefreshTokenError`).
  *
  * Callers MUST additionally check `authInfo.mode === "chatgpt"` and
  * that the model isn't already the OAuth default before falling back —
@@ -334,8 +337,44 @@ export function isChatGptModelMismatchError(message: string): boolean {
 export function isSilentOAuthExitError(message: string): boolean {
   if (!message) return false;
   if (isChatGptModelMismatchError(message)) return false;
+  if (isCodexRefreshTokenError(message)) return false;
   return (
     /Codex\s+Exec\s+exited\s+with\s+code\s+\d+/i.test(message) &&
     /Reading\s+prompt\s+from\s+stdin/i.test(message)
   );
 }
+
+/**
+ * Detect an expired ChatGPT OAuth login.
+ *
+ * When the stored refresh token has been invalidated (the user logged
+ * out elsewhere, or the session was ended server-side) the Codex CLI
+ * prints its startup banner, logs
+ *
+ *   `ERROR codex_login::auth::manager: Failed to refresh token: 401
+ *    Unauthorized: {"error": {"code": "refresh_token_invalidated", …}}`
+ *
+ * to stderr, and exits 1 before the prompt reaches the model. The SDK
+ * folds that stderr into the same `Codex Exec exited with code 1:
+ * Reading prompt from stdin...` wrapper the silent OAuth-incompat exit
+ * uses, so without this check it is misread as a model mismatch —
+ * resetting the thread and retrying on a fallback model that fails the
+ * same way. Nothing but `codex login` fixes it.
+ */
+export function isCodexRefreshTokenError(message: string): boolean {
+  return /Failed\s+to\s+refresh\s+token|refresh_token_invalidated/i.test(
+    message,
+  );
+}
+
+/**
+ * The error surfaced to the user for an expired Codex login. Typed
+ * `auth` so the shared retry ladder propagates it untouched — no thread
+ * reset, no fallback model — and `friendlyMessage` keeps the detail.
+ */
+export function codexLoginExpiredError(cause: unknown): TalonError {
+  return new TalonError(
+    "Codex login expired — run `codex login` to re-authenticate.",
+    { reason: "auth", retryable: false, status: 401, cause },
+  );
+}

package/src/backend/codex/handler/message.ts

@@ -52,7 +52,9 @@ import {
 import { getState } from "../state.js";
 import { ensureCodex, getCodexAuthInfo } from "../init.js";
 import {
+  codexLoginExpiredError,
   isChatGptModelMismatchError,
+  isCodexRefreshTokenError,
   isSilentOAuthExitError,
 } from "../auth.js";
 import {
@@ -81,6 +83,19 @@ const isTerminatorAbort = (state: StreamState, err: unknown): boolean =>
   state.turnTerminated &&
   (errMsg(err) === "AbortError" || /abort/i.test(errMsg(err)));
 
+/**
+ * Swap an expired-login exit for the user-facing auth error before the
+ * shared retry ladder classifies it. The raw SDK text is the CLI banner
+ * plus a stderr dump (see `isCodexRefreshTokenError`); left alone it
+ * reads as an opaque exit-1 and the user never learns that `codex
+ * login` is the fix. Any other error passes through unchanged.
+ */
+function surfaceLoginExpiry(err: unknown, turnFailedError?: string): unknown {
+  return isCodexRefreshTokenError(`${turnFailedError ?? ""} ${errMsg(err)}`)
+    ? codexLoginExpiredError(err)
+    : err;
+}
+
 /**
  * One-shot ChatGPT-OAuth model-mismatch recovery.
  *
@@ -356,7 +371,7 @@ async function recoverCodexFailure(inputs: {
   if (fallback) return fallback;
 
   const decision = await applyRetryDecision({
-    err,
+    err: surfaceLoginExpiry(err, outcome.turnFailedError),
     chatId,
     activeModel,
     retried,

package/src/backend/codex/plan-usage.ts

@@ -11,7 +11,7 @@
  * missing or expired token, or any transport failure.
  */
 
-import { readFile } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { logWarn } from "../../util/log.js";
@@ -26,6 +26,12 @@ const CACHE_TTL_MS = 60_000;
 
 let cache: { value: PlanUsage; fetchedAt: number } | undefined;
 let inFlight: Promise<PlanUsage | undefined> | undefined;
+/**
+ * `auth.json` mtime of a token the endpoint rejected with 401. An
+ * invalidated login stays invalid until `codex login` rewrites the file,
+ * so the poller warns once and stops calling until the mtime moves.
+ */
+let rejectedAuthMtimeMs: number | undefined;
 
 function authPath(): string {
   const home = process.env.CODEX_HOME?.trim();
@@ -37,11 +43,18 @@ function authPath(): string {
 interface CodexAuth {
   accessToken: string;
   accountId?: string;
+  /** `auth.json` mtime — identifies the login the token came from. */
+  mtimeMs: number;
 }
 
 async function readAuth(): Promise<CodexAuth | undefined> {
   try {
-    const parsed = JSON.parse(await readFile(authPath(), "utf8")) as {
+    const path = authPath();
+    const [raw, stats] = await Promise.all([
+      readFile(path, "utf8"),
+      stat(path),
+    ]);
+    const parsed = JSON.parse(raw) as {
       auth_mode?: string;
       tokens?: { access_token?: string; account_id?: string };
     };
@@ -52,6 +65,7 @@ async function readAuth(): Promise<CodexAuth | undefined> {
       ...(parsed.tokens?.account_id
         ? { accountId: parsed.tokens.account_id }
         : {}),
+      mtimeMs: stats.mtimeMs,
     };
   } catch {
     return undefined;
@@ -123,6 +137,8 @@ export function parseCodexUsage(body: unknown): PlanUsage | undefined {
 async function load(): Promise<PlanUsage | undefined> {
   const auth = await readAuth();
   if (!auth) return undefined;
+  if (auth.mtimeMs === rejectedAuthMtimeMs) return undefined;
+  rejectedAuthMtimeMs = undefined;
 
   try {
     const res = await fetch(USAGE_ENDPOINT, {
@@ -133,6 +149,15 @@ async function load(): Promise<PlanUsage | undefined> {
       },
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
     });
+    if (res.status === 401) {
+      rejectedAuthMtimeMs = auth.mtimeMs;
+      logWarn(
+        "agent",
+        "codex usage: endpoint returned 401 — Codex login expired; " +
+          "run `codex login` (not retried until auth.json changes)",
+      );
+      return undefined;
+    }
     if (!res.ok) {
       logWarn("agent", `codex usage: endpoint returned ${res.status}`);
       return undefined;

package/src/backend/kilo/handler/message.ts

@@ -7,6 +7,7 @@ import type { QueryParams, QueryResult } from "../../shared/handler-types.js";
 import { runRemoteChatTurn } from "../../remote-server/chat-turn.js";
 import {
   ensureServer,
+  trackActiveTurn,
   ensureSession,
   ensureChatMcpServer,
   ensurePluginMcpServers,
@@ -26,6 +27,7 @@ export function handleMessage(params: QueryParams): Promise<QueryResult> {
       label: "Kilo",
       getConfig,
       ensureServer,
+      trackActiveTurn,
       parseModelSelection: parseStoredKiloModelSelection,
       resolveProviderID,
       ensureSession,

package/src/backend/kilo/server.ts

@@ -82,6 +82,7 @@ export const stopKiloServer = kilo.stop;
 export const {
   onServerStop,
   ensureServer,
+  trackActiveTurn,
   ensureChatMcpServer,
   ensurePluginMcpServers,
   buildToolOverrides,

package/src/backend/opencode/handler/message.ts

@@ -7,6 +7,7 @@ import type { QueryParams, QueryResult } from "../../shared/handler-types.js";
 import { runRemoteChatTurn } from "../../remote-server/chat-turn.js";
 import {
   ensureServer,
+  trackActiveTurn,
   ensureSession,
   ensureChatMcpServer,
   ensurePluginMcpServers,
@@ -26,6 +27,7 @@ export function handleMessage(params: QueryParams): Promise<QueryResult> {
       label: "OpenCode",
       getConfig,
       ensureServer,
+      trackActiveTurn,
       parseModelSelection: parseStoredOpenCodeModelSelection,
       resolveProviderID,
       ensureSession,

package/src/backend/opencode/server.ts

@@ -64,6 +64,7 @@ export const stopOpenCodeServer = opencode.stop;
 export const {
   onServerStop,
   ensureServer,
+  trackActiveTurn,
   ensureChatMcpServer,
   ensurePluginMcpServers,
   buildToolOverrides,

package/src/backend/remote-server/chat-turn.ts

@@ -45,6 +45,7 @@ export type RemoteChatBindings<TClient extends RemoteAgentClient> = Pick<
   RemoteServerBindings<TClient>,
   | "getConfig"
   | "ensureServer"
+  | "trackActiveTurn"
   | "parseModelSelection"
   | "resolveProviderID"
   | "ensureSession"
@@ -145,6 +146,11 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
     state.turnTerminated = true;
     await turnClient.session.abort({ sessionID: sessionId });
   });
+  // Stopping the backend mid-turn (a `/model` swap, shutdown) aborts this
+  // controller, which rejects the turn promptly instead of leaving it to
+  // the deadline.
+  const stopController = new AbortController();
+  const untrackTurn = bindings.trackActiveTurn(stopController);
   const promptStartedAt = Date.now();
 
   const setupMs = Date.now() - t0;
@@ -175,6 +181,7 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
       onStreamDelta: undefined,
       onTextBlock,
       onToolUse,
+      stopSignal: stopController.signal,
     });
     promptMs = Date.now() - turnStart;
   } catch (err) {
@@ -205,6 +212,7 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
     );
     throw outcome.classified;
   } finally {
+    untrackTurn();
     unregisterInterrupt();
     // Note: we deliberately do NOT disconnect the chat MCP server here.
     // The server is named per-chat so it's safe to keep across turns;
@@ -256,14 +264,16 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
 }
 
 /**
- * If the SSE loop missed any usage info, fall back to the session
- * summary endpoint (which always reflects the final server state).
+ * If the SSE loop missed the usage info, fall back to the session summary
+ * endpoint (which always reflects the final server state). Best-effort:
+ * session summaries can race on cancellation, so a failure leaves the
+ * counts at zero.
  */
 async function fillUsageFromSummary(
   oc: RemoteSessionClient,
   sessionId: string,
   promptStartedAt: number,
-  state: StreamState,
+  state: ReturnType<typeof createStreamState>,
 ): Promise<void> {
   if (
     state.sdkInputTokens !== 0 ||

package/src/backend/remote-server/lifecycle.ts

@@ -13,11 +13,29 @@
  * reuse machinery.
  */
 
+import { TalonError } from "../../core/errors.js";
 import { log, logWarn } from "../../util/log.js";
 import type { RemoteAgentClient } from "./client.js";
 import type { RemoteServerState } from "./state.js";
 import { errMsg } from "./state.js";
 
+/**
+ * Rejection for a turn whose server was stopped underneath it (a backend
+ * hot-swap or shutdown). Non-retryable on purpose: the chat no longer
+ * points at this backend, so a fallback-model retry against it would be
+ * wrong — the turn fails cleanly and the next message runs on the new
+ * backend.
+ */
+export class RemoteServerStoppedError extends TalonError {
+  constructor(label: string) {
+    super(`${label} server stopped while the turn was in flight`, {
+      reason: "unknown",
+      retryable: false,
+    });
+    this.name = "RemoteServerStoppedError";
+  }
+}
+
 /**
  * Inputs passed to {@link ensureRemoteServer}. The backend supplies its
  * SDK's client/server factories; the shared helper handles the
@@ -180,6 +198,7 @@ export function stopRemoteServer<TClient extends RemoteAgentClient>(
   extraCleanup?: () => void,
 ): void {
   state.clientPromise = null;
+  abortActiveTurns(state);
   state.modelProviderCache.clear();
   state.registeredMcpServers.clear();
   state.registeredMcpTools.clear();
@@ -201,3 +220,21 @@ export function stopRemoteServer<TClient extends RemoteAgentClient>(
   // reused and is intentionally left running for its external owner.
   state.client = null;
 }
+
+/**
+ * Reject every in-flight turn with {@link RemoteServerStoppedError} before
+ * the server goes away. The turn's own cleanup unregisters its controller;
+ * clearing here only covers turns that never reach their `finally`.
+ */
+function abortActiveTurns<TClient extends RemoteAgentClient>(
+  state: RemoteServerState<TClient>,
+): void {
+  if (state.activeTurns.size === 0) return;
+  log(
+    "agent",
+    `${state.label} stopping with ${state.activeTurns.size} turn(s) in flight; aborting them`,
+  );
+  const reason = new RemoteServerStoppedError(state.label);
+  for (const controller of state.activeTurns) controller.abort(reason);
+  state.activeTurns.clear();
+}

package/src/backend/remote-server/server-bindings.ts

@@ -107,6 +107,12 @@ export interface RemoteServerBindings<TClient extends RemoteAgentClient> {
   stop(): void;
   /** Lazily start (or reuse) the local server and return a strict client. */
   ensureServer(): Promise<TClient>;
+  /**
+   * Register a chat turn's abort controller for the lifetime of the turn.
+   * `stop()` aborts every registered controller so no turn outlives its
+   * server. Returns the unregister function; call it when the turn ends.
+   */
+  trackActiveTurn(controller: AbortController): () => void;
   ensureChatMcpServer(oc: TClient, chatId: string): Promise<string>;
   ensurePluginMcpServers(oc: TClient, chatId: string): Promise<string[]>;
   /**
@@ -193,6 +199,12 @@ export function bindRemoteServer<TClient extends RemoteAgentClient>(
       });
     },
     ensureServer,
+    trackActiveTurn(controller) {
+      state.activeTurns.add(controller);
+      return () => {
+        state.activeTurns.delete(controller);
+      };
+    },
     ensureChatMcpServer,
     ensurePluginMcpServers,
     buildToolOverrides: (oc, chatServerName, pluginServerNames = []) =>

package/src/backend/remote-server/state.ts

@@ -56,6 +56,13 @@ export interface RemoteServerState<TClient extends RemoteAgentClient> {
   readonly registeredMcpTools: Map<string, readonly string[]>;
   /** Plugin-name → registered server-name mapping for each chat context. */
   readonly pluginMcpServersByChat: Map<string, Map<string, string>>;
+  /**
+   * One controller per in-flight chat turn. `stopRemoteServer` aborts them
+   * so a turn cannot outlive the server it is streaming from — without
+   * this, a mid-turn backend swap left the SSE await hanging until the
+   * 600s deadline while the question watchdog hammered the dead socket.
+   */
+  readonly activeTurns: Set<AbortController>;
 }
 
 /** Inputs for {@link createRemoteServerState}. */
@@ -90,6 +97,7 @@ export function createRemoteServerState<TClient extends RemoteAgentClient>(
     registeredMcpServers: new Set(),
     registeredMcpTools: new Map(),
     pluginMcpServersByChat: new Map(),
+    activeTurns: new Set(),
   };
 }
 

package/src/backend/remote-server/turn.ts

@@ -69,8 +69,22 @@ export interface RunRemoteTurnInputs {
   onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void;
   onTextBlock?: (text: string) => Promise<void>;
   onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
+  /**
+   * Fires when the backend is stopped underneath the turn (hot-swap or
+   * shutdown). Its `reason` is the error the turn rejects with.
+   */
+  stopSignal?: AbortSignal;
 }
 
+/** Poll cadence for the headless question/permission watchdog. */
+const WATCHDOG_INTERVAL_MS = 350;
+/**
+ * Consecutive poll failures before the watchdog gives up. A server that
+ * refuses three polls in a row is gone; polling on would only log
+ * `fetch failed` every 350ms until the turn is torn down.
+ */
+const WATCHDOG_MAX_CONSECUTIVE_FAILURES = 3;
+
 /**
  * Run one turn end-to-end.
  *
@@ -105,6 +119,7 @@ export async function runRemoteTurn(
     onStreamDelta,
     onTextBlock,
     onToolUse,
+    stopSignal,
   } = inputs;
   const sessionClient = oc as unknown as RemoteSessionClient;
 
@@ -112,6 +127,10 @@ export async function runRemoteTurn(
   // `message.part.updated` events can fire immediately after promptAsync
   // returns, so the iterator must already be alive.
   const sseAbort = new AbortController();
+  // A backend stop ends the SSE loop and the watchdog the same way a
+  // finished turn does; the turn itself rejects via `rejectWhenStopped`.
+  const onStop = (): void => sseAbort.abort();
+  stopSignal?.addEventListener("abort", onStop, { once: true });
   const sseDone = subscribeToTurnEvents({
     label,
     oc,
@@ -144,35 +163,30 @@ export async function runRemoteTurn(
         label,
       ),
     ]);
-  const questionWatchdog = (async () => {
-    while (!sseAbort.signal.aborted) {
-      try {
-        await settlePending();
-      } catch (err) {
-        logWarn(
-          "agent",
-          `[${chatId}] question watchdog failed: ${errMsg(err)}`,
-        );
-      }
-      await sleep(350, sseAbort.signal);
-    }
-  })();
+  const questionWatchdog = runQuestionWatchdog({
+    settlePending,
+    signal: sseAbort.signal,
+    chatId,
+  });
 
   try {
     // Fire and forget — promptAsync returns immediately. The await below
     // is on the SSE close event. Per-prompt overrides hide sibling chats'
     // MCP tools while session permissions independently deny execution.
     await awaitRemoteTurn(
-      (async () => {
-        await oc.session.promptAsync({
-          sessionID: sessionId,
-          parts: [{ type: "text", text: prompt }],
-          model: { providerID, modelID },
-          system: systemPrompt,
-          ...(toolOverrides ? { tools: toolOverrides } : {}),
-        });
-        await sseDone;
-      })(),
+      rejectWhenStopped(
+        (async () => {
+          await oc.session.promptAsync({
+            sessionID: sessionId,
+            parts: [{ type: "text", text: prompt }],
+            model: { providerID, modelID },
+            system: systemPrompt,
+            ...(toolOverrides ? { tools: toolOverrides } : {}),
+          });
+          await sseDone;
+        })(),
+        stopSignal,
+      ),
       { client: oc, sessionId, chatId, label },
     );
 
@@ -214,6 +228,7 @@ export async function runRemoteTurn(
     }
     throw err;
   } finally {
+    stopSignal?.removeEventListener("abort", onStop);
     sseAbort.abort();
     // A dead SSE socket may ignore the local abort flag until another event
     // arrives. Bound cleanup so a timed-out turn cannot wedge its caller in
@@ -228,6 +243,61 @@ export async function runRemoteTurn(
   }
 }
 
+/**
+ * Race the turn against a backend stop. A stop rejects with the signal's
+ * `reason` (a `RemoteServerStoppedError`) the moment it fires, instead of
+ * waiting for an SSE socket that will never close on its own.
+ */
+function rejectWhenStopped<T>(
+  turn: Promise<T>,
+  stopSignal: AbortSignal | undefined,
+): Promise<T> {
+  if (!stopSignal) return turn;
+  if (stopSignal.aborted) return Promise.reject(stopSignal.reason);
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = (): void => reject(stopSignal.reason);
+    stopSignal.addEventListener("abort", onAbort, { once: true });
+    turn.then(resolve, reject).finally(() => {
+      stopSignal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+
+/**
+ * Poll the pending question/permission lists until the turn's signal
+ * fires. Gives up after {@link WATCHDOG_MAX_CONSECUTIVE_FAILURES} failed
+ * polls in a row — a server that stopped answering is not coming back
+ * within this turn, and the finally-block settle runs once more anyway.
+ */
+async function runQuestionWatchdog(inputs: {
+  settlePending: () => Promise<unknown>;
+  signal: AbortSignal;
+  chatId: string;
+}): Promise<void> {
+  const { settlePending, signal, chatId } = inputs;
+  let consecutiveFailures = 0;
+  while (!signal.aborted) {
+    try {
+      await settlePending();
+      consecutiveFailures = 0;
+    } catch (err) {
+      consecutiveFailures += 1;
+      logWarn(
+        "agent",
+        `[${chatId}] question watchdog failed (${consecutiveFailures}/${WATCHDOG_MAX_CONSECUTIVE_FAILURES}): ${errMsg(err)}`,
+      );
+      if (consecutiveFailures >= WATCHDOG_MAX_CONSECUTIVE_FAILURES) {
+        logWarn(
+          "agent",
+          `[${chatId}] question watchdog stopped: server unreachable`,
+        );
+        return;
+      }
+    }
+    await sleep(WATCHDOG_INTERVAL_MS, signal);
+  }
+}
+
 interface SubscribeInputs {
   label: string;
   oc: RemoteTurnClient;

package/src/bootstrap.ts

@@ -28,6 +28,7 @@ import { initPulse, resetPulseTimer } from "./core/background/pulse.js";
 import { initCron } from "./core/background/cron.js";
 import { initPlanAlerts } from "./core/background/plan-alerts.js";
 import { setAdminNotifier } from "./core/notify.js";
+import { startAuthExpiryMonitor } from "./core/auth/expiry-monitor.js";
 import {
   initTriggers,
   resumeAfterRestart as resumeTriggersAfterRestart,
@@ -486,16 +487,7 @@ export async function initBackendAndDispatcher(
   // first consumer is WhatsApp pairing: codes must travel over a LIVE
   // frontend, not the dead one's log). Same delivery route as the plan
   // alerts above.
-  if (config.adminUserId) {
-    const adminChatId = config.adminUserId;
-    setAdminNotifier(async (text: string) =>
-      resolveFrontendByNumericId(
-        adminChatId,
-        String(adminChatId),
-        frontends,
-      ).sendMessage(adminChatId, text),
-    );
-  }
+  wireAdminNotifier(config, frontends);
 
   // Soul — initialize the identity kernel singleton from config so the prompt
   // injection / dream hooks see the right enabled state. Off by default; a
@@ -586,3 +578,25 @@ export async function initBackendAndDispatcher(
 
   return { backend };
 }
+
+/**
+ * Wire the admin notification seam to the admin's frontend, and start the
+ * login-expiry monitor that rides it: the CLIs' "N days to log in again"
+ * banner, delivered to the admin instead of a terminal nobody is watching
+ * (/auth then completes the sign-in from the chat).
+ */
+function wireAdminNotifier(
+  config: TalonConfig,
+  frontends: Parameters<typeof resolveFrontendByNumericId>[2],
+): void {
+  if (!config.adminUserId) return;
+  const adminChatId = config.adminUserId;
+  setAdminNotifier(async (text: string) =>
+    resolveFrontendByNumericId(
+      adminChatId,
+      String(adminChatId),
+      frontends,
+    ).sendMessage(adminChatId, text),
+  );
+  startAuthExpiryMonitor();
+}