@pellux/goodvibes-tui 2.0.17 → 2.0.19

package/CHANGELOG.md

@@ -4,6 +4,47 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [2.0.19] - 2026-08-22
+
+### Changes
+
+- **This terminal adopts the running daemon again.** The adoption gate had
+  compared the daemon's 1.28.x artifact version against the sdk's 2.x
+  version and refused every adoption since sdk 2.0.0, silently running
+  local-only with no session spine. It now band-checks the platform build
+  the daemon reports.
+- **A dead subscription login is stamped and shown as ended**, everywhere a
+  status renders; a near-expiry token refreshes silently before the send.
+- **A machine with no microphone is reported as that**, once, in plain
+  words, with a gentle retry every minute — not a wake-detector crash loop
+  spamming the transcript and latching off. A busy device keeps prompt
+  retries and the crash latch.
+- Pins move to sdk/terminal-shell/toolchain 2.0.22 and daemon 1.28.24;
+  reusable-workflow pins repoint to the 2.0.22 release commit.
+
+## [2.0.18] - 2026-08-21
+
+### Changes
+
+- **Session start no longer crashes behind the scenes.** Every session
+  opened with "[Error] Provider error: Cannot access 'render' before
+  initialization" — a startup crash inside the TUI's own wiring, mislabeled
+  as a provider problem, that killed whatever bootstrap step was mid-flight.
+  Render requests that arrive before the renderer exists are now deferred
+  into the first paint instead of throwing.
+- **A dead subscription login is named as such.** An OpenAI subscription
+  session ended server-side used to surface as "the provider rejected your
+  API key. Run /login to re-authenticate or check your API key", which reads
+  as "your subscription isn't there" to a logged-in subscriber. It now says
+  the subscription session has ended and to sign in again — and with
+  platform runtime 2.0.21 underneath, a token OpenAI rotated early is
+  refreshed and retried before anything is surfaced at all.
+- **Escaped errors are captioned honestly.** An unhandled rejection with no
+  provider markers is reported as a GoodVibes bug; one carrying provider
+  markers (a 5xx outage classifies as neither auth nor network) stays
+  neutral instead of blaming either side.
+- Platform runtime pins move to 2.0.21; the bundled daemon moves to 1.28.23.
+
 ## [2.0.17] - 2026-08-21
 
 ### Changes

package/docs/foundation-artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "2.0.20"
+    "version": "2.0.22"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "description": "Terminal-native GoodVibes client for coding, operations, knowledge and channel workflows; a pure client of the GoodVibes daemon.",
   "type": "module",
   "main": "src/main.ts",
@@ -96,11 +96,11 @@
     "@anthropic-ai/bedrock-sdk": "^0.29.1",
     "@anthropic-ai/sdk": "^0.92.0",
     "@ast-grep/napi": "^0.42.0",
-    "@pellux/goodvibes-sdk": "2.0.20",
-    "@pellux/goodvibes-terminal-shell": "2.0.20",
+    "@pellux/goodvibes-sdk": "2.0.22",
+    "@pellux/goodvibes-terminal-shell": "2.0.22",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
-    "@pellux/goodvibes-daemon": "1.28.22",
+    "@pellux/goodvibes-daemon": "1.28.24",
     "graphql": "^16.13.2",
     "jszip": "^3.10.1",
     "node-edge-tts": "^1.2.10",
@@ -121,7 +121,7 @@
     "zustand": "^5.0.12"
   },
   "devDependencies": {
-    "@pellux/goodvibes-toolchain": "2.0.20",
+    "@pellux/goodvibes-toolchain": "2.0.22",
     "@types/bun": "^1.3.10",
     "typescript": "^5.9.3"
   },

package/src/core/format-user-error.ts

