@pellux/goodvibes-tui 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.22.0] — 2026-06-12
+
+Second best-in-class program release: the backlog tail, the providers/failover track opened, and the release pipeline made fully honest. Every change passed independent review at 10/10 before commit.
+
+### Features
+- Added a Cockpit control room: live agent roster (status, stalled flag, real cost/tokens), inspect and confirm-gated cancel action keys on the shared orphan-free cancel path.
+- Added /session as the single front-door for session work: lifecycle subcommands (list, rename, resume, fork, save, info, export, search, delete, events, groups, hotspots) and orchestration (link-task with cycle detection, handoff, graph, cancel with task/subtree/session scopes); alias /sess.
+- Added a merged memory panel (records + review queue via Tab) with the knowledge-graph view on its own panel; /project-memory routes to records; session scratch surface renamed to notes.
+- Added settings reset-category and reset-all (Shift+R / Ctrl+Shift+R, confirm-gated, runtime-synced), schema-derived unknown-key warnings at load, restart hints from a typed key table, and width-honest footers proven at 80 and 120 columns.
+- Added wizard required-field gating: apply blocks with per-field messages and a focus jump to the first offender.
+- Added the provider optimizer enable switch: /provider optimizer on|off drives the live instance and persists; /provider route auto says honestly when the optimizer is off.
+- Added wizard security hardening: Cloudflare tunnel apply sets trustProxy with the residual risk named until SDK header validation ships; TLS plaintext hard-warn in the wizard and a startup banner; CORS guidance.
+- Added context truth: auto-compact runs only when behavior.autoCompact is enabled (threshold from config, percent converted correctly), with a passive suggest-compact status hint and honest transcript notices.
+- Added tts.speed to settings, bridged end-to-end today (modal to synthesis call); explicit tts.* defaults with truthful modified markers.
+
+### Fixes
+- Fixed CLI flag truth end-to-end: a drift-proof parity test extracts flags from parser source and asserts equality across help, completions, and docs; ghost completion flags removed; --output-format deprecated with a stderr warning; session lifecycle flags are mutually exclusive with a clear error.
+- Fixed onboarding marker timing residue and wizard copy; sessions, recovery, and WRFC chains read through version-gated, quarantining loaders everywhere.
+
+### Internal
+- Performance gate is real: fail-closed in CI without a baseline, headless startup and frame benches sharing one methodology and one CI-safe budget source (p95 16ms, p99 110ms with runner headroom), committed ratchet baseline.
+- Per-agent stall watchdog constants shared; agent cost/token surfaces fabricated-number-free; concurrency-safe test temp dirs; eval gate fail-closed with a committed baseline; 540 test files green.
+
 ## [0.21.0] — 2026-06-12
 
 First release of the best-in-class program: a full UX-first review of the codebase followed by WRFC-gated remediation (every change passed independent review at 10/10 before commit).

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.21.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.22.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -57,6 +57,7 @@
     "build:prod": "bun run scripts/build.ts",
     "build:all": "bun run scripts/build.ts --all",
     "perf:check": "bun run scripts/perf-check.ts",
+    "perf:baseline": "GOODVIBES_PERF_SAVE_BASELINE=1 bun run scripts/perf-check.ts",
     "architecture:check": "bun run scripts/check-architecture.ts",
     "audit:home": "bun run scripts/audit-goodvibes-home.ts",
     "foundation:artifacts": "bun run scripts/export-foundation-artifacts.ts",

package/src/cli/completions/generate.ts

@@ -137,12 +137,8 @@ export const GLOBAL_FLAGS: readonly CompletionFlag[] = [
   },
   { name: '--continue', takesValue: false, description: 'Continue the latest session' },
   { name: '--fork', takesValue: false, description: 'Fork session when supported' },
-  { name: '--raw-output', takesValue: false, description: 'Raw output mode' },
-  {
-    name: '--accept-raw-output-risk',
-    takesValue: false,
-    description: 'Acknowledge raw output risk',
-  },
+  { name: '--yes', short: '-y', takesValue: false, description: 'Auto-confirm prompts (non-interactive)' },
+  { name: '--non-interactive', takesValue: false, description: 'Disable all interactive prompts (implies --yes)' },
 ] as const;
 
 // ---------------------------------------------------------------------------
