@pellux/goodvibes-tui 0.21.0 → 0.23.0

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

@@ -1,6 +1,7 @@
 import type { UiRuntimeEvents } from '@/runtime/index.ts';
 import { createStreamStallWatchdog } from './stream-stall-watchdog.ts';
 import { formatUserFacingErrorLine } from './format-user-error.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 
 /**
  * Live stream and tool-execution metrics maintained by wireStreamEventMetrics.
@@ -29,9 +30,28 @@ interface StreamOrchestrator {
   readonly streamingOutputTokens: number;
 }
 
-/** Minimal provider surface required for the stream stall watchdog. */
+/** Minimal provider surface required for the stream stall watchdog and failover switching. */
 interface StreamProviderRegistry {
-  getCurrentModel(): { readonly provider: string };
+  getCurrentModel(): { readonly provider: string; readonly registryKey?: string };
+  setCurrentModel(registryKey: string): void;
+}
+
+/**
+ * Minimal fallback-chain node shape returned by ProviderOptimizer.testFallback().
+ * Only the fields consumed by the failover path are declared here.
+ */
+interface FailoverChainNode {
+  readonly position: number;
+  readonly providerId: string;
+  readonly modelId: string;
+  readonly capable: boolean;
+}
+
+/** Minimal ProviderOptimizer surface required by the failover path. */
+interface FailoverOptimizer {
+  readonly enabled: boolean;
+  testFallback(profile?: Record<string, unknown>): { readonly chain: readonly FailoverChainNode[] };
+  recordFallbackTransition(from: string, to: string, reason: string): void;
 }
 
 /** Minimal system-message surface required for user-visible notifications. */
@@ -56,6 +76,32 @@ export interface WireStreamEventMetricsOptions {
    * so the render closure can read it without a forward-reference issue.
    */
   readonly metrics: StreamMetrics;
+  /**
+   * When provided and enabled, the optimizer is consulted on TURN_ERROR to
+   * attempt the next viable provider before surfacing the error to the user.
+   * When absent or optimizer.enabled is false, behaviour is identical to the
+   * pre-failover baseline: error surfaces immediately via systemMessageRouter.
+   */
+  readonly providerOptimizer?: FailoverOptimizer;
+  /**
+   * Callback the caller provides to re-submit the last user turn on a
+   * different provider after a successful failover switch.  Called only when
+   * the optimizer is enabled and a viable next provider exists in the chain.
+   */
+  readonly retryTurn?: () => void;
+}
+
+/** Result of wireStreamEventMetrics. */
+export interface WireStreamEventMetricsResult {
+  /** Unsubscribe functions; push into the parent unsubs array for cleanup on exit. */
+  readonly unsubs: ReadonlyArray<() => void>;
+  /**
+   * Clear the per-turn failover visited-provider set.
+   * Call this on every new user submission so the visited set does not bleed
+   * across independent turns (the set is also cleared automatically on
+   * TURN_COMPLETED, but a new submission may arrive before TURN_COMPLETED fires).
+   */
+  readonly clearFailoverVisited: () => void;
 }
 
 /**
@@ -64,8 +110,7 @@ export interface WireStreamEventMetricsOptions {
  * and declares it before render() so both the render closure and the returned
  * event handlers share the same reference.
  *
- * Returns an array of unsubscribe functions; push them into the parent unsubs
- * array so they are cleaned up on exit.
+ * Returns an object with unsubscribe functions and a clearFailoverVisited helper.
  *
  * Responsibilities:
  *   - Track stream start time, delta count, token speed, and TTFT
@@ -75,8 +120,11 @@ export interface WireStreamEventMetricsOptions {
  */
 export function wireStreamEventMetrics(
   options: WireStreamEventMetricsOptions,
-): ReadonlyArray<() => void> {
-  const { events, metrics, orchestrator, providerRegistry, systemMessageRouter, render } = options;
+): WireStreamEventMetricsResult {
+  const {
+    events, metrics, orchestrator, providerRegistry,
+    systemMessageRouter, render, providerOptimizer, retryTurn,
+  } = options;
 
   const unsubs: Array<() => void> = [];
 
@@ -103,8 +151,78 @@ export function wireStreamEventMetrics(
     metrics.tokenSpeed = elapsed > 0 ? tokenCount / elapsed : 0;
   }));
 
