wiggum-cli 0.17.3 → 0.18.3

package/dist/tui/app.js

@@ -55,9 +55,18 @@ interviewProps, runProps, agentProps, onComplete, onExit, }) {
     const columns = stdout?.columns ?? 80;
     const rows = stdout?.rows ?? 24;
     const compact = rows < 20 || columns < 60;
+    const agentModelOverride = currentScreen === 'agent'
+        ? (typeof screenProps?.modelOverride === 'string' ? screenProps.modelOverride : agentProps?.modelOverride)
+        : undefined;
+    const agentProviderOverride = currentScreen === 'agent'
+        ? (sessionState.config?.agent.defaultProvider || sessionState.provider || undefined)
+        : undefined;
+    const effectiveAgentModel = currentScreen === 'agent'
+        ? (agentModelOverride || sessionState.config?.agent.defaultModel || sessionState.model)
+        : undefined;
     // Shared header element - includes columns/rows in deps so the
     // header subtree re-renders on terminal resize (banner auto-compacts)
-    const headerElement = useMemo(() => (_jsx(HeaderContent, { version: version, sessionState: sessionState, backgroundRuns: backgroundRuns, compact: compact })), [version, sessionState, backgroundRuns, compact, columns, rows]);
+    const headerElement = useMemo(() => (_jsx(HeaderContent, { version: version, sessionState: sessionState, providerOverride: agentProviderOverride, modelOverride: effectiveAgentModel, backgroundRuns: backgroundRuns, compact: compact })), [version, sessionState, agentProviderOverride, effectiveAgentModel, backgroundRuns, compact, columns, rows]);
     /**
      * Navigate to a different screen
      */

package/dist/tui/components/HeaderContent.d.ts

@@ -15,6 +15,9 @@ export interface HeaderContentProps {
     version: string;
     /** Current session state */
     sessionState: SessionState;
+    /** Optional provider/model display overrides for screen-specific modes */
+    providerOverride?: string;
+    modelOverride?: string;
     /** Background runs (only active ones are displayed) */
     backgroundRuns?: BackgroundRun[];
     /** Use compact banner for small terminals */
@@ -25,4 +28,4 @@ export interface HeaderContentProps {
  *
  * Renders the banner and status row for the AppShell header zone.
  */
-export declare function HeaderContent({ version, sessionState, backgroundRuns, compact, }: HeaderContentProps): React.ReactElement;
+export declare function HeaderContent({ version, sessionState, providerOverride, modelOverride, backgroundRuns, compact, }: HeaderContentProps): React.ReactElement;

package/dist/tui/components/HeaderContent.js

@@ -7,10 +7,12 @@ import { colors, theme } from '../theme.js';
  *
  * Renders the banner and status row for the AppShell header zone.
  */
-export function HeaderContent({ version, sessionState, backgroundRuns, compact = false, }) {
+export function HeaderContent({ version, sessionState, providerOverride, modelOverride, backgroundRuns, compact = false, }) {
     const activeRuns = backgroundRuns?.filter((r) => !r.completed && !r.pollError) ?? [];
     const errorRuns = backgroundRuns?.filter((r) => r.pollError) ?? [];
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(WiggumBanner, { compact: compact }), _jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: colors.pink, children: ["v", version] }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), sessionState.provider ? (_jsxs(Text, { color: colors.blue, children: [sessionState.provider, "/", sessionState.model] })) : (_jsx(Text, { color: colors.orange, children: "not configured" })), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsx(Text, { color: sessionState.initialized ? colors.green : colors.orange, children: sessionState.initialized ? 'Ready' : 'Not initialized' }), activeRuns.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsxs(Text, { color: colors.green, children: [theme.chars.bulletLarge, " ", activeRuns[0].featureName, activeRuns[0].lastStatus.iteration > 0
+    const provider = providerOverride || sessionState.provider;
+    const model = modelOverride || sessionState.model;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(WiggumBanner, { compact: compact }), _jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: colors.pink, children: ["v", version] }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), provider ? (_jsxs(Text, { color: colors.blue, children: [provider, "/", model] })) : (_jsx(Text, { color: colors.orange, children: "not configured" })), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsx(Text, { color: sessionState.initialized ? colors.green : colors.orange, children: sessionState.initialized ? 'Ready' : 'Not initialized' }), activeRuns.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsxs(Text, { color: colors.green, children: [theme.chars.bulletLarge, " ", activeRuns[0].featureName, activeRuns[0].lastStatus.iteration > 0
                                         ? ` (${activeRuns[0].lastStatus.iteration}/${activeRuns[0].lastStatus.maxIterations || '?'})`
                                         : ''] }), activeRuns.length > 1 && (_jsxs(Text, { dimColor: true, children: [" +", activeRuns.length - 1, " more"] }))] })), errorRuns.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsxs(Text, { color: colors.orange, children: [theme.chars.bullet, " ", errorRuns[0].featureName, " (status unknown)"] })] }))] })] }));
 }

