@pellux/goodvibes-agent 1.4.4 → 1.5.0

package/src/input/keybindings.ts

@@ -11,6 +11,16 @@
  * }
  *
  * Each value is a KeyCombo or an array of KeyCombos for multi-binding support.
+ *
+ * Action ID backward-compatibility aliases (accepted in keybindings.json):
+ *   "panel-picker"    → "workspace-picker"
+ *   "panel-close"     → "workspace-close"
+ *   "panel-close-all" → "workspace-close-all"
+ *   "panel-tab-next"  → "workspace-tab-next"
+ *   "panel-tab-prev"  → "workspace-tab-prev"
+ *
+ * These aliases are accepted when loading user-provided keybindings.json
+ * override files so existing user configs continue to work without changes.
  */
 
 import { readFileSync, existsSync } from 'node:fs';
@@ -34,11 +44,12 @@ export type KeyAction =
   | 'copy-selection'
   | 'clear-cancel'
   | 'screen-clear'
-  | 'panel-picker'
-  | 'panel-close'
-  | 'panel-close-all'
-  | 'panel-tab-next'
-  | 'panel-tab-prev'
+  | 'workspace-picker'
+  | 'workspace-close'
+  | 'workspace-close-all'
+  | 'workspace-tab-next'
+  | 'workspace-tab-prev'
+  | 'sidebar-toggle'
   | 'history-search'
   | 'search'
   | 'block-copy'
@@ -59,11 +70,12 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'copy-selection':        'Copy selected text to clipboard',
   'clear-cancel':          'Clear input / cancel generation / exit (double)',
   'screen-clear':          'Repaint the screen',
-  'panel-picker':          'Open the Agent operator workspace',
-  'panel-close':            'Dismiss Agent workspace',
-  'panel-close-all':         'Dismiss Agent workspace focus',
-  'panel-tab-next':        'Cycle Agent workspace category forward',
-  'panel-tab-prev':        'Cycle Agent workspace category backward',
+  'workspace-picker':      'Open the Agent operator workspace',
+  'workspace-close':       'Close the Agent workspace',
+  'workspace-close-all':   'Close the Agent workspace (alias: also bound to Ctrl+Shift+X)',
+  'workspace-tab-next':    'Cycle Agent workspace category forward',
+  'workspace-tab-prev':    'Cycle Agent workspace category backward',
+  'sidebar-toggle':        'Show or hide the activity sidebar',
   'history-search':        'Reverse input history search',
   'search':                'Toggle conversation search',
   'block-copy':            'Copy nearest block to clipboard',
@@ -98,11 +110,12 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'copy-selection':        [{ key: 'c', ctrl: true, shift: true }],
   'clear-cancel':          [{ key: 'c', ctrl: true }],
   'screen-clear':          [{ key: 'l', ctrl: true }],
-  'panel-picker':          [{ key: 'p', ctrl: true }],
-  'panel-close':            [{ key: 'x', ctrl: true }],
-  'panel-close-all':         [{ key: 'x', ctrl: true, shift: true }],
-  'panel-tab-next':        [{ key: ']', ctrl: true }],
-  'panel-tab-prev':        [{ key: '[', ctrl: true }],
+  'workspace-picker':      [{ key: 'p', ctrl: true }],
+  'workspace-close':       [{ key: 'x', ctrl: true }],
+  'workspace-close-all':   [{ key: 'x', ctrl: true, shift: true }],
+  'workspace-tab-next':    [{ key: ']', ctrl: true }],
+  'workspace-tab-prev':    [{ key: '[', ctrl: true }],
+  'sidebar-toggle':        [{ key: 'o', ctrl: true }],
   'history-search':        [{ key: 'r', ctrl: true }],
   'search':                [{ key: 'f', ctrl: true }],
   'block-copy':            [{ key: 'y', ctrl: true }],
@@ -116,7 +129,7 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'undo':                  [{ key: 'z', ctrl: true }],
   'redo':                  [{ key: 'z', ctrl: true, shift: true }],
   'paste':                 [{ key: 'v', ctrl: true }],