+  // Per-turn visited-provider set: tracks providers already attempted this turn
+  // so failover cannot ping-pong between two mutually-failing providers.
+  // True invariant: at most one retry per provider per turn; exhaustion fires
+  // after the chain is consumed.
+  // Cleared on TURN_COMPLETED (see handler below) and on new user submission
+  // (caller clears via clearFailoverVisited(), wired in main.ts).
+  const failoverVisited = new Set<string>();
+
+  unsubs.push(events.turns.on('TURN_COMPLETED', () => {
+    failoverVisited.clear();
+  }));
+
   unsubs.push(events.turns.on('TURN_ERROR', (event) => {
     const errVal: string = event.error;
+
+    // --- Optimizer-gated failover path ---
+    // When the optimizer is present and enabled, attempt to advance to the next
+    // viable provider in the fallback chain before surfacing the error.  When
+    // the optimizer is absent or disabled, behaviour is identical to baseline:
+    // error surfaces immediately.
+    if (providerOptimizer?.enabled && retryTurn) {
+      const fromProvider = providerRegistry.getCurrentModel().provider;
+      // Mark the failing provider as visited so it will never be selected again
+      // in this turn, even if a second TURN_ERROR arrives (e.g. ping-pong).
+      failoverVisited.add(fromProvider);
+      const result = providerOptimizer.testFallback({});
+      // Find the first capable node that is NOT already visited this turn and
+      // is NOT synthetic. Synthetic nodes are skipped permanently by design:
+      // a synthetic model is itself a fallback ladder over real backends, so
+      // failing over INTO one after a real backend already failed is unsound
+      // double-indirection (it can route straight back to the failed provider).
+      const next = result.chain.find(
+        (node) =>
+          node.capable &&
+          !failoverVisited.has(node.providerId) &&
+          node.providerId !== 'synthetic',
+      );
+
+      if (next) {
+        const toRegistryKey = `${next.providerId}:${next.modelId}`;
+        const errorClass = formatUserFacingErrorLine(errVal);
+        try {
+          providerRegistry.setCurrentModel(toRegistryKey);
+        } catch (switchErr) {
+          // Switch failed — fall through to honest error display.
+          logger.debug('failover setCurrentModel failed', { toRegistryKey, error: String(switchErr) });
+          systemMessageRouter.high(`[Error] ${errorClass}`);
+          render();
+          return;
+        }
+        // Record the selected provider as visited before the retry fires so
+        // a subsequent TURN_ERROR from that provider also skips it.
+        failoverVisited.add(next.providerId);
+        providerOptimizer.recordFallbackTransition(fromProvider, next.providerId, errorClass);
+        systemMessageRouter.high(
+          `[Failover] ${fromProvider} -> ${next.providerId} (${errorClass})`,
+        );
+        render();
+        // Re-submit the last user turn on the new provider.
+        retryTurn();
+        return;
+      }
+
+      // Chain exhausted — all capable candidates have been visited or none exist.
+      systemMessageRouter.high(
+        `[Failover] Chain exhausted — no alternative provider available. Original error: ${formatUserFacingErrorLine(errVal)}`,
+      );
+      render();
+      return;
+    }
+
+    // Baseline: optimizer disabled or not wired — surface error immediately.
     const formatted = formatUserFacingErrorLine(errVal);
     systemMessageRouter.high(`[Error] ${formatted}`);
     render();
@@ -140,5 +258,5 @@ export function wireStreamEventMetrics(
     metrics.activeToolName = undefined;
   }));
 
-  return unsubs;
+  return { unsubs, clearFailoverVisited: () => failoverVisited.clear() };
 }

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

