rafcode 2.1.0 → 2.2.0

package/tests/unit/token-tracker.test.ts

@@ -0,0 +1,352 @@
+import { TokenTracker, CostBreakdown } from '../../src/utils/token-tracker.js';
+import { UsageData, PricingConfig, DEFAULT_CONFIG } from '../../src/types/config.js';
+
+function makeUsage(overrides: Partial<UsageData> = {}): UsageData {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    modelUsage: {},
+    ...overrides,
+  };
+}
+
+const testPricing: PricingConfig = DEFAULT_CONFIG.pricing;
+
+describe('TokenTracker', () => {
+  describe('calculateCost', () => {
+    it('should calculate cost for opus model usage', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 500_000,
+        cacheReadInputTokens: 200_000,
+        cacheCreationInputTokens: 100_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 500_000,
+            cacheReadInputTokens: 200_000,
+            cacheCreationInputTokens: 100_000,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      expect(cost.inputCost).toBeCloseTo(15); // 1M * $15/MTok
+      expect(cost.outputCost).toBeCloseTo(37.5); // 0.5M * $75/MTok
+      expect(cost.cacheReadCost).toBeCloseTo(0.3); // 0.2M * $1.5/MTok
+      expect(cost.cacheCreateCost).toBeCloseTo(1.875); // 0.1M * $18.75/MTok
+      expect(cost.totalCost).toBeCloseTo(15 + 37.5 + 0.3 + 1.875);
+    });
+
+    it('should calculate cost for sonnet model usage', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-sonnet-4-5-20250929': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      expect(cost.inputCost).toBeCloseTo(3); // 1M * $3/MTok
+      expect(cost.outputCost).toBeCloseTo(15); // 1M * $15/MTok
+      expect(cost.totalCost).toBeCloseTo(18);
+    });
+
+    it('should calculate cost for haiku model usage', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        inputTokens: 2_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-haiku-4-5-20251001': {
+            inputTokens: 2_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      expect(cost.inputCost).toBeCloseTo(2); // 2M * $1/MTok
+      expect(cost.outputCost).toBeCloseTo(5); // 1M * $5/MTok
+      expect(cost.totalCost).toBeCloseTo(7);
+    });
+
+    it('should handle multi-model usage in a single task', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        inputTokens: 2_000_000,
+        outputTokens: 1_500_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 500_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+          'claude-haiku-4-5-20251001': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      // Opus: 1M*$15 + 0.5M*$75 = $15 + $37.5
+      // Haiku: 1M*$1 + 1M*$5 = $1 + $5
+      expect(cost.inputCost).toBeCloseTo(16); // 15 + 1
+      expect(cost.outputCost).toBeCloseTo(42.5); // 37.5 + 5
+      expect(cost.totalCost).toBeCloseTo(58.5);
+    });
+
+    it('should fallback to sonnet pricing when no model breakdown', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {},
+      });
+
+      const cost = tracker.calculateCost(usage);
+      expect(cost.inputCost).toBeCloseTo(3); // sonnet fallback
+      expect(cost.outputCost).toBeCloseTo(15);
+      expect(cost.totalCost).toBeCloseTo(18);
+    });
+
+    it('should fallback to sonnet pricing for unknown model families', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-unknown-3-0': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      expect(cost.inputCost).toBeCloseTo(3); // sonnet fallback
+      expect(cost.outputCost).toBeCloseTo(15);
+    });
+
+    it('should return zero cost for zero tokens', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage();
+      const cost = tracker.calculateCost(usage);
+      expect(cost.totalCost).toBe(0);
+    });
+
+    it('should apply cache read discount correctly', () => {
+      const tracker = new TokenTracker(testPricing);
+      const usage = makeUsage({
+        cacheReadInputTokens: 1_000_000,
+        modelUsage: {
+          'claude-sonnet-4-5': {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadInputTokens: 1_000_000,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      // Cache read: 1M * $0.30/MTok = $0.30 (90% off $3 input price)
+      expect(cost.cacheReadCost).toBeCloseTo(0.3);
+      expect(cost.totalCost).toBeCloseTo(0.3);
+    });
+  });
+
+  describe('addTask and accumulation', () => {
+    it('should accumulate usage across multiple tasks', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      tracker.addTask('01', makeUsage({
+        inputTokens: 500_000,
+        outputTokens: 200_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 500_000,
+            outputTokens: 200_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      tracker.addTask('02', makeUsage({
+        inputTokens: 300_000,
+        outputTokens: 100_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 300_000,
+            outputTokens: 100_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      const totals = tracker.getTotals();
+      expect(totals.usage.inputTokens).toBe(800_000);
+      expect(totals.usage.outputTokens).toBe(300_000);
+      expect(totals.usage.modelUsage['claude-opus-4-6']?.inputTokens).toBe(800_000);
+      expect(totals.usage.modelUsage['claude-opus-4-6']?.outputTokens).toBe(300_000);
+    });
+
+    it('should accumulate costs across multiple tasks', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      const entry1 = tracker.addTask('01', makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-sonnet-4-5': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      const entry2 = tracker.addTask('02', makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-sonnet-4-5': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      const totals = tracker.getTotals();
+      // Each task: $3 input + $15 output = $18
+      expect(entry1.cost.totalCost).toBeCloseTo(18);
+      expect(entry2.cost.totalCost).toBeCloseTo(18);
+      expect(totals.cost.totalCost).toBeCloseTo(36);
+    });
+
+    it('should accumulate multi-model usage across tasks', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      tracker.addTask('01', makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 500_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 500_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      tracker.addTask('02', makeUsage({
+        inputTokens: 500_000,
+        outputTokens: 200_000,
+        modelUsage: {
+          'claude-haiku-4-5-20251001': {
+            inputTokens: 500_000,
+            outputTokens: 200_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      const totals = tracker.getTotals();
+      expect(totals.usage.modelUsage['claude-opus-4-6']?.inputTokens).toBe(1_000_000);
+      expect(totals.usage.modelUsage['claude-haiku-4-5-20251001']?.inputTokens).toBe(500_000);
+    });
+
+    it('should return empty totals when no tasks added', () => {
+      const tracker = new TokenTracker(testPricing);
+      const totals = tracker.getTotals();
+      expect(totals.usage.inputTokens).toBe(0);
+      expect(totals.usage.outputTokens).toBe(0);
+      expect(totals.cost.totalCost).toBe(0);
+      expect(Object.keys(totals.usage.modelUsage)).toHaveLength(0);
+    });
+
+    it('should return per-task entries', () => {
+      const tracker = new TokenTracker(testPricing);
+      tracker.addTask('01', makeUsage({ inputTokens: 100 }));
+      tracker.addTask('02', makeUsage({ inputTokens: 200 }));
+
+      const entries = tracker.getEntries();
+      expect(entries).toHaveLength(2);
+      expect(entries[0].taskId).toBe('01');
+      expect(entries[1].taskId).toBe('02');
+    });
+
+    it('addTask returns the entry with cost', () => {
+      const tracker = new TokenTracker(testPricing);
+      const entry = tracker.addTask('01', makeUsage({
+        inputTokens: 1_000_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 0,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      }));
+
+      expect(entry.taskId).toBe('01');
+      expect(entry.cost.inputCost).toBeCloseTo(15);
+      expect(entry.cost.totalCost).toBeCloseTo(15);
+    });
+  });
+
+  describe('custom pricing', () => {
+    it('should use custom pricing config', () => {
+      const customPricing: PricingConfig = {
+        opus: { inputPerMTok: 10, outputPerMTok: 50, cacheReadPerMTok: 1, cacheCreatePerMTok: 12.5 },
+        sonnet: { inputPerMTok: 2, outputPerMTok: 10, cacheReadPerMTok: 0.2, cacheCreatePerMTok: 2.5 },
+        haiku: { inputPerMTok: 0.5, outputPerMTok: 2.5, cacheReadPerMTok: 0.05, cacheCreatePerMTok: 0.625 },
+      };
+
+      const tracker = new TokenTracker(customPricing);
+      const usage = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const cost = tracker.calculateCost(usage);
+      expect(cost.inputCost).toBeCloseTo(10); // 1M * $10/MTok
+      expect(cost.outputCost).toBeCloseTo(50); // 1M * $50/MTok
+      expect(cost.totalCost).toBeCloseTo(60);
+    });
+  });
+});

package/tests/unit/verbose-toggle.test.ts

@@ -0,0 +1,204 @@
+import { jest } from '@jest/globals';
+import { EventEmitter } from 'events';
+
+// Mock logger to capture output
+const mockDim = jest.fn();
+jest.unstable_mockModule('../../src/utils/logger.js', () => ({
+  logger: {
+    dim: mockDim,
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const { VerboseToggle } = await import('../../src/utils/verbose-toggle.js');
+
+describe('VerboseToggle', () => {
+  // Save original stdin properties
+  const originalIsTTY = process.stdin.isTTY;
+  const originalSetRawMode = process.stdin.setRawMode;
+  const originalResume = process.stdin.resume;
+  const originalPause = process.stdin.pause;
+
+  let mockSetRawMode: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockSetRawMode = jest.fn();
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, writable: true, configurable: true });
+    (process.stdin as any).setRawMode = mockSetRawMode;
+    (process.stdin as any).resume = jest.fn();
+    (process.stdin as any).pause = jest.fn();
+  });
+
+  afterEach(() => {
+    // Restore original stdin
+    Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, writable: true, configurable: true });
+    if (originalSetRawMode) {
+      (process.stdin as any).setRawMode = originalSetRawMode;
+    }
+    (process.stdin as any).resume = originalResume;
+    (process.stdin as any).pause = originalPause;
+  });
+
+  it('initializes with the provided verbose state', () => {
+    const toggle = new VerboseToggle(true);
+    expect(toggle.isVerbose).toBe(true);
+
+    const toggle2 = new VerboseToggle(false);
+    expect(toggle2.isVerbose).toBe(false);
+  });
+
+  it('is not active before start()', () => {
+    const toggle = new VerboseToggle(false);
+    expect(toggle.isActive).toBe(false);
+  });
+
+  it('becomes active after start() on a TTY', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    expect(toggle.isActive).toBe(true);
+    expect(mockSetRawMode).toHaveBeenCalledWith(true);
+    toggle.stop();
+  });
+
+  it('shows toggle hint on start', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    expect(mockDim).toHaveBeenCalledWith('  Press Tab to toggle verbose mode');
+    toggle.stop();
+  });
+
+  it('skips start when stdin is not a TTY', () => {
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, writable: true, configurable: true });
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    expect(toggle.isActive).toBe(false);
+    expect(mockSetRawMode).not.toHaveBeenCalled();
+  });
+
+  it('toggles verbose state on Tab keypress', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+
+    // Simulate Tab key (0x09)
+    process.stdin.emit('data', Buffer.from([0x09]));
+    expect(toggle.isVerbose).toBe(true);
+    expect(mockDim).toHaveBeenCalledWith('  [verbose: on]');
+
+    // Toggle back
+    process.stdin.emit('data', Buffer.from([0x09]));
+    expect(toggle.isVerbose).toBe(false);
+    expect(mockDim).toHaveBeenCalledWith('  [verbose: off]');
+
+    toggle.stop();
+  });
+
+  it('emits SIGINT on Ctrl+C keypress', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+
+    const sigintHandler = jest.fn();
+    process.once('SIGINT', sigintHandler);
+
+    // Simulate Ctrl+C (0x03)
+    process.stdin.emit('data', Buffer.from([0x03]));
+    expect(sigintHandler).toHaveBeenCalled();
+
+    toggle.stop();
+  });
+
+  it('ignores non-Tab, non-Ctrl+C keypresses', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+
+    // Simulate 'a' keypress
+    process.stdin.emit('data', Buffer.from([0x61]));
+    expect(toggle.isVerbose).toBe(false);
+
+    toggle.stop();
+  });
+
+  it('handles multiple bytes in a single data event', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+
+    // Two Tab keys in one buffer
+    process.stdin.emit('data', Buffer.from([0x09, 0x09]));
+    // Should toggle twice → back to false
+    expect(toggle.isVerbose).toBe(false);
+
+    toggle.stop();
+  });
+
+  it('restores stdin on stop()', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    toggle.stop();
+
+    expect(toggle.isActive).toBe(false);
+    expect(mockSetRawMode).toHaveBeenCalledWith(false);
+    expect(process.stdin.pause).toHaveBeenCalled();
+  });
+
+  it('is safe to call stop() multiple times', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    toggle.stop();
+    toggle.stop(); // should not throw
+    expect(toggle.isActive).toBe(false);
+  });
+
+  it('is safe to call start() multiple times', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    toggle.start(); // should not start again
+    expect(mockSetRawMode).toHaveBeenCalledTimes(1);
+    toggle.stop();
+  });
+
+  it('does not respond to keypress after stop()', () => {
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    toggle.stop();
+
+    // Clear mocks to check no new calls
+    mockDim.mockClear();
+
+    // This should not trigger any toggle
+    process.stdin.emit('data', Buffer.from([0x09]));
+    expect(toggle.isVerbose).toBe(false);
+    // Only the hint message was logged (already cleared by mockClear), no toggle messages
+    expect(mockDim).not.toHaveBeenCalled();
+  });
+
+  it('works correctly across multiple tasks (stop and restart)', () => {
+    const toggle = new VerboseToggle(false);
+
+    // First task
+    toggle.start();
+    process.stdin.emit('data', Buffer.from([0x09]));
+    expect(toggle.isVerbose).toBe(true);
+    toggle.stop();
+
+    // State persists after stop
+    expect(toggle.isVerbose).toBe(true);
+
+    // Restart for second task
+    toggle.start();
+    expect(toggle.isVerbose).toBe(true); // Still true from previous toggle
+    process.stdin.emit('data', Buffer.from([0x09]));
+    expect(toggle.isVerbose).toBe(false);
+    toggle.stop();
+  });
+
+  it('handles setRawMode throwing an error', () => {
+    mockSetRawMode.mockImplementation(() => { throw new Error('Cannot set raw mode'); });
+    const toggle = new VerboseToggle(false);
+    toggle.start();
+    // Should gracefully skip activation
+    expect(toggle.isActive).toBe(false);
+  });
+});

