@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/input/handler-onboarding.ts

@@ -1,10 +1,9 @@
-import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
 import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
 import { getProviderIdFromModel } from '../config/provider-model.ts';
-import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
+import { buildProviderAccountSnapshot } from '../panels/provider-account-snapshot.ts';
 import { OnboardingWizardController, type OnboardingWizardAction, type OnboardingWizardApplyFeedback } from './onboarding/onboarding-wizard.ts';
-import { applyOnboardingRequest, collectOnboardingSnapshot, verifyOnboardingRequest } from '../runtime/onboarding/index.ts';
+import { applyOnboardingRequest, collectOnboardingSnapshot, verifyOnboardingRequest, writeOnboardingCheckMarker } from '../runtime/onboarding/index.ts';
 import type { OnboardingApplyRequest, OnboardingVerificationItem } from '../runtime/onboarding/index.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
 import { captureOnboardingWizardSnapshot, restoreOnboardingWizardSnapshot } from './handler-ui-state.ts';
@@ -156,6 +155,17 @@ export function handleModelPickerCommitForHandler(handler: InputHandler): boolea
   }
 
 export async function handleOnboardingActionForHandler(handler: InputHandler, action: OnboardingWizardAction): Promise<void> {
+    if (action.startsWith('open-agent-workspace:')) {
+      const categoryId = action.slice('open-agent-workspace:'.length);
+      if (handler.commandContext) handler.openAgentWorkspace(handler.commandContext, categoryId);
+      else handler.onboardingWizard.setApplyFeedback({
+        severity: 'warning',
+        title: 'Workspace unavailable',
+        summary: 'The Agent workspace cannot open because the command context is not wired yet.',
+        messages: [`Requested workspace: ${categoryId}`],
+      });
+      return;
+    }
     if (action === 'start-openai-subscription') {
       await handler.handleOpenAiSubscriptionStart();
       return;
@@ -219,7 +229,7 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
       showOnboardingApplyFeedbackForHandler(handler, {
         severity: 'error',
         title: 'Apply failed',
-        summary: 'The wizard could not persist these settings. No service restart was attempted.',
+        summary: 'The wizard could not persist these settings. No connected-host restart was attempted.',
         messages: [error instanceof Error ? error.message : String(error)],
       });
       return;
@@ -240,17 +250,34 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
 
     handler.syncRuntimeFromOnboardingRequest(request);
     handler.onboardingWizard.markApplied();
+    let markerWarning: string | null = null;
+    try {
+      writeOnboardingCheckMarker(handler.uiServices.environment.shellPaths, {
+        scope: 'user',
+        source: 'wizard',
+        mode: request.mode,
+      });
+    } catch (error) {
+      markerWarning = error instanceof Error ? error.message : String(error);
+    }
     handler.onboardingWizard.close();
     for (let index = handler.modalStack.length - 1; index >= 0; index -= 1) {
       if (handler.modalStack[index] === 'onboarding') handler.modalStack.splice(index, 1);
     }
     if (handler.modalStack.length === 0) {
       const returnFocus = handler.modalReturnFocus;
-      handler.panelFocused = returnFocus === 'panel';
+      handler.panelFocused = false;
       handler.indicatorFocused = returnFocus === 'indicator';
       handler.modalReturnFocus = 'prompt';
     }
-    handler.commandContext?.print?.(formatOnboardingApplyCompletionMessage(verificationItems));
+    const completionMessage = formatOnboardingApplyCompletionMessage(verificationItems);
+    handler.commandContext?.print?.(markerWarning
+      ? `${completionMessage}\nSetup check marker could not be written: ${markerWarning}`
+      : completionMessage);
+    if (handler.commandContext) {
+      handler.openAgentWorkspace(handler.commandContext, 'setup');
+      return;
+    }
     handler.requestRender();
   }
 
@@ -275,10 +302,12 @@ export async function refreshOnboardingHydrationForHandler(handler: InputHandler
         },
         providerAccounts: {
           loadSnapshot: () => buildProviderAccountSnapshot({
-            providerRegistry: handler.uiServices.providers.providerRegistry,
-            serviceRegistry: handler.uiServices.platform.serviceRegistry,
-            subscriptionManager: handler.uiServices.platform.subscriptionManager,
-            secretsManager: handler.uiServices.platform.secretsManager,
+            providerModels: handler.uiServices.providers.providerRegistry,
+            services: handler.uiServices.platform.serviceRegistry,
+            subscriptions: handler.uiServices.platform.subscriptionManager,
+            environment: {
+              hasEnvironmentVariable: (name: string) => Boolean(process.env[name]),
+            },
           }),
         },
       });
