@pellux/goodvibes-tui 1.1.0 → 1.9.0

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

@@ -0,0 +1,112 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+/**
+ * registerImageRuntimeCommands - `/imagine <prompt>`.
+ *
+ * Named 'imagine', not 'image' — `/image <path> [prompt]` already exists
+ * (local-runtime.ts) and does something entirely different (attach a local
+ * image file to the next message). Re-verified against the current registry
+ * before wiring this in: the brief that scoped this command was written
+ * before checking for the collision.
+ *
+ * First production caller of MediaProviderRegistry.generate() — the SDK
+ * plumbing existed with zero non-test call sites before this command.
+ * findProvider('generate') returns whichever generation-capable provider is
+ * configured; when none are, the command prints the registry's own
+ * per-provider status (id/state/detail) verbatim — those detail strings
+ * already name the exact env var per builtin provider
+ * (builtin-generation-providers.ts's buildStatus()), so this command never
+ * has to (and never should) guess or hardcode an env-var name itself.
+ */
+export function registerImageRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'imagine',
+    description: 'Generate an image from a prompt via a configured media provider',
+    usage: '<prompt>',
+    argsHint: '<prompt>',
+    async handler(args, ctx) {
+      const mediaProviders = ctx.platform.mediaProviders;
+      const artifactStore = ctx.platform.artifactStore;
+      if (!mediaProviders || !artifactStore) {
+        ctx.print('Image generation is not available in this session.');
+        return;
+      }
+
+      const prompt = args.join(' ').trim();
+      if (!prompt) {
+        ctx.print('Usage: /imagine <prompt>');
+        return;
+      }
+
+      const provider = mediaProviders.findProvider('generate');
+      if (!provider?.generate) {
+        const statuses = await mediaProviders.status();
+        const generationStatuses = statuses.filter((status) => status.capabilities.includes('generate'));
+        const lines = ['No image-generation provider is configured.', ''];
+        if (generationStatuses.length === 0) {
+          lines.push('No media-generation providers are registered in this build.');
+        } else {
+          for (const status of generationStatuses) {
+            lines.push(`  ${status.id} (${status.label}): ${status.state}${status.detail ? ` — ${status.detail}` : ''}`);
+          }
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      try {
+        const result = await provider.generate({
+          prompt,
+          outputMimeType: 'image/png',
+          metadata: { source: 'tui-image-command' },
+        });
+
+        if (result.artifacts.length === 0) {
+          ctx.print(`${provider.label} returned no artifacts for this prompt.`);
+          return;
+        }
+
+        const lines = [`Generated ${result.artifacts.length} artifact(s) via ${provider.label} (${result.providerId}).`];
+        for (const artifact of result.artifacts) {
+          if (!artifact.mimeType.startsWith('image/')) {
+            lines.push(`  Note: ${provider.label} produced ${artifact.mimeType}, not an image — no image-capable provider is configured in this build.`);
+          }
+          if (artifact.dataBase64) {
+            const descriptor = await artifactStore.create({
+              dataBase64: artifact.dataBase64,
+              mimeType: artifact.mimeType,
+              filename: artifact.filename ?? 'generated-image',
+              metadata: { ...artifact.metadata, generatedBy: result.providerId },
+            });
+            lines.push(`  artifact: ${descriptor.id} (${descriptor.mimeType}, ${descriptor.sizeBytes} bytes)`);
+          } else if (artifact.uri) {
+            // Design note: this is the first production caller of generate(), and
+            // returned artifacts may be provider-hosted remote URLs rather than
+            // inline bytes. There is no existing precedent for whether to eagerly
+            // download remote-only output into ArtifactStore, and doing so
+            // unconditionally would turn a text command into an unbounded
+            // background fetch of arbitrary provider-hosted content. Conservative
+            // default: store a small JSON pointer record (not the media bytes) so
+            // the generation is still discoverable via the artifact store, and
+            // render the URL directly so the result stays immediately usable.
+            const descriptor = await artifactStore.create({
+              text: JSON.stringify({ remoteUrl: artifact.uri, mimeType: artifact.mimeType, providerId: result.providerId }, null, 2),
+              mimeType: 'application/json',
+              filename: `${artifact.filename ?? 'generated-image'}.reference.json`,
+              sourceUri: artifact.uri,
+              metadata: { ...artifact.metadata, generatedBy: result.providerId, remote: true },
+            });
+            lines.push(`  artifact: ${descriptor.id} (remote reference — not downloaded)`);
+            lines.push(`  url: ${artifact.uri}`);
+          } else {
+            lines.push('  artifact: (no retrievable content returned)');
+          }
+        }
+        ctx.print(lines.join('\n'));
+      } catch (error) {
+        ctx.print(`Image generation failed: ${summarizeError(error)}`);
+      }
+    },
+  });
+}

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