package/RAF/ahrtxf-session-sentinel/decisions.md

@@ -1,19 +0,0 @@
-# Project Decisions
-
-## What's the main use case for logging the session ID?
-Resume interrupted sessions. Capture session ID so RAF can attempt to resume interrupted Claude sessions using `claude --resume <id>`, and also allow manual inspection. Add `raf do <project> --resume <session-id>` flag for resuming after Ctrl+C interruption.
-
-## Should the session ID be captured in all execution modes?
-Verbose + non-interactive. Both modes that run tasks should capture session ID. Interactive planning mode can be skipped.
-
-## When a session is interrupted, should the session ID be displayed to the user?
-Print to terminal. Display session ID in terminal output on interruption so user can copy it for `--resume`.
-
-## For `raf do --resume`, should it resume the exact interrupted task or restart from scratch?
-Resume exact task. Pass `--resume` to Claude CLI for the specific interrupted task, continuing from where Claude left off mid-task. Add metadata (task ID) to support this. Format could be `--resume <task-id>:<session-id>` or assume it's the last unfinished task.
-
-## How should non-interactive mode get access to the session ID?
-Always use `--output-format stream-json` for both verbose and non-interactive modes. Parse the init event to capture session_id. Only render/display the stream output when `--verbose` flag is passed. This gives us session IDs universally without changing user-visible behavior.
-
-## When resuming, should RAF pass the original task's system prompt again?
-Rely on session state. Trust that Claude's `--resume` restores the full context including the original prompt. Don't re-send system prompt or task context.

