@pellux/goodvibes-tui 1.0.0 → 1.7.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,7 +17,7 @@ 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 ─────────────────────────────────────────────────────────
@@ -76,6 +76,10 @@ export const recallCommand: SlashCommand = {
         handleRecallExplain(rest, context);
         break;
 
+      case 'injections':
+        handleRecallInjections(rest, context);
+        break;
+
       case 'promote':
         handleRecallPromote(rest, context);
         break;
@@ -134,6 +138,7 @@ export const recallCommand: SlashCommand = {
           '  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',

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

@@ -13,31 +13,29 @@ export function registerOperatorPanelCommand(registry: CommandRegistry): void {
       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();
@@ -47,6 +45,11 @@ export function registerOperatorPanelCommand(registry: CommandRegistry): void {
           return;
         }
         try {
+          // 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);
           if (ctx.showPanel) ctx.showPanel(id, pane as 'top' | 'bottom' | undefined);
           else {
             pm.open(id, pane as 'top' | 'bottom' | undefined);
@@ -54,9 +57,22 @@ export function registerOperatorPanelCommand(registry: CommandRegistry): void {
             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];

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

@@ -5,7 +5,15 @@ 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
+ * (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.
+ */
+const PSEUDO_SUBCOMMAND_VERBS = new Set(['dismiss', 'answer', 'pause', 'stop', 'cancel']);
 
 function recordNextQuestion(
   state: Partial<ProjectPlanningState>,
@@ -43,7 +51,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');
 }
 
@@ -67,7 +75,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 +173,21 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         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') {

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

@@ -13,7 +13,7 @@ import {
   upsertEcosystemCatalogEntry,
   uninstallEcosystemCatalogEntry,
 } from '@/runtime/index.ts';
-import { requireEcosystemCatalogPaths, requirePluginPathOptions } from './runtime-services.ts';
+import { openModalCommand, requireEcosystemCatalogPaths, requirePluginPathOptions } from './runtime-services.ts';
 
 export function registerPluginRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
@@ -33,7 +33,7 @@ export function registerPluginRuntimeCommands(registry: CommandRegistry): void {
       const sub = args[0];
 
       if (!sub || sub === 'open' || sub === 'panel') {
-        if (ctx.showPanel) ctx.showPanel('plugins');
+        openModalCommand(ctx, 'plugins-modal');
         return;
       }
 

package/src/input/commands/policy-dispatch.ts

@@ -301,6 +301,23 @@ export function renderPolicyUsage(): string {
   ].join('\n');
 }
 
+// W6 command-path parity: the policy modal dropped its 'r' (record a
+// divergence-dashboard trend sample) action because the panel used to call
+// this._state.recordTrendEntry() directly and /policy had no equivalent verb.
+// This exposes it as a thin wrapper: recordTrendEntry() forwards to the attached
+// DivergencePanel, so it only captures a sample while a simulation dashboard is
+// active — reported honestly here rather than silently no-op'ing.
+function handleRecordTrend(_args: string[], context: CommandContext): void {
+  const policyState = getPolicyState(context);
+  if (!policyState.getDashboard()) {
+    context.print('[policy] No active simulation dashboard — nothing to sample. Run `/policy simulate` first, then `/policy record-trend`.');
+    return;
+  }
+  policyState.recordTrendEntry();
+  const snap = policyState.getSnapshot();
+  context.print(`[policy] Recorded a divergence trend sample (${snap.divergence?.trend.length ?? 0} point(s) total).`);
+}
+
 export async function dispatchPolicyCommand(args: string[], context: CommandContext): Promise<void> {
   const [sub, ...rest] = args;
   switch (sub) {
@@ -332,6 +349,10 @@ export async function dispatchPolicyCommand(args: string[], context: CommandCont
     case 'st':
       await handleStatus(rest, context);
       break;
+    case 'record-trend':
+    case 'trend':
+      handleRecordTrend(rest, context);
+      break;
     default:
       context.print(renderPolicyUsage());
       break;

package/src/input/commands/provider-accounts-runtime.ts

@@ -29,7 +29,7 @@ export function registerProviderAccountsRuntimeCommands(registry: CommandRegistr
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'accounts');
+        ctx.openModal?.('providers-modal'); // W6.1: accounts alias -> provider-health modal
         return;
       }
       const snapshot = await loadProviderAccountSnapshot(ctx);

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

@@ -1,5 +1,5 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import { openCommandPanel } from './runtime-services.ts';
+import { openModalCommand } from './runtime-services.ts';
 
 /**
  * Register the /qrcode command.
@@ -11,9 +11,9 @@ export function registerQrcodeRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'qrcode',
     aliases: ['qr', 'pair'],
-    description: 'Open the QR code panel for companion app pairing',
+    description: 'Open the companion-app pairing modal (QR code)',
     handler(_args, ctx) {
-      openCommandPanel(ctx, 'qr-code');
+      openModalCommand(ctx, 'pairing-modal');
     },
   });
 }

package/src/input/commands/recall-review.ts

@@ -1,6 +1,7 @@
 import type { CommandContext } from '../command-registry.ts';
 import { VALID_REVIEW_STATES, VALID_SCOPES, isValidReviewState, isValidScope } from './recall-shared.ts';
 import { getMemoryApi } from './recall-query.ts';
+import { buildMainSessionTurnInjectionsText, buildTurnInjectionsText } from '../../renderer/turn-injection.ts';
 
 export function handleRecallQueue(args: string[], context: CommandContext): void {
   const memory = getMemoryApi(context);
@@ -102,6 +103,40 @@ export function handleRecallExplain(args: string[], context: CommandContext): vo
   context.print(explanation.prompt ?? '[recall] No explainable project knowledge was selected.');
 }
 
+/**
+ * W5.2 (wo803) — per-turn passive knowledge injection inspectability.
+ *
+ * With an explicit agent id, reads `AgentRecord.turnInjections` (Wave-5 wo801)
+ * via `context.ops.agentManager.exportState()` — the CommandContext-exposed
+ * `ShellAgentManagerService` doesn't have a `getStatus`/`list` pair, but
+ * `exportState()` returns the same full `AgentRecord[]` (it's what
+ * compactConversation() already uses for the same reason).
+ *
+ * With NO agent id (wo805 wiring), renders the MAIN interactive session's own
+ * per-turn injection ring — `Orchestrator.getTurnInjections()`, threaded onto
+ * the command context as `session.getMainSessionTurnInjections`. As of wo805 the
+ * main session DOES route through the passive-injection engine, so this is the
+ * honest main-session default (previously there was no record source, so the
+ * no-id path could only print a usage hint). When the accessor isn't wired
+ * (headless/test contexts built without an orchestrator), the main-session
+ * renderer's honest empty state stands in.
+ */
+export function handleRecallInjections(args: string[], context: CommandContext): void {
+  const agentId = args[0];
+  if (!agentId) {
+    const mainSessionInjections = context.session.getMainSessionTurnInjections?.() ?? [];
+    context.print(buildMainSessionTurnInjectionsText(mainSessionInjections));
+    return;
+  }
+  const records = context.ops.agentManager?.exportState() ?? [];
+  const record = records.find((candidate) => candidate.id === agentId);
+  if (!record) {
+    context.print(`[recall] Agent not found: ${agentId}`);
+    return;
+  }
+  context.print(buildTurnInjectionsText(agentId, record.turnInjections ?? []));
+}
+
 export function handleRecallPromote(args: string[], context: CommandContext): void {
   const memory = getMemoryApi(context);
   if (!memory) {

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

@@ -47,11 +47,11 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
     usage: '[list | show [agentId] | supervisor [runnerId] | capabilities [runnerId] | recover [runnerId] | setup [export <path>] | env [export <path>] | tunnel [review|export <path>] | bootstrap [export <path>|inspect <path>] | session <export|inspect|import> <path> | pool <list|show|create|assign|unassign> ... | dispatch [template] <description> | dispatch-pool <pool> [template] <description> | contract [agentId] | cancel <agentId> | export <agentId> [path] | artifact list | artifact show <id> | artifact export <id> [path] | review <id> | rerun-local <id> | import <path>]',
     async handler(args, ctx) {
       if (args.length === 0) {
-        if (ctx.openRemotePanel) {
-          ctx.openRemotePanel();
+        if (ctx.openModal) {
+          ctx.openModal('remote-modal'); // W6.1: remote panel -> config modal
           return;
         }
-        ctx.print('Remote panel is not available in this runtime.');
+        ctx.print('Remote surface is not available in this runtime.');
         return;
       }