@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/priority.js

@@ -132,10 +132,23 @@ function computeHumanCurve(input, weights) {
 }
 /**
  * Cκ — Calibration Coefficient [0.7, 1.3].
- * A tuning knob that lets operators scale the final score up or down.
+ *
+ * Category-scoped (RFC-0008 §10 Amendment 6) when `categoryResolver`
+ * and `categoryCoefficients` are both present: resolver returns a
+ * category label, coefficient is looked up, scalar fallback applies
+ * when the category has no entry. Otherwise uses the scalar path
+ * unchanged.
  */
-function computeCalibration(config) {
-    const coeff = config?.calibrationCoefficient ?? 1.0;
+function computeCalibration(input, config) {
+    let coeff = config?.calibrationCoefficient ?? 1.0;
+    const resolver = config?.categoryResolver;
+    const table = config?.categoryCoefficients;
+    if (resolver && table) {
+        const category = resolver(input);
+        if (category && table[category] !== undefined) {
+            coeff = table[category];
+        }
+    }
     return clamp(coeff, CALIBRATION_MIN, CALIBRATION_MAX);
 }
 // ── Confidence ──────────────────────────────────────────────────────
@@ -143,7 +156,7 @@ function computeCalibration(config) {
  * Compute a confidence score [0, 1] based on the fraction of optional
  * input fields that were explicitly provided (not defaulted).
  */
-function computeConfidence(input) {
+export function computeConfidence(input) {
     let provided = 0;
     for (const field of SCORABLE_FIELDS) {
         if (input[field] !== undefined) {
@@ -194,7 +207,7 @@ export function computePriority(input, config) {
     const executionReality = computeExecutionReality(input);
     const entropyTax = computeEntropyTax(input);
     const humanCurve = computeHumanCurve(input, hcWeights);
-    const calibration = computeCalibration(config);
+    const calibration = computeCalibration(input, config);
     // ── Composite ─────────────────────────────────────────────────
     const composite = soulAlignment *
         demandPressure *

package/dist/review-meta.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Meta-review pass — filters medium-confidence findings through a
+ * lightweight LLM call (Haiku) to reduce false positives.
+ *
+ * Flow:
+ *   High confidence (>0.8)  → post directly
+ *   Medium (0.5-0.8)        → meta-review decides keep/drop
+ *   Low (<0.5)              → already suppressed by parseVerdict()
+ */
+import type { ReviewVerdict, ReviewFinding } from './runners/review-agent.js';
+export interface MetaReviewDecision {
+    keep: boolean;
+    adjustedSeverity?: ReviewFinding['severity'];
+    reason: string;
+}
+export interface MetaReviewResult {
+    /** The filtered verdict with medium-confidence findings reviewed. */
+    verdict: ReviewVerdict;
+    /** Decisions for each medium-confidence finding. */
+    decisions: Array<{
+        finding: ReviewFinding;
+        decision: MetaReviewDecision;
+    }>;
+    /** Count of findings suppressed by meta-review. */
+    suppressed: number;
+}
+/**
+ * Run a meta-review pass on medium-confidence findings.
+ *
+ * @param verdict - The original verdict from a review agent
+ * @param principles - Review principles text for context
+ * @param callLLM - Function to make a single-turn LLM call (injectable for testing)
+ */
+export declare function metaReview(verdict: ReviewVerdict, principles: string, callLLM: (prompt: string) => Promise<string>): Promise<MetaReviewResult>;
+export interface ReviewFeedback {
+    /** PR number. */
+    prNumber: number;
+    /** Finding that was posted. */
+    finding: ReviewFinding;
+    /** Human response. */
+    signal: 'accepted' | 'dismissed' | 'ignored';
+    /** Timestamp. */
+    timestamp: string;
+}
+/**
+ * Store for tracking human feedback on review findings.
+ * Used to calibrate confidence thresholds over time.
+ */
+export declare class ReviewFeedbackStore {
+    private entries;
+    record(feedback: ReviewFeedback): void;
+    /** Get all feedback entries. */
+    getAll(): ReviewFeedback[];
+    /** Get precision: accepted / (accepted + dismissed). */
+    precision(): number;
+    /** Get feedback by category. */
+    byCategory(): Record<string, {
+        accepted: number;
+        dismissed: number;
+        ignored: number;
+    }>;
+    /** Categories with high false-positive rate (dismissed > 50%). */
+    highFalsePositiveCategories(): string[];
+}
+//# sourceMappingURL=review-meta.d.ts.map

package/dist/review-meta.js

@@ -0,0 +1,149 @@
+/**
+ * Meta-review pass — filters medium-confidence findings through a
+ * lightweight LLM call (Haiku) to reduce false positives.
+ *
+ * Flow:
+ *   High confidence (>0.8)  → post directly
+ *   Medium (0.5-0.8)        → meta-review decides keep/drop
+ *   Low (<0.5)              → already suppressed by parseVerdict()
+ */
+// ── Thresholds ───────────────────────────────────────────────────────
+const HIGH_CONFIDENCE = 0.8;
+// ── Meta-reviewer ────────────────────────────────────────────────────
+/**
+ * Run a meta-review pass on medium-confidence findings.
+ *
+ * @param verdict - The original verdict from a review agent
+ * @param principles - Review principles text for context
+ * @param callLLM - Function to make a single-turn LLM call (injectable for testing)
+ */
+export async function metaReview(verdict, principles, callLLM) {
+    const highConfidence = [];
+    const mediumConfidence = [];
+    for (const finding of verdict.findings) {
+        const conf = finding.confidence ?? 1.0; // legacy findings without confidence pass through
+        if (conf >= HIGH_CONFIDENCE) {
+            highConfidence.push(finding);
+        }
+        else {
+            mediumConfidence.push(finding);
+        }
+    }
+    // If no medium-confidence findings, return as-is
+    if (mediumConfidence.length === 0) {
+        return {
+            verdict,
+            decisions: [],
+            suppressed: 0,
+        };
+    }
+    // Review each medium-confidence finding
+    const decisions = [];
+    const kept = [...highConfidence];
+    for (const finding of mediumConfidence) {
+        try {
+            const decision = await reviewSingleFinding(finding, principles, callLLM);
+            decisions.push({ finding, decision });
+            if (decision.keep) {
+                kept.push({
+                    ...finding,
+                    severity: decision.adjustedSeverity ?? finding.severity,
+                });
+            }
+        }
+        catch {
+            // Meta-review failure = keep the finding (conservative)
+            kept.push(finding);
+            decisions.push({
+                finding,
+                decision: { keep: true, reason: 'Meta-review failed, keeping conservatively' },
+            });
+        }
+    }
+    return {
+        verdict: {
+            ...verdict,
+            findings: kept,
+            // If all findings were suppressed, approve
+            approved: kept.length === 0 ? true : verdict.approved,
+        },
+        decisions,
+        suppressed: Math.max(0, mediumConfidence.length - (kept.length - highConfidence.length)),
+    };
+}
+async function reviewSingleFinding(finding, principles, callLLM) {
+    const prompt = `You are a meta-reviewer evaluating whether a code review finding should be posted to a pull request.
+
+## Review Principles
+${principles}
+
+## Finding to evaluate
+- Severity: ${finding.severity}
+- Confidence: ${finding.confidence}
+- Category: ${finding.category ?? 'unknown'}
+- File: ${finding.file ?? 'N/A'}
+- Message: ${finding.message}
+${finding.evidence?.failureScenario ? `- Failure scenario: ${finding.evidence.failureScenario}` : '- No failure scenario provided'}
+${finding.evidence?.codePathTraced ? `- Code path: ${finding.evidence.codePathTraced}` : ''}
+
+## Decision criteria
+- Is this a real issue or noise?
+- Does the evidence support the severity?
+- Would a senior engineer flag this?
+- Is this something CI already catches?
+
+Respond with ONLY a JSON object:
+{"keep": true/false, "adjustedSeverity": "critical|major|minor|suggestion" (optional), "reason": "brief explanation"}`;
+    const response = await callLLM(prompt);
+    // Parse response
+    const cleaned = response.replace(/^```(?:json)?\s*/m, '').replace(/\s*```$/m, '');
+    const parsed = JSON.parse(cleaned);
+    return {
+        keep: Boolean(parsed.keep),
+        adjustedSeverity: parsed.adjustedSeverity ?? undefined,
+        reason: String(parsed.reason ?? ''),
+    };
+}
+/**
+ * Store for tracking human feedback on review findings.
+ * Used to calibrate confidence thresholds over time.
+ */
+export class ReviewFeedbackStore {
+    entries = [];
+    record(feedback) {
+        this.entries.push(feedback);
+    }
+    /** Get all feedback entries. */
+    getAll() {
+        return [...this.entries];
+    }
+    /** Get precision: accepted / (accepted + dismissed). */
+    precision() {
+        const accepted = this.entries.filter((e) => e.signal === 'accepted').length;
+        const dismissed = this.entries.filter((e) => e.signal === 'dismissed').length;
+        const total = accepted + dismissed;
+        return total === 0 ? 1.0 : accepted / total;
+    }
+    /** Get feedback by category. */
+    byCategory() {
+        const result = {};
+        for (const entry of this.entries) {
+            const cat = entry.finding.category ?? 'other';
+            if (!result[cat])
+                result[cat] = { accepted: 0, dismissed: 0, ignored: 0 };
+            result[cat][entry.signal]++;
+        }
+        return result;
+    }
+    /** Categories with high false-positive rate (dismissed > 50%). */
+    highFalsePositiveCategories() {
+        const cats = this.byCategory();
+        return Object.entries(cats)
+            .filter(([, v]) => {
+            const total = v.accepted + v.dismissed;
+            return total >= 3 && v.dismissed / total > 0.5;
+        })
+            .map(([k]) => k);
+    }
+}
+//# sourceMappingURL=review-meta.js.map

package/dist/review.d.ts

@@ -0,0 +1,35 @@
+/**
+ * PR Review orchestrator — thin wrapper around ReviewAgentRunner
+ * that handles context assembly and verdict extraction.
+ */
+import { ReviewAgentRunner, type ReviewType, type ReviewVerdict, type ReviewAgentConfig } from './runners/review-agent.js';
+import type { Logger } from './logger.js';
+export interface ReviewContext {
+    issueTitle: string;
+    issueBody: string;
+    acceptanceCriteria?: string;
+}
+export interface ReviewOptions {
+    /** Anthropic API config overrides. */
+    apiConfig?: Omit<ReviewAgentConfig, 'reviewType'>;
+    /** Logger for diagnostic output. */
+    logger?: Logger;
+    /** Inject runner for testing. */
+    runner?: ReviewAgentRunner;
+    /** Review principles text for meta-review context. */
+    principles?: string;
+    /** LLM caller for meta-review pass. If provided, medium-confidence findings are filtered. */
+    metaReviewLLM?: (prompt: string) => Promise<string>;
+}
+/**
+ * Execute a single review agent against a PR diff.
+ *
+ * @param prNumber - PR number (for logging/identification)
+ * @param diff - The full PR diff text
+ * @param reviewType - Which review perspective (testing, critic, security)
+ * @param context - Issue context for the review
+ * @param options - Optional configuration overrides
+ * @returns Review verdict with findings
+ */
+export declare function executeReview(prNumber: number, diff: string, reviewType: ReviewType, context: ReviewContext, options?: ReviewOptions): Promise<ReviewVerdict>;
+//# sourceMappingURL=review.d.ts.map

package/dist/review.js

@@ -0,0 +1,84 @@
+/**
+ * PR Review orchestrator — thin wrapper around ReviewAgentRunner
+ * that handles context assembly and verdict extraction.
+ */
+import { ReviewAgentRunner, } from './runners/review-agent.js';
+import { metaReview } from './review-meta.js';
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Execute a single review agent against a PR diff.
+ *
+ * @param prNumber - PR number (for logging/identification)
+ * @param diff - The full PR diff text
+ * @param reviewType - Which review perspective (testing, critic, security)
+ * @param context - Issue context for the review
+ * @param options - Optional configuration overrides
+ * @returns Review verdict with findings
+ */
+export async function executeReview(prNumber, diff, reviewType, context, options) {
+    const logger = options?.logger;
+    logger?.info?.(`Starting ${reviewType} review for PR #${prNumber}`);
+    const runner = options?.runner ??
+        new ReviewAgentRunner({
+            ...options?.apiConfig,
+            reviewType,
+        });
+    const result = await runner.run({
+        issueId: `PR-${prNumber}`,
+        issueNumber: prNumber,
+        issueTitle: context.issueTitle,
+        issueBody: diff,
+        workDir: '',
+        branch: '',
+        constraints: {
+            maxFilesPerChange: 0,
+            requireTests: false,
+            blockedPaths: [],
+        },
+        // Reuse ciErrors field for acceptance criteria
+        ciErrors: context.acceptanceCriteria,
+    });
+    if (!result.success) {
+        logger?.error?.(`${reviewType} review failed: ${result.error}`);
+        return {
+            type: reviewType,
+            approved: false,
+            findings: [
+                {
+                    severity: 'critical',
+                    message: `Review agent failed: ${result.error ?? 'unknown error'}`,
+                },
+            ],
+            summary: `${reviewType} review could not be completed`,
+        };
+    }
+    try {
+        let verdict = JSON.parse(result.summary);
+        verdict = { ...verdict, type: reviewType };
+        // Run meta-review on medium-confidence findings if LLM caller provided
+        if (options?.metaReviewLLM && options?.principles) {
+            const metaResult = await metaReview(verdict, options.principles, options.metaReviewLLM);
+            if (metaResult.suppressed > 0) {
+                logger?.info?.(`${reviewType} meta-review: ${metaResult.suppressed} finding(s) suppressed`);
+            }
+            verdict = metaResult.verdict;
+        }
+        logger?.info?.(`${reviewType} review complete: ${verdict.approved ? 'APPROVED' : 'CHANGES REQUESTED'} (${verdict.findings.length} findings)`);
+        return verdict;
+    }
+    catch {
+        logger?.error?.(`Failed to parse ${reviewType} verdict from runner output`);
+        return {
+            type: reviewType,
+            approved: false,
+            findings: [
+                {
+                    severity: 'critical',
+                    message: 'Failed to parse review verdict from runner output',
+                },
+            ],
+            summary: `${reviewType} review verdict was not valid JSON`,
+        };
+    }
+}
+//# sourceMappingURL=review.js.map

package/dist/runners/claude-code-sdk.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Claude Code SDK runner — invokes Claude Code via the Agent SDK's query() API
+ * instead of spawning a CLI subprocess.
+ *
+ * Advantages over ClaudeCodeRunner:
+ * - maxBudgetUsd / maxTurns — hard limits enforced by the engine
+ * - allowedTools / disallowedTools — fine-grained tool filtering with glob patterns
+ * - appendSystemPrompt — inject governance without replacing Claude Code defaults
+ * - Structured NDJSON messages — no stdout parsing
+ */
+import type { AgentRunner, AgentContext, AgentResult } from './types.js';
+/**
+ * Map agent-role tool names to SDK-compatible tool filter patterns.
+ */
+/** @internal Exported for testing. */
+export declare function mapToolsToSdkFormat(allowedTools?: string[]): string[] | undefined;
+/**
+ * Build tool deny-list from blocked actions.
+ * Converts blockedActions glob patterns to SDK disallowedTools format.
+ */
+/** @internal Exported for testing. */
+export declare function mapBlockedActionsToSdkDenyList(blockedActions?: string[]): string[];
+/**
+ * Build governance system prompt appendix from constraints.
+ */
+/** @internal Exported for testing. */
+export declare function buildGovernancePrompt(ctx: AgentContext): string;
+export declare class ClaudeCodeSdkRunner implements AgentRunner {
+    run(ctx: AgentContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=claude-code-sdk.d.ts.map

package/dist/runners/claude-code-sdk.js

@@ -0,0 +1,238 @@
+/**
+ * Claude Code SDK runner — invokes Claude Code via the Agent SDK's query() API
+ * instead of spawning a CLI subprocess.
+ *
+ * Advantages over ClaudeCodeRunner:
+ * - maxBudgetUsd / maxTurns — hard limits enforced by the engine
+ * - allowedTools / disallowedTools — fine-grained tool filtering with glob patterns
+ * - appendSystemPrompt — inject governance without replacing Claude Code defaults
+ * - Structured NDJSON messages — no stdout parsing
+ */
+import { buildPrompt } from './claude-code.js';
+import { detectChangedFiles, gitExec, runAutoFix, snapshotWorktree } from './git-utils.js';
+import { DEFAULT_MODEL, DEFAULT_ALLOWED_TOOLS, DEFAULT_LINT_COMMAND, DEFAULT_FORMAT_COMMAND, DEFAULT_COMMIT_MESSAGE_TEMPLATE, DEFAULT_COMMIT_CO_AUTHOR, } from '../defaults.js';
+/** Default budget cap per agent run. */
+const DEFAULT_MAX_BUDGET_USD = 5.0;
+/** Default turn limit per agent run. */
+const DEFAULT_MAX_TURNS = 100;
+/**
+ * Map agent-role tool names to SDK-compatible tool filter patterns.
+ */
+/** @internal Exported for testing. */
+export function mapToolsToSdkFormat(allowedTools) {
+    if (!allowedTools)
+        return undefined;
+    // SDK accepts tool names directly or glob patterns like Bash(git:*)
+    return allowedTools;
+}
+/**
+ * Build tool deny-list from blocked actions.
+ * Converts blockedActions glob patterns to SDK disallowedTools format.
+ */
+/** @internal Exported for testing. */
+export function mapBlockedActionsToSdkDenyList(blockedActions) {
+    if (!blockedActions || blockedActions.length === 0)
+        return [];
+    // Map each blocked action pattern to a Bash() deny rule
+    return blockedActions.map((pattern) => `Bash(${pattern})`);
+}
+/**
+ * Build governance system prompt appendix from constraints.
+ */
+/** @internal Exported for testing. */
+export function buildGovernancePrompt(ctx) {
+    const lines = ['## AI-SDLC Governance Constraints\n'];
+    if (ctx.constraints.blockedPaths.length > 0) {
+        lines.push(`Blocked paths (do NOT modify): ${ctx.constraints.blockedPaths.join(', ')}`);
+    }
+    if (ctx.constraints.blockedActions && ctx.constraints.blockedActions.length > 0) {
+        lines.push(`Blocked actions (NEVER execute): ${ctx.constraints.blockedActions.map((a) => `\`${a}\``).join(', ')}`);
+    }
+    lines.push(`Max files per change: ${ctx.constraints.maxFilesPerChange}`);
+    if (ctx.constraints.requireTests) {
+        lines.push('Tests required: every new module must have tests.');
+    }
+    lines.push('');
+    lines.push('**NEVER merge PRs. Only humans merge.**');
+    return lines.join('\n');
+}
+export class ClaudeCodeSdkRunner {
+    async run(ctx) {
+        // Dynamic import — SDK is an optional peer dependency
+        let query;
+        /* v8 ignore start — dynamic import fails in unit tests (SDK not installed) */
+        try {
+            const sdk = await import('@anthropic-ai/claude-agent-sdk');
+            query = sdk.query;
+        }
+        catch {
+            return {
+                success: false,
+                filesChanged: [],
+                summary: '',
+                error: '@anthropic-ai/claude-agent-sdk is not installed. Install it to use the SDK runner: pnpm add @anthropic-ai/claude-agent-sdk',
+            };
+        }
+        /* v8 ignore stop */
+        const prompt = buildPrompt(ctx);
+        const model = ctx.model ?? DEFAULT_MODEL;
+        const maxTurns = ctx.constraints.maxTurns ?? DEFAULT_MAX_TURNS;
+        const maxBudgetUsd = ctx.constraints.maxBudgetUsd ?? DEFAULT_MAX_BUDGET_USD;
+        const allowedTools = mapToolsToSdkFormat(ctx.allowedTools ?? DEFAULT_ALLOWED_TOOLS.split(','));
+        const disallowedTools = mapBlockedActionsToSdkDenyList(ctx.constraints.blockedActions);
+        const governancePrompt = buildGovernancePrompt(ctx);
+        let summary = '';
+        let tokenUsage;
+        // Capture worktree state before invoking the agent so untracked noise
+        // doesn't get swept into the eventual `git add`.
+        const baseline = await snapshotWorktree(ctx.workDir);
+        /* v8 ignore start — SDK streaming loop requires real SDK connection */
+        try {
+            const result = query({
+                prompt,
+                options: {
+                    model,
+                    maxTurns,
+                    maxBudgetUsd,
+                    appendSystemPrompt: governancePrompt,
+                    allowedTools,
+                    disallowedTools: disallowedTools.length > 0 ? disallowedTools : undefined,
+                    permissionMode: 'acceptEdits',
+                    cwd: ctx.workDir,
+                },
+            });
+            for await (const msg of result) {
+                const msgType = msg.type;
+                // Emit progress events
+                if (msgType === 'assistant' && ctx.onProgress) {
+                    const blocks = msg.message?.content;
+                    if (blocks) {
+                        for (const block of blocks) {
+                            if (block.type === 'tool_use') {
+                                ctx.onProgress({
+                                    type: 'tool_start',
+                                    tool: block.name,
+                                    message: `${block.name}`,
+                                });
+                            }
+                            else if (block.type === 'text') {
+                                summary = (block.text ?? '').slice(0, 2000);
+                            }
+                        }
+                    }
+                }
+                // Parse result event for token usage and cost
+                if (msgType === 'result') {
+                    const usage = msg.usage;
+                    const resultModel = msg.model ?? model;
+                    if (usage) {
+                        tokenUsage = {
+                            inputTokens: usage.input_tokens ?? 0,
+                            outputTokens: usage.output_tokens ?? 0,
+                            cacheReadTokens: usage.cache_read_input_tokens,
+                            model: resultModel,
+                        };
+                    }
+                    if (ctx.onProgress) {
+                        ctx.onProgress({
+                            type: 'cost',
+                            costUsd: msg.cost_usd,
+                        });
+                    }
+                    // Check exit reason
+                    const subtype = msg.subtype;
+                    if (subtype === 'error_max_turns') {
+                        return {
+                            success: false,
+                            filesChanged: [],
+                            summary: `Agent hit turn limit (${maxTurns})`,
+                            error: `Max turns (${maxTurns}) exceeded`,
+                            tokenUsage,
+                        };
+                    }
+                    if (subtype === 'error_max_budget_usd') {
+                        return {
+                            success: false,
+                            filesChanged: [],
+                            summary: `Agent hit budget limit ($${maxBudgetUsd})`,
+                            error: `Max budget ($${maxBudgetUsd}) exceeded`,
+                            tokenUsage,
+                        };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            return {
+                success: false,
+                filesChanged: [],
+                summary: '',
+                error: `SDK runner error: ${err.message}`,
+                tokenUsage,
+            };
+        }
+        /* v8 ignore stop */
+        /* v8 ignore start — post-SDK commit/lint logic only runs when SDK succeeds */
+        // Detect changed files (same logic as ClaudeCodeRunner), excluding any
+        // untracked noise that pre-existed the agent invocation.
+        const { filesChanged, agentAlreadyCommitted } = await detectChangedFiles(ctx.workDir, baseline);
+        if (filesChanged.length === 0) {
+            return {
+                success: false,
+                filesChanged: [],
+                summary: 'Agent made no changes',
+                error: 'No files were modified',
+                tokenUsage,
+            };
+        }
+        if (agentAlreadyCommitted) {
+            return {
+                success: true,
+                filesChanged,
+                summary,
+                tokenUsage,
+            };
+        }
+        // Stage only the files the agent touched (NOT `git add -A` — the
+        // AISDLC-68 incident showed `add -A` sweeps in pre-existing untracked
+        // noise like sqlite working files and unrelated draft files).
+        await gitExec(ctx.workDir, ['add', '--', ...filesChanged]);
+        const lintCmd = ctx.lintCommand ?? DEFAULT_LINT_COMMAND;
+        const fmtCmd = ctx.formatCommand ?? DEFAULT_FORMAT_COMMAND;
+        await runAutoFix(ctx.workDir, lintCmd, fmtCmd);
+        await gitExec(ctx.workDir, ['add', '--', ...filesChanged]);
+        const tmpl = ctx.commitMessageTemplate ?? DEFAULT_COMMIT_MESSAGE_TEMPLATE;
+        const coAuthor = ctx.commitCoAuthor ?? DEFAULT_COMMIT_CO_AUTHOR;
+        const commitMsg = tmpl
+            .replace(/\{issueNumber\}/g, ctx.issueId)
+            .replace(/\{issueTitle\}/g, ctx.issueTitle);
+        try {
+            await gitExec(ctx.workDir, ['commit', '-m', `${commitMsg}\n\nCo-Authored-By: ${coAuthor}`]);
+        }
+        catch {
+            // Pre-commit hook failure — auto-fix and retry once
+            await runAutoFix(ctx.workDir, lintCmd, fmtCmd);
+            await gitExec(ctx.workDir, ['add', '--', ...filesChanged]);
+            try {
+                await gitExec(ctx.workDir, ['commit', '-m', `${commitMsg}\n\nCo-Authored-By: ${coAuthor}`]);
+            }
+            catch (retryErr) {
+                return {
+                    success: false,
+                    filesChanged,
+                    summary,
+                    error: `Commit failed after auto-fix retry: ${retryErr.message}`,
+                    tokenUsage,
+                };
+            }
+        }
+        return {
+            success: true,
+            filesChanged,
+            summary,
+            tokenUsage,
+        };
+        /* v8 ignore stop */
+    }
+}
+//# sourceMappingURL=claude-code-sdk.js.map

package/dist/runners/claude-code.d.ts

@@ -9,6 +9,9 @@ export declare function buildPrompt(ctx: AgentContext): string;
  * Claude Code CLI outputs token info to stderr in various formats.
  */
 export declare function parseTokenUsage(stderr: string, model: string): TokenUsage | undefined;
+/**
+ * Run lint --fix and format commands (best-effort) so pre-commit hooks pass.
+ */
 export declare class ClaudeCodeRunner implements AgentRunner {
     run(ctx: AgentContext): Promise<AgentResult>;
 }