package/dist/tui/hooks/useAgentOrchestrator.d.ts

@@ -6,7 +6,7 @@
  * calls into structured state (active issue, queue, completed, log).
  * Exposes an abort() function for clean shutdown on q/Esc.
  */
-import type { AgentIssueState, AgentLogEntry, ReviewMode } from '../../agent/types.js';
+import type { AgentOrchestratorEvent, AgentIssueState, AgentLogEntry, ReviewMode } from '../../agent/types.js';
 import { type LoopStatus, type TaskCounts, type ActivityEvent } from '../utils/loop-status.js';
 import { type CommitLogEntry } from '../utils/git-summary.js';
 export type AgentStatus = 'idle' | 'running' | 'complete' | 'error';
@@ -38,4 +38,5 @@ export interface UseAgentOrchestratorResult {
     error: string | null;
     abort: () => void;
 }
+export declare function applyOrchestratorEvent(event: AgentOrchestratorEvent, setActiveIssue: React.Dispatch<React.SetStateAction<AgentIssueState | null>>, setQueue: React.Dispatch<React.SetStateAction<AgentIssueState[]>>, setCompleted: React.Dispatch<React.SetStateAction<AgentIssueState[]>>, setLogEntries: React.Dispatch<React.SetStateAction<AgentLogEntry[]>>, completedIssuesRef: React.MutableRefObject<Set<number>>): void;
 export declare function useAgentOrchestrator(options: UseAgentOrchestratorOptions): UseAgentOrchestratorResult;

package/dist/tui/hooks/useAgentOrchestrator.js

@@ -27,11 +27,16 @@ function appendLog(prev, message, level = 'info') {
     }
     return next;
 }
+function shouldReopenCompletedIssue(issue) {
+    return issue.recommendation === 'resume_pr_phase'
+        || issue.recommendation === 'pr_merged'
+        || issue.recommendation === 'linked_pr_merged';
+}
 /**
  * Interpret a tool call name and extract relevant info from args/results
  * to drive TUI state transitions.
  */
