@pellux/goodvibes-agent 1.4.4 → 1.5.1

package/src/shell/autonomy-surfacing.ts

@@ -0,0 +1,272 @@
+/**
+ * Ambient autonomy surfacing module.
+ *
+ * HISTORY: this factory was extracted from main.ts to keep that file under the
+ * 800-line cap. After extraction it gained two capabilities:
+ *   1. Calendar merging — listCalendarEvents callback merges upcoming events
+ *      into the Coming-up sidebar alongside scheduled jobs (buildCalendarEventsLister).
+ *   2. Skill-draft accrual — onAwayDigest callback runs skill-draft proposal
+ *      once per away-digest pass and appends a feed line when drafts are created
+ *      (buildSkillDraftProposer).
+ * These additions are NOT "no behavior change" refactors; they add real surface.
+ */
+
+import { buildAwayDigest, formatDigestTime, formatRelativeTime } from '../core/away-digest.ts';
+import { LastSeenStore } from '../core/last-seen-store.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { AgentCalendarRegistry } from '../agent/calendar-registry.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import { runSkillDraftProposer } from '../agent/skill-draft-runner.ts';
+import type { CommandContext } from '../input/command-registry.ts';
+
+interface AutomationJobLike {
+  readonly name: string;
+  readonly enabled: boolean;
+  readonly nextRunAt?: number;
+  readonly lastRunAt?: number;
+  readonly runCount?: number;
+}
+
+interface ApprovalLike {
+  readonly status: string;
+}
+
+interface AutonomyMessageRouter {
+  high(message: string): void;
+  getFeed(): { push(text: string, priority?: 'high' | 'low', kind?: string): void } | null;
+}
+
+export interface AutonomySurfacingOptions {
+  readonly shellPaths: Parameters<typeof LastSeenStore.fromShellPaths>[0];
+  readonly listAutomationJobs: () => readonly AutomationJobLike[];
+  readonly listApprovals: () => readonly ApprovalLike[];
+  readonly getTasksSnapshot: () => readonly unknown[];
+  readonly router: AutonomyMessageRouter;
+  readonly render: () => void;
+  /**
+   * Optional callback to list upcoming local calendar events.
+   * Each item carries a formatted label and a numeric sort key (ms since epoch)
+   * so the Coming up section merges calendar and job entries chronologically.
+   */
+  readonly listCalendarEvents?: () => readonly { label: string; start: number }[];
+  /**
+   * Optional callback invoked once per announceAwayDigest pass.
+   * Should run skill draft proposal and return the count of drafts created.
+   * When > 0, a line is appended to the digest feed.
+   */
+  readonly onAwayDigest?: () => number;
+}
+
+const COMING_UP_TTL_MS = 60_000;
+const FETCH_TIMEOUT_MS = 2500;
+const LAST_SEEN_REFRESH_MS = 5 * 60_000;
+
+/**
+ * Ambient autonomy surfacing for the shell: the launch "While you were away"
+ * digest and the sidebar's Coming up entries. Everything here is best-effort
+ * and offline-tolerant — failures are silent and renders are never blocked.
+ */
+export function createAutonomySurfacing(options: AutonomySurfacingOptions) {
+  const lastSeenStore = LastSeenStore.fromShellPaths(options.shellPaths);
+
+  // Refresh lastSeenAt every 5 minutes so rapid restarts still detect activity.
+  const lastSeenRefreshInterval = setInterval(() => {
+    lastSeenStore.save();
+  }, LAST_SEEN_REFRESH_MS);
+  lastSeenRefreshInterval.unref();
+
+  const comingUpCache: { items: string[]; fetchedAt: number | null; fetching: boolean } = {
+    items: [],
+    fetchedAt: null,
+    fetching: false,
+  };
+
+  function refreshComingUp(): void {
+    if (comingUpCache.fetching) return;
+    const now = Date.now();
+    if (comingUpCache.fetchedAt !== null && now - comingUpCache.fetchedAt < COMING_UP_TTL_MS) return;
+    comingUpCache.fetching = true;
+    Promise.resolve().then(() => {
+      try {
+        const jobs = options.listAutomationJobs();
+        const jobItems: Array<{ label: string; sortKey: number }> = jobs
+          .filter((job) => job.enabled && job.nextRunAt !== undefined && job.nextRunAt > now)
+          .sort((a, b) => (a.nextRunAt ?? 0) - (b.nextRunAt ?? 0))
+          .map((job) => {
+            const when = job.nextRunAt ? formatRelativeTime(job.nextRunAt, now) : '';
+            const name = job.name.length > 22 ? `${job.name.slice(0, 20)}…` : job.name;
+            return { label: when ? `${name} — ${when}` : name, sortKey: job.nextRunAt ?? 0 };
+          });
+
+        const calItems: Array<{ label: string; sortKey: number }> = [];
+        if (options.listCalendarEvents) {
+          try {
+            for (const ev of options.listCalendarEvents()) {
+              calItems.push({ label: ev.label, sortKey: ev.start });
+            }
+          } catch {
+            // Calendar unavailable — skip silently.
+          }
+        }
+
+        comingUpCache.items = [...jobItems, ...calItems]
+          .sort((a, b) => a.sortKey - b.sortKey)
+          .slice(0, 3)
+          .map((item) => item.label);
+        comingUpCache.fetchedAt = Date.now();
+      } catch {
+        // Offline or manager unavailable — leave cache as-is.
+      } finally {
+        comingUpCache.fetching = false;
+      }
+    }).catch(() => {
+      comingUpCache.fetching = false;
+    });
+  }
+
+  function announceAwayDigest(): void {
+    void (async () => {
+      try {
+        const lastSeenAt = lastSeenStore.read();
+        const withTimeout = <T>(get: () => T) => Promise.race([
+          Promise.resolve(get()),
+          new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), FETCH_TIMEOUT_MS)),
+        ]);
+
+        const [jobsResult, tasksResult] = await Promise.allSettled([
+          withTimeout(options.listAutomationJobs),
+          withTimeout(options.getTasksSnapshot),
+        ]);
+        const jobs = jobsResult.status === 'fulfilled' ? jobsResult.value : [];
+        const allTasks = tasksResult.status === 'fulfilled' ? tasksResult.value : [];
+
+        const firedSchedules = lastSeenAt !== null
+          ? jobs
+            .filter((job) => job.lastRunAt !== undefined && job.lastRunAt > lastSeenAt)
+            .map((job) => ({ name: job.name, lastRunAt: job.lastRunAt, runCount: job.runCount ?? 0 }))
+          : [];
+
+        const changedTasks = lastSeenAt !== null
+          ? allTasks
+            .filter((task) => {
+              const completedAt = (task as { completedAt?: number }).completedAt;
+              return completedAt !== undefined ? completedAt > lastSeenAt : false;
+            })
+            .map((task) => ({
+              title: (task as { title?: string; name?: string }).title
+                ?? (task as { name?: string }).name
+                ?? 'Task',
+              status: (task as { status?: string }).status ?? 'done',
+              completedAt: (task as { completedAt?: number }).completedAt,
+            }))
+          : [];
+
+        const pendingApprovals = options.listApprovals()
+          .filter((approval) => approval.status === 'pending').length;
+
+        const digest = buildAwayDigest({
+          lastSeenAt,
+          schedules: firedSchedules,
+          tasks: changedTasks,
+          pendingApprovals,
+        });
+
+        if (digest !== null) {
+          const full = [digest.headline, ...digest.lines].join('\n  ');
+          options.router.high(`[Status] ${full}`);
+          for (const line of digest.lines) {
+            options.router.getFeed()?.push(`[Status] ${line}`, 'low', 'schedule');
+          }
+          options.render();
+        }
+
+        // Invoke optional skill-draft hook once per pass.
+        if (options.onAwayDigest) {
+          try {
+            const drafted = options.onAwayDigest();
+            if (drafted > 0) {
+              options.router.getFeed()?.push(
+                `[Status] I drafted ${drafted} skill${drafted !== 1 ? 's' : ''} from recent work — review them under Memory`,
+                'low',
+                'schedule',
+              );
+            }
+          } catch {
+            // Skill draft hook failed — skip silently.
+          }
+        }
+      } catch (err) {
+        logger.debug('away-digest failed (non-fatal)', { error: err instanceof Error ? err.message : String(err) });
+      }
+    })();
+  }
+
+  function stop(): void {
+    clearInterval(lastSeenRefreshInterval);
+    lastSeenStore.save();
+  }
+
+  return {
+    refreshComingUp,
+    announceAwayDigest,
+    stop,
+    // Return a defensive copy so callers cannot mutate internal cache state.
+    comingUpItems: (): readonly string[] => [...comingUpCache.items],
+  };
+}
+
+/**
+ * Build the onAwayDigest callback for the given shellPaths and command context.
+ * Extracted so main.ts can pass a single symbol instead of an inline lambda.
+ * (See module-header note for history.)
+ */
+export function buildSkillDraftProposer(
+  shellPaths: Parameters<typeof AgentSkillRegistry.fromShellPaths>[0],
+  context: CommandContext,
+): () => number {
+  return () =>
+    runSkillDraftProposer(
+      context,
+      AgentSkillRegistry.fromShellPaths(shellPaths),
+    ).proposed;
+}
+
+/**
+ * Build the listCalendarEvents callback for the given shellPaths.
+ * Extracts the closure that was previously inlined in main.ts so that
+ * file stays under the 800-line cap.
+ *
+ * The optional `upcomingEvents` parameter is a testability seam: when provided,
+ * it replaces the `registry.upcoming(7)` call so unit tests can inject a
+ * deterministic event set without mocking the module. Production callers omit
+ * this parameter; the default is the real registry lookup.
+ */
+export function buildCalendarEventsLister(
+  shellPaths: Parameters<typeof LastSeenStore.fromShellPaths>[0],
+  upcomingEvents?: () => readonly import('../agent/calendar-registry.ts').AgentCalendarEvent[],
+): () => readonly { label: string; start: number }[] {
+  return () => {
+    const now = Date.now();
+    const registry = AgentCalendarRegistry.fromShellPaths(shellPaths);
+    return (upcomingEvents ?? (() => registry.upcoming(7)))()
+      .map((e) => {
+        const allDay = e.allDay;
+        // Sort key: use local midnight for all-day events so they sort at the
+        // correct local calendar date rather than UTC midnight (which would land
+        // the previous day for timezones east of UTC).
+        // Timed events: parse the ISO string directly; Date.parse handles
+        // offset-bearing strings correctly.
+        const startMs = allDay
+          ? new Date(`${e.start}T00:00:00`).getTime()   // no tz suffix ⇒ local time
+          : Date.parse(e.start);
+        const sortMs = isNaN(startMs) ? now : startMs;
+        // Display: format via local Date methods so the user sees their own
+        // timezone, never a raw stored offset or UTC-shifted string.
+        const label = e.title.length > 22 ? `${e.title.slice(0, 20)}…` : e.title;
+        const when = allDay
+          ? e.start   // date-only string, no time component to misformat
+          : formatDigestTime(startMs, now);
+        return { label: `${label} — ${when}`, start: sortMs };
+      });
+  };
+}