package/RAF/ahrtxf-session-sentinel/input.md

@@ -1 +0,0 @@
-check if it's possible to log claude session id if session got interrupted

package/RAF/ahrtxf-session-sentinel/outcomes/01-capture-session-id.md

@@ -1,37 +0,0 @@
-# Outcome: Capture Session ID from Claude CLI Output
-
-## Summary
-
-Implemented session ID extraction from Claude CLI's `system.init` NDJSON event in both `run()` and `runVerbose()` methods. The session ID is now captured, returned in `RunResult`, and printed to the terminal on interruption.
-
-## Key Changes
-
-### `src/parsers/stream-renderer.ts`
-- Added `session_id` field to `StreamEvent` interface
-- Added `sessionId` field to `RenderResult` interface
-- Modified `renderStreamEvent()` to extract and return `session_id` from system init events
-
-### `src/core/claude-runner.ts`
-- Added `sessionId?: string` field to `RunResult` interface
-- Added `_sessionId` private field and public `sessionId` getter to `ClaudeRunner` class
-- Refactored `run()` to use `--output-format stream-json --verbose` with silent NDJSON parsing (no stdout display), enabling session ID extraction
-- Updated `runVerbose()` to capture `sessionId` from stream events
-- Both methods return `sessionId` in `RunResult`
-- Session ID is printed via `logger.info()` on timeout and context overflow in both methods
-
-### `src/core/shutdown-handler.ts`
-- Added session ID logging in `handleShutdown()` — prints `Session ID: <id>` when a Claude session is interrupted via Ctrl+C/SIGTERM
-
-### `tests/unit/stream-renderer.test.ts`
-- Added 3 new tests: session_id extraction, undefined for missing session_id, undefined for non-system events
-
-### `tests/unit/claude-runner.test.ts`
-- Updated existing `run()` tests to emit NDJSON events (since `run()` now uses stream-json format)
-- Updated flag assertion: `run()` now includes `--output-format stream-json --verbose`
-- Added 5 new tests: sessionId extraction in run(), runVerbose(), undefined when missing, getter exposure, deduplication
-
-## Test Results
-
-All 986 tests pass (45 test suites). No regressions introduced.
-
-<promise>COMPLETE</promise>

