@opengsd/get-shit-done-redux 1.0.0

package/sdk/src/bug-3591-gsdtools-runtime-workstream.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Bug #3591: createGSDToolsRuntime accepts a `workstream` option, but the
+ * native dispatch closure passed to QueryNativeDirectAdapter dropped it
+ * before forwarding to registry.dispatch(). The omission silently routed
+ * native query handlers to root `.planning` instead of
+ * `.planning/workstreams/<name>` whenever a GSDTools instance was created
+ * with a workstream and native dispatch was used.
+ *
+ * The fix passes `opts.workstream` as the 4th argument to
+ * `registry.dispatch(command, args, projectDir, workstream)`. This test
+ * captures the dispatch closure via a constructor-seam spy on
+ * QueryNativeDirectAdapter, builds a mock registry whose dispatch records
+ * its arguments, then invokes the captured closure to verify the
+ * workstream is forwarded.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { createGSDToolsRuntime } from './query-gsd-tools-runtime.js';
+import * as adapterModule from './query-native-direct-adapter.js';
+import * as registryModule from './query/index.js';
+
+describe('bug #3591: createGSDToolsRuntime forwards workstream to registry.dispatch', () => {
+  it('native dispatch closure passes opts.workstream as 4th arg to registry.dispatch', async () => {
+    // Capture the `dispatch` option passed into QueryNativeDirectAdapter.
+    let capturedDispatch:
+      | ((command: string, args: string[]) => Promise<unknown>)
+      | null = null;
+    const adapterSpy = vi
+      .spyOn(adapterModule, 'QueryNativeDirectAdapter')
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation((deps: any) => {
+        capturedDispatch = deps.dispatch;
+        // Return a minimal stub satisfying the runtime constructor.
+        return {
+          dispatchResult: vi.fn(),
+          dispatchJson: vi.fn(),
+          dispatchRaw: vi.fn(),
+        } as unknown as adapterModule.QueryNativeDirectAdapter;
+      });
+
+    const registry = registryModule.createRegistry();
+    const dispatchSpy = vi.spyOn(registry, 'dispatch');
+    const createRegistrySpy = vi
+      .spyOn(registryModule, 'createRegistry')
+      .mockReturnValue(registry);
+
+    try {
+      createGSDToolsRuntime({
+        projectDir: '/tmp/3591-proj',
+        gsdToolsPath: '/tmp/gsd-tools.cjs',
+        timeoutMs: 1_000,
+        workstream: 'frontend-ws',
+        shouldUseNativeQuery: () => true,
+        execJsonFallback: vi.fn(async () => ({})),
+        execRawFallback: vi.fn(async () => ''),
+      });
+
+      expect(adapterSpy).toHaveBeenCalled();
+      expect(capturedDispatch).not.toBeNull();
+      await capturedDispatch!('__bug-3591-unknown-cmd__', ['x']);
+    } catch (err) {
+      // unknown command is expected from the real registry
+      void err;
+    } finally {
+      createRegistrySpy.mockRestore();
+      adapterSpy.mockRestore();
+    }
+
+    expect(dispatchSpy).toHaveBeenCalledWith(
+      '__bug-3591-unknown-cmd__',
+      ['x'],
+      '/tmp/3591-proj',
+      'frontend-ws',
+    );
+  });
+
+  it('forwards undefined workstream when the option is omitted (back-compat)', async () => {
+    // Same shape as above but no workstream. The closure must still pass
+    // projectDir; passing `undefined` for the 4th slot is the documented
+    // signature of registry.dispatch.
+    let capturedDispatch:
+      | ((command: string, args: string[]) => Promise<unknown>)
+      | null = null;
+    const registry = registryModule.createRegistry();
+    const dispatchSpy = vi.spyOn(registry, 'dispatch');
+    const adapterSpy = vi
+      .spyOn(adapterModule, 'QueryNativeDirectAdapter')
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation((deps: any) => {
+        capturedDispatch = deps.dispatch;
+        return {
+          dispatchResult: vi.fn(),
+          dispatchJson: vi.fn(),
+          dispatchRaw: vi.fn(),
+        } as unknown as adapterModule.QueryNativeDirectAdapter;
+      });
+
+    const createRegistrySpy = vi
+      .spyOn(registryModule, 'createRegistry')
+      .mockReturnValue(registry);
+
+    try {
+      createGSDToolsRuntime({
+        projectDir: '/tmp/3591-proj',
+        gsdToolsPath: '/tmp/gsd-tools.cjs',
+        timeoutMs: 1_000,
+        // workstream intentionally omitted
+        shouldUseNativeQuery: () => true,
+        execJsonFallback: vi.fn(async () => ({})),
+        execRawFallback: vi.fn(async () => ''),
+      });
+
+      expect(capturedDispatch).not.toBeNull();
+      await capturedDispatch!('__bug-3591-unknown-cmd-2__', []);
+    } catch (err) {
+      // unknown command is expected from the real registry
+      void err;
+    } finally {
+      createRegistrySpy.mockRestore();
+      adapterSpy.mockRestore();
+    }
+
+    expect(dispatchSpy).toHaveBeenCalledWith(
+      '__bug-3591-unknown-cmd-2__',
+      [],
+      '/tmp/3591-proj',
+      undefined,
+    );
+  });
+});
+
+describe('bug #3591: end-to-end — workstream-aware probe handler receives the workstream', () => {
+  it('a registered probe handler receives opts.workstream as its 3rd arg', async () => {
+    // End-to-end path: register a probe handler on a real registry (via
+    // module-level export), build the runtime with a workstream, and
+    // assert the handler observed the workstream when invoked through the
+    // native dispatch closure.
+    const registryModule = await import('./query/index.js');
+    const probeRegistry = registryModule.createRegistry();
+    const seen: Array<{ args: string[]; projectDir: string; workstream?: string }> = [];
+    probeRegistry.register('__bug-3591-probe__', async (args, projectDir, workstream) => {
+      seen.push({ args, projectDir, workstream });
+      return { data: { ok: true } };
+    });
+
+    // The runtime builds its OWN registry internally; we can't substitute
+    // ours unless we mock createRegistry. Hoist a module mock for that.
+    const createRegistrySpy = vi
+      .spyOn(registryModule, 'createRegistry')
+      .mockReturnValue(probeRegistry);
+
+    try {
+      const runtime = createGSDToolsRuntime({
+        projectDir: '/tmp/3591-proj',
+        gsdToolsPath: '/tmp/gsd-tools.cjs',
+        timeoutMs: 1_000,
+        workstream: 'frontend-ws',
+        shouldUseNativeQuery: () => true,
+        execJsonFallback: vi.fn(async () => ({})),
+        execRawFallback: vi.fn(async () => ''),
+      });
+
+      await runtime.bridge.dispatchHotpath(
+        '__bug-3591-probe-legacy__',
+        [],
+        '__bug-3591-probe__',
+        ['payload'],
+        'json',
+      );
+    } finally {
+      createRegistrySpy.mockRestore();
+    }
+
+    expect(seen).toHaveLength(1);
+    expect(seen[0]?.args).toEqual(['payload']);
+    expect(seen[0]?.projectDir).toBe('/tmp/3591-proj');
+    expect(seen[0]?.workstream).toBe('frontend-ws');
+  });
+});