-  'replay-panel':          [{ key: 'r', ctrl: true, shift: true }],
+  'replay-panel':          [],  // intentionally unbound until replay-panel is implemented
 };
 
 /** Resolved overrides type: each key can be a single combo or array. */
@@ -185,7 +198,17 @@ export class KeybindingsManager {
       // Reset to defaults before applying overrides
       this.bindings = this.cloneDefaults();
 
-      for (const [action, combo] of Object.entries(parsed)) {
+      // Backward-compatibility aliases: map old panel-* action ids to workspace-* equivalents.
+      const ALIASES: Readonly<Record<string, KeyAction>> = {
+        'panel-picker': 'workspace-picker',
+        'panel-close': 'workspace-close',
+        'panel-close-all': 'workspace-close-all',
+        'panel-tab-next': 'workspace-tab-next',
+        'panel-tab-prev': 'workspace-tab-prev',
+      };
+
+      for (const [rawAction, combo] of Object.entries(parsed)) {
+        const action: string = Object.hasOwn(ALIASES, rawAction) ? ALIASES[rawAction as keyof typeof ALIASES] : rawAction;
         if (!validActions.has(action as KeyAction)) {
           logger.debug('keybindings: unknown action, skipping', { action });
           continue;

package/src/input/model-picker-local-fit.ts

@@ -0,0 +1,130 @@
+/**
+ * Local-fit recommendation builder.
+ *
+ * When no provider credentials are configured, the model picker would show an
+ * empty list. This module builds a small set of synthetic model entries that
+ * represent common local model sizes so the picker opens with useful content.
+ *
+ * Rules:
+ *   - These entries are purely informational — they are NOT installed models.
+ *   - They must never appear when any real provider is configured.
+ *   - Selecting one routes through the local-provider install/confirm path,
+ *     never a silent model switch.
+ *   - The provider sentinel 'local' is distinct from 'ollama', 'lm-studio',
+ *     etc. so cloud-provider fit checks are never triggered.
+ */
+
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import {
+  estimateModelBytes,
+  fitAssessment,
+  fitVerdictLabel,
+  readHardwareProfileSync,
+} from '../core/hardware-profile.ts';
+import type { HardwareProfile } from '../core/hardware-profile.ts';
+
+/**
+ * Sentinel provider ID used on synthetic local recommendation entries.
+ * Must not collide with any real provider (ollama, lm-studio, etc.).
+ */
+export const LOCAL_REC_PROVIDER = 'local';
+
+/**
+ * Representative local model sizes to recommend.
+ * Each entry: { id, displayName, params, sizeLabel }
+ */
+const LOCAL_REC_SIZES = [
+  { id: 'local:3b', displayName: '3B model (small, fast)', params: 3_000_000_000, sizeLabel: '3B' },
+  { id: 'local:7b', displayName: '7B model (balanced)', params: 7_000_000_000, sizeLabel: '7B' },
+  { id: 'local:13b', displayName: '13B model (more capable)', params: 13_000_000_000, sizeLabel: '13B' },
+] as const;
+
+/**
+ * Sentinel id used on the synthetic "Sign in to a provider" row that is
+ * appended to the local-only list when no credentials are configured.
+ */
+export const SIGN_IN_ROW_ID = 'local:sign-in';
+
+/**
+ * Return true when a model entry is the synthetic sign-in affordance row.
+ * This row must never be committed as an active model.
+ */
+export function isProviderSignInRow(model: ModelDefinition): boolean {
+  return model.id === SIGN_IN_ROW_ID && model.provider === LOCAL_REC_PROVIDER;
+}
+
+/**
+ * Return true when a model entry is a synthetic local fit recommendation
+ * (i.e. not a real installed model).
+ */
+export function isLocalFitRecommendation(model: ModelDefinition): boolean {
+  return (
+    model.provider === LOCAL_REC_PROVIDER &&
+    (model.description ?? '').includes('not yet installed')
+  );
+}
+
+/**
+ * Build the synthetic "Sign in to a provider" row for the local-only list.
+ * Selecting this row routes to the provider picker; it must never be committed
+ * as an active model.
+ */
+export function buildSignInRow(): ModelDefinition {
+  return {
+    id: SIGN_IN_ROW_ID,
+    provider: LOCAL_REC_PROVIDER,
+    registryKey: SIGN_IN_ROW_ID,
+    displayName: 'Sign in to a provider →',
+    description: 'Open the provider sign-in flow to connect a cloud or local provider.',
+    capabilities: {
+      toolCalling: false,
+      codeEditing: false,
+      reasoning: false,
+      multimodal: false,
+    },
+    contextWindow: 0,
+    selectable: true,
+    tier: 'free',
+  };
+}
+
+/**
+ * Build synthetic local recommendation entries annotated with hardware fit
+ * labels for the current machine.
+ *
+ * Pass a `profile` override for deterministic tests; omit to use the
+ * process-level hardware probe (`readHardwareProfileSync`).
+ */
+export function buildLocalFitRecommendations(
+  profileOverride?: HardwareProfile,
+): ModelDefinition[] {
+  const profile = profileOverride ?? readHardwareProfileSync();
+
+  return LOCAL_REC_SIZES.map((spec) => {
+    const sizeBytes = estimateModelBytes(spec.params);
+    const verdict = fitAssessment(sizeBytes, profile);
+    const fitHint = fitVerdictLabel(verdict, spec.sizeLabel);
+    // Plain-language detail: never imply the model is ready to use.
+    const detail = fitHint
+      ? `recommended for your hardware — not yet installed (${fitHint})`
+      : 'recommended for your hardware — not yet installed';
+
+    const model: ModelDefinition = {
+      id: spec.id,
+      provider: LOCAL_REC_PROVIDER,
+      registryKey: spec.id,
+      displayName: spec.displayName,
+      description: detail,
+      capabilities: {
+        toolCalling: true,
+        codeEditing: false,
+        reasoning: false,
+        multimodal: false,
+      },
+      contextWindow: 8192,
+      selectable: true,
+      tier: 'free',
+    };
+    return model;
+  });
+}

package/src/input/submission-router.ts

@@ -3,13 +3,11 @@ import type { SubmissionIntent } from './submission-intent.ts';
 export interface SubmissionRouterInput {
   readonly text: string;
   readonly commandMode?: boolean;
-  readonly panelFocused?: boolean;
   readonly hasAttachments?: boolean;
 }
 
 const PLAN_COMMANDS = new Set(['plan']);
 const DELEGATION_COMMANDS = new Set(['delegate', 'build', 'review', 'wrfc', 'agents', 'remote']);
-const PANEL_COMMANDS = new Set(['panel']);
 const ORCHESTRATION_COMMANDS = new Set([
   'orchestration',
   'tasks',
@@ -45,9 +43,6 @@ export function routeSubmissionIntent(input: SubmissionRouterInput): SubmissionI
     if (DELEGATION_COMMANDS.has(commandName)) {
       return { kind: 'delegation', label: 'delegation', commandName, hasAttachments };
     }
-    if (PANEL_COMMANDS.has(commandName)) {
-      return { kind: 'slash-command', label: 'Agent workspace', commandName, hasAttachments };
-    }
     if (ORCHESTRATION_COMMANDS.has(commandName)) {
       return { kind: 'orchestration', label: 'orchestration', commandName, hasAttachments };
     }

package/src/main.ts

@@ -25,20 +25,17 @@ import { createShellLayout } from './renderer/layout-engine.ts';
 import { buildShellFooter, estimateShellFooterHeight } from './renderer/shell-surface.ts';
 import { buildConversationViewport } from './renderer/conversation-layout.ts';
 import { applyConversationOverlays } from './renderer/conversation-overlays.ts';
-import { buildPanelCompositeData } from './renderer/panel-composite.ts';
+import { buildActivitySidebarLines, resolveActivitySidebarWidth } from './renderer/activity-sidebar.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import { registerBuiltinPanels } from './panels/builtin-panels.ts';
-import { renderPanelTabBar } from './renderer/panel-tab-bar.ts';
 import { bootstrapRuntime } from './runtime/bootstrap.ts';
 import type { BootstrapContext } from './runtime/bootstrap.ts';
 import type { HITLMode } from '@pellux/goodvibes-sdk/platform/state';
-import type { HookPhase, HookCategory, HookEventPath } from '@pellux/goodvibes-sdk/platform/hooks';
+import { wireSessionPersistenceAndRecovery, wireSetupIncompleteHint } from './shell/startup-wiring.ts';
+import { localModelCookbook } from './tools/agent-harness-model-routing.ts';
+import { localModelSetupStatus } from './tools/agent-harness-setup-model-helpers.ts';
 import {
-  checkRecoveryFile,
   deleteRecoveryFile,
   loadRecoveryConversation,
-  persistConversation,
-  writeRecoveryFile,
 } from '@/runtime/index.ts';
 import type { SessionSnapshot } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
@@ -47,7 +44,7 @@ import { getTerminalSize } from './shell/terminal-size.ts';
 import { buildShellSessionContinuityHints } from './shell/session-continuity-hints.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
-import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
+import { buildPersistedSessionContext } from '@/runtime/index.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState, formatFatalStartupErrorForLog, formatFatalStartupErrorForUser, getInteractiveTerminalLaunchError } from './cli/tui-startup.ts';
@@ -56,6 +53,8 @@ import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './au
 import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/terminal-output-guard.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { GOODVIBES_AGENT_PAIRING_SURFACE } from './config/surface.ts';
+import { createAutonomySurfacing, buildCalendarEventsLister, buildSkillDraftProposer } from './shell/autonomy-surfacing.ts';
+import { startHardwareProbe } from './core/hardware-profile.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h', ALT_SCREEN_EXIT = '\x1b[?1049l', MOUSE_ENABLE = '\x1b[?1000h\x1b[?1002h\x1b[?1006h', MOUSE_DISABLE = '\x1b[?1006l\x1b[?1002l\x1b[?1000l', CURSOR_HIDE = '\x1b[?25l', CURSOR_SHOW = '\x1b[?25h', CLEAR_SCREEN = '\x1b[2J\x1b[3J\x1b[H';
 const KEYBOARD_EXT_ENABLE = '\x1b[>4;2m' + '\x1b[?1u', KEYBOARD_EXT_DISABLE = '\x1b[>4;0m' + '\x1b[?1l', PASTE_ENABLE = '\x1b[?2004h', PASTE_DISABLE = '\x1b[?2004l';
@@ -127,12 +126,10 @@ async function main() {
     }
   }
 
-  const panelManager = ctx.services.panelManager;
   const buildSessionContinuityHints = () => buildShellSessionContinuityHints(
     uiServices.readModels.session.getSnapshot(),
     uiServices.readModels.tasks.getSnapshot(),
     uiServices.readModels.remote.getSnapshot(),
-    panelManager.getAllOpen(),
   );
   const buildCurrentSessionSnapshot = (): SessionSnapshot => {
     const messages = conversation.getMessageSnapshot();
@@ -154,13 +151,37 @@ async function main() {
     render();
   });
 
-  let streamStartTime = 0;
-  let streamDeltaCount = 0;
   let streamTokenSpeed = 0;
 
   let scrollTop = 0;
   let scrollLocked = true;
 
+  // Ambient autonomy surfacing: away digest at launch + sidebar Coming up.
+  const autonomy = createAutonomySurfacing({
+    shellPaths: ctx.services.shellPaths,
+    listAutomationJobs: () => ctx.services.automationManager.listJobs(),
+    listApprovals: () => ctx.services.approvalBroker.listApprovals(),
+    getTasksSnapshot: () => uiServices.readModels.tasks.getSnapshot().tasks,
+    router: {
+      high: (message) => systemMessageRouter.high(message),
+      getFeed: () => systemMessageRouter.getFeed(),
+    },
+    render: () => render(),
+    listCalendarEvents: buildCalendarEventsLister(ctx.services.shellPaths),
+    onAwayDigest: buildSkillDraftProposer(ctx.services.shellPaths, commandContext),
+  });
+
+  // Activity sidebar: shows ambient status on wide terminals. null = automatic
+  // (visible when the terminal is wide enough); the user can toggle it with
+  // Ctrl+O, which pins an explicit on/off override for the session.
+  let sidebarOverride: boolean | null = null;
+  const sidebarWidthFor = (width: number): number => {
+    const auto = resolveActivitySidebarWidth(width);
+    if (sidebarOverride === null) return auto;
+    if (!sidebarOverride) return 0;
+    return auto > 0 ? auto : Math.min(36, Math.max(28, Math.floor(width * 0.3)));
+  };
+
   const getPromptContentWidth = () => {
     const w = getTerminalSize(stdout).width;
     const boxMargin = 2;
@@ -228,6 +249,8 @@ async function main() {
   const exitApp = (): void => {
     stopSpokenOutputForExit?.();
     unsubs.forEach(fn => fn());
+    // Persist last-seen before shutdown so the next launch can compute the digest.
+    autonomy.stop();
     const snapshot = buildCurrentSessionSnapshot();
     ctx.shutdown(snapshot).catch((err) => {
       logger.debug('ctx.shutdown error during exitApp (non-fatal)', { error: summarizeError(err) });
@@ -349,6 +372,11 @@ async function main() {
     allowTerminalWrite(() => stdout.write(CLEAR_SCREEN));
     render();
   };
+  commandContext.toggleActivitySidebar = () => {
+    const width = getTerminalSize(stdout).width;
+    sidebarOverride = !(sidebarWidthFor(width) > 0);
+    render();
+  };
   permissionPromptRef.requestPermission = (request) =>
     new Promise((resolve) => {
       pendingPermission = {
@@ -389,7 +417,6 @@ async function main() {
       shell: {
         bookmarkManager: ctx.services.bookmarkManager,
         keybindingsManager: ctx.services.keybindingsManager,
-        panelManager,
         processManager,
         profileManager: ctx.services.profileManager,
       },
@@ -430,8 +457,10 @@ async function main() {
   const render = () => {
     const { width, height } = getTerminalSize(stdout);
 
+    // Fire-and-forget refresh for the 'Coming up' sidebar section.
+    autonomy.refreshComingUp();
+
     if (input.agentWorkspace.active) {
-      input.setPanelMouseLayout(null);
       activeConversationWidth = width;
       conversation.setSplashSuppressed(true);
       if (input.modelPicker.active) {
@@ -463,7 +492,6 @@ async function main() {
     const composerState = deriveComposerState({
       text: input.prompt,
       commandMode: input.commandMode,
-      panelFocused: input.panelFocused,
       pendingApproval: pendingPermission !== null,
       hasAttachments: input.getImageAttachments().size > 0,
       turnState: sessionSnapshot.turnState,
@@ -513,31 +541,18 @@ async function main() {
 
     const shellHeaderLines = headerLines;
     const shellFooterLines = footerLines;
-    const panelWidth = panelManager.isVisible() && panelManager.getAllOpen().length > 0
-      ? panelManager.getRightWidth(width)
-      : 0;
+    const sidebarWidth = sidebarWidthFor(width);
     const shellLayout = createShellLayout({
       width,
       height,
       headerHeight: shellHeaderLines.length,
       footerHeight: shellFooterLines.length,
-      panelWidth,
+      panelWidth: sidebarWidth,
     });
-    input.setPanelMouseLayout(shellLayout.panel
-      ? {
-          x: shellLayout.panel.x,
-          y: shellLayout.panel.y,
-          width: shellLayout.panel.width,
-          height: shellLayout.panel.height,
-          hasBottomPane: panelManager.isBottomPaneVisible() && panelManager.getBottomPane().panels.length > 0,
-          verticalSplitRatio: panelManager.getVerticalSplitRatio(),
-        }
-      : null);
     const vHeight = shellLayout.body.height;
     const conversationWidth = shellLayout.conversation.width;
     activeConversationWidth = conversationWidth;
-    const hasPanelWorkspace = panelManager.isVisible() && panelManager.getAllOpen().length > 0;
-    conversation.setSplashSuppressed(hasPanelWorkspace);
+    conversation.setSplashSuppressed(false);
 
     // Flush pending renders after updating the width provider and splash posture
     // so the transcript and splash rebuild against the current shell layout.
@@ -599,13 +614,27 @@ async function main() {
       contextWindow: currentModel.contextWindow,
     });
 
-    // Panel composite data
-    const panelComposite = buildPanelCompositeData(
-        panelManager,
-        input,
-        shellLayout.panel?.width ?? 0,
-        shellLayout.panel?.height ?? vHeight,
-      );
+    // Activity sidebar (ambient status on wide terminals)
+    const sidebar = sidebarWidth > 0
+      ? {
+          lines: buildActivitySidebarLines({
+            now: {
+              busy: orchestrator.isThinking,
+              label: sessionSnapshot.streamToolPreview?.trim() || undefined,
+              agents: activeAgents.slice(0, 3).map((agent) => ({
+                label: agent.label,
+                progress: agent.latestProgress?.trim() || undefined,
+              })),
+              processes: runningProcessCount,
+            },
+            needsYou: pendingPermission
+              ? ['Approval needed — answer the prompt under the conversation.']
+              : [],
+            comingUp: [...autonomy.comingUpItems()],
+            recent: systemMessageRouter.getFeed()?.latest(Math.max(4, vHeight - 8)) ?? [],
+          }, sidebarWidth, vHeight),
+        }
+      : undefined;
 
     compositor.composite({
       width, height,
@@ -622,8 +651,8 @@ async function main() {
         scrollTop,
         viewportStartY: shellHeaderLines.length,
       } : undefined,
-      panel: panelComposite.panelData,
-      panelWidth: panelComposite.panelWidth,
+      sidebar,
+      sidebarWidth,
     });
   };
   const terminalOutputGuard = installTuiTerminalOutputGuard({ stdout, stderr: process.stderr, notify: (message) => { systemMessageRouter.low(message); render(); } });
@@ -634,7 +663,6 @@ async function main() {
   wireShellUiOpeners({
     commandContext,
     input,
-    panelManager,
     conversation,
     configManager,
     providerRegistry,
@@ -651,35 +679,6 @@ async function main() {
     render,
   });
 
-  // --- Streaming speed + tool preview wiring ---
-  unsubs.push(uiServices.events.turns.on('TURN_COMPLETED', () => {
-    // Auto-save after every LLM turn so kills don't lose the session
-    try {
-      const snapshot = buildCurrentSessionSnapshot();
-      persistConversation(
-        runtime.sessionId,
-        snapshot,
-        runtime.model,
-        runtime.provider,
-        conversation.title || '',
-        { workingDirectory: workingDir, homeDirectory, sessionManager: ctx.services.sessionManager },
-      );
-      hookDispatcher.fire({ path: 'Lifecycle:session:save' as HookEventPath, phase: 'Lifecycle' as HookPhase, category: 'session' as HookCategory, specific: 'save', sessionId: runtime.sessionId, timestamp: Date.now(), payload: { sessionId: runtime.sessionId } }).catch((err: unknown) => logger.debug('hook fire error', { error: summarizeError(err) }));
-    } catch (e) { logger.debug('auto-save on turn:complete failed', { error: summarizeError(e) }); }
-  }));
-
-  unsubs.push(uiServices.events.turns.on('STREAM_START', () => {
-    streamStartTime = Date.now();
-    streamDeltaCount = 0;
-    streamTokenSpeed = 0;
-  }));
-  unsubs.push(uiServices.events.turns.on('STREAM_DELTA', () => {
-    streamDeltaCount++;
-    const elapsed = (Date.now() - streamStartTime) / 1000;
-    // Note: counts stream deltas, not actual tokens. ~1 delta per token for most providers.
-    streamTokenSpeed = elapsed > 0 ? streamDeltaCount / elapsed : 0;
-  }));
-
   stdin.setRawMode(true);
   stdin.resume();
   stdin.setEncoding('utf8');
@@ -721,25 +720,48 @@ async function main() {
   conversation.rebuildHistory();
   render();
 
-  const recoveryInfo = checkRecoveryFile({ workingDirectory: workingDir, homeDirectory });
-  if (recoveryInfo) {
-    systemMessageRouter.high(`[Recovery] Found unsaved session from ${new Date(recoveryInfo.timestamp).toLocaleString()}. Title: "${recoveryInfo.title}". Press Ctrl+R to restore, Esc to discard, or start typing to ignore it.`);
-    for (const line of formatReturnContextForDisplay(recoveryInfo.returnContext)) {
-      systemMessageRouter.low(`[Recovery] ${line}`);
-    }
-    render();
-    recoveryPending = true;
-  }
+  // Async GPU probe runs off the render frame — nvidia-smi result will populate
+  // the module cache and appear on the next render cycle after it completes.
+  startHardwareProbe();
 
-  recoveryInterval = setInterval(() => {
-    const snapshot = buildCurrentSessionSnapshot();
-    writeRecoveryFile(
-      snapshot,
-      runtime.sessionId,
-      conversation.title ?? '',
-      { workingDirectory: workingDir, homeDirectory },
-    );
-  }, 60_000);
+  // Away digest runs after the first render so it lands as ambient context,
+  // never a startup blocker.
+  autonomy.announceAwayDigest();
+
+  // If setup is in-progress (user has opened /agent but not finished), show a
+  // gentle plain-language reminder and point them back to /agent.
+  wireSetupIncompleteHint({
+    shellPaths: ctx.services.shellPaths,
+    providerReady: (() => {
+      try { return Boolean(providerRegistry.getCurrentModel()?.id); } catch { return false; }
+    })(),
+    // localReady mirrors the 'local-model-readiness' plan item from buildSetupPlan:
+    // cookbook status === 'detected-local-route'. Best-effort — never blocks render.
+    localReady: (() => {
+      try { return localModelSetupStatus(localModelCookbook(commandContext, false) as Record<string, unknown>) === 'ready'; } catch { return false; }
+    })(),
+    // hostReady is intentionally omitted: at startup the external-services stub
+    // always reports mode='external', which would produce a misleading 'active'
+    // line before any real probe has run. Omitting it keeps the hint honest.
+    systemMessageRouter,
+  });
+
+  // Wire streaming-speed metrics, auto-save, and recovery — all run after the
+  // first render so they land as ambient context, never startup blockers.
+  ({ recoveryInterval, recoveryPending } = wireSessionPersistenceAndRecovery({
+    buildCurrentSessionSnapshot,
+    runtime,
+    conversation,
+    workingDir,
+    homeDirectory,
+    systemMessageRouter,
+    render,
+    unsubs,
+    uiServicesTurns: uiServices.events.turns,
+    hookDispatcher,
+    sessionManager: ctx.services.sessionManager,
+    onStreamSpeedUpdate: (speed) => { streamTokenSpeed = speed; },
+  }));
 }
 main().catch((err: unknown) => {
   const detail = formatFatalStartupErrorForLog(err);
@@ -758,4 +780,4 @@ main().catch((err: unknown) => {
     // Ignore secondary stderr failures during process teardown.
   }
   process.exit(1);
-});
+});