@@ -55,7 +55,17 @@ export function registerIntelligenceRuntimeCommands(registry: CommandRegistry):
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'intelligence');
+        // W6.1 (the purge): 'intelligence'/IntelligencePanel was
+        // DELETE-disposition (no surviving human surface — its read model
+        // stays and still backs every subcommand below). There is no alias
+        // to resolve through, so this prints an honest notice and opens
+        // Fleet instead of throwing "Unknown panel".
+        ctx.print('Intelligence panel retired — use /intelligence review|diagnostics|symbols|outline|definition|references|hover|repair for the live data. Opening Fleet.');
+        try {
+          openCommandPanel(ctx, 'fleet');
+        } catch {
+          // Panel registry may be unavailable in lightweight command-only contexts.
+        }
         return;
       }
 

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

@@ -10,7 +10,10 @@ export function handleLocalAuthCommand(args: string[], ctx: CommandContext): voi
   const sub = (args[0] ?? 'review').toLowerCase();
   const auth = requireLocalUserAuthManager(ctx);
   if (sub === 'panel' || sub === 'open') {
-    openCommandPanel(ctx, 'local-auth');
+    // W6.1: browse view moved to local-auth-modal. The LocalAuthPanel itself is
+    // kept (masked password-entry host) but is no longer the /local-auth panel
+    // destination — masked entry is reached via add-user/rotate-password below.
+    ctx.openModal?.('local-auth-modal');
     return;
   }
 

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

