@arvorco/relentless 0.6.1 → 0.8.0

package/.claude/skills/validators/scripts/validate.sh

@@ -0,0 +1,295 @@
+#!/usr/bin/env bash
+# validate.sh - Main validation orchestrator
+# Usage:
+#   validate.sh <feature-path>           # Validate all docs in feature directory
+#   validate.sh <file.md>                # Validate single file (auto-detect type)
+#   validate.sh --type=spec <file.md>    # Validate file as specific type
+#   validate.sh --help                   # Show help
+#
+# Exit codes:
+#   0 - All validations passed
+#   1 - Validation errors found
+#   2 - Usage error
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+show_help() {
+  cat <<EOF
+Relentless Document Validator
+
+USAGE:
+    validate.sh <feature-path>           Validate all docs in feature directory
+    validate.sh <file.md>                Validate single file (auto-detect type)
+    validate.sh --type=<type> <file.md>  Validate file as specific type
+    validate.sh --help                   Show this help
+
+TYPES:
+    spec          Feature specification (spec.md)
+    plan          Technical plan (plan.md)
+    tasks         Implementation tasks (tasks.md)
+    checklist     Quality checklist (checklist.md)
+    constitution  Project constitution (constitution.md)
+    prompt        Agent instructions (prompt.md)
+
+EXAMPLES:
+    # Validate all documents in a feature
+    validate.sh relentless/features/001-queued-prompts
+
+    # Validate a single spec file
+    validate.sh relentless/features/001-queued-prompts/spec.md
+
+    # Force validation as specific type
+    validate.sh --type=spec my-document.md
+
+EXIT CODES:
+    0  All validations passed
+    1  Validation errors found
+    2  Usage error
+EOF
+}
+
+# Detect document type from filename
+detect_type() {
+  local file="$1"
+  local basename
+  basename=$(basename "$file")
+
+  case "$basename" in
+    spec.md|*-spec.md|specification.md)
+      echo "spec"
+      ;;
+    plan.md|*-plan.md|technical-plan.md)
+      echo "plan"
+      ;;
+    tasks.md|*-tasks.md|implementation-tasks.md)
+      echo "tasks"
+      ;;
+    checklist.md|*-checklist.md)
+      echo "checklist"
+      ;;
+    constitution.md|*-constitution.md)
+      echo "constitution"
+      ;;
+    prompt.md|*-prompt.md|agent-prompt.md)
+      echo "prompt"
+      ;;
+    *)
+      # Try to detect from content
+      if grep -qE "^# Feature Specification:" "$file" 2>/dev/null; then
+        echo "spec"
+      elif grep -qE "^# (Technical )?Plan:" "$file" 2>/dev/null; then
+        echo "plan"
+      elif grep -qE "^# Implementation Tasks:" "$file" 2>/dev/null; then
+        echo "tasks"
+      elif grep -qE "^# .*Checklist:" "$file" 2>/dev/null; then
+        echo "checklist"
+      elif grep -qE "^# .*Constitution" "$file" 2>/dev/null; then
+        echo "constitution"
+      elif grep -qE "^# .*Agent.*Instructions|^# Relentless" "$file" 2>/dev/null; then
+        echo "prompt"
+      else
+        echo "unknown"
+      fi
+      ;;
+  esac
+}
+
+# Run validator for specific type
+run_validator() {
+  local type="$1"
+  local file="$2"
+
+  case "$type" in
+    spec)
+      "$SCRIPT_DIR/validate-spec.sh" "$file"
+      ;;
+    plan)
+      "$SCRIPT_DIR/validate-plan.sh" "$file"
+      ;;
+    tasks)
+      "$SCRIPT_DIR/validate-tasks.sh" "$file"
+      ;;
+    checklist)
+      "$SCRIPT_DIR/validate-checklist.sh" "$file"
+      ;;
+    constitution)
+      "$SCRIPT_DIR/validate-constitution.sh" "$file"
+      ;;
+    prompt)
+      "$SCRIPT_DIR/validate-prompt.sh" "$file"
+      ;;
+    *)
+      echo -e "${RED}Unknown document type: $type${NC}"
+      return 2
+      ;;
+  esac
+}
+
+# Validate all documents in a feature directory
+validate_feature() {
+  local feature_path="$1"
+  local exit_code=0
+
+  echo -e "${BOLD}${BLUE}╔═══════════════════════════════════════════╗${NC}"
+  echo -e "${BOLD}${BLUE}║   Relentless Document Validator           ║${NC}"
+  echo -e "${BOLD}${BLUE}╚═══════════════════════════════════════════╝${NC}"
+  echo ""
+  echo -e "Feature: ${BOLD}$feature_path${NC}"
+  echo ""
+
+  # Find and validate each document type
+  local docs_validated=0
+
+  # spec.md
+  if [[ -f "$feature_path/spec.md" ]]; then
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    if ! run_validator "spec" "$feature_path/spec.md"; then
+      exit_code=1
+    fi
+    ((docs_validated++))
+  fi
+
+  # plan.md
+  if [[ -f "$feature_path/plan.md" ]]; then
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    if ! run_validator "plan" "$feature_path/plan.md"; then
+      exit_code=1
+    fi
+    ((docs_validated++))
+  fi
+
+  # tasks.md
+  if [[ -f "$feature_path/tasks.md" ]]; then
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    if ! run_validator "tasks" "$feature_path/tasks.md"; then
+      exit_code=1
+    fi
+    ((docs_validated++))
+  fi
+
+  # checklist.md
+  if [[ -f "$feature_path/checklist.md" ]]; then
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    if ! run_validator "checklist" "$feature_path/checklist.md"; then
+      exit_code=1
+    fi
+    ((docs_validated++))
+  fi
+
+  # Project-level constitution (check parent directories)
+  local constitution_path=""
+  if [[ -f "$feature_path/../../constitution.md" ]]; then
+    constitution_path="$feature_path/../../constitution.md"
+  elif [[ -f "$feature_path/../../../relentless/constitution.md" ]]; then
+    constitution_path="$feature_path/../../../relentless/constitution.md"
+  fi
+
+  if [[ -n "$constitution_path" && -f "$constitution_path" ]]; then
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    if ! run_validator "constitution" "$constitution_path"; then
+      exit_code=1
+    fi
+    ((docs_validated++))
+  fi
+
+  # Project-level prompt.md (check parent directories)
+  local prompt_path=""
+  if [[ -f "$feature_path/../../prompt.md" ]]; then
+    prompt_path="$feature_path/../../prompt.md"
+  elif [[ -f "$feature_path/../../../relentless/prompt.md" ]]; then
+    prompt_path="$feature_path/../../../relentless/prompt.md"
+  fi
+
+  if [[ -n "$prompt_path" && -f "$prompt_path" ]]; then
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    if ! run_validator "prompt" "$prompt_path"; then
+      exit_code=1
+    fi
+    ((docs_validated++))
+  fi
+
+  # Summary
+  echo ""
+  echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+  echo -e "${BOLD}Overall Summary${NC}"
+  echo -e "Documents validated: $docs_validated"
+
+  if [[ "$exit_code" -eq 0 ]]; then
+    echo -e "${GREEN}${BOLD}✓ All documents passed validation${NC}"
+  else
+    echo -e "${RED}${BOLD}✗ Some documents have validation errors${NC}"
+  fi
+
+  return $exit_code
+}
+
+# Main
+main() {
+  local type=""
+  local target=""
+
+  # Parse arguments
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --help|-h)
+        show_help
+        exit 0
+        ;;
+      --type=*)
+        type="${1#--type=}"
+        shift
+        ;;
+      *)
+        target="$1"
+        shift
+        ;;
+    esac
+  done
+
+  if [[ -z "$target" ]]; then
+    echo -e "${RED}Error: No target specified${NC}"
+    echo ""
+    show_help
+    exit 2
+  fi
+
+  # Check if target exists
+  if [[ ! -e "$target" ]]; then
+    echo -e "${RED}Error: Target not found: $target${NC}"
+    exit 2
+  fi
+
+  # Directory or file?
+  if [[ -d "$target" ]]; then
+    validate_feature "$target"
+  elif [[ -f "$target" ]]; then
+    # Validate single file
+    if [[ -z "$type" ]]; then
+      type=$(detect_type "$target")
+    fi
+
+    if [[ "$type" == "unknown" ]]; then
+      echo -e "${RED}Error: Could not detect document type for: $target${NC}"
+      echo "Use --type=<type> to specify the document type"
+      exit 2
+    fi
+
+    echo -e "${BOLD}${BLUE}Validating $target as $type${NC}"
+    run_validator "$type" "$target"
+  else
+    echo -e "${RED}Error: Target is neither a file nor directory: $target${NC}"
+    exit 2
+  fi
+}
+
+main "$@"

