@pellux/goodvibes-tui 1.1.0 → 1.7.0

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

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

@@ -33,7 +33,7 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
       const controlPlaneConfigDir = ctx.platform.configManager.getControlPlaneConfigDir();
       const sub = (args[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'settings-sync');
+        ctx.openModal?.('settings-sync-modal'); // W6.1: settings-sync panel -> config modal
         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' },
@@ -207,18 +209,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.');
       }

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();