-function interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLogEntries, pollingRef, stopLoopPolling, ranLoopRef, activeIssueRef, issueNumberFilter) {
+function interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLogEntries, pollingRef, stopLoopPolling, ranLoopRef, activeIssueRef) {
     // If a new tool call arrives while polling, the runLoop tool has finished — stop polling
     for (const tc of event.toolCalls) {
         if (tc.toolName !== 'runLoop' && pollingRef.current) {
@@ -188,15 +193,6 @@ function interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLo
                 break;
         }
     }
-    // Detect whether listIssues was called with a label filter (e.g. P0 check)
-    // so we don't overwrite the queue with a filtered subset.
-    const listIssuesHasLabelFilter = event.toolCalls.some((tc) => {
-        if (tc.toolName !== 'listIssues')
-            return false;
-        const args = tc.args;
-        const labels = args?.labels;
-        return Array.isArray(labels) && labels.length > 0;
-    });
     // Process tool results for additional state updates
     for (const tr of event.toolResults) {
         const result = tr.result;
@@ -204,35 +200,10 @@ function interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLo
             case 'listIssues': {
                 const issues = (result?.issues ?? result);
                 if (Array.isArray(issues)) {
-                    // Only update queue from unfiltered listIssues calls (full backlog scan).
-                    // Filtered calls (e.g. labels: ["bug"]) are P0/blocker checks — not the backlog.
-                    if (!listIssuesHasLabelFilter) {
-                        // When --issues is configured, defensively filter queue to only those issues
-                        // (the tool should already filter, but this guards against edge cases)
-                        const relevantIssues = issueNumberFilter
-                            ? issues.filter(i => issueNumberFilter.has((i.number ?? i.issueNumber)))
-                            : issues;
-                        const queueItems = relevantIssues.map((issue) => ({
-                            issueNumber: (issue.number ?? issue.issueNumber),
-                            title: issue.title ?? `Issue #${issue.number ?? issue.issueNumber}`,
-                            labels: Array.isArray(issue.labels) ? issue.labels : [],
-                            phase: 'idle',
-                        }));
-                        setQueue(queueItems);
-                    }
                     setLogEntries((prev) => appendLog(prev, `Found ${issues.length} issue(s) in backlog`));
                 }
                 break;
             }
-            case 'readIssue': {
-                // Update queue entry titles from full issue data (agent reads many issues during triage)
-                const issueNumber = (result?.number ?? result?.issueNumber);
-                const title = result?.title;
-                if (issueNumber && title) {
-                    setQueue((prev) => prev.map((i) => i.issueNumber === issueNumber ? { ...i, title } : i));
-                }
-                break;
-            }
             case 'checkLoopStatus': {
                 const iteration = (result?.iteration ?? result?.currentIteration);
                 if (iteration != null) {
@@ -245,6 +216,78 @@ function interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLo
         }
     }
 }
+export function applyOrchestratorEvent(event, setActiveIssue, setQueue, setCompleted, setLogEntries, completedIssuesRef) {
+    switch (event.type) {
+        case 'scope_expanded':
+            setLogEntries((prev) => appendLog(prev, `Expanded scope with ${event.expansions.map(expansion => `#${expansion.issueNumber}`).join(', ')}`));
+            break;
+        case 'backlog_progress':
+            setLogEntries((prev) => appendLog(prev, event.message));
+            break;
+        case 'backlog_timing':
+            setLogEntries((prev) => appendLog(prev, `${event.phase} took ${event.durationMs}ms${event.count != null ? ` (${event.count})` : ''}`));
+            break;
+        case 'backlog_scanned':
+            setLogEntries((prev) => appendLog(prev, `Scanned ${event.total} backlog issue(s)`));
+            break;
+        case 'candidate_enriched':
+            setLogEntries((prev) => appendLog(prev, `Enriched #${event.issue.issueNumber}: ${event.issue.title}`));
+            break;
+        case 'dependencies_inferred':
+            if (event.edges.length > 0) {
+                setLogEntries((prev) => appendLog(prev, `Inferred ${event.edges.length} dependency edge(s) for #${event.issueNumber}`));
+            }
+            break;
+        case 'queue_ranked':
+            {
+                const resumedIssueNumbers = new Set(event.queue
+                    .filter(shouldReopenCompletedIssue)
+                    .map(issue => issue.issueNumber));
+                if (resumedIssueNumbers.size > 0) {
+                    for (const issueNumber of resumedIssueNumbers) {
+                        completedIssuesRef.current.delete(issueNumber);
+                    }
+                    setCompleted((prev) => prev.filter((issue) => !resumedIssueNumbers.has(issue.issueNumber)));
+                }
+                setQueue(event.queue.filter((issue) => !completedIssuesRef.current.has(issue.issueNumber)));
+            }
+            break;
+        case 'task_selected':
+            completedIssuesRef.current.delete(event.issue.issueNumber);
+            setCompleted((prev) => prev.filter((issue) => issue.issueNumber !== event.issue.issueNumber));
+            setActiveIssue({ ...event.issue, phase: 'planning' });
+            setQueue((prev) => prev.filter((issue) => issue.issueNumber !== event.issue.issueNumber));
+            setLogEntries((prev) => appendLog(prev, `Selected #${event.issue.issueNumber}: ${event.issue.title}`));
+            break;
+        case 'task_blocked':
+            setLogEntries((prev) => appendLog(prev, `Blocked #${event.issue.issueNumber}: ${event.issue.blockedBy?.[0]?.reason ?? event.issue.actionability ?? 'blocked'}`, 'warn'));
+            break;
+        case 'task_started':
+            setActiveIssue((prev) => ({ ...(prev ?? event.issue), ...event.issue }));
+            setLogEntries((prev) => appendLog(prev, `Started #${event.issue.issueNumber}`));
+            break;
+        case 'task_completed':
+            setCompleted((prev) => {
+                const filtered = prev.filter((issue) => issue.issueNumber !== event.issue.issueNumber);
+                return [...filtered, {
+                        ...event.issue,
+                        error: event.outcome === 'failure' ? 'failed' : event.issue.error,
+                    }];
+            });
+            if (event.outcome === 'success' || event.outcome === 'skipped') {
+                completedIssuesRef.current.add(event.issue.issueNumber);
+            }
+            else {
+                completedIssuesRef.current.delete(event.issue.issueNumber);
+            }
+            setQueue((prev) => prev.filter((issue) => issue.issueNumber !== event.issue.issueNumber));
+            setActiveIssue((prev) => prev?.issueNumber === event.issue.issueNumber ? null : prev);
+            setLogEntries((prev) => appendLog(prev, `${event.outcome === 'failure' ? 'Failed' : event.outcome === 'partial' ? 'Paused' : 'Completed'} #${event.issue.issueNumber} (${event.outcome})`, event.outcome === 'failure' ? 'error' : event.outcome === 'partial' ? 'warn' : 'success'));
+            break;
+        default:
+            break;
+    }
+}
 export function useAgentOrchestrator(options) {
     const [status, setStatus] = useState('idle');
     const [activeIssue, setActiveIssue] = useState(null);
@@ -258,6 +301,7 @@ export function useAgentOrchestrator(options) {
     const pollingRef = useRef(null);
     const ranLoopRef = useRef(new Set());
     const activeIssueRef = useRef(null);
+    const completedIssuesRef = useRef(new Set());
     // Keep ref in sync for use inside polling callback
     useEffect(() => { activeIssueRef.current = activeIssue; }, [activeIssue]);
     const stopLoopPolling = useCallback(() => {
@@ -380,9 +424,6 @@ export function useAgentOrchestrator(options) {
                     model: options.modelOverride,
                 });
                 setLogEntries((prev) => appendLog(prev, `Using ${env.provider}/${env.modelId ?? 'default'} on ${env.owner}/${env.repo}`));
-                const issueFilter = options.issues?.length
-                    ? new Set(options.issues)
-                    : undefined;
                 const agentConfig = {
                     model: env.model,
                     modelId: env.modelId,
@@ -397,7 +438,10 @@ export function useAgentOrchestrator(options) {
                     reviewMode: options.reviewMode,
                     dryRun: options.dryRun,
                     onStepUpdate: (event) => {
-                        interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLogEntries, pollingRef, stopLoopPolling, ranLoopRef, activeIssueRef, issueFilter);
+                        interpretToolCalls(event, setActiveIssue, setQueue, setCompleted, setLogEntries, pollingRef, stopLoopPolling, ranLoopRef, activeIssueRef);
+                    },
+                    onOrchestratorEvent: (event) => {
+                        applyOrchestratorEvent(event, setActiveIssue, setQueue, setCompleted, setLogEntries, completedIssuesRef);
                     },
                     onProgress: (toolName, line) => {
                         // Detect generateSpec execution start (onStepFinish fires too late)

package/dist/tui/screens/AgentScreen.js

@@ -82,7 +82,9 @@ function SectionSeparator({ width }) {
  * Issues panel content — shared between wide and narrow layouts
  */
 function IssuesPanel({ activeIssue, queue, completed, panelWidth, }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: colors.yellow, children: "Active Issue" }), activeIssue ? (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [_jsxs(Text, { children: [_jsxs(Text, { color: colors.blue, children: ["#", activeIssue.issueNumber] }), _jsxs(Text, { children: [" ", activeIssue.title] })] }), _jsxs(Text, { dimColor: true, children: [phase.active, " ", phaseLabel(activeIssue.phase, activeIssue), activeIssue.loopIterations != null ? ` (iter ${activeIssue.loopIterations})` : ''] })] })) : (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { dimColor: true, children: "No active issue" }) })), _jsx(SectionSeparator, { width: panelWidth }), _jsxs(Text, { bold: true, color: colors.yellow, children: ["Queue", _jsxs(Text, { dimColor: true, children: [" (", queue.length, ")"] })] }), queue.length === 0 ? (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { dimColor: true, children: "Empty" }) })) : (queue.slice(0, 5).map((issue) => (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["#", issue.issueNumber] }), _jsxs(Text, { children: [" ", issue.title] })] }) }, issue.issueNumber)))), queue.length > 5 && (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { dimColor: true, children: ["...and ", queue.length - 5, " more"] }) })), _jsx(SectionSeparator, { width: panelWidth }), _jsxs(Text, { bold: true, color: colors.yellow, children: ["Completed", _jsxs(Text, { dimColor: true, children: [" (", completed.length, ")"] })] }), completed.length === 0 ? (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { dimColor: true, children: "None yet" }) })) : (completed.slice(-5).map((issue) => (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: issue.error ? colors.pink : colors.green, children: issue.error ? phase.error : phase.complete }), _jsxs(Text, { dimColor: true, children: [" #", issue.issueNumber] }), _jsxs(Text, { children: [" ", issue.title] })] }), issue.prUrl && (_jsxs(Text, { dimColor: true, children: ["  \\u2514 PR: ", issue.prUrl] }))] }, issue.issueNumber))))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: colors.yellow, children: "Active Issue" }), activeIssue ? (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [_jsxs(Text, { children: [_jsxs(Text, { color: colors.blue, children: ["#", activeIssue.issueNumber] }), _jsxs(Text, { children: [" ", activeIssue.title] })] }), _jsxs(Text, { dimColor: true, children: [phase.active, " ", phaseLabel(activeIssue.phase, activeIssue), activeIssue.loopIterations != null ? ` (iter ${activeIssue.loopIterations})` : ''] })] })) : (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { dimColor: true, children: "No active issue" }) })), _jsx(SectionSeparator, { width: panelWidth }), _jsxs(Text, { bold: true, color: colors.yellow, children: ["Queue", _jsxs(Text, { dimColor: true, children: [" (", queue.length, ")"] })] }), queue.length === 0 ? (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { dimColor: true, children: "Empty" }) })) : (queue.slice(0, 5).map((issue) => (_jsxs(Box, { marginLeft: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: ["#", issue.issueNumber] }), _jsxs(Text, { children: [" ", issue.title] })] }), (issue.actionability || issue.recommendation || issue.dependsOn?.length || issue.inferredDependsOn?.length) && (_jsxs(Text, { dimColor: true, children: [issue.scopeOrigin === 'dependency' && issue.requestedBy?.length
+                                ? `dependency for ${issue.requestedBy.map(n => `#${n}`).join(', ')} · `
+                                : '', issue.actionability ?? 'ready', issue.recommendation ? ` · ${issue.recommendation}` : '', issue.dependsOn?.length ? ` · explicit: ${issue.dependsOn.map(n => `#${n}`).join(', ')}` : '', issue.inferredDependsOn?.length ? ` · inferred: ${issue.inferredDependsOn.map(dep => `#${dep.issueNumber} (${dep.confidence})`).join(', ')}` : ''] })), issue.blockedBy?.length ? (_jsxs(Text, { color: colors.orange, children: ["  blocked: ", issue.blockedBy[0].reason] })) : null] }, issue.issueNumber)))), queue.length > 5 && (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { dimColor: true, children: ["...and ", queue.length - 5, " more"] }) })), _jsx(SectionSeparator, { width: panelWidth }), _jsxs(Text, { bold: true, color: colors.yellow, children: ["Completed", _jsxs(Text, { dimColor: true, children: [" (", completed.length, ")"] })] }), completed.length === 0 ? (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { dimColor: true, children: "None yet" }) })) : (completed.slice(-5).map((issue) => (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: issue.error ? colors.pink : colors.green, children: issue.error ? phase.error : phase.complete }), _jsxs(Text, { dimColor: true, children: [" #", issue.issueNumber] }), _jsxs(Text, { children: [" ", issue.title] })] }), issue.prUrl && (_jsxs(Text, { dimColor: true, children: ["  \\u2514 PR: ", issue.prUrl] }))] }, issue.issueNumber))))] }));
 }
 /**
  * Log panel content — shared between wide and narrow layouts.

package/dist/tui/utils/polishGoal.js

@@ -72,6 +72,19 @@ function normalizeWhitespace(text) {
 function looksLikeAbbreviation(fragment) {
     return /^(e\.g|i\.e|etc|vs|mr|mrs|dr|prof|no|vol|fig|ch|approx|est)$/i.test(fragment.trim());
 }
+/** Remove trailing sentence punctuation without regex backtracking. */
+function stripTrailingSentencePunctuation(text) {
+    let end = text.length;
+    while (end > 0) {
+        const char = text.charCodeAt(end - 1);
+        if (char === 46 || char === 33 || char === 63) { // . ! ?
+            end -= 1;
+            continue;
+        }
+        break;
+    }
+    return text.slice(0, end);
+}
 /**
  * Enforce single-sentence: split conservatively on `. ` boundaries, skipping
  * abbreviation-like fragments, then return only the first sentence.
@@ -155,7 +168,7 @@ export function polishGoalSentence(text) {
     // 4. Single-sentence enforcement
     result = toOneSentence(result);
     // Strip any trailing sentence-ending punctuation before we add our own
-    result = result.replace(/[.!?]+$/, '').trim();
+    result = stripTrailingSentencePunctuation(result).trim();
     // 5. Imperative verb enforcement
     if (!IMPERATIVE_VERB_PATTERN.test(result)) {
         // Lowercase first char before prepending to avoid "Implement The thing"

package/dist/utils/env.js

@@ -77,7 +77,13 @@ export function writeKeysToEnvFile(filePath, keys) {
             envContent = envContent.trimEnd() + (envContent ? '\n' : '') + `${envVar}=${value}\n`;
         }
     }
-    fs.writeFileSync(filePath, envContent);
+    fs.writeFileSync(filePath, envContent, { mode: 0o600 });
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch {
+        // Best-effort hardening; ignore chmod failures on unusual filesystems.
+    }
 }
 /**
  * Load known AI provider API keys from .ralph/.env.local into process.env.

package/dist/utils/github.d.ts

@@ -1,9 +1,12 @@
 export declare function isGhInstalled(): Promise<boolean>;
 export declare function _resetGhCache(): void;
 export interface GitHubIssueDetail {
+    number: number;
     title: string;
     body: string;
     labels: string[];
+    state: 'open' | 'closed';
+    createdAt: string;
 }
 export declare function fetchGitHubIssue(owner: string, repo: string, number: number): Promise<GitHubIssueDetail | null>;
 export interface GitHubIssueListItem {
@@ -17,7 +20,17 @@ export interface ListIssuesResult {
     issues: GitHubIssueListItem[];
     error?: string;
 }
+export interface GitHubDiagnosticCheck {
+    name: string;
+    ok: boolean;
+    message: string;
+}
+export interface GitHubDiagnostics {
+    success: boolean;
+    checks: GitHubDiagnosticCheck[];
+}
 export declare function listRepoIssues(owner: string, repo: string, search?: string, limit?: number): Promise<ListIssuesResult>;
+export declare function runGitHubDiagnostics(owner: string, repo: string, issueNumbers?: number[]): Promise<GitHubDiagnostics>;
 export declare function detectGitHubRemote(projectRoot: string): Promise<GitHubRepo | null>;
 export interface ParsedGitHubIssue {
     owner: string;

package/dist/utils/github.js

@@ -12,6 +12,29 @@ function safeExec(cmd, args, cwd) {
         });
     });
 }
+function shouldRetryGhError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes('error connecting to api.github.com')
+        || message.includes('Client.Timeout exceeded')
+        || message.includes('i/o timeout')
+        || message.includes('TLS handshake timeout');
+}
+async function safeExecWithRetry(cmd, args, cwd, attempts = 3) {
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return await safeExec(cmd, args, cwd);
+        }
+        catch (error) {
+            lastError = error;
+            const canRetry = cmd === 'gh' && attempt < attempts && shouldRetryGhError(error);
+            if (!canRetry)
+                break;
+            await new Promise(resolve => setTimeout(resolve, 200 * attempt));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
 let ghInstalledCache = null;
 export async function isGhInstalled() {
     if (ghInstalledCache !== null)
@@ -30,16 +53,19 @@ export function _resetGhCache() {
 }
 export async function fetchGitHubIssue(owner, repo, number) {
     try {
-        const stdout = await safeExec('gh', [
+        const stdout = await safeExecWithRetry('gh', [
             'issue', 'view', String(number),
             '--repo', `${owner}/${repo}`,
-            '--json', 'title,body,labels',
+            '--json', 'number,title,body,labels,state,createdAt',
         ]);
         const data = JSON.parse(stdout);
         return {
+            number: data.number ?? number,
             title: data.title ?? '',
             body: data.body ?? '',
             labels: (data.labels ?? []).map((l) => l.name),
+            state: data.state?.toLowerCase?.() === 'closed' ? 'closed' : 'open',
+            createdAt: data.createdAt ?? '',
         };
     }
     catch {
@@ -58,7 +84,7 @@ export async function listRepoIssues(owner, repo, search, limit = 20) {
         if (search) {
             args.push('--search', search);
         }
-        const stdout = await safeExec('gh', args);
+        const stdout = await safeExecWithRetry('gh', args);
         const data = JSON.parse(stdout);
         const issues = data.map((item) => ({
             number: item.number,
@@ -74,8 +100,41 @@ export async function listRepoIssues(owner, repo, search, limit = 20) {
         if (msg.includes('auth') || msg.includes('login') || msg.includes('not logged')) {
             return { issues: [], error: 'Run "gh auth login" to enable issue browsing' };
         }
-        return { issues: [] };
+        return { issues: [], error: `GitHub issue listing failed: ${msg}` };
+    }
+}
+async function runDiagnosticCheck(name, cmd, args) {
+    try {
+        await safeExecWithRetry(cmd, args);
+        return { name, ok: true, message: 'ok' };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { name, ok: false, message };
+    }
+}
+export async function runGitHubDiagnostics(owner, repo, issueNumbers) {
+    const checks = [];
+    checks.push(await runDiagnosticCheck('gh version', 'gh', ['--version']));
+    checks.push(await runDiagnosticCheck('gh auth status', 'gh', ['auth', 'status']));
+    checks.push(await runDiagnosticCheck('gh issue list', 'gh', [
+        'issue', 'list',
+        '--repo', `${owner}/${repo}`,
+        '--limit', '1',
+        '--state', 'open',
+        '--json', 'number',
+    ]));
+    for (const issueNumber of issueNumbers ?? []) {
+        checks.push(await runDiagnosticCheck(`gh issue view #${issueNumber}`, 'gh', [
+            'issue', 'view', String(issueNumber),
+            '--repo', `${owner}/${repo}`,
+            '--json', 'number,title',
+        ]));
     }
+    return {
+        success: checks.every(check => check.ok),
+        checks,
+    };
 }
 export async function detectGitHubRemote(projectRoot) {
     try {

package/dist/utils/logger.js

@@ -13,7 +13,7 @@ export const logger = {
         console.log(pc.yellow('warn'), message);
     },
     error(message) {
-        console.log(pc.red('error'), message);
+        process.stderr.write(`${pc.red('error')} ${message}\n`);
     },
     debug(message) {
         if (process.env.DEBUG) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wiggum-cli",
-  "version": "0.17.3",
-  "description": "AI-powered feature development loop CLI",
+  "version": "0.18.3",
+  "description": "AI agent CLI for spec-driven feature loops with Claude Code and Codex",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -29,15 +29,17 @@
     "cli",
     "ai-agent",
     "autonomous-coding",
-    "ralph-loop",
     "spec-generation",
+    "feature-specs",
+    "feature-loop",
+    "backlog-automation",
     "claude-code",
     "codex",
-    "ai-coding",
-    "feature-loop",
-    "code-generation",
     "developer-tools",
-    "tech-stack-detection"
+    "terminal-ui",
+    "tech-stack-detection",
+    "ralph-loop",
+    "typescript"
   ],
   "repository": {
     "type": "git",