package/src/shell/session-continuity-hints.ts

@@ -18,15 +18,10 @@ interface ShellRemoteSnapshot {
   readonly contracts: readonly ShellRemoteContract[];
 }
 
-interface ShellPanelRecord {
-  readonly id: string;
-}
-
 export function buildShellSessionContinuityHints(
   sessionSnapshot: ShellSessionSnapshot,
   tasksSnapshot: ShellTaskSnapshot,
   remoteSnapshot: ShellRemoteSnapshot,
-  openPanels: readonly ShellPanelRecord[],
 ) {
   return {
     pendingApprovals: sessionSnapshot.pendingApproval ? 1 : 0,
@@ -34,6 +29,5 @@ export function buildShellSessionContinuityHints(
     blockedTasks: tasksSnapshot.tasks.filter((task) => task.status === 'blocked').length,
     remoteContracts: remoteSnapshot.contracts.length,
     remoteRunners: remoteSnapshot.contracts.slice(0, 4).map((contract) => contract.runnerId),
-    openPanels: openPanels.map((panel) => panel.id),
   };
 }

package/src/shell/startup-wiring.ts

@@ -0,0 +1,221 @@
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { HookDispatcher, HookEventPath, HookPhase, HookCategory } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
+import {
+  checkRecoveryFile,
+  formatReturnContextForDisplay,
+  persistConversation,
+  writeRecoveryFile,
+} from '@/runtime/index.ts';
+import type { SessionSnapshot } from '@/runtime/index.ts';
+import {
+  readOnboardingCheckMarker,
+  readOnboardingCompletionMarker,
+} from '../runtime/onboarding/index.ts';
+import { deriveOnboardingState } from '../runtime/onboarding/onboarding-state.ts';
+import { buildSetupIncompleteHint } from '../core/setup-incomplete-hint.ts';
+
+export interface SessionPersistenceAndRecoveryDeps {
+  readonly buildCurrentSessionSnapshot: () => SessionSnapshot;
+  readonly runtime: { readonly sessionId: string; readonly model: string; readonly provider: string };
+  readonly conversation: { readonly title?: string | null };
+  readonly workingDir: string;
+  readonly homeDirectory: string;
+  readonly systemMessageRouter: { high(message: string): void; low(message: string): void };
+  readonly render: () => void;
+  readonly unsubs: Array<() => void>;
+  readonly uiServicesTurns: {
+    on(event: 'TURN_COMPLETED' | 'STREAM_START' | 'STREAM_DELTA', handler: () => void): () => void;
+  };
+  readonly hookDispatcher: HookDispatcher;
+  readonly sessionManager: SessionManager;
+  /**
+   * Called whenever the computed stream-token speed changes so that main.ts
+   * (which owns the render closure) can keep the value up to date.
+   */
+  readonly onStreamSpeedUpdate: (tokensPerSecond: number) => void;
+}
+
+export interface SessionPersistenceAndRecoveryResult {
+  /** Interval handle for the periodic recovery-file writer; clear it on exit. */
+  recoveryInterval: ReturnType<typeof setInterval>;
+  /** True if an unsaved recovery session was found and the user prompt was shown. */
+  recoveryPending: boolean;
+}
+
+/**
+ * Wires streaming-speed event subscriptions, auto-save on turn completion,
+ * and the post-first-render recovery-file check + periodic writer.
+ *
+ * Call AFTER the first render() so that:
+ * - announceAwayDigest has already run
+ * - startHardwareProbe has already fired
+ * - The recovery prompt lands as ambient context, not a startup blocker
+ */
+export function wireSessionPersistenceAndRecovery(
+  deps: SessionPersistenceAndRecoveryDeps,
+): SessionPersistenceAndRecoveryResult {
+  const {
+    buildCurrentSessionSnapshot,
+    runtime,
+    conversation,
+    workingDir,
+    homeDirectory,
+    systemMessageRouter,
+    render,
+    unsubs,
+    uiServicesTurns,
+    hookDispatcher,
+    sessionManager,
+    onStreamSpeedUpdate,
+  } = deps;
+
+  // --- Streaming speed + tool preview wiring ---
+  let streamStartTime = 0;
+  let streamDeltaCount = 0;
+
+  unsubs.push(uiServicesTurns.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 },
+      );
+      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(uiServicesTurns.on('STREAM_START', () => {
+    streamStartTime = Date.now();
+    streamDeltaCount = 0;
+    onStreamSpeedUpdate(0);
+  }));
+  unsubs.push(uiServicesTurns.on('STREAM_DELTA', () => {
+    streamDeltaCount++;
+    const elapsed = (Date.now() - streamStartTime) / 1000;
+    // Note: counts stream deltas, not actual tokens. ~1 delta per token for most providers.
+    onStreamSpeedUpdate(elapsed > 0 ? streamDeltaCount / elapsed : 0);
+  }));
+
+  // Recovery file check: display prompt if an unsaved session exists.
+  // Runs after the first render so the message lands as ambient context.
+  let recoveryPending = false;
+  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;
+  }
+
+  const recoveryInterval = setInterval(() => {
+    const snapshot = buildCurrentSessionSnapshot();
+    writeRecoveryFile(
+      snapshot,
+      runtime.sessionId,
+      conversation.title ?? '',
+      { workingDirectory: workingDir, homeDirectory },
+    );
+  }, 60_000);
+
+  return { recoveryInterval, recoveryPending };
+}
+
+/**
+ * Deps for the setup-incomplete hint, kept narrow so the function is easily
+ * testable and doesn't pull in the full bootstrap context.
+ */
+export interface SetupIncompleteHintDeps {
+  /**
+   * Shell path service — used to locate onboarding marker files.
+   * Must satisfy the minimal interface required by readOnboardingCheckMarker.
+   */
+  readonly shellPaths: Parameters<typeof readOnboardingCheckMarker>[0];
+  /**
+   * Whether a model route is currently configured and usable for chat.
+   * Pass true when the provider registry has a ready model, false otherwise.
+   */
+  readonly providerReady: boolean;
+  /**
+   * Whether a local model route has been detected and is ready for chat.
+   * Pass true when the local-model-cookbook status === 'detected-local-route'.
+   * Omit or pass false when unavailable. Best-effort: errors should produce false.
+   * This mirrors the 'local-model-readiness' plan item in the real buildSetupPlan.
+   */
+  readonly localReady?: boolean;
+  /**
+   * Whether the assistant service (connected host) is known to be running.
+   * Pass true/false for a confirmed live signal; omit or pass null/undefined
+   * when the signal is unreliable or unavailable at startup time.
+   */
+  readonly hostReady?: boolean | null;
+  /** Low-priority message channel — same interface as SystemMessageRouter.low(). */
+  readonly systemMessageRouter: { low(message: string): void };
+}
+
+/**
+ * Derives the current onboarding state from disk markers and, if setup is
+ * in-progress, pushes a plain-language hint to the conversation feed.
+ *
+ * Best-effort: any error is caught silently so startup is never blocked.
+ * Call after the first render, alongside announceAwayDigest.
+ */
+export function wireSetupIncompleteHint(deps: SetupIncompleteHintDeps): void {
+  try {
+    const { shellPaths, providerReady, localReady, hostReady, systemMessageRouter } = deps;
+
+    const checkMarker = readOnboardingCheckMarker(shellPaths, 'user');
+    const completionMarker = readOnboardingCompletionMarker(shellPaths, 'user');
+
+    // Build a minimal plan with BOTH provider-access AND local-model-readiness so
+    // that deriveReadyToChat mirrors the workspace's canonical definition:
+    //   readyToChat = providerItem.ready OR localModelItem.ready
+    //
+    // local-model-readiness uses blocksAutonomy:false so it never becomes a false
+    // blocker when only the local route is available (matching real plan behaviour).
+    // We intentionally skip the full buildSetupPlan (requires CommandContext +
+    // async collectSnapshot) because this is a best-effort ambient hint.
+    const minimalPlan = [
+      {
+        id: 'provider-access',
+        label: 'Model access',
+        status: providerReady ? ('ready' as const) : ('blocked' as const),
+        priority: 20,
+        blocksAutonomy: true,
+        reason: '',
+        nextAction: 'Choose a model to start chatting.',
+        userRoute: 'Agent Workspace -> Start -> Choose main model',
+        modelRoute: '',
+      },
+      {
+        id: 'local-model-readiness',
+        label: 'Local model',
+        status: localReady ? ('ready' as const) : ('recommended' as const),
+        priority: 25,
+        blocksAutonomy: false,
+        reason: '',
+        nextAction: 'Run /agent to set up a local model route.',
+        userRoute: 'Agent Workspace -> Models -> Local models',
+        modelRoute: '',
+      },
+    ];
+
+    const state = deriveOnboardingState({ plan: minimalPlan, checkMarker, completionMarker });
+
+    const hint = buildSetupIncompleteHint(state, hostReady);
+    if (hint === null) return;
+
+    for (const line of hint.lines) {
+      systemMessageRouter.low(`[Setup] ${line}`);
+    }
+  } catch {
+    // Never block startup on hint errors.
+  }
+}

