@arvorco/relentless 0.6.0 → 0.7.0

package/.claude/skills/specify/SKILL.md

@@ -198,14 +198,14 @@ If validation fails, revise and re-check (max 3 iterations).
 ## Step 6: Save & Report
 
 1. Write complete specification to `SPEC_FILE` from JSON output
-2. Create progress.txt if it doesn't exist:
+2. Create progress.txt if it doesn't exist (note that markdown frontmatter must be properly formatted YAML):
    ```markdown
    ---
    feature: FEATURE_NAME
    started: DATE
    last_updated: DATE
    stories_completed: 0
-   routing_preference: [auto: mode | allow free: yes/no]
+   routing_preference: "[auto: mode | allow free: yes/no]"
    ---
 
    # Progress Log: FEATURE_NAME

package/CHANGELOG.md

@@ -7,6 +7,65 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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

package/package.json

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

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 =
@@ -180,14 +181,27 @@ export const claudeAdapter: AgentAdapter = {
   },
 
   detectRateLimit(output: string): RateLimitInfo {
-    if (output.includes("[Relentless] Idle timeout")) {
-      return {
-        limited: true,
-        message: "Claude idle timeout",
-      };
-    }
+    // Debug: Log to file when rate limit is detected
+    const debugRateLimit = (pattern: string, message: string) => {
+      if (process.env.RELENTLESS_DEBUG) {
+        const debugInfo = {
+          timestamp: new Date().toISOString(),
+          pattern,
+          message,
+          outputLength: output.length,
+          outputSample: output.slice(0, 500),
+          outputEnd: output.slice(-500),
+        };
+        console.error(`[RELENTLESS_DEBUG] Rate limit detected: ${JSON.stringify(debugInfo, null, 2)}`);
+      }
+    };
+
+    // 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");
       return {
         limited: true,
         message: "Claude unavailable due to permission error",
@@ -195,8 +209,10 @@ export const claudeAdapter: AgentAdapter = {
     }
 
     // More specific pattern for actual API model not found errors
-    // Avoid matching if Claude just mentions "model" and "not_found_error" in conversation
-    if (/error.*model.*not[_\s]?found|model.*not[_\s]?found.*error|"type":\s*"not_found_error"/i.test(output)) {
+    // Only match JSON API error responses, not conversational mentions
+    const modelNotFoundPattern = /"type":\s*"not_found_error".*"model"/i;
+    if (modelNotFoundPattern.test(output)) {
+      debugRateLimit("model_not_found", "Claude model not found");
       return {
         limited: true,
         message: "Claude model not found",
@@ -225,6 +241,7 @@ export const claudeAdapter: AgentAdapter = {
         }
       }
 
+      debugRateLimit("hit_your_limit", "Claude Code rate limit exceeded");
       return {
         limited: true,
         resetTime,

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 = [

package/src/agents/opencode.ts

@@ -81,6 +81,7 @@ export const opencodeAdapter: AgentAdapter = {
     const result = await runCommand(args, {
       cwd: options?.workingDirectory,
       timeoutMs: options?.timeout,
+      signal: options?.signal,
     });
 
     const timeoutNote =
@@ -237,12 +238,8 @@ export const opencodeAdapter: AgentAdapter = {
   },
 
   detectRateLimit(output: string): RateLimitInfo {
-    if (output.includes("[Relentless] Idle timeout")) {
-      return {
-        limited: true,
-        message: "OpenCode 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.
 
     // OpenCode rate limit patterns
     const patterns = [

package/src/agents/types.ts

@@ -18,6 +18,8 @@ export interface InvokeOptions {
   dangerouslyAllowAll?: boolean;
   /** Claude Code TaskList ID for cross-session coordination */
   taskListId?: string;
+  /** AbortSignal for cancelling the agent execution */
+  signal?: AbortSignal;
 }
 
 /**

package/src/config/schema.ts

@@ -171,7 +171,7 @@ export type FallbackConfig = z.infer<typeof FallbackConfigSchema>;
 export const ExecutionConfigSchema = z.object({
   maxIterations: z.number().int().positive().default(20),
   iterationDelay: z.number().int().nonnegative().default(2000),
-  timeout: z.number().int().positive().default(600000), // 10 minutes
+  timeout: z.number().int().positive().default(1800000), // 30 minutes
 });
 
 export type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;
@@ -232,7 +232,7 @@ export const DEFAULT_CONFIG: RelentlessConfig = {
   execution: {
     maxIterations: 20,
     iterationDelay: 2000,
-    timeout: 600000,
+    timeout: 1800000, // 30 minutes
   },
   prompt: {
     path: "prompt.md",

package/src/tui/App.tsx

@@ -1,7 +1,7 @@
 /**
  * Relentless TUI App
  *
- * Main application component that renders the full interface
+ * Main application component with responsive 3-column layout
  */
 
 import React from "react";
@@ -15,6 +15,12 @@ import { AgentStatus } from "./components/AgentStatus.js";
 import { QueuePanel } from "./components/QueuePanel.js";
 import { QueueInput } from "./components/QueueInput.js";
 import { QueueRemovalPrompt } from "./components/QueueRemoval.js";
+import { TaskPanel } from "./components/TaskPanel.js";
+import { OutputPanel } from "./components/OutputPanel.js";
+import { MessageQueuePanel } from "./components/MessageQueuePanel.js";
+import { StatusBar } from "./components/StatusBar.js";
+import { LayoutSwitcher } from "./layouts/LayoutSwitcher.js";
+import { useResponsiveLayout } from "./hooks/useResponsiveLayout.js";
 import { colors } from "./theme.js";
 import type { TUIState } from "./types.js";
 
@@ -24,23 +30,112 @@ interface AppProps {
 
 export function App({ state }: AppProps): React.ReactElement {
   const { stdout } = useStdout();
-  const terminalRows = stdout.rows ?? 24;
-  
+  const terminalRows = stdout?.rows ?? 24;
+  const layout = useResponsiveLayout();
+
   const completedCount = state.stories.filter((s) => s.passes).length;
   const totalCount = state.stories.length;
-  
+
   // Calculate available rows for stories based on terminal height
-  // Chrome: Header(2) + Feature/Progress(2) + CurrentStory(2) + AgentOutputHeader(1) + AgentStatusFooter(2) + Padding(2) = ~11 lines
-  // AgentOutput: 6 lines
-  // Remaining space for stories
   const chromeHeight = 11;
   const agentOutputLines = 6;
   const availableForStories = Math.max(8, terminalRows - chromeHeight - agentOutputLines);
-  
-  // Calculate story rows needed for 2-column layout
   const storyRows = Math.ceil(totalCount / 2);
   const maxStoryRows = Math.min(storyRows, availableForStories);
 
+  // Use 3-column layout for wider terminals
+  if (layout.mode !== "vertical") {
+    return (
+      <Box flexDirection="column" width="100%">
+        <LayoutSwitcher
+          taskPanel={
+            <TaskPanel
+              stories={state.stories}
+              currentStoryId={state.currentStory?.id}
+              maxRows={terminalRows - 4}
+              showPhases={true}
+            />
+          }
+          outputPanel={
+            <OutputPanel
+              lines={state.outputLines}
+              maxLines={terminalRows - 6}
+              currentStory={state.currentStory}
+              currentAgent={state.currentAgent?.displayName}
+              currentModel={state.currentRouting?.model}
+              routing={state.currentRouting}
+              displayMode={state.outputMode}
+            />
+          }
+          queuePanel={
+            <MessageQueuePanel
+              messages={state.messages}
+              queueItems={state.queueItems}
+              maxMessages={terminalRows - 10}
+              maxQueueItems={5}
+            />
+          }
+          statusBar={
+            <StatusBar
+              costData={state.costData}
+              tokens={state.costData?.tokens}
+              iteration={state.iteration}
+              maxIterations={state.maxIterations}
+              agents={state.agents}
+              elapsedSeconds={state.totalElapsedSeconds || state.elapsedSeconds}
+              mode={state.currentRouting?.mode}
+              complexity={state.currentRouting?.complexity}
+              harness={state.currentRouting?.harness}
+              model={state.currentRouting?.model}
+              savingsPercent={state.savingsPercent}
+              completedStories={completedCount}
+              totalStories={totalCount}
+            />
+          }
+          forceMode={layout.mode}
+        />
+
+        {/* Error display */}
+        {state.error && (
+          <Box paddingX={1}>
+            <Text color={colors.error}>Error: {state.error}</Text>
+          </Box>
+        )}
+
+        {/* Completion message */}
+        {state.isComplete && (
+          <Box paddingX={1}>
+            <Text color={colors.success} bold>
+              All stories complete!
+            </Text>
+          </Box>
+        )}
+
+        {/* Idle warning when agent has been idle for too long */}
+        {state.isRunning && state.idleSeconds >= 300 && (
+          <Box paddingX={1}>
+            <Text color={colors.warning}>
+              Agent idle for {Math.floor(state.idleSeconds / 60)}m {state.idleSeconds % 60}s - Press 's' to skip
+            </Text>
+          </Box>
+        )}
+
+        {/* Queue removal prompt */}
+        <QueueRemovalPrompt
+          deleteMode={state.deleteMode}
+          confirmClearActive={state.confirmClearActive}
+          statusMessage={state.statusMessage}
+        />
+
+        {/* Full-width queue input at bottom (Claude Code style) */}
+        {!state.deleteMode && !state.confirmClearActive && !state.statusMessage && (
+          <QueueInput active={state.queueInputActive} value={state.queueInputValue} />
+        )}
+      </Box>
+    );
+  }
+
+  // Vertical layout fallback for narrow terminals
   return (
     <Box flexDirection="column" width="100%">
       {/* Header */}
@@ -89,6 +184,23 @@ export function App({ state }: AppProps): React.ReactElement {
         maxIterations={state.maxIterations}
       />
 
+      {/* Status bar */}
+      <StatusBar
+        costData={state.costData}
+        tokens={state.costData?.tokens}
+        iteration={state.iteration}
+        maxIterations={state.maxIterations}
+        agents={state.agents}
+        elapsedSeconds={state.totalElapsedSeconds || state.elapsedSeconds}
+        mode={state.currentRouting?.mode}
+        complexity={state.currentRouting?.complexity}
+        harness={state.currentRouting?.harness}
+        model={state.currentRouting?.model}
+        savingsPercent={state.savingsPercent}
+        completedStories={completedCount}
+        totalStories={totalCount}
+      />
+
       {/* Error display */}
       {state.error && (
         <Box paddingX={1}>
@@ -100,14 +212,11 @@ export function App({ state }: AppProps): React.ReactElement {
       {state.isComplete && (
         <Box paddingX={1} paddingY={1}>
           <Text color={colors.success} bold>
-            🎉 All stories complete!
+            All stories complete!
           </Text>
         </Box>
       )}
 
-      {/* Queue input */}
-      <QueueInput active={state.queueInputActive} value={state.queueInputValue} />
-
       {/* Queue removal prompt */}
       <QueueRemovalPrompt
         deleteMode={state.deleteMode}
@@ -115,12 +224,19 @@ export function App({ state }: AppProps): React.ReactElement {
         statusMessage={state.statusMessage}
       />
 
-      {/* Keyboard hint when not in input mode */}
-      {!state.queueInputActive && !state.deleteMode && !state.confirmClearActive && !state.statusMessage && (
+      {/* Idle warning when agent has been idle for too long */}
+      {state.isRunning && state.idleSeconds >= 300 && (
         <Box paddingX={1}>
-          <Text color={colors.dim}>Press 'q' to add, 'd' to delete, 'D' to clear queue</Text>
+          <Text color={colors.warning}>
+            Agent idle for {Math.floor(state.idleSeconds / 60)}m {state.idleSeconds % 60}s - Press 's' to skip to next iteration
+          </Text>
         </Box>
       )}
+
+      {/* Full-width queue input at bottom (Claude Code style) */}
+      {!state.deleteMode && !state.confirmClearActive && !state.statusMessage && (
+        <QueueInput active={state.queueInputActive} value={state.queueInputValue} />
+      )}
     </Box>
   );
 }