package/CHANGELOG.md

@@ -7,6 +7,114 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0](https://github.com/ArvorCo/Relentless/releases/tag/v0.8.0) - 2026-01-24
+
+### Major Features
+
+#### Document Validators - Ensure Artifact Quality
+- **New validators module**: `.claude/skills/validators/` with comprehensive validation scripts
+- **6 document validators**:
+  - `validate-spec.sh` - Feature specification validation
+  - `validate-plan.sh` - Technical plan validation
+  - `validate-tasks.sh` - Implementation tasks validation (PRD-convertible format)
+  - `validate-checklist.sh` - Quality checklist validation
+  - `validate-constitution.sh` - Project constitution validation
+  - `validate-prompt.sh` - Agent instructions validation
+- **Main orchestrator**: `validate.sh` validates all docs in a feature directory
+- **Shared utilities**: `common.sh` with color output, pattern counting, placeholder detection
+- **Auto-detect document type**: From filename or content analysis
+
+#### Learning System (`/relentless.learn`) - Feedback Loop
+- **New skill**: Distill learnings from completed features and propose amendments
+- **Script-based extraction**: CLI tools (jq, grep, awk) extract data without context bloat
+- **Dual-target amendments**: Constitutional (MUST/SHOULD) vs Tactical (prompt.md)
+- **Human approval workflow**: Proposals require explicit approval before applying
+- **Stats aggregation**: `relentless/stats.md` tracks costs, tokens, and patterns across features
+- **Runner integration**: Recommends `/relentless.learn` after feature completion
+
+### Added
+- `.claude/skills/validators/` - Complete validation framework
+- `.claude/skills/validators/scripts/common.sh` - Shared utilities
+- `.claude/skills/validators/scripts/validate-*.sh` - Individual validators
+- `.claude/skills/validators/SKILL.md` - Validator documentation
+- `.claude/skills/learn/` - Learning skill implementation
+- `.claude/skills/learn/scripts/` - Extraction scripts
+- `.claude/commands/relentless.learn.md` - Command wrapper
+
+### Changed
+- **All skills now include validation steps**: specify, plan, tasks, checklist, constitution
+  - Each skill runs the appropriate validator after generating its artifact
+  - Validation failures must be fixed before proceeding
+- **Constitution skill**: Now validates both `constitution.md` and `prompt.md`
+- **Removed XML comment tags**: Cleaned up `<!-- TEMPLATE_VERSION: -->` from constitution templates
+- **Validators are flexible**: Support both old and new document formats
+
+### Fixed
+- **Bash arithmetic with `set -e`**: Fixed `((PASSED++))` causing exit code 1 when PASSED=0
+- **Pattern counting**: Fixed `count_pattern` returning "0\n0" due to grep exit codes
+- **Warning handling**: `check_section_warn` now returns 0 (warnings don't fail validation)
+- **grep option parsing**: Added `--` to prevent patterns like `- [ ]` being parsed as options
+- **Octal interpretation**: Fixed bash interpreting 008/009 as invalid octal (use `10#$num`)
+
+## [0.7.0](https://github.com/ArvorCo/Relentless/releases/tag/v0.7.0) - 2026-01-24
+
+### Major Features
+
+#### Enhanced TUI with mIRC-Inspired 3-Column Layout
+- **Responsive layout system**: Automatic switching between layouts based on terminal width
+  - Full 3-column (≥120 cols): Tasks | Output | Queue
+  - Compressed 3-column (≥100 cols): Narrower panels
+  - Vertical layout (<100 cols): Stacked panels for narrow terminals
+- **New layout components**: `ThreeColumnLayout`, `VerticalLayout`, `LayoutSwitcher`
+- **Task Panel (Left)**: Scrollable task list with status indicators and pulse animation for active tasks
+- **Output Panel (Center)**: Enhanced output display with context header and code block detection
+- **Message Queue Panel (Right)**: mIRC-style message display with timestamps
+
+#### Real-Time Metrics Display
+- **Cost Badge**: Real-time cost tracking display
+- **Token Counter**: Input/output token usage visualization
+- **Rate Limit Indicator**: Countdown timer when rate limited
+- **Status Bar**: Comprehensive bottom bar with all metrics
+
+#### Skip Iteration with Process Kill
+- **Idle warning**: Shows warning after 5 minutes of agent inactivity
+- **Press 's' to skip**: Kills the running agent process and moves to next iteration
+- **AbortController integration**: Clean process termination via SIGTERM (with SIGKILL fallback)
+- **AbortSignal support**: Added to all 6 agent adapters (Claude, Amp, OpenCode, Codex, Droid, Gemini)
+
+### Added
+- `src/tui/layouts/` - New layout system with responsive switching
+- `src/tui/components/TaskItem.tsx` - Individual task display with animations
+- `src/tui/components/TaskPanel.tsx` - Left panel with scrollable task list
+- `src/tui/components/OutputPanel.tsx` - Enhanced center output panel
+- `src/tui/components/MessageItem.tsx` - mIRC-style message component
+- `src/tui/components/MessageQueuePanel.tsx` - Right panel queue display
+- `src/tui/components/CostBadge.tsx` - Real-time cost display
+- `src/tui/components/TokenCounter.tsx` - Token usage display
+- `src/tui/components/RateLimitIndicator.tsx` - Rate limit countdown
+- `src/tui/components/StatusBar.tsx` - Bottom metrics bar
+- `src/tui/hooks/useResponsiveLayout.ts` - Terminal size detection with breakpoints
+- `src/tui/hooks/useAnimation.ts` - Pulse, typing, blinking effects
+- `src/tui/hooks/useCostTracking.ts` - Cost and token aggregation
+- `signal` option in `InvokeOptions` for agent cancellation
+- `aborted` flag in `RunCommandResult` to detect cancelled commands
+
+### Changed
+- **Default timeout**: Increased from 10 minutes to 30 minutes (1800000ms)
+- **Idle timeout behavior**: No longer kills process automatically, just shows warning
+- **Theme extended**: Added panel colors, animation constants, badges to `theme.ts`
+- **Types extended**: Added `TokenUsage`, `CostData`, `MessageItem`, `LayoutMode`, `OutputMode` interfaces
+
+### Fixed
+- **Idle timeout no longer detected as rate limit**: Removed idle timeout from rate limit detection in all 6 agents
+- **Process cleanup**: Skip functionality now properly kills the agent process instead of leaving it running
+- **YAML parsing error for routing_preference** (#9): Fixed template quoting to prevent YAML parser errors when routing_preference contains colons (thanks @namick!)
+
+## [0.6.1](https://github.com/ArvorCo/Relentless/releases/tag/v0.6.1) - 2026-01-23
+
+### Fixed
+- **Rate Limit Detection**: Added debug logging to help diagnose false positive rate limit detection
+
 ## [0.6.0](https://github.com/ArvorCo/Relentless/releases/tag/v0.6.0) - 2026-01-23
 
 ### Major Features
@@ -510,7 +618,10 @@ Relentless evolved from the [Ralph Wiggum Pattern](https://ghuntley.com/ralph/)
 - **License**: MIT
 - **Inspiration**: [Ralph Wiggum Pattern](https://ghuntley.com/ralph/) by Geoffrey Huntley
 
-[Unreleased]: https://github.com/ArvorCo/Relentless/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/ArvorCo/Relentless/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/ArvorCo/Relentless/compare/v0.7.0...v0.8.0
+[0.7.0]: https://github.com/ArvorCo/Relentless/compare/v0.6.1...v0.7.0
+[0.6.1]: https://github.com/ArvorCo/Relentless/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/ArvorCo/Relentless/compare/v0.5.3...v0.6.0
 [0.5.3]: https://github.com/ArvorCo/Relentless/compare/v0.5.2...v0.5.3
 [0.5.2]: https://github.com/ArvorCo/Relentless/compare/v0.5.1...v0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvorco/relentless",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Universal AI agent orchestrator - works with Claude Code, Amp, OpenCode, Codex, Droid, and Gemini",
   "type": "module",
   "publishConfig": {

package/relentless/constitution.md

@@ -1,6 +1,3 @@
-<!-- TEMPLATE_VERSION: 2.1.0 -->
-<!-- LAST_UPDATED: 2026-01-20 -->
-
 # Relentless Project Constitution
 
 **Version:** 2.1.0

package/src/agents/amp.ts

@@ -80,6 +80,7 @@ export const ampAdapter: AgentAdapter = {
       cwd: options?.workingDirectory,
       stdin: new Blob([prompt]),
       timeoutMs: options?.timeout,
+      signal: options?.signal,
     });
 
     const timeoutNote =
@@ -102,12 +103,8 @@ export const ampAdapter: AgentAdapter = {
   },
 
   detectRateLimit(output: string): RateLimitInfo {
-    if (output.includes("[Relentless] Idle timeout")) {
-      return {
-        limited: true,
-        message: "Amp idle timeout",
-      };
-    }
+    // NOTE: Idle timeout is NOT a rate limit - it just means the agent stopped
+    // producing output for a while, which is normal behavior for complex tasks.
 
     // Amp rate limit patterns
     const patterns = [

package/src/agents/claude.ts

@@ -90,6 +90,7 @@ export const claudeAdapter: AgentAdapter = {
       stdin: new Blob([prompt]),
       timeoutMs: options?.timeout,
       env: Object.keys(env).length > 0 ? env : undefined,
+      signal: options?.signal,
     });
 
     const timeoutNote =
@@ -195,13 +196,9 @@ export const claudeAdapter: AgentAdapter = {
       }
     };
 
-    if (output.includes("[Relentless] Idle timeout")) {
-      debugRateLimit("idle_timeout", "Claude idle timeout");
-      return {
-        limited: true,
-        message: "Claude idle timeout",
-      };
-    }
+    // NOTE: Idle timeout is NOT a rate limit - it just means the agent stopped
+    // producing output for a while, which is normal behavior for complex tasks.
+    // We should NOT switch agents on idle timeout.
 
     if (/(?:operation not permitted|permission denied|\beperm\b).*(?:\/\.claude|\.claude)/i.test(output)) {
       debugRateLimit("permission_error", "Claude unavailable due to permission error");

package/src/agents/codex.ts

@@ -87,6 +87,7 @@ export const codexAdapter: AgentAdapter = {
       cwd: options?.workingDirectory,
       stdin: new Blob([prompt]),
       timeoutMs: options?.timeout,
+      signal: options?.signal,
     });
 
     const timeoutNote =
@@ -109,12 +110,8 @@ export const codexAdapter: AgentAdapter = {
   },
 
   detectRateLimit(output: string): RateLimitInfo {
-    if (output.includes("[Relentless] Idle timeout")) {
-      return {
-        limited: true,
-        message: "Codex idle timeout",
-      };
-    }
+    // NOTE: Idle timeout is NOT a rate limit - it just means the agent stopped
+    // producing output for a while, which is normal behavior for complex tasks.
 
     if (
       /cannot access session files/i.test(output) ||

package/src/agents/droid.ts

@@ -87,6 +87,7 @@ export const droidAdapter: AgentAdapter = {
       cwd: options?.workingDirectory,
       stdin: new Blob([prompt]),
       timeoutMs: options?.timeout,
+      signal: options?.signal,
     });
 
     const timeoutNote =
@@ -109,12 +110,8 @@ export const droidAdapter: AgentAdapter = {
   },
 
   detectRateLimit(output: string): RateLimitInfo {
-    if (output.includes("[Relentless] Idle timeout")) {
-      return {
-        limited: true,
-        message: "Droid idle timeout",
-      };
-    }
+    // NOTE: Idle timeout is NOT a rate limit - it just means the agent stopped
+    // producing output for a while, which is normal behavior for complex tasks.
 
     if (/mcp start failed/i.test(output) || /error reloading mcp servers/i.test(output)) {
       return {

package/src/agents/exec.ts

@@ -8,6 +8,8 @@ export interface RunCommandOptions {
   timeoutMs?: number;
   /** Environment variables to pass to the command */
   env?: Record<string, string>;
+  /** AbortSignal for cancelling the command */
+  signal?: AbortSignal;
 }
 
 export interface RunCommandResult {
@@ -16,6 +18,8 @@ export interface RunCommandResult {
   exitCode: number;
   duration: number;
   timedOut: boolean;
+  /** Whether the command was aborted via signal */
+  aborted: boolean;
 }
 
 async function readStream(
@@ -66,34 +70,75 @@ export async function runCommand(
 
   let lastOutput = Date.now();
   let timedOut = false;
+  let aborted = false;
   let idleTimer: ReturnType<typeof setInterval> | undefined;
 
   const onChunk = () => {
     lastOutput = Date.now();
   };
 
+  // Handle abort signal - kill the process when skip is requested
+  const abortHandler = () => {
+    aborted = true;
+    proc.kill("SIGTERM");
+    // Give it a moment, then force kill if still running
+    setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+        // Process already exited, ignore
+      }
+    }, 1000);
+  };
+
+  if (options.signal) {
+    if (options.signal.aborted) {
+      // Already aborted before we started
+      proc.kill("SIGTERM");
+      aborted = true;
+    } else {
+      options.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+  }
+
+  // NOTE: We no longer kill the process on idle timeout.
+  // Idle timeout is just informational - the TUI will show a warning
+  // and let the user decide to skip if needed.
+  // The process continues running until it completes naturally.
   if (options.timeoutMs && options.timeoutMs > 0) {
     idleTimer = setInterval(() => {
       if (Date.now() - lastOutput > options.timeoutMs!) {
         timedOut = true;
-        try {
-          proc.kill();
-        } catch {
-          // Best-effort kill on timeout.
-        }
+        // We intentionally do NOT kill the process here anymore.
+        // Just mark that idle timeout was reached for informational purposes.
+        clearInterval(idleTimer!);
+        idleTimer = undefined;
       }
-    }, 500);
+    }, 1000);
+  }
+
+  // Read streams - they may error if process is killed, so we handle that
+  let stdout = "";
+  let stderr = "";
+  try {
+    [stdout, stderr] = await Promise.all([
+      readStream(proc.stdout, onChunk),
+      readStream(proc.stderr, onChunk),
+    ]);
+  } catch {
+    // Stream read failed, likely due to process being killed
+    // Continue with whatever output we collected
   }
 
-  const [stdout, stderr] = await Promise.all([
-    readStream(proc.stdout, onChunk),
-    readStream(proc.stderr, onChunk),
-  ]);
   const exitCode = await proc.exited;
 
+  // Cleanup
   if (idleTimer) {
     clearInterval(idleTimer);
   }
+  if (options.signal) {
+    options.signal.removeEventListener("abort", abortHandler);
+  }
 
   return {
     stdout,
@@ -101,5 +146,6 @@ export async function runCommand(
     exitCode,
     duration: Date.now() - startTime,
     timedOut,
+    aborted,
   };
 }

package/src/agents/gemini.ts

@@ -83,6 +83,7 @@ export const geminiAdapter: AgentAdapter = {
     const result = await runCommand(["gemini", ...args], {
       cwd: options?.workingDirectory,
       timeoutMs: options?.timeout,
+      signal: options?.signal,
     });
 
     const timeoutNote =
@@ -105,12 +106,8 @@ export const geminiAdapter: AgentAdapter = {
   },
 
   detectRateLimit(output: string): RateLimitInfo {
-    if (output.includes("[Relentless] Idle timeout")) {
-      return {
-        limited: true,
-        message: "Gemini idle timeout",
-      };
-    }
+    // NOTE: Idle timeout is NOT a rate limit - it just means the agent stopped
+    // producing output for a while, which is normal behavior for complex tasks.
 
     // Gemini rate limit patterns
     const patterns = [