@pellux/goodvibes-tui 0.20.3 → 0.22.0

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

@@ -196,18 +196,18 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
   });
 
   registry.register({
-    name: 'knowledge',
-    aliases: ['know'],
-    description: 'Inspect durable project knowledge, risks, runbooks, and architecture notes',
+    name: 'project-memory',
+    aliases: ['pmem'],
+    description: 'Inspect durable project memory: risks, runbooks, and architecture notes',
     usage: '[open | queue [limit] | explain <task...> [--scope <path> ...]]',
     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);
@@ -237,7 +237,7 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
         });
         const task = taskTokens.join(' ').trim();
         if (!task) {
-          ctx.print('Usage: /knowledge explain <task...> [--scope <path> ...]');
+          ctx.print('Usage: /project-memory explain <task...> [--scope <path> ...]');
           return;
         }
         const injections = selectKnowledgeForTask(memory, task, scopeValues);
@@ -245,11 +245,11 @@ 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 knowledge subcommand: ${subcommand}`);
+      ctx.print(`Unknown project-memory subcommand: ${subcommand}`);
     },
   });
 }

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

@@ -222,7 +222,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
 
   registry.register({
     name: 'voice',
-    description: 'Review voice posture and package portable voice-surface metadata',
+    description: 'Review or toggle always-speak mode (same switch as /tts on|off) and package portable voice metadata',
     usage: '[review|enable|disable|bundle export <path>|bundle inspect <path>]',
     handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
@@ -231,8 +231,9 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         const enabled = Boolean(ctx.platform.configManager.get('ui.voiceEnabled') ?? false);
         ctx.print([
           'Voice Review',
-          `  enabled: ${enabled ? 'yes' : 'no'}`,
-          '  posture: optional local companion surface; disabled by default',
+          `  always-speak: ${enabled ? 'on' : 'off'}`,
+          '  config key: ui.voiceEnabled (same as /tts on|off)',
+          '  posture: optional local TTS output; disabled by default',
           '  note: voice remains an optional operator convenience, not a required SaaS dependency',
         ].join('\n'));
         return;
@@ -240,7 +241,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
       if (sub === 'enable' || sub === 'disable') {
         const next = sub === 'enable';
         ctx.platform.configManager.setDynamic('ui.voiceEnabled', next);
-        ctx.print(`Voice surface ${next ? 'enabled' : 'disabled'} for this runtime.`);
+        ctx.print(`Always-speak mode ${next ? 'enabled' : 'disabled'}. ${next ? 'Every submitted turn will be played through live TTS.' : 'Use /tts <prompt> to speak individual turns.'}`);
         return;
       }
       if (sub === 'bundle') {

package/src/input/commands/knowledge.ts

@@ -131,7 +131,7 @@ function renderKnowledgeAskResult(result: KnowledgeAskResult): string {
 
 export const knowledgeCommand: SlashCommand = {
   name: 'knowledge',
-  aliases: ['know', 'kb'],
+  aliases: ['know'],
   description: 'Structured knowledge graph: ingest URLs/bookmarks, inspect issues, and build compact prompt packets.',
   usage: '<subcommand> [args]',
   argsHint: 'status|ask|ingest-url|import-bookmarks|import-urls|list|search|get|queue|review-issue|candidates|reports|schedules|lint|packet|explain|reindex|consolidate',

package/src/input/commands/local-auth-runtime.ts

@@ -17,11 +17,22 @@ export function handleLocalAuthCommand(args: string[], ctx: CommandContext): voi
   if (sub === 'add-user') {
     const username = args[1];
     const password = args[2];
-    const roles = args[3]?.split(',').map((value) => value.trim()).filter(Boolean) ?? ['admin'];
-    if (!username || !password) {
-      ctx.print('Usage: /auth local add-user <username> <password> [roles]');
+    if (!username) {
+      ctx.print('Usage: /auth local add-user <username> <password> [roles]\nTip: invoke without a password to use the masked panel: /auth local add-user <username>');
+      return;
+    }
+    if (!password) {
+      // No password supplied — open masked-entry mode on the LocalAuthPanel.
+      if (ctx.openLocalAuthMaskedEntry) {
+        ctx.openLocalAuthMaskedEntry('add-user', username);
+      } else {
+        ctx.print('Masked entry unavailable in this context. Use: /auth local add-user <username> <password>');
+      }
       return;
     }
+    // Password supplied as argv: warn that the history entry has been scrubbed.
+    ctx.print('Warning: passwords passed as command arguments are scrubbed from history, but may appear in shell scrollback. The masked entry is preferred: /auth local add-user <username>');
+    const roles = args[3]?.split(',').map((value) => value.trim()).filter(Boolean) ?? ['admin'];
     try {
       const added = auth.addUser(username, password, roles);
       ctx.print(`Added local auth user ${added.username} (${formatRoles(added.roles)}).`);
@@ -49,10 +60,21 @@ export function handleLocalAuthCommand(args: string[], ctx: CommandContext): voi
   if (sub === 'rotate-password') {
     const username = args[1];
     const password = args[2];
-    if (!username || !password) {
-      ctx.print('Usage: /auth local rotate-password <username> <password>');
+    if (!username) {
+      ctx.print('Usage: /auth local rotate-password <username> <password>\nTip: invoke without a password to use the masked panel: /auth local rotate-password <username>');
+      return;
+    }
+    if (!password) {
+      // No password supplied — open masked-entry mode on the LocalAuthPanel.
+      if (ctx.openLocalAuthMaskedEntry) {
+        ctx.openLocalAuthMaskedEntry('rotate-password', username);
+      } else {
+        ctx.print('Masked entry unavailable in this context. Use: /auth local rotate-password <username> <password>');
+      }
       return;
     }
+    // Password supplied as argv: warn that the history entry has been scrubbed.
+    ctx.print('Warning: passwords passed as command arguments are scrubbed from history, but may appear in shell scrollback. The masked entry is preferred: /auth local rotate-password <username>');
     try {
       auth.rotatePassword(username, password);
       ctx.print(`Rotated password for ${username}. Existing sessions were revoked.`);

package/src/input/commands/local-setup.ts

@@ -1,5 +1,6 @@
 import { dirname, join } from 'path';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { atomicWriteFileSync } from '../../config/atomic-write.ts';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { ConfigKey } from '../../config/index.ts';
 import { CONFIG_SCHEMA } from '../../config/index.ts';
@@ -204,18 +205,15 @@ export function registerLocalSetupCommands(registry: CommandRegistry): void {
             }
             if (bundle.services) {
               const servicesPath = getShellPaths().resolveProjectPath('tui', 'services.json');
-              mkdirSync(dirname(servicesPath), { recursive: true });
-              writeFileSync(servicesPath, JSON.stringify(bundle.services, null, 2) + '\n', 'utf-8');
+              atomicWriteFileSync(servicesPath, JSON.stringify(bundle.services, null, 2) + '\n', { mkdirp: true });
             }
             if (bundle.ecosystem?.plugins) {
               const pluginsPath = getShellPaths().resolveProjectPath('tui', 'ecosystem', 'plugins.json');
-              mkdirSync(dirname(pluginsPath), { recursive: true });
-              writeFileSync(pluginsPath, JSON.stringify(bundle.ecosystem.plugins, null, 2) + '\n', 'utf-8');
+              atomicWriteFileSync(pluginsPath, JSON.stringify(bundle.ecosystem.plugins, null, 2) + '\n', { mkdirp: true });
             }
             if (bundle.ecosystem?.skills) {
               const skillsPath = getShellPaths().resolveProjectPath('tui', 'ecosystem', 'skills.json');
-              mkdirSync(dirname(skillsPath), { recursive: true });
-              writeFileSync(skillsPath, JSON.stringify(bundle.ecosystem.skills, null, 2) + '\n', 'utf-8');
+              atomicWriteFileSync(skillsPath, JSON.stringify(bundle.ecosystem.skills, null, 2) + '\n', { mkdirp: true });
             }
             ctx.print(`Imported setup transfer bundle from ${targetPath}`);
           } catch (error) {

package/src/input/commands/memory-product-runtime.ts

@@ -55,7 +55,7 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
 
   registry.register({
     name: 'session-memory',
-    description: 'Dedicated front-door for session-scoped memory capture and review',
+    description: 'Dedicated front-door for session-scoped memory capture and review. All subcommands are filtered to scope=session.',
     usage: '[queue [limit] | export <path> | add <class> <summary...>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'queue').toLowerCase();
@@ -64,7 +64,8 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'queue') {
-        await ctx.executeCommand('recall', ['queue', ...(args[1] ? [args[1]] : [])]);
+        // Pass --scope session so only session-scoped records appear in the queue.
+        await ctx.executeCommand('recall', ['queue', '--scope', 'session', ...(args[1] ? [args[1]] : [])]);
         return;
       }
       if (sub === 'export' && args[1]) {
@@ -75,13 +76,13 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         await ctx.executeCommand('recall', ['add', args[1], ...args.slice(2), '--scope', 'session']);
         return;
       }
-      ctx.print('Usage: /session-memory [queue [limit] | export <path> | add <class> <summary...>]');
+      ctx.print('Usage: /session-memory [queue [limit] | export <path> | add <class> <summary...>]\nAll subcommands are scoped to session records only.');
     },
   });
 
   registry.register({
     name: 'team-memory',
-    description: 'Dedicated front-door for team/shared memory review and exchange',
+    description: 'Dedicated front-door for team/shared memory review and exchange. The queue and export subcommands are filtered to scope=team.',
     usage: '[queue [limit] | export <path> | import <path> | capture policy]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'queue').toLowerCase();
@@ -90,7 +91,8 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'queue') {
-        await ctx.executeCommand('recall', ['queue', ...(args[1] ? [args[1]] : [])]);
+        // Pass --scope team so only team-scoped records appear in the queue.
+        await ctx.executeCommand('recall', ['queue', '--scope', 'team', ...(args[1] ? [args[1]] : [])]);
         return;
       }
       if (sub === 'export' && args[1]) {
@@ -105,7 +107,7 @@ export function registerMemoryProductRuntimeCommands(registry: CommandRegistry):
         await ctx.executeCommand('recall', ['capture', 'policy']);
         return;
       }
-      ctx.print('Usage: /team-memory [queue [limit] | export <path> | import <path> | capture policy]');
+      ctx.print('Usage: /team-memory [queue [limit] | export <path> | import <path> | capture policy]\nqueue and export are scoped to team records; import applies the bundle\'s own scopes and capture policy is global.');
     },
   });
 }

package/src/input/commands/operator-panel-runtime.ts

@@ -5,7 +5,7 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 export function registerOperatorPanelCommand(registry: CommandRegistry): void {
   registry.register({
     name: 'panel',
-    aliases: ['panels', 'p'],
+    aliases: ['panels'],
     description: 'Open, place, resize, or list panels. Usage: /panel [open <id> [top|bottom]|close <id>|list|toggle|move|focus|split|width|height]',
     usage: '[open <id> [top|bottom]|close <id>|list|toggle|move <top|bottom|other> [id]|focus <top|bottom|toggle>|split [show|hide|toggle]|width <left|right|reset>|height <up|down|reset>]',
     argsHint: '<open|close|list|toggle|move|focus|split|width|height> [id]',

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

@@ -5,6 +5,7 @@ import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
 import { requireOpsApi, requireProfileManager, requireReplayEngine } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { estimateConversationTokens } from '@pellux/goodvibes-sdk/platform/core';
 
 export function registerOperatorRuntimeCommands(registry: CommandRegistry): void {
   registerOperatorPanelCommand(registry);
@@ -32,18 +33,10 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
           ctx.print('[context] No messages in conversation.');
           return;
         }
-        const estimateTokens = (text: string): number => Math.ceil(text.length / 4);
-        let total = 0;
+        const total = estimateConversationTokens(msgs);
         const lines: string[] = ['Context breakdown:'];
         for (const m of msgs) {
-          const text = typeof m.content === 'string'
-            ? m.content
-            : (m.content as Array<{ type: string; text?: string }>)
-              .filter((p) => p.type === 'text')
-              .map((p) => p.text ?? '')
-              .join('');
-          const t = estimateTokens(text);
-          total += t;
+          const t = estimateConversationTokens([m]);
           lines.push(`  ${m.role.padEnd(12)} ~${t.toLocaleString()} tokens`);
         }
         lines.push(`  ${'Total'.padEnd(12)} ~${total.toLocaleString()} tokens (${msgs.length} messages)`);

package/src/input/commands/{integration-runtime.ts → plugin-runtime.ts}

@@ -15,7 +15,7 @@ import {
 } from '@/runtime/index.ts';
 import { requireEcosystemCatalogPaths, requirePluginPathOptions } from './runtime-services.ts';
 
-export function registerIntegrationRuntimeCommands(registry: CommandRegistry): void {
+export function registerPluginRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'plugin',
     aliases: [],

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/recall-review.ts

@@ -7,8 +7,32 @@ export function handleRecallQueue(args: string[], context: CommandContext): void
   if (!memory) {
     return;
   }
-  const limit = Math.max(1, parseInt(args[0] ?? '10', 10) || 10);
-  const queue = memory.reviewQueue(limit);
+
+  // Extract optional --scope filter before parsing the positional limit argument.
+  const scopeIdx = args.indexOf('--scope');
+  let scopeFilter: string | undefined;
+  let remainingArgs = args;
+  if (scopeIdx !== -1 && args[scopeIdx + 1]) {
+    const candidateScope = args[scopeIdx + 1];
+    if (!isValidScope(candidateScope)) {
+      context.print(`[recall] Unknown scope "${candidateScope}". Valid: ${VALID_SCOPES.join(', ')}`);
+      return;
+    }
+    scopeFilter = candidateScope;
+    remainingArgs = args.filter((_, i) => i !== scopeIdx && i !== scopeIdx + 1);
+  }
+
+  const limitRaw = remainingArgs.find((a) => !a.startsWith('--'));
+  const limit = Math.max(1, parseInt(limitRaw ?? '10', 10) || 10);
+
+  // When a scope filter is requested, fetch a larger pool then slice to the
+  // requested limit so scope-sparse queues still return meaningful results.
+  const fetchLimit = scopeFilter ? 1000 : limit;
+  const rawQueue = memory.reviewQueue(fetchLimit);
+  const queue = scopeFilter
+    ? rawQueue.filter((record) => record.scope === scopeFilter).slice(0, limit)
+    : rawQueue;
+
   if (!queue.length) {
     context.print('[recall] Review queue is empty.');
     return;

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

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { atomicWriteFileSync } from '../../config/atomic-write.ts';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
 import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
@@ -161,8 +162,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
         try {
           const parsed = JSON.parse(readFileSync(sourcePath, 'utf-8')) as Record<string, unknown>;
           const targetPath = shellPaths.resolveProjectPath('tui', 'services.json');
-          mkdirSync(dirname(targetPath), { recursive: true });
-          writeFileSync(targetPath, JSON.stringify(parsed, null, 2) + '\n', 'utf-8');
+          atomicWriteFileSync(targetPath, JSON.stringify(parsed, null, 2) + '\n', { mkdirp: true });
           ctx.print(`Imported services config from ${sourcePath}`);
         } catch (error) {
           ctx.print(`Failed to import services config: ${summarizeError(error)}`);

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',
-    aliases: ['sess'],
-    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 [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;

package/src/input/commands/session.ts

@@ -319,18 +319,52 @@ function handleCancel(args: string[], context: CommandContext): void {
 /**
  * sessionCommand — The `/session` slash command.
  *
- * Routes to multi-session orchestration subcommand handlers based on args[0].
+ * The ONE front-door for all session operations. Owns two domains:
+ *
+ * Lifecycle (continuity, export, resume, pruning):
+ *   list | rename | resume | fork | save | info | events | groups | hotspots | export | search | delete
+ *
+ * Orchestration (cross-session task DAG — 40 tests, cycle detection):
+ *   link-task | handoff | graph | cancel
+ *
+ * Orchestration-command decision (TASK-032):
+ *   Both domains live under /session rather than splitting orchestration into
+ *   a separate /session-orch command. Rationale: they share the same entity
+ *   (a session) and the same operator mental model ("I am working with sessions").
+ *   A second front-door would create ambiguity about which command to reach for.
+ *   Explicit switch routing (not fallthrough) makes both domains first-class;
+ *   the former /session-mgmt alias (session-mgmt/smgmt) is removed so there
+ *   is exactly one registration and no silent shadowing.
  */
 export const sessionCommand: SlashCommand = {
   name: 'session',
   aliases: ['sess'],
-  description: 'Multi-session orchestration: link tasks, handoff, view graph, and cancel across sessions.',
+  description: 'Session lifecycle and orchestration: list, resume, fork, save, export, link-task, handoff, graph, cancel.',
   usage: '<subcommand> [args]',
-  argsHint: 'link-task|handoff|graph|cancel',
+  argsHint: 'list|rename|resume|fork|save|info|export|search|delete|events|groups|hotspots|link-task|handoff|graph|cancel',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
     switch (sub) {
+      // ── Lifecycle subcommands ────────────────────────────────────────────────
+      // Each delegates explicitly to handleSessionWorkflowCommand so every
+      // subcommand has a deterministic, named path — no silent fallthrough.
+      case 'list':
+      case 'rename':
+      case 'resume':
+      case 'fork':
+      case 'save':
+      case 'info':
+      case 'export':
+      case 'search':
+      case 'delete':
+      case 'events':
+      case 'groups':
+      case 'hotspots':
+        await handleSessionWorkflowCommand(args, context);
+        break;
+
+      // ── Orchestration subcommands ─────────────────────────────────────────────
       case 'link-task':
       case 'link':
         handleLinkTask(rest, context);
@@ -350,24 +384,40 @@ export const sessionCommand: SlashCommand = {
         handleCancel(rest, context);
         break;
 
+      // ── No-arg: show current session info ────────────────────────────────────
+      case undefined:
+        await handleSessionWorkflowCommand([], context);
+        break;
+
       default: {
-        const handled = await handleSessionWorkflowCommand(args, context);
-        if (!handled) {
-          const usage = [
-            'Usage: /session <subcommand>',
-            '  list | rename <name> | resume <id|name> | fork [name] | save [name] | info [id] | export <id> [format] | search <query> | delete <id>',
-            '                                 — Session continuity, export, resume, and pruning',
-            '  link-task <taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
-            '                                 — Register a task in the cross-session graph',
-            '  handoff <taskId> --to <sid>  [--session <sid>] [--reason <reason>]',
-            '                                 — Hand a task off to another session',
-            '  graph [--session <sid>] [--format text|json]',
-            '                                 — Display the cross-session task dependency graph',
-            '  cancel <taskId> [--scope task|subtree|session] [--session <sid>] [--reason <reason>]',
-            '                                 — Cancel tasks with scoped semantics',
-          ].join('\n');
-          context.print(usage);
-        }
+        const usage = [
+          'Usage: /session <subcommand>',
+          '',
+          'Lifecycle:',
+          '  list                                    — List saved sessions',
+          '  rename <name>                           — Rename the current session',
+          '  resume <id|name>                        — Resume a saved session',
+          '  fork [name]                             — Fork the current session',
+          '  save [name]                             — Save the current session',
+          '  info [id]                               — Show session info',
+          '  export <id|.> [markdown|text]           — Export session transcript',
+          '  search <query>                          — Search session content',
+          '  delete <id>                             — Delete a saved session',
+          '  events [kind]                           — Show transcript events',
+          '  groups [kind]                           — Show transcript groups',
+          '  hotspots                                — Show transcript hotspots',
+          '',
+          'Orchestration:',
+          '  link-task <taskId> [--session <sid>] [--depends-on <sid:taskId>] [--label <label>]',
+          '                                          — Register a task in the cross-session graph',
+          '  handoff <taskId> --to <sid> [--session <sid>] [--reason <reason>]',
+          '                                          — Hand a task off to another session',
+          '  graph [--session <sid>] [--format text|json]',
+          '                                          — Display the cross-session task dependency graph',
+          '  cancel <taskId> [--scope task|subtree|session] [--session <sid>] [--reason <reason>]',
+          '                                          — Cancel tasks with scoped semantics',
+        ].join('\n');
+        context.print(usage);
         break;
       }
     }