@pellux/goodvibes-tui 2.0.21 → 2.1.1

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

@@ -21,11 +21,9 @@
 // The undo/redo stacks stay TUI-side: the service reports how to reverse a
 // rewind (its receipt's undo block), and this module performs the reversal.
 //
-// The confirm step reuses the DiffPanel confirm idiom (PanelConfirmOverlay),
-// exactly like the former checkpoint-id /rewind this replaces (see the
-// architecture note in checkpoint-runtime.ts): the handler resolves the
-// anchor, previews the change, and arms the panel's confirm overlay; the actual
-// y/n handling lives in DiffPanel.handleInput().
+// The confirm step is a question on a Changes preview (ctx.previewChanges):
+// the handler resolves the anchor, shows exactly what changes, and waits for
+// the answer; Esc or closing the preview answers no.
 // ---------------------------------------------------------------------------
 
 import {
@@ -44,7 +42,6 @@ import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { buildRewindReceiptBlock } from '../../core/rewind-receipt.ts';
 import { getTurnAnchors, type TurnAnchor } from '@pellux/goodvibes-sdk/platform/rewind';
 import { createConversationRewindPort, type ConversationRewindPort } from '../../runtime/conversation-rewind-port.ts';
-import { requirePanelManager } from './runtime-services.ts';
 import { shortId } from './checkpoint-runtime.ts';
 
 export type RewindScope = SdkRewindScope;
@@ -239,7 +236,7 @@ function parseScope(token: string | undefined): RewindScope | null {
 // dead-ending on "no completed turns" while /checkpoints and the boot notice
 // both point back here, /rewind falls back to listing and restoring
 // checkpoints directly, a FILES-ONLY restore (there is no turn anchor to
-// join a conversation boundary against), reusing the same diff-panel
+// join a conversation boundary against), reusing the same diff
 // preview/confirm idiom as the turn-anchored path above.
 // ---------------------------------------------------------------------------
 
@@ -304,52 +301,42 @@ async function handleCheckpointOnlyRewind(args: string[], ctx: CommandContext):
   }
   const checkpoint = resolved;
 
-  const { DiffPanel } = await import('../../panels/diff-panel.ts');
-  const pm = requirePanelManager(ctx);
-  let panel = pm.getAllOpen().find((p) => p.id === 'diff');
-  if (!panel) {
-    try { panel = pm.open('diff'); } catch { ctx.print('Could not open diff panel.'); return; }
-  }
-  pm.activateById('diff');
-  if (!pm.isVisible()) pm.show();
-  ctx.focusPanels?.();
-  const diffPanel = panel as InstanceType<typeof DiffPanel>;
-
+  let diff: string | undefined;
+  let note: string | undefined;
   try {
-    const diff = await mgr.diff(checkpoint.id);
-    if (diff.unifiedDiff.trim()) diffPanel.loadRawDiff(diff.unifiedDiff);
-    else diffPanel.showDiff('(no file changes)', '@@ -0,0 +0,0 @@\n Working tree already matches this checkpoint.');
+    const result = await mgr.diff(checkpoint.id);
+    if (result.unifiedDiff.trim()) diff = result.unifiedDiff;
+    else note = 'The working tree already matches this checkpoint.';
   } catch {
-    diffPanel.showDiff('(preview unavailable)', '@@ -0,0 +0,0 @@\n Could not load the checkpoint diff.');
+    note = 'Could not load the checkpoint diff.';
+  }
+  if (!ctx.previewChanges) {
+    ctx.print('Previewing a restore needs the Changes view, which is not available in this session.');
+    return;
   }
 
-  diffPanel.confirmOverlay.arm({
-    id: checkpoint.id,
-    label: `${checkpoint.label}: restore FILES ONLY (no conversation state this run)`,
-    verb: 'Restore',
-    onConfirm: async () => {
-      try {
-        await mgr.restore(checkpoint.id, { safetyCheckpoint: true });
-        ctx.session.conversationManager.addTypedSystemMessage(
-          `[Rewind] Restored files from checkpoint ${shortId(checkpoint.id)} ("${checkpoint.label}"). Files only: no turn anchors exist this run, so conversation state is unchanged.`,
-          'operational',
-        );
-        pm.close('diff');
-        ctx.focusPrompt?.();
-        ctx.renderRequest();
-      } catch (err) {
-        ctx.print(`Checkpoint restore failed: ${summarizeError(err)}`);
-      }
-    },
-    onCancel: () => {
-      ctx.print('Restore cancelled: nothing changed.');
-      pm.close('diff');
-      ctx.focusPrompt?.();
-      ctx.renderRequest();
-    },
+  ctx.print(`Previewing checkpoint restore: "${checkpoint.label}" (files only; no conversation state this run). Enter or y restores, n or Esc cancels.`);
+  ctx.renderRequest();
+  const confirmed = await ctx.previewChanges({
+    title: checkpoint.label,
+    diff,
+    note,
+    question: { text: `Restore "${checkpoint.label}"? Files only: no conversation state this run.`, confirmLabel: 'Restore', tone: 'warning' },
   });
-
-  ctx.print(`Previewing checkpoint restore: "${checkpoint.label}" (FILES ONLY; no conversation state this run). Confirm in the diff panel: Enter/y to restore, n/Esc to cancel.`);
+  if (!confirmed) {
+    ctx.print('Restore cancelled: nothing changed.');
+    ctx.renderRequest();
+    return;
+  }
+  try {
+    await mgr.restore(checkpoint.id, { safetyCheckpoint: true });
+    ctx.session.conversationManager.addTypedSystemMessage(
+      `[Rewind] Restored files from checkpoint ${shortId(checkpoint.id)} ("${checkpoint.label}"). Files only: no turn anchors exist this run, so conversation state is unchanged.`,
+      'operational',
+    );
+  } catch (err) {
+    ctx.print(`Checkpoint restore failed: ${summarizeError(err)}`);
+  }
   ctx.renderRequest();
 }
 
@@ -412,82 +399,68 @@ export function registerRewindRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      // Preview in the DiffPanel + arm its confirm overlay (same idiom the
-      // former checkpoint-id /rewind used, see checkpoint-runtime.ts).
-      const { DiffPanel } = await import('../../panels/diff-panel.ts');
-      const pm = requirePanelManager(ctx);
-      let panel = pm.getAllOpen().find((p) => p.id === 'diff');
-      if (!panel) {
-        try { panel = pm.open('diff'); } catch { ctx.print('Could not open diff panel.'); return; }
-      }
-      pm.activateById('diff');
-      if (!pm.isVisible()) pm.show();
-      ctx.focusPanels?.();
-      const diffPanel = panel as InstanceType<typeof DiffPanel>;
-
+      // Preview what changes in Changes, with the question on it.
+      let diff: string | undefined;
+      let note: string | undefined;
       const checkpointId = plan.files?.checkpointId ?? null;
       if (filesAvailable && checkpointId && ctx.workspace.workspaceCheckpointManager) {
         try {
-          const diff = await ctx.workspace.workspaceCheckpointManager.diff(checkpointId);
-          if (diff.unifiedDiff.trim()) diffPanel.loadRawDiff(diff.unifiedDiff);
-          else diffPanel.showDiff('(no file changes)', '@@ -0,0 +0,0 @@\n Working tree already matches this checkpoint.');
+          const result = await ctx.workspace.workspaceCheckpointManager.diff(checkpointId);
+          if (result.unifiedDiff.trim()) diff = result.unifiedDiff;
+          else note = 'The working tree already matches this checkpoint.';
         } catch {
-          diffPanel.showDiff('(preview unavailable)', '@@ -0,0 +0,0 @@\n Could not load the checkpoint diff.');
+          note = 'Could not load the checkpoint diff.';
         }
       } else {
         const drop = plan.conversation?.messagesToDrop ?? 0;
         const remaining = plan.conversation?.messagesRemaining ?? 0;
-        diffPanel.showDiff(
-          `Conversation rewind: drop ${drop} message(s)`,
-          `@@ rewind @@\n Keep ${remaining} message(s), drop ${drop} after this turn. No files change.`,
-        );
+        note = `Conversation rewind: keep ${remaining} message(s), drop ${drop} after this turn. No files change.`;
       }
 
       const summaryParts: string[] = [];
       if (wants(scope, 'files')) summaryParts.push(filesAvailable ? `${plan.files?.affectedFileCount ?? 0} file(s)` : 'files: none');
       if (wants(scope, 'conversation')) summaryParts.push(conversationAvailable ? `${plan.conversation?.messagesToDrop ?? 0} message(s)` : 'conversation: unavailable');
+      if (!ctx.previewChanges) {
+        ctx.print('Previewing a rewind needs the Changes view, which is not available in this session.');
+        return;
+      }
 
-      diffPanel.confirmOverlay.arm({
-        id: anchor.turnId ?? sessionId,
-        label: `${resolved.label}: rewind ${scope} (${summaryParts.join(', ')})`,
-        verb: 'Rewind',
-        onConfirm: async () => {
-          try {
-            const result = await state.service.apply(anchor, scope, { confirmToken: plan.token });
-            const receipt = result.receipt;
-            if (!receipt) {
-              ctx.print(`Rewind not applied: ${result.refusal?.reason ?? 'confirmation was refused.'}`);
-              return;
-            }
-            if (undoAvailable(receipt)) {
-              state.undo.push(receipt);
-              state.redo.length = 0; // a fresh apply invalidates the redo stack
-            }
-            // addTypedSystemMessage persists the receipt into real session
-            // history (indexed by getTranscriptEventIndex + save/load), and the
-            // [Rewind] prefix is force-surfaced inline (system-message-router.ts).
-            ctx.session.conversationManager.addTypedSystemMessage(
-              buildRewindReceiptBlock({ ...receipt, undoAvailable: undoAvailable(receipt) }),
-              'operational',
-            );
-            pm.close('diff');
-            ctx.focusPrompt?.();
-            ctx.renderRequest();
-          } catch (err) {
-            ctx.print(`Rewind failed: ${summarizeError(err)}`);
-          }
-        },
-        onCancel: () => {
-          ctx.print('Rewind cancelled: nothing changed.');
-          pm.close('diff');
-          ctx.focusPrompt?.();
-          ctx.renderRequest();
-        },
-      });
-
-      ctx.print(`Previewing rewind of turn "${resolved.label}" (${scope}: ${summaryParts.join(', ')}). Confirm in the diff panel: Enter/y to rewind, n/Esc to cancel.`);
+      ctx.print(`Previewing rewind of turn "${resolved.label}" (${scope}: ${summaryParts.join(', ')}). Enter or y rewinds, n or Esc cancels.`);
       for (const w of plan.warnings) ctx.print(`  note: ${w}`);
       ctx.renderRequest();
+      const confirmed = await ctx.previewChanges({
+        title: `rewind ${resolved.label}`,
+        diff,
+        note,
+        question: { text: `Rewind ${scope} to "${resolved.label}"? (${summaryParts.join(', ')})`, confirmLabel: 'Rewind', tone: 'warning' },
+      });
+      if (!confirmed) {
+        ctx.print('Rewind cancelled: nothing changed.');
+        ctx.renderRequest();
+        return;
+      }
+      try {
+        const result = await state.service.apply(anchor, scope, { confirmToken: plan.token });
+        const receipt = result.receipt;
+        if (!receipt) {
+          ctx.print(`Rewind not applied: ${result.refusal?.reason ?? 'confirmation was refused.'}`);
+          return;
+        }
+        if (undoAvailable(receipt)) {
+          state.undo.push(receipt);
+          state.redo.length = 0; // a fresh apply invalidates the redo stack
+        }
+        // addTypedSystemMessage persists the receipt into real session
+        // history (indexed by getTranscriptEventIndex + save/load), and the
+        // [Rewind] prefix is force-surfaced inline (system-message-router.ts).
+        ctx.session.conversationManager.addTypedSystemMessage(
+          buildRewindReceiptBlock({ ...receipt, undoAvailable: undoAvailable(receipt) }),
+          'operational',
+        );
+        ctx.renderRequest();
+      } catch (err) {
+        ctx.print(`Rewind failed: ${summarizeError(err)}`);
+      }
     },
   });
 }

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

