@pellux/goodvibes-tui 1.0.0 → 1.7.0

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

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

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

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

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

@@ -7,6 +7,7 @@ import { exportToMarkdown } from '@pellux/goodvibes-sdk/platform/export';
 import { TemplateManager, parseTemplateArgs } from '@pellux/goodvibes-sdk/platform/templates';
 import { requireSessionManager, requireSessionMemoryStore, requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { sessionCommand } from './session.ts';
 
 export function registerSessionContentCommands(registry: CommandRegistry): void {
   registry.register({
@@ -238,7 +239,18 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
   registry.register({
     name: 'sessions',
     description: 'List saved sessions',
+    usage: '[resume <id|name>]',
+    argsHint: '[resume <id|name>]',
     async handler(_args, ctx) {
+      // Splash's "resume last session" hint and users' muscle memory both say
+      // `/sessions resume <id>` (plural, matching this command's own name) —
+      // but subcommands like `resume` are only implemented on the singular
+      // `/session` command. Forward instead of silently listing and dropping
+      // the subcommand+id on the floor.
+      if (_args.length > 0) {
+        await sessionCommand.handler(_args, ctx);
+        return;
+      }
       const sessionManager = requireSessionManager(ctx);
       const sessions = sessionManager.list();
       if (ctx.openSelection) {

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;
 }
 
@@ -260,6 +275,9 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
           });
         },
       });
+      // Hydrate the footer's token counters from the resumed (+ journal-replayed)
+      // history now, before ctx.renderRequest() below (W0.9).
+      ctx.session.hydrateSessionUsage?.();
 
       if (meta.model) {
         try {

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/share-runtime.ts

@@ -10,7 +10,7 @@ import {
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { calcSessionCost } from '../../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../../export/cost-utils.ts';
 import {
   GistUploadTarget,
   NO_TOKEN_GUIDANCE,
@@ -113,6 +113,13 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
       const sessionCostUsd = calcSessionCost(
         totalInput, totalOutput, totalCacheRead, totalCacheWrite, sessionModel,
       );
+      // The exported document has no field for "this cost is a placeholder" —
+      // omit `cost` entirely rather than embed a misleading 0 when the model
+      // never resolved to a real price (WO-315).
+      const costIsUnpriced = !isModelPriced(sessionModel);
+      if (costIsUnpriced) {
+        ctx.print(`Note: cost omitted from export — no pricing data for model "${sessionModel}".`);
+      }
 
       const metadata = {
         model: sessionModel,
@@ -120,7 +127,7 @@ export function registerShareRuntimeCommands(registry: CommandRegistry): void {
         sessionId: ctx.session.runtime.sessionId,
         title: ctx.session.conversationManager.title || undefined,
       };
-      const options = { redact, cost: sessionCostUsd };
+      const options = { redact, cost: costIsUnpriced ? undefined : sessionCostUsd };
 
       let outputContent: string;
       try {

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

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

@@ -0,0 +1,277 @@
+import { loadPackageScripts, getSkippedGateReason } from '@pellux/goodvibes-sdk/platform/agents';
+import type { ToolCall } from '@pellux/goodvibes-sdk/platform/types';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+/**
+ * Timeout for a /test run, in milliseconds. Deliberately much longer than
+ * WRFC's WRFC_GATE_TIMEOUT_MS (120s, tuned for CI gates) — this repo's own
+ * suite is 600+ test files (scripts/run-tests.ts), and /test is an
+ * interactive command with no other caller waiting on it.
+ *
+ * Exported (rather than a private const) so tests can pass a shorter override
+ * straight through to runTestCommand's optional third parameter instead of
+ * waiting out the real timeout.
+ */
+export const TEST_RUN_TIMEOUT_MS = 300_000;
+
+/** How often buffered stdout/stderr lines are flushed to the transcript during
+ * a run. Batching avoids hammering the transcript.append_one perf budget
+ * (6ms, scripts/perf-baseline.json) with one ctx.print() call per output line. */
+const STREAM_FLUSH_INTERVAL_MS = 250;
+
+/** Cap on individually-listed failing test file names before truncating. */
+const MAX_FAILING_NAMES_SHOWN = 20;
+
+/** Lines of raw output shown when structured results could not be parsed. */
+const RAW_TAIL_LINES = 30;
+
+const FAIL_LINE_RE = /^==> (.+?)\s+\[FAIL\]$/gm;
+const SUMMARY_LINE_RE = /^Test files: (\d+), passed: (\d+), failed: (\d+)$/m;
+// Plain `bun test` output: " N pass" / " N fail" counters (tests, not files),
+// "Ran N tests across M files.", and "(fail) suite > name" per failing test.
+const BUN_PASS_RE = /^\s*(\d+) pass\s*$/m;
+const BUN_FAIL_RE = /^\s*(\d+) fail\s*$/m;
+const BUN_FILES_RE = /across (\d+) files?\./;
+const BUN_FAIL_TEST_RE = /^\(fail\) (.+)$/gm;
+
+interface ParsedTestResults {
+  totalFiles: number;
+  passed: number;
+  failed: number;
+  failingFiles: string[];
+  /** Whether passed/failed count files (goodvibes runner) or tests (bun test). */
+  unit: 'files' | 'tests';
+}
+
+/**
+ * Parse this repo's own scripts/run-tests.ts output shape:
+ *   per-file:  `==> path/to/file.test.ts  [FAIL]` (only present on failure)
+ *   summary:   `Test files: N, passed: P, failed: F`
+ * Returns null when the summary line isn't present at all — the fallback
+ * path (raw tail, no fabricated counts) covers a different project's
+ * jest/vitest/pytest output, or any run that bypassed run-tests.ts.
+ */
+export function parseTestOutput(output: string): ParsedTestResults | null {
+  const summaryMatch = SUMMARY_LINE_RE.exec(output);
+  if (summaryMatch) {
+    const failingFiles: string[] = [];
+    FAIL_LINE_RE.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = FAIL_LINE_RE.exec(output)) !== null) {
+      failingFiles.push(match[1]!);
+    }
+    return {
+      totalFiles: Number(summaryMatch[1]),
+      passed: Number(summaryMatch[2]),
+      failed: Number(summaryMatch[3]),
+      failingFiles,
+      unit: 'files',
+    };
+  }
+  // Plain `bun test`: counts are per-test, failing entries are test names.
+  const bunPass = BUN_PASS_RE.exec(output);
+  const bunFail = BUN_FAIL_RE.exec(output);
+  if (bunPass && bunFail) {
+    const failingTests: string[] = [];
+    BUN_FAIL_TEST_RE.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = BUN_FAIL_TEST_RE.exec(output)) !== null) {
+      failingTests.push(match[1]!);
+    }
+    return {
+      totalFiles: Number(BUN_FILES_RE.exec(output)?.[1] ?? 0),
+      passed: Number(bunPass[1]),
+      failed: Number(bunFail[1]),
+      failingFiles: failingTests,
+      unit: 'tests',
+    };
+  }
+  return null;
+}
+
+/**
+ * Single-quote shell-escape a value for safe interpolation into a
+ * `/bin/sh -c` string: wrap in single quotes, turning any embedded single
+ * quote into `'\''` (close quote, escaped literal quote, reopen quote).
+ * Mirrors the injection-risk class already present in the SDK's
+ * wrfc-gates.ts (executeGateCommand) and this repo's git-runtime.ts /
+ * diff-runtime.ts, which build shell command strings the same way — a
+ * pattern arg is never string-concatenated into the command raw.
+ */
+export function shQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/** Reads a ReadableStream<Uint8Array> incrementally, decoding and forwarding
+ * each chunk of text as it arrives (display-only accumulation happens in the
+ * caller; this just pumps the stream to completion). */
+async function pumpStream(
+  stream: ReadableStream<Uint8Array> | undefined,
+  onChunk: (text: string) => void,
+): Promise<void> {
+  if (!stream) return;
+  const decoder = new TextDecoder();
+  for await (const chunk of stream) {
+    onChunk(decoder.decode(chunk, { stream: true }));
+  }
+}
+
+export function registerTestRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'test',
+    aliases: [],
+    description: 'Run the project test script and show pass/fail results',
+    usage: '[pattern]',
+    argsHint: '[pattern]',
+    async handler(args, ctx) {
+      await runTestCommand(args, ctx);
+    },
+  });
+}
+
+/**
+ * Core /test implementation, factored out of the registered handler so tests
+ * can call it directly with a shortened `timeoutMs` override (the timeout
+ * path would otherwise take TEST_RUN_TIMEOUT_MS to exercise).
+ */
+export async function runTestCommand(
+  args: string[],
+  ctx: CommandContext,
+  timeoutMs: number = TEST_RUN_TIMEOUT_MS,
+): Promise<void> {
+  const cwd = requireShellPaths(ctx).workingDirectory;
+  const pkgScripts = await loadPackageScripts(cwd);
+  const skip = getSkippedGateReason('test', cwd, pkgScripts);
+  if (skip) {
+    ctx.print(skip);
+    return;
+  }
+
+  const pattern = args.length > 0 ? args.join(' ') : undefined;
+  const command = args.length > 0
+    ? `${pkgScripts.test} ${args.map(shQuote).join(' ')}`
+    : pkgScripts.test!;
+  const toolCall: ToolCall = { id: 'test-run', name: 'test', arguments: pattern ? { pattern } : {} };
+
+  ctx.print(`Running: ${command}`);
+
+  const startedAt = Date.now();
+  const proc = Bun.spawn(['/bin/sh', '-c', command], { cwd, stdout: 'pipe', stderr: 'pipe' });
+
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    proc.kill();
+  }, timeoutMs);
+  timer.unref?.();
+
+  let combinedOutput = '';
+  let pendingDisplay = '';
+  const appendChunk = (text: string): void => {
+    combinedOutput += text;
+    pendingDisplay += text;
+  };
+  const flushDisplay = (force = false): void => {
+    if (!pendingDisplay) return;
+    if (force) {
+      ctx.print(pendingDisplay);
+      pendingDisplay = '';
+      return;
+    }
+    const lastNewline = pendingDisplay.lastIndexOf('\n');
+    if (lastNewline === -1) return; // no complete line buffered yet
+    const toPrint = pendingDisplay.slice(0, lastNewline);
+    pendingDisplay = pendingDisplay.slice(lastNewline + 1);
+    if (toPrint) ctx.print(toPrint);
+  };
+  const flushTimer = setInterval(() => flushDisplay(false), STREAM_FLUSH_INTERVAL_MS);
+
+  let exitCode: number;
+  try {
+    [exitCode] = await Promise.all([
+      proc.exited,
+      pumpStream(proc.stdout, appendChunk),
+      pumpStream(proc.stderr, appendChunk),
+    ]);
+  } finally {
+    clearTimeout(timer);
+    clearInterval(flushTimer);
+  }
+
+  const durationMs = Date.now() - startedAt;
+
+  if (timedOut) {
+    flushDisplay(true);
+    const timeoutSeconds = Math.round(timeoutMs / 1000);
+    ctx.print(`Test run timed out after ${timeoutSeconds}s and was killed.`);
+    ctx.session.conversationManager.logToolResultBlock(
+      toolCall,
+      'error',
+      'timed out',
+      durationMs,
+      `timed out after ${timeoutSeconds}s`,
+    );
+    // Durable end state: logToolResultBlock (above) renders straight into the
+    // display-only history buffer and never touches the real message list, so
+    // it does not survive the next full rebuildHistory() (which rebuilds
+    // strictly from conversationManager.getMessageSnapshot()) — the very next
+    // dirty render silently wipes it back to how the transcript looked before
+    // /test ran. addSystemMessage persists the same content as a real message
+    // (same durable pattern as /rewind's confirm notice in
+    // checkpoint-runtime.ts) so the timeout outcome survives like any other
+    // command's output. The streamed output during the run is allowed to stay
+    // transient — only this final state needs to persist.
+    ctx.session.conversationManager.addSystemMessage(
+      `[Test] Timed out after ${timeoutSeconds}s and was killed.`,
+    );
+    ctx.renderRequest();
+    return;
+  }
+
+  flushDisplay(true);
+
+  const ok = exitCode === 0;
+  const parsed = parseTestOutput(combinedOutput);
+
+  if (parsed) {
+    const summary = parsed.unit === 'files'
+      ? `${parsed.passed}/${parsed.totalFiles} files passed`
+      : `${parsed.passed} passed, ${parsed.failed} failed${parsed.totalFiles ? ` across ${parsed.totalFiles} file${parsed.totalFiles === 1 ? '' : 's'}` : ''}`;
+    const failedNoun = parsed.unit === 'files' ? 'file' : 'test';
+    const errorMsg = ok ? undefined : `${parsed.failed} ${failedNoun}${parsed.failed === 1 ? '' : 's'} failed`;
+    ctx.session.conversationManager.logToolResultBlock(toolCall, ok ? 'done' : 'error', summary, durationMs, errorMsg);
+    const durableLines = [`[Test] ${summary}${errorMsg ? ` — ${errorMsg}` : ''}`];
+    if (parsed.failingFiles.length > 0) {
+      const shown = parsed.failingFiles.slice(0, MAX_FAILING_NAMES_SHOWN);
+      const failListHeader = parsed.unit === 'files' ? 'Failing test files:' : 'Failing tests:';
+      const lines = [failListHeader, ...shown.map((f) => `  - ${f}`)];
+      const remaining = parsed.failingFiles.length - shown.length;
+      if (remaining > 0) lines.push(`  ...and ${remaining} more`);
+      ctx.print(lines.join('\n'));
+      durableLines.push(...lines);
+    }
+    // See the timeout branch's comment above: logToolResultBlock's tool-styled
+    // render is display-only and does not survive the next full history
+    // rebuild. addSystemMessage persists the pass/fail summary AND the
+    // failing-file detail as a real message so both remain in the transcript
+    // after the command completes, not just during the ~1s before the next
+    // render wipes the display-only copy.
+    ctx.session.conversationManager.addSystemMessage(durableLines.join('\n'));
+  } else {
+    ctx.session.conversationManager.logToolResultBlock(
+      toolCall,
+      ok ? 'done' : 'error',
+      `exit code ${exitCode}`,
+      durationMs,
+      ok ? undefined : `exit code ${exitCode}`,
+    );
+    const tail = combinedOutput.split('\n').slice(-RAW_TAIL_LINES).join('\n');
+    ctx.print(`(could not parse structured test results; showing raw tail)\n${tail}`);
+    ctx.session.conversationManager.addSystemMessage(
+      `[Test] exit code ${exitCode} (could not parse structured test results)`,
+    );
+  }
+
+  ctx.renderRequest();
+}