@pellux/goodvibes-tui 2.0.20 → 2.1.0

package/src/runtime/services.ts

@@ -19,7 +19,7 @@
  *
  * The SDK's own note on that shape applies here literally: it is a FLOOR, not a
  * ceiling. Everything below the `createClientRuntimeServices` call is what THIS
- * surface adds on top, panels, keybindings, the WRFC controller wired over the
+ * surface adds on top, views, keybindings, the WRFC controller wired over the
  * client's own `agentManager`, the workstream engine, the fleet read model, the
  * voice stack with its local playback sink, the knowledge stack the recall
  * surfaces read. None of those need daemon furniture; they are simply not
@@ -30,7 +30,7 @@
  *
  * `sessionBroker` and `approvalBroker` are still constructed. They are this
  * surface's own record of the sessions it is running and the asks it raised,
- * what the transcript, the session panel and the approval card read. They are
+ * what the transcript, the session browser and the approval card read. They are
  * NOT authoritative: session identity is mirrored to the daemon's spine
  * (register/heartbeat/inputs) and an ask is raised on the daemon
  * (`approvals.raise`) so every other surface can see and answer it. Where the
@@ -65,7 +65,7 @@ import { VoiceProviderRegistry, VoiceService, ensureBuiltinVoiceProviders } from
 import { CacheRegistry, PauseController } from '@pellux/goodvibes-sdk/platform/runtime/memory';
 import { wireMemoryGovernance } from './memory-governance-services.ts';
 import { wireVoiceSetup } from '@pellux/goodvibes-sdk/platform/runtime/operations';