@@ -104,21 +104,21 @@ export function requirePluginPathOptions(
   };
 }
 
-export function openCommandPanel(
-  context: Pick<CommandContext, 'showPanel'>,
-  panelId: string,
-  pane?: 'top' | 'bottom',
+/**
+ * Open the modal that holds a view, by its current or old name (views.ts):
+ * 'fleet' and 'worktrees' open Agents, 'cost' opens Usage, and so on.
+ */
+export function openCommandView(
+  context: Pick<CommandContext, 'openView' | 'print'>,
+  name: string,
 ): void {
-  const showPanel = requireContextValue(context.showPanel, 'showPanel');
-  showPanel(panelId, pane);
+  const openView = requireContextValue(context.openView, 'openView');
+  if (!openView(name)) context.print(`Nothing holds "${name}" in this build.`);
 }
 
 /**
- * (group-B migration): open a config-modal surface by name via the
- * ctx.openModal seam (ui-openers wires it; the 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.
+ * Open a config-modal surface by name via the ctx.openModal seam (ui-openers
+ * wires it). Stubbed in tests by setting ctx.openModal.
  */
 export function openModalCommand(
   context: Pick<CommandContext, 'openModal'>,
@@ -145,10 +145,6 @@ export function requireProfileManager(context: CommandContext) {
   return requireContextValue(context.workspace.profileManager, 'workspace.profileManager');
 }
 
-export function requirePanelManager(context: CommandContext) {
-  return requireContextValue(context.workspace.panelManager, 'workspace.panelManager');
-}
-
 export function requireBookmarkManager(context: CommandContext) {
   return requireContextValue(context.workspace.bookmarkManager, 'workspace.bookmarkManager');
 }
@@ -283,9 +279,11 @@ export async function compactConversation(context: CommandContext): Promise<Comp
   // Resolve the live context window for the current model so manual /compact
   // matches the auto-compaction path (which scales behaviour by window size)
   // instead of passing a meaningless 0.
-  const contextWindow = providerRegistry.getContextWindowForModel(
+  // 0 when the window is unknown (a guess, or disproven by a larger accepted
+  // request): an unknown window is never treated as a small one.
+  const contextWindow = providerRegistry.getKnownContextWindowForModel(
     providerRegistry.getCurrentModel(),
-  );
+  ) ?? 0;
 
   // Small-window models lack room for the structured (multi-LLM) extraction
   // pipeline, so mirror the SDK auto-compaction path and degrade to the

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

@@ -3,7 +3,7 @@ import { dirname, join, resolve } from 'node:path';
 import { atomicWriteFileSync } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandRegistry } from '../command-registry.ts';
 import type { SelectionAction, SelectionItem } from '../selection-modal.ts';
-import { openCommandPanel, requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
+import { requireServiceRegistry, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 export function registerServicesRuntimeCommands(registry: CommandRegistry): void {
@@ -16,7 +16,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
       const sub = args[0] ?? 'open';
       const shellPaths = requireShellPaths(ctx);
       if (sub === 'open' || sub === 'panel') {
-        ctx.openModal?.('services-modal'); // services panel -> config modal
+        ctx.openModal?.('services-modal'); // services view -> config modal
         return;
       }
       const svcRegistry = requireServiceRegistry(ctx);

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

@@ -280,15 +280,31 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         ctx.openSelection('Sessions', items, { allowSearch: true, customActions: deleteAction }, (result) => {
           if (!result) return;
           if (result.action === 'delete') {
-            try {
-              const sessionInfo = sessions.find(s => s.name === result.item.id);
-              if (sessionInfo) {
+            const sessionInfo = sessions.find(s => s.name === result.item.id);
+            if (!sessionInfo) return;
+            const remove = (): void => {
+              try {
                 unlinkSync(sessionInfo.filePath);
                 ctx.print(`Session deleted: ${result.item.id}`);
+              } catch (e) {
+                ctx.print(`Failed to delete session: ${summarizeError(e)}`);
               }
-            } catch (e) {
-              ctx.print(`Failed to delete session: ${summarizeError(e)}`);
+              ctx.renderRequest();
+            };
+            // Deleting is permanent, so it asks first where a confirm dialog exists.
+            if (!ctx.confirm) {
+              remove();
+              return;
             }
+            void ctx.confirm({
+              title: 'Delete session?',
+              body: `This removes "${sessionInfo.name}" and its ${sessionInfo.messageCount} message${sessionInfo.messageCount === 1 ? '' : 's'} from this project.\nIt cannot be undone.`,
+              confirmLabel: 'Delete',
+              tone: 'danger',
+            }).then((confirmed) => {
+              if (confirmed) remove();
+              else ctx.renderRequest();
+            });
           } else {
             try {
               const { meta, messages } = sessionManager.load(result.item.id);

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

@@ -5,9 +5,9 @@ import { type SessionMeta } from '@pellux/goodvibes-sdk/platform/sessions';
 import type { TranscriptEventKind } from '@pellux/goodvibes-sdk/platform/core';
 import type { ConversationTitleSource } from '../../core/conversation';
 import type { SessionReturnContextSummary } from '@/runtime/index.ts';
-import { formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
-import { requirePanelManager, requireProviderApi, requireSessionManager, requireSurface } from './runtime-services.ts';
-import { resumeSessionCore, reopenPanelsWithModalSkip, DEFAULT_PANEL_REOPEN_LIMIT } from '../../core/session-resume-core.ts';
+import { formatReturnContextForDisplay, getReturnContextMode, loadedReturnContext, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
+import { requireProviderApi, requireSessionManager, requireSurface } from './runtime-services.ts';
+import { resumeSessionCore } from '../../core/session-resume-core.ts';
 import { checkSessionLiveness } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
@@ -80,24 +80,6 @@ function buildTranscriptReviewLines(
   ];
 }
 
-// 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.
-// Delegates to the shared reopenPanelsWithModalSkip (core/session-resume-core.ts)
-//, the same routine resumeSessionCore uses, so this standalone entry point
-// and the canonical resume sequence can never diverge on panel-reopen behavior.
-export function reopenPanelsFromReturnContext(ctx: CommandContext, summary: SessionReturnContextSummary | undefined): string[] {
-  if (!summary?.openPanels || summary.openPanels.length === 0) return [];
-  const panelManager = requirePanelManager(ctx);
-  const { reopened, movedToModal, notReopened } = reopenPanelsWithModalSkip(panelManager, summary.openPanels, DEFAULT_PANEL_REOPEN_LIMIT);
-  if (movedToModal.length > 0) {
-    ctx.print(`Note: ${movedToModal.join(', ')} moved to a modal; reopen via its command instead of as a panel.`);
-  }
-  if (notReopened.length > 0) {
-    ctx.print(`  …and ${notReopened.length} more not reopened (/panels to open)`);
-  }
-  return [...reopened];
-}
 
 function printSessionExport(
   ctx: { print: (text: string) => void },
@@ -181,14 +163,11 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
       const model = session.model ? ` [${session.model}]` : '';
       const active = session.name === ctx.session.runtime.sessionId ? ' ●' : '  ';
       lines.push(`${active} ${session.name.padEnd(28)} ${name.slice(0, 22).padEnd(22)} ${date}  ${session.messageCount} msgs${model}`);
-      if (session.returnContext?.activeTasks || session.returnContext?.blockedTasks || session.returnContext?.pendingApprovals || session.returnContext?.openPanels?.length) {
+      if (session.returnContext?.activeTasks || session.returnContext?.blockedTasks || session.returnContext?.pendingApprovals) {
         const posture = [
           session.returnContext.activeTasks ? `active=${session.returnContext.activeTasks}` : null,
           session.returnContext.blockedTasks ? `blocked=${session.returnContext.blockedTasks}` : null,
           session.returnContext.pendingApprovals ? `approvals=${session.returnContext.pendingApprovals}` : null,
-          session.returnContext.openPanels?.length
-            ? `panels=${session.returnContext.openPanels.slice(0, 3).join(',')}${session.returnContext.openPanels.length > 3 ? ` (+${session.returnContext.openPanels.length - 3} more)` : ''}`
-            : null,
         ].filter(Boolean).join('  ');
         if (posture) lines.push(`     posture: ${posture}`);
       }
@@ -270,11 +249,10 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
         conversation: ctx.session.conversationManager,
         runtime: ctx.session.runtime,
         surface: requireSurface(ctx),
-        panelManager: requirePanelManager(ctx),
         selectModel: (model) => providerApi.selectModel(model),
         hydrateSessionUsage: ctx.session.hydrateSessionUsage,
       });
-      const { meta, journalReplay, restoredAnchorCount, resumedMessageCount, panels } = outcome;
+      const { meta, journalReplay, restoredAnchorCount, resumedMessageCount } = outcome;
 
       ctx.renderRequest();
       ctx.print(`Resumed session: ${found.name}\n  Name: ${meta.title || '(untitled)'}\n  Messages: ${resumedMessageCount}\n  Model: ${meta.model || ctx.session.runtime.model}`);
@@ -289,20 +267,13 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
       } else if (journalReplay.hadCorruptTail) {
         ctx.print('  [Recovery] Journal tail was partially corrupt (quarantined). Replay stopped at last good record.');
       }
-      if (panels.movedToModal.length > 0) {
-        ctx.print(`Note: ${panels.movedToModal.join(', ')} moved to a modal; reopen via its command instead of as a panel.`);
-      }
-      if (panels.notReopened.length > 0) {
-        ctx.print(`  …and ${panels.notReopened.length} more not reopened (/panels to open)`);
-      }
       const returnContextMode = getReturnContextMode(ctx.platform.configManager);
       if (returnContextMode !== 'off' && meta.returnContext) {
+        // The SDK's session loader already dropped any legacy open-view list from a
+        // session saved by an older TUI, so the loaded return context is shown as-is.
         for (const line of formatReturnContextForDisplay(meta.returnContext)) {
           ctx.print(`  ${line}`);
         }
-        if (panels.reopened.length > 0) {
-          ctx.print(`  Reopened panels: ${panels.reopened.join(', ')}`);
-        }
         if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
           ctx.print(`  Remote re-entry: /remote recover ${meta.returnContext.remoteRunners![0]}`);
         }
@@ -336,7 +307,9 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
           provider: ctx.session.runtime.provider,
       timestamp: Date.now(),
       titleSource: exportData.titleSource,
-      returnContext: exportData.returnContext,
+      // Same shape a session file is read back in: a legacy open-view list
+      // (from an older session file) is never written again.
+      returnContext: loadedReturnContext(exportData.returnContext),
       // The operator asked for this fork by name; it is not turn machinery.
       saveSource: 'user',
     };
@@ -362,7 +335,9 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
           provider: ctx.session.runtime.provider,
       timestamp: Date.now(),
       titleSource: exportData.titleSource,
-      returnContext: exportData.returnContext,
+      // Same shape a session file is read back in: a legacy open-view list
+      // (from an older session file) is never written again.
+      returnContext: loadedReturnContext(exportData.returnContext),
       // The one unambiguous "keep this" act in the app. Marked so the
       // session-conversations retention sweep never expires it, unlike the
       // automatic per-turn snapshot (turn-event-wiring.ts, saveSource 'auto').

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

@@ -19,7 +19,7 @@ import { getProviderIdFromModel } from '@pellux/goodvibes-sdk/platform/providers
 import { type ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import { CONFIG_KEYS } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandRegistry } from '../command-registry.ts';
-import { openCommandPanel, requireShellPaths } from './runtime-services.ts';
+import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry): void {
@@ -41,7 +41,7 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
         return;
       }
       if (sub === 'panel' || sub === 'open') {
-        ctx.openModal?.('settings-sync-modal'); // settings-sync panel -> config modal
+        ctx.openModal?.('settings-sync-modal'); // settings-sync view -> config modal
         return;
       }
       if (sub === 'report' || sub === 'review') {

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

@@ -12,6 +12,7 @@ import {
   toEffortModel,
 } from '../../providers/reasoning-effort-surface.ts';
 import { executeWriteQuit } from './quit-shared.ts';
+import { startFreshConversation, type FreshConversationResult } from './fresh-conversation.ts';
 import { compactConversation, requireKeybindingsManager, requireProviderApi, requireSessionMemoryStore } from './runtime-services.ts';
 import { buildCompactionPreview, buildCompactionAfterNotice, buildPinUsageText, buildPinSuccessText } from '../../renderer/compaction-preview.ts';
 import { buildCompactionHistoryText } from '../../renderer/compaction-history-modal.ts';
@@ -242,9 +243,22 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'clear',
     aliases: ['cls'],
-    description: 'Clear the conversation display (keeps LLM context)',
+    description: 'Start a fresh conversation (the current one is saved as its own session)',
     handler(_args, ctx) {
-      ctx.session.conversationManager.clearDisplay();
+      if (ctx.isGenerating?.()) {
+        ctx.print('A turn is still running. Stop it with Esc or let it finish, then /clear.');
+        return;
+      }
+      let result: FreshConversationResult;
+      try {
+        result = startFreshConversation(ctx);
+      } catch (e) {
+        ctx.print(`Could not save the current conversation, so nothing was cleared: ${summarizeError(e)}`);
+        return;
+      }
+      if (result.savedAs) {
+        ctx.showToast?.({ title: 'Fresh conversation', body: `The previous one is saved as ${result.savedAs}. /session resume ${result.savedAs} returns to it.`, tone: 'info' });
+      }
       ctx.renderRequest();
     },
   });
@@ -274,9 +288,10 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
       // 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(
+      // 0 when the window is unknown: the preview then leaves out the capacity clause.
+      const contextWindow = ctx.provider.providerRegistry.getKnownContextWindowForModel(
         ctx.provider.providerRegistry.getCurrentModel(),
-      );
+      ) ?? 0;
       const memStore = ctx.session.sessionMemoryStore;
       const pinnedMemoryCount = memStore ? memStore.list().length : 0;
       // Pre-compact preview: honest estimate, clearly labelled.

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

@@ -1,5 +1,5 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import { discoverSkills } from '../../panels/skills-panel.ts';
+import { discoverSkills } from '../../views/skills-discovery.ts';
 import {
   installEcosystemCatalogEntry,
   listInstalledEcosystemEntries,
@@ -169,7 +169,7 @@ export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
           `  source: ${entry.source}`,
           `  tags: ${entry.tags.join(', ') || '(none)'}`,
           `  trust notes: ${entry.trustNotes ?? '(none)'}`,
-          `  install hint: ${entry.installHint ?? 'Place the skill pack under a configured skill directory and refresh the skills panel.'}`,
+          `  install hint: ${entry.installHint ?? 'Place the skill pack under a configured skill directory and refresh the skills modal.'}`,
         ].join('\n'));
         return;
       }

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

@@ -0,0 +1,13 @@
+import type { CommandRegistry } from '../command-registry.ts';
+
+/** /status, everything the footer used to carry, in one report (shell/status-report.ts). */
+export function registerStatusRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'status',
+    aliases: [],
+    description: 'Show session status: model, tools, token totals and cost, context use, surfaces and safety states',
+    handler(_args, ctx) {
+      ctx.print(ctx.describeStatus ? ctx.describeStatus() : 'Status is not available in this runtime.');
+    },
+  });
+}

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

@@ -80,7 +80,7 @@ export function registerSubscriptionRuntimeCommands(registry: CommandRegistry):
     async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       if (args.length === 0 && ctx.openModal) {
-        ctx.openModal('subscription-modal'); // subscription panel -> config modal
+        ctx.openModal('subscription-modal'); // subscription view -> config modal
         return;
       }
       const sub = (args[0] ?? 'review').toLowerCase();

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

@@ -23,7 +23,7 @@
 import type { CommandRegistry, CommandContext } from '../command-registry.ts';
 import type { RuntimeTask, TaskLifecycleState } from '@/runtime/index.ts';
 import { reviewWorktreeAttachments } from '@/runtime/index.ts';
-import { requireOperatorClient, requireOpsApi, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { requireOperatorClient, requireOpsApi, requireShellPaths } from './runtime-services.ts';
 import { createTasksClient, type TasksClient, type UnionTask } from '@pellux/goodvibes-sdk/platform/runtime/client';
 import { createDaemonVerbCaller } from '../../runtime/client/operator-endpoint.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
@@ -85,13 +85,7 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
     usage: '[list [status|kind] | show <taskId> | output <taskId> | create <kind> <owner> <title...> | update <taskId> <title|description|result> <value...> | complete <taskId> [result] | fail <taskId> <error...> | cancel <taskId> [note] | pause <taskId> [note] | resume <taskId> [note] | retry <taskId> [note]]',
     async handler(args, ctx) {
       if (args.length === 0) {
-        if (ctx.showPanel) ctx.showPanel('tasks');
-        else {
-          const panelManager = requirePanelManager(ctx);
-          panelManager.open('tasks');
-          panelManager.show();
-          ctx.renderRequest();
-        }
+        if (!ctx.openView?.('tasks')) ctx.print('The Agents view is not available in this session; /tasks list prints them.');
         return;
       }
 

package/src/input/commands/work-plan-runtime.ts

@@ -24,7 +24,7 @@ function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPla
   return ctx.workspace.workPlanStore ?? null;
 }
 
-function openPanel(ctx: import('../command-registry.ts').CommandContext): void {
+function openWorkPlanModal(ctx: import('../command-registry.ts').CommandContext): void {
   // work-plan migrated to the 'work-plan' modal, open it via the seam.
   openModalCommand(ctx, 'work-plan-modal');
 }
@@ -86,8 +86,8 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
       const subcommand = (args[0] ?? 'panel').toLowerCase();
       try {
         if (subcommand === 'panel' || subcommand === 'open') {
-          openPanel(ctx);
-          ctx.print('Opened work plan panel.');
+          openWorkPlanModal(ctx);
+          ctx.print('Opened the work plan.');
           return;
         }
         if (subcommand === 'list') {
@@ -118,7 +118,7 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
             ...(parsed.notes ? { notes: parsed.notes } : {}),
           };
           const item = store.addItem(parsed.title, addOptions);
-          openPanel(ctx);
+          openWorkPlanModal(ctx);
           ctx.print(`Added work plan item ${item.id}.`);
           return;
         }