@pellux/goodvibes-tui 1.11.1 → 1.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "1.11.1",
+  "version": "1.13.0",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -99,7 +99,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "1.4.1",
+    "@pellux/goodvibes-sdk": "1.6.1",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/input/commands/context-window.ts

@@ -0,0 +1,97 @@
+/**
+ * /context window — view, set, or clear a custom context window for the
+ * current model.
+ *
+ * The override is stored by the SDK's ProviderRegistry (persisted under the
+ * control-plane config dir with provenance 'configured_cap'), so it survives
+ * restarts, applies to any model (cloud or local), and is honored by every
+ * consumer of the same home. Clearing returns the model to its automatic
+ * window (catalog / provider API / family fallback).
+ */
+import type { CommandContext } from '../command-registry.ts';
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import { MAX_CONTEXT_WINDOW_OVERRIDE } from '@pellux/goodvibes-sdk/platform/providers';
+
+/**
+ * Parse a user-supplied context window size. Accepts plain token counts
+ * ("200000"), thousands ("200k", "12.5k"), and millions ("1m", "2M").
+ * Returns null for anything unparseable or outside 1..MAX_CONTEXT_WINDOW_OVERRIDE.
+ */
+export function parseContextWindowSize(raw: string): number | null {
+  const match = /^(\d+(?:\.\d+)?)\s*([km])?$/i.exec(raw.trim());
+  if (!match) return null;
+  const base = Number(match[1]);
+  const suffix = match[2]?.toLowerCase();
+  const multiplier = suffix === 'm' ? 1_000_000 : suffix === 'k' ? 1_000 : 1;
+  const value = Math.round(base * multiplier);
+  if (!Number.isInteger(value) || value <= 0 || value > MAX_CONTEXT_WINDOW_OVERRIDE) return null;
+  return value;
+}
+
+function describeProvenance(model: ModelDefinition): string {
+  switch (model.contextWindowProvenance) {
+    case 'configured_cap': return 'custom override';
+    case 'observed_limit': return 'learned from a provider rejection';
+    case 'provider_api': return 'reported by the provider';
+    case 'fallback': return 'family default (no catalog entry)';
+    default: return 'model catalog';
+  }
+}
+
+/** Status text for the current model's window + override state. */
+export function buildContextWindowStatusText(
+  model: ModelDefinition,
+  resolvedWindow: number,
+  override: number | null,
+  observed: number | null = null,
+): string {
+  const lines = [
+    `Context window for ${model.displayName} (${model.registryKey}):`,
+    `  resolved: ${resolvedWindow.toLocaleString()} tokens (${describeProvenance(model)})`,
+    `  override: ${override === null ? 'none (automatic)' : `${override.toLocaleString()} tokens`}`,
+  ];
+  if (observed !== null) {
+    lines.push(`  learned limit: ${observed.toLocaleString()} tokens (the provider rejected a longer request; self-corrects as requests succeed)`);
+  }
+  lines.push(
+    '',
+    'Set:   /context window <size>   (e.g. 120000, 200k, 1m)',
+    'Clear: /context window clear    (also forgets the learned limit)',
+  );
+  return lines.join('\n');
+}
+
+/** Handle `/context window [<size>|clear]`. Returns the text it printed (for tests). */
+export function handleContextWindowSubcommand(args: readonly string[], ctx: CommandContext): string {
+  const registry = ctx.provider.providerRegistry;
+  const model = registry.getCurrentModel();
+  const arg = args[0]?.trim().toLowerCase() ?? '';
+
+  let output: string;
+  if (arg === '') {
+    output = buildContextWindowStatusText(
+      model,
+      registry.getContextWindowForModel(model),
+      registry.getModelContextCap(model.registryKey),
+      registry.getObservedContextWindow(model.registryKey),
+    );
+  } else if (arg === 'clear' || arg === 'auto' || arg === 'reset') {
+    const existed = registry.clearModelContextCap(model.registryKey);
+    const resolved = registry.getContextWindowForModel(registry.getCurrentModel());
+    output = existed
+      ? `Context window settings cleared for ${model.displayName} (custom override and any learned limit). Back to automatic: ${resolved.toLocaleString()} tokens.`
+      : `${model.displayName} has no custom context window or learned limit set (automatic: ${resolved.toLocaleString()} tokens).`;
+  } else {
+    const size = parseContextWindowSize(arg);
+    if (size === null) {
+      output = `Invalid size '${args[0]}'. Use a token count between 1 and ${MAX_CONTEXT_WINDOW_OVERRIDE.toLocaleString()} — e.g. 120000, 200k, 1m — or 'clear'.`;
+    } else {
+      registry.setModelContextCap(model.registryKey, size);
+      output = `Context window for ${model.displayName} set to ${size.toLocaleString()} tokens (was ${registry.getContextWindowForModel(model).toLocaleString()}). Clear with /context window clear.`;
+    }
+  }
+
+  ctx.print(output);
+  ctx.renderRequest();
+  return output;
+}

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