-import { PanelManager } from '../panels/panel-manager.ts';
+import { createViewPanelAdapter } from '../views/view-panel-adapter.ts';
 import { BookmarkManager } from '@pellux/goodvibes-sdk/platform/bookmarks';
 import { ProfileManager } from '@pellux/goodvibes-sdk/platform/profiles';
 import { SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
@@ -79,7 +79,7 @@ import { deriveFeatureStates, bindFeatureSettingsBridge } from '@pellux/goodvibe
 import { createChannelComposition } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { applyProviderOptimizerConfigMode, bindProviderOptimizerFeatureFlag } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { createFleetServices } from '@pellux/goodvibes-terminal-shell';
-import { createWorkstreamServices } from '@pellux/goodvibes-sdk/platform/orchestration';
+import { createFixWorkstreamRunner, createWorkstreamServices } from '@pellux/goodvibes-sdk/platform/orchestration';
 import { codeIndexDbPath, createCodeIndexServices, createStoreRerooter, isCodeInjectionSettingEnabled } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { WorkspaceTrustManager } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { ensureConfiguredModelIsRoutable } from '@pellux/goodvibes-sdk/platform/providers';
@@ -102,7 +102,7 @@ import { createFleetUnionReadModel } from './client/fleet-union.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { VERSION } from '../version.ts';
 import { createSessionConversationRewindPort, hasSessionConversation } from './conversation-rewind-port.ts';
-import { createFleetReadModel } from '../panels/fleet-read-model.ts';
+import { createFleetReadModel } from '../views/fleet-read-model.ts';
 import type { PermissionPromptDecision, PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { RuntimeServicesOptions, RuntimeServices } from './runtime-services-types.ts';
 export type { RuntimeServicesOptions, RuntimeServices } from './runtime-services-types.ts';
@@ -136,7 +136,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   // nothing and keeps the ordering honest.
   const shellPaths = createShellPathService({ workingDirectory, homeDirectory });
   // The surface's own record of the asks it raised, what the approval card and
-  // the panel read. The AUTHORITATIVE record is the daemon's; the raiser below
+  // the modal read. The AUTHORITATIVE record is the daemon's; the raiser below
   // keeps the two in step (see the SDK's client/approval-raiser.ts).
   const approvalBroker = new ApprovalBroker({
     storePath: shellPaths.resolveProjectPath('tui', 'control-plane', 'approvals.json'),
@@ -156,7 +156,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     actor: 'tui',
     sessionId: () => liveSessionIdRef.value,
     // The "local prompt" is this surface's own broker plus the terminal ask:
-    // that is what puts the ask on the approval card and in the panel while the
+    // that is what puts the ask on the approval card and in the modal while the
     // daemon holds the record every other surface reads.
     localPrompt: () => (request) => approvalBroker.requestApproval({
       request,
@@ -218,7 +218,8 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const admitExpensiveWork = (label: string): { allowed: boolean; reason?: string | undefined } =>
     admitExpensiveWorkRef.current?.(label) ?? { allowed: true };
   const isKnowledgeBackgroundPaused = (): boolean => pauseController.isPaused('knowledge-self-improvement');
-  const panelManager = new PanelManager();
+  // The operator API's panels.list / panels.open, answered by the modal views.
+  const viewPanelAdapter = createViewPanelAdapter();
   const keybindingsManager = new KeybindingsManager({
     configPath: shellPaths.resolveUserPath('tui', 'keybindings.json'),
   });
@@ -265,6 +266,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     agentManager,
     configManager,
     projectRoot: workingDirectory,
+    // A chain's fix phase: review findings become a dependency-graph
+    // workstream on the one orchestration engine, composed further down
+    // (createWorkstreamServices); the runner reads it when a fix cycle starts.
+    fixWorkstreamRunner: createFixWorkstreamRunner({ engine: () => orchestrationEngine }),
   });
   agentManager.setWrfcController(wrfcController);
   const sessionBroker = new SharedSessionBroker({
@@ -463,10 +468,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeBus: options.runtimeBus,
     providerRegistry,
   });
-  // What the Fleet panel reads: this surface's own live registry UNION the
+  // What the Agents modal reads: this surface's own live registry UNION the
   // adopted daemon's rows. The daemon runs work no registry here knows about
   // (scheduled jobs, channel-driven runs, sessions other surfaces started, the
-  // external agents it observes), and a panel showing only half the fleet is
+  // external agents it observes), and a modal showing only half the fleet is
   // worse than one showing none, the half it shows looks complete.
   const fleetReadModel = createFleetUnionReadModel({
     local: createFleetReadModel(processRegistry, options.runtimeBus),
@@ -508,7 +513,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
 
   const integrationHelpers = new IntegrationHelperService({
     surface, configManager, automationManager, approvalBroker, sessionBroker, distributedRuntime,
-    remoteRunnerRegistry, remoteSupervisor, panelManager, localUserAuthManager, providerRegistry,
+    remoteRunnerRegistry, remoteSupervisor, panelManager: viewPanelAdapter, localUserAuthManager, providerRegistry,
     serviceRegistry, subscriptionManager, secretsManager,
     runtimeStore: options.runtimeStore, runtimeBus: options.runtimeBus,
     getConversationTitle: options.getConversationTitle,
@@ -568,7 +573,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     runtimeBus: options.runtimeBus,
     runtimeStore: options.runtimeStore,
     runtimeDispatch,
-    panelManager,
+    panelManager: viewPanelAdapter,
     keybindingsManager,
     routeBindings,
     surfaceRegistry,

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

@@ -4,11 +4,10 @@
  * Extracted from main.ts (which sits at the architecture line cap) so the
  * startup wiring there stays within budget. Builds the small counts/paths
  * bundle written into the recovery file so a resumed session can describe what
- * was in flight (pending approvals, active/blocked tasks, remotes, worktrees,
- * open panels) without re-reading live state.
+ * was in flight (pending approvals, active/blocked tasks, remotes, worktrees)
+ * without re-reading live state.
  */
 import type { UiReadModels } from './ui-read-models.ts';
-import type { PanelManager } from '../panels/panel-manager.ts';
 
 /**
  * The continuity summary written into the recovery file. A loose serializable
@@ -17,7 +16,6 @@ import type { PanelManager } from '../panels/panel-manager.ts';
  */
 export function createSessionContinuityHintsBuilder(deps: {
   readonly readModels: UiReadModels;
-  readonly panelManager: Pick<PanelManager, 'getAllOpen'>;
 }): () => Record<string, unknown> {
   return () => {
     const sessionSnapshot = deps.readModels.session.getSnapshot();
@@ -32,7 +30,6 @@ export function createSessionContinuityHintsBuilder(deps: {
       remoteRunners: remoteSnapshot.contracts.slice(0, 4).map((contract) => contract.runnerId),
       worktreeCount: worktreeSnapshot.records.length,
       worktreePaths: worktreeSnapshot.records.slice(0, 3).map((record) => record.path),
-      openPanels: deps.panelManager.getAllOpen().map((panel) => panel.id),
     };
   };
 }

package/src/runtime/session-inbound-inputs.ts

@@ -214,7 +214,7 @@ export class SessionInboundInputPoller {
 }
 
 /** Format the operator-facing narration for an inbound steer, e.g.
- * "steer received from webui (Alice): resize the panel". */
+ * "steer received from webui (Alice): resize the sidebar". */
 export function narrateInboundSteer(steer: InboundSteer): string {
   const surface = steer.surfaceKind ?? steer.surfaceId ?? 'another surface';
   const who = steer.displayName ? ` (${steer.displayName})` : '';

package/src/runtime/session-resume-liveness-confirm.ts

@@ -1,10 +1,10 @@
 /**
  * session-resume-liveness-confirm.ts, the "this session is open somewhere
- * else" check for the session-browser / panel resume seam.
+ * else" check for the session-browser resume seam.
  *
  * `/session resume <id>` already refuses to resume a session whose liveness
  * marker points at another running process, and tells the operator to re-run
- * with `--force`. The panel seam had no such check at all: picking a session
+ * with `--force`. The session-browser seam had no such check at all: picking a session
  * from the browser forked another terminal's live state with no warning. That
  * seam has no argv to carry a `--force`, so it asks the same question as a
  * modal instead.
@@ -17,6 +17,7 @@
 import { checkSessionLiveness } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import type { SessionSurface } from '@/runtime/index.ts';
 import type { SelectionItem, SelectionResult } from '../input/selection-modal.ts';
+import type { ConfirmOptions } from '../input/confirm-dialog.ts';
 
 export type LiveResumeSelectionOpener = (
   title: string,
@@ -54,6 +55,8 @@ export interface ConfirmLiveResumeDeps {
   readonly surface: SessionSurface;
   /** Late-bound: the shell builds its selection opener after the resume handler exists. */
   readonly openSelection: () => LiveResumeSelectionOpener | undefined;
+  /** Late-bound confirm dialog; preferred over the selection list when the shell has one. */
+  readonly confirm?: () => ((options: ConfirmOptions) => Promise<boolean>) | undefined;
   /** Injectable for tests; defaults to this process's own pid. */
   readonly selfPid?: number;
 }
@@ -71,6 +74,15 @@ export async function confirmLiveResume(sessionId: string, deps: ConfirmLiveResu
   const selfPid = deps.selfPid ?? process.pid;
   const liveness = checkSessionLiveness(deps.surface, sessionId);
   if (!liveness.live || liveness.pid === null || liveness.pid === selfPid) return true;
+  const confirm = deps.confirm?.();
+  if (confirm) {
+    return confirm({
+      title: `${LIVE_RESUME_CONFIRM_TITLE}?`,
+      body: `This session appears open in another terminal (pid ${liveness.pid}); resuming will fork its live state. Both terminals would hold their own copy of the conversation from this point on.`,
+      confirmLabel: 'Resume anyway',
+      tone: 'warning',
+    });
+  }
   const open = deps.openSelection();
   if (!open) return true;
   return new Promise<boolean>((resolve) => {

package/src/runtime/startup-typeahead-gate.ts

@@ -0,0 +1,103 @@
+/**
+ * startup-typeahead-gate.ts, keeps keys typed before a startup question
+ * appeared out of that question.
+ *
+ * The crash-recovery offer (recovery-prompt.ts) opens a modal at startup whose
+ * Enter resumes a snapshot. A user who started typing before that modal was
+ * on screen (during boot, or while the first frame was still on its way) is
+ * typing into the composer in their head; routing those keys to the modal
+ * would drop the text and let their Enter answer a question they never saw.
+ *
+ * The gate sits in the stdin path after the terminal-reply filters and before
+ * the input router. While a startup modal is armed it HOLDS keyboard input
+ * that is typeahead, and lets through input that is an answer:
+ *   - anything that arrives before the modal's first frame was painted is
+ *     typeahead by definition;
+ *   - anything within settleMs of that paint is typeahead too (nobody reads a
+ *     question and answers it that fast; it is a keystroke already in flight);
+ *   - a key within burstGapMs of the previous held key continues the same
+ *     burst of typing, and is held with it.
+ * The first key after a pause goes to the modal, and from then on the modal
+ * gets everything. When the modal flow ends, release() hands the held bytes
+ * back and the caller replays them into the normal input path: they land in
+ * the composer exactly as typed, nothing lost and nothing misrouted.
+ *
+ * Mouse reports and focus events are never held: they are not typing, and a
+ * click on the modal is an answer.
+ */
+
+/** Input this soon after the modal's first frame is typeahead. */
+export const TYPEAHEAD_SETTLE_MS = 250;
+/** A key this soon after the previous held key continues the same burst. */
+export const TYPEAHEAD_BURST_GAP_MS = 500;
+
+/** SGR mouse reports and focus in/out reports: never typing. */
+const NON_TYPING = /\x1b\[<\d+;\d+;\d+[Mm]|\x1b\[[IO]/g;
+
+export interface StartupTypeaheadGate {
+  /** A startup modal just opened. Holding starts; ignored when already armed. */
+  arm(): void;
+  /** The render loop painted a frame (only the first one after arm() counts). */
+  framePainted(): void;
+  /** Route one stdin chunk: returns the bytes to route now ('' when held). */
+  filter(chunk: string): string;
+  /** The modal flow ended: stop holding and return what was held. */
+  release(): string;
+  /** True while armed (holding or already passing input to the modal). */
+  readonly armed: boolean;
+}
+
+export interface StartupTypeaheadGateOptions {
+  readonly now?: () => number;
+  readonly settleMs?: number;
+  readonly burstGapMs?: number;
+}
+
+export function createStartupTypeaheadGate(options: StartupTypeaheadGateOptions = {}): StartupTypeaheadGate {
+  const now = options.now ?? Date.now;
+  const settleMs = options.settleMs ?? TYPEAHEAD_SETTLE_MS;
+  const burstGapMs = options.burstGapMs ?? TYPEAHEAD_BURST_GAP_MS;
+  let state: 'idle' | 'holding' | 'passing' = 'idle';
+  let paintedAt: number | null = null;
+  let lastHeldAt: number | null = null;
+  let held = '';
+
+  const isTyping = (chunk: string): boolean => chunk.replace(NON_TYPING, '').length > 0;
+
+  return {
+    get armed() {
+      return state !== 'idle';
+    },
+    arm() {
+      if (state !== 'idle') return;
+      state = 'holding';
+      paintedAt = null;
+      lastHeldAt = null;
+    },
+    framePainted() {
+      if (state === 'holding' && paintedAt === null) paintedAt = now();
+    },
+    filter(chunk) {
+      if (state !== 'holding' || !isTyping(chunk)) return chunk;
+      const t = now();
+      const typeahead = paintedAt === null
+        || t - paintedAt <= settleMs
+        || (lastHeldAt !== null && t - lastHeldAt <= burstGapMs);
+      if (typeahead) {
+        held += chunk;
+        lastHeldAt = t;
+        return '';
+      }
+      state = 'passing';
+      return chunk;
+    },
+    release() {
+      const out = held;
+      held = '';
+      state = 'idle';
+      paintedAt = null;
+      lastHeldAt = null;
+      return out;
+    },
+  };
+}

package/src/runtime/store/domains/domain-read-matrix.ts

@@ -1,5 +1,4 @@
 export const DOMAINS = [
-  'panels',
   'ui-perf',
 ] as const;
 

package/src/runtime/store/domains/index.ts

@@ -36,14 +36,6 @@ export type {
 } from '@/runtime/index.ts';
 export { createInitialOverlaysState } from '@/runtime/index.ts';
 
-export type {
-  PanelId,
-  PanelPosition,
-  PanelState,
-  PanelDomainState,
-} from './panels.ts';
-export { createInitialPanelsState } from './panels.ts';
-
 export type {
   PermissionMode,
   PermissionDecisionMachineState,

package/src/runtime/store/selectors/index.ts

@@ -13,7 +13,6 @@ import type { SessionDomainState } from '@/runtime/index.ts';
 import type { ModelDomainState } from '@/runtime/index.ts';
 import type { ConversationDomainState, TurnState } from '@/runtime/index.ts';
 import type { OverlayDomainState, OverlayId } from '@/runtime/index.ts';
-import type { PanelDomainState, PanelState } from '../domains/panels.ts';
 import type { PermissionDomainState, PermissionMode } from '@/runtime/index.ts';
 import type { TaskDomainState, RuntimeTask, TaskKind } from '@/runtime/index.ts';
 import type { AgentDomainState, RuntimeAgent } from '@/runtime/index.ts';
@@ -53,11 +52,6 @@ export function selectOverlays(state: RuntimeState): OverlayDomainState {
   return state.overlays;
 }
 
-/** Select the full panels domain slice. Casts from Record<string,unknown> to PanelDomainState. */
-export function selectPanels(state: RuntimeState): PanelDomainState {
-  return state.panels as unknown as PanelDomainState;
-}
-
 /** Select the full permissions domain slice. */
 export function selectPermissions(state: RuntimeState): PermissionDomainState {
   return state.permissions;
@@ -269,28 +263,6 @@ export function selectPermissionMode(state: RuntimeState): PermissionMode {
   return state.permissions.mode;
 }
 
-/**
- * Returns all panels that are currently open.
- */
-export function selectActivePanels(state: RuntimeState): PanelState[] {
-  const result: PanelState[] = [];
-  const panelDomain = state.panels as unknown as PanelDomainState;
-  for (const panel of panelDomain.panels.values()) {
-    if (panel.open) {
-      result.push(panel);
-    }
-  }
-  return result;
-}
-
-/**
- * Returns the panel currently holding focus.
- */
-export function selectFocusedPanel(state: RuntimeState): PanelState | undefined {
-  const panelDomain = state.panels as unknown as PanelDomainState;
-  return panelDomain.panels.get(panelDomain.focusedPanelId);
-}
-
 /**
  * Returns whether any overlay is currently visible.
  */

package/src/runtime/store/state.ts

@@ -10,7 +10,6 @@ import type { SessionDomainState } from '@/runtime/index.ts';
 import type { ModelDomainState } from '@/runtime/index.ts';
 import type { ConversationDomainState } from '@/runtime/index.ts';
 import type { OverlayDomainState } from '@/runtime/index.ts';
-import type { PanelDomainState } from './domains/panels.ts';
 import type { PermissionDomainState } from '@/runtime/index.ts';
 import type { TaskDomainState } from '@/runtime/index.ts';
 import type { AgentDomainState } from '@/runtime/index.ts';
@@ -41,7 +40,6 @@ import { createInitialSessionState } from '@/runtime/index.ts';
 import { createInitialModelState } from '@/runtime/index.ts';
 import { createInitialConversationState } from '@/runtime/index.ts';
 import { createInitialOverlaysState } from '@/runtime/index.ts';
-import { createInitialPanelsState } from './domains/panels.ts';
 import { createInitialPermissionsState } from '@/runtime/index.ts';
 import { createInitialTasksState } from '@/runtime/index.ts';
 import { createInitialAgentsState } from '@/runtime/index.ts';
@@ -76,11 +74,6 @@ export interface RuntimeState {
   model: ModelDomainState;
   conversation: ConversationDomainState;
   overlays: OverlayDomainState;
-  /**
-   * TUI panel state. Typed as Record<string,unknown> for SDK RuntimeState
-   * compatibility. Use selectPanels() which casts to PanelDomainState.
-   */
-  panels: Record<string, unknown>;
   permissions: PermissionDomainState;
   tasks: TaskDomainState;
   agents: AgentDomainState;
@@ -118,7 +111,6 @@ export function createInitialRuntimeState(): RuntimeState {
     model: createInitialModelState(),
     conversation: createInitialConversationState(),
     overlays: createInitialOverlaysState(),
-    panels: createInitialPanelsState() as unknown as Record<string, unknown>,
     permissions: createInitialPermissionsState(),
     tasks: createInitialTasksState(),
     agents: createInitialAgentsState(),

package/src/runtime/ui-services.ts

@@ -20,7 +20,6 @@ export interface UiEnvironmentServices {
 
 export interface UiShellServices {
   readonly keybindingsManager: RuntimeServices['keybindingsManager'];
-  readonly panelManager: RuntimeServices['panelManager'];
   readonly processManager: RuntimeServices['processManager'];
   readonly profileManager: RuntimeServices['profileManager'];
   readonly bookmarkManager: RuntimeServices['bookmarkManager'];
@@ -41,7 +40,7 @@ export interface UiProviderServices {
 export interface UiSessionServices {
   readonly sessionManager: RuntimeServices['sessionManager'];
   /**
-   * The panel-facing session READ source is the cross-surface union
+   * The modal-facing session READ source is the cross-surface union
    * facade, not the raw local broker, in adopted-daemon ('external') mode the
    * local broker misses sessions hosted for other surfaces. Sync signature
    * preserved; the facade's cache makes that honest (see session-union-cache.ts).
@@ -115,11 +114,11 @@ export interface UiRuntimeSharedServices {
     readonly distributedRuntime: RuntimeServices['distributedRuntime'];
     readonly remoteRunnerRegistry: RuntimeServices['remoteRunnerRegistry'] & RemoteRunnerRegistry;
     readonly remoteSupervisor: RuntimeServices['remoteSupervisor'] & RemoteSupervisor;
-    /** the shared live process registry backing the Fleet panel. */
+    /** the shared live process registry backing the Agents modal. */
     readonly processRegistry: RuntimeServices['processRegistry'];
-    /** The Fleet panel's read model: local rows union the adopted daemon's. */
+    /** The Agents modal's read model: local rows union the adopted daemon's. */
     readonly fleetReadModel: RuntimeServices['fleetReadModel'];
-    /** The shared runtime event bus, the Fleet panel subscribes to its 'communication' domain for the honest steer-consumed signal. */
+    /** The shared runtime event bus, the Agents modal subscribes to its 'communication' domain for the honest steer-consumed signal. */
     readonly runtimeBus: RuntimeServices['runtimeBus'];
   };
 }
@@ -161,7 +160,6 @@ export function createUiRuntimeServices(
     },
     shell: {
       keybindingsManager: runtimeServices.keybindingsManager,
-      panelManager: runtimeServices.panelManager,
       processManager: runtimeServices.processManager,
       profileManager: runtimeServices.profileManager,
       bookmarkManager: runtimeServices.bookmarkManager,