@pellux/goodvibes-tui 1.1.0 → 1.7.0

package/src/core/long-task-notifier.ts

@@ -18,15 +18,21 @@
  * When neither target is available the function is an honest no-op (debug log
  * only; no user-facing error spam).
  *
- * Focus tracking: terminal focus state is not tracked anywhere in the TUI.
- * Notifications therefore fire regardless of whether the terminal window is
- * focused. A future implementation may suppress notifications when the TUI is
- * in the foreground by reading a focus-state ref. // seam: wire focus ref here.
+ * Focus tracking (W2.3): when `focusTracker` is supplied, notifications are
+ * gated the same way as the other unfocused-user alert classes (see
+ * alert-gating.ts) — they fire when the terminal is unfocused or focus state
+ * was never observed, and are suppressed when it's known to be focused,
+ * unless `behavior.notifyOnlyWhenUnfocused` is turned off. `focusTracker` is
+ * optional and defaults to "always fire" (the pre-W2.3 behavior) when
+ * omitted, so existing callers that don't have a FocusTracker in scope are
+ * unaffected.
  */
 
 import { notifyCompletion } from '@pellux/goodvibes-sdk/platform/utils';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import type { FocusTracker } from './focus-tracker.ts';
+import { readNotifyOnlyWhenUnfocused, type ConfigGet } from './alert-gating.ts';
 
 /** Default threshold in seconds. Turns shorter than this do not notify. */
 export const NOTIFY_AFTER_SECONDS_DEFAULT = 60;