@@ -0,0 +1,124 @@
+import type { UiRuntimeEvents } from '@/runtime/index.ts';
+import { buildPersistedSessionContext, persistConversation } from '@/runtime/index.ts';
+import { maybeAutoCompact } from './context-auto-compact.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { HookDispatcher, HookPhase, HookCategory, HookEventPath } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { ConversationManager } from './conversation.ts';
+
+/** Infer the options param of persistConversation to pick up SessionManager correctly. */
+type PersistOptions = NonNullable<Parameters<typeof persistConversation>[5]>;
+
+/** Minimal orchestrator surface required by turn-event wiring. */
+interface TurnOrchestrator {
+  readonly lastInputTokens: number;
+}
+
+/** Minimal provider registry surface required by turn-event wiring. */
+interface TurnProviderRegistry {
+  getCurrentModel(): { readonly contextWindow: number };
+}
+
+/** Minimal config manager surface required by turn-event wiring. */
+interface TurnConfigManager {
+  get(key: string): unknown;
+}
+
+/** Minimal system message router surface required by turn-event wiring. */
+interface TurnSystemMessageRouter {
+  high(message: string): void;
+  low(message: string): void;
+  routeSystemMessage(message: string, level: string): void;
+}
+
+export interface WireTurnEventHandlersOptions {
+  readonly events: UiRuntimeEvents;
+  readonly conversation: ConversationManager;
+  readonly runtime: { sessionId: string; model: string; provider: string };
+  readonly orchestrator: TurnOrchestrator;
+  readonly configManager: TurnConfigManager;
+  readonly providerRegistry: TurnProviderRegistry;
+  readonly systemMessageRouter: TurnSystemMessageRouter;
+  readonly hookDispatcher: HookDispatcher;
+  readonly workingDir: string;
+  readonly homeDirectory: string;
+  readonly sessionManager: PersistOptions['sessionManager'];
+  readonly gitStatusProvider: { refresh(): Promise<unknown> };
+  readonly lastGitInfoRef: { value: unknown };
+  readonly buildSessionContinuityHints: () => Record<string, unknown>;
+  readonly render: () => void;
+}
+
+export interface WireTurnEventHandlersResult {
+  /** Trigger a git status refresh; may be called from external code after tool execution. */
+  readonly refreshGit: () => void;
+  /** Unsubscribe functions to push into the parent unsubs array. */
+  readonly unsubs: ReadonlyArray<() => void>;
+}
+
+/**
+ * Wire TURN_COMPLETED, TOOL_SUCCEEDED, and TOOL_FAILED runtime events.
+ *
+ * Responsibilities:
+ *   - Auto-save conversation to persistent store after each LLM turn
+ *   - Fire the Lifecycle:session:save hook
+ *   - Trigger auto-compact when context usage exceeds the configured threshold
+ *   - Refresh git status after turns and tool results
+ *
+ * Returns refreshGit (callable externally) and unsubs (push into parent unsubs).
+ */
+export function wireTurnEventHandlers(
+  options: WireTurnEventHandlersOptions,
+): WireTurnEventHandlersResult {
+  const {
+    events, conversation, runtime, orchestrator, configManager,
+    providerRegistry, systemMessageRouter, hookDispatcher,
+    workingDir, homeDirectory, sessionManager, gitStatusProvider,
+    lastGitInfoRef, buildSessionContinuityHints, render,
+  } = options;
+
+  const unsubs: Array<() => void> = [];
+
+  const refreshGit = (): void => {
+    gitStatusProvider.refresh().then((info) => { lastGitInfoRef.value = info; render(); }).catch(() => { /* non-fatal */ });
+  };
+
+  unsubs.push(events.turns.on('TURN_COMPLETED', () => {
+    // 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 };
+      const persisted = buildPersistedSessionContext(snapshot.messages, conversation.getTitleSource(), buildSessionContinuityHints());
+      persistConversation(
+        runtime.sessionId,
+        { ...snapshot, ...persisted },
+        runtime.model,
+        runtime.provider,
+        conversation.title || '',
+        { workingDirectory: workingDir, homeDirectory, sessionManager },
+      );
+      hookDispatcher.fire({ path: 'Lifecycle:session:save' as HookEventPath, phase: 'Lifecycle' as HookPhase, category: 'session' as HookCategory, specific: 'save', sessionId: runtime.sessionId, timestamp: Date.now(), payload: { sessionId: runtime.sessionId } }).catch((err: unknown) => logger.debug('hook fire error', { error: summarizeError(err) }));
+    } catch (e) { logger.debug('auto-save on turn:complete failed', { error: summarizeError(e) }); }
+    // Auto-compact: check context usage and compact if threshold exceeded
+    const currentModelForCompact = providerRegistry.getCurrentModel();
+    maybeAutoCompact({
+      configManager: configManager as Parameters<typeof maybeAutoCompact>[0]['configManager'],
+      conversation,
+      providerRegistry: providerRegistry as Parameters<typeof maybeAutoCompact>[0]['providerRegistry'],
+      systemMessageRouter: systemMessageRouter as Parameters<typeof maybeAutoCompact>[0]['systemMessageRouter'],
+      model: runtime.model,
+      provider: runtime.provider,
+      lastInputTokens: orchestrator.lastInputTokens,
+      contextWindow: currentModelForCompact.contextWindow,
+    }).catch((err: unknown) => logger.debug('maybeAutoCompact error', { error: summarizeError(err) }));
+    refreshGit();
+  }));
+
+  unsubs.push(events.tools.on('TOOL_SUCCEEDED', () => {
+    refreshGit();
+  }));
+  unsubs.push(events.tools.on('TOOL_FAILED', () => {
+    refreshGit();
+  }));
+
+  return { refreshGit, unsubs };
+}

