rafcode 2.1.0 → 2.1.1

package/tests/unit/stream-renderer.test.ts

@@ -14,36 +14,6 @@ describe('renderStreamEvent', () => {
       expect(result.display).toBe('');
       expect(result.textContent).toBe('');
     });
-
-    it('should extract session_id from system init events', () => {
-      const line = JSON.stringify({
-        type: 'system',
-        subtype: 'init',
-        session_id: 'abc123-session-id',
-        tools: ['Read', 'Write', 'Bash'],
-        model: 'claude-opus-4-6',
-      });
-      const result = renderStreamEvent(line);
-      expect(result.sessionId).toBe('abc123-session-id');
-    });
-
-    it('should return undefined sessionId for system events without session_id', () => {
-      const line = JSON.stringify({
-        type: 'system',
-        subtype: 'other',
-      });
-      const result = renderStreamEvent(line);
-      expect(result.sessionId).toBeUndefined();
-    });
-
-    it('should not return sessionId for non-system events', () => {
-      const line = JSON.stringify({
-        type: 'assistant',
-        message: { content: [{ type: 'text', text: 'hello' }] },
-      });
-      const result = renderStreamEvent(line);
-      expect(result.sessionId).toBeUndefined();
-    });
   });
 
   describe('assistant events with text', () => {

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>

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

@@ -1,41 +0,0 @@
-# Task: Capture Session ID from Claude CLI Output
-
-## Objective
-Extract and store the Claude session ID from stream-json output in both verbose and non-interactive execution modes.
-
-## Context
-Claude CLI emits a `session_id` in its `system.init` NDJSON event when using `--output-format stream-json`. RAF currently discards this event entirely. We need to capture and surface this ID so it can be used for session resumption and debugging.
-
-## Requirements
-- Unify both `run()` (non-interactive) and `runVerbose()` methods to use `--output-format stream-json` so that the system init event is always available
-- In non-verbose mode, parse NDJSON events silently (extract textContent for output accumulation and detect completion markers) without rendering anything to stdout
-- In verbose mode, continue rendering stream events to stdout as before
-- Extract `session_id` from the `system.init` event (first event in the stream)
-- Add `sessionId?: string` field to the `RunResult` type returned by both `run()` and `runVerbose()`
-- Modify `renderStreamEvent()` in `stream-renderer.ts` to return the session_id when it encounters a system init event, rather than discarding it
-- When a session is interrupted (Ctrl+C, timeout, context overflow), print the session ID to terminal: `Session ID: <id>` so the user can copy it
-- Add tests for the session ID extraction from system init events
-- Add tests verifying session ID is included in RunResult
-
-## Implementation Steps
-1. Update the `RunResult` type to include an optional `sessionId` field
-2. Modify `renderStreamEvent()` to extract and return `session_id` from system init events (add a new field to the return type, e.g. `sessionId?: string`)
-3. Refactor `run()` to use `--output-format stream-json` internally, parsing NDJSON lines the same way `runVerbose()` does, but without writing display output to stdout
-4. In both `run()` and `runVerbose()`, capture the session_id from the first system init event and include it in the returned `RunResult`
-5. In the shutdown handler and timeout/overflow paths, print the captured session ID to the terminal before exiting
-6. Write unit tests for session ID extraction from stream events
-7. Write integration-style tests verifying RunResult includes sessionId
-
-## Acceptance Criteria
-- [ ] `run()` uses stream-json format internally and parses events silently
-- [ ] `runVerbose()` continues to display stream events as before
-- [ ] Both methods return `sessionId` in `RunResult` when available
-- [ ] On interruption (Ctrl+C, timeout, overflow), session ID is printed to terminal
-- [ ] Existing tests continue to pass
-- [ ] New tests cover session ID extraction
-
-## Notes
-- The system init event format is: `{ type: 'system', subtype: 'init', session_id: string, tools: string[], model: string }`
-- Currently `stream-renderer.ts` line 96 returns `{ display: '', textContent: '' }` for all system events — this is where extraction should happen
-- The `run()` method currently uses plain text output with `child_process.spawn` — it needs to switch to stream-json parsing similar to `runVerbose()`. Consider extracting shared NDJSON parsing logic to avoid duplication.
-- Be careful: `run()` has its own completion marker detection and timeout logic that must continue to work with the new stream-json parsing

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

@@ -1,51 +0,0 @@
-# Task: Add --resume Flag to raf do Command
-
-## Objective
-Add a `--resume` option to `raf do` that resumes an interrupted Claude session for a specific task.
-
-## Context
-After task 01 captures the session ID and displays it on interruption, users need a way to actually resume the interrupted session. This task adds `raf do <project> --resume <session-id>` which passes Claude CLI's `--resume` flag to continue a session from where it left off.
-
-## Dependencies
-01
-
-## Requirements
-- Add `--resume <session-id>` option to the `raf do` command in Commander.js
-- When `--resume` is provided, RAF should:
-  1. Identify the task to resume — find the first task that is in-progress (has no outcome file, or has a partial/missing completion marker)
-  2. Skip the normal task execution flow and instead spawn Claude with `--resume <session-id>` flag
-  3. Do NOT pass `-p` (prompt), `--append-system-prompt`, or `--model` flags — rely on Claude's session state to restore these
-  4. DO pass `--dangerously-skip-permissions` as it's required for non-interactive operation
-  5. Still use `--output-format stream-json` so we can capture the new session's events and detect completion
-  6. Continue monitoring for completion markers and outcome file as usual
-- After the resumed session completes, normal post-task flow should apply (outcome validation, commit verification, next task, etc.)
-- If `--resume` is used with `--worktree`, ensure the CWD is set to the worktree path
-- Print a clear message indicating which task is being resumed: `Resuming task <id> with session <session-id>`
-- Add a new method to `ClaudeRunner` (e.g. `runResume(sessionId, options)`) that spawns Claude with the `--resume` flag
-- Cover the new flag and resume method with tests
-
-## Implementation Steps
-1. Add `--resume <session-id>` option to the `do` command definition in `src/commands/do.ts`
-2. Add a `runResume()` method to `ClaudeRunner` that spawns Claude with `--resume <session-id> --dangerously-skip-permissions --output-format stream-json` and the same completion monitoring as existing methods
-3. In the task execution loop, when `--resume` is provided:
-   - Determine the current task (first task without a valid outcome)
-   - Call `runResume()` instead of the normal `run()`/`runVerbose()` method
-   - After the resumed task completes, clear the `--resume` flag so subsequent tasks use normal execution
-4. Handle edge cases: invalid session ID format, all tasks already complete, resumed session fails
-5. Write tests for the new `runResume()` method
-6. Write tests for the `--resume` flag integration in the do command
-
-## Acceptance Criteria
-- [ ] `raf do <project> --resume <session-id>` resumes the interrupted session
-- [ ] Claude is spawned with `--resume` flag and without prompt/model/system-prompt flags
-- [ ] Completion monitoring works the same as normal execution
-- [ ] After resumed task completes, subsequent tasks run normally
-- [ ] Works with `--worktree` mode
-- [ ] Clear user-facing message on resume start
-- [ ] Tests cover resume path
-
-## Notes
-- Claude CLI's `--resume` flag restores the full session context including the system prompt, so we must NOT pass those flags again (they may conflict or be rejected)
-- The `--resume` flag only applies to a single task — after it completes (or fails), remaining tasks use normal execution
-- Consider what happens if the user provides a session ID for a task that already completed — should gracefully handle this
-- Check Claude CLI docs/help to verify exact `--resume` flag syntax: `claude --resume <session-id>`