wiggum-cli 0.17.2 → 0.18.3

package/dist/agent/tools/backlog.d.ts

@@ -1,6 +1,9 @@
 export interface BacklogToolsOptions {
     defaultLabels?: string[];
     issueNumbers?: number[];
+    scopeListIssuesToIssueNumbers?: boolean;
+    scopeReadIssueToIssueNumbers?: boolean;
+    allowGlobalBugDuplicateChecks?: boolean;
 }
 export declare function createBacklogTools(owner: string, repo: string, options?: BacklogToolsOptions): {
     listIssues: import("ai").Tool<{
@@ -20,9 +23,12 @@ export declare function createBacklogTools(owner: string, repo: string, options?
         error: string;
     } | {
         dependsOn: number[];
+        number: number;
         title: string;
         body: string;
         labels: string[];
+        state: "open" | "closed";
+        createdAt: string;
         error?: undefined;
     }>;
 };

package/dist/agent/tools/backlog.js

@@ -8,6 +8,10 @@ function extractDependencyHints(body) {
     return [...new Set(numbers)].sort((a, b) => a - b);
 }
 export function createBacklogTools(owner, repo, options = {}) {
+    const issueNumberSet = options.issueNumbers?.length
+        ? new Set(options.issueNumbers)
+        : undefined;
+    const listVisibleIssueNumbers = new Set();
     const listIssues = tool({
         description: 'List open GitHub issues from the backlog, optionally filtered by labels or milestone.',
         inputSchema: zodSchema(z.object({
@@ -30,10 +34,19 @@ export function createBacklogTools(owner, repo, options = {}) {
                 return { issues: [], error: result.error };
             // Sort by issue number ascending — lower numbers are typically more foundational
             const sorted = [...result.issues].sort((a, b) => a.number - b.number);
-            const filtered = options.issueNumbers?.length
-                ? sorted.filter(i => options.issueNumbers.includes(i.number))
-                : sorted;
-            return { issues: filtered };
+            const isBugDuplicateCheck = options.allowGlobalBugDuplicateChecks === true
+                && milestone == null
+                && uniqueLabels.length === 1
+                && uniqueLabels[0] === 'bug';
+            if (issueNumberSet && options.scopeListIssuesToIssueNumbers !== false && !isBugDuplicateCheck) {
+                const filtered = sorted.filter(i => issueNumberSet.has(Number(i.number)));
+                for (const issue of filtered)
+                    listVisibleIssueNumbers.add(Number(issue.number));
+                return { issues: filtered };
+            }
+            for (const issue of sorted)
+                listVisibleIssueNumbers.add(Number(issue.number));
+            return { issues: sorted };
         },
     });
     const readIssue = tool({
@@ -42,6 +55,12 @@ export function createBacklogTools(owner, repo, options = {}) {
             issueNumber: z.number().int().min(1).describe('The issue number to read'),
         })),
         execute: async ({ issueNumber }) => {
+            if (issueNumberSet
+                && options.scopeReadIssueToIssueNumbers !== false
+                && !issueNumberSet.has(issueNumber)
+                && !listVisibleIssueNumbers.has(issueNumber)) {
+                return { error: `Issue #${issueNumber} is outside the selected worker scope` };
+            }
             const detail = await fetchGitHubIssue(owner, repo, issueNumber);
             if (!detail)
                 return { error: `Issue #${issueNumber} not found` };

package/dist/agent/tools/execution.js

@@ -106,7 +106,7 @@ export function createExecutionTools(projectRoot, options) {
         },
     });
     const runLoop = tool({
-        description: 'Run the development loop for a feature. Spawns a background process and returns when complete. The loop uses Claude Code internally with its own model config — do NOT forward the agent model here.',
+        description: 'Run the development loop for a feature. Spawns a background process and returns when complete. The loop uses the coding CLI configured in ralph.config.cjs; do NOT forward the agent model here.',
         inputSchema: zodSchema(z.object({
             featureName: FEATURE_NAME_SCHEMA,
             worktree: z.boolean().default(true).describe('Use git worktree isolation'),

package/dist/agent/tools/introspection.js

@@ -1,9 +1,9 @@
 import { tool, zodSchema } from 'ai';
 import { z } from 'zod';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { readFile, stat, open } from 'node:fs/promises';
 import { join } from 'node:path';
 import { FEATURE_NAME_SCHEMA } from './schemas.js';
+const MAX_LOG_BYTES = 1_048_576; // 1 MB
 export function createIntrospectionTools(projectRoot) {
     const readLoopLog = tool({
         description: 'Read the stdout/stderr log of a development loop (running or completed).',
@@ -13,10 +13,32 @@ export function createIntrospectionTools(projectRoot) {
         })),
         execute: async ({ featureName, tailLines }) => {
             const logPath = join('/tmp', `ralph-loop-${featureName}.log`);
-            if (!existsSync(logPath)) {
+            let fileSize;
+            try {
+                const fileStat = await stat(logPath);
+                fileSize = fileStat.size;
+            }
+            catch {
                 return { error: `No log found at ${logPath} — verify featureName matches exactly what runLoop used` };
             }
-            const content = await readFile(logPath, 'utf-8');
+            let content;
+            if (fileSize <= MAX_LOG_BYTES) {
+                content = await readFile(logPath, 'utf-8');
+            }
+            else {
+                // For large files, read only the last MAX_LOG_BYTES to bound memory usage.
+                // totalLines will reflect lines in the chunk, not the full file.
+                const offset = fileSize - MAX_LOG_BYTES;
+                const fd = await open(logPath, 'r');
+                try {
+                    const buffer = Buffer.allocUnsafe(MAX_LOG_BYTES);
+                    const { bytesRead } = await fd.read(buffer, 0, MAX_LOG_BYTES, offset);
+                    content = buffer.subarray(0, bytesRead).toString('utf-8');
+                }
+                finally {
+                    await fd.close();
+                }
+            }
             const allLines = content.split('\n');
             const lines = allLines.slice(-tailLines);
             return { lines, totalLines: allLines.length };

package/dist/agent/types.d.ts

@@ -1,5 +1,39 @@
 import type { LanguageModel } from 'ai';
 export type ReviewMode = 'manual' | 'auto' | 'merge';
+export type DependencyKind = 'explicit' | 'inferred';
+export type DependencyConfidence = 'high' | 'medium' | 'low';
+export type TaskActionability = 'ready' | 'housekeeping' | 'waiting_pr' | 'blocked_dependency' | 'blocked_cycle' | 'blocked_out_of_scope';
+export type AttemptState = 'never_tried' | 'partial' | 'failure' | 'success' | 'skipped';
+export type PriorityTier = 'P0' | 'P1' | 'P2' | 'unlabeled';
+export type ScopeOrigin = 'requested' | 'dependency';
+export interface DependencyEvidence {
+    summary: string;
+    codebaseSignals?: string[];
+    backlogSignals?: string[];
+}
+export interface DependencyEdge {
+    sourceIssue: number;
+    targetIssue: number;
+    kind: DependencyKind;
+    confidence: DependencyConfidence;
+    evidence: DependencyEvidence;
+    blocking: boolean;
+}
+export interface SelectionReason {
+    kind: 'priority' | 'explicit_dependency' | 'inferred_dependency' | 'scope_expansion' | 'retry' | 'existing_work' | 'housekeeping' | 'blocked' | 'tie_break';
+    message: string;
+    confidence?: DependencyConfidence;
+    issueNumber?: number;
+}
+export interface TaskScoreBreakdown {
+    actionability: number;
+    retryResume: number;
+    priority: number;
+    dependencyHint: number;
+    existingWork: number;
+    issueNumber: number;
+    total: number;
+}
 export interface AgentConfig {
     model: LanguageModel;
     modelId?: string;
@@ -14,6 +48,7 @@ export interface AgentConfig {
     reviewMode?: ReviewMode;
     dryRun?: boolean;
     onStepUpdate?: (event: AgentStepEvent) => void;
+    onOrchestratorEvent?: (event: AgentOrchestratorEvent) => void;
     onProgress?: (toolName: string, line: string) => void;
 }
 export interface AgentStepEvent {
@@ -33,14 +68,92 @@ export interface AgentLogEntry {
     level: 'info' | 'warn' | 'error' | 'success';
 }
 export type AgentPhase = 'idle' | 'planning' | 'generating_spec' | 'running_loop' | 'reporting' | 'reflecting';
+export interface FeatureStateSummary {
+    recommendation?: string;
+    hasExistingBranch?: boolean;
+    commitsAhead?: number;
+    hasPlan?: boolean;
+    hasOpenPr?: boolean;
+}
 export interface AgentIssueState {
     issueNumber: number;
     title: string;
     labels: string[];
     phase: AgentPhase;
+    scopeOrigin?: ScopeOrigin;
+    requestedBy?: number[];
+    actionability?: TaskActionability;
+    priorityTier?: PriorityTier;
+    dependsOn?: number[];
+    inferredDependsOn?: Array<{
+        issueNumber: number;
+        confidence: DependencyConfidence;
+    }>;
+    blockedBy?: Array<{
+        issueNumber: number;
+        reason: string;
+        confidence?: DependencyConfidence;
+    }>;
+    recommendation?: string;
+    selectionReasons?: SelectionReason[];
+    score?: TaskScoreBreakdown;
+    attemptState?: AttemptState;
+    featureState?: FeatureStateSummary;
     loopPhase?: string;
     loopFeatureName?: string;
     loopIterations?: number;
     prUrl?: string;
     error?: string;
 }
+export interface BacklogCandidate extends AgentIssueState {
+    body: string;
+    createdAt: string;
+    explicitDependencyEdges: DependencyEdge[];
+    inferredDependencyEdges: DependencyEdge[];
+}
+export interface ScopeExpansion {
+    issueNumber: number;
+    requestedBy: number[];
+}
+export type AgentOrchestratorEvent = {
+    type: 'scope_expanded';
+    expansions: ScopeExpansion[];
+} | {
+    type: 'backlog_progress';
+    phase: 'listing' | 'scope_expansion' | 'hydration' | 'enrichment' | 'dependency_inference' | 'ranking';
+    message: string;
+    completed?: number;
+    total?: number;
+} | {
+    type: 'backlog_timing';
+    phase: 'listing' | 'scope_expansion' | 'hydration' | 'enrichment' | 'dependency_inference' | 'ranking';
+    durationMs: number;
+    count?: number;
+} | {
+    type: 'backlog_scanned';
+    total: number;
+    issues: AgentIssueState[];
+} | {
+    type: 'candidate_enriched';
+    issue: AgentIssueState;
+} | {
+    type: 'dependencies_inferred';
+    issueNumber: number;
+    edges: DependencyEdge[];
+} | {
+    type: 'queue_ranked';
+    queue: AgentIssueState[];
+} | {
+    type: 'task_selected';
+    issue: AgentIssueState;
+} | {
+    type: 'task_blocked';
+    issue: AgentIssueState;
+} | {
+    type: 'task_started';
+    issue: AgentIssueState;
+} | {
+    type: 'task_completed';
+    issue: AgentIssueState;
+    outcome: 'success' | 'partial' | 'failure' | 'skipped' | 'unknown';
+};

package/dist/ai/conversation/url-fetcher.js

@@ -24,25 +24,58 @@ export function isUrl(input) {
  * Simple extraction that removes scripts, styles, and HTML tags
  */
 function extractTextFromHtml(html) {
-    // Remove script and style tags with their content
-    let text = html
-        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
-        .replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, '');
+    // Remove script, style, and noscript blocks before generic tag stripping.
+    let text = stripElementBlocks(html, 'script');
+    text = stripElementBlocks(text, 'style');
+    text = stripElementBlocks(text, 'noscript');
     // Remove HTML tags but keep content
     text = text.replace(/<[^>]+>/g, ' ');
-    // Decode common HTML entities
-    text = text
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'");
+    // Decode only safe presentation entities; keep angle brackets encoded.
+    text = decodeSafeHtmlEntities(text);
     // Clean up whitespace
     text = text.replace(/\s+/g, ' ').trim();
     return text;
 }
+/**
+ * Remove full HTML element blocks (open tag + content + closing tag) using
+ * deterministic string scanning instead of regex.
+ */
+function stripElementBlocks(input, tagName) {
+    let output = input;
+    const openToken = `<${tagName}`;
+    const closeToken = `</${tagName}`;
+    while (true) {
+        const lower = output.toLowerCase();
+        const openStart = lower.indexOf(openToken);
+        if (openStart === -1) {
+            break;
+        }
+        const openEnd = lower.indexOf('>', openStart + openToken.length);
+        if (openEnd === -1) {
+            output = output.slice(0, openStart);
+            break;
+        }
+        const closeStart = lower.indexOf(closeToken, openEnd + 1);
+        if (closeStart === -1) {
+            output = output.slice(0, openStart);
+            break;
+        }
+        const closeEnd = lower.indexOf('>', closeStart + closeToken.length);
+        if (closeEnd === -1) {
+            output = output.slice(0, openStart);
+            break;
+        }
+        output = output.slice(0, openStart) + output.slice(closeEnd + 1);
+    }
+    return output;
+}
+/** Decode non-structural entities only (quotes/spaces), preserving `<`/`>`/`&`. */
+function decodeSafeHtmlEntities(input) {
+    return input
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/g, "'");
+}
 /**
  * Fetch content from a URL
  */

package/dist/ai/enhancer.js

@@ -102,11 +102,10 @@ export class AIEnhancer {
     async enhance(scanResult) {
         // Check if API key is available
         if (!this.isAvailable()) {
-            const envVar = this.getRequiredEnvVar();
             return {
                 ...scanResult,
                 aiEnhanced: false,
-                aiError: `API key not found. Set ${envVar} to enable AI enhancement.`,
+                aiError: 'API key not found. Configure credentials to enable AI enhancement.',
             };
         }
         try {

package/dist/ai/providers.js

@@ -100,11 +100,11 @@ export function hasApiKey(provider) {
  */
 function getApiKey(provider) {
     const envVar = API_KEY_ENV_VARS[provider];
-    const apiKey = process.env[envVar];
-    if (!apiKey) {
-        throw new Error(`API key not found. Set ${envVar} environment variable to use ${provider} provider.`);
+    const credential = process.env[envVar];
+    if (!credential) {
+        throw new Error(`API key not found for provider: ${provider}.`);
     }
-    return apiKey;
+    return credential;
 }
 /**
  * Get a configured AI model for the specified provider

package/dist/commands/agent.d.ts

@@ -14,5 +14,6 @@ export interface AgentOptions {
     reviewMode?: 'manual' | 'auto' | 'merge';
     dryRun?: boolean;
     stream?: boolean;
+    diagnoseGh?: boolean;
 }
 export declare function agentCommand(options?: AgentOptions): Promise<void>;

package/dist/commands/agent.js

@@ -9,8 +9,25 @@ import { logger } from '../utils/logger.js';
 import { createAgentOrchestrator, } from '../agent/orchestrator.js';
 import { resolveAgentEnv } from '../agent/resolve-config.js';
 import { initTracing, flushTracing, traced, currentSpan } from '../utils/tracing.js';
+import { detectGitHubRemote, runGitHubDiagnostics } from '../utils/github.js';
 export async function agentCommand(options = {}) {
     const projectRoot = process.cwd();
+    if (options.diagnoseGh) {
+        const repo = await detectGitHubRemote(projectRoot);
+        if (!repo) {
+            console.error('Error: No GitHub remote detected. Run this inside a git repo with an origin remote.');
+            process.exit(1);
+        }
+        const diagnostics = await runGitHubDiagnostics(repo.owner, repo.repo, options.issues);
+        for (const check of diagnostics.checks) {
+            const status = check.ok ? 'OK' : 'FAIL';
+            console.log(`[diagnose-gh] ${status} ${check.name}: ${check.message}`);
+        }
+        if (!diagnostics.success) {
+            process.exit(1);
+        }
+        return;
+    }
     // Initialize Braintrust tracing (no-op if BRAINTRUST_API_KEY not set)
     initTracing();
     // Resolve provider, model, and GitHub remote
@@ -19,7 +36,7 @@ export async function agentCommand(options = {}) {
         env = await resolveAgentEnv(projectRoot, { model: options.model });
     }
     catch (err) {
-        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        logger.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
         process.exit(1);
     }
     const { provider, model, modelId, owner, repo } = env;
@@ -51,6 +68,38 @@ export async function agentCommand(options = {}) {
                 log(`[tool:done] ${tr.toolName} → ${summary}`);
             }
         },
+        onOrchestratorEvent: (event) => {
+            const log = options.stream
+                ? (msg) => process.stdout.write(`${msg}\n`)
+                : (msg) => logger.info(msg);
+            switch (event.type) {
+                case 'scope_expanded':
+                    log(`[orchestrator] expanded scope with ${event.expansions.map(expansion => `#${expansion.issueNumber}`).join(', ')}`);
+                    break;
+                case 'backlog_progress':
+                    log(`[orchestrator] ${event.message}`);
+                    break;
+                case 'backlog_timing':
+                    log(`[orchestrator] ${event.phase} took ${event.durationMs}ms${event.count != null ? ` (${event.count})` : ''}`);
+                    break;
+                case 'queue_ranked':
+                    log(`[orchestrator] ranked ${event.queue.length} issue(s)`);
+                    break;
+                case 'task_selected': {
+                    const reason = event.issue.selectionReasons?.[0]?.message;
+                    log(`[orchestrator] selected #${event.issue.issueNumber}${reason ? ` — ${reason}` : ''}`);
+                    break;
+                }
+                case 'task_blocked':
+                    log(`[orchestrator] blocked #${event.issue.issueNumber} — ${event.issue.blockedBy?.[0]?.reason ?? event.issue.actionability ?? 'blocked'}`);
+                    break;
+                case 'task_completed':
+                    log(`[orchestrator] completed #${event.issue.issueNumber} (${event.outcome})`);
+                    break;
+                default:
+                    break;
+            }
+        },
         onProgress: (toolName, line) => {
             const log = options.stream
                 ? (msg) => process.stdout.write(`${msg}\n`)
@@ -107,6 +156,9 @@ export async function agentCommand(options = {}) {
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         console.error(`Error: Agent failed — ${message}`);
+        if (message.includes('GitHub') || message.includes('gh ')) {
+            console.error(`Hint: run 'wiggum agent --diagnose-gh${options.issues?.length ? ` --issues ${options.issues.join(',')}` : ''}' to inspect GitHub connectivity.`);
+        }
         process.exit(1);
     }
     finally {

package/dist/commands/config.js

@@ -9,6 +9,7 @@ import { logger } from '../utils/logger.js';
 import { simpson } from '../utils/colors.js';
 import { getAvailableProvider, AVAILABLE_MODELS } from '../ai/providers.js';
 import { writeKeysToEnvFile } from '../utils/env.js';
+import { loadConfigWithDefaults } from '../utils/config.js';
 /**
  * Supported services for API key configuration
  */
@@ -26,6 +27,11 @@ const CONFIGURABLE_SERVICES = {
         description: 'AI tracing and analytics',
     },
 };
+const LOOP_CLI_SETTINGS = ['cli', 'review-cli'];
+const LOOP_CLI_VALUES = ['claude', 'codex'];
+const DEFAULT_CLAUDE_IMPL_MODEL = 'sonnet';
+const DEFAULT_CLAUDE_REVIEW_MODEL = 'opus';
+const DEFAULT_CODEX_MODEL = 'gpt-5.3-codex';
 /**
  * Check if a service API key is configured
  */
@@ -45,6 +51,69 @@ function saveKeyToEnvLocal(projectRoot, envVar, value) {
     const envLocalPath = path.join(ralphDir, '.env.local');
     writeKeysToEnvFile(envLocalPath, { [envVar]: value });
 }
+function toConfigFileContent(config) {
+    const content = `module.exports = ${JSON.stringify(config, null, 2)};
+`;
+    return content
+        .replace(/"(\w+)":/g, '$1:')
+        .replace(/: "([^"]+)"/g, ": '$1'");
+}
+function normalizeLoopCliSetting(raw) {
+    if (raw === 'cli')
+        return 'cli';
+    if (raw === 'review-cli' || raw === 'reviewCli')
+        return 'review-cli';
+    return null;
+}
+function isLoopCliValue(value) {
+    return LOOP_CLI_VALUES.includes(value);
+}
+function reconcileLoopModelsForCliSelection(loop, codingCli, reviewCli) {
+    let defaultModel = loop.defaultModel;
+    let planningModel = loop.planningModel;
+    const usesClaude = codingCli === 'claude' || reviewCli === 'claude';
+    const codexOnly = codingCli === 'codex' && reviewCli === 'codex';
+    if (usesClaude) {
+        if (defaultModel === DEFAULT_CODEX_MODEL) {
+            defaultModel = DEFAULT_CLAUDE_IMPL_MODEL;
+        }
+        if (planningModel === DEFAULT_CODEX_MODEL) {
+            planningModel = DEFAULT_CLAUDE_REVIEW_MODEL;
+        }
+    }
+    else if (codexOnly) {
+        if (defaultModel === DEFAULT_CLAUDE_IMPL_MODEL) {
+            defaultModel = DEFAULT_CODEX_MODEL;
+        }
+        if (planningModel === DEFAULT_CLAUDE_REVIEW_MODEL) {
+            planningModel = DEFAULT_CODEX_MODEL;
+        }
+    }
+    return { defaultModel, planningModel };
+}
+async function saveLoopCliToConfig(projectRoot, setting, value) {
+    // Check that .ralph/ exists (project is initialized)
+    const ralphDir = path.join(projectRoot, '.ralph');
+    if (!fs.existsSync(ralphDir) || !fs.statSync(ralphDir).isDirectory()) {
+        throw new Error('This project is not initialized. Run \'wiggum init\' before using loop CLI settings.');
+    }
+    const configPath = path.join(projectRoot, 'ralph.config.cjs');
+    const config = await loadConfigWithDefaults(projectRoot);
+    const nextCodingCli = setting === 'cli' ? value : config.loop.codingCli;
+    const nextReviewCli = setting === 'review-cli' ? value : config.loop.reviewCli;
+    const { defaultModel, planningModel } = reconcileLoopModelsForCliSelection(config.loop, nextCodingCli, nextReviewCli);
+    const nextConfig = {
+        ...config,
+        loop: {
+            ...config.loop,
+            defaultModel,
+            planningModel,
+            codingCli: nextCodingCli,
+            reviewCli: nextReviewCli,
+        },
+    };
+    fs.writeFileSync(configPath, toConfigFileContent(nextConfig), 'utf-8');
+}
 /**
  * Display current configuration status
  */
@@ -75,6 +144,8 @@ function displayConfigStatus(state) {
     console.log(`  ${simpson.yellow('/config set tavily')} ${pc.dim('<api-key>')}`);
     console.log(`  ${simpson.yellow('/config set context7')} ${pc.dim('<api-key>')}`);
     console.log(`  ${simpson.yellow('/config set braintrust')} ${pc.dim('<api-key>')}`);
+    console.log(`  ${simpson.yellow('/config set cli')} ${pc.dim('<claude|codex>')}`);
+    console.log(`  ${simpson.yellow('/config set review-cli')} ${pc.dim('<claude|codex>')}`);
     console.log('');
 }
 /**
@@ -93,17 +164,37 @@ export async function handleConfigCommand(args, state) {
     }
     // /config set <service> <key>
     if (args.length < 3) {
-        logger.error('Usage: /config set <service> <api-key>');
+        logger.error('Usage: /config set <service> <value>');
         console.log('');
         console.log('Available services:');
         for (const [service, config] of Object.entries(CONFIGURABLE_SERVICES)) {
             console.log(`  ${service.padEnd(12)} ${pc.dim(config.description)}`);
         }
+        for (const setting of LOOP_CLI_SETTINGS) {
+            console.log(`  ${setting.padEnd(12)} ${pc.dim('Loop CLI setting')}`);
+        }
         console.log('');
         return state;
     }
-    const service = args[1]?.toLowerCase();
-    const apiKey = args[2];
+    const rawService = args[1]?.toLowerCase() ?? '';
+    const value = args[2];
+    const loopCliSetting = normalizeLoopCliSetting(rawService);
+    if (loopCliSetting) {
+        if (!isLoopCliValue(value)) {
+            logger.error(`Invalid ${loopCliSetting} value: '${value}'. Allowed values: ${LOOP_CLI_VALUES.join(', ')}`);
+            return state;
+        }
+        try {
+            await saveLoopCliToConfig(state.projectRoot, loopCliSetting, value);
+            logger.success(`${loopCliSetting} saved to ralph.config.cjs (${value})`);
+            console.log('');
+        }
+        catch (error) {
+            logger.error(`Failed to save ${loopCliSetting}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return state;
+    }
+    const service = rawService;
     if (!(service in CONFIGURABLE_SERVICES)) {
         logger.error(`Unknown service: ${service}`);
         console.log('');
@@ -111,20 +202,23 @@ export async function handleConfigCommand(args, state) {
         for (const [svc, config] of Object.entries(CONFIGURABLE_SERVICES)) {
             console.log(`  ${svc.padEnd(12)} ${pc.dim(config.description)}`);
         }
+        for (const setting of LOOP_CLI_SETTINGS) {
+            console.log(`  ${setting.padEnd(12)} ${pc.dim('Loop CLI setting')}`);
+        }
         console.log('');
         return state;
     }
     const { envVar } = CONFIGURABLE_SERVICES[service];
     // Validate API key format (basic check)
-    if (!apiKey || apiKey.length < 10) {
+    if (!value || value.length < 10) {
         logger.error('Invalid API key. Key appears too short.');
         return state;
     }
     try {
         // Save to .env.local
-        saveKeyToEnvLocal(state.projectRoot, envVar, apiKey);
+        saveKeyToEnvLocal(state.projectRoot, envVar, value);
         // Also set in current process environment
-        process.env[envVar] = apiKey;
+        process.env[envVar] = value;
         logger.success(`${envVar} saved to .ralph/.env.local`);
         console.log(pc.dim('Restart Wiggum to apply changes to tool availability.'));
         console.log('');

package/dist/commands/run.d.ts

@@ -6,6 +6,8 @@ export interface RunOptions {
     worktree?: boolean;
     resume?: boolean;
     model?: string;
+    cli?: 'claude' | 'codex';
+    reviewCli?: 'claude' | 'codex';
     maxIterations?: number;
     maxE2eAttempts?: number;
     reviewMode?: 'manual' | 'auto' | 'merge';