@@ -74,6 +80,18 @@ export interface MaybeNotifyLongTaskOptions {
    * skipped silently.
    */
   readonly webhookNotifier?: WebhookNotifier | null;
+
+  /**
+   * Terminal focus tracker (W2.3). When supplied together with `configGet`,
+   * the notification additionally respects behavior.notifyOnlyWhenUnfocused
+   * (default on): suppressed when the terminal is known to be focused, fires
+   * when unfocused or when focus was never observed. Omit both to preserve
+   * pre-W2.3 behavior (always fire once the threshold is met).
+   */
+  readonly focusTracker?: Pick<FocusTracker, 'shouldAlertWhenUnfocused'> | null;
+
+  /** Config reader used only for the notifyOnlyWhenUnfocused gate above. */
+  readonly configGet?: ConfigGet;
 }
 
 /**
@@ -81,13 +99,14 @@ export interface MaybeNotifyLongTaskOptions {
  * exceeds the configured threshold.
  *
  * Returns true when at least one delivery was attempted, false when the
- * call was a no-op (threshold not reached, or off-state).
+ * call was a no-op (threshold not reached, off-state, or focus-gated off —
+ * see `focusTracker`/`configGet` above).
  *
  * PRIVACY: builds message text from structural metadata only (kind, elapsed,
  * status, sessionId). Never includes conversation content.
  */
 export function maybeNotifyLongTask(opts: MaybeNotifyLongTaskOptions): boolean {
-  const { elapsedMs, status, kind, sessionId, thresholdSeconds, webhookNotifier } = opts;
+  const { elapsedMs, status, kind, sessionId, thresholdSeconds, webhookNotifier, focusTracker, configGet } = opts;
 
   // Off-state: 0 disables notifications entirely.
   if (thresholdSeconds === NOTIFY_AFTER_SECONDS_OFF) {
@@ -102,6 +121,14 @@ export function maybeNotifyLongTask(opts: MaybeNotifyLongTaskOptions): boolean {
     return false;
   }
 
+  // Focus gate (W2.3): only applied when both a tracker and a config reader
+  // are supplied. Absent either one, behavior is unchanged from pre-W2.3
+  // (always fire once the threshold is met).
+  if (focusTracker && configGet && readNotifyOnlyWhenUnfocused(configGet) && !focusTracker.shouldAlertWhenUnfocused()) {
+    logger.debug('long-task-notifier: suppressed — terminal focused');
+    return false;
+  }
+
   // Build concise, metadata-only message. No conversation text.
   const statusLabel = status === 'ok' ? 'completed' : 'failed';
   const title = `GoodVibes — ${kind} ${statusLabel}`;

package/src/core/system-message-router.ts

@@ -5,19 +5,26 @@
  * Delivery is resolved from the message KIND ('system' | 'wrfc' |
  * 'operational'), which maps to a configurable routing target
  * (ui.systemMessages / ui.wrfcMessages / ui.operationalMessages, each
- * 'panel' | 'conversation' | 'both'). resolveSystemMessageDelivery() turns that
- * target — plus whether a panel is attached — into a { toPanel, toConversation }
- * decision. The priority ('high' | 'low') only sets the panel emphasis; it does
- * not by itself decide conversation delivery.
+ * 'panel' | 'conversation' | 'both'). resolveSystemMessageDelivery() turns
+ * that target — plus whether a panel is attached — into a { toPanel,
+ * toConversation } decision.
  *
- * Critical override: errors, provider failovers, and compaction/context notices
- * (see FORCE_CONVERSATION_PREFIXES) ALWAYS also reach the main conversation,
- * regardless of target, so the user never has to open the SystemMessagesPanel
- * to discover them.
+ * W6.1 (the purge): the SystemMessagesPanel this router used to optionally
+ * push into was DELETE-disposition (no surviving human surface — a picker
+ * over the old panel registry, not something worth a dedicated console) and
+ * has been removed entirely, so this router now always resolves with
+ * `hasPanel = false`. Per resolveSystemMessageDelivery's own contract that
+ * means EVERY kind/target combination (including 'panel'-only) falls back
+ * to `toConversation: true` — nothing this router routes can vanish; it all
+ * reaches conversation.addTypedSystemMessage(), which the transcript
+ * renders as a navigable system line. This is deliberate, not a regression:
+ * operational chatter that used to be tucked away in a rarely-opened panel
+ * now surfaces inline, same as the messages that were already forced there
+ * (see FORCE_CONVERSATION_PREFIXES below).
  *
  * Usage:
  * ```ts
- * const router = createSystemMessageRouter(conversation, panel);
+ * const router = createSystemMessageRouter(conversation);
  * router.routeSystemMessage('[Provider] anthropic registered', 'low');
  * router.routeSystemMessage('[Session] Saved session abc123', 'high');
  * ```
@@ -33,7 +40,6 @@
  */
 
 import type { ConversationManager } from './conversation';
-import type { SystemMessagesPanel, SystemMessagePriority } from '../panels/system-messages-panel.ts';
 import {
   classifySystemMessageKind,
   classifySystemMessagePriority,
@@ -48,13 +54,15 @@ export type {
   SystemMessageTarget,
 } from '@/runtime/index.ts';
 
+/** Panel emphasis level. Panel delivery was removed in W6.1 (see file doc); kept as the priority vocabulary for callers and for the SDK's delivery-resolution signature. */
+export type SystemMessagePriority = 'high' | 'low';
+
 /**
  * Message categories that are operationally critical enough that the user must
  * see them inline in the main conversation, regardless of the configured
- * routing target (ui.systemMessages defaults to panel-only). Errors, provider
- * failovers, and compaction/context notices fall here: a user should never have
- * to open the SystemMessagesPanel to discover that a turn errored, a provider
- * failed over, or the context was compacted.
+ * routing target. Errors, provider failovers, and compaction/context notices
+ * fall here: a user should never have to go hunting to discover that a turn
+ * errored, a provider failed over, or the context was compacted.
  *
  * Detection is by the stable message prefix tag, mirroring how the SDK
  * classifiers key off message content. This deliberately does NOT force every
@@ -72,13 +80,12 @@ function mustReachConversation(message: string): boolean {
 // ---------------------------------------------------------------------------
 
 /**
- * Routes system messages to the conversation and/or the SystemMessagesPanel
- * based on priority level.
+ * Routes system messages to the conversation based on priority level and
+ * configured target. See file doc for the W6.1 panel removal.
  */
 export class SystemMessageRouter {
   constructor(
     private readonly conversation: ConversationManager,
-    private panel: SystemMessagesPanel | null,
     private readonly getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultSystemMessageTarget,
   ) {}
 
@@ -87,28 +94,26 @@ export class SystemMessageRouter {
   /**
    * Route a system message.
    *
-   * Delivery is resolved from the kind and its configured target; priority only
-   * sets panel emphasis. Critical notices (errors/failover/compaction, see
-   * FORCE_CONVERSATION_PREFIXES) are additionally forced into the conversation.
+   * Delivery is resolved from the kind and its configured target. Critical
+   * notices (errors/failover/compaction, see FORCE_CONVERSATION_PREFIXES)
+   * are additionally forced into the conversation.
    *
    * @param message  - Message text.
-   * @param priority - 'high' | 'low'.
+   * @param priority - 'high' | 'low' (kept for callers; no longer changes
+   *                   delivery now that there is no panel to emphasize on).
    * @param kind     - Classification kind ('system' | 'wrfc' | 'operational');
    *                   used to resolve routing target and conversation navigability.
    */
   routeTypedSystemMessage(
     message: string,
-    priority: SystemMessagePriority,
+    _priority: SystemMessagePriority,
     kind: SystemMessageKind,
   ): void {
     const target = this.getTargetForKind(kind);
-    const delivery = resolveSystemMessageDelivery(target, this.panel !== null);
-    if (delivery.toPanel) {
-      this.panel?.push(message, priority);
-    }
-    // Critical notices (errors, failover, compaction) must surface inline even
-    // when the configured target is panel-only — otherwise a user without the
-    // SystemMessagesPanel open would never see them.
+    // hasPanel is always false post-W6.1 — resolveSystemMessageDelivery's own
+    // contract means every target ('panel' | 'conversation' | 'both')
+    // resolves toConversation: true in that case (see file doc).
+    const delivery = resolveSystemMessageDelivery(target, false);
     const toConversation = delivery.toConversation || mustReachConversation(message);
     if (toConversation) {
       // addTypedSystemMessage threads the kind into the conversation so the
@@ -153,21 +158,6 @@ export class SystemMessageRouter {
   wrfc(message: string, priority: SystemMessagePriority = 'high'): void {
     this.routeTypedSystemMessage(message, priority, 'wrfc');
   }
-
-  /**
-   * Returns the current panel reference.
-   */
-  getPanel(): SystemMessagesPanel | null {
-    return this.panel;
-  }
-
-  /**
-   * Replace the panel reference after construction (late binding).
-   * Pass null to detach the panel.
-   */
-  setPanel(panel: SystemMessagesPanel | null): void {
-    this.panel = panel;
-  }
 }
 
 // ---------------------------------------------------------------------------
@@ -175,17 +165,13 @@ export class SystemMessageRouter {
 // ---------------------------------------------------------------------------
 
 /**
- * Create a SystemMessageRouter wired to the given conversation and panel.
+ * Create a SystemMessageRouter wired to the given conversation.
  *
- * @param conversation - The ConversationManager for high-priority messages.
- * @param panel        - The SystemMessagesPanel for all messages. Can be null
- *                       (router still works; messages to panel are silently
- *                       dropped until a panel is available).
+ * @param conversation - The ConversationManager all routed messages reach.
  */
 export function createSystemMessageRouter(
   conversation: ConversationManager,
-  panel: SystemMessagesPanel | null = null,
   getTargetForKind: (kind: SystemMessageKind) => SystemMessageTarget = defaultSystemMessageTarget,
 ): SystemMessageRouter {
-  return new SystemMessageRouter(conversation, panel, getTargetForKind);
+  return new SystemMessageRouter(conversation, getTargetForKind);
 }

package/src/core/turn-cancellation.ts

@@ -0,0 +1,20 @@
+import type { Orchestrator } from './orchestrator';
+import type { SpokenTurnRuntime } from '../audio/spoken-turn-wiring.ts';
+
+/**
+ * Builds the shared "cancel the active turn" action: stops any in-flight
+ * spoken output, then aborts the orchestrator's turn if one is actively
+ * streaming. Extracted from main.ts so the file can stay under its 800-line
+ * cap while still wiring `commandContext.isGenerating` (see W1.6 FIX 1).
+ */
+export function createCancelGeneration(
+  orchestrator: Orchestrator,
+  spokenTurns: Pick<SpokenTurnRuntime, 'stop'>,
+): () => void {
+  return () => {
+    spokenTurns.stop('Spoken output stopped.');
+    if (orchestrator.isThinking) {
+      orchestrator.abort();
+    }
+  };
+}

package/src/core/turn-event-wiring.ts

@@ -6,7 +6,12 @@ import type { HookDispatcher, HookPhase, HookCategory, HookEventPath } from '@pe
 import type { ConversationManager } from './conversation.ts';
 import { journalPathFor, openTranscriptJournal, type TranscriptJournal } from './transcript-journal.ts';
 import type { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
+import { notifyCompletion } from '@pellux/goodvibes-sdk/platform/utils';
 import { maybeNotifyLongTask, readNotifyAfterSeconds, type LongTaskStatus } from './long-task-notifier.ts';
+import type { FocusTracker } from './focus-tracker.ts';
+import { shouldFireAlert, FORCE_NOTIFY_DURATION_MS } from './alert-gating.ts';
+import { createBudgetBreachNotifier, type BudgetBreachNotifier } from './budget-breach-notifier.ts';
+import { readBudgetAlertUsd } from '../export/cost-utils.ts';
 
 /** Infer the options param of persistConversation to pick up SessionManager correctly. */
 type PersistOptions = NonNullable<Parameters<typeof persistConversation>[5]>;
@@ -14,11 +19,13 @@ type PersistOptions = NonNullable<Parameters<typeof persistConversation>[5]>;
 /** Minimal orchestrator surface required by turn-event wiring. */
 interface TurnOrchestrator {
   readonly lastInputTokens: number;
+  /** Cumulative session usage — same object CostTrackerPanel reads, used here for budget-breach checks. */
+  readonly usage: { readonly input: number; readonly output: number; readonly cacheRead: number; readonly cacheWrite: number };
 }
 
 /** Minimal provider registry surface required by turn-event wiring. */
 interface TurnProviderRegistry {
-  getCurrentModel(): { readonly contextWindow: number };
+  getCurrentModel(): { readonly contextWindow: number; readonly id?: string };
   getContextWindowForModel(model: { readonly contextWindow: number }): number;
 }
 
@@ -57,6 +64,16 @@ export interface WireTurnEventHandlersOptions {
    * when absent.
    */
   readonly webhookNotifier?: WebhookNotifier | null;
+  /**
+   * Terminal focus tracker (W2.3). Gates the long-task, budget-breach, and
+   * agent/chain-failure desktop alerts wired in this module — see
+   * alert-gating.ts. Optional; when absent, none of the new W2.3 alert
+   * behavior is gated by focus (long-task keeps its pre-W2.3 always-fire
+   * behavior, and budget-breach/failure alerts are skipped entirely, since
+   * they are new-in-W2.3 and have no pre-existing unconditional-fire path
+   * to fall back to).
+   */
+  readonly focusTracker?: Pick<FocusTracker, 'shouldAlertWhenUnfocused'> | null;
   /**
    * Minimal test seam: injectable clock for controlling Date.now() in tests.
    * Defaults to the real Date.now when absent.
@@ -94,13 +111,14 @@ export function wireTurnEventHandlers(
   options: WireTurnEventHandlersOptions,
 ): WireTurnEventHandlersResult {
   const {
-    events, conversation, runtime, configManager, hookDispatcher,
+    events, conversation, runtime, configManager, hookDispatcher, orchestrator, providerRegistry,
     workingDir, homeDirectory, sessionManager, gitStatusProvider,
-    lastGitInfoRef, buildSessionContinuityHints, render, webhookNotifier,
+    lastGitInfoRef, buildSessionContinuityHints, render, webhookNotifier, focusTracker,
     _clock = Date.now,
   } = options;
 
   const unsubs: Array<() => void> = [];
+  const configGet = (k: string): unknown => configManager.get(k as Parameters<typeof configManager.get>[0]);
 
   // Create the per-session transcript journal. Path mirrors recovery-file
   // convention (homeDirectory-scoped). Created lazily on first append.
@@ -112,6 +130,13 @@ export function wireTurnEventHandlers(
   // Track turn start time for long-task notification threshold.
   let turnStartTime: number | null = null;
 
+  // Budget-breach edge-trigger checker (W2.3) — one instance per session,
+  // piggybacking on the same TURN_COMPLETED handler as the long-task
+  // notification below rather than adding a second TURN_COMPLETED subscription.
+  const budgetBreachNotifier: BudgetBreachNotifier | null = focusTracker
+    ? createBudgetBreachNotifier({ focusTracker, configGet, webhookNotifier: webhookNotifier ?? null, sessionId: runtime.sessionId })
+    : null;
+
   const refreshGit = (): void => {
     gitStatusProvider.refresh().then((info) => { lastGitInfoRef.value = info; render(); }).catch(() => { /* non-fatal */ });
   };
@@ -140,7 +165,15 @@ export function wireTurnEventHandlers(
       sessionId: runtime.sessionId,
       thresholdSeconds: notifyThreshold,
       webhookNotifier: webhookNotifier ?? null,
+      focusTracker,
+      configGet,
     });
+    // Budget-breach alert (W2.3): edge-triggered, piggybacks on this same
+    // TURN_COMPLETED handler rather than a second subscription.
+    if (budgetBreachNotifier) {
+      const sessionModel = providerRegistry.getCurrentModel().id ?? 'unknown';
+      budgetBreachNotifier.check(orchestrator.usage, sessionModel, readBudgetAlertUsd(configGet));
+    }
     // Auto-save after every LLM turn so kills don't lose the session
     try {
       const snapshot = conversation.toJSON() as { messages: Array<import('./conversation.ts').ConversationMessageSnapshot>; timestamp?: number };
@@ -180,5 +213,33 @@ export function wireTurnEventHandlers(
     refreshGit();
   }));
 
+  // Agent/chain-failure desktop alerts (W2.3). The SDK's WebhookNotifier and
+  // Notifier already fire webhook/Slack/Discord notifications for these two
+  // events unconditionally (attachToRuntimeBus in the SDK's
+  // platform/integrations — pre-existing, not focus-gated: an out-of-band
+  // push to another device is useful regardless of terminal focus). What was
+  // missing was a desktop notification, gated by focus like the other three
+  // alert classes — that's the only thing added here, to avoid double-firing
+  // a webhook that's already covered.
+  if (focusTracker) {
+    unsubs.push(events.agents.on('AGENT_FAILED', (payload) => {
+      if (!shouldFireAlert(focusTracker, configGet, 'behavior.notifyOnAgentFailure')) return;
+      try {
+        notifyCompletion('GoodVibes — agent failed', `agent ${payload.agentId.slice(0, 8)} failed: ${payload.error}`, FORCE_NOTIFY_DURATION_MS);
+      } catch (err) {
+        logger.debug('turn-event-wiring: agent-failure notify error', { error: String(err) });
+      }
+    }));
+    unsubs.push(events.workflows.on('WORKFLOW_CHAIN_FAILED', (payload) => {
+      if (!shouldFireAlert(focusTracker, configGet, 'behavior.notifyOnChainFailure')) return;
+      const kindLabel = payload.failureKind === 'transport' ? 'transient transport error' : payload.reason;
+      try {
+        notifyCompletion('GoodVibes — WRFC chain failed', `chain ${payload.chainId.slice(0, 12)} failed: ${kindLabel}`, FORCE_NOTIFY_DURATION_MS);
+      } catch (err) {
+        logger.debug('turn-event-wiring: chain-failure notify error', { error: String(err) });
+      }
+    }));
+  }
+
   return { refreshGit, unsubs, transcriptJournal };
 }

package/src/export/cost-utils.ts

@@ -151,3 +151,39 @@ export function calcSessionCost(
   const billableInput = inputTokens + cacheRead + cacheWrite;
   return (billableInput * pricing.input + outputTokens * pricing.output) / 1_000_000;
 }
+
+/**
+ * computeBudgetBreach — pure predicate shared by CostTrackerPanel's render-time
+ * "OVER BUDGET" flag and the background budget-breach notifier
+ * (core/budget-breach-notifier.ts), so both agree on exactly one definition
+ * of "over budget". `budgetThreshold <= 0` means no budget is configured
+ * (disabled), which can never be breached.
+ */
+export function computeBudgetBreach(sessionCost: number, budgetThreshold: number): boolean {
+  return budgetThreshold > 0 && sessionCost > budgetThreshold;
+}
+
+/** Read/write access to the `behavior.budgetAlertUsd` TUI-local config key. Plain
+ * callbacks (rather than a ConfigManager reference) so callers can pass a
+ * generic-key-cast wrapper without this module depending on the SDK config types. */
+export interface BudgetAlertConfigAccess {
+  readonly get: (key: string) => unknown;
+  readonly set: (key: string, value: unknown) => void;
+}
+
+/** Default for the `behavior.budgetAlertUsd` synthetic setting: 0 = no budget configured. */
+export const BUDGET_ALERT_USD_DEFAULT = 0;
+
+/**
+ * readBudgetAlertUsd — read the session cost-budget alert threshold (USD) from
+ * config. This is the single source of truth CostTrackerPanel and the
+ * background budget-breach notifier (core/budget-breach-notifier.ts) both
+ * read, so a threshold set via the panel's 'b' key is immediately visible to
+ * the notifier and vice versa. Falls back to BUDGET_ALERT_USD_DEFAULT (off)
+ * when the key is absent or invalid.
+ */
+export function readBudgetAlertUsd(configGet: (key: string) => unknown): number {
+  const raw = configGet('behavior.budgetAlertUsd');
+  const parsed = typeof raw === 'number' ? raw : Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : BUDGET_ALERT_USD_DEFAULT;
+}

package/src/input/command-registry.ts

@@ -7,6 +7,7 @@ import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SelectionItem, SelectionResult, SelectionAction } from './selection-modal.ts';
 import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
+import type { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
@@ -68,6 +69,9 @@ export interface CommandUiActions {
   };
   executeCommand?: (name: string, args: string[]) => Promise<boolean>;
   cancelGeneration?: () => void;
+  /** True while an LLM turn is actively streaming. Used to give Escape
+   *  cancel-turn precedence over a focused panel's own escape handling. */
+  isGenerating?: () => boolean;
   completeModelSelection?: (selection: {
     model: { id: string; provider: string; displayName: string; registryKey: string };
     effort: string;
@@ -75,6 +79,14 @@ export interface CommandUiActions {
     /** Which config target to write the selected model to. Defaults to 'main'. */
     target?: import('./model-picker.ts').ModelPickerTarget;
   }) => void;
+  /**
+   * Commit an embedding-provider selection from the model picker's
+   * 'embeddingProvider' mode (the 'embeddings' target). Deliberately separate
+   * from completeModelSelection — embedding providers are not
+   * ModelDefinition-shaped, so routing them through the same commit path
+   * would require fabricating a fake model object.
+   */
+  completeEmbeddingProviderSelection?: (providerId: string) => void;
   clearScreen?: () => void;
   activatePlan?: (planId: string, task: string) => void;
   requestPermission?: PermissionRequestHandler;
@@ -107,6 +119,13 @@ export interface CommandShellUiOpeners {
     callback: (result: SelectionResult | null) => void,
   ) => void;
   openSettingsModal?: (target?: string) => void;
+  /**
+   * Open a MIGRATE-TO-MODAL surface by name (W6.1 purge skeleton — WO-A/B
+   * command runtimes call this instead of openCommandPanel once their panel
+   * is converted to a ModalFactory config). Threaded from ui-openers.ts the
+   * same way openSettingsModal is.
+   */
+  openModal?: (name: string) => void;
   openSessionPicker?: () => void;
   openProfilePicker?: () => void;
   openShortcutsOverlay?: () => void;
@@ -157,6 +176,18 @@ export interface CommandSessionServices {
    * fresh Orchestrator's zeroed default (W0.9).
    */
   readonly hydrateSessionUsage?: () => void;
+  /** Wave 4 (wo703): the orchestration engine's command-facing facade — see runtime/workstream-services.ts. */
+  readonly workstreamEngine?: import('../runtime/workstream-services.ts').WorkstreamCommandService;
+  /** Wave 5 (wo804): the repo source-tree code index — see runtime/code-index-services.ts. */
+  readonly codeIndexStore?: import('@pellux/goodvibes-sdk/platform/state').CodeIndexStore;
+  /**
+   * Wave 5 (wo805): the MAIN interactive session's per-turn passive-injection
+   * honesty ring — `Orchestrator.getTurnInjections()`, the main-session
+   * counterpart to `AgentRecord.turnInjections` (wo801). `/recall injections`
+   * with no agent id reads this. Optional so command contexts built without an
+   * orchestrator (headless, tests) fall back to the honest empty state.
+   */
+  readonly getMainSessionTurnInjections?: () => readonly import('../renderer/turn-injection.ts').TurnInjectionEntry[];
 }
 
 export interface CommandProviderServices {
@@ -173,6 +204,7 @@ export interface CommandProviderServices {
 export interface CommandWorkspaceUiServices {
   keybindingsManager?: KeybindingsManager;
   fileUndoManager?: FileUndoManager;
+  workspaceCheckpointManager?: WorkspaceCheckpointManager;
   panelManager?: PanelManager;
   profileManager?: import('@pellux/goodvibes-sdk/platform/profiles').ProfileManager;
   bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks').BookmarkManager;
@@ -190,6 +222,11 @@ export interface CommandPlatformConfigServices {
   readonly configManager: ConfigManager;
   readonly voiceProviderRegistry?: VoiceProviderRegistry;
   readonly voiceService?: VoiceService;
+  /** Direct-command consumer (`/search`) alongside the existing agent-tool consumer. */
+  readonly webSearchService?: import('@pellux/goodvibes-sdk/platform/web-search').WebSearchService;
+  /** Direct-command consumer (`/image`) — first production caller of `.generate()`. */
+  readonly mediaProviders?: import('@pellux/goodvibes-sdk/platform/media').MediaProviderRegistry;
+  readonly artifactStore?: import('@pellux/goodvibes-sdk/platform/artifacts').ArtifactStore;
 }
 
 export interface CommandPlatformServices
@@ -202,7 +239,7 @@ export interface CommandOpsServices
 export interface CommandExtensionRegistryServices {
   readonly toolRegistry: ToolRegistry;
   readonly mcpRegistry: McpRegistry;
-  readonly evalRegistry?: import('../panels/eval-panel.ts').EvalRegistry;
+  readonly evalRegistry?: import('../panels/eval-registry.ts').EvalRegistry;
 }
 
 export interface CommandExtensionServices