@@ -6,6 +6,7 @@ import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
 import { requireOpsApi, requireProfileManager, requireReplayEngine } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { estimateConversationTokens } from '@pellux/goodvibes-sdk/platform/core';
+import { handleContextWindowSubcommand } from './context-window.ts';
 
 export function registerOperatorRuntimeCommands(registry: CommandRegistry): void {
   registerOperatorPanelCommand(registry);
@@ -23,8 +24,14 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'context',
     aliases: ['ctx'],
-    description: 'Inspect context window usage (token breakdown per message)',
-    handler: (_args, ctx) => {
+    description: 'Inspect context usage, or set/clear a custom context window for the current model',
+    usage: '[window [<size>|clear]]',
+    argsHint: '[window <size|clear>]',
+    handler: (args, ctx) => {
+      if (args[0]?.toLowerCase() === 'window') {
+        handleContextWindowSubcommand(args.slice(1), ctx);
+        return;
+      }
       if (ctx.openContextInspector) {
         ctx.openContextInspector();
       } else {

package/src/input/commands/session.ts

@@ -21,7 +21,7 @@ import type { SlashCommand, CommandContext } from '../command-registry.ts';
 import type { CancellationScope, CrossSessionTaskRef } from '@pellux/goodvibes-sdk/platform/sessions';
 import { VALID_SCOPES } from '@pellux/goodvibes-sdk/platform/sessions';
 import { handleSessionWorkflowCommand } from './session-workflow.ts';
-import { requireSessionOrchestration } from './runtime-services.ts';
+import { requireSessionOrchestration, requireSessionManager } from './runtime-services.ts';
 
 // ── Argument parsing helpers ──────────────────────────────────────────────────
 
@@ -423,3 +423,48 @@ export const sessionCommand: SlashCommand = {
     }
   },
 };
+
+/**
+ * /resume — the discoverable front door to session resume.
+ *
+ * `/session resume <id>` has always existed but is buried behind a
+ * subcommand nobody remembers mid-context-switch. `/resume` with no
+ * arguments opens a picker over saved sessions (newest first, current
+ * session excluded); with an argument it resumes directly via the exact
+ * same workflow path (journal replay, model reselection, return-context
+ * reveal included).
+ */
+export const resumeCommand: SlashCommand = {
+  name: 'resume',
+  aliases: [],
+  description: 'Resume a previous session — pick from a list, or pass an id/name',
+  usage: '[session-id-or-name]',
+  argsHint: '[id|name]',
+  handler: async (args: string[], ctx: CommandContext): Promise<void> => {
+    if (args.length > 0 && args.join(' ').trim().length > 0) {
+      await handleSessionWorkflowCommand(['resume', ...args], ctx);
+      return;
+    }
+    const sm = requireSessionManager(ctx);
+    const sessions = sm.list().filter((s) => s.name !== ctx.session.runtime.sessionId);
+    if (sessions.length === 0) {
+      ctx.print('No previous sessions to resume yet. /session save [name] stores the current one explicitly.');
+      return;
+    }
+    if (!ctx.openSelection) {
+      // Headless/test surface without the picker: honest fallback to the list.
+      await handleSessionWorkflowCommand(['list'], ctx);
+      ctx.print('Resume one with: /resume <id-or-name>');
+      return;
+    }
+    const items = sessions.map((s) => ({
+      id: s.name,
+      label: s.title || s.name,
+      detail: `${new Date(s.timestamp).toLocaleString()} · ${s.messageCount} msg${s.messageCount === 1 ? '' : 's'}${s.model ? ` · ${s.model}` : ''} · ${s.name}`,
+    }));
+    ctx.openSelection('Resume session', items, { allowSearch: true, primaryVerbLabel: 'Resume' }, (result) => {
+      if (!result) return;
+      void handleSessionWorkflowCommand(['resume', result.item.id], ctx);
+    });
+  },
+};

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

@@ -120,6 +120,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/model', label: '/model [id]', detail: 'Select LLM model', category: 'Model & Provider' },
           { id: '/provider', label: '/provider [name]', detail: 'Switch provider', category: 'Model & Provider' },
           { id: '/effort', label: '/effort [level]', detail: 'Reasoning effort (instant/low/medium/high)', category: 'Model & Provider' },
+          { id: '/context window', label: '/context window [<size>|clear]', detail: 'Show, set, or clear a custom context window for the current model', category: 'Model & Provider' },
           { id: '/config', label: '/config [category|key]', detail: 'Open fullscreen configuration workspace', category: 'Config & Display' },
           { id: '/debug', label: '/debug', detail: 'Toggle debug mode', category: 'Config & Display' },
           { id: '/expand', label: '/expand [type]', detail: 'Expand blocks (all|thinking|tool|code)', category: 'Config & Display' },
@@ -136,6 +137,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/session', label: '/session', detail: 'Current session info', category: 'Conversation' },
           { id: '/session list', label: '/session list', detail: 'List all sessions', category: 'Conversation' },
           { id: '/session rename', label: '/session rename <name>', detail: 'Rename current session', category: 'Conversation' },
+          { id: '/resume', label: '/resume [id]', detail: 'Resume a previous session (picker when no id)', category: 'Conversation' },
           { id: '/session resume', label: '/session resume <id>', detail: 'Load and resume a session', category: 'Conversation' },
           { id: '/session fork', label: '/session fork [name]', detail: 'Fork current session to new ID', category: 'Conversation' },
           { id: '/session save', label: '/session save [name]', detail: 'Force-save current session', category: 'Conversation' },

package/src/input/commands.ts

@@ -2,7 +2,7 @@ import type { CommandRegistry } from './command-registry.ts';
 import { policyCommand } from './commands/policy.ts';
 import { providerCommand } from './commands/provider.ts';
 import { evalCommand } from './commands/eval.ts';
-import { sessionCommand } from './commands/session.ts';
+import { sessionCommand, resumeCommand } from './commands/session.ts';
 import { recallCommand } from './commands/memory.ts';
 import { knowledgeCommand } from './commands/knowledge.ts';
 import { registerShellCoreCommands } from './commands/shell-core.ts';
@@ -140,6 +140,9 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   // ── /session ─────────────────────────────────────────────────────────────
   registry.register(sessionCommand);
 
+  // ── /resume — the discoverable front door to /session resume ─────────────
+  registry.register(resumeCommand);
+
   // ── /recall ──────────────────────────────────────────────────────────────
   registry.register(recallCommand);
 

package/src/main.ts

@@ -643,11 +643,11 @@ async function main() {
       panelWidth: panelComposite.panelWidth,
     });
   };