@@ -70,8 +70,14 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
     handler(args, ctx) {
       const sub = (args[0] ?? '').toLowerCase();
       if (sub === 'panel' || sub === 'review') {
+        // W6.1 (the purge): 'tools'/ToolInspectorPanel was DELETE-disposition
+        // (no surviving human surface — tool results render inline in the
+        // transcript, plus a per-node tool list in Fleet). There is no alias
+        // to resolve through, so this prints an honest notice and opens
+        // Fleet instead of the retired inspector.
+        ctx.print('Tools panel retired — tool activity now renders inline in the transcript and per-agent in the Fleet panel. Opening Fleet.');
         try {
-          openCommandPanel(ctx, 'tools');
+          openCommandPanel(ctx, 'fleet');
         } catch {
           // Panel registry may be unavailable in lightweight command-only contexts.
         }
@@ -79,9 +85,9 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
           ctx.print([
             'Tool Surface Review',
             '  Native file tools stay compact by default.',
-            '  Read/write/edit/notebook capabilities are available through the native tool stack, with detail routed to the tools panel and approval surfaces instead of transcript bloat.',
+            '  Read/write/edit/notebook capabilities are available through the native tool stack, with detail routed inline and to approval surfaces instead of transcript bloat.',
             '  Shell and native tool approvals classify work into read, mutation, destructive, dependency, config, notebook, network, remote, and lifecycle risk families.',
-            '  Use /tools panel to inspect risk class, output-policy actions, spill posture, compact summaries, and approval posture for recent calls.',
+            '  Use /tools panel to jump to the Fleet panel for live per-agent tool activity.',
             '  Use /approval review shell or /approval review file when you need the action-specific why-prompted posture.',
           ].join('\n'));
         }

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

@@ -19,7 +19,7 @@ import {
   type EcosystemCatalogEntry,
   type EcosystemEntryKind,
 } from '@/runtime/index.ts';
-import { openCommandPanel, requireEcosystemCatalogPaths, requireReadModels, requireShellPaths } from './runtime-services.ts';
+import { openModalCommand, requireEcosystemCatalogPaths, requireReadModels, requireShellPaths } from './runtime-services.ts';
 
 function resolveMarketplaceEntry(
   kind: EcosystemEntryKind,
@@ -45,7 +45,7 @@ export function registerMarketplaceRuntimeCommands(registry: CommandRegistry): v
       const ecosystemPaths = requireEcosystemCatalogPaths(ctx);
       const sub = args[0] ?? 'open';
       if (sub === 'open' || sub === 'panel') {
-        openCommandPanel(ctx, 'marketplace');
+        openModalCommand(ctx, 'marketplace-modal');
         return;
       }
       if (sub === 'overview') {

package/src/input/commands/memory.ts

@@ -17,21 +17,82 @@ import type { SlashCommand, CommandContext } from '../command-registry.ts';
 import { handleRecallAdd, handleRecallCapture } from './recall-capture.ts';
 import { handleRecallExport, handleRecallHandoffExport, handleRecallHandoffImport, handleRecallHandoffInspect, handleRecallImport } from './recall-bundle.ts';
 import { handleRecallGet, handleRecallLink, handleRecallList, handleRecallRemove, handleRecallSearch, handleRecallVector } from './recall-query.ts';
-import { handleRecallExplain, handleRecallPromote, handleRecallQueue, handleRecallReview } from './recall-review.ts';
+import { handleRecallExplain, handleRecallInjections, handleRecallPromote, handleRecallQueue, handleRecallReview } from './recall-review.ts';
 import { VALID_CLASSES, VALID_REVIEW_STATES, VALID_SCOPES } from './recall-shared.ts';
 
 // ── 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;
@@ -76,6 +137,10 @@ export const recallCommand: SlashCommand = {
         handleRecallExplain(rest, context);
         break;
 
+      case 'injections':
+        handleRecallInjections(rest, context);
+        break;
+
       case 'promote':
         handleRecallPromote(rest, context);
         break;
@@ -116,36 +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',
-          '  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,62 +1,101 @@
 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);
       const sub = args[0]?.toLowerCase() ?? '';
       if (!sub || sub === 'toggle') {
-        try {
-          if (ctx.showPanel) ctx.showPanel('panel-list');
-          else {
-            pm.open('panel-list');
-            pm.show();
-            ctx.focusPanels?.();
-            ctx.renderRequest();
-          }
-        } catch {
-          pm.toggle();
-          ctx.renderRequest();
-        }
+        // W6.1 (the purge): 'panel-list' (the browse-all-panels picker) was
+        // DELETE-disposition — a picker over a handful of panels is dead
+        // weight now (see the Ctrl+P selectionModal repoint in
+        // shell/ui-openers.ts for its interactive replacement). Bare
+        // `/panel` and `/panel toggle` now do what "toggle" actually means:
+        // toggle the workspace, which opens 'fleet' by default when nothing
+        // is open (PanelManager.toggle()) rather than force-opening a
+        // specific browse panel.
+        pm.toggle();
+        ctx.renderRequest();
       } else if (sub === 'list') {
-        try {
-          if (ctx.showPanel) ctx.showPanel('panel-list');
-          else {
-            pm.open('panel-list');
-            pm.show();
-            ctx.focusPanels?.();
-            ctx.renderRequest();
+        // Print a text listing instead of opening a picker panel — grouped
+        // by category from the live registry, so this can never drift from
+        // what's actually registered.
+        const byCategory = pm.getTypesByCategory();
+        const lines: string[] = [];
+        for (const [category, entries] of byCategory) {
+          lines.push(`${category}:`);
+          for (const entry of entries) {
+            lines.push(`  ${entry.icon} ${entry.id} — ${entry.name}`);
           }
-        } catch {
-          pm.show();
-          ctx.renderRequest();
         }
+        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 {
-          if (ctx.showPanel) ctx.showPanel(id, pane as 'top' | 'bottom' | undefined);
+          // A MIGRATE-TO-MODAL id (e.g. 'sessions' -> the session-picker modal)
+          // resolves to a modal, not a panel: opening it fires the redirect and
+          // no panel lands in the workspace. Report that honestly rather than
+          // claiming "Panel opened: <id>".
+          const redirectTarget = pm.getModalRedirect(id);
+          // 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();
           }
-          ctx.print(`Panel opened: ${id}${pane ? ` (${pane} pane)` : ''}`);
+          if (redirectTarget) {
+            ctx.print(`"${id}" moved to the ${redirectTarget} modal — opening it.`);
+          } else {
+            ctx.print(`Panel opened: ${id}${pane ? ` (${pane} pane)` : ''}`);
+          }
         } catch (e) {
-          ctx.print(`Error: ${summarizeError(e)}`);
+          // A deleted/unknown panel id throws "No panel type registered with
+          // id: <id>" from PanelManager.open — surface the same friendly line
+          // the bare-/panel path uses instead of leaking the raw error. Any
+          // genuinely unexpected failure still shows its real message.
+          const message = summarizeError(e);
+          if (message.includes('No panel type registered with id')) {
+            ctx.print(`Unknown panel "${id}". Use /panel list to see available panels.`);
+          } else {
+            ctx.print(`Error: ${message}`);
+          }
         }
       } else if (sub === 'close') {
         const id = args[1];
@@ -130,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

@@ -5,7 +5,18 @@ import type {
   ProjectPlanningState,
 } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { CommandRegistry } from '../command-registry.ts';
-import { requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
+import { openModalCommand, requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
+
+/**
+ * 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(['pause', 'stop', 'cancel']);
 
 function recordNextQuestion(
   state: Partial<ProjectPlanningState>,
@@ -43,7 +54,7 @@ function formatNextQuestion(question: ProjectPlanningQuestion | undefined): stri
   if (!question) return 'No next question recorded.';
   const lines = [`Next question: ${question.prompt}`];
   if (question.recommendedAnswer) lines.push(`Recommended answer: ${question.recommendedAnswer}`);
-  lines.push('Answer in the prompt, or focus the Planning panel to choose/type an answer.');
+  lines.push('Answer in the prompt, or open the Planning modal to choose/type an answer.');
   return lines.join('\n');
 }
 
@@ -51,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);
@@ -67,7 +78,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
 
       const projectPlanningService = ctx.workspace.projectPlanningService;
       const projectId = ctx.workspace.projectPlanningProjectId;
-      const openProjectPlanningPanel = () => ctx.showPanel?.('project-planning');
+      const openProjectPlanningPanel = () => openModalCommand(ctx, 'planning-modal');
 
       if (args.length === 0) {
         if (projectPlanningService && projectId) {
@@ -165,6 +176,107 @@ 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
+      // subcommand and silently fell through to this free-form branch, seeding
+      // the goal with the literal "dismiss". Refuse to seed on a lone
+      // known-or-formerly-planned verb and point at the real usage instead of
+      // corrupting the goal.
+      if (args.length === 1 && PSEUDO_SUBCOMMAND_VERBS.has(args[0].toLowerCase())) {
+        ctx.print(
+          `Unknown /plan subcommand "${args[0]}" — did you mean panel, approve, list, show, or status? ` +
+          `To seed a planning goal, use /plan <a real sentence describing the change>.`,
+        );
+        return;
+      }
+
       const taskDescription = args.join(' ');
       if (!projectPlanningService || !projectId) {
         ctx.print('Project planning service is not available in this runtime.');

package/src/input/commands/platform-sandbox-runtime.ts

@@ -98,12 +98,7 @@ export function registerPlatformSandboxRuntimeCommands(registry: CommandRegistry
       const shellPaths = requireShellPaths(ctx);
       const sub = args[0] ?? 'open';
       if (sub === 'open' || sub === 'panel') {
-        if (ctx.showPanel) ctx.showPanel('sandbox');
-        else {
-          const panelManager = requirePanelManager(ctx);
-          panelManager.open('sandbox');
-          panelManager.show();
-        }
+        ctx.openModal?.('sandbox-modal'); // W6.1: sandbox panel -> config modal
         return;
       }
       if (sub === 'review') {