package/sdk/src/cli-transport.test.ts

@@ -0,0 +1,388 @@
+import { describe, it, expect } from 'vitest';
+import { PassThrough } from 'node:stream';
+import { CLITransport } from './cli-transport.js';
+import { GSDEventType, type GSDEvent, type GSDEventBase } from './types.js';
+
+// ─── ANSI constants (mirror the source for readable assertions) ──────────────
+
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[90m';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeBase(overrides: Partial<GSDEventBase> = {}): Omit<GSDEventBase, 'type'> {
+  return {
+    timestamp: '2025-06-15T14:30:45.123Z',
+    sessionId: 'test-session',
+    ...overrides,
+  };
+}
+
+function readOutput(stream: PassThrough): string {
+  const chunks: Buffer[] = [];
+  let chunk: Buffer | null;
+  while ((chunk = stream.read() as Buffer | null) !== null) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8').trim();
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('CLITransport', () => {
+  it('formats SessionInit event correctly', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.SessionInit,
+      model: 'claude-sonnet-4-20250514',
+      tools: ['Read', 'Write', 'Bash'],
+      cwd: '/home/project',
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toBe(
+      '[14:30:45] [INIT] Session started — model: claude-sonnet-4-20250514, tools: 3, cwd: /home/project',
+    );
+  });
+
+  it('formats SessionComplete in green with checkmark', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.SessionComplete,
+      success: true,
+      totalCostUsd: 1.234,
+      durationMs: 45600,
+      numTurns: 12,
+      result: 'done',
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toBe(
+      `[14:30:45] ${GREEN}✓ Session complete — cost: $1.23, turns: 12, duration: 45.6s${RESET}`,
+    );
+  });
+
+  it('formats SessionError in red with ✗ marker', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.SessionError,
+      success: false,
+      totalCostUsd: 0.5,
+      durationMs: 3000,
+      numTurns: 2,
+      errorSubtype: 'tool_error',
+      errors: ['file not found', 'permission denied'],
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toBe(
+      `[14:30:45] ${RED}✗ Session failed — subtype: tool_error, errors: [file not found, permission denied]${RESET}`,
+    );
+  });
+
+  it('formats PhaseStart as bold cyan banner and PhaseComplete with running cost', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.PhaseStart,
+      phaseNumber: '01',
+      phaseName: 'Authentication',
+    } as GSDEvent);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.PhaseComplete,
+      phaseNumber: '01',
+      phaseName: 'Authentication',
+      success: true,
+      totalCostUsd: 2.50,
+      totalDurationMs: 60000,
+      stepsCompleted: 5,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    const lines = output.split('\n');
+    expect(lines[0]).toBe(`${BOLD}${CYAN}━━━ GSD ► PHASE 01: Authentication ━━━${RESET}`);
+    expect(lines[1]).toBe('[14:30:45] [PHASE] Phase 01 complete — success: true, cost: $2.50, running: $0.00');
+  });
+
+  it('formats ToolCall with truncated input', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    const longInput = { content: 'x'.repeat(200) };
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.ToolCall,
+      toolName: 'Write',
+      toolUseId: 'tool-123',
+      input: longInput,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toMatch(/^\[14:30:45\] \[TOOL\] Write\(.+…\)$/);
+    // The truncated input portion (inside parens) should be ≤80 chars
+    const insideParens = output.match(/Write\((.+)\)/)![1]!;
+    expect(insideParens.length).toBeLessThanOrEqual(80);
+  });
+
+  it('formats MilestoneStart as bold banner and MilestoneComplete with running cost', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.MilestoneStart,
+      phaseCount: 3,
+      prompt: 'build the app',
+    } as GSDEvent);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.MilestoneComplete,
+      success: true,
+      totalCostUsd: 8.75,
+      totalDurationMs: 300000,
+      phasesCompleted: 3,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    const lines = output.split('\n');
+    // MilestoneStart emits 3 lines (top bar, text, bottom bar)
+    expect(lines[0]).toBe(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+    expect(lines[1]).toBe(`${BOLD}  GSD Milestone — 3 phases${RESET}`);
+    expect(lines[2]).toBe(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+    expect(lines[3]).toBe(`${BOLD}━━━ Milestone complete — success: true, cost: $8.75, running: $0.00 ━━━${RESET}`);
+  });
+
+  it('close() is callable without error', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+    expect(() => transport.close()).not.toThrow();
+  });
+
+  it('onEvent does not throw on unknown event type variant', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    // Use a known event type that hits the default/fallback branch
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.ToolProgress,
+      toolName: 'Bash',
+      toolUseId: 'tool-456',
+      elapsedSeconds: 12,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toBe('[14:30:45] [EVENT] tool_progress');
+  });
+
+  it('formats AssistantText as dim with truncation at 200 chars', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    const longText = 'A'.repeat(300);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.AssistantText,
+      text: longText,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toMatch(new RegExp(`^${escRe(DIM)}\\[14:30:45\\] A+…${escRe(RESET)}$`));
+    // Strip ANSI to check text length
+    const stripped = stripAnsi(output);
+    const agentText = stripped.split('] ')[1]!;
+    expect(agentText.length).toBeLessThanOrEqual(200);
+  });
+
+  it('formats WaveStart in yellow and WaveComplete with colored counts', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.WaveStart,
+      phaseNumber: '01',
+      waveNumber: 2,
+      planCount: 4,
+      planIds: ['plan-a', 'plan-b', 'plan-c', 'plan-d'],
+    } as GSDEvent);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.WaveComplete,
+      phaseNumber: '01',
+      waveNumber: 2,
+      successCount: 3,
+      failureCount: 1,
+      durationMs: 25000,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    const lines = output.split('\n');
+    expect(lines[0]).toBe(`${YELLOW}⟫ Wave 2 (4 plans)${RESET}`);
+    expect(lines[1]).toBe(
+      `[14:30:45] [WAVE] Wave 2 complete — ${GREEN}3 success${RESET}, ${RED}1 failed${RESET}, 25000ms`,
+    );
+  });
+
+  // ─── New tests for rich formatting ─────────────────────────────────────────
+
+  it('formats PhaseStepStart in cyan with ◆ indicator', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.PhaseStepStart,
+      phaseNumber: '01',
+      step: 'research',
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toBe(`${CYAN}◆ research${RESET}`);
+  });
+
+  it('formats PhaseStepComplete green ✓ on success, red ✗ on failure', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.PhaseStepComplete,
+      phaseNumber: '01',
+      step: 'plan',
+      success: true,
+      durationMs: 5200,
+    } as GSDEvent);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.PhaseStepComplete,
+      phaseNumber: '01',
+      step: 'execute',
+      success: false,
+      durationMs: 12000,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    const lines = output.split('\n');
+    expect(lines[0]).toBe(`${GREEN}✓ plan${RESET} ${DIM}5200ms${RESET}`);
+    expect(lines[1]).toBe(`${RED}✗ execute${RESET} ${DIM}12000ms${RESET}`);
+  });
+
+  it('formats InitResearchSpawn in cyan with ◆ and session count', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.InitResearchSpawn,
+      sessionCount: 4,
+      researchTypes: ['stack', 'features', 'architecture', 'pitfalls'],
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    expect(output).toBe(`${CYAN}◆ Spawning 4 researchers...${RESET}`);
+  });
+
+  it('tracks running cost across CostUpdate events', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    // First cost update
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.CostUpdate,
+      sessionCostUsd: 0.50,
+      cumulativeCostUsd: 0.50,
+    } as GSDEvent);
+
+    // Second cost update
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.CostUpdate,
+      sessionCostUsd: 0.75,
+      cumulativeCostUsd: 1.25,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    const lines = output.split('\n');
+    expect(lines[0]).toBe(`${DIM}[14:30:45] Cost: session $0.50, running $0.50${RESET}`);
+    expect(lines[1]).toBe(`${DIM}[14:30:45] Cost: session $0.75, running $1.25${RESET}`);
+  });
+
+  it('shows running cost in PhaseComplete and MilestoneComplete after CostUpdates', () => {
+    const stream = new PassThrough();
+    const transport = new CLITransport(stream);
+
+    // Accumulate some cost
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.CostUpdate,
+      sessionCostUsd: 1.50,
+      cumulativeCostUsd: 1.50,
+    } as GSDEvent);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.PhaseComplete,
+      phaseNumber: '02',
+      phaseName: 'Build',
+      success: true,
+      totalCostUsd: 1.50,
+      totalDurationMs: 30000,
+      stepsCompleted: 3,
+    } as GSDEvent);
+
+    transport.onEvent({
+      ...makeBase(),
+      type: GSDEventType.MilestoneComplete,
+      success: true,
+      totalCostUsd: 1.50,
+      totalDurationMs: 30000,
+      phasesCompleted: 2,
+    } as GSDEvent);
+
+    const output = readOutput(stream);
+    const lines = output.split('\n');
+    // CostUpdate line
+    expect(lines[0]).toContain('running $1.50');
+    // PhaseComplete includes running cost
+    expect(lines[1]).toContain('running: $1.50');
+    // MilestoneComplete includes running cost
+    expect(lines[2]).toContain('running: $1.50');
+  });
+});
+
+// ─── Test utilities ──────────────────────────────────────────────────────────
+
+/** Escape a string for use in a RegExp. */
+function escRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Strip ANSI escape sequences from a string. */
+function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/sdk/src/cli-transport.ts