-  const renderScheduler = createRenderScheduler(renderNow); // WO-208 same-tick coalescer
+  const renderScheduler = createRenderScheduler(renderNow, undefined, () => lifecycle.isTerminalRestored()); // WO-208 coalescer; no frames after terminal restore
   const render = (): void => renderScheduler.schedule(); // captured direct writes → activity log + quiet /debug counter, not repeated transcript lines (UX-B 1a)
   const terminalOutputGuard = installTuiTerminalOutputGuard({ stdout, stderr: process.stderr, onCapture: (total) => { commandContext.session.runtime.terminalWritesIntercepted = total; render(); } });
 
-  setRenderRequest(renderNow); // bootstrap's 16ms coalescer calls the composite directly
+  setRenderRequest(() => renderScheduler.flushNow()); // bootstrap's 16ms coalescer composites via the (restore-gated) scheduler
   setPanelFrameRequester(render); // live panels repaint when idle (a replay finding: fleet sat stale until keypress)
   orchestratorRefs.requestRender = render;
   commandContext.renderRequest = render;

package/src/panels/fleet-panel.ts

@@ -96,6 +96,8 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   private readonly actions: FleetActionCallbacks;
   private readonly confirmOverlay: PanelConfirmOverlay;
   private follow = false;
+  /** Tree view mode: the live fleet, or the session archive of finished subtrees. */
+  private viewMode: 'active' | 'archived' = 'active';
   private tabsState: FleetTabsState = EMPTY_FLEET_TABS_STATE;
   private tickTimer: ReturnType<typeof setInterval> | null = null;
   /**
@@ -221,7 +223,9 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   protected getItems(): readonly FleetTreeRow[] {
-    return this.readModel.getSnapshot().rows;
+    return this.viewMode === 'archived'
+      ? this.readModel.getArchivedSnapshot().rows
+      : this.readModel.getSnapshot().rows;
   }
 
   protected override getPalette(): PanelPalette {
@@ -229,7 +233,9 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   protected override getEmptyStateMessage(): string {
-    return ' No processes tracked yet.';
+    return this.viewMode === 'archived'
+      ? ' Archive is empty — press a on a finished process (or A for all) to move it here.'
+      : ' No processes tracked yet.';
   }
 
   /**
@@ -381,6 +387,38 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
     const selected = this.getSelectedItem();
 
+    // Archive controls: v toggles the live fleet <-> session archive view;
+    // a archives the selected finished subtree (or restores it from the
+    // archive view); A archives every fully-finished root subtree.
+    if (key === 'v') {
+      this.viewMode = this.viewMode === 'active' ? 'archived' : 'active';
+      this.markDirty();
+      return true;
+    }
+    if (key === 'a') {
+      if (!selected) return false;
+      if (this.viewMode === 'archived') {
+        const restored = this.readModel.unarchive(selected.node.id);
+        if (restored === 0) this.setError('Nothing restored for this node.');
+        this.markDirty();
+        return true;
+      }
+      if (!isTerminalProcessState(selected.node.state)) {
+        this.setError('Only finished processes can be archived.');
+        return true;
+      }
+      const result = this.readModel.archive(selected.node.id);
+      if (!result.archived) this.setError(result.reason ?? 'Could not archive this process.');
+      this.markDirty();
+      return true;
+    }
+    if (key === 'A' && this.viewMode === 'active') {
+      const count = this.readModel.archiveFinished();
+      if (count === 0) this.setError('No fully-finished processes to archive.');
+      this.markDirty();
+      return true;
+    }
+
     if (key === 'i') {
       // Guard: only consume on a real, non-terminal node (cockpit-panel.ts
       // precedent) so the key falls through when there is nothing to act on.
@@ -736,7 +774,7 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     // can actually accept them (most kinds are never interruptible; nothing is
     // killable once terminal), incl. the d2 state-dependent p pause/resume chip.
     // Mirrors the handleInput guards above. See buildFleetTreeHints (fleet-stop.ts).
-    const hints = buildFleetTreeHints(selected?.node, this.follow, this.tabsState.tabs.length > 0);
+    const hints = buildFleetTreeHints(selected?.node, this.follow, this.tabsState.tabs.length > 0, this.viewMode);
 
     // Tab strip renders only when tabs exist — omitting it entirely with no
     // tabs attached keeps the pre-session-tab root-tree rendering byte-identical.
@@ -744,7 +782,7 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     const header = stripLine ? [stripLine] : undefined;
 
     return this.renderList(width, height, {
-      title: 'Fleet',
+      title: this.viewMode === 'archived' ? 'Fleet — Archived' : 'Fleet',
       header,
       footer,
       hints,

package/src/panels/fleet-read-model.ts

@@ -29,6 +29,7 @@
 // ---------------------------------------------------------------------------
 
 import type {
+  ArchivableProcessRegistry,
   ProcessCostState,
   ProcessKind,
   ProcessNode,
@@ -459,10 +460,23 @@ export interface FleetReadModel {
    * the steer()/steerable degrade-without-a-dep convention.
    */
   subscribeConsumed(listener: (event: SteerConsumedEvent) => void): () => void;