package/src/daemon/cli.ts

@@ -104,6 +104,11 @@ async function main(): Promise<void> {
     console.error(renderGoodVibesDaemonHelp('goodvibes-daemon'));
     process.exit(2);
   }
+  if (cli.warnings.length > 0) {
+    for (const warning of cli.warnings) {
+      console.warn(`[goodvibes-daemon] warning: ${warning}`);
+    }
+  }
   if (cli.flags.help || cli.command === 'help') {
     console.log(renderGoodVibesDaemonHelp('goodvibes-daemon'));
     process.exit(0);

package/src/input/command-registry.ts

@@ -118,6 +118,7 @@ export interface CommandShellUiOpeners {
   openMcpWorkspace?: () => void;
   openSecurityPanel?: () => void;
   openKnowledgePanel?: () => void;
+  openMemoryPanel?: () => void;
   openRemotePanel?: () => void;
   openSubscriptionPanel?: () => void;
   /**

package/src/input/commands/channel-runtime.ts

@@ -0,0 +1,139 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { requireIntegrationHelpers } from './runtime-services.ts';
+
+export function registerChannelRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'channel',
+    aliases: [],
+    description: 'Inspect channel routes, delivery strategies, and ingress policies',
+    usage: '[status|routes|delivery|policy] [--json]',
+    argsHint: 'status | routes | delivery | policy',
+    handler(args, ctx) {
+      const sub = args[0];
+      const asJson = args.includes('--json');
+
+      if (!sub || sub === 'open' || sub === 'panel') {
+        if (ctx.showPanel) ctx.showPanel('routes');
+        return;
+      }
+
+      const helpers = requireIntegrationHelpers(ctx);
+
+      if (sub === 'status') {
+        const review = helpers.buildReview();
+        if (asJson) {
+          ctx.print(JSON.stringify(review, null, 2));
+          return;
+        }
+        const lines: string[] = [
+          'Channel Status',
+          `  routes:            ${review.routes.length}`,
+          `  api families:      ${review.apiFamilies.join(', ') || '(none)'}`,
+          `  sessions:          ${review.sessions}`,
+          `  tasks:             ${review.tasks}`,
+          `  pending approvals: ${review.pendingApprovals}`,
+          `  remote contracts:  ${review.remoteContracts}`,
+          '',
+          `Active route families: ${review.routes.join(', ') || '(none)'}`,
+          '',
+          'Use /channel routes for delivery binding details.',
+          'Use /channel delivery for outbound delivery snapshot.',
+          'Use /channel policy for ingress policy snapshot.',
+        ];
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      if (sub === 'routes') {
+        const snapshot = helpers.getRouteSnapshot();
+        if (asJson) {
+          ctx.print(JSON.stringify(snapshot, null, 2));
+          return;
+        }
+        const entries = Object.entries(snapshot);
+        if (entries.length === 0) {
+          ctx.print('No route bindings active.\n\nRoutes become active when channel surfaces (slack, discord, ntfy, webhook, etc.) are configured and the daemon is running.');
+          return;
+        }
+        const lines: string[] = ['Channel Routes'];
+        for (const [key, value] of entries) {
+          lines.push(`  ${String(key).padEnd(28)} ${JSON.stringify(value)}`);
+        }
+        lines.push('');
+        lines.push('Route bindings reflect active daemon surface registrations.');
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      if (sub === 'delivery') {
+        const snapshot = helpers.getDeliverySnapshot();
+        if (asJson) {
+          ctx.print(JSON.stringify(snapshot, null, 2));
+          return;
+        }
+        const entries = Object.entries(snapshot);
+        if (entries.length === 0) {
+          ctx.print('No delivery snapshot available.\n\nDelivery state is populated when the daemon handles outbound channel messages.');
+          return;
+        }
+        const lines: string[] = ['Channel Delivery Snapshot'];
+        for (const [key, value] of entries) {
+          lines.push(`  ${String(key).padEnd(28)} ${JSON.stringify(value)}`);
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      if (sub === 'policy') {
+        const configManager = ctx.platform.configManager;
+        // Channel policy is persisted by ChannelPolicyManager in
+        // .goodvibes/tui/channels/policies.json — surface via configManager
+        // category (runtime-accessible without a daemon round-trip).
+        const surfaces = [
+          'slack', 'discord', 'ntfy', 'webhook', 'homeassistant',
+          'telegram', 'google-chat', 'signal', 'whatsapp',
+          'imessage', 'msteams', 'bluebubbles', 'mattermost', 'matrix',
+        ];
+        const lines: string[] = ['Channel Ingress Policies'];
+        let found = false;
+        for (const surface of surfaces) {
+          const key = `surfaces.${surface}.enabled` as Parameters<typeof configManager.get>[0];
+          const enabled = configManager.get(key);
+          if (enabled !== undefined && enabled !== null) {
+            found = true;
+            lines.push(`  ${surface.padEnd(20)} enabled=${String(enabled)}`);
+          }
+        }
+        if (!found) {
+          lines.push('  No channel surfaces configured.');
+          lines.push('');
+          lines.push('  Configure surfaces via /onboarding or Settings > Surfaces.');
+          lines.push('  Fine-grained ingress policies (allowedCommands, requireMention, groupPolicies)');
+          lines.push('  are managed by ChannelPolicyManager in .goodvibes/tui/channels/policies.json.');
+        } else {
+          lines.push('');
+          lines.push('  Fine-grained ingress policies (allowedCommands, requireMention, groupPolicies)');
+          lines.push('  are managed by ChannelPolicyManager in .goodvibes/tui/channels/policies.json.');
+        }
+        if (asJson) {
+          ctx.print(JSON.stringify({ surfaces: Object.fromEntries(surfaces.map((s) => [s, configManager.get(`surfaces.${s}.enabled` as Parameters<typeof configManager.get>[0])])) }, null, 2));
+          return;
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      ctx.print(
+        'Usage: /channel <subcommand>\n'
+        + '  (no args)  — open the Routes panel\n'
+        + '  status     — channel overview: routes, sessions, tasks, pending approvals\n'
+        + '  routes     — active route binding snapshot\n'
+        + '  delivery   — outbound delivery snapshot\n'
+        + '  policy     — configured channel surfaces and ingress policy location\n'
+        + '\n'
+        + 'Options:\n'
+        + '  --json  Output raw JSON for scripting'
+      );
+    },
+  });
+}

package/src/input/commands/control-room-runtime.ts

@@ -203,11 +203,11 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
     handler(args, ctx) {
       const subcommand = (args[0] ?? 'open').toLowerCase();
       if (subcommand === 'open') {
-        if (ctx.openKnowledgePanel) {
-          ctx.openKnowledgePanel();
+        if (ctx.openMemoryPanel) {
+          ctx.openMemoryPanel();
           return;
         }
-        ctx.print('Knowledge panel is not available in this runtime.');
+        ctx.print('Memory panel is not available in this runtime.');
         return;
       }
       const memory = getMemoryApi(ctx);
@@ -245,8 +245,8 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
         ctx.print(prompt ?? 'No reviewed project knowledge matched that task.');
         return;
       }
-      if (ctx.openKnowledgePanel) {
-        ctx.openKnowledgePanel();
+      if (ctx.openMemoryPanel) {
+        ctx.openMemoryPanel();
         return;
       }
       ctx.print(`Unknown project-memory subcommand: ${subcommand}`);

package/src/input/commands/provider.ts

@@ -3,6 +3,7 @@
  *
  * Implements the Provider Optimizer panel commands:
  *
+ *   /provider optimizer on|off   — Enable or disable the provider optimizer
  *   /provider route auto|manual  — Set optimizer routing mode
  *   /provider explain-route      — Print current route explanation
  *   /provider pin <provider:model> — Pin routing to a specific provider/model
@@ -10,14 +11,19 @@
  *
  * When the optimizer is disabled, commands report its status and
  * explain-route still works (reads current model capabilities).
+ * Enabling the optimizer persists the change to config so it survives restart.
  */
 
 import type { SlashCommand, CommandContext } from '../command-registry.ts';
+import type { ConfigKey } from '../../config/index.ts';
 import type { RouteExplanation } from '@pellux/goodvibes-sdk/platform/providers';
 import type { FallbackTestResult, FallbackTransition } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ProviderApiModelRecord } from '@pellux/goodvibes-sdk/platform/providers';
 import { requireProviderApi } from './runtime-services.ts';
 
+const PROVIDER_OPTIMIZER_FLAG = 'provider-optimizer';
+const PROVIDER_OPTIMIZER_CONFIG_KEY = `featureFlags.${PROVIDER_OPTIMIZER_FLAG}` as ConfigKey;
+
 // ---------------------------------------------------------------------------
 // Formatting helpers
 // ---------------------------------------------------------------------------
@@ -65,6 +71,49 @@ function fmtExplanation(expl: RouteExplanation, context: CommandContext): void {
   }
 }
 
