@pellux/goodvibes-tui 1.7.0 → 1.9.1

package/src/input/autocomplete.ts

@@ -1,4 +1,4 @@
-import type { SlashCommand } from './command-registry.ts';
+import { COMMON_COMMAND_NAMES, type SlashCommand } from './command-registry.ts';
 import type { CommandRegistry } from './command-registry.ts';
 
 /**
@@ -18,6 +18,14 @@ export interface AutocompleteState {
   query: string;
   results: AutocompleteResult[];
   selectedIndex: number;
+  /**
+   * UX-C (item 4): how many leading entries of `results` belong to the
+   * curated "common" tier — only meaningful when `query === ''` (0
+   * otherwise, since a typed filter searches everything and the common/rest
+   * split no longer applies). The renderer uses this to draw a separator
+   * before the alphabetical rest.
+   */
+  commonCount: number;
 }
 
 /**
@@ -35,6 +43,7 @@ export class AutocompleteEngine {
     query: '',
     results: [],
     selectedIndex: 0,
+    commonCount: 0,
   };
 
   constructor(private registry: CommandRegistry) {}
@@ -47,6 +56,22 @@ export class AutocompleteEngine {
     this.state.query = query;
     this.state.results = this.registry.fuzzyMatch(query);
     this.state.active = true;
+    // UX-C: fuzzyMatch('') sorts the curated common tier first (score 2),
+    // then the alphabetical rest (score 1) — both tiers alphabetical within
+    // themselves. Count the leading common run to tell the renderer where to
+    // draw the separator. A non-empty query means every command was scored on
+    // its actual match quality, not tier, so the common/rest split does not
+    // apply — the resulting 0 is not a real answer to "how many are common"
+    // and is unused because renderAutocompleteOverlay itself gates on the
+    // query string too, but zeroing here keeps the field internally honest.
+    let commonCount = 0;
+    if (query === '') {
+      for (const result of this.state.results) {
+        if (!COMMON_COMMAND_NAMES.has(result.command.name)) break;
+        commonCount++;
+      }
+    }
+    this.state.commonCount = commonCount;
     // Clamp selection to new result count
     if (this.state.selectedIndex >= this.state.results.length) {
       this.state.selectedIndex = Math.max(0, this.state.results.length - 1);
@@ -79,6 +104,7 @@ export class AutocompleteEngine {
       query: '',
       results: [],
       selectedIndex: 0,
+      commonCount: 0,
     };
   }
 

package/src/input/command-registry.ts

@@ -8,7 +8,7 @@ import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/pe
 import type { SelectionItem, SelectionResult, SelectionAction } from './selection-modal.ts';
 import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
 import type { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
-import type { PanelManager } from '../panels/panel-manager.ts';
+import type { PanelManager, PanelDeepLinkTarget } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
 import type { OpenOnboardingWizardOptions } from './handler-ui-state.ts';
@@ -48,6 +48,13 @@ export interface CommandRuntimeState {
   systemPrompt: string;
   reasoningEffort: string;
   sessionId: string;
+  /**
+   * Cumulative count of direct terminal writes the output guard intercepted
+   * this session — surfaced by /debug. Optional so the SDK's MutableRuntimeState
+   * (which has no such field) stays assignable; the guard sets it lazily on the
+   * shared runtime object. (UX-B item 1a.)
+   */
+  terminalWritesIntercepted?: number;
 }
 
 /**
@@ -115,7 +122,7 @@ export interface CommandShellUiOpeners {
   openSelection?: (
     title: string,
     items: SelectionItem[],
-    opts: { preSelectId?: string; allowSearch?: boolean; customActions?: Map<string, SelectionAction> } | undefined,
+    opts: { preSelectId?: string; allowSearch?: boolean; customActions?: Map<string, SelectionAction>; primaryVerbLabel?: string } | undefined,
     callback: (result: SelectionResult | null) => void,
   ) => void;
   openSettingsModal?: (target?: string) => void;
@@ -131,7 +138,16 @@ export interface CommandShellUiOpeners {
   openShortcutsOverlay?: () => void;
   getScrollTop?: () => number;
   openPanelPicker?: () => void;
-  showPanel?: (panelId: string, pane?: 'top' | 'bottom') => void;
+  /**
+   * Open (and optionally focus) a panel. UX-C focus rule: the command path is
+   * "the user is mid-command-flow" — opening a panel this way leaves keyboard
+   * focus in the composer by default. Pass `{ focus: true }` for a caller that
+   * genuinely wants to grab focus (chords use panelManager.focusPanels()
+   * directly instead of this method, so no current call site needs it — but
+   * the intent is explicit rather than implicit here). `target` (DEBT-5) is a
+   * fleet deep-link jump target forwarded to PanelManager.open.
+   */
+  showPanel?: (panelId: string, pane?: 'top' | 'bottom', target?: PanelDeepLinkTarget, opts?: { focus?: boolean }) => void;
   focusPanels?: () => void;
   focusPrompt?: () => void;
   openOpsPanel?: () => void;