package/src/shell/ui-openers.ts

@@ -3,7 +3,6 @@ import { getProviderIdFromModel } from '../config/provider-model.ts';
 import type { ConversationManager } from '../core/conversation';
 import type { CommandContext } from '../input/command-registry.ts';
 import type { InputHandler } from '../input/handler.ts';
-import type { PanelManager } from '../panels/panel-manager.ts';
 import { EFFORT_DESCRIPTIONS } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import type { MutableRuntimeState } from '@/runtime/index.ts';
@@ -13,13 +12,12 @@ import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config'
 import type { SecretsManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
 import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
+import { buildLocalFitRecommendations, buildSignInRow, LOCAL_REC_PROVIDER } from '../input/model-picker-local-fit.ts';
 import { syncServiceSettingToPlatform } from './service-settings-sync.ts';
-import { agentWorkspaceCategoryForPanel } from '../input/agent-workspace-panel-route.ts';
 
 type WireShellUiOpenersOptions = {
   commandContext: CommandContext;
   input: InputHandler;
-  panelManager: PanelManager;
   conversation: ConversationManager;
   configManager: ConfigManager;
   providerRegistry: ProviderRegistry;
@@ -84,7 +82,6 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   const {
     commandContext,
     input,
-    panelManager,
     conversation,
     configManager,
     providerRegistry,
@@ -190,10 +187,19 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
 
   commandContext.openModelPicker = () => {
     void (async () => {
-      const models = providerRegistry.getSelectableModels();
+      const catalogModels = providerRegistry.getSelectableModels();
       const configuredIds = new Set(getConfiguredProviderIds());
       input.modelPicker.configuredProviders = configuredIds;
-      const providerIds = [...new Set(models.map((m) => m.provider))];
+
+      // CRITICAL GATE: inject synthetic local recommendations ONLY when zero
+      // providers are configured. When any real credential exists these must
+      // not be present in the list. The sign-in row is appended last so it
+      // is always reachable but does not displace hardware-fit entries.
+      const models = configuredIds.size === 0
+        ? [...buildLocalFitRecommendations(), buildSignInRow(), ...catalogModels]
+        : catalogModels;
+
+      const providerIds = [...new Set(models.map((m) => m.provider).filter((p) => p !== LOCAL_REC_PROVIDER))];
       const secretProviderIds = await resolveSecretProviderIds();
       input.modelPicker.configuredViaMap = buildConfiguredViaMap(providerIds, configuredIds, subscriptionManager, secretProviderIds);
       void getPinned().then((pinned) => {
@@ -202,7 +208,11 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
       void input.modelPicker.loadRecentModels().catch(() => {}); // best-effort: prefetch for UI, failure is non-visible
       input.modalOpened('modelPicker');
       input.modelPicker.setTargetInfos(buildModelPickerTargets());
-      input.modelPicker.openAllModels(models, getCurrentModelForPickerTarget());
+      // Pre-select the best-fit local recommendation when no providers are configured.
+      const preSelectId = configuredIds.size === 0 && models.length > 0
+        ? (models[0]?.registryKey ?? models[0]?.id ?? getCurrentModelForPickerTarget())
+        : getCurrentModelForPickerTarget();
+      input.modelPicker.openAllModels(models, preSelectId);
       render();
     })().catch((error: unknown) => {
       commandContext.print?.(`Model picker failed to open: ${error instanceof Error ? error.message : String(error)}`);
@@ -439,36 +449,15 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     render();
   };
 
-  commandContext.openPanelPicker = () => {
-    panelManager.hide();
-    input.panelFocused = false;
+  commandContext.openWorkspacePicker = () => {
     conversation.setSplashSuppressed(false);
-    conversation.log('Panel picker is handled through Agent Workspace. Use /agent for current operator controls.', { fg: '214' });
     input.openAgentWorkspace(commandContext, 'home');
     conversation.rebuildHistory();
     render();
   };
 
-  commandContext.focusPanels = () => {
-    input.panelFocused = false;
-    input.openAgentWorkspace(commandContext, 'home');
-    render();
-  };
-
   commandContext.focusPrompt = () => {
-    input.panelFocused = false;
     input.indicatorFocused = false;
     render();
   };
-
-  commandContext.showPanel = (panelId, pane) => {
-    void pane;
-    panelManager.hide();
-    input.panelFocused = false;
-    conversation.setSplashSuppressed(false);
-    conversation.log(`Panel route "${panelId}" is handled through Agent Workspace. Opening the matching operator area.`, { fg: '214' });
-    input.openAgentWorkspace(commandContext, agentWorkspaceCategoryForPanel(panelId));
-    conversation.rebuildHistory();
-    render();
-  };
 }

package/src/tools/agent-context-policy.ts

@@ -160,7 +160,7 @@ function buildAgentCapabilitiesContract(registry?: ToolRegistry): Record<string,
       },
       {
         area: 'Harness operation',
-        can: 'Discover and use harness modes, slash commands, workspace actions, settings, panels, UI surfaces, keybindings, and model tools.',
+        can: 'Discover and use harness modes, slash commands, workspace actions, settings, UI surfaces, keybindings, and model tools.',
         tools: [optionalTool('agent_harness'), optionalTool('host'), optionalTool('settings'), 'goodvibes_context'],
         inspect: 'agent_harness mode:"modes" query:"capability"',
       },

package/src/tools/agent-harness-background-processes.ts

@@ -658,7 +658,7 @@ export async function runBackgroundProcessAction(context: CommandContext, args:
   const action = readProcessAction(args);
   if (action === 'write') {
     const confirmationError = requireConfirmed(args, 'Background process stdin write');
-    if (confirmationError) throw new Error(confirmationError);
+    if (confirmationError) return { status: 'needs_confirmation', reason: confirmationError, policy: 'Writing stdin to a background process requires confirm:true and explicitUserRequest.' };
     const writeInput = firstManagerFunction(manager, STDIN_WRITE_METHOD_NAMES);
     if (!writeInput) {
       return {
@@ -710,7 +710,7 @@ export async function runBackgroundProcessAction(context: CommandContext, args:
   }
   if (action === 'start' || action === 'spawn' || action === 'run') {
     const confirmationError = requireConfirmed(args, 'Background process start');
-    if (confirmationError) throw new Error(confirmationError);
+    if (confirmationError) return { status: 'needs_confirmation', reason: confirmationError, policy: 'Starting a background process requires confirm:true and explicitUserRequest.' };
     const command = readCommand(args);
     if (!command) throw new Error('Background process start requires command.');
     if (looksLikeSudo(command)) {
@@ -749,7 +749,7 @@ export async function runBackgroundProcessAction(context: CommandContext, args:
 
   if (action === 'stop' || action === 'kill' || action === 'cancel') {
     const confirmationError = requireConfirmed(args, 'Background process stop');
-    if (confirmationError) throw new Error(confirmationError);
+    if (confirmationError) return { status: 'needs_confirmation', reason: confirmationError, policy: 'Stopping a background process requires confirm:true and explicitUserRequest.' };
     const processId = readProcessId(args);
     if (!processId) throw new Error('Background process stop requires processId.');
     const stopped = manager.stop(processId);
@@ -767,7 +767,7 @@ export async function runBackgroundProcessAction(context: CommandContext, args:
 
   if (action === 'wait') {
     const confirmationError = requireConfirmed(args, 'Background process wait');
-    if (confirmationError) throw new Error(confirmationError);
+    if (confirmationError) return { status: 'needs_confirmation', reason: confirmationError, policy: 'Waiting on a background process requires confirm:true and explicitUserRequest.' };
     const processId = readProcessId(args);
     if (!processId) throw new Error('Background process wait requires processId.');
     const timeoutMs = clampTimeout(args.timeoutMs ?? readField(args, 'timeoutMs'), DEFAULT_WAIT_TIMEOUT_MS);