@@ -512,8 +508,8 @@ export function generateZsh(surface: CompletionSurface): string {
   lines.push(`    '(-s --session)'{-s,--session}'[Use a specific session]:id:' \\`);
   lines.push(`    '--continue[Continue the latest session]' \\`);
   lines.push(`    '--fork[Fork session when supported]' \\`);
-  lines.push(`    '--raw-output[Raw output mode]' \\`);
-  lines.push(`    '--accept-raw-output-risk[Acknowledge raw output risk]' \\`);
+  lines.push(`    '(-y --yes)'{-y,--yes}'[Auto-confirm prompts]' \\`);
+  lines.push(`    '--non-interactive[Disable all interactive prompts]' \\`);
   lines.push(`    '1:command:->cmd' \\`);
   lines.push(`    '*:args:->args';`);
   lines.push('');

package/src/cli/entrypoint.ts

@@ -61,6 +61,12 @@ export async function prepareShellCliRuntime(
     process.exit(2);
   }
 
+  if (cli.warnings.length > 0) {
+    for (const warning of cli.warnings) {
+      console.warn(`[goodvibes] warning: ${warning}`);
+    }
+  }
+
   if (cli.flags.help || cli.command === 'help') {
     const helpTopic = cli.command === 'help'
       ? cli.commandArgs[0]

package/src/cli/parser.ts

@@ -174,6 +174,7 @@ export function parseGoodVibesCli(
   const commandArgs: string[] = [];
   const positionals: string[] = [];
   const errors: string[] = [];
+  const warnings: string[] = [];
   let sawCommand = false;
   let passthrough = false;
 
@@ -292,6 +293,9 @@ export function parseGoodVibesCli(
       const consumed = getValue(argv, index, inlineValue, name, errors);
       index = consumed.nextIndex;
       flags = withFlag(flags, 'outputFormat', normalizeOutputFormat(consumed.value, name, errors));
+      if (name === '--output-format') {
+        warnings.push('--output-format is deprecated; use --output (or -o) instead.');
+      }
       continue;
     }
     if (name === '--config' || name === '-c') {
@@ -353,6 +357,18 @@ export function parseGoodVibesCli(
     errors.push(`Unknown command: ${rawCommand}`);
   }
 
+  // Session lifecycle conflict detection — only one of --continue / --resume / --fork may be used.
+  const sessionLifecycleFlags = [
+    flags.continueLast ? '--continue' : undefined,
+    flags.resume !== undefined ? '--resume' : undefined,
+    flags.fork !== undefined ? '--fork' : undefined,
+  ].filter((f): f is string => f !== undefined);
+  if (sessionLifecycleFlags.length > 1) {
+    errors.push(
+      `Conflicting session lifecycle flags: ${sessionLifecycleFlags.join(' and ')}. Use only one of --continue, --resume, or --fork.`,
+    );
+  }
+
   return {
     binary,
     command,
@@ -361,5 +377,6 @@ export function parseGoodVibesCli(
     positionals,
     flags,
     errors,
+    warnings,
   };
 }

package/src/cli/types.ts

@@ -68,6 +68,8 @@ export interface GoodVibesCliParseResult {
   readonly positionals: readonly string[];
   readonly flags: GoodVibesCliFlags;
   readonly errors: readonly string[];
+  /** Deprecation and soft-warning messages (non-fatal). Callers should surface these to users. */
+  readonly warnings: readonly string[];
 }
 
 export interface CliCommandRuntime {

package/src/config/goodvibes-home-audit.ts

@@ -117,6 +117,8 @@ const KNOWN_DYNAMIC_KEYS = [
   /^featureFlags(?:\.|$)/,
   /^notifications\.webhookUrls$/,
   /^wrfc\.gates$/,
+  // TUI-bridged setting awaiting SDK schema registration (handoff Item 5b)
+  /^tts\.speed$/,
 ];
 
 export const GOODVIBES_ALLOWED_WRITE_ROOTS = ['tui/', 'daemon/'] as const;

package/src/core/context-auto-compact.ts

@@ -0,0 +1,77 @@
+/**
+ * Auto-compaction helper — TASK-058.
+ *
+ * Evaluates whether auto-compact should run after a turn completes and, if so,
+ * triggers compaction and posts an honest transcript notice.
+ *
+ * behavior.autoCompactThreshold: SDK schema range [10, 100], default 80.
+ * Auto-compact is active whenever the threshold is in its valid range (>0).
+ * The display/suggestion path (hint + meter) is always active regardless.
+ */
+
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConversationManager } from './conversation';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import type { SystemMessageRouter } from './system-message-router';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+export interface AutoCompactDeps {
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly conversation: ConversationManager;
+  readonly providerRegistry: ProviderRegistry;
+  readonly systemMessageRouter: SystemMessageRouter;
+  readonly model: string;
+  readonly provider: string;
+  readonly lastInputTokens: number;
+  readonly contextWindow: number;
+}
+
+/**
+ * Run after each TURN_COMPLETED event.
+ *
+ * Reads behavior.autoCompactThreshold from config (SDK default: 80, range [10, 100]).
+ * When usage is at or above the threshold, compacts the conversation and posts
+ * an honest transcript notice so the user understands any summary discontinuity.
+ *
+ * This function is intentionally non-throwing; failures are logged and
+ * surfaced via the system message router.
+ */
+export async function maybeAutoCompact(deps: AutoCompactDeps): Promise<void> {
+  // SDK schema default is 80; valid range is [10, 100]. The ?? 0 fallback is a
+  // defensive guard for missing/null values only — not a normal operating state.
+  const rawThreshold = Number(deps.configManager.get('behavior.autoCompactThreshold') ?? 0);
+  const thresholdPct = Number.isFinite(rawThreshold) ? rawThreshold : 0;
+
+  // Defensive guard: skip only when threshold is missing/non-positive (real config defaults to 80).
+  if (thresholdPct <= 0 || deps.contextWindow <= 0) return;
+
+  const usagePct = Math.min(100, Math.round((Math.max(0, deps.lastInputTokens) / deps.contextWindow) * 100));
+  if (usagePct < thresholdPct) return;
+
+  try {
+    logger.debug('auto-compact triggered', { usagePct, thresholdPct });
+    // Honest transcript notice — the user should always know when compaction
+    // runs automatically so they can understand any summary discontinuity.
+    deps.systemMessageRouter.routeSystemMessage(
+      `[Context] Auto-compacting conversation — usage reached ${usagePct}% (threshold ${thresholdPct}%). A summary will replace older turns to recover headroom.`,
+      'high',
+    );
+    await deps.conversation.compact(
+      deps.providerRegistry,
+      deps.model,
+      'auto',
+      deps.provider,
+    );
+    deps.systemMessageRouter.routeSystemMessage(
+      `[Context] Auto-compact complete — older turns summarised. Use /compact to compact again manually.`,
+      'low',
+    );
+  } catch (err) {
+    logger.error('auto-compact failed', { error: summarizeError(err) });
+    deps.systemMessageRouter.routeSystemMessage(
+      `[Context] Auto-compact failed: ${summarizeError(err)}. Use /compact to try manually.`,
+      'high',
+    );
+  }
+}

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/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/session-workflow.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from 'node:crypto';
 
-import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { CommandContext } from '../command-registry.ts';
 import { type SessionMeta } from '@pellux/goodvibes-sdk/platform/sessions';
 import type { TranscriptEventKind } from '@pellux/goodvibes-sdk/platform/core';
 import type { ConversationTitleSource } from '../../core/conversation';
@@ -441,21 +441,13 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
   return false;
 }
 
-export function registerSessionWorkflowCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'session-mgmt',
-    aliases: ['smgmt'],
-    description: 'Manage sessions, resume posture, and transcript structure',
-    usage: '[list | rename <name> | resume <id|name> | fork | save | info <id> | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id>]',
-    argsHint: '<list|rename|resume|fork|save|info|events|groups|hotspots|export|search|delete>',
-    async handler(args, ctx) {
-      const handled = await handleSessionWorkflowCommand(args, ctx);
-      if (!handled) {
-        ctx.print('Unknown subcommand: ' + (args[0] ?? '') + '\nUsage: /session-mgmt [list | rename <name> | resume <id> | fork [name] | save [name] | info [id] | events [kind] | groups [kind] | hotspots | export <id> [format] | search <query> | delete <id>]');
-      }
-    },
-  });
-}
+// session-mgmt / smgmt was removed in TASK-032.
+// All session lifecycle operations are now first-class subcommands of /session.
+// Use /session list, /session resume, /session save, etc.
+//
+// CommandRegistry.register() throws on duplicate names/aliases, so this
+// registration was intentionally deleted rather than left as dead code.
+
 interface SessionExportData {
   readonly messages: object[];
   readonly timestamp?: number;