@@ -77,12 +77,15 @@ function probeString(err: unknown): string {
 export function classifyError(err: unknown): ErrorClass {
   const probe = probeString(err);
 
-  // Auth: 401 status, key/token invalidity, Unauthorized
+  // Auth: 401 status, key/token invalidity, Unauthorized, or a subscription
+  // session the provider's backend has ended (matched by message too, because
+  // a wrapper that re-throws can drop the 401 status on the way up).
   if (
     /\b401\b/.test(probe) ||
     /invalid.{0,10}(api.?key|key|token)/i.test(probe) ||
     /unauthorized/i.test(probe) ||
     /authentication/i.test(probe) ||
+    /subscription session has ended/i.test(probe) ||
     /api.?key.{0,20}(missing|not.?set|required|invalid)/i.test(probe)
   ) {
     return 'auth';
@@ -143,12 +146,24 @@ export function formatUserFacingError(err: unknown): UserFacingError {
   const kind = classifyError(err);
 
   switch (kind) {
-    case 'auth':
+    case 'auth': {
+      // A subscription-session death is not an API-key problem, and telling a
+      // subscriber to "check your API key" reads as "your subscription isn't
+      // there". The SDK's subscription providers phrase that failure
+      // distinctly; keep their meaning.
+      if (/subscription session has ended/i.test(probeString(err))) {
+        return {
+          kind,
+          message: 'Authentication failed: your provider subscription session has ended.',
+          action: 'Run /login to sign in to the provider again.',
+        };
+      }
       return {
         kind,
         message: 'Authentication failed: the provider rejected your API key.',
         action: 'Run /login to re-authenticate or check your API key.',
       };
+    }
 
     case 'rate-limit':
       return {

package/src/main.ts

@@ -54,9 +54,7 @@ import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState, reportFatalStartupError } from './cli/tui-startup.ts';
 import { applyConfiguredHitlMode, applyRuntimeConfigValue, applyTerminalRuntimeConfigDefaults } from '@pellux/goodvibes-terminal-shell';
 import { renderToolCallBlock } from './renderer/tool-call.ts';
-import { wireSpokenTurnRuntime } from './audio/spoken-turn-wiring.ts';
 import { installVoiceCapture } from './shell/voice-capture-shell.ts';
-import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './audio/spoken-turn-model-routing.ts';
 import { allowTerminalWrite, installFullScreenTerminalOutputGuard } from '@pellux/goodvibes-terminal-shell/terminal-output-guard';
 import { installProcessLifecycle } from './runtime/process-lifecycle.ts';
 import { createRenderScheduler } from '@pellux/goodvibes-terminal-shell';
@@ -68,9 +66,7 @@ import { wireStreamEventMetrics, createStreamMetrics, type StreamMetrics, type W
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
 import { resolveContextStatusHint } from './renderer/context-status-hint.ts';
 import { isEffectiveDangerMode } from '@pellux/goodvibes-sdk/platform/config';
-import { createScriptableStatusline } from './core/scriptable-statusline.ts';
 import { applyComposerCapture, applyAtModelDirective } from './input/composer-capture.ts';
-import { createSessionAutoTitler } from './core/session-auto-titler.ts';
 import { makeComposerEditorOpener } from './input/composer-editor.ts';
 import { evaluateSessionMaintenance } from '@/runtime/index.ts';
 import { createCancelGeneration } from './core/turn-cancellation.ts';
@@ -80,6 +76,9 @@ import { fetchDaemonPowerState, installKeepAwakeRemoteForward } from './runtime/
 import { wrapRequestPermissionWithAlert } from './core/approval-alert.ts';
 import { createTerminalNotifier } from './core/terminal-notifier.ts';
 import { setPanelFrameRequester } from './panels/base-panel.ts';
+import { createDeferredRender } from './renderer/deferred-render.ts';
+import { wireSessionAmbience } from './runtime/session-ambience-wiring.ts';
+import { createSpokenTurnInputOptions } from './audio/spoken-turn-model-routing.ts';
 
 import { ALT_SCREEN_ENTER, ALT_SCREEN_EXIT, MOUSE_ENABLE, MOUSE_DISABLE, CURSOR_HIDE, CURSOR_SHOW, CLEAR_SCREEN, KEYBOARD_EXT_ENABLE, KEYBOARD_EXT_DISABLE, PASTE_ENABLE, PASTE_DISABLE, FOCUS_ENABLE, FOCUS_DISABLE } from './renderer/terminal-escapes.ts';
 import { installBackgroundThemeProbe } from './renderer/terminal-bg-probe.ts';
@@ -162,6 +161,10 @@ async function main() {
   const panelManager = ctx.services.panelManager;
   const buildSessionContinuityHints = createSessionContinuityHintsBuilder({ readModels: uiServices.readModels, panelManager });
 
+  // Callable before the scheduler exists; see deferred-render.ts for why.
+  const deferredRender = createDeferredRender();
+  const render = deferredRender.render;
+
   let pendingPermission: PendingPermissionState | null = null;
   // One-key jump/attach to a spawned CI fix-session: the affordance ARMS the id; the next 'j' runs the resume so the user never retypes it.
   let fixSessionAttachArmed: string | null = null;
@@ -259,30 +262,15 @@ async function main() {
     configGet: (k: string) => configManager.get(k as Parameters<typeof configManager.get>[0]),
   });
 
-  const spokenTurns = wireSpokenTurnRuntime({
-    voiceService: ctx.services.voiceService,
-    configManager,
-    events: uiServices.events,
-    notify: (message) => { systemMessageRouter.high(message); render(); },
-  });
-  // Exit-path stop: bounded drain of the audio already playing (see stopForExit).
-  stopSpokenOutputForExit = () => spokenTurns.stopForExit();
-  unsubs.push(...spokenTurns.unsubs);
-  // Scriptable status line: runs the user's `statusline.command` at turn boundaries.
-  const scriptableStatusline = createScriptableStatusline({ configManager, cwd: workingDir, turns: uiServices.events.turns, onChange: () => render() });
-  unsubs.push(...scriptableStatusline.unsubs);
-  // Auto-title an untitled session via the weak/fast tool model (session.autoTitle, off by default).
-  const sessionAutoTitler = createSessionAutoTitler({
-    conversation, model: ctx.services.toolLLM, configManager, turns: uiServices.events.turns,
-    onTitled: (title) => { systemMessageRouter.high(`[Session] Auto-titled: "${title}"`); render(); },
+  // Spoken output, scriptable statusline, auto-titling, spoken-turn routing.
+  const ambience = wireSessionAmbience({
+    voiceService: ctx.services.voiceService, configManager, events: uiServices.events,
+    conversation, toolLLM: ctx.services.toolLLM, orchestrator, providerRegistry, workingDir,
+    notify: (message) => systemMessageRouter.high(message), render,
   });
-  unsubs.push(...sessionAutoTitler.unsubs);
-  unsubs.push(attachSpokenTurnModelRouting({
-    orchestrator,
-    providerRegistry,
-    configManager,
-    notify: (message) => { systemMessageRouter.high(message); render(); },
-  }));
+  stopSpokenOutputForExit = ambience.stopSpokenOutputForExit;
+  const { spokenTurns, scriptableStatusline } = ambience;
+  unsubs.push(...ambience.unsubs);
   const submitInput = (text: string, content?: ContentPart[], options: { readonly spokenOutput?: boolean } = {}) => {
     input.clearModalStack();
     scrollLocked = true; // Re-lock on any user input
@@ -649,7 +637,7 @@ async function main() {
     });
   };
   const renderScheduler = createRenderScheduler(renderNow, undefined, () => lifecycle.isTerminalRestored()); // coalescer; no frames after terminal restore
-  const render = (): void => renderScheduler.schedule(); // captured direct writes → activity log + quiet /debug counter, not repeated transcript lines (1a)
+  deferredRender.set(() => renderScheduler.schedule()); // from here on, render() actually schedules
   const terminalOutputGuard = installFullScreenTerminalOutputGuard({ stdout, stderr: process.stderr, onCapture: (total) => { commandContext.session.runtime.terminalWritesIntercepted = total; render(); } });
 
   setRenderRequest(() => renderScheduler.flushNow()); // bootstrap's 16ms coalescer composites via the (restore-gated) scheduler

package/src/renderer/deferred-render.ts

@@ -0,0 +1,31 @@
+/**
+ * A render function usable before the renderer exists.
+ *
+ * main() captures `render` in dozens of closures declared long before the
+ * render scheduler is built (the scheduler needs the compositor and lifecycle
+ * constructed below them). A direct `const render` declared at the scheduler
+ * put every one of those closures in its temporal dead zone, and every
+ * session start crashed with "Cannot access 'render' before initialization"
+ * surfacing as an unhandled rejection that killed whatever bootstrap step was
+ * mid-flight. The firing path has to be a callback some installer in that
+ * window invokes synchronously with the rejection crossing a promise boundary
+ * on the way out — the window contains no await, so no timer or scan callback
+ * can interleave into it — and this indirection removes the entire class
+ * rather than the one caller: a closure that fires before {@link
+ * DeferredRender.set} runs gets a no-op, and main()'s unconditional first
+ * paint after wiring covers everything deferred.
+ */
+export interface DeferredRender {
+  /** Safe to call at any time; a no-op until {@link set} provides the real renderer. */
+  readonly render: () => void;
+  /** Install the real renderer; every later render() call goes to it. */
+  readonly set: (impl: () => void) => void;
+}
+
+export function createDeferredRender(): DeferredRender {
+  let impl: () => void = () => {};
+  return {
+    render: () => impl(),
+    set: (next) => { impl = next; },
+  };
+}

package/src/runtime/process-lifecycle.ts

@@ -21,7 +21,7 @@
 import { existsSync } from 'node:fs';
 import { flushActivityLogSync, logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { createTerminalLifecycle, TERMINAL_ESCAPES } from '@pellux/goodvibes-terminal-shell';
-import { formatUserFacingErrorLine } from '../core/format-user-error.ts';
+import { formatUserFacingError } from '../core/format-user-error.ts';
 import { allowTerminalWrite } from '@pellux/goodvibes-terminal-shell/terminal-output-guard';
 import { buildPersistedSessionContext, deleteRecoveryFile } from '@/runtime/index.ts';
 import type { SessionSurface } from '@/runtime/index.ts';
@@ -154,9 +154,29 @@ export function installProcessLifecycle(deps: ProcessLifecycleDeps): ProcessLife
         `[Critical] Multiple errors detected (${_unhandledRejectionCount} in 10s). If the issue persists, please restart. Latest: ${msg}`
       );
     } else {
-      const formatted = formatUserFacingErrorLine(reason);
-      ctx.systemMessageRouter.high(`[Error] ${formatted}`);
-      logger.error('unhandledRejection', { error: String(reason) });
+      // Recognized kinds (auth, rate-limit, network...) keep their specific
+      // line. A generic rejection used to be captioned "Provider error",
+      // which sent a startup UI crash out dressed as a model-backend
+      // problem — but the reverse lie matters too: the classifier has no
+      // 5xx rule, so a provider outage also classifies generic, and calling
+      // THAT a GoodVibes bug blames us for OpenAI's downtime. The
+      // discriminator is whether the reason carries provider markers
+      // (provider / statusCode, which every SDK AppError sets): with them,
+      // stay neutral; without them, it escaped from our own code and
+      // honesty says so.
+      const classified = formatUserFacingError(reason);
+      let line: string;
+      if (classified.kind !== 'generic') {
+        line = `[Error] ${classified.message} ${classified.action}`;
+      } else {
+        const record = typeof reason === 'object' && reason !== null ? reason as Record<string, unknown> : {};
+        const providerShaped = typeof record['provider'] === 'string' || typeof record['statusCode'] === 'number';
+        line = providerShaped
+          ? `[Error] Unexpected error: ${msg}. Retry your last message, or switch models with /model.`
+          : `[Error] Unexpected error: ${msg}. This is a GoodVibes bug, not a provider failure; if it repeats, restart the session.`;
+      }
+      ctx.systemMessageRouter.high(line);
+      logger.error('unhandledRejection', { error: String(reason), stack: reason instanceof Error ? reason.stack : undefined });
     }
     render();
   };

package/src/runtime/session-ambience-wiring.ts

@@ -0,0 +1,66 @@
+/**
+ * Turn-boundary ambience: spoken turn output, the user's scriptable status
+ * line, session auto-titling, and spoken-turn model routing. Extracted from
+ * main() as one seam because the four share the same inputs (turn events,
+ * config, a notify line, a repaint) and main() only needs their teardowns and
+ * the bounded exit-path audio stop.
+ */
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { Orchestrator } from '@pellux/goodvibes-sdk/platform/core';
+import { wireSpokenTurnRuntime } from '../audio/spoken-turn-wiring.ts';
+import { attachSpokenTurnModelRouting } from '../audio/spoken-turn-model-routing.ts';
+import { createScriptableStatusline } from '../core/scriptable-statusline.ts';
+import { createSessionAutoTitler } from '../core/session-auto-titler.ts';
+
+export interface SessionAmbienceDeps {
+  readonly voiceService: Parameters<typeof wireSpokenTurnRuntime>[0]['voiceService'];
+  readonly configManager: ConfigManager;
+  readonly events: Parameters<typeof wireSpokenTurnRuntime>[0]['events'];
+  readonly conversation: Parameters<typeof createSessionAutoTitler>[0]['conversation'];
+  readonly toolLLM: Parameters<typeof createSessionAutoTitler>[0]['model'];
+  readonly orchestrator: Orchestrator;
+  readonly providerRegistry: Parameters<typeof attachSpokenTurnModelRouting>[0]['providerRegistry'];
+  readonly workingDir: string;
+  readonly notify: (message: string) => void;
+  readonly render: () => void;
+}
+
+export interface SessionAmbience {
+  /** Bounded drain of audio already playing; the exit path calls this. */
+  readonly stopSpokenOutputForExit: () => Promise<void>;
+  /** Spoken-turn runtime handle: submit/stop, and the cancel path consumes it whole. */
+  readonly spokenTurns: ReturnType<typeof wireSpokenTurnRuntime>;
+  /** The footer reads the statusline's current text each frame. */
+  readonly scriptableStatusline: ReturnType<typeof createScriptableStatusline>;
+  readonly unsubs: ReadonlyArray<() => void>;
+}
+
+export function wireSessionAmbience(deps: SessionAmbienceDeps): SessionAmbience {
+  const { configManager, notify, render } = deps;
+  const notifyAndPaint = (message: string): void => { notify(message); render(); };
+  const spokenTurns = wireSpokenTurnRuntime({
+    voiceService: deps.voiceService,
+    configManager,
+    events: deps.events,
+    notify: notifyAndPaint,
+  });
+  const scriptableStatusline = createScriptableStatusline({
+    configManager, cwd: deps.workingDir, turns: deps.events.turns, onChange: () => render(),
+  });
+  const sessionAutoTitler = createSessionAutoTitler({
+    conversation: deps.conversation, model: deps.toolLLM, configManager, turns: deps.events.turns,
+    onTitled: (title) => notifyAndPaint(`[Session] Auto-titled: "${title}"`),
+  });
+  const routingUnsub = attachSpokenTurnModelRouting({
+    orchestrator: deps.orchestrator,
+    providerRegistry: deps.providerRegistry,
+    configManager,
+    notify: notifyAndPaint,
+  });
+  return {
+    stopSpokenOutputForExit: () => spokenTurns.stopForExit(),
+    spokenTurns,
+    scriptableStatusline,
+    unsubs: [...spokenTurns.unsubs, ...scriptableStatusline.unsubs, ...sessionAutoTitler.unsubs, routingUnsub],
+  };
+}