+// ---------------------------------------------------------------------------
+// /provider optimizer on|off
+// ---------------------------------------------------------------------------
+
+function handleOptimizerToggle(
+  args: string[],
+  context: CommandContext,
+): void {
+  const optimizer = requireProviderOptimizer(context);
+  if (!optimizer) return;
+  const sub = args[0];
+
+  if (sub !== 'on' && sub !== 'off') {
+    context.print('[provider] Usage: /provider optimizer on|off');
+    context.print(`  Current state: optimizer is ${optimizer.enabled ? 'enabled' : 'disabled'}`);
+    context.print('  "on"  — activates intelligent failover and auto-routing');
+    context.print('  "off" — disables optimizer; provider selection is manual only');
+    return;
+  }
+
+  const enable = sub === 'on';
+  const wasEnabled = optimizer.enabled;
+  optimizer.setEnabled(enable);
+
+  // Persist to config so the setting survives restart.
+  const flagValue = enable ? 'enabled' : 'disabled';
+  context.platform.configManager.setDynamic(PROVIDER_OPTIMIZER_CONFIG_KEY, flagValue);
+
+  if (enable && !wasEnabled) {
+    context.print('[provider] Optimizer enabled.');
+    context.print('  Intelligent failover is now active: on a request error the optimizer');
+    context.print('  will attempt the next viable provider and surface a transcript notice');
+    context.print('  naming the from→to transition and reason before retrying.');
+    context.print('  Use "/provider route auto" to enable fully automatic routing.');
+  } else if (!enable && wasEnabled) {
+    context.print('[provider] Optimizer disabled.');
+    context.print('  Provider selection returns to manual-only mode. No automatic failover.');
+    context.print('  Pinned targets and fallback log are preserved; re-enable to resume.');
+  } else {
+    context.print(`[provider] Optimizer already ${enable ? 'enabled' : 'disabled'} — no change.`);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // /provider route auto|manual
 // ---------------------------------------------------------------------------
@@ -85,9 +134,9 @@ function handleRoute(
 
   if (!optimizer.enabled) {
     context.print(
-      '[provider] Optimizer is currently disabled. Enable it with the provider-optimizer feature flag.',
+      '[provider] Optimizer is off — routing mode recorded but failover will not fire until optimizer is enabled.',
     );
-    context.print(`  Routing mode set to: ${sub} (no-op until optimizer is enabled)`);
+    context.print('  Enable with: /provider optimizer on');
   }
 
   optimizer.setMode(sub);
@@ -318,11 +367,15 @@ export const providerCommand: SlashCommand = {
   aliases: ['prov-opt'],
   description: 'Manage provider routing optimizer (route, pin, explain, fallback).',
   usage: '<subcommand> [args]',
-  argsHint: 'route|explain-route|pin|fallback',
+  argsHint: 'optimizer|route|explain-route|pin|fallback',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
     switch (sub) {
+      case 'optimizer':
+        handleOptimizerToggle(rest, context);
+        break;
+
       case 'route':
         handleRoute(rest, context);
         break;
@@ -345,6 +398,7 @@ export const providerCommand: SlashCommand = {
         if (!optimizer) return;
         const lines = [
           'Usage: /provider <subcommand>',
+          '  optimizer on|off               — Enable or disable the provider optimizer',
           '  route auto|manual              — Set optimizer routing mode',
           '  explain-route                  — Show current route explanation',
           '  pin <provider:model>           — Pin routing to specific provider/model',

package/src/input/commands/runtime-services.ts

@@ -7,6 +7,8 @@ import type {
   CommandSessionServices,
   CommandWorkspaceServices,
 } from '../command-registry.ts';
+import { getLastCompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+import type { CompactionContext, CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
 import type { UiReadModels } from '../../runtime/ui-read-models.ts';
 import type { ShellPathService } from '@/runtime/index.ts';
 import type { EcosystemCatalogPathOptions } from '@/runtime/index.ts';
@@ -236,13 +238,40 @@ export function requireProviderApi(context: CommandContext): ProviderApi {
   return requireContextValue(context.clients?.providerApi, 'clients.providerApi');
 }
 
-export async function compactConversation(context: CommandContext): Promise<void> {
+/**
+ * Compact the conversation and return the CompactionEvent recorded by the SDK,
+ * or null if no event was recorded (e.g. compaction was skipped or produced no
+ * change).
+ */
+export async function compactConversation(context: CommandContext): Promise<CompactionEvent | null> {
+  const eventBefore = getLastCompactionEvent();
+  const sessionMemories = context.session.sessionMemoryStore?.list() ?? [];
+  const compactionCtx: CompactionContext = {
+    messages: context.session.conversationManager.getMessagesForLLM(),
+    sessionMemories,
+    agents: [],
+    wrfcChains: [],
+    activePlan: null,
+    lineageEntries: [],
+    compactionCount: 0,
+    contextWindow: 0,
+    trigger: 'manual',
+    extractionModelId: context.session.runtime.model,
+    extractionProvider: context.session.runtime.provider,
+  };
   await context.session.conversationManager.compact(
     context.provider.providerRegistry,
     context.session.runtime.model,
     'manual',
     context.session.runtime.provider,
+    compactionCtx,
   );
+  const eventAfter = getLastCompactionEvent();
+  // Return the new event only if it differs from the one recorded before the call.
+  if (eventAfter !== null && eventAfter !== eventBefore) {
+    return eventAfter;
+  }
+  return null;
 }
 
 export function requireKnowledgeApi(context: CommandContext): KnowledgeApi {