@pellux/goodvibes-tui 1.1.0 → 1.9.0

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,19 +1,39 @@
+import { join } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
-import { openCommandPanel } 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 QR code panel for companion app pairing',
-    handler(_args, ctx) {
-      openCommandPanel(ctx, 'qr-code');
+    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');
     },
   });
 }

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-setup.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { getDefaultAcpAgentCommand } from '@pellux/goodvibes-sdk/platform/acp';
+import { resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandContext, RemoteCommandService } from '../command-registry.ts';
 import type { RemoteSessionBundle } from '@/runtime/index.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -37,10 +38,11 @@ export async function handleRemoteSetupCommand(
   if (subcommand === 'setup') {
     const command = getDefaultAcpAgentCommand();
     const danger = ctx.platform.configManager.getCategory('danger');
+    const daemonEnabled = resolveDaemonEnabled(ctx.platform.configManager);
     const lines = [
       'Remote Setup Review',
       `  acp agent command: ${command.join(' ')}`,
-      `  daemon enabled: ${danger.daemon ? 'yes' : 'no'}`,
+      `  daemon enabled: ${daemonEnabled ? 'yes' : 'no'}`,
       `  http listener enabled: ${danger.httpListener ? 'yes' : 'no'}`,
       `  remote runner contracts: ${remoteRegistry.listContracts().length}`,
       `  active acp connections: ${activeConnections.length}`,
@@ -48,7 +50,7 @@ export async function handleRemoteSetupCommand(
       '  guidance:',
       '    - set ACP_AGENT_CMD to override the spawned remote agent command',
       '    - use /remote env to export a reusable shell snippet',
-      '    - enable danger.daemon / danger.httpListener only when you actually need those remote surfaces',
+      '    - the daemon runs by default (daemon.enabled); enable danger.httpListener only when you actually need that remote surface',
     ];
     if (args[1]?.toLowerCase() === 'export') {
       const pathArg = args[2];
@@ -62,7 +64,7 @@ export async function handleRemoteSetupCommand(
       writeFileSync(targetPath, `${JSON.stringify({
         exportedAt: Date.now(),
         acpAgentCommand: command,
-        daemonEnabled: Boolean(danger.daemon),
+        daemonEnabled,
         httpListenerEnabled: Boolean(danger.httpListener),
         remoteRunnerContracts: remoteRegistry.listContracts().length,
       }, null, 2)}\n`, 'utf-8');

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;
       }
 

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

@@ -9,6 +9,8 @@ import type {
 } from '../command-registry.ts';
 import { compactSmallWindow, getLastCompactionEvent, SMALL_WINDOW_THRESHOLD } from '@pellux/goodvibes-sdk/platform/core';
 import type { CompactionContext, CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+import { recordCompactionQualityScore, scoreCompactionRun } from '../../renderer/compaction-quality.ts';
+import type { CompactionQualityScore } from '../../renderer/compaction-quality.ts';
 import type { UiReadModels } from '../../runtime/ui-read-models.ts';
 import type { ShellPathService } from '@/runtime/index.ts';
 import type { EcosystemCatalogPathOptions } from '@/runtime/index.ts';
@@ -101,6 +103,21 @@ export function openCommandPanel(
   showPanel(panelId, pane);
 }
 
+/**
+ * W6.1 (group-B migration): open a config-modal surface by name via the
+ * ctx.openModal seam (ui-openers wires it; the WO-A host replaces the interim
+ * "not available yet" implementation with real dispatch). Front-doors for
+ * panels that migrated to modals call this instead of openCommandPanel — the
+ * modal is the surface's new home. Stubbed in tests by setting ctx.openModal.
+ */
+export function openModalCommand(
+  context: Pick<CommandContext, 'openModal'>,
+  modalName: string,
+): void {
+  const openModal = requireContextValue(context.openModal, 'openModal');
+  openModal(modalName);
+}
+
 export function openOnboardingWizard(
   context: Pick<CommandContext, 'openOnboardingWizard'>,
   modeOrOptions?: import('../onboarding/onboarding-wizard.ts').OnboardingWizardMode
@@ -238,12 +255,19 @@ export function requireProviderApi(context: CommandContext): ProviderApi {
   return requireContextValue(context.clients?.providerApi, 'clients.providerApi');
 }
 
+/** Result of a manual /compact run: the SDK's CompactionEvent, plus an
+ * out-of-band quality score (W5.4/B28) when one could be computed. */
+export interface CompactionRunResult {
+  readonly event: CompactionEvent;
+  readonly qualityScore: CompactionQualityScore | null;
+}
+
 /**
- * Compact the conversation and return the CompactionEvent recorded by the SDK,
- * or null if no event was recorded (e.g. compaction was skipped or produced no
- * change).
+ * Compact the conversation and return the CompactionEvent recorded by the SDK
+ * (plus an out-of-band quality score), or null if no event was recorded (e.g.
+ * compaction was skipped or produced no change).
  */
-export async function compactConversation(context: CommandContext): Promise<CompactionEvent | null> {
+export async function compactConversation(context: CommandContext): Promise<CompactionRunResult | null> {
   const conversationManager = context.session.conversationManager;
   const providerRegistry = context.provider.providerRegistry;
   // Resolve the live context window for the current model so manual /compact
@@ -263,20 +287,20 @@ export async function compactConversation(context: CommandContext): Promise<Comp
   }
 
   const eventBefore = getLastCompactionEvent();
+  const messagesBefore = conversationManager.getMessagesForLLM();
   const sessionMemories = context.session.sessionMemoryStore?.list() ?? [];
   const lineageTracker = context.session.sessionLineageTracker;
   const agentManager = context.ops.agentManager;
   const planManager = context.ops.planManager;
   const compactionCtx: CompactionContext = {
-    messages: conversationManager.getMessagesForLLM(),
+    messages: messagesBefore,
     sessionMemories,
-    // Mirror buildAutoCompactionContext: pass the running/pending agents, the
-    // active execution plan, and the session-lineage log so the handoff summary
-    // and lineage section are populated correctly (not "compaction #0").
-    agents:
-      agentManager
-        ?.exportState()
-        .filter((agent) => agent.status === 'running' || agent.status === 'pending') ?? [],
+    // Mirror buildAutoCompactionContext: pass ALL agent records (not just
+    // running/pending) so completed/failed subagent work reaches the
+    // "Completed Agent Work" / "Currently Running" compaction sections, plus
+    // the active execution plan and the session-lineage log so the handoff
+    // summary and lineage section are populated correctly (not "compaction #0").
+    agents: agentManager?.exportState() ?? [],
     // Mirror buildAutoCompactionContext: include the live WRFC chains (wired
     // through context.session.wrfcController) so the handoff summary's
     // orchestration section matches the SDK auto-compaction path.
@@ -284,6 +308,11 @@ export async function compactConversation(context: CommandContext): Promise<Comp
     activePlan: planManager?.getActive(context.session.runtime.sessionId) ?? null,
     lineageEntries: lineageTracker?.getEntries() ?? [],
     compactionCount: lineageTracker?.getCompactionCount() ?? 0,
+    // Mirror buildAutoCompactionContext: pass the recorded original task so
+    // the "Original task" lineage line reflects the session's actual first
+    // task instead of falling back to the current message on every manual
+    // compaction after the first.
+    originalTask: lineageTracker?.getOriginalTask() ?? undefined,
     contextWindow,
     trigger: 'manual',
     extractionModelId: context.session.runtime.model,
@@ -299,7 +328,19 @@ export async function compactConversation(context: CommandContext): Promise<Comp
   const eventAfter = getLastCompactionEvent();
   // Return the new event only if it differs from the one recorded before the call.
   if (eventAfter !== null && eventAfter !== eventBefore) {
-    return eventAfter;
+    // W5.4/B28: score this run out-of-band (see compaction-quality.ts for why
+    // this can't just subscribe to the SDK's own CompactionManager pipeline)
+    // and keep the score keyed by this event's timestamp for /compact-history.
+    const qualityScore = scoreCompactionRun({
+      sessionId: context.session.runtime.sessionId,
+      contextWindow,
+      messagesBefore,
+      messagesAfter: conversationManager.getMessagesForLLM(),
+      tokensBefore: eventAfter.tokensBeforeEstimate,
+      tokensAfter: eventAfter.tokensAfterEstimate,
+    });
+    recordCompactionQualityScore(eventAfter.timestamp, qualityScore);
+    return { event: eventAfter, qualityScore };
   }
   return null;
 }

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

@@ -16,7 +16,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
       const sub = args[0] ?? 'open';
       const shellPaths = requireShellPaths(ctx);
       if (sub === 'open' || sub === 'panel') {
-        openCommandPanel(ctx, 'services');
+        ctx.openModal?.('services-modal'); // W6.1: services panel -> config modal
         return;
       }
       const svcRegistry = requireServiceRegistry(ctx);

package/src/input/commands/session-content.ts

@@ -384,9 +384,20 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     },
   });
 
+  // W6-C3 (Wave 6 core-verb pass, MEMORY fragmentation — worst-class
+  // collision #2): this command used to be named /memory, colliding with
+  // the agent's /memory (an alias that forwards to /recall, the durable
+  // cross-session MemoryStore) — same command name, two unrelated features.
+  // Renamed to /note (this feature manages EPHEMERAL, session-scoped sticky
+  // notes pinned across context compaction — an entirely different resource
+  // from /recall's durable records). /memory is now registered as an alias
+  // of /recall below (memory.ts), matching the agent, so the word means the
+  // same thing on both surfaces. See
+  // docs/decisions/2026-07-06-core-verb-spec.md (in the SDK repo) for the
+  // full writeup.
   registry.register({
-    name: 'memory',
-    description: 'Manage session memories (pinned across context compaction)',
+    name: 'note',
+    description: 'Manage session notes (pinned across context compaction)',
     usage: '[list|add <text>|remove <id>]',
     argsHint: '[list|add|remove]',
     handler(args, ctx) {
@@ -394,26 +405,26 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       if (sub === 'list' || args.length === 0) {
         const memories = requireSessionMemoryStore(ctx).list();
         ctx.print(memories.length === 0
-          ? 'No session memories. Use !# prefix or /memory add <text> to create one.'
-          : [`Session Memories (${memories.length}):`, ...memories.map(m => `  [${m.id}] ${m.text}`)].join('\n'));
+          ? 'No session notes. Use !# prefix or /note add <text> to create one.'
+          : [`Session Notes (${memories.length}):`, ...memories.map(m => `  [${m.id}] ${m.text}`)].join('\n'));
       } else if (sub === 'add') {
         const text = args.slice(1).join(' ').trim();
         if (!text) {
-          ctx.print('Usage: /memory add <text>');
+          ctx.print('Usage: /note add <text>');
           return;
         }
         const id = requireSessionMemoryStore(ctx).add(text);
-        ctx.print(`Memory added: [${id}] ${text}`);
+        ctx.print(`Note added: [${id}] ${text}`);
       } else if (sub === 'remove') {
         const id = args[1];
         if (!id) {
-          ctx.print('Usage: /memory remove <id>');
+          ctx.print('Usage: /note remove <id>');
           return;
         }
         const store = requireSessionMemoryStore(ctx);
-        ctx.print(store.remove(id) ? `Memory removed: [${id}]` : `Memory not found: ${id}`);
+        ctx.print(store.remove(id) ? `Note removed: [${id}]` : `Note not found: ${id}`);
       } else {
-        ctx.print('Usage: /memory [list|add <text>|remove <id>]\n  /memory              — list all session memories\n  /memory list         — list all session memories\n  /memory add <text>   — add a memory without sending a message\n  /memory remove <id>  — remove a specific memory');
+        ctx.print('Usage: /note [list|add <text>|remove <id>]\n  /note              — list all session notes\n  /note list         — list all session notes\n  /note add <text>   — add a note without sending a message\n  /note remove <id>  — remove a specific note');
       }
     },
   });

package/src/input/commands/session-workflow.ts

@@ -79,11 +79,23 @@ function buildTranscriptReviewLines(
   ];
 }
 
-function reopenPanelsFromReturnContext(ctx: CommandContext, summary: SessionReturnContextSummary | undefined): string[] {
+// Exported (test-only concern) so the MIGRATE-TO-MODAL redirect-skip honesty
+// (W6 review, finding 3: saved-layout restore with 'sessions' must not lie)
+// can be unit-tested directly instead of through a full /resume harness.
+export function reopenPanelsFromReturnContext(ctx: CommandContext, summary: SessionReturnContextSummary | undefined): string[] {
   if (!summary?.openPanels || summary.openPanels.length === 0) return [];
   const panelManager = requirePanelManager(ctx);
   const reopened: string[] = [];
+  const movedToModal: string[] = [];
   for (const panelId of summary.openPanels.slice(0, 4)) {
+    // W6.1 (the purge): a MIGRATE-TO-MODAL id has no panel to restore — a modal
+    // is not part of the saved panel layout. Skip it (don't pop a modal
+    // mid-resume) and note it once, rather than firing openModal + revealing an
+    // empty workspace during resume.
+    if (panelManager.getModalRedirect(panelId) !== undefined) {
+      movedToModal.push(panelId);
+      continue;
+    }
     try {
       panelManager.open(panelId);
       reopened.push(panelId);
@@ -92,6 +104,9 @@ function reopenPanelsFromReturnContext(ctx: CommandContext, summary: SessionRetu
     }
   }
   if (reopened.length > 0) panelManager.show();
+  if (movedToModal.length > 0) {
+    ctx.print(`Note: ${movedToModal.join(', ')} moved to a modal — reopen via its command instead of as a panel.`);
+  }
   return reopened;
 }
 

package/src/input/commands/settings-sync-runtime.ts

@@ -26,14 +26,26 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
   registry.register({
     name: 'settings-sync',
     aliases: ['settingssync'],
-    description: 'Review sync posture, export/import settings-sync bundles, and open the settings sync workspace',
-    usage: '[review|panel|show <key>|staged|conflicts|resolve <key> <local|synced>|failures|rollback-history|export <path>|inspect <path>|pull <path>|push <path>|lock <key> <source> <reason...>|unlock <key>]',
+    description: 'Open the settings sync modal (bare); review posture, export/import bundles, or resolve conflicts by subcommand',
+    usage: '[panel|report|review|show <key>|staged|conflicts|resolve <key> <local|synced>|failures|rollback-history|export <path>|inspect <path>|pull <path>|push <path>|lock <key> <source> <reason...>|unlock <key>] — bare opens the modal',
     handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const controlPlaneConfigDir = ctx.platform.configManager.getControlPlaneConfigDir();
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const sub = (args[0] ?? '').toLowerCase();
+      // DEBT-5 item 3 (report-vs-modal front doors): settings-sync has a full
+      // modal surface (settings-sync-modal), so the bare command now opens it
+      // — the old bare/`review` transcript report moved to an explicit
+      // `report` subcommand (scriptability preserved: /settings-sync report).
+      if (sub === '') {
+        ctx.openModal?.('settings-sync-modal');
+        return;
+      }
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'settings-sync');
+        ctx.openModal?.('settings-sync-modal'); // W6.1: settings-sync panel -> config modal
+        return;
+      }
+      if (sub === 'report' || sub === 'review') {
+        ctx.print(formatSettingsControlPlaneReview(ctx.platform.configManager).join('\n'));
         return;
       }
       if (sub === 'show') {

package/src/input/commands/shell-core.ts

@@ -153,6 +153,8 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/template save', label: '/template save <name>', detail: 'Save prompt as template', category: 'Templates' },
           { id: '/template use', label: '/template use <name>', detail: 'Execute template', category: 'Templates' },
           { id: '/tools', label: '/tools', detail: 'List available tools', category: 'Tools & System' },
+          { id: '/search', label: '/search <query> [--limit <n>]', detail: 'Search the web and show ranked results', category: 'Tools & System' },
+          { id: '/imagine', label: '/imagine <prompt>', detail: 'Generate an image from a prompt', category: 'Tools & System' },
           { id: '/paste', label: '/paste', detail: 'Insert clipboard text or image into the prompt', category: 'Tools & System' },
           { id: '/shortcuts', label: '/shortcuts', detail: 'View keyboard shortcuts reference', category: 'Tools & System' },
           { id: '/commands', label: '/commands', detail: 'Browse all commands in a scrollable list', category: 'Tools & System' },
@@ -161,7 +163,10 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/quit', label: '/quit', detail: 'Exit', category: 'Tools & System' },
           { id: '/wq', label: '/wq', detail: 'Commit all git changes and then exit', category: 'Tools & System' },
         ];
-        ctx.openSelection('Help  —  Commands', items, { allowSearch: true }, (result) => {
+        // UX-C: every item here is a command, and picking one RUNS it — label
+        // the verb "Run" (matching the slash-command palette) instead of the
+        // generic "Select" default.
+        ctx.openSelection('Help  —  Commands', items, { allowSearch: true, primaryVerbLabel: 'Run' }, (result) => {
           if (!result) return;
           const command = result.item.id;
           if (command.startsWith('/')) {
@@ -207,18 +212,24 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     description: 'Summarize conversation to free context window',
     async handler(_args, ctx) {
       const messages = ctx.session.conversationManager.getMessagesForLLM();
-      // contextWindow is not on CommandContext; preview shows message/token counts
-      // without the capacity-% clause (still honest; no fabricated value).
-      const contextWindow = 0;
+      // W5.4 (wo803): contextWindow IS reachable from CommandContext — the same
+      // call compactConversation() (runtime-services.ts) already makes to scale
+      // its own behaviour by window size. Previously hardcoded to 0 here, which
+      // silently suppressed buildCompactionPreview()'s capacity-% clause even
+      // though the builder has always supported it.
+      const contextWindow = ctx.provider.providerRegistry.getContextWindowForModel(
+        ctx.provider.providerRegistry.getCurrentModel(),
+      );
       const memStore = ctx.session.sessionMemoryStore;
       const pinnedMemoryCount = memStore ? memStore.list().length : 0;
       // Pre-compact preview: honest estimate, clearly labelled.
       const preview = buildCompactionPreview({ messages, contextWindow, pinnedMemoryCount, trigger: 'manual' });
       ctx.print(preview);
-      const event = await compactConversation(ctx);
-      if (event) {
-        // Post-compact notice: uses real CompactionEvent figures.
-        ctx.print(buildCompactionAfterNotice({ event, pinnedMemoryCount }));
+      const result = await compactConversation(ctx);
+      if (result) {
+        // Post-compact notice: uses real CompactionEvent figures, plus an
+        // out-of-band quality-score grade line when one was computed (W5.4/B28).
+        ctx.print(buildCompactionAfterNotice({ event: result.event, pinnedMemoryCount, qualityScore: result.qualityScore }));
       } else {
         ctx.print('[Context] Compact complete.');
       }
@@ -286,6 +297,12 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     handler(_args, ctx) {
       ctx.session.runtime.debugMode = !ctx.session.runtime.debugMode;
       ctx.print(`Debug mode: ${ctx.session.runtime.debugMode ? 'ON' : 'OFF'}`);
+      // Honest quiet counter for direct terminal writes the guard intercepted
+      // (routed here instead of spamming the transcript). (UX-B item 1a.)
+      const intercepted = ctx.session.runtime.terminalWritesIntercepted ?? 0;
+      if (intercepted > 0) {
+        ctx.print(`Terminal writes intercepted this session: ${intercepted} (details in the activity log)`);
+      }
     },
   });
 

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

@@ -11,7 +11,7 @@ import {
   updateInstalledEcosystemEntry,
   upsertEcosystemCatalogEntry,
 } from '@/runtime/index.ts';
-import { requireEcosystemCatalogPaths, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { openModalCommand, requireEcosystemCatalogPaths, requireShellPaths } from './runtime-services.ts';
 
 export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
@@ -22,13 +22,7 @@ export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
     async handler(args, ctx) {
       const sub = args[0] ?? 'open';
       if (sub === 'open' || sub === 'panel') {
-        if (ctx.showPanel) ctx.showPanel('skills');
-        else {
-          const panelManager = requirePanelManager(ctx);
-          panelManager.open('skills');
-          panelManager.show();
-          ctx.renderRequest();
-        }
+        openModalCommand(ctx, 'skills-modal');
         return;
       }
       const skills = await discoverSkills(requireShellPaths(ctx));

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

@@ -79,8 +79,8 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
     usage: '[review|list|providers|inspect <provider>|login <provider> start [--no-browser] [--manual]|finish <code-or-url>|logout <provider>|bundle export <path>|bundle inspect <path>]',
     async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
-      if (args.length === 0 && ctx.openSubscriptionPanel) {
-        ctx.openSubscriptionPanel();
+      if (args.length === 0 && ctx.openModal) {
+        ctx.openModal('subscription-modal'); // W6.1: subscription panel -> config modal
         return;
       }
       const sub = (args[0] ?? 'review').toLowerCase();