@pellux/goodvibes-tui 1.7.0 → 1.9.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 {

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

@@ -8,12 +8,15 @@ import type { CommandRegistry } from '../command-registry.ts';
 import { openModalCommand, requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
 
 /**
- * Single-token verbs that look like a `/plan` subcommand but are not real ones
- * (some, like `dismiss`, were dispatched by UI that assumed a subcommand that
- * never existed). A lone one of these is refused rather than seeded as a goal,
- * so a stray verb can never overwrite the project goal with itself.
+ * Single-token verbs that look like a `/plan` subcommand but are not real ones.
+ * A lone one of these is refused rather than seeded as a goal, so a stray verb
+ * can never overwrite the project goal with itself.
+ *
+ * DEBT-3: `dismiss` and `answer` are now REAL subcommands (handled above this
+ * guard), so they were removed from the refuse-list. `pause`/`stop`/`cancel`
+ * remain here — they still have no backing verb and must not seed a goal.
  */
-const PSEUDO_SUBCOMMAND_VERBS = new Set(['dismiss', 'answer', 'pause', 'stop', 'cancel']);
+const PSEUDO_SUBCOMMAND_VERBS = new Set(['pause', 'stop', 'cancel']);
 
 function recordNextQuestion(
   state: Partial<ProjectPlanningState>,
@@ -59,7 +62,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'plan',
     description: 'Inspect or seed TUI-owned project planning state',
-    usage: '[panel | approve | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
+    usage: '[panel | approve | dismiss | answer <n> <text> | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
     argsHint: '[panel|approve|status|<goal>]',
     async handler(args, ctx) {
       const planManager = requirePlanManager(ctx);
@@ -173,6 +176,92 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      // DEBT-3: /plan dismiss — archive the current plan. Dismisses the active
+      // execution plan (ExecutionPlanManager.dismiss, honest per-state) AND
+      // deactivates the project-planning interview state shown in the modal so a
+      // later /plan <goal> starts fresh. Mid-execution is refused outright.
+      if (args[0] === 'dismiss') {
+        const dismissal = planManager.dismiss(ctx.session.runtime.sessionId);
+        if (dismissal.outcome === 'requires-cancel') {
+          ctx.print(
+            `Plan "${dismissal.blockedBy?.title ?? 'active plan'}" is mid-execution and was not dismissed. ` +
+            `Run /workstream cancel to stop it first, then /plan dismiss.`,
+          );
+          return;
+        }
+        let planningNote = '';
+        if (projectPlanningService && projectId) {
+          const current = await projectPlanningService.getState({ projectId });
+          if (current.state && current.state.metadata?.['active'] === true) {
+            await projectPlanningService.upsertState({
+              projectId,
+              state: {
+                ...current.state,
+                metadata: {
+                  ...(current.state.metadata ?? {}),
+                  active: false,
+                  dismissedAt: Date.now(),
+                  dismissedFrom: 'plan-command',
+                },
+              },
+            });
+            planningNote = ' Project planning interview marked inactive.';
+          }
+        }
+        if (dismissal.outcome === 'dismissed') {
+          ctx.print(
+            `Dismissed plan "${dismissal.plan?.title ?? 'active plan'}" ` +
+            `(archived as dismissed; retained in /plan list; /plan <goal> starts fresh).${planningNote}`,
+          );
+        } else if (planningNote) {
+          ctx.print(`No active execution plan to dismiss.${planningNote}`);
+        } else {
+          ctx.print('No active plan or planning state to dismiss.');
+        }
+        return;
+      }
+
+      // DEBT-3: /plan answer <n|question-id> <text> — record a real answer to an
+      // open planning question (moves open → answered, consumed on next refine).
+      if (args[0] === 'answer') {
+        if (!projectPlanningService || !projectId) {
+          ctx.print('Project planning service is not available in this runtime.');
+          return;
+        }
+        const ref = args[1];
+        const answerText = args.slice(2).join(' ').trim();
+        if (!ref || !answerText) {
+          ctx.print('Usage: /plan answer <question-number|question-id> <your answer>');
+          return;
+        }
+        const asNum = Number(ref);
+        const selector = Number.isInteger(asNum) && asNum >= 1
+          ? { questionIndex: asNum - 1 }
+          : { questionId: ref };
+        const answerResult = await projectPlanningService.answerQuestion({ projectId, ...selector, answer: answerText });
+        if (!answerResult.answered) {
+          if (answerResult.reason === 'no-state') {
+            ctx.print('No project planning state exists yet. Seed it with /plan <goal>.');
+          } else if (answerResult.reason === 'question-not-found') {
+            const open = answerResult.openQuestions;
+            const listing = open.length > 0
+              ? open.map((question, index) => `  ${index + 1}. ${question.prompt} (${question.id})`).join('\n')
+              : '  (no open questions)';
+            ctx.print(`No open question matched "${ref}". Open questions:\n${listing}`);
+          } else {
+            ctx.print('Usage: /plan answer <question-number|question-id> <your answer>');
+          }
+          return;
+        }
+        openProjectPlanningPanel();
+        ctx.print(
+          `Recorded answer to: ${answerResult.question?.prompt ?? 'question'}\n` +
+          `Readiness: ${answerResult.evaluation.readiness}\n` +
+          formatNextQuestion(answerResult.evaluation.nextQuestion),
+        );
+        return;
+      }
+
       // Defense (Wave 6 review): a single verb-looking token is almost never a
       // real planning goal — it is a mistyped or removed subcommand. The
       // Planning modal used to dispatch `/plan dismiss`, which has no

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

@@ -1,18 +1,38 @@
+import { join } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
-import { openModalCommand } from './runtime-services.ts';
+import { openModalCommand, requireShellPaths } from './runtime-services.ts';
+import { regenerateCompanionToken } from '@pellux/goodvibes-sdk/platform/pairing';
 
 /**
  * Register the /qrcode command.
  *
- * Opens the QR Code panel which displays a scannable QR code for
- * companion app pairing, along with connection URL, token, and username.
+ * `/qrcode` (no args) opens the companion-app pairing modal (QR code + URL/
+ * token/username). `/qrcode regenerate` rotates the companion pairing token:
+ * it re-keys the shared operator-token store, so the previously-issued token is
+ * rejected on the next auth and a fresh QR must be scanned to reconnect.
  */
 export function registerQrcodeRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'qrcode',
     aliases: ['qr', 'pair'],
-    description: 'Open the companion-app pairing modal (QR code)',
-    handler(_args, ctx) {
+    description: 'Open the companion-app pairing modal (QR code), or regenerate the pairing token',
+    usage: '[regenerate]',
+    argsHint: '[regenerate]',
+    handler(args, ctx) {
+      if (args[0]?.toLowerCase() === 'regenerate') {
+        const shellPaths = requireShellPaths(ctx);
+        const daemonHomeDir = join(shellPaths.homeDirectory, '.goodvibes', 'daemon');
+        try {
+          const rotated = regenerateCompanionToken({ daemonHomeDir });
+          ctx.print(
+            'Pairing token rotated. The previous token is now rejected — ' +
+            `re-scan the QR (new peer ${rotated.peerId.slice(0, 8)}…) to reconnect the companion app.`,
+          );
+        } catch (error) {
+          ctx.print(`Could not regenerate the pairing token: ${String(error)}`);
+        }
+        return;
+      }
       openModalCommand(ctx, 'pairing-modal');
     },
   });