+  /** Rows snapshot of ARCHIVED subtrees (empty when the runtime has no archive layer). */
+  getArchivedSnapshot(): FleetSnapshot;
+  /** Move a finished subtree to the session archive. Honest refusal reason when it cannot be. */
+  archive(id: string): { readonly archived: boolean; readonly count: number; readonly reason?: string };
+  /** Archive every fully-finished root subtree. Returns the number of nodes archived. */
+  archiveFinished(): number;
+  /** Return an archived subtree to the live view. Returns the number of nodes restored. */
+  unarchive(id: string): number;
 }
 
-/** Narrow surface of ProcessRegistry this read-model depends on. */
-export type FleetRegistryLike = Pick<ProcessRegistry, 'query' | 'subscribe' | 'interrupt' | 'resume' | 'kill' | 'steer'>;
+/**
+ * Narrow surface of ProcessRegistry this read-model depends on. The archive
+ * methods are optional: a runtime whose registry lacks the archive layer
+ * (or a bare test double) degrades to "no archive" instead of crashing.
+ */
+export type FleetRegistryLike = Pick<ProcessRegistry, 'query' | 'subscribe' | 'interrupt' | 'resume' | 'kill' | 'steer'>
+  & Partial<Pick<ArchivableProcessRegistry, 'archive' | 'archiveFinished' | 'unarchive' | 'listArchived'>>;
 
 /**
  * Create a live FleetReadModel backed by the SDK's ProcessRegistry.
@@ -503,6 +517,21 @@ export function createFleetReadModel(
         }
       });
     },
+    getArchivedSnapshot(): FleetSnapshot {
+      if (!registry.listArchived) return buildFleetSnapshot([]);
+      const snapshot = registry.listArchived();
+      return buildFleetSnapshot(snapshot.nodes, snapshot.capturedAt);
+    },
+    archive(id: string) {
+      if (!registry.archive) return { archived: false, count: 0, reason: 'this runtime has no fleet archive' };
+      return registry.archive(id);
+    },
+    archiveFinished(): number {
+      return registry.archiveFinished?.() ?? 0;
+    },
+    unarchive(id: string): number {
+      return registry.unarchive?.(id) ?? 0;
+    },
   };
 }
 
@@ -516,5 +545,9 @@ export function createStaticFleetReadModel(snapshot: FleetSnapshot): FleetReadMo
     kill: () => [],
     steer: () => ({ queued: false, reason: 'no live registry' }),
     subscribeConsumed: () => () => {},
+    getArchivedSnapshot: () => buildFleetSnapshot([]),
+    archive: () => ({ archived: false, count: 0, reason: 'no live registry' }),
+    archiveFinished: () => 0,
+    unarchive: () => 0,
   };
 }

package/src/panels/fleet-stop.ts

@@ -108,6 +108,7 @@ export function buildFleetTreeHints(
   selected: ProcessNode | undefined,
   follow: boolean,
   hasTabs: boolean,
+  viewMode: 'active' | 'archived' = 'active',
 ): FleetHint[] {
   const live = selected !== undefined && !isTerminalProcessState(selected.state);
   const isPaused = selected !== undefined && selected.state === 'paused';
@@ -115,11 +116,22 @@ export function buildFleetTreeHints(
     { keys: 'j/k', label: 'navigate' },
     { keys: 'Enter', label: 'attach' },
   ];
+  if (viewMode === 'archived') {
+    // Archive view: restore + return to the live fleet; nothing here is live,
+    // so the live-only control hints (s/i/K/p) never apply.
+    if (selected) hints.push({ keys: 'a', label: 'restore' });
+    hints.push({ keys: 'v', label: 'live view' });
+    if (hasTabs) hints.push({ keys: '[ ]', label: 'tabs' });
+    return hints;
+  }
   if (live && selected.capabilities.steerable) hints.push({ keys: 's', label: 'steer' }); // discoverable from the tree (attach-and-steer)
   if (live && selected.capabilities.interruptible) hints.push({ keys: 'i', label: 'interrupt' });
   if (live && selected.capabilities.killable) hints.push({ keys: 'K', label: 'kill' });
   if (live && !isPaused && selected.capabilities.pausable) hints.push({ keys: 'p', label: 'pause' });
   if (isPaused && selected.capabilities.resumable) hints.push({ keys: 'p', label: 'resume' });
+  if (selected && !live) hints.push({ keys: 'a', label: 'archive' });
+  hints.push({ keys: 'A', label: 'archive finished' });
+  hints.push({ keys: 'v', label: 'archived' });
   hints.push({ keys: 'f', label: follow ? 'follow:on' : 'follow' });
   if (hasTabs) hints.push({ keys: '[ ]', label: 'tabs' });
   return hints;

package/src/runtime/process-lifecycle.ts

@@ -63,6 +63,13 @@ export interface ProcessLifecycleDeps {
 export interface ProcessLifecycleHandlers {
   readonly exitApp: () => Promise<void>;
   readonly restoreTerminal: () => void;
+  /**
+   * True once restoreTerminal has run. The compositor must never write another
+   * frame after this: the terminal is back on the user's primary screen, and a
+   * late cursor-positioned frame (async shutdown races, stray timers) would
+   * paint over shell content and strand the prompt mid-screen.
+   */
+  readonly isTerminalRestored: () => boolean;
   readonly resizeHandler: () => void;
   readonly sigintHandler: () => void;
   readonly unhandledRejectionHandler: (reason: unknown) => void;
