@pellux/goodvibes-tui 1.0.0 → 1.7.0

package/src/renderer/turn-injection.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-turn knowledge injection record rendering (Wave-5 W5.2, wo803).
+ *
+ * The SDK's passive per-turn retrieval engine (wo801, W5.1 —
+ * packages/sdk/src/platform/agents/turn-knowledge-injection.ts) stores one
+ * `TurnInjectionRecord` per turn on `AgentRecord.turnInjections` (a bounded
+ * ring, default 20 entries) and appends the same record to the agent's
+ * session transcript as `{type:'knowledge_injection', turn, ...record}`.
+ *
+ * `TurnInjectionRecord` itself is not re-exported from the SDK's
+ * `platform/agents` barrel (only `AgentRecord.turnInjections` carries its
+ * structural shape through the already-public `platform/tools` barrel), so
+ * the entry type here is DERIVED from `AgentRecord` rather than imported by
+ * name — this needs no SDK export change.
+ *
+ * Reality check (updated wo805): as of Wave-5 wo805 the TUI's main interactive
+ * session DOES route through this engine. The SDK `Orchestrator` runs per-turn
+ * passive injection on the evolving primary conversation and records each turn
+ * on its own bounded ring, exposed via `Orchestrator.getTurnInjections()` — the
+ * main-session counterpart to `AgentRecord.turnInjections` (there is no
+ * AgentRecord for the primary conversation). `buildMainSessionTurnInjectionsText`
+ * renders that ring for `/recall injections` with no agent id. Spawned agents
+ * (Task-tool runs, automation-triggered runs, session continuations) still
+ * record onto their own `AgentRecord.turnInjections`, rendered per-agent by
+ * `buildTurnInjectionsText` when an explicit agent id is given.
+ */
+import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
+
+/** One TurnInjectionRecord entry, derived from AgentRecord (see module doc). */
+export type TurnInjectionEntry = NonNullable<AgentRecord['turnInjections']>[number];
+
+function fmtN(n: number): string {
+  return n.toLocaleString();
+}
+
+/** Render a single TurnInjectionRecord as one readable line. */
+export function formatTurnInjectionEntry(entry: TurnInjectionEntry): string {
+  const backendTag = entry.embeddingBackend === 'fallback-lexical' ? ' [lexical fallback]' : '';
+  if (entry.injectedIds.length === 0) {
+    // Honest empty state: the engine ran this turn but injected nothing —
+    // distinct from "the engine never ran" (see buildTurnInjectionsText).
+    const reasonText = entry.reason === 'no records cleared relevance floor'
+      ? 'nothing injected this turn — nothing cleared the relevance floor'
+      : `nothing injected this turn — ${entry.reason ?? 'unknown reason'}`;
+    return `  turn ${entry.turn}: ${reasonText}${backendTag} (considered ${entry.candidatesConsidered}, floor ${entry.relevanceFloor})`;
+  }
+  const droppedStr = entry.droppedForBudget.length > 0
+    ? `, dropped for budget: ${entry.droppedForBudget.join(', ')}`
+    : '';
+  // The retrieval query is part of the record's honesty contract — without it
+  // an injected line can't be traced back to WHY those ids were retrieved
+  // (Wave-5 replay flagged the omission). Truncated to keep the line scannable.
+  const queryStr = entry.query ? ` for ${JSON.stringify(truncateQuery(entry.query))}` : '';
+  return (
+    `  turn ${entry.turn}: injected ${entry.injectedIds.join(', ')}${queryStr} ` +
+    `(~${fmtN(entry.tokenCost)}/${fmtN(entry.budgetTokens)} tok, floor ${entry.relevanceFloor})${droppedStr}${backendTag}`
+  );
+}
+
+function truncateQuery(query: string): string {
+  const flat = query.replace(/\s+/g, ' ').trim();
+  return flat.length > 48 ? `${flat.slice(0, 47)}…` : flat;
+}
+
+/**
+ * Render the full per-turn injection history for one agent, most-recent-turn
+ * first, with an honest empty state when nothing has been recorded yet.
+ *
+ * An empty `entries` array is deliberately ambiguous about WHY it's empty
+ * (flag disabled, no turn with new input has run yet, or every turn's token
+ * budget had no headroom) — the SDK does not distinguish these cases in the
+ * ring itself, so this renders all three possibilities rather than guessing.
+ */
+export function buildTurnInjectionsText(agentId: string, entries: readonly TurnInjectionEntry[]): string {
+  if (entries.length === 0) {
+    return (
+      `[recall] No per-turn injection records for agent ${agentId} yet. This means one of: ` +
+      'passive knowledge injection is disabled, no turn with new input has run yet, or the ' +
+      'token budget had no headroom on every turn so far — there is no record either way.'
+    );
+  }
+  const lines = [`[recall] Per-turn knowledge injections for agent ${agentId} (${entries.length}, most recent first):`];
+  for (const entry of [...entries].reverse()) {
+    lines.push(formatTurnInjectionEntry(entry));
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Render the MAIN interactive session's per-turn injection ring
+ * (`Orchestrator.getTurnInjections()`, wo805), most-recent-turn first, with the
+ * same honest empty state as the per-agent path. The main-session counterpart
+ * to {@link buildTurnInjectionsText}: no agent id, main-session-appropriate
+ * wording, but the identical per-entry rendering (`formatTurnInjectionEntry`).
+ *
+ * As with the agent path, an empty `entries` array is deliberately ambiguous
+ * about WHY it's empty (flag disabled, no turn with new input has run yet, or
+ * every turn's token budget had no headroom) — the ring does not distinguish
+ * these, so this renders all three possibilities rather than guessing.
+ */
+export function buildMainSessionTurnInjectionsText(entries: readonly TurnInjectionEntry[]): string {
+  if (entries.length === 0) {
+    return (
+      '[recall] No per-turn injection records for the main session yet. This means one of: ' +
+      'passive knowledge injection is disabled, no turn with new input has run yet, or the ' +
+      'token budget had no headroom on every turn so far — there is no record either way.'
+    );
+  }
+  const lines = [`[recall] Per-turn knowledge injections for the main session (${entries.length}, most recent first):`];
+  for (const entry of [...entries].reverse()) {
+    lines.push(formatTurnInjectionEntry(entry));
+  }
+  return lines.join('\n');
+}

package/src/renderer/ui-factory.ts

@@ -8,13 +8,36 @@ import { GLYPHS, UI_TONES } from './ui-primitives.ts';
 import { formatElapsed } from '../utils/format-elapsed.ts';
 import { abbreviateCount } from '../utils/format-number.ts';
 import { computeContextUsage } from '../core/context-usage.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 import { buildFooterTip, isAgentActive } from './footer-tips.ts';
+import type { StreamMetrics } from '../core/stream-event-wiring.ts';
 
 /** Number of frames before the animated gradient completes one full cycle. */
 const GRADIENT_CYCLE_FRAMES = 50;
 /** Number of frames before rotating to the next thinking phrase (~30 seconds at 80ms/frame). */
 const PHRASE_ROTATION_FRAMES = 375;
+/**
+ * Ms since the last STREAM_DELTA before the whimsical phrase rotation freezes
+ * and createThinkingFragment shows an honest "stalled Ns" / "reconnecting"
+ * label instead. Deliberately much shorter than the 30s stream-stall-watchdog
+ * hint threshold (stream-stall-watchdog.ts) — that threshold gates a
+ * low-priority system message about a likely-dead connection; this one gates
+ * a cosmetic label so the UI stops claiming "Vibing..." within a couple of
+ * seconds of real silence, well before the stall is confirmed as a problem.
+ */
+const THINKING_STALL_FREEZE_MS = 2_500;
+
+/**
+ * Stall/reconnect state for the live thinking indicator, computed by the
+ * caller every render frame from streamMetrics (see stream-event-wiring.ts).
+ * `reconnect` is populated only once the SDK's STREAM_RETRY event fires
+ * (structurally consumed — absent from SDK 0.35.0's TurnEvent union today).
+ */
+export interface ThinkingStallInfo {
+  /** Ms since the last STREAM_DELTA (or STREAM_START if none yet this turn). */
+  readonly msSinceLastDelta: number;
+  readonly reconnect?: { readonly attempt: number; readonly maxAttempts: number };
+}
 
 /** Build the git segment string and its display width. Single source of truth for header layout. */
 function buildGitSegment(gitInfo: GitHeaderInfo): { text: string; width: number } {
@@ -313,7 +336,15 @@ export class UIFactory {
     const cw = u.cacheWrite ?? 0;
     const total = inp + out + cr + cw;
     const tokenSep = ` ${GLYPHS.navigation.pipeSeparator} `;
-    const costSegment = model ? `${tokenSep}~$${fmtCost(calcSessionCost(inp, out, cr, cw, model))}` : '';
+    // 'n/a' (not 'unpriced') to stay compact in the single-line footer and
+    // match the existing "no priceable data" convention used elsewhere
+    // (cockpit-panel formatCost, agent-inspector-shared) — the footer has no
+    // room for a longer marker before truncation kicks in.
+    const costSegment = model
+      ? isModelPriced(model)
+        ? `${tokenSep}~$${fmtCost(calcSessionCost(inp, out, cr, cw, model))}`
+        : `${tokenSep}~n/a`
+      : '';
     const tokenLine = ` Token Usage [ Input: ${fmtNum(inp)}${tokenSep}Output: ${fmtNum(out)}${tokenSep}Cache Read: ${fmtNum(cr)}${tokenSep}Cache Write: ${fmtNum(cw)}${tokenSep}Total: ${fmtNum(total)}${costSegment} ]`;
     const copiedNotice = isRecentlyCopied ? ` [COPIED] ` : '';
     const statsLine = '  ' + tokenLine + ' '.repeat(Math.max(0, width - 4 - getDisplayWidth(tokenLine) - getDisplayWidth(copiedNotice))) + copiedNotice;
@@ -345,7 +376,11 @@ export class UIFactory {
         ctxParts.push(model + (provider ? ` (${provider})` : ''));
       }
       if (toolCount) ctxParts.push(`${toolCount} tools`);
-      if (hitlMode) ctxParts.push(`hitl:${hitlMode}`);
+      // Labeled "notify" (not "hitl") — /mode (aliased /hitl) governs UX
+      // notification verbosity (quiet/balanced/operator), not tool
+      // auto-approval, so it must not share vocabulary with the DANGER MODE
+      // risk banner rendered a few lines below.
+      if (hitlMode) ctxParts.push(`notify:${hitlMode}`);
       const ctxLine = '   ' + ctxParts.join(`  ${GLYPHS.navigation.pipeSeparator}  `);
       lines.push(this.stringToLine(truncateDisplay(ctxLine, width), width, { fg: '240', dim: true }));
     }
@@ -406,10 +441,59 @@ export class UIFactory {
   private static readonly THINK_GRADIENT_START = UI_TONES.accent.gradientStart;
   private static readonly THINK_GRADIENT_END = UI_TONES.accent.gradientEnd;
 
-  public static createThinkingFragment(width: number, spinner: string, frame: number = 0, tokenSpeed?: number, toolPreview?: string, inputTokens?: number, outputTokens?: number, elapsedMs?: number, ttftMs?: number): Line[] {
-    // Rotate phrase every ~30 seconds (frame ticks at 80ms, so ~375 frames)
-    const phraseIndex = Math.floor(frame / PHRASE_ROTATION_FRAMES) % this.THINKING_PHRASES.length;
-    const phrase = this.THINKING_PHRASES[phraseIndex];
+  /**
+   * Per-frame stall info from stream metrics — computed from lastDeltaAtMs every render (not
+   * from any event) so it degrades gracefully with zero new SDK events. Undefined until the
+   * first delta clock exists this turn.
+   */
+  public static computeStallInfo(lastDeltaAtMs: number | undefined, reconnectAttempt: number | undefined, reconnectMaxAttempts: number | undefined, nowMs: number): ThinkingStallInfo | undefined {
+    if (lastDeltaAtMs === undefined) return undefined;
+    const reconnect = reconnectAttempt !== undefined && reconnectMaxAttempts !== undefined
+      ? { attempt: reconnectAttempt, maxAttempts: reconnectMaxAttempts }
+      : undefined;
+    return { msSinceLastDelta: nowMs - lastDeltaAtMs, reconnect };
+  }
+
+  /**
+   * Render-frame stall-info decision used at the main render loop's call
+   * site: suppress stall detection entirely while a tool is actively
+   * executing. lastDeltaAtMs only tracks STREAM_START/STREAM_DELTA and is
+   * never advanced during tool execution (the model isn't producing tokens
+   * then), so without this gate any tool call longer than
+   * THINKING_STALL_FREEZE_MS would make the thinking fragment print
+   * "Stalled Ns..." directly above the ticking "executing (Ns)" tool row — a
+   * false positive during ordinary tool execution (see stream-event-wiring.ts
+   * TOOL_EXECUTING/TOOL_SUCCEEDED/TOOL_FAILED/TOOL_CANCELLED handlers).
+   * Genuine no-delta silence while waiting on the provider — including the
+   * pre-first-token case, where lastDeltaAtMs is seeded at STREAM_START —
+   * still stall-detects normally here, since no tool is active then; that is
+   * the honest stall case this indicator exists for.
+   */
+  public static computeRenderStallInfo(
+    metrics: Pick<StreamMetrics, 'activeToolName' | 'lastDeltaAtMs' | 'reconnectAttempt' | 'reconnectMaxAttempts'>,
+    nowMs: number,
+  ): ThinkingStallInfo | undefined {
+    return metrics.activeToolName === undefined
+      ? this.computeStallInfo(metrics.lastDeltaAtMs, metrics.reconnectAttempt, metrics.reconnectMaxAttempts, nowMs)
+      : undefined;
+  }
+
+  public static createThinkingFragment(width: number, spinner: string, frame: number = 0, tokenSpeed?: number, toolPreview?: string, inputTokens?: number, outputTokens?: number, elapsedMs?: number, ttftMs?: number, stallInfo?: ThinkingStallInfo): Line[] {
+    // Freeze the whimsical phrase rotation once real silence has gone on
+    // long enough to be misleading (THINKING_STALL_FREEZE_MS), and show an
+    // honest label instead: the SDK's reconnect attempt/maxAttempts once
+    // STREAM_RETRY is available, else a plain elapsed-silence readout.
+    const isStalled = stallInfo !== undefined && stallInfo.msSinceLastDelta >= THINKING_STALL_FREEZE_MS;
+    let phrase: string;
+    if (stallInfo?.reconnect) {
+      phrase = `Reconnecting (attempt ${stallInfo.reconnect.attempt}/${stallInfo.reconnect.maxAttempts})...`;
+    } else if (isStalled) {
+      phrase = `Stalled ${Math.floor(stallInfo.msSinceLastDelta / 1000)}s...`;
+    } else {
+      // Rotate phrase every ~30 seconds (frame ticks at 80ms, so ~375 frames)
+      const phraseIndex = Math.floor(frame / PHRASE_ROTATION_FRAMES) % this.THINKING_PHRASES.length;
+      phrase = this.THINKING_PHRASES[phraseIndex];
+    }
     const speedSuffix = (tokenSpeed !== undefined && tokenSpeed > 0) ? ` (${Math.round(tokenSpeed)} tok/s)` : '';
     const elapsedSuffix = elapsedMs !== undefined ? ` (${formatElapsed(elapsedMs)})` : '';
     const ttftSuffix = (ttftMs !== undefined && ttftMs > 0) ? ` ttft:${ttftMs}ms` : '';

package/src/runtime/bootstrap-command-context.ts

@@ -16,6 +16,7 @@ import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { ForensicsRegistry } from '@/runtime/index.ts';
 import type { PolicyRuntimeState } from '@/runtime/index.ts';
 import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
+import type { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import type { IntegrationHelperService } from '@/runtime/index.ts';
@@ -61,6 +62,10 @@ export type CreateBootstrapCommandContextOptions = {
   mcpRegistry: McpRegistry;
   voiceProviderRegistry?: VoiceProviderRegistry;
   voiceService?: VoiceService;
+  /** B31: direct-command consumers (`/search`, `/image`) of already-constructed RuntimeServices. */
+  webSearchService?: import('@pellux/goodvibes-sdk/platform/web-search').WebSearchService;
+  mediaProviders?: import('@pellux/goodvibes-sdk/platform/media').MediaProviderRegistry;
+  artifactStore?: import('@pellux/goodvibes-sdk/platform/artifacts').ArtifactStore;
   forensicsRegistry: ForensicsRegistry;
   policyRuntimeState: PolicyRuntimeState;
   readModels: UiReadModels;
@@ -68,6 +73,7 @@ export type CreateBootstrapCommandContextOptions = {
   remoteRuntime?: RemoteCommandService;
   planRuntime?: PlanRuntimeService;
   fileUndoManager: FileUndoManager;
+  workspaceCheckpointManager?: WorkspaceCheckpointManager;
   memoryRegistry?: MemoryRegistry;
   integrationHelpers?: IntegrationHelperService;
   automationManager?: ShellAutomationManagerRuntimeService;
@@ -114,6 +120,10 @@ export type CreateBootstrapCommandContextOptions = {
   sessionLineageTracker?: import('@pellux/goodvibes-sdk/platform/core').SessionLineageTracker;
   wrfcController?: import('@pellux/goodvibes-sdk/platform/agents').WrfcController;
   componentHealthMonitor: import('@/runtime/index.ts').ComponentHealthMonitor;
+  hydrateSessionUsage?: () => void;
+  workstreamEngine?: import('./workstream-services.ts').WorkstreamCommandService;
+  codeIndexStore?: import('@pellux/goodvibes-sdk/platform/state').CodeIndexStore;
+  getMainSessionTurnInjections?: () => readonly import('../renderer/turn-injection.ts').TurnInjectionEntry[];
 };
 
 export function createBootstrapCommandContext(
@@ -131,6 +141,9 @@ export function createBootstrapCommandContext(
     mcpRegistry,
     voiceProviderRegistry,
     voiceService,
+    webSearchService,
+    mediaProviders,
+    artifactStore,
     forensicsRegistry,
     policyRuntimeState,
     readModels,
@@ -138,6 +151,7 @@ export function createBootstrapCommandContext(
     remoteRuntime,
     planRuntime,
     fileUndoManager,
+    workspaceCheckpointManager,
     memoryRegistry,
     integrationHelpers,
     automationManager,
@@ -167,6 +181,10 @@ export function createBootstrapCommandContext(
     sessionLineageTracker,
     wrfcController,
     changeTracker,
+    hydrateSessionUsage,
+    workstreamEngine,
+    codeIndexStore,
+    getMainSessionTurnInjections,
     planManager,
     adaptivePlanner,
     sessionOrchestration,
@@ -223,6 +241,10 @@ export function createBootstrapCommandContext(
     sessionLineageTracker,
     wrfcController,
     changeTracker,
+    hydrateSessionUsage,
+    workstreamEngine,
+    codeIndexStore,
+    getMainSessionTurnInjections,
   });
   const provider = createBootstrapCommandProviderSection({
     providerRegistry,
@@ -233,6 +255,7 @@ export function createBootstrapCommandContext(
   const workspace = createBootstrapCommandWorkspaceSection({
     keybindingsManager,
     fileUndoManager,
+    workspaceCheckpointManager,
     panelManager,
     profileManager,
     bookmarkManager,
@@ -240,7 +263,7 @@ export function createBootstrapCommandContext(
     projectPlanningProjectId,
     workPlanStore,
   }, shellServices);
-  const platform = createBootstrapCommandPlatformSection({ configManager, voiceProviderRegistry, voiceService }, shellServices);
+  const platform = createBootstrapCommandPlatformSection({ configManager, voiceProviderRegistry, voiceService, webSearchService, mediaProviders, artifactStore }, shellServices);
   const extensions = createBootstrapCommandExtensionsSection({
     toolRegistry,
     mcpRegistry,

package/src/runtime/bootstrap-command-parts.ts

@@ -16,7 +16,8 @@ import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/pe
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { ForensicsRegistry } from '@/runtime/index.ts';
 import type { PolicyRuntimeState } from '@/runtime/index.ts';
-import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
+import type { CodeIndexStore, FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
+import type { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import type { IntegrationHelperService } from '@/runtime/index.ts';
@@ -79,11 +80,16 @@ export interface BootstrapCommandSectionOptions {
   readonly mcpRegistry: McpRegistry;
   readonly voiceProviderRegistry?: VoiceProviderRegistry;
   readonly voiceService?: VoiceService;
+  /** B31: direct-command consumers (`/search`, `/image`) of already-constructed RuntimeServices. */
+  readonly webSearchService?: import('@pellux/goodvibes-sdk/platform/web-search').WebSearchService;
+  readonly mediaProviders?: import('@pellux/goodvibes-sdk/platform/media').MediaProviderRegistry;
+  readonly artifactStore?: import('@pellux/goodvibes-sdk/platform/artifacts').ArtifactStore;
   readonly forensicsRegistry: ForensicsRegistry;
   readonly policyRuntimeState: PolicyRuntimeState;
   readonly readModels: UiReadModels;
   readonly shellPaths: ShellPathService;
   readonly fileUndoManager: FileUndoManager;
+  readonly workspaceCheckpointManager?: WorkspaceCheckpointManager;
   readonly memoryRegistry?: MemoryRegistry;
   readonly integrationHelpers?: IntegrationHelperService;
   readonly knowledgeService?: KnowledgeService;
@@ -109,6 +115,10 @@ export interface BootstrapCommandSectionOptions {
   readonly sessionLineageTracker?: import('@pellux/goodvibes-sdk/platform/core').SessionLineageTracker;
   readonly wrfcController?: import('@pellux/goodvibes-sdk/platform/agents').WrfcController;
   readonly changeTracker?: import('@pellux/goodvibes-sdk/platform/sessions').SessionChangeTracker;
+  readonly hydrateSessionUsage?: () => void;
+  readonly workstreamEngine?: import('./workstream-services.ts').WorkstreamCommandService;
+  readonly codeIndexStore?: CodeIndexStore;
+  readonly getMainSessionTurnInjections?: () => readonly import('../renderer/turn-injection.ts').TurnInjectionEntry[];
   readonly agentManager?: ShellAgentManagerService;
   readonly modeManager?: ShellModeManagerService;
   readonly automationManager?: ShellAutomationManagerRuntimeService;
@@ -181,8 +191,15 @@ export function createBootstrapCommandActions(
   } = options;
 
   const showPanel = (panelId: string, pane?: 'top' | 'bottom') => {
+    // W6.1 (the purge): a MIGRATE-TO-MODAL id resolves to a modal, not a panel.
+    // panelManager.open() fires the injected openModal callback and returns a
+    // no-op sentinel — so skip panelManager.show() (which would reveal an empty
+    // panel workspace behind the modal) when this id redirects. Keeps every
+    // showPanel-based front-door (openHooksPanel/openSecurityPanel/… and the
+    // migrated command runtimes) opening the modal cleanly.
+    const redirected = panelManager.getModalRedirect(panelId) !== undefined;
     panelManager.open(panelId, pane);
-    panelManager.show();
+    if (!redirected) panelManager.show();
     requestRender();
   };
 
@@ -278,11 +295,15 @@ export function createBootstrapCommandActions(
     openMemoryPanel: () => {
       showPanel('memory');
     },
+    // W6.1: remote/subscription migrated to config-modal surfaces. open() hits
+    // the modal redirect and invokes the openModal callback — do NOT go through
+    // showPanel here, which would additionally reveal + focus an (empty) panel
+    // workspace behind the fullscreen modal.
     openRemotePanel: () => {
-      showPanel('remote');
+      panelManager.open('remote');
     },
     openSubscriptionPanel: () => {
-      showPanel('subscription');
+      panelManager.open('subscription');
     },
     openLocalAuthMaskedEntry: (kind, username) => {
       showPanel('local-auth');
@@ -300,7 +321,7 @@ export function createBootstrapCommandActions(
 export function createBootstrapCommandSessionSection(
   options: Pick<
     BootstrapCommandSectionOptions,
-    'conversation' | 'runtime' | 'sessionManager' | 'sessionMemoryStore' | 'sessionLineageTracker' | 'wrfcController' | 'changeTracker'
+    'conversation' | 'runtime' | 'sessionManager' | 'sessionMemoryStore' | 'sessionLineageTracker' | 'wrfcController' | 'changeTracker' | 'hydrateSessionUsage' | 'workstreamEngine' | 'codeIndexStore' | 'getMainSessionTurnInjections'
   >,
 ): BootstrapCommandSessionSection {
   return {
@@ -311,6 +332,10 @@ export function createBootstrapCommandSessionSection(
     sessionLineageTracker: options.sessionLineageTracker,
     wrfcController: options.wrfcController,
     changeTracker: options.changeTracker,
+    hydrateSessionUsage: options.hydrateSessionUsage,
+    workstreamEngine: options.workstreamEngine,
+    codeIndexStore: options.codeIndexStore,
+    getMainSessionTurnInjections: options.getMainSessionTurnInjections,
   };
 }
 
@@ -331,7 +356,7 @@ export function createBootstrapCommandProviderSection(
 export function createBootstrapCommandWorkspaceSection(
   options: Pick<
     BootstrapCommandSectionOptions,
-    'keybindingsManager' | 'fileUndoManager' | 'panelManager' | 'profileManager' | 'bookmarkManager'
+    'keybindingsManager' | 'fileUndoManager' | 'workspaceCheckpointManager' | 'panelManager' | 'profileManager' | 'bookmarkManager'
     | 'projectPlanningService' | 'projectPlanningProjectId' | 'workPlanStore'
   >,
   shellServices: BootstrapCommandShellServices,
@@ -339,6 +364,7 @@ export function createBootstrapCommandWorkspaceSection(
   return {
     keybindingsManager: options.keybindingsManager,
     fileUndoManager: options.fileUndoManager,
+    workspaceCheckpointManager: options.workspaceCheckpointManager,
     panelManager: options.panelManager,
     profileManager: options.profileManager,
     bookmarkManager: options.bookmarkManager,
@@ -352,7 +378,7 @@ export function createBootstrapCommandWorkspaceSection(
 export function createBootstrapCommandPlatformSection(
   options: Pick<
     BootstrapCommandSectionOptions,
-    'configManager' | 'voiceProviderRegistry' | 'voiceService'
+    'configManager' | 'voiceProviderRegistry' | 'voiceService' | 'webSearchService' | 'mediaProviders' | 'artifactStore'
   >,
   shellServices: BootstrapCommandShellServices,
 ): BootstrapCommandPlatformSection {
@@ -361,6 +387,9 @@ export function createBootstrapCommandPlatformSection(
     configManager: options.configManager,
     voiceProviderRegistry: options.voiceProviderRegistry,
     voiceService: options.voiceService,
+    webSearchService: options.webSearchService,
+    mediaProviders: options.mediaProviders,
+    artifactStore: options.artifactStore,
     ...shellServices.platform,
   };
 }

package/src/runtime/bootstrap-core.ts

@@ -7,7 +7,6 @@ import { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import { registerAllTools } from '@pellux/goodvibes-sdk/platform/tools';
 import { PermissionManager, createPermissionConfigReader } from '@pellux/goodvibes-sdk/platform/permissions';
 import { Notifier } from '@pellux/goodvibes-sdk/platform/integrations';
-import { WebhookNotifier } from '@pellux/goodvibes-sdk/platform/integrations';
 import { Compositor } from '../renderer/compositor.ts';
 import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
@@ -28,11 +27,12 @@ import { loadBootstrapSystemPrompt, syncConfiguredServices } from '@/runtime/ind
 import { registerBootstrapHookBridge } from '@/runtime/index.ts';
 import { registerBootstrapRuntimeEvents } from '@/runtime/index.ts';
 import { createRuntimeServices, type RuntimeServices } from './services.ts';
+import { setPricingSource } from '../export/cost-utils.ts';
 import { createUiRuntimeServices, type UiRuntimeServices } from './ui-services.ts';
 import { join } from 'node:path';
 import { installWrfcAgentToolGuard } from '../tools/wrfc-agent-guard.ts';
 import { createWrfcPersistence, type WrfcPersistence } from './wrfc-persistence.ts';
-import type { SystemMessagePriority } from '../panels/system-messages-panel.ts';
+import type { SystemMessagePriority } from '../core/system-message-router.ts';
 
 // ---------------------------------------------------------------------------
 // Pre-router buffer
@@ -255,6 +255,10 @@ export async function initializeBootstrapCore(
   providerRegistry.initModelLimits();
   services.benchmarkStore.initBenchmarks();
   providerRegistry.initCatalog();
+  // Wire cost-utils to the live catalog so cost displays distinguish real
+  // pricing from unpriced (WO-315) instead of silently reading zero for any
+  // model the small static fallback table doesn't cover.
+  setPricingSource(() => providerRegistry.getRawCatalogModels());
   services.keybindingsManager.loadFromDisk();
   domainDispatch.syncControlPlaneState({
     enabled: Boolean(configManager.get('controlPlane.enabled')),
@@ -632,10 +636,20 @@ export async function initializeBootstrapCore(
 
   providerRegistry.startWatching(runtimeBus);
 
+  // W2.3: attach the SAME WebhookNotifier instance that `/notify add|remove|clear`
+  // (notify-runtime.ts) keeps live via ctx.services.webhookNotifier, rather than
+  // constructing a second, boot-time-only instance here. Before this fix, a
+  // webhook URL added mid-session reached long-task notifications (which read
+  // ctx.services.webhookNotifier directly) but never reached this instance's
+  // AGENT_FAILED/WORKFLOW_CHAIN_FAILED/WORKFLOW_CHAIN_PASSED runtime-bus
+  // listeners until restart — and if the session started with zero URLs
+  // configured, attachToRuntimeBus was never even called, so those listeners
+  // never existed at all for the rest of the session. Always attaching
+  // (regardless of initial URL count) and seeding the shared instance fixes
+  // both: `send()` is already a safe no-op with zero URLs configured.
   const webhookUrls = (configManager.getCategory('notifications') as { webhookUrls?: string[] }).webhookUrls ?? [];
   if (webhookUrls.length > 0) {
-    const webhookNotifier = WebhookNotifier.fromConfig(webhookUrls);
-    webhookNotifier.attachToRuntimeBus(runtimeBus);
+    services.webhookNotifier.setUrls(webhookUrls);
     domainDispatch.syncIntegration({
       id: 'webhooks',
       displayName: 'Webhooks',
@@ -647,6 +661,7 @@ export async function initializeBootstrapCore(
       meta: { urlCount: webhookUrls.length },
     }, 'bootstrap.webhooks');
   }
+  services.webhookNotifier.attachToRuntimeBus(runtimeBus);
 
   const notifier = await Notifier.fromConfig(services.serviceRegistry);
   const queueStatuses = notifier.getQueueStatus();

package/src/runtime/bootstrap-hook-bridge.ts

@@ -29,6 +29,8 @@ export interface ResumeSessionOptions {
   readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
   readonly providerRegistry: Pick<ProviderRegistry, 'get' | 'getCurrentModel' | 'getForModel' | 'require'>;
   readonly homeDirectory: string;
+  /** See CommandSessionServices.hydrateSessionUsage (command-registry.ts). */
+  readonly hydrateSessionUsage?: () => void;
 }
 
 export function createResumeSessionHandler(options: ResumeSessionOptions): (sessionId: string) => void {
@@ -65,6 +67,9 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
           });
         },
       });
+      // Hydrate the footer's token counters from the resumed history now that
+      // fromJSON()/journal replay are both applied — before requestRender() below.
+      options.hydrateSessionUsage?.();
       options.onSessionIdChanged?.(sessionId);
       if (meta?.model) options.runtime.model = meta.model;
       if (meta?.provider) options.runtime.provider = meta.provider;