@@ -180,6 +196,10 @@ export interface CommandSessionServices {
   readonly workstreamEngine?: import('../runtime/workstream-services.ts').WorkstreamCommandService;
   /** Wave 5 (wo804): the repo source-tree code index — see runtime/code-index-services.ts. */
   readonly codeIndexStore?: import('@pellux/goodvibes-sdk/platform/state').CodeIndexStore;
+  /** Wave-5 Stage B: tool-site reindex scheduler — `/codebase status` reports its last activity. */
+  readonly codeIndexReindexScheduler?: import('@pellux/goodvibes-sdk/platform/state').CodeIndexReindexScheduler;
+  /** Wave-5 Stage B: whether the (default-off) `agent-passive-code-injection` flag is on — for `/codebase status`. */
+  readonly isPassiveCodeInjectionFlagEnabled?: () => boolean;
   /**
    * Wave 5 (wo805): the MAIN interactive session's per-turn passive-injection
    * honesty ring — `Orchestrator.getTurnInjections()`, the main-session
@@ -272,6 +292,23 @@ export interface CommandContext
   };
 }
 
+/**
+ * UX-C palette curation (item 4): the "common" first tier the slash-command
+ * autocomplete dropdown shows before the alphabetical rest when it opens with
+ * no filter typed yet (bare '/') — the "132-command palette unranked"
+ * evaluator finding. Typed filtering (any non-empty query) is completely
+ * unaffected — fuzzyMatch still searches every registered command exactly as
+ * before; this only reorders the empty-query case. Curated for breadth across
+ * the product's main workflows rather than raw usage frequency: help/config
+ * (orientation), panel/model (workspace + provider), recall/codebase/search
+ * (knowledge), workstream/checkpoint (control-plane), imagine (generation),
+ * sessions (continuity), quit (exit).
+ */
+export const COMMON_COMMAND_NAMES: ReadonlySet<string> = new Set([
+  'help', 'config', 'panel', 'model', 'recall', 'codebase',
+  'workstream', 'checkpoint', 'search', 'imagine', 'sessions', 'quit',
+]);
+
 /**
  * SlashCommand - A single slash command definition.
  */
@@ -374,7 +411,12 @@ export class CommandRegistry {
       }
 
       if (bestScore > 0 || q === '') {
-        results.push({ command: cmd, score: q === '' ? 1 : bestScore });
+        // UX-C: with no query yet, rank the curated common tier (score 2)
+        // ahead of everything else (score 1) — the tie-break below then sorts
+        // each tier alphabetically, so the result is "common tier, then the
+        // alphabetical rest" rather than one flat alphabetical list.
+        const score = q === '' ? (COMMON_COMMAND_NAMES.has(cmd.name) ? 2 : 1) : bestScore;
+        results.push({ command: cmd, score });
       }
     }
 

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

@@ -14,11 +14,12 @@
 // node while it runs), status (counts, skips, degradation state, last
 // build), search <query> (explicit retrieval, results labeled
 // 'lexical'|'semantic' honestly — never implied as more precise than they