@@ -0,0 +1,130 @@
+/**
+ * CLI Transport — renders GSD events as rich ANSI-colored output to a Writable stream.
+ *
+ * Implements TransportHandler with colored banners, step indicators, spawn markers,
+ * and running cost totals. No external dependencies — ANSI codes are inline constants.
+ */
+
+import type { Writable } from 'node:stream';
+import { GSDEventType, type GSDEvent, type TransportHandler } from './types.js';
+
+// ─── ANSI escape constants (no dependency per D021) ──────────────────────────
+
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[90m';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Extract HH:MM:SS from an ISO-8601 timestamp. */
+function formatTime(ts: string): string {
+  try {
+    const d = new Date(ts);
+    if (Number.isNaN(d.getTime())) return '??:??:??';
+    return d.toISOString().slice(11, 19);
+  } catch {
+    return '??:??:??';
+  }
+}
+
+/** Truncate a string to `max` characters, appending '…' if truncated. */
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + '…';
+}
+
+/** Format a USD amount. */
+function usd(n: number): string {
+  return `$${n.toFixed(2)}`;
+}
+
+// ─── CLITransport ────────────────────────────────────────────────────────────
+
+export class CLITransport implements TransportHandler {
+  private readonly out: Writable;
+  private runningCostUsd = 0;
+
+  constructor(out?: Writable) {
+    this.out = out ?? process.stdout;
+  }
+
+  /** Format and write a GSD event as a rich ANSI-colored line. Never throws. */
+  onEvent(event: GSDEvent): void {
+    try {
+      const line = this.formatEvent(event);
+      this.out.write(line + '\n');
+    } catch {
+      // TransportHandler contract: onEvent must never throw
+    }
+  }
+
+  /** No-op — stdout doesn't need cleanup. */
+  close(): void {
+    // Nothing to clean up
+  }
+
+  // ─── Private formatting ────────────────────────────────────────────
+
+  private formatEvent(event: GSDEvent): string {
+    const time = formatTime(event.timestamp);
+
+    switch (event.type) {
+      case GSDEventType.SessionInit:
+        return `[${time}] [INIT] Session started — model: ${event.model}, tools: ${event.tools.length}, cwd: ${event.cwd}`;
+
+      case GSDEventType.SessionComplete:
+        return `[${time}] ${GREEN}✓ Session complete — cost: ${usd(event.totalCostUsd)}, turns: ${event.numTurns}, duration: ${(event.durationMs / 1000).toFixed(1)}s${RESET}`;
+
+      case GSDEventType.SessionError:
+        return `[${time}] ${RED}✗ Session failed — subtype: ${event.errorSubtype}, errors: [${event.errors.join(', ')}]${RESET}`;
+
+      case GSDEventType.ToolCall:
+        return `[${time}] [TOOL] ${event.toolName}(${truncate(JSON.stringify(event.input), 80)})`;
+
+      case GSDEventType.PhaseStart:
+        return `${BOLD}${CYAN}━━━ GSD ► PHASE ${event.phaseNumber}: ${event.phaseName} ━━━${RESET}`;
+
+      case GSDEventType.PhaseComplete:
+        return `[${time}] [PHASE] Phase ${event.phaseNumber} complete — success: ${event.success}, cost: ${usd(event.totalCostUsd)}, running: ${usd(this.runningCostUsd)}`;
+
+      case GSDEventType.PhaseStepStart:
+        return `${CYAN}◆ ${event.step}${RESET}`;
+
+      case GSDEventType.PhaseStepComplete:
+        return event.success
+          ? `${GREEN}✓ ${event.step}${RESET} ${DIM}${event.durationMs}ms${RESET}`
+          : `${RED}✗ ${event.step}${RESET} ${DIM}${event.durationMs}ms${RESET}`;
+
+      case GSDEventType.WaveStart:
+        return `${YELLOW}⟫ Wave ${event.waveNumber} (${event.planCount} plans)${RESET}`;
+
+      case GSDEventType.WaveComplete:
+        return `[${time}] [WAVE] Wave ${event.waveNumber} complete — ${GREEN}${event.successCount} success${RESET}, ${RED}${event.failureCount} failed${RESET}, ${event.durationMs}ms`;
+
+      case GSDEventType.CostUpdate: {
+        this.runningCostUsd += event.sessionCostUsd;
+        return `${DIM}[${time}] Cost: session ${usd(event.sessionCostUsd)}, running ${usd(this.runningCostUsd)}${RESET}`;
+      }
+
+      case GSDEventType.MilestoneStart:
+        return `${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}\n${BOLD}  GSD Milestone — ${event.phaseCount} phases${RESET}\n${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`;
+
+      case GSDEventType.MilestoneComplete:
+        return `${BOLD}━━━ Milestone complete — success: ${event.success}, cost: ${usd(event.totalCostUsd)}, running: ${usd(this.runningCostUsd)} ━━━${RESET}`;
+
+      case GSDEventType.AssistantText:
+        return `${DIM}[${time}] ${truncate(event.text, 200)}${RESET}`;
+
+      case GSDEventType.InitResearchSpawn:
+        return `${CYAN}◆ Spawning ${event.sessionCount} researchers...${RESET}`;
+
+      // Generic fallback for event types without specific formatting
+      default:
+        return `[${time}] [EVENT] ${event.type}`;
+    }
+  }
+}