wiggum-cli 0.16.0 → 0.17.1

package/dist/tui/utils/git-summary.js

@@ -69,6 +69,22 @@ export function getDiffStats(projectRoot, fromHash, toHash) {
  * @param toHash - Ending commit hash (inclusive)
  * @returns Array of commit entries, or null if not available
  */
+export function getRecentCommits(projectRoot, count = 3) {
+    try {
+        const output = execFileSync('git', ['log', '--oneline', `-${count}`], { cwd: projectRoot, encoding: 'utf-8', timeout: 10_000 }).trim();
+        if (!output)
+            return [];
+        return output.split('\n').map((line) => {
+            const spaceIdx = line.indexOf(' ');
+            if (spaceIdx === -1)
+                return { hash: line, title: '' };
+            return { hash: line.substring(0, spaceIdx), title: line.substring(spaceIdx + 1) };
+        });
+    }
+    catch {
+        return [];
+    }
+}
 export function getCommitList(projectRoot, fromHash, toHash) {
     try {
         const output = execFileSync('git', ['log', '--oneline', `${fromHash}..${toHash}`], {

package/dist/tui/utils/loop-status.d.ts

@@ -1,6 +1,13 @@
 /**
  * Loop status helpers for the TUI run/monitor screens.
  */
+/**
+ * Find the implementation plan file, checking main project and git worktrees.
+ *
+ * Shared between loop-status.ts and monitor.ts to avoid duplicating the
+ * worktree search logic.
+ */
+export declare function findImplementationPlan(projectRoot: string, specsRelPath: string, feature: string): string | null;
 export interface LoopStatus {
     running: boolean;
     phase: string;
@@ -10,12 +17,14 @@ export interface LoopStatus {
     tokensOutput: number;
     cacheCreate: number;
     cacheRead: number;
+    tokensUpdatedAt?: number;
 }
 export interface TaskCounts {
     tasksDone: number;
     tasksPending: number;
     e2eDone: number;
     e2ePending: number;
+    planExists: boolean;
 }
 /**
  * Phase execution status and timing.
@@ -27,12 +36,17 @@ export interface PhaseInfo {
     /** Human-readable phase label */
     label: string;
     /** Phase completion status */
-    status: 'success' | 'skipped' | 'failed';
+    status: 'success' | 'skipped' | 'failed' | 'started';
     /** Duration in milliseconds, if available */
     durationMs?: number;
     /** Number of iterations in this phase (e.g., for implementation) */
     iterations?: number;
 }
+/**
+ * Phase ID to human-readable label mapping.
+ * Matches the phase IDs written by feature-loop.sh.
+ */
+export declare const PHASE_LABELS: Record<string, string>;
 /**
  * Return the conventional log file path for a feature loop.
  */
@@ -45,6 +59,14 @@ export declare function getLoopLogPath(feature: string): string;
  * concurrent loops are rare, but callers should be aware of the limitation.
  */
 export declare function detectPhase(feature: string): string;
+/**
+ * Read the current phase from the `.phases` file written by feature-loop.sh.
+ * Returns the human-readable label of the active phase, or null if unavailable.
+ *
+ * The file format is: phase_id|status|start_timestamp|end_timestamp
+ * A line with status "started" and no end timestamp indicates the active phase.
+ */
+export declare function readCurrentPhase(feature: string): string | null;
 /**
  * Read loop status from temp files written by feature-loop.sh.
  *
@@ -87,6 +109,10 @@ export interface ActivityEvent {
     /** Inferred status based on event content */
     status: 'success' | 'error' | 'in-progress';
 }
+/**
+ * Returns true if a log line should be excluded from the activity feed.
+ */
+export declare function shouldSkipLine(line: string): boolean;
 /**
  * Parse the loop log file into structured activity events.
  *
@@ -108,3 +134,17 @@ export declare function parsePhaseChanges(feature: string, lastKnownPhases?: Pha
     events: ActivityEvent[];
     currentPhases?: PhaseInfo[];
 };
+/**
+ * Parse phase information from the phases file written by feature-loop.sh.
+ *
+ * Format: phase_id|status|start_timestamp|end_timestamp
+ * Accepts both 3-field lines (started: phase_id|started|timestamp) and
+ * 4-field lines (completed: phase_id|status|start_ts|end_ts).
+ *
+ * The parser handles duplicate phase entries defensively (last status wins,
+ * durations aggregate), though feature-loop.sh normally writes one final
+ * line per phase.
+ *
+ * Used by build-run-summary.ts for completion summaries.
+ */
+export declare function parsePhases(phasesFilePath: string): PhaseInfo[];

package/dist/tui/utils/loop-status.js

@@ -6,6 +6,51 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadConfigWithDefaults } from '../../utils/config.js';
 import { logger } from '../../utils/logger.js';
+/**
+ * Find the implementation plan file, checking main project and git worktrees.
+ *
+ * Shared between loop-status.ts and monitor.ts to avoid duplicating the
+ * worktree search logic.
+ */
+export function findImplementationPlan(projectRoot, specsRelPath, feature) {
+    // 1. Check main project
+    const mainPath = join(projectRoot, specsRelPath, `${feature}-implementation-plan.md`);
+    if (existsSync(mainPath))
+        return mainPath;
+    // 2. Check git worktrees for the feature branch
+    try {
+        const output = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+        });
+        const worktrees = output.split('\n\n').filter(Boolean);
+        for (const wt of worktrees) {
+            const pathMatch = wt.match(/^worktree (.+)$/m);
+            const escapedFeature = feature.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const branchMatch = wt.match(new RegExp(`^branch .+/feat/${escapedFeature}$`, 'm'));
+            if (pathMatch && branchMatch) {
+                const wtPlan = join(pathMatch[1], specsRelPath, `${feature}-implementation-plan.md`);
+                if (existsSync(wtPlan))
+                    return wtPlan;
+            }
+        }
+    }
+    catch {
+        // git worktree list failed — ignore
+    }
+    return null;
+}
+/**
+ * Phase ID to human-readable label mapping.
+ * Matches the phase IDs written by feature-loop.sh.
+ */
+export const PHASE_LABELS = {
+    planning: 'Planning',
+    implementation: 'Implementation',
+    e2e_testing: 'E2E Testing',
+    verification: 'Verification',
+    pr_review: 'PR & Review',
+};
 /**
  * Track whether pgrep is available to avoid repeated failed calls.
  * null = untested, true = available, false = unavailable
@@ -66,6 +111,48 @@ export function detectPhase(feature) {
         return 'Running';
     return 'Idle';
 }
+/**
+ * Read the current phase from the `.phases` file written by feature-loop.sh.
+ * Returns the human-readable label of the active phase, or null if unavailable.
+ *
+ * The file format is: phase_id|status|start_timestamp|end_timestamp
+ * A line with status "started" and no end timestamp indicates the active phase.
+ */
+export function readCurrentPhase(feature) {
+    const phasesFile = `/tmp/ralph-loop-${feature}.phases`;
+    let content;
+    try {
+        content = readFileSync(phasesFile, 'utf-8').trim();
+    }
+    catch {
+        return null;
+    }
+    if (!content)
+        return null;
+    const lines = content.split('\n');
+    let lastStartedPhase = null;
+    let lastCompletedPhase = null;
+    for (const line of lines) {
+        const parts = line.split('|');
+        if (parts.length < 2)
+            continue;
+        const [id, status] = parts;
+        if (status === 'started') {
+            lastStartedPhase = id;
+        }
+        else if (status === 'success' || status === 'failed' || status === 'skipped') {
+            lastCompletedPhase = id;
+        }
+    }
+    if (lastStartedPhase) {
+        return PHASE_LABELS[lastStartedPhase] || lastStartedPhase;
+    }
+    if (lastCompletedPhase) {
+        const label = PHASE_LABELS[lastCompletedPhase] || lastCompletedPhase;
+        return `post-${label}`;
+    }
+    return null;
+}
 /**
  * Read loop status from temp files written by feature-loop.sh.
  *
@@ -89,8 +176,14 @@ export function readLoopStatus(feature) {
         try {
             const content = readFileSync(fileToRead, 'utf-8').trim();
             const parts = content.split('|');
-            iteration = parseInt(parts[0] || '0', 10) || 0;
-            maxIterations = parseInt(parts[1] || '0', 10) || 0;
+            // Require at least 2 fields (iteration|maxIterations); skip partial writes
+            if (parts.length >= 2) {
+                iteration = parseInt(parts[0] || '0', 10) || 0;
+                maxIterations = parseInt(parts[1] || '0', 10) || 0;
+            }
+            else {
+                logger.debug(`Status file has fewer than 2 fields, using defaults: ${content}`);
+            }
         }
         catch (err) {
             logger.debug(`Failed to parse status file: ${err instanceof Error ? err.message : String(err)}`);
@@ -100,28 +193,48 @@ export function readLoopStatus(feature) {
     let tokensOutput = 0;
     let cacheCreate = 0;
     let cacheRead = 0;
+    let tokensUpdatedAt;
     if (existsSync(tokensFile)) {
         try {
             const content = readFileSync(tokensFile, 'utf-8').trim();
             const parts = content.split('|');
-            tokensInput = parseInt(parts[0] || '0', 10) || 0;
-            tokensOutput = parseInt(parts[1] || '0', 10) || 0;
-            cacheCreate = parseInt(parts[2] || '0', 10) || 0;
-            cacheRead = parseInt(parts[3] || '0', 10) || 0;
+            // Require at least 2 fields (input|output); cache fields are optional (legacy format)
+            if (parts.length >= 2) {
+                tokensInput = parseInt(parts[0] || '0', 10) || 0;
+                tokensOutput = parseInt(parts[1] || '0', 10) || 0;
+                cacheCreate = parts.length >= 3 ? (parseInt(parts[2] || '0', 10) || 0) : 0;
+                cacheRead = parts.length >= 4 ? (parseInt(parts[3] || '0', 10) || 0) : 0;
+                if (parts[4]) {
+                    const epoch = parseInt(parts[4], 10);
+                    if (epoch > 0)
+                        tokensUpdatedAt = epoch * 1000; // convert to ms
+                }
+            }
+            else {
+                logger.debug(`Tokens file has fewer than 2 fields, using defaults: ${content}`);
+            }
         }
         catch (err) {
             logger.debug(`Failed to parse tokens file: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    const running = isProcessRunning(`feature-loop.sh.*${feature}`);
+    // Prefer .phases file (written by feature-loop.sh on transitions) over process
+    // detection. pgrep-based detection can return stale results when old Claude
+    // sessions linger, causing the phase to appear stuck (e.g., "Planning" during
+    // Verification). The .phases file is the authoritative source of phase transitions.
+    const phaseFromFile = readCurrentPhase(feature);
+    let phase = phaseFromFile ?? detectPhase(feature);
     return {
-        running: isProcessRunning(`feature-loop.sh.*${feature}`),
-        phase: detectPhase(feature),
+        running,
+        phase,
         iteration,
         maxIterations,
         tokensInput,
         tokensOutput,
         cacheCreate,
         cacheRead,
+        tokensUpdatedAt,
     };
 }
 /**
@@ -143,12 +256,13 @@ export async function parseImplementationPlan(projectRoot, feature, specsDirOver
         }
     }
     const specsDir = specsDirOverride || config?.paths.specs || '.ralph/specs';
-    const planPath = join(projectRoot, specsDir, `${feature}-implementation-plan.md`);
+    const planPath = findImplementationPlan(projectRoot, specsDir, feature);
     let tasksDone = 0;
     let tasksPending = 0;
     let e2eDone = 0;
     let e2ePending = 0;
-    if (existsSync(planPath)) {
+    const planExists = planPath !== null;
+    if (planPath) {
         try {
             const content = readFileSync(planPath, 'utf-8');
             const lines = content.split('\n');
@@ -171,12 +285,36 @@ export async function parseImplementationPlan(projectRoot, feature, specsDirOver
                     }
                 }
             }
+            // Fallback: if no checkboxes found, count "#### Task N:" headers
+            if (tasksDone === 0 && tasksPending === 0 && e2eDone === 0 && e2ePending === 0) {
+                let headerTaskCount = 0;
+                for (const line of lines) {
+                    if (line.match(/^#{1,4}\s+Task\s+\d+/i)) {
+                        headerTaskCount++;
+                    }
+                }
+                if (headerTaskCount > 0) {
+                    // Check phases file to determine completion
+                    const phasesPath = `/tmp/ralph-loop-${feature}.phases`;
+                    let implDone = false;
+                    if (existsSync(phasesPath)) {
+                        const phases = readFileSync(phasesPath, 'utf-8');
+                        implDone = phases.includes('implementation|success');
+                    }
+                    if (implDone) {
+                        tasksDone = headerTaskCount;
+                    }
+                    else {
+                        tasksPending = headerTaskCount;
+                    }
+                }
+            }
         }
         catch (err) {
             logger.debug(`Failed to parse implementation plan: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    return { tasksDone, tasksPending, e2eDone, e2ePending };
+    return { tasksDone, tasksPending, e2eDone, e2ePending, planExists };
 }
 /**
  * Get current git branch.
@@ -259,14 +397,14 @@ const SKIP_LINE_PATTERNS = [
     /^Baseline commit:/,
     /^Creating branch:/,
     // Misc noise
-    /^\{"level"/, // JSON log lines (BashTool warnings etc.)
+    /^\{"/, // Any line starting with JSON object (Claude result, log entries)
     /^Pending implementation tasks: \d+$/, // raw task count (redundant with progress bar)
     /^Ready for feedback\.?$/i, // Conversational filler
 ];
 /**
  * Returns true if a log line should be excluded from the activity feed.
  */
-function shouldSkipLine(line) {
+export function shouldSkipLine(line) {
     return SKIP_LINE_PATTERNS.some((pattern) => pattern.test(line));
 }
 /**
@@ -279,13 +417,18 @@ function stripMarkdown(msg) {
         .replace(/^\s*[-*]\s+/, '') // leading bullet points
         .trim();
 }
-const SUCCESS_KEYWORDS = /completed|passed|success|approved|all implementation tasks completed/i;
-const ERROR_KEYWORDS = /error|failed|failure/i;
+const SUCCESS_KEYWORDS = /\b(completed|passed|success|approved|fixed|resolved|merged|works)\b/i;
+const ERROR_KEYWORDS = /\b(error|failed|failure)\b/i;
+const POSITIVE_ERROR_CONTEXT = /\b(fixed|resolved|added|handled|handling|recovery|boundary|boundaries|tests?\s+passed)\b/i;
 function inferStatus(message) {
     if (SUCCESS_KEYWORDS.test(message))
         return 'success';
-    if (ERROR_KEYWORDS.test(message))
+    if (ERROR_KEYWORDS.test(message)) {
+        // Avoid misclassifying positive actions that mention error-related words
+        if (POSITIVE_ERROR_CONTEXT.test(message))
+            return 'in-progress';
         return 'error';
+    }
     return 'in-progress';
 }
 /**
@@ -366,28 +509,26 @@ export function parsePhaseChanges(feature, lastKnownPhases) {
         }
         return { events: [] };
     }
-    let parsed;
-    try {
-        parsed = JSON.parse(rawContent);
-        if (!Array.isArray(parsed)) {
-            logger.debug(`parsePhaseChanges: expected array in ${phasesFile}, got ${typeof parsed}`);
-            return { events: [], currentPhases: lastKnownPhases };
-        }
-    }
-    catch (err) {
-        logger.debug(`parsePhaseChanges: invalid JSON in ${phasesFile}: ${err instanceof Error ? err.message : String(err)}`);
+    const content = rawContent.trim();
+    if (!content) {
         return { events: [], currentPhases: lastKnownPhases };
     }
-    // Validate each phase has required fields
-    const currentPhases = [];
-    for (const item of parsed) {
-        if (typeof item === 'object' && item !== null &&
-            'id' in item && typeof item.id === 'string' &&
-            'label' in item && typeof item.label === 'string' &&
-            'status' in item && typeof item.status === 'string') {
-            currentPhases.push(item);
-        }
+    // Parse pipe-delimited format: phase_id|status|start_timestamp|end_timestamp
+    const VALID_STATUSES = new Set(['success', 'skipped', 'failed', 'started']);
+    const phaseMap = new Map();
+    for (const line of content.split('\n')) {
+        const parts = line.split('|');
+        if (parts.length < 2)
+            continue;
+        const [id, status] = parts;
+        if (!id || !VALID_STATUSES.has(status))
+            continue;
+        const label = PHASE_LABELS[id] || id;
+        const validStatus = status;
+        // Last status wins for each phase id
+        phaseMap.set(id, { id, label, status: validStatus });
     }
+    const currentPhases = Array.from(phaseMap.values());
     const events = [];
     const now = Date.now();
     for (const current of currentPhases) {
@@ -411,3 +552,70 @@ export function parsePhaseChanges(feature, lastKnownPhases) {
     }
     return { events, currentPhases };
 }
+/**
+ * Parse phase information from the phases file written by feature-loop.sh.
+ *
+ * Format: phase_id|status|start_timestamp|end_timestamp
+ * Accepts both 3-field lines (started: phase_id|started|timestamp) and
+ * 4-field lines (completed: phase_id|status|start_ts|end_ts).
+ *
+ * The parser handles duplicate phase entries defensively (last status wins,
+ * durations aggregate), though feature-loop.sh normally writes one final
+ * line per phase.
+ *
+ * Used by build-run-summary.ts for completion summaries.
+ */
+export function parsePhases(phasesFilePath) {
+    if (!existsSync(phasesFilePath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(phasesFilePath, 'utf-8').trim();
+        if (!content) {
+            return [];
+        }
+        const lines = content.split('\n');
+        const VALID_STATUSES = new Set(['success', 'skipped', 'failed', 'started']);
+        const phaseMap = new Map();
+        for (const line of lines) {
+            const parts = line.split('|');
+            if (parts.length < 2)
+                continue;
+            const [id, status] = parts;
+            if (!id || !VALID_STATUSES.has(status)) {
+                logger.warn(`Unknown phase status "${status}" for phase "${id}", treating as failed`);
+                // Still process with 'failed' status
+            }
+            const validatedStatus = VALID_STATUSES.has(status)
+                ? status
+                : 'failed';
+            // Parse timestamps (may be absent for 3-field 'started' lines)
+            const startTime = parts.length >= 3 ? (parseInt(parts[2], 10) || 0) : 0;
+            const endTime = parts.length >= 4 ? (parseInt(parts[3], 10) || 0) : 0;
+            // Calculate duration (end - start) in milliseconds
+            const durationMs = endTime > 0 && startTime > 0 ? (endTime - startTime) * 1000 : undefined;
+            // Get or create phase entry
+            let phase = phaseMap.get(id);
+            if (!phase) {
+                phase = {
+                    id,
+                    label: PHASE_LABELS[id] || id,
+                    status: validatedStatus,
+                    durationMs: 0,
+                };
+                phaseMap.set(id, phase);
+            }
+            // Update status (last status wins)
+            phase.status = validatedStatus;
+            // Aggregate duration
+            if (durationMs !== undefined) {
+                phase.durationMs = (phase.durationMs || 0) + durationMs;
+            }
+        }
+        return Array.from(phaseMap.values());
+    }
+    catch (err) {
+        logger.warn(`Failed to parse phases file: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}

package/dist/tui/utils/pr-summary.d.ts

@@ -24,11 +24,12 @@ export interface IssueInfo {
 export declare function getPrForBranch(projectRoot: string, branchName: string): PrInfo | null;
 /**
  * Get linked issue for a branch by parsing the PR body for closing keywords
- * (Closes/Fixes/Resolves #N).
+ * (Closes/Fixes/Resolves #N), with fallbacks for spec file and feature name search.
  *
  * @param projectRoot - Root directory of the git repository
  * @param branchName - Branch name to look up
  * @param prInfo - Optional pre-fetched PR info to avoid redundant gh call
+ * @param featureName - Optional feature name for fallback issue detection
  * @returns Issue info object, or null if not found or gh not available
  */
-export declare function getLinkedIssue(projectRoot: string, branchName: string, prInfo?: PrInfo | null): IssueInfo | null;
+export declare function getLinkedIssue(projectRoot: string, branchName: string, prInfo?: PrInfo | null, featureName?: string): IssueInfo | null;

package/dist/tui/utils/pr-summary.js

@@ -2,6 +2,8 @@
  * PR and Issue utilities for enhanced run summary.
  */
 import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { logger } from '../../utils/logger.js';
 /**
  * Get PR information for a branch.
@@ -33,16 +35,51 @@ export function getPrForBranch(projectRoot, branchName) {
         title: pr.title,
     };
 }
+/**
+ * Extract issue number from PR body closing keywords or fallback strategies.
+ */
+function findIssueNumber(body, featureName, projectRoot) {
+    // Strategy 1: Closing keywords in PR body (Closes/Fixes/Resolves #N)
+    const issueMatch = body.match(/(?:closes|fixes|resolves)\s+#(\d+)/i);
+    if (issueMatch) {
+        return parseInt(issueMatch[1], 10);
+    }
+    // Strategy 2: Bare "#N" references in the body (e.g., "Closes #7" without keyword before it)
+    // Look for "# N" patterns that are likely issue references (not markdown headers)
+    const hashRefMatch = body.match(/(?:^|\s)#(\d+)\b/m);
+    if (hashRefMatch) {
+        return parseInt(hashRefMatch[1], 10);
+    }
+    // Strategy 3: Read spec file for issue reference
+    if (featureName && projectRoot) {
+        try {
+            const specPath = join(projectRoot, '.ralph', 'specs', `${featureName}.md`);
+            if (existsSync(specPath)) {
+                const specContent = readFileSync(specPath, 'utf-8');
+                // Look for "Issue: #N", "Source Issue: #N", "GitHub Issue: #N", or issue URLs
+                const specIssueMatch = specContent.match(/(?:issue|source|github)[:\s]*#(\d+)/i) || specContent.match(/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/i);
+                if (specIssueMatch) {
+                    return parseInt(specIssueMatch[1], 10);
+                }
+            }
+        }
+        catch {
+            // spec read failure is non-fatal
+        }
+    }
+    return null;
+}
 /**
  * Get linked issue for a branch by parsing the PR body for closing keywords
- * (Closes/Fixes/Resolves #N).
+ * (Closes/Fixes/Resolves #N), with fallbacks for spec file and feature name search.
  *
  * @param projectRoot - Root directory of the git repository
  * @param branchName - Branch name to look up
  * @param prInfo - Optional pre-fetched PR info to avoid redundant gh call
+ * @param featureName - Optional feature name for fallback issue detection
  * @returns Issue info object, or null if not found or gh not available
  */
-export function getLinkedIssue(projectRoot, branchName, prInfo) {
+export function getLinkedIssue(projectRoot, branchName, prInfo, featureName) {
     try {
         // Use provided PR info or fetch it
         const pr = prInfo !== undefined ? prInfo : getPrForBranch(projectRoot, branchName);
@@ -57,12 +94,10 @@ export function getLinkedIssue(projectRoot, branchName, prInfo) {
         }).trim();
         const prData = JSON.parse(prBody);
         const body = prData.body || '';
-        // Look for issue references in PR body (e.g., "Closes #123", "Fixes #456")
-        const issueMatch = body.match(/(?:closes|fixes|resolves)\s+#(\d+)/i);
-        if (!issueMatch) {
+        const issueNumber = findIssueNumber(body, featureName, projectRoot);
+        if (!issueNumber) {
             return null;
         }
-        const issueNumber = parseInt(issueMatch[1], 10);
         // Fetch the issue details
         const issueOutput = execFileSync('gh', ['issue', 'view', String(issueNumber), '--json', 'number,url,state,title'], {
             cwd: projectRoot,

package/dist/utils/config.d.ts

@@ -50,6 +50,13 @@ export interface LoopConfig {
     planningModel: string;
     reviewMode: 'manual' | 'auto' | 'merge';
 }
+/**
+ * Agent configuration in ralph.config.cjs
+ */
+export interface AgentSectionConfig {
+    defaultProvider: string;
+    defaultModel: string;
+}
 /**
  * Full ralph.config.cjs structure
  */
@@ -59,6 +66,7 @@ export interface RalphConfig {
     commands: CommandsConfig;
     paths: PathsConfig;
     loop: LoopConfig;
+    agent: AgentSectionConfig;
 }
 /**
  * Default configuration values

package/dist/utils/config.js

@@ -47,6 +47,10 @@ export const DEFAULT_CONFIG = {
         planningModel: 'opus',
         reviewMode: 'manual',
     },
+    agent: {
+        defaultProvider: '',
+        defaultModel: '',
+    },
 };
 /**
  * Load ralph.config.cjs from a project directory
@@ -104,6 +108,10 @@ export async function loadConfigWithDefaults(projectRoot) {
             ...DEFAULT_CONFIG.loop,
             ...config.loop,
         },
+        agent: {
+            ...DEFAULT_CONFIG.agent,
+            ...config?.agent,
+        },
     };
 }
 /**

package/dist/utils/github.d.ts

@@ -0,0 +1,32 @@
+export declare function isGhInstalled(): Promise<boolean>;
+export declare function _resetGhCache(): void;
+export interface GitHubIssueDetail {
+    title: string;
+    body: string;
+    labels: string[];
+}
+export declare function fetchGitHubIssue(owner: string, repo: string, number: number): Promise<GitHubIssueDetail | null>;
+export interface GitHubIssueListItem {
+    number: number;
+    title: string;
+    state: 'open' | 'closed';
+    labels: string[];
+    createdAt: string;
+}
+export interface ListIssuesResult {
+    issues: GitHubIssueListItem[];
+    error?: string;
+}
+export declare function listRepoIssues(owner: string, repo: string, search?: string, limit?: number): Promise<ListIssuesResult>;
+export declare function detectGitHubRemote(projectRoot: string): Promise<GitHubRepo | null>;
+export interface ParsedGitHubIssue {
+    owner: string;
+    repo: string;
+    number: number;
+}
+export declare function isGitHubIssueUrl(input: string): ParsedGitHubIssue | null;
+export interface GitHubRepo {
+    owner: string;
+    repo: string;
+}
+export declare function parseGitHubRemote(remoteUrl: string): GitHubRepo | null;