@@ -129,8 +136,20 @@ export function installProcessLifecycle(deps: ProcessLifecycleDeps): ProcessLife
   const restoreTerminal = (): void => {
     if (terminalRestored) return;
     terminalRestored = true;
-    const exitScreen = noAltScreen ? ansi.CLEAR_SCREEN : ansi.CLEAR_SCREEN + ansi.ALT_SCREEN_EXIT;
-    allowTerminalWrite(() => stdout.write(ansi.PASTE_DISABLE + ansi.KEYBOARD_EXT_DISABLE + ansi.MOUSE_DISABLE + ansi.FOCUS_DISABLE + ansi.CURSOR_SHOW + exitScreen));
+    // Alt-screen path: just leave the alt screen — 1049l restores the primary
+    // screen and cursor exactly as they were at launch. Clearing first is
+    // pointless (the alt screen is discarded) and actively harmful: the old
+    // CLEAR_SCREEN included ESC[3J, which wipes the PRIMARY scrollback on
+    // several emulators even when issued from the alt screen.
+    // No-alt path: the compositor painted over the primary screen, so clear
+    // the viewport and home the cursor — but WITHOUT 3J, the user's scrollback
+    // is theirs. CURSOR_SHOW goes AFTER the screen switch so visibility
+    // applies to the screen the shell prompt lands on.
+    const exitScreen = noAltScreen ? '\x1b[2J\x1b[H' : ansi.ALT_SCREEN_EXIT;
+    allowTerminalWrite(() => stdout.write(
+      ansi.PASTE_DISABLE + ansi.KEYBOARD_EXT_DISABLE + ansi.MOUSE_DISABLE + ansi.FOCUS_DISABLE
+      + exitScreen + ansi.CURSOR_SHOW,
+    ));
     getTerminalOutputGuard().dispose();
     try { stdin.setRawMode(false); } catch { /* stdin may not be a TTY */ }
   };