-// are). This is Stage A only: no auto-injection into coding turns (Stage B,
-// out of scope — see the wo802/W5.3 design doc).
+// are). Stage B (now landed) adds passive auto-injection into coding turns and
+// tool-site incremental reindex; `status` surfaces both honestly (the
+// auto-injection flag+setting gate, and the last reindex activity).
 // ---------------------------------------------------------------------------
 
-import type { CodeIndexStats, CodeContextResult } from '@pellux/goodvibes-sdk/platform/state';
+import type { CodeIndexStats, CodeContextResult, CodeIndexReindexActivity } from '@pellux/goodvibes-sdk/platform/state';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { isCodeIndexAutoStartEnabled, CODE_INDEX_MAX_FILES, CODE_INDEX_MAX_FILE_BYTES, CODE_INDEX_MAX_TOTAL_BYTES } from '../../runtime/code-index-services.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
@@ -33,7 +34,40 @@ function formatBytes(bytes: number): string {
   return `${bytes}B`;
 }
 
-function renderCodeIndexStatus(stats: CodeIndexStats, configManager: Pick<ConfigManager, 'get'>): string {
+/**
+ * Honest one-line auto-injection state (Stage B): both the (default-off)
+ * `agent-passive-code-injection` feature flag AND storage.codeIndexEnabled must
+ * be on for passive code injection to run — state which is off, and why.
+ */
+function renderAutoInjectionState(flagEnabled: boolean, settingEnabled: boolean): string {
+  if (flagEnabled && settingEnabled) {
+    return '  auto-injection: on (code hits may be injected into coding turns within the shared knowledge budget)';
+  }
+  const reasons: string[] = [];
+  if (!flagEnabled) reasons.push('agent-passive-code-injection flag off (default off) — enable in the settings modal flags section');
+  if (!settingEnabled) reasons.push('storage.codeIndexEnabled off — /config to change');
+  return `  auto-injection: off (${reasons.join('; ')})`;
+}
+
+/** Honest last-reindex activity line (Stage B tool-site incremental reindex). */
+function renderReindexActivity(activity: CodeIndexReindexActivity | null, now: number): string {
+  if (!activity) return '  last reindex: none this session (writes/edits reindex touched files once the index is built)';
+  const agoSec = Math.max(0, Math.round((now - activity.at) / 1000));
+  const detail = activity.status === 'error'
+    ? `error: ${activity.error ?? 'unknown'}`
+    : activity.status === 'skipped'
+      ? `skipped (${activity.mode ?? 'empty'})`
+      : `indexed (${activity.mode ?? 'symbols'})`;
+  return `  last reindex: ${activity.path} — ${detail}, ${agoSec}s ago`;
+}
+
+interface CodeIndexStatusExtras {
+  readonly flagEnabled: boolean;
+  readonly reindexActivity: CodeIndexReindexActivity | null;
+  readonly now?: number;
+}
+
+function renderCodeIndexStatus(stats: CodeIndexStats, configManager: Pick<ConfigManager, 'get'>, extras: CodeIndexStatusExtras): string {
   const lines: string[] = [];
   lines.push(`Code index — backend: ${stats.backend}, available: ${stats.available ? 'yes' : 'no'}`);
   lines.push(`  path: ${stats.path}`);
@@ -48,6 +82,9 @@ function renderCodeIndexStatus(stats: CodeIndexStats, configManager: Pick<Config
   lines.push(
     `  auto-build on startup: ${autoStart ? 'on' : 'off'} (storage.codeIndexEnabled, default off — /config to change)`,
   );
+  // Stage B surfacing: passive code auto-injection state (flag + setting) and the last tool-site reindex.
+  lines.push(renderAutoInjectionState(extras.flagEnabled, autoStart));
+  lines.push(renderReindexActivity(extras.reindexActivity, extras.now ?? Date.now()));
   lines.push(
     `  bounds: max ${CODE_INDEX_MAX_FILES} files (maxFiles), ${formatBytes(CODE_INDEX_MAX_FILE_BYTES)} per file (maxFileBytes),`
     + ` ${formatBytes(CODE_INDEX_MAX_TOTAL_BYTES)} total per build (maxTotalBytes)`,
@@ -133,7 +170,7 @@ const USAGE = 'Usage:\n'
 export function registerCodebaseRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'codebase',
-    description: 'Repo source-tree code index — build, inspect, and search (Wave-5 W5.3 Stage A)',
+    description: 'Repo source-tree code index — build, inspect, and search',
     usage: 'build | status | search <query...> [--limit n]',
     argsHint: 'build | status | search <query>',
     handler(args: string[], ctx: CommandContext) {
@@ -146,7 +183,10 @@ export function registerCodebaseRuntimeCommands(registry: CommandRegistry): void
       const sub = args[0];
 
       if (!sub || sub === 'status') {
-        ctx.print(renderCodeIndexStatus(store.stats(), ctx.platform.configManager));
+        ctx.print(renderCodeIndexStatus(store.stats(), ctx.platform.configManager, {
+          flagEnabled: ctx.session.isPassiveCodeInjectionFlagEnabled?.() ?? false,
+          reindexActivity: ctx.session.codeIndexReindexScheduler?.lastActivity() ?? null,
+        }));
         return;
       }
 

package/src/input/commands/config.ts

@@ -1,13 +1,45 @@
 import type { CommandRegistry } from '../command-registry.ts';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { setActiveThemeMode, type ThemeMode } from '../../renderer/theme.ts';
 
 export function registerConfigCommand(registry: CommandRegistry): void {
   registry.register({
     name: 'config',
     aliases: ['cfg'],
-    description: 'Open the fullscreen configuration workspace',
-    usage: '[category|key]',
-    argsHint: '[category|key]',
+    description: 'Open the fullscreen configuration workspace, or set a key directly',
+    usage: '[category|key] | set <key> <value>',
+    argsHint: '[category|key] | set <key> <value>',
     handler(args, ctx) {
+      // Batch replay D2: `/config set <key> <value>` used to fall through to
+      // the workspace with the assignment silently ignored — the dishonest-
+      // fallthrough class. `set` is now a real verb.
+      if (args[0] === 'set') {
+        const key = args[1];
+        const value = args.slice(2).join(' ');
+        if (!key || value === '') {
+          ctx.print('Usage: /config set <key> <value> — e.g. /config set display.themeMode light');
+          return;
+        }
+        try {
+          const before = ctx.platform.configManager.get(key as ConfigKey);
+          ctx.platform.configManager.setDynamic(key as ConfigKey, coerceConfigValue(value));
+          const after = ctx.platform.configManager.get(key as ConfigKey);
+          ctx.print(`Set ${key}: ${JSON.stringify(before)} → ${JSON.stringify(after)}`);
+          // Forced theme modes apply immediately (matches the settings-modal
+          // path); 'auto' re-probes on the next launch (stated honestly).
+          if (key === 'display.themeMode') {
+            if (after === 'dark' || after === 'light') {
+              setActiveThemeMode(after as ThemeMode);
+              ctx.print('Theme applied. Note: transcript, modal, and header/footer/thinking chrome all flip; only the background colour follows your terminal.');
+            } else {
+              ctx.print('Theme mode "auto" probes the terminal background on the next launch.');
+            }
+          }
+        } catch (e) {
+          ctx.print(`Could not set ${key}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return;
+      }
       if (ctx.openSettingsModal) {
         ctx.openSettingsModal(args[0]);
         return;
@@ -16,3 +48,11 @@ export function registerConfigCommand(registry: CommandRegistry): void {
     },
   });
 }
+
+/** Coerce CLI text to the JSON-ish scalar the config schema expects. */
+function coerceConfigValue(raw: string): unknown {
+  if (raw === 'true') return true;
+  if (raw === 'false') return false;
+  if (raw !== '' && Number.isFinite(Number(raw))) return Number(raw);
+  return raw;
+}

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

@@ -39,7 +39,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
     name: 'health',
     aliases: ['doctor'],
     description: 'Health workspace for startup posture, service readiness, sandbox posture, and provider health',
-    usage: '[open|review|setup|services|sandbox|provider|accounts|auth|settings|intelligence|remote|mcp|continuity|worktrees|maintenance|term|repair [domain]]',
+    usage: '[report|review|open|setup|services|sandbox|provider|accounts|auth|settings|intelligence|remote|mcp|continuity|worktrees|maintenance|term|repair [domain]] — bare and report stay a cross-domain transcript report (see also /health provider for the providers modal)',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       const readModels = requireReadModels(ctx);
@@ -424,6 +424,14 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
 
       ctx.print([
         'Health Review',
+        // DEBT-5 item 3: /health stays a cross-domain transcript report (it
+        // genuinely spans settings/accounts/auth/sandbox/etc — no single
+        // modal owns this data), but the providers domain DOES have one, so
+        // point at it honestly. "/provider" (no domain) is a DIFFERENT
+        // command (switch/manage custom providers) — the real front door to
+        // the providers modal is /health provider (see sub === 'provider'
+        // above), so that is what this hint names.
+        '  see also: the providers modal — /health provider',
         `  session: ${snapshot.sessionId}`,
         `  setup issues: ${snapshot.issues.length}`,
         `  service issues: ${snapshot.serviceIssues.length}`,

package/src/input/commands/memory.ts

@@ -22,16 +22,77 @@ import { VALID_CLASSES, VALID_REVIEW_STATES, VALID_SCOPES } from './recall-share
 
 // ── Top-level command ─────────────────────────────────────────────────────────
 
+/**
+ * DEBT-5 item 3 divergence note (historical): the work order that shipped
+ * this command named its front door "/memory", but at the time `/memory` was
+ * already a distinct, unrelated command (session-pinned sticky notes,
+ * src/input/commands/session-content.ts) with no modal surface — so that
+ * work order deliberately did NOT touch /memory and used /recall instead.
+ *
+ * W6-C3 update (Wave 6 core-verb pass, MEMORY fragmentation — worst-class
+ * collision #2): the agent's own `/memory` command was a plain alias for its
+ * `/recall`-equivalent the whole time, meaning "/memory" meant two unrelated
+ * things depending which surface you were on. The session-notes command was
+ * renamed to `/note` (session-content.ts) to free the word, and `/memory` is
+ * now registered here as a real alias of `/recall` — the word means the same
+ * durable Project Memory Substrate on both surfaces. The modal that exists
+ * for this data — the Project Memory Substrate — is still `memory-modal.ts`,
+ * owned by THIS command, confirmed by the panel-id redirect
+ * `registerModalRedirect('memory', 'memory-modal')` in builtin-modals.ts.
+ */
+function printRecallUsage(context: CommandContext): void {
+  const usage = [
+    'Usage: /recall <subcommand>',
+    '  add <class> <summary> [--scope <session|project|team>] [--detail <text>] [--tags <t,t>] [--session <id>] [--task <id>] [--file <path>]',
+    `       classes: ${VALID_CLASSES.join(', ')}`,
+    '  capture incident <id|latest>                    — Capture a forensics incident as durable memory',
+    '  capture policy                                  — Capture the latest policy preflight review as durable memory',
+    '  capture mcp <server>                            — Capture MCP trust/quarantine posture as durable memory',
+    '  capture plugin <name>                           — Capture plugin trust/quarantine posture as durable memory',
+    '  search [query] [--semantic] [--cls <class>] [--scope <scope>] [--limit <n>]  — Full-text or sqlite-vec semantic search',
+    '  vector [status|doctor|rebuild]                  — Inspect or rebuild the sqlite-vec memory index',
+    '  get <id>                                       — Show record with provenance + links',
+    '  link <fromId> <toId> <relation>               — Create a directed relation between records',
+    '  queue [limit]                                  — Show the operator review queue',
+    '  review <id> <state> [--confidence <n>] [--by <name>] [--reason <text>]',
+    '  stale <id> [reason...]                          — Mark a record stale with an operator reason',
+    '  contradict <id> [reason...]                     — Mark a record contradicted with an operator reason',
+    '  explain <task...> [--scope <path> ...]         — Show the knowledge records that would be injected for a task',
+    '  injections [agentId]                           — Show per-turn passive knowledge injection records; no id shows the main session, an id shows that spawned agent',
+    '  promote <id> <scope>                           — Promote a memory record into session|project|team scope',
+    '  export <path> [--scope <scope>] [--cls <class>] — Export a durable knowledge bundle',
+    '  import <path>                                  — Import a durable knowledge bundle',
+    '  handoff-export <path> [--scope <scope>]        — Export a reviewable handoff bundle for team/shared use',
+    '  handoff-inspect <path>                         — Inspect a handoff bundle before import',
+    '  handoff-import <path>                          — Import a handoff bundle into durable memory',
+    '  list [class] [--scope <scope>]                 — List all records grouped by class',
+    '  remove <id>                                    — Delete a record',
+  ].join('\n');
+  context.print(usage);
+}
+
 export const recallCommand: SlashCommand = {
   name: 'recall',
-  aliases: ['rc'],
-  description: 'Project memory: add decisions, constraints, incidents, and patterns with provenance',
-  usage: '<subcommand> [args]',
-  argsHint: 'add|search|link|get|list|remove',
+  aliases: ['rc', 'memory', 'mem'],
+  description: 'Bare opens the Memory modal; project memory subcommands add decisions, constraints, incidents, and patterns with provenance',
+  usage: '[<subcommand> [args]] — bare opens the modal; report prints the subcommand usage text',
+  argsHint: 'add|search|link|get|list|remove|report',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     const [sub, ...rest] = args;
 
+    // DEBT-5 item 3: bare `/recall` opens the memory-modal surface — the old
+    // bare/unknown-subcommand usage block moved to an explicit `report`
+    // subcommand (scriptability preserved: /recall report).
+    if (sub === undefined) {
+      context.openModal?.('memory-modal');
+      return;
+    }
+
     switch (sub) {
+      case 'report':
+        printRecallUsage(context);
+        break;
+
       case 'add':
         await handleRecallAdd(rest, context);
         break;
@@ -120,37 +181,9 @@ export const recallCommand: SlashCommand = {
         await handleRecallHandoffImport(rest, context);
         break;
 
-      default: {
-        const usage = [
-          'Usage: /recall <subcommand>',
-          '  add <class> <summary> [--scope <session|project|team>] [--detail <text>] [--tags <t,t>] [--session <id>] [--task <id>] [--file <path>]',
-          `       classes: ${VALID_CLASSES.join(', ')}`,
-          '  capture incident <id|latest>                    — Capture a forensics incident as durable memory',
-          '  capture policy                                  — Capture the latest policy preflight review as durable memory',
-          '  capture mcp <server>                            — Capture MCP trust/quarantine posture as durable memory',
-          '  capture plugin <name>                           — Capture plugin trust/quarantine posture as durable memory',
-          '  search [query] [--semantic] [--cls <class>] [--scope <scope>] [--limit <n>]  — Full-text or sqlite-vec semantic search',
-          '  vector [status|doctor|rebuild]                  — Inspect or rebuild the sqlite-vec memory index',
-          '  get <id>                                       — Show record with provenance + links',
-          '  link <fromId> <toId> <relation>               — Create a directed relation between records',
-          '  queue [limit]                                  — Show the operator review queue',
-          '  review <id> <state> [--confidence <n>] [--by <name>] [--reason <text>]',
-          '  stale <id> [reason...]                          — Mark a record stale with an operator reason',
-          '  contradict <id> [reason...]                     — Mark a record contradicted with an operator reason',
-          '  explain <task...> [--scope <path> ...]         — Show the knowledge records that would be injected for a task',
-          '  injections [agentId]                           — Show per-turn passive knowledge injection records (Wave-5); no id shows the main session, an id shows that spawned agent',
-          '  promote <id> <scope>                           — Promote a memory record into session|project|team scope',
-          '  export <path> [--scope <scope>] [--cls <class>] — Export a durable knowledge bundle',
-          '  import <path>                                  — Import a durable knowledge bundle',
-          '  handoff-export <path> [--scope <scope>]        — Export a reviewable handoff bundle for team/shared use',
-          '  handoff-inspect <path>                         — Inspect a handoff bundle before import',
-          '  handoff-import <path>                          — Import a handoff bundle into durable memory',
-          '  list [class] [--scope <scope>]                 — List all records grouped by class',
-          '  remove <id>                                    — Delete a record',
-        ].join('\n');
-        context.print(usage);
-        break;
-      }
+      default:
+        printRecallUsage(context);
+        break;
     }
   },
 };

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

@@ -1,13 +1,32 @@
 import type { CommandRegistry } from '../command-registry.ts';
+import type { PanelDeepLinkTarget } from '../../panels/panel-manager.ts';
 import { requirePanelManager } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
+/**
+ * Parse `--target <id>[:<kind>]` out of the args following `<panel-id>
+ * [top|bottom]` (DEBT-5 item 4). Splits the args array in place (removing the
+ * flag + its value) so positional `pane` parsing downstream is unaffected by
+ * where the flag appears. Only `open fleet` currently has a deep-link
+ * consumer (FleetPanel.receiveDeepLink) — other panel ids just ignore an
+ * unused target via PanelManager's optional-chaining delivery.
+ */
+function extractTargetFlag(rest: string[]): PanelDeepLinkTarget | undefined {
+  const flagIdx = rest.indexOf('--target');
+  if (flagIdx < 0) return undefined;
+  const raw = rest[flagIdx + 1];
+  rest.splice(flagIdx, 2);
+  if (!raw) return undefined;
+  const sep = raw.indexOf(':');
+  return sep >= 0 ? { id: raw.slice(0, sep), kind: raw.slice(sep + 1) } : { id: raw };
+}
+
 export function registerOperatorPanelCommand(registry: CommandRegistry): void {
   registry.register({
     name: 'panel',
     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>]',
+    usage: '[open <id> [top|bottom] [--target <id>[:<kind>]]|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]',
     handler(args, ctx) {
       const pm = requirePanelManager(ctx);
@@ -38,10 +57,12 @@ export function registerOperatorPanelCommand(registry: CommandRegistry): void {
         ctx.print(lines.length > 0 ? lines.join('\n') : 'No panels registered.');
       } else if (sub === 'open') {
         const id = args[1];
-        const pane = args[2]?.toLowerCase();
+        const rest = args.slice(2);
+        const target = extractTargetFlag(rest);
+        const pane = rest[0]?.toLowerCase();
         if (!id) { ctx.print('Usage: /panel open <panel-id>'); return; }
         if (pane && pane !== 'top' && pane !== 'bottom') {
-          ctx.print('Usage: /panel open <panel-id> [top|bottom]');
+          ctx.print('Usage: /panel open <panel-id> [top|bottom] [--target <id>[:<kind>]]');
           return;
         }
         try {
@@ -50,11 +71,13 @@ export function registerOperatorPanelCommand(registry: CommandRegistry): void {
           // no panel lands in the workspace. Report that honestly rather than
           // claiming "Panel opened: <id>".
           const redirectTarget = pm.getModalRedirect(id);
-          if (ctx.showPanel) ctx.showPanel(id, pane as 'top' | 'bottom' | undefined);
+          // UX-C focus rule 1a: the command path leaves focus in the composer
+          // ("mid-command-flow") — showPanel does not grab panel focus here.
+          // DEBT-5: forward the deep-link target so the panel lands on the row.
+          if (ctx.showPanel) ctx.showPanel(id, pane as 'top' | 'bottom' | undefined, target);
           else {
-            pm.open(id, pane as 'top' | 'bottom' | undefined);
+            pm.open(id, pane as 'top' | 'bottom' | undefined, target);
             pm.show();
-            ctx.focusPanels?.();
             ctx.renderRequest();
           }
           if (redirectTarget) {
@@ -146,11 +169,12 @@ export function registerOperatorPanelCommand(registry: CommandRegistry): void {
       } else {
         const id = args[0]!;
         try {
+          // UX-C: bare `/panel <id>` is the same command path as `/panel open
+          // <id>` — composer stays focused.
           if (ctx.showPanel) ctx.showPanel(id);
           else {
             pm.open(id);
             pm.show();
-            ctx.focusPanels?.();
             ctx.renderRequest();
           }
         } catch {