package/RAF/ahrtxf-session-sentinel/outcomes/02-resume-flag.md

@@ -1,45 +0,0 @@
-# Outcome: Add --resume Flag to raf do Command
-
-## Summary
-
-Added `--resume <session-id>` option to `raf do` that resumes an interrupted Claude session for a specific task. When used, Claude is spawned with `--resume` flag only (no prompt/model/system-prompt flags), and completion monitoring works identically to normal execution.
-
-## Key Changes
-
-### `src/types/config.ts`
-- Added `resume?: string` field to `DoCommandOptions` interface
-
-### `src/commands/do.ts`
-- Added `-r, --resume <session-id>` option to the `do` command definition
-- Added `resumeSessionId` to `SingleProjectOptions` interface
-- In the task execution loop: when `activeResumeSessionId` is set, calls `runResume()` instead of `run()`/`runVerbose()` for the first attempt
-- Clears `activeResumeSessionId` after the first task completes, so subsequent tasks use normal execution
-- Prints clear user-facing message: `Resuming task <id> with session <session-id>` in both verbose and minimal modes
-
-### `src/core/claude-runner.ts`
-- Added `runResume(sessionId, options)` method that spawns Claude with:
-  - `--resume <session-id>` — restores the interrupted session
-  - `--dangerously-skip-permissions` — required for non-interactive operation
-  - `--output-format stream-json --verbose` — enables NDJSON event parsing
-  - Does NOT pass `--model`, `--append-system-prompt`, or `-p` (Claude restores these from session state)
-- Same completion detection, timeout handling, context overflow detection, and session ID extraction as existing methods
-
-### `tests/unit/claude-runner.test.ts`
-- Added 11 new tests in `runResume()` describe block:
-  - Spawns with `--resume` flag and session ID
-  - Does NOT include `--model`, `--append-system-prompt`, or `-p` flags
-  - Includes `--dangerously-skip-permissions` flag
-  - Includes `--output-format stream-json` and `--verbose` flags
-  - Collects output from NDJSON events
-  - Handles timeout correctly
-  - Detects completion markers
-  - Extracts session ID from resumed session
-  - Passes cwd to spawn (worktree support)
-  - Detects context overflow
-  - Sets CLAUDE_CODE_EFFORT_LEVEL env var when provided
-
-## Test Results
-
-All 997 tests pass (45 test suites). No regressions introduced.
-
-<promise>COMPLETE</promise>