@@ -300,7 +329,6 @@ export async function refreshOnboardingHydrationForHandler(handler: InputHandler
 export async function handleOpenAiSubscriptionStartForHandler(handler: InputHandler): Promise<void> {
     if (handler.onboardingApplyPending) return;
     handler.onboardingApplyPending = true;
-    let listener: Awaited<ReturnType<typeof createOAuthLocalListener>> | null = null;
     try {
       const started = await beginOpenAICodexLogin();
       handler.uiServices.platform.subscriptionManager.savePending({
@@ -310,12 +338,6 @@ export async function handleOpenAiSubscriptionStartForHandler(handler: InputHand
         redirectUri: started.redirectUri,
         createdAt: Date.now(),
       });
-      listener = await createOAuthLocalListener({
-        expectedState: started.state,
-        host: '127.0.0.1',
-        port: 1455,
-        path: '/auth/callback',
-      }).catch(() => null);
       const browserOpened = await openExternalUrl(started.authorizationUrl);
       await handler.refreshOnboardingHydration({ preserveValues: true, targetStepId: 'provider-access' });
       handler.onboardingWizard.setFieldValue('providers.openai-authorization-url', started.authorizationUrl);
@@ -323,31 +345,14 @@ export async function handleOpenAiSubscriptionStartForHandler(handler: InputHand
       if (providerIndex >= 0) handler.onboardingWizard.setStep(providerIndex);
       handler.requestRender();
 
-      if (listener && browserOpened) {
-        const serial = ++handler.onboardingOpenAiListenerSerial;
-        handler.commandContext?.print?.([
-          'OpenAI subscription sign-in started from onboarding.',
-          '  callback listener: waiting on 127.0.0.1:1455',
-          '  authorizationUrl: shown in the wizard provider step',
-          'You can also paste the callback code or URL into the OpenAI callback field.',
-        ].join('\n'));
-        void handler.completeOpenAiSubscriptionFromListener(listener, started.verifier, serial);
-        listener = null;
-        handler.requestRender();
-        return;
-      }
-
-      listener?.close();
       handler.commandContext?.print?.([
         'OpenAI subscription sign-in started from onboarding.',
         `  browser: ${browserOpened ? 'opened' : 'open failed'}`,
-        `  callback listener: ${listener ? 'ready' : 'unavailable'}`,
+        '  completion: paste callback code or URL into the OpenAI callback field',
         '  authorizationUrl: shown in the wizard provider step',
-        'Paste the callback code or URL into the OpenAI callback field after sign-in.',
       ].join('\n'));
       handler.requestRender();
     } catch (error) {
-      listener?.close();
       handler.commandContext?.print?.([
         'OpenAI subscription sign-in could not start.',
         `  ${error instanceof Error ? error.message : String(error)}`,
@@ -358,51 +363,6 @@ export async function handleOpenAiSubscriptionStartForHandler(handler: InputHand
     }
   }
 
-export async function completeOpenAiSubscriptionFromListenerForHandler(
-  handler: InputHandler,
-    listener: Awaited<ReturnType<typeof createOAuthLocalListener>>,
-    verifier: string,
-    serial: number,
-  ): Promise<void> {
-    try {
-      const callback = await listener.waitForCode();
-      const pending = handler.uiServices.platform.subscriptionManager.getPending('openai');
-      if (!pending || pending.verifier !== verifier || serial !== handler.onboardingOpenAiListenerSerial) return;
-      const token = await exchangeOpenAICodexCode(callback.code, verifier);
-      const now = Date.now();
-      const existing = handler.uiServices.platform.subscriptionManager.get('openai');
-      handler.uiServices.platform.subscriptionManager.saveSubscription({
-        provider: 'openai',
-        accessToken: token.accessToken,
-        refreshToken: token.refreshToken,
-        tokenType: token.tokenType,
-        expiresAt: token.expiresAt,
-        ...(token.scopes ? { scopes: token.scopes } : {}),
-        authMode: 'oauth',
-        overrideAmbientApiKeys: false,
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now,
-      });
-      handler.uiServices.platform.subscriptionManager.clearPending('openai');
-      handler.onboardingOpenAiListenerSerial += 1;
-      handler.commandContext?.print?.([
-        'OpenAI subscription sign-in completed from onboarding.',
-        `  tokenType: ${token.tokenType}`,
-        `  expiresAt: ${token.expiresAt ? new Date(token.expiresAt).toISOString() : 'n/a'}`,
-      ].join('\n'));
-      await handler.refreshOnboardingHydration({ preserveValues: true, targetStepId: 'provider-access' });
-    } catch (error) {
-      handler.commandContext?.print?.([
-        'OpenAI subscription listener could not complete automatically.',
-        `  listener: ${error instanceof Error ? error.message : String(error)}`,
-        'Paste the callback code or URL into the OpenAI callback field to finish in onboarding.',
-      ].join('\n'));
-      handler.requestRender();
-    } finally {
-      listener.close();
-    }
-  }
-
 export async function handleOpenAiSubscriptionFinishForHandler(handler: InputHandler): Promise<void> {
     if (handler.onboardingApplyPending) return;
     const code = extractAuthorizationCode(handler.onboardingWizard.getTextFieldValue('providers.openai-callback-code'));
@@ -455,7 +415,7 @@ export async function handleOpenAiSubscriptionFinishForHandler(handler: InputHan
   }
 
 export function syncRuntimeFromOnboardingRequestForHandler(handler: InputHandler, request: ReturnType<OnboardingWizardController['buildApplyRequest']>): void {
-    const runtime = handler.commandContext?.session.runtime;
+    const runtime = handler.commandContext?.session?.runtime;
     if (!runtime) return;
 
     for (const operation of request.operations) {
@@ -469,12 +429,13 @@ export function syncRuntimeFromOnboardingRequestForHandler(handler: InputHandler
   }
 
 export function getOnboardingConfigValueForHandler(handler: InputHandler, request: OnboardingApplyRequest, key: string): unknown {
-    const config = handler.uiServices.platform.configManager;
+    const configManager: object = handler.uiServices.platform.configManager;
     for (let index = request.operations.length - 1; index >= 0; index -= 1) {
       const operation = request.operations[index];
       if (operation?.kind === 'set-config' && operation.key === key) return operation.value;
     }
-    return config.get(key as never);
+    const get = Reflect.get(configManager, 'get');
+    return typeof get === 'function' ? Reflect.apply(get, configManager, [key]) : undefined;
   }
 
 export function getOnboardingRuntimePostureForHandler(handler: InputHandler, request: OnboardingApplyRequest): OnboardingRuntimePosture {
@@ -487,12 +448,12 @@ export function getOnboardingRuntimePostureForHandler(handler: InputHandler, req
 export async function restartOnboardingExternalServicesIfNeededForHandler(handler: InputHandler, request: OnboardingApplyRequest): Promise<OnboardingVerificationItem[]> {
     const externalServices = handler.uiServices.platform.externalServices;
     const state = externalServices?.inspect();
-    const serviceStatus = state?.daemonStatus?.reason ?? (state?.daemonRunning ? 'connected GoodVibes services appear active' : 'connected GoodVibes services are not verified from this shell');
+    const hostStatus = state?.connectedHostStatus?.reason ?? (state?.connectedHostRunning ? 'connected GoodVibes host appears active' : 'connected GoodVibes host is not verified from this shell');
     return [{
-      id: 'runtime:external-service-owned',
+      id: 'runtime:external-host-owned',
       status: 'pass',
-      message: `GoodVibes Agent did not start, stop, restart, or reconfigure connected services. ${serviceStatus}`,
-      target: 'service',
+      message: `GoodVibes Agent did not start, stop, restart, or reconfigure the connected host. ${hostStatus}`,
+      target: 'host',
     }];
   }
 
@@ -500,11 +461,11 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
     const externalServices = handler.uiServices.platform.externalServices;
     const externalState = externalServices?.inspect();
     return [{
-      id: 'runtime:external-service-owned',
+      id: 'runtime:external-host-owned',
       status: 'pass',
       message: externalState
-        ? 'Connected GoodVibes services are managed outside Agent; Agent onboarding did not request shutdown, startup, restart, bind, or surface changes.'
-        : 'Connected GoodVibes services are managed outside Agent; no local service controller is required for Agent onboarding.',
-      target: 'service',
+        ? 'The connected GoodVibes host is managed outside Agent; Agent onboarding did not request shutdown, startup, restart, bind, or surface changes.'
+        : 'The connected GoodVibes host is managed outside Agent; no local host controller is required for Agent onboarding.',
+      target: 'host',
     }];
   }

package/src/input/handler-shortcuts.ts

@@ -37,12 +37,12 @@ export type GlobalShortcutRouteState = {
   handleBlockCopy: () => void;
   handleBookmark: () => void;
   handleBlockSave: () => void;
-  handleDiffApply: () => boolean;
   handleUndo: () => void;
   handleRedo: () => void;
   handlePaste: () => void;
   handleEscape: () => void;
-  cyclePanelTab: (direction: 'next' | 'prev') => void;
+  cycleAgentWorkspaceCategory: (direction: 'next' | 'prev') => void;
+  dismissAgentWorkspace: () => boolean;
 };
 
 export function handleGlobalShortcutToken(
@@ -87,6 +87,10 @@ export function handleGlobalShortcutToken(
       return true;
 
     case 'panel-close-all': {
+      if (state.dismissAgentWorkspace()) {
+        state.panelFocused = false;
+        return true;
+      }
       const pm = state.panelManager;
       for (const p of pm.getAllOpen()) pm.close(p.id);
       pm.hide();
@@ -96,6 +100,10 @@ export function handleGlobalShortcutToken(
     }
 
     case 'panel-close': {
+      if (state.dismissAgentWorkspace()) {
+        state.panelFocused = false;
+        return true;
+      }
       const pm = state.panelManager;
       const active = pm.getActivePanel();
       if (active) {
@@ -108,16 +116,18 @@ export function handleGlobalShortcutToken(
 
     case 'panel-picker':
       state.commandContext?.openPanelPicker?.();
-      state.panelFocused = state.panelManager.isVisible() && state.panelManager.getAllOpen().length > 0;
+      state.panelFocused = false;
       state.requestRender();
       return true;
 
     case 'panel-tab-next':
-      state.cyclePanelTab('next');
+      state.cycleAgentWorkspaceCategory('next');
+      state.panelFocused = false;
       return true;
 
     case 'panel-tab-prev':
-      state.cyclePanelTab('prev');
+      state.cycleAgentWorkspaceCategory('prev');
+      state.panelFocused = false;
       return true;
 
     case 'history-search':
@@ -154,8 +164,7 @@ export function handleGlobalShortcutToken(
       return true;
     }
 
-    case 'apply-diff-line-start': {
-      if (!state.commandMode && state.handleDiffApply()) return true;
+    case 'line-start': {
       const info = state.getWrappedPromptInfo(state.contentWidth);
       state.cursorPos = info.wrappedLines.length > 1 ? info.segments[info.cursorWrappedLine].rawStart : 0;
       state.ensureInputCursorVisible();

package/src/input/handler.ts

@@ -1,12 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { InputTokenizer } from '@pellux/goodvibes-sdk/platform/core';
-import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config';
-import { clearModalStackForHandler, cleanupMarkerRegistryForHandler, executeBlockActionForHandler, expandPromptForHandler, findMarkerAtPosForHandler, getImageAttachmentsForHandler, handleBlockCopyForHandler, handleBlockRerunForHandler, handleBlockSaveForHandler, handleBlockToggleForHandler, handleBookmarkForHandler, handleCopyForHandler, handleCtrlCForHandler, handleDiffApplyForHandler, handleEscapeForHandler, hydrateOnboardingWizardFromRuntimeForHandler, modalOpenedForHandler, openOnboardingWizardForHandler, registerPasteForHandler } from './handler-interactions.ts';
-import { clearOnboardingModelPickerCancelStateForHandler, clearOnboardingPendingModelPickerTargetForHandler, completeOpenAiSubscriptionFromListenerForHandler, getOnboardingConfigValueForHandler, getOnboardingRuntimePostureForHandler, handleModelPickerCommitForHandler, handleOnboardingActionForHandler, handleOpenAiSubscriptionFinishForHandler, handleOpenAiSubscriptionStartForHandler, openModelPickerWithTargetForHandler, openProviderModelPickerWithTargetForHandler, refreshOnboardingHydrationForHandler, restartOnboardingExternalServicesIfNeededForHandler, restoreOnboardingModelPickerCancelStateForHandler, syncRuntimeFromOnboardingRequestForHandler, verifyOnboardingRuntimePostureForHandler, type OnboardingRuntimePosture } from './handler-onboarding.ts';
-import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
-import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
-import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
+import { clearModalStackForHandler, cleanupMarkerRegistryForHandler, executeBlockActionForHandler, expandPromptForHandler, findMarkerAtPosForHandler, getImageAttachmentsForHandler, handleBlockCopyForHandler, handleBlockRerunForHandler, handleBlockSaveForHandler, handleBlockToggleForHandler, handleBookmarkForHandler, handleCopyForHandler, handleCtrlCForHandler, handleEscapeForHandler, hydrateOnboardingWizardFromRuntimeForHandler, modalOpenedForHandler, openOnboardingWizardForHandler, registerPasteForHandler } from './handler-interactions.ts';
+import { clearOnboardingModelPickerCancelStateForHandler, clearOnboardingPendingModelPickerTargetForHandler, getOnboardingConfigValueForHandler, getOnboardingRuntimePostureForHandler, handleModelPickerCommitForHandler, handleOnboardingActionForHandler, handleOpenAiSubscriptionFinishForHandler, handleOpenAiSubscriptionStartForHandler, openModelPickerWithTargetForHandler, openProviderModelPickerWithTargetForHandler, refreshOnboardingHydrationForHandler, restartOnboardingExternalServicesIfNeededForHandler, restoreOnboardingModelPickerCancelStateForHandler, syncRuntimeFromOnboardingRequestForHandler, verifyOnboardingRuntimePostureForHandler, type OnboardingRuntimePosture } from './handler-onboarding.ts';
 import { SelectionManager } from './selection.ts';
 import type { InfiniteBuffer } from '../core/history.ts';
 import type { CommandRegistry, CommandContext } from './command-registry.ts';
@@ -56,7 +52,6 @@ import {
   handleClipboardPaste,
   handleCopy,
   handleCtrlC,
-  handleDiffApply,
   mediaTypeFromExt,
   registerPaste,
 } from './handler-content-actions.ts';
@@ -164,14 +159,13 @@ export class InputHandler {
   public onboardingModelPickerCancelSnapshot: OnboardingWizardSnapshot | null = null;
   public onboardingHydrationSerial = 0;
   public onboardingApplyPending = false;
-  public onboardingOpenAiListenerSerial = 0;
 
   /**
    * Modal navigation stack. Each element is the name of an open modal.
    * Used to support back-navigation via Escape.
    */
   public modalStack: string[] = [];
-  public modalReturnFocus: 'prompt' | 'panel' | 'indicator' = 'prompt';
+  public modalReturnFocus: 'prompt' | 'indicator' = 'prompt';
   public sessionPickerModal: SessionPickerModal;
   public profilePickerModal: ProfilePickerModal;
   /** True when the help overlay is visible. */
@@ -302,7 +296,6 @@ export class InputHandler {
         handleBlockCopy: () => this.handleBlockCopy(),
         handleBookmark: () => this.handleBookmark(),
         handleBlockSave: () => this.handleBlockSave(),
-        handleDiffApply: () => this.handleDiffApply(),
         handleUndo: () => { this.handleUndo(); this.syncFeedContextMutableFields(); },
         handleRedo: () => { this.handleRedo(); this.syncFeedContextMutableFields(); },
         handlePaste: () => { this.handlePaste(); this.syncFeedContextMutableFields(); },
@@ -310,7 +303,8 @@ export class InputHandler {
         ensureInputCursorVisible: (contentWidth?: number) => this.ensureInputCursorVisible(contentWidth),
         registerPaste: (content: string) => this.registerPaste(content),
         executeBlockAction: (id: string) => this.executeBlockAction(id),
-        cyclePanelTab: (direction: 'next' | 'prev') => this.cyclePanelTab(direction),
+        cycleAgentWorkspaceCategory: (direction: 'next' | 'prev') => this.cycleAgentWorkspaceCategory(direction),
+        dismissAgentWorkspace: () => this.dismissAgentWorkspace(),
         onPanelInputConsumed: (activePanel: Panel | null, key: string) => this.handlePanelIntegrationAction(activePanel, key),
         getWrappedPromptInfo: (contentWidth: number) => this.getWrappedPromptInfo(contentWidth),
         moveCursorVertical: (direction: -1 | 1) => this.moveCursorVertical(direction),
@@ -351,7 +345,7 @@ export class InputHandler {
     this.autocomplete = new AutocompleteEngine(registry);
   }
 
-  /** Wire in the conversation manager for block copy/apply/collapse. */
+  /** Wire in the conversation manager for block copy/collapse. */
   public setConversationManager(cm: ConversationManager): void { this.conversationManager = cm; }
 
   /**
@@ -393,7 +387,6 @@ export class InputHandler {
   public executeBlockAction(actionId: string): void { executeBlockActionForHandler(this, actionId); }
   public handleBlockRerun(): void { handleBlockRerunForHandler(this); }
   public handleBlockToggle(): void { handleBlockToggleForHandler(this); }
-  public handleDiffApply(): boolean { return handleDiffApplyForHandler(this); }
   public handleCtrlC(): void { handleCtrlCForHandler(this); }
   public modalOpened(name: string): void { modalOpenedForHandler(this, name); }
   public clearModalStack(): void { clearModalStackForHandler(this); }
@@ -411,19 +404,37 @@ export class InputHandler {
     this.mcpWorkspace.open(context);
     this.requestRender();
   }
-  public openAgentWorkspace(context: CommandContext): void {
+  public openAgentWorkspace(context: CommandContext, categoryId?: string): void {
     this.panelFocused = false;
     this.indicatorFocused = false;
     this.modalOpened('agentWorkspace');
-    this.agentWorkspace.open(context, (command) => this.dispatchAgentWorkspaceCommand(command, context));
+    this.agentWorkspace.open(
+      context,
+      (command) => this.dispatchAgentWorkspaceCommand(command, context),
+      categoryId,
+      (prompt) => this.dispatchAgentWorkspacePrompt(prompt, context),
+    );
     this.requestRender();
   }
 
-  private dispatchAgentWorkspaceCommand(command: string, context: CommandContext): void {
+  private closeAgentWorkspaceModal(): void {
     this.agentWorkspace.close();
     for (let index = this.modalStack.length - 1; index >= 0; index -= 1) {
       if (this.modalStack[index] === 'agentWorkspace') this.modalStack.splice(index, 1);
     }
+  }
+
+  public dismissAgentWorkspace(): boolean {
+    if (!this.agentWorkspace.active) return false;
+    this.closeAgentWorkspaceModal();
+    this.panelFocused = false;
+    this.indicatorFocused = false;
+    this.requestRender();
+    return true;
+  }
+
+  private dispatchAgentWorkspaceCommand(command: string, context: CommandContext): void {
+    this.closeAgentWorkspaceModal();
     const { name, args } = parseSlashCommand(command);
     if (!name) return;
     void context.executeCommand?.(name, [...args]).catch((error: unknown) => {
@@ -432,11 +443,16 @@ export class InputHandler {
     });
     this.requestRender();
   }
+
+  private dispatchAgentWorkspacePrompt(prompt: string, context: CommandContext): void {
+    this.closeAgentWorkspaceModal();
+    context.submitInput?.(prompt);
+    this.requestRender();
+  }
   public handleModelPickerCommit(): boolean { return handleModelPickerCommitForHandler(this); }
   public async handleOnboardingAction(action: OnboardingWizardAction): Promise<void> { await handleOnboardingActionForHandler(this, action); }
   public async refreshOnboardingHydration(options: { readonly preserveValues?: boolean; readonly targetStepId?: string } = {}): Promise<void> { await refreshOnboardingHydrationForHandler(this, options); }
   public async handleOpenAiSubscriptionStart(): Promise<void> { await handleOpenAiSubscriptionStartForHandler(this); }
-  public async completeOpenAiSubscriptionFromListener(listener: Awaited<ReturnType<typeof createOAuthLocalListener>>, verifier: string, serial: number): Promise<void> { await completeOpenAiSubscriptionFromListenerForHandler(this, listener, verifier, serial); }
   public async handleOpenAiSubscriptionFinish(): Promise<void> { await handleOpenAiSubscriptionFinishForHandler(this); }
   public syncRuntimeFromOnboardingRequest(request: ReturnType<OnboardingWizardController['buildApplyRequest']>): void { syncRuntimeFromOnboardingRequestForHandler(this, request); }
   public getOnboardingConfigValue(request: OnboardingApplyRequest, key: string): unknown { return getOnboardingConfigValueForHandler(this, request, key); }
@@ -696,13 +712,24 @@ export class InputHandler {
    * Word-wrap a single line to fit within maxW columns.
    * Breaks at spaces; words wider than maxW are force-broken.
    */
-  public cyclePanelTab(direction: 'next' | 'prev'): void {
-    const pm = this.uiServices.shell.panelManager;
-    if (pm.isVisible()) {
-      if (direction === 'next') pm.nextWorkspaceTab();
-      else pm.prevWorkspaceTab();
-      this.requestRender();
+  public cycleAgentWorkspaceCategory(direction: 'next' | 'prev'): void {
+    const context = this.commandContext;
+    if (!this.agentWorkspace.active) {
+      if (!context) return;
+      this.panelFocused = false;
+      this.indicatorFocused = false;
+      this.modalOpened('agentWorkspace');
+      this.agentWorkspace.open(
+        context,
+        (command) => this.dispatchAgentWorkspaceCommand(command, context),
+        undefined,
+        (prompt) => this.dispatchAgentWorkspacePrompt(prompt, context),
+      );
     }
+    this.agentWorkspace.cycleCategory(direction);
+    this.panelFocused = false;
+    this.indicatorFocused = false;
+    this.requestRender();
   }
 
   public handlePanelIntegrationAction(activePanel: Panel | null, key: string): void {

package/src/input/input-history.ts

@@ -284,13 +284,12 @@ export class InputHistory {
 
   private normalizeStoredEntry(entry: unknown): StoredInputHistoryEntry | null {
     if (typeof entry === 'string') return entry;
-    if (!entry || typeof entry !== 'object') return null;
-    const record = entry as Record<string, unknown>;
-    if (typeof record.text !== 'string') return null;
-    const text = record.text.trim();
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+    if (!('text' in entry) || typeof entry.text !== 'string') return null;
+    const text = entry.text.trim();
     if (!text) return null;
-    if (typeof record.recallText === 'string' && record.recallText.trim() && record.recallText.trim() !== text) {
-      return { text, recallText: record.recallText.trim() };
+    if ('recallText' in entry && typeof entry.recallText === 'string' && entry.recallText.trim() && entry.recallText.trim() !== text) {
+      return { text, recallText: entry.recallText.trim() };
     }
     return text;
   }

package/src/input/keybindings.ts

@@ -45,7 +45,7 @@ export type KeyAction =
   | 'bookmark'
   | 'block-save'
   | 'delete-word'
-  | 'apply-diff-line-start'
+  | 'line-start'
   | 'next-error-line-end'
   | 'kill-line'
   | 'clear-prompt'
@@ -59,27 +59,40 @@ 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, focus, or hide the panel workspace',
-  'panel-close':            'Close the currently active panel',
-  'panel-close-all':         'Close all open panels',
-  'panel-tab-next':        'Next workspace panel tab',
-  'panel-tab-prev':        'Previous workspace panel tab',
+  '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',
   'history-search':        'Reverse input history search',
   'search':                'Toggle conversation search',
   'block-copy':            'Copy nearest block to clipboard',
   'bookmark':              'Bookmark / unbookmark nearest block',
   'block-save':            'Block file save disabled; copy block or export conversation',
   'delete-word':           'Delete word backward',
-  'apply-diff-line-start': 'Delegate diff changes / move to line start',
+  'line-start':            'Move to start of line',
   'next-error-line-end':   'Navigate to next error / move to line end',
   'kill-line':             'Kill to end of line',
   'clear-prompt':          'Clear the prompt',
   'undo':                  'Undo last prompt edit',
   'redo':                  'Redo last undone edit',
   'paste':                 'Paste from clipboard (image priority)',
-  'replay-panel':          'Open / close the Replay panel',
+  'replay-panel':          'Reserved replay workspace shortcut',
 };
 
+function isKeyAction(action: string): action is KeyAction {
+  return Object.hasOwn(ACTION_DESCRIPTIONS, action);
+}
+
+function isKeyCombo(value: unknown): value is KeyCombo {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  if (!('key' in value) || typeof value.key !== 'string' || value.key.length === 0) return false;
+  if ('ctrl' in value && value.ctrl !== undefined && typeof value.ctrl !== 'boolean') return false;
+  if ('shift' in value && value.shift !== undefined && typeof value.shift !== 'boolean') return false;
+  if ('alt' in value && value.alt !== undefined && typeof value.alt !== 'boolean') return false;
+  return true;
+}
+
 /** Default key bindings for all actions. */
 export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'copy-selection':        [{ key: 'c', ctrl: true, shift: true }],
@@ -96,7 +109,7 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'bookmark':              [{ key: 'b', ctrl: true }],
   'block-save':            [{ key: 's', ctrl: true }],
   'delete-word':           [{ key: 'w', ctrl: true }],
-  'apply-diff-line-start': [{ key: 'a', ctrl: true }],
+  'line-start':            [{ key: 'a', ctrl: true }],
   'next-error-line-end':   [{ key: 'e', ctrl: true }],
   'kill-line':             [{ key: 'k', ctrl: true }],
   'clear-prompt':          [{ key: 'u', ctrl: true }],
@@ -218,11 +231,7 @@ export class KeybindingsManager {
   }
 
   private validateCombos(combos: unknown[]): combos is KeyCombo[] {
-    return combos.every((c) => {
-      if (typeof c !== 'object' || c === null) return false;
-      const combo = c as Record<string, unknown>;
-      return typeof combo['key'] === 'string' && combo['key'].length > 0;
-    });
+    return combos.every(isKeyCombo);
   }
 
   /**
@@ -233,9 +242,10 @@ export class KeybindingsManager {
    *                Expects: { logicalName: string; ctrl?: boolean; shift?: boolean; alt?: boolean }
    */
   matches(
-    action: KeyAction,
+    action: string,
     token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean },
   ): boolean {
+    if (!isKeyAction(action)) return false;
     const combos = this.bindings[action];
     if (!combos) return false;
     return combos.some((combo) => this.comboMatches(combo, token));
@@ -267,7 +277,8 @@ export class KeybindingsManager {
    * getComboLabel — Return a human-readable label for the first combo of an action.
    * Example: { key: 'f', ctrl: true } → "Ctrl+F"
    */
-  getComboLabel(action: KeyAction): string {
+  getComboLabel(action: string): string {
+    if (!isKeyAction(action)) return '(unbound)';
     const combos = this.bindings[action];
     if (!combos?.length) return '(unbound)';
     return this.formatCombo(combos[0]);