@@ -201,6 +220,7 @@ export function installProcessLifecycle(deps: ProcessLifecycleDeps): ProcessLife
   return {
     exitApp,
     restoreTerminal,
+    isTerminalRestored: () => terminalRestored,
     resizeHandler,
     sigintHandler,
     unhandledRejectionHandler,

package/src/runtime/render-scheduler.ts

@@ -52,6 +52,14 @@ export interface RenderScheduler {
 export function createRenderScheduler(
   renderNow: () => void,
   scheduleFlush: (flush: () => void) => void = queueMicrotask,
+  /**
+   * When provided and returning true, every composite path becomes a no-op.
+   * Wired to process-lifecycle's isTerminalRestored(): once the exit teardown
+   * has handed the terminal back to the shell, a late frame (async shutdown
+   * races, stray timers) would paint cursor-positioned content over the
+   * user's primary screen and strand the next prompt mid-screen.
+   */
+  isReleased: () => boolean = () => false,
 ): RenderScheduler {
   let scheduled = false;
 
@@ -61,6 +69,7 @@ export function createRenderScheduler(
     // tick never composites twice.
     if (!scheduled) return;
     scheduled = false;
+    if (isReleased()) return;
     renderNow();
   };
 
@@ -73,6 +82,7 @@ export function createRenderScheduler(
   const flushNow = (): void => {
     // Satisfy any pending coalesced flush, then composite synchronously.
     scheduled = false;
+    if (isReleased()) return;
     renderNow();
   };
 

package/src/runtime/services.ts

@@ -56,7 +56,7 @@ import { isFeatureFlagEnabled } from './surface-feature-flags.ts';
 import type { FeatureFlagManager } from '@/runtime/index.ts';
 import { createFeatureFlagManager } from '@/runtime/index.ts';
 import { PolicyRuntimeState } from '@/runtime/index.ts';
-import { createProcessRegistry, type ProcessRegistry } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import { createProcessRegistry, withFleetArchive, type ArchivableProcessRegistry } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
 import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 import { createWorkstreamServices, type OrchestrationEngine, type WorkstreamCommandService } from './workstream-services.ts';
 import { codeIndexDbPath, createCodeIndexServices, isCodeInjectionSettingEnabled } from './code-index-services.ts';
@@ -231,8 +231,8 @@ export interface RuntimeServices {
   /** The repo source-tree code index — see runtime/code-index-services.ts. */
   readonly codeIndexStore: CodeIndexStore;
   readonly codeIndexReindexScheduler: CodeIndexReindexScheduler; // tool-site reindex
-  /** W2.1/W2.2: unified live process registry (agents, WRFC chains, workflows, watchers, background processes) backing the Fleet panel. */
-  readonly processRegistry: ProcessRegistry;
+  /** Unified live process registry (agents, WRFC chains, workflows, watchers, background processes) backing the Fleet panel; archive-aware — finished subtrees can be moved to the session archive view. */
+  readonly processRegistry: ArchivableProcessRegistry;
   readonly modeManager: ModeManager;
   readonly fileUndoManager: FileUndoManager;
   readonly workspaceCheckpointManager: WorkspaceCheckpointManager;
@@ -609,7 +609,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   // the Fleet panel (panels/fleet-read-model.ts) is its first consumer.
   // Constructed once here (not per-consumer) so the coalesced tick and the
   // agent-activity side-table are shared, not duplicated.
-  const processRegistry = createProcessRegistry({
+  const processRegistry = withFleetArchive(createProcessRegistry({
     agentManager,
     wrfcController,
     orchestrationEngine, // Folds workstream/phase/work-item nodes into the fleet
@@ -628,7 +628,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
       if (!isModelPriced(modelId)) return null;
       return calcSessionCost(usage.inputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens, modelId);
     },
-  });
+  }));
   const modeManager = new ModeManager();
   const fileUndoManager = new FileUndoManager();
   const workspaceCheckpointManager = new WorkspaceCheckpointManager({

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.11.1';
+let _version = '1.13.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;