@kody-ade/kody-engine-lite 0.1.63 → 0.1.65

package/dist/retrospective.js

@@ -0,0 +1,211 @@
+import * as fs from "fs";
+import * as path from "path";
+import { STAGES } from "./definitions.js";
+import { resolveModel } from "./context.js";
+import { getRunnerForStage } from "./pipeline/runner-selection.js";
+import { logger } from "./logger.js";
+// ─── Prompt ─────────────────────────────────────────────────────────────────
+const RETROSPECTIVE_PROMPT = `You are a pipeline retrospective analyst. You observe automated software development pipeline runs and identify flaws, patterns, and improvement opportunities.
+
+Output ONLY valid JSON. No markdown fences. No explanation.
+
+{
+  "observation": "One paragraph: what happened in this run, what went well, what went wrong",
+  "patternMatch": "If this matches a pattern seen in previous runs, describe the pattern. Otherwise null",
+  "suggestion": "One specific, actionable change to improve pipeline reliability or efficiency",
+  "pipelineFlaw": {
+    "component": "pipeline component name (e.g., verify, build, autofix, taskify prompt, review prompt, model selection, timeout config)",
+    "issue": "concise description of the flaw",
+    "evidence": "specific data from this run that supports this conclusion"
+  }
+}
+
+If no pipeline flaw is detected, set "pipelineFlaw" to null.
+
+`;
+// ─── Context Collection ─────────────────────────────────────────────────────
+function readArtifact(taskDir, filename, maxChars) {
+    const p = path.join(taskDir, filename);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const content = fs.readFileSync(p, "utf-8");
+        return content.length > maxChars
+            ? content.slice(0, maxChars) + "\n...(truncated)"
+            : content;
+    }
+    catch {
+        return null;
+    }
+}
+function computeStageDuration(stage) {
+    if (!stage.startedAt)
+        return undefined;
+    const end = stage.completedAt ?? new Date().toISOString();
+    return new Date(end).getTime() - new Date(stage.startedAt).getTime();
+}
+export function collectRunContext(ctx, state, pipelineStartTime) {
+    const durationMs = Date.now() - pipelineStartTime;
+    const lines = [];
+    lines.push(`## This Run`);
+    lines.push(`Task: ${state.taskId}`);
+    lines.push(`Outcome: ${state.state}`);
+    lines.push(`Duration: ${durationMs}ms (${Math.round(durationMs / 1000)}s)`);
+    lines.push(`Mode: ${ctx.input.mode}`);
+    lines.push(``);
+    // Stage results
+    lines.push(`### Stage Results`);
+    let failedStage;
+    for (const def of STAGES) {
+        const s = state.stages[def.name];
+        const duration = computeStageDuration(s);
+        const durationStr = duration != null ? `, ${duration}ms` : "";
+        const errorStr = s.error ? ` — ${s.error}` : "";
+        lines.push(`${def.name}: ${s.state} (${s.retries} retries${durationStr})${errorStr}`);
+        if (s.state === "failed" || s.state === "timeout") {
+            failedStage = def.name;
+        }
+    }
+    lines.push(``);
+    // Artifacts summary (truncated)
+    const artifacts = [
+        ["task.md", 300],
+        ["task.json", 500],
+        ["plan.md", 500],
+        ["verify.md", 800],
+        ["review.md", 500],
+        ["ship.md", 300],
+    ];
+    lines.push(`### Artifacts`);
+    for (const [filename, maxChars] of artifacts) {
+        const content = readArtifact(ctx.taskDir, filename, maxChars);
+        if (content) {
+            lines.push(`#### ${filename}`);
+            lines.push(content);
+            lines.push(``);
+        }
+    }
+    return lines.join("\n");
+}
+// ─── Previous Retrospectives ────────────────────────────────────────────────
+function getLogPath(projectDir) {
+    return path.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+}
+export function readPreviousRetrospectives(projectDir, limit = 10) {
+    const logPath = getLogPath(projectDir);
+    if (!fs.existsSync(logPath))
+        return [];
+    try {
+        const content = fs.readFileSync(logPath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const entries = [];
+        // Take last N lines
+        const start = Math.max(0, lines.length - limit);
+        for (let i = start; i < lines.length; i++) {
+            try {
+                entries.push(JSON.parse(lines[i]));
+            }
+            catch {
+                // Skip corrupt lines
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+function formatPreviousEntries(entries) {
+    if (entries.length === 0)
+        return "No previous runs recorded.";
+    return entries.map((e) => {
+        const failed = e.failedStage ? ` at ${e.failedStage}` : "";
+        const pattern = e.patternMatch ? `Pattern: ${e.patternMatch}` : "Pattern: none";
+        const flaw = e.pipelineFlaw ? ` | Flaw: ${e.pipelineFlaw.component} — ${e.pipelineFlaw.issue}` : "";
+        return `[${e.timestamp.slice(0, 10)}] ${e.taskId}: ${e.outcome}${failed} — "${e.observation.slice(0, 120)}"\n  ${pattern} | Suggestion: "${e.suggestion}"${flaw}`;
+    }).join("\n");
+}
+// ─── Append ─────────────────────────────────────────────────────────────────
+export function appendRetrospectiveEntry(projectDir, entry) {
+    const logPath = getLogPath(projectDir);
+    const dir = path.dirname(logPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+}
+// ─── Main ───────────────────────────────────────────────────────────────────
+export async function runRetrospective(ctx, state, pipelineStartTime) {
+    if (ctx.input.dryRun)
+        return;
+    try {
+        const durationMs = Date.now() - pipelineStartTime;
+        const runContext = collectRunContext(ctx, state, pipelineStartTime);
+        const previous = readPreviousRetrospectives(ctx.projectDir);
+        const previousText = formatPreviousEntries(previous);
+        const prompt = RETROSPECTIVE_PROMPT
+            + `## Run Context\n${runContext}\n\n`
+            + `## Previous Retrospectives (last ${previous.length} runs)\n${previousText}\n`;
+        const runner = getRunnerForStage(ctx, "taskify");
+        const model = resolveModel("cheap");
+        const result = await runner.run("retrospective", prompt, model, 30_000, "");
+        let observation = "Retrospective analysis unavailable";
+        let patternMatch = null;
+        let suggestion = "No suggestion";
+        let pipelineFlaw = null;
+        if (result.outcome === "completed" && result.output) {
+            const cleaned = result.output
+                .replace(/^```json\s*\n?/m, "")
+                .replace(/\n?```\s*$/m, "")
+                .trim();
+            try {
+                const parsed = JSON.parse(cleaned);
+                observation = parsed.observation ?? observation;
+                patternMatch = parsed.patternMatch ?? null;
+                suggestion = parsed.suggestion ?? suggestion;
+                if (parsed.pipelineFlaw && parsed.pipelineFlaw.component) {
+                    pipelineFlaw = {
+                        component: parsed.pipelineFlaw.component,
+                        issue: parsed.pipelineFlaw.issue ?? "Unknown",
+                        evidence: parsed.pipelineFlaw.evidence ?? "",
+                    };
+                }
+            }
+            catch {
+                logger.warn("  Retrospective: failed to parse LLM output");
+            }
+        }
+        // Build deterministic fields
+        const stageResults = {};
+        let failedStage;
+        for (const def of STAGES) {
+            const s = state.stages[def.name];
+            stageResults[def.name] = {
+                state: s.state,
+                retries: s.retries,
+                durationMs: computeStageDuration(s),
+                error: s.error,
+            };
+            if (s.state === "failed" || s.state === "timeout") {
+                failedStage = def.name;
+            }
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            taskId: state.taskId,
+            outcome: state.state === "completed" ? "completed" : "failed",
+            durationMs,
+            stageResults,
+            failedStage,
+            observation,
+            patternMatch,
+            suggestion,
+            pipelineFlaw,
+        };
+        appendRetrospectiveEntry(ctx.projectDir, entry);
+        logger.info(`Retrospective: ${observation.slice(0, 120)}`);
+    }
+    catch (err) {
+        logger.warn(`Retrospective failed: ${err instanceof Error ? err.message : err}`);
+    }
+}

package/dist/stages/agent.d.ts

@@ -0,0 +1,2 @@
+import type { StageDefinition, StageResult, PipelineContext } from "../types.js";
+export declare function executeAgentStage(ctx: PipelineContext, def: StageDefinition): Promise<StageResult>;

package/dist/stages/agent.js

@@ -0,0 +1,94 @@
+import * as fs from "fs";
+import * as path from "path";
+import { buildFullPrompt, resolveModel } from "../context.js";
+import { validateTaskJson, validatePlanMd, validateReviewMd, stripFences } from "../validators.js";
+import { getProjectConfig } from "../config.js";
+import { getRunnerForStage } from "../pipeline/runner-selection.js";
+import { logger } from "../logger.js";
+function validateStageOutput(stageName, content) {
+    switch (stageName) {
+        case "taskify":
+            return validateTaskJson(content);
+        case "plan":
+            return validatePlanMd(content);
+        case "review":
+            return validateReviewMd(content);
+        default:
+            return { valid: true };
+    }
+}
+export async function executeAgentStage(ctx, def) {
+    if (ctx.input.dryRun) {
+        logger.info(`  [dry-run] skipping ${def.name}`);
+        return { outcome: "completed", retries: 0 };
+    }
+    const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
+    const model = resolveModel(def.modelTier, def.name);
+    const config = getProjectConfig();
+    const runnerName = config.agent.stageRunners?.[def.name] ??
+        config.agent.defaultRunner ??
+        Object.keys(ctx.runners)[0] ?? "claude";
+    logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1000}s`);
+    const extraEnv = {};
+    if (config.agent.litellmUrl) {
+        extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
+    }
+    const runner = getRunnerForStage(ctx, def.name);
+    const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+        cwd: ctx.projectDir,
+        env: extraEnv,
+    });
+    if (result.outcome !== "completed") {
+        return { outcome: result.outcome, error: result.error, retries: 0 };
+    }
+    if (def.outputFile && result.output) {
+        fs.writeFileSync(path.join(ctx.taskDir, def.outputFile), result.output);
+    }
+    // Variant file detection: if expected file missing, look for <base>-*<ext> variants
+    if (def.outputFile) {
+        const outputPath = path.join(ctx.taskDir, def.outputFile);
+        if (!fs.existsSync(outputPath)) {
+            const ext = path.extname(def.outputFile);
+            const base = path.basename(def.outputFile, ext);
+            const files = fs.readdirSync(ctx.taskDir);
+            const variant = files.find((f) => f.startsWith(base + "-") && f.endsWith(ext));
+            if (variant) {
+                fs.renameSync(path.join(ctx.taskDir, variant), outputPath);
+                logger.info(`  Renamed variant ${variant} → ${def.outputFile}`);
+            }
+        }
+    }
+    if (def.outputFile) {
+        const outputPath = path.join(ctx.taskDir, def.outputFile);
+        if (fs.existsSync(outputPath)) {
+            const content = fs.readFileSync(outputPath, "utf-8");
+            const validation = validateStageOutput(def.name, content);
+            if (!validation.valid) {
+                // Taskify must produce valid JSON — retry once with stricter prompt
+                if (def.name === "taskify") {
+                    logger.warn(`  taskify output invalid (${validation.error}), retrying...`);
+                    const retryPrompt = prompt + "\n\nIMPORTANT: Your previous output was not valid JSON. Output ONLY the raw JSON object. No markdown, no fences, no explanation.";
+                    const retryResult = await runner.run(def.name, retryPrompt, model, def.timeout, ctx.taskDir, {
+                        cwd: ctx.projectDir,
+                        env: extraEnv,
+                    });
+                    if (retryResult.outcome === "completed" && retryResult.output) {
+                        const stripped = stripFences(retryResult.output);
+                        const retryValidation = validateTaskJson(stripped);
+                        if (retryValidation.valid) {
+                            fs.writeFileSync(outputPath, retryResult.output);
+                            logger.info(`  taskify retry produced valid JSON`);
+                        }
+                        else {
+                            logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
+                        }
+                    }
+                }
+                else {
+                    logger.warn(`  validation warning: ${validation.error}`);
+                }
+            }
+        }
+    }
+    return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+}

package/dist/stages/gate.d.ts

@@ -0,0 +1,2 @@
+import type { StageDefinition, StageResult, PipelineContext } from "../types.js";
+export declare function executeGateStage(ctx: PipelineContext, def: StageDefinition): StageResult;

package/dist/stages/gate.js

@@ -0,0 +1,32 @@
+import * as fs from "fs";
+import * as path from "path";
+import { runQualityGates } from "../verify-runner.js";
+import { logger } from "../logger.js";
+export function executeGateStage(ctx, def) {
+    if (ctx.input.dryRun) {
+        logger.info(`  [dry-run] skipping ${def.name}`);
+        return { outcome: "completed", retries: 0 };
+    }
+    const verifyResult = runQualityGates(ctx.taskDir, ctx.projectDir);
+    const lines = [
+        `# Verification Report\n`,
+        `## Result: ${verifyResult.pass ? "PASS" : "FAIL"}\n`,
+    ];
+    if (verifyResult.errors.length > 0) {
+        lines.push(`\n## Errors\n`);
+        for (const e of verifyResult.errors) {
+            lines.push(`- ${e}\n`);
+        }
+    }
+    if (verifyResult.summary.length > 0) {
+        lines.push(`\n## Summary\n`);
+        for (const s of verifyResult.summary) {
+            lines.push(`- ${s}\n`);
+        }
+    }
+    fs.writeFileSync(path.join(ctx.taskDir, "verify.md"), lines.join(""));
+    return {
+        outcome: verifyResult.pass ? "completed" : "failed",
+        retries: 0,
+    };
+}

package/dist/stages/review.d.ts

@@ -0,0 +1,2 @@
+import type { StageDefinition, StageResult, PipelineContext } from "../types.js";
+export declare function executeReviewWithFix(ctx: PipelineContext, def: StageDefinition): Promise<StageResult>;

package/dist/stages/review.js

@@ -0,0 +1,32 @@
+import * as fs from "fs";
+import * as path from "path";
+import { STAGES } from "../definitions.js";
+import { logger } from "../logger.js";
+import { executeAgentStage } from "./agent.js";
+export async function executeReviewWithFix(ctx, def) {
+    if (ctx.input.dryRun) {
+        return { outcome: "completed", retries: 0 };
+    }
+    const reviewDef = STAGES.find((s) => s.name === "review");
+    const reviewFixDef = STAGES.find((s) => s.name === "review-fix");
+    const reviewResult = await executeAgentStage(ctx, reviewDef);
+    if (reviewResult.outcome !== "completed") {
+        return reviewResult;
+    }
+    const reviewFile = path.join(ctx.taskDir, "review.md");
+    if (!fs.existsSync(reviewFile)) {
+        return { outcome: "failed", retries: 0, error: "review.md not found" };
+    }
+    const content = fs.readFileSync(reviewFile, "utf-8");
+    const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
+    if (!hasIssues) {
+        return reviewResult;
+    }
+    logger.info(`  review found issues, running review-fix...`);
+    const fixResult = await executeAgentStage(ctx, reviewFixDef);
+    if (fixResult.outcome !== "completed") {
+        return fixResult;
+    }
+    logger.info(`  re-running review after fix...`);
+    return executeAgentStage(ctx, reviewDef);
+}

package/dist/stages/ship.d.ts

@@ -0,0 +1,3 @@
+import type { StageDefinition, StageResult, PipelineContext } from "../types.js";
+export declare function buildPrBody(ctx: PipelineContext): string;
+export declare function executeShipStage(ctx: PipelineContext, _def: StageDefinition): StageResult;

package/dist/stages/ship.js

@@ -0,0 +1,154 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+import { getCurrentBranch, getDefaultBranch, pushBranch, } from "../git-utils.js";
+import { postComment, createPR, } from "../github-api.js";
+import { getProjectConfig } from "../config.js";
+export function buildPrBody(ctx) {
+    const sections = [];
+    // What and why — from task.json
+    const taskJsonPath = path.join(ctx.taskDir, "task.json");
+    if (fs.existsSync(taskJsonPath)) {
+        try {
+            const raw = fs.readFileSync(taskJsonPath, "utf-8");
+            const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+            const task = JSON.parse(cleaned);
+            if (task.description) {
+                sections.push(`## What\n\n${task.description}`);
+            }
+            if (task.scope?.length) {
+                sections.push(`\n## Scope\n\n${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
+            }
+            sections.push(`\n**Type:** ${task.task_type ?? "unknown"} | **Risk:** ${task.risk_level ?? "unknown"}`);
+        }
+        catch { /* ignore parse errors */ }
+    }
+    // Changes — from review.md summary
+    const reviewPath = path.join(ctx.taskDir, "review.md");
+    if (fs.existsSync(reviewPath)) {
+        const review = fs.readFileSync(reviewPath, "utf-8");
+        const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
+        if (summaryMatch) {
+            const summary = summaryMatch[1].trim();
+            if (summary) {
+                sections.push(`\n## Changes\n\n${summary}`);
+            }
+        }
+        const verdictMatch = review.match(/## Verdict:\s*(PASS|FAIL)/i);
+        if (verdictMatch) {
+            sections.push(`\n**Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "✅ PASS" : "❌ FAIL"}`);
+        }
+    }
+    // Verify result
+    const verifyPath = path.join(ctx.taskDir, "verify.md");
+    if (fs.existsSync(verifyPath)) {
+        const verify = fs.readFileSync(verifyPath, "utf-8");
+        if (/PASS/i.test(verify))
+            sections.push(`**Verify:** ✅ typecheck + tests + lint passed`);
+    }
+    // Plan — collapsible details
+    const planPath = path.join(ctx.taskDir, "plan.md");
+    if (fs.existsSync(planPath)) {
+        const plan = fs.readFileSync(planPath, "utf-8").trim();
+        if (plan) {
+            const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
+            sections.push(`\n<details><summary>📋 Implementation plan</summary>\n\n${truncated}\n</details>`);
+        }
+    }
+    // Closes issue
+    if (ctx.input.issueNumber) {
+        sections.push(`\nCloses #${ctx.input.issueNumber}`);
+    }
+    sections.push(`\n---\n🤖 Generated by Kody`);
+    return sections.join("\n");
+}
+export function executeShipStage(ctx, _def) {
+    const shipPath = path.join(ctx.taskDir, "ship.md");
+    if (ctx.input.dryRun) {
+        fs.writeFileSync(shipPath, "# Ship\n\nShip stage skipped — dry run.\n");
+        return { outcome: "completed", outputFile: "ship.md", retries: 0 };
+    }
+    // Local mode or no issue: skip git push + PR
+    if (ctx.input.local && !ctx.input.issueNumber) {
+        fs.writeFileSync(shipPath, "# Ship\n\nShip stage skipped — local mode, no issue number.\n");
+        return { outcome: "completed", outputFile: "ship.md", retries: 0 };
+    }
+    try {
+        const head = getCurrentBranch(ctx.projectDir);
+        const base = getDefaultBranch(ctx.projectDir);
+        pushBranch(ctx.projectDir);
+        // Resolve owner/repo
+        const config = getProjectConfig();
+        let owner = config.github?.owner;
+        let repo = config.github?.repo;
+        if (!owner || !repo) {
+            try {
+                const remoteUrl = execFileSync("git", ["remote", "get-url", "origin"], {
+                    encoding: "utf-8",
+                    cwd: ctx.projectDir,
+                }).trim();
+                const match = remoteUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+                if (match) {
+                    owner = match[1];
+                    repo = match[2];
+                }
+            }
+            catch {
+                // Can't determine repo
+            }
+        }
+        // Derive PR title from task.json (preferred) or task.md (fallback)
+        let title = "Update";
+        const TYPE_PREFIX = {
+            feature: "feat",
+            bugfix: "fix",
+            refactor: "refactor",
+            docs: "docs",
+            chore: "chore",
+        };
+        const taskJsonPath = path.join(ctx.taskDir, "task.json");
+        if (fs.existsSync(taskJsonPath)) {
+            try {
+                const raw = fs.readFileSync(taskJsonPath, "utf-8");
+                const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+                const task = JSON.parse(cleaned);
+                const prefix = TYPE_PREFIX[task.task_type] ?? "chore";
+                const taskTitle = task.title ?? "Update";
+                title = `${prefix}: ${taskTitle}`.slice(0, 72);
+            }
+            catch { /* fallback below */ }
+        }
+        if (title === "Update") {
+            const taskMdPath = path.join(ctx.taskDir, "task.md");
+            if (fs.existsSync(taskMdPath)) {
+                const content = fs.readFileSync(taskMdPath, "utf-8");
+                const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#") && !l.startsWith("*"));
+                if (firstLine)
+                    title = `chore: ${firstLine.trim()}`.slice(0, 72);
+            }
+        }
+        // Build rich PR body
+        const body = buildPrBody(ctx);
+        const pr = createPR(head, base, title, body);
+        if (pr) {
+            if (ctx.input.issueNumber && !ctx.input.local) {
+                try {
+                    postComment(ctx.input.issueNumber, `🎉 PR created: ${pr.url}`);
+                }
+                catch {
+                    // Fire and forget
+                }
+            }
+            fs.writeFileSync(shipPath, `# Ship\n\nPR created: ${pr.url}\nPR #${pr.number}\n`);
+        }
+        else {
+            fs.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        }
+        return { outcome: "completed", outputFile: "ship.md", retries: 0 };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        fs.writeFileSync(shipPath, `# Ship\n\nFailed: ${msg}\n`);
+        return { outcome: "failed", retries: 0, error: msg };
+    }
+}

package/dist/stages/verify.d.ts

@@ -0,0 +1,2 @@
+import type { StageDefinition, StageResult, PipelineContext } from "../types.js";
+export declare function executeVerifyWithAutofix(ctx: PipelineContext, def: StageDefinition): Promise<StageResult>;

package/dist/stages/verify.js

@@ -0,0 +1,94 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+import { resolveModel } from "../context.js";
+import { getProjectConfig, FIX_COMMAND_TIMEOUT_MS } from "../config.js";
+import { parseCommand } from "../verify-runner.js";
+import { getRunnerForStage } from "../pipeline/runner-selection.js";
+import { postComment } from "../github-api.js";
+import { diagnoseFailure, getModifiedFiles } from "../observer.js";
+import { logger } from "../logger.js";
+import { executeAgentStage } from "./agent.js";
+import { executeGateStage } from "./gate.js";
+export async function executeVerifyWithAutofix(ctx, def) {
+    const maxAttempts = def.maxRetries ?? 2;
+    for (let attempt = 0; attempt <= maxAttempts; attempt++) {
+        logger.info(`  verification attempt ${attempt + 1}/${maxAttempts + 1}`);
+        const gateResult = executeGateStage(ctx, def);
+        if (gateResult.outcome === "completed") {
+            return { ...gateResult, retries: attempt };
+        }
+        if (attempt < maxAttempts) {
+            // Read verify errors for diagnosis
+            const verifyPath = path.join(ctx.taskDir, "verify.md");
+            const errorOutput = fs.existsSync(verifyPath) ? fs.readFileSync(verifyPath, "utf-8") : "Unknown error";
+            // AI diagnosis — classify the failure
+            const modifiedFiles = getModifiedFiles(ctx.projectDir);
+            const defaultRunner = getRunnerForStage(ctx, "taskify"); // use cheap model
+            const diagnosis = await diagnoseFailure("verify", errorOutput, modifiedFiles, defaultRunner, resolveModel("cheap"));
+            if (diagnosis.classification === "infrastructure") {
+                logger.warn(`  Infrastructure issue: ${diagnosis.reason}`);
+                if (ctx.input.issueNumber && !ctx.input.local) {
+                    try {
+                        postComment(ctx.input.issueNumber, `⚠️ **Infrastructure issue detected:** ${diagnosis.reason}\n\n${diagnosis.resolution}`);
+                    }
+                    catch { /* fire-and-forget */ }
+                }
+                return { outcome: "completed", retries: attempt, error: `Skipped: ${diagnosis.reason}` };
+            }
+            if (diagnosis.classification === "pre-existing") {
+                logger.warn(`  Pre-existing issue: ${diagnosis.reason}`);
+                return { outcome: "completed", retries: attempt, error: `Skipped: ${diagnosis.reason}` };
+            }
+            if (diagnosis.classification === "abort") {
+                logger.error(`  Unrecoverable: ${diagnosis.reason}`);
+                return { outcome: "failed", retries: attempt, error: diagnosis.reason };
+            }
+            // fixable or retry — proceed with autofix
+            logger.info(`  Diagnosis: ${diagnosis.classification} — ${diagnosis.reason}`);
+            const config = getProjectConfig();
+            const runFix = (cmd) => {
+                if (!cmd)
+                    return;
+                const parts = parseCommand(cmd);
+                if (parts.length === 0)
+                    return;
+                try {
+                    execFileSync(parts[0], parts.slice(1), {
+                        stdio: "pipe",
+                        timeout: FIX_COMMAND_TIMEOUT_MS,
+                    });
+                }
+                catch {
+                    // Silently ignore fix failures
+                }
+            };
+            runFix(config.quality.lintFix);
+            runFix(config.quality.formatFix);
+            if (def.retryWithAgent) {
+                // Create new context with diagnosis guidance — don't mutate original
+                const autofixCtx = {
+                    ...ctx,
+                    input: {
+                        ...ctx.input,
+                        feedback: `${diagnosis.resolution}\n\n${ctx.input.feedback ?? ""}`.trim(),
+                    },
+                };
+                logger.info(`  running ${def.retryWithAgent} agent with diagnosis guidance...`);
+                await executeAgentStage(autofixCtx, {
+                    ...def,
+                    name: def.retryWithAgent,
+                    type: "agent",
+                    modelTier: "mid",
+                    timeout: 300_000,
+                    outputFile: undefined,
+                });
+            }
+        }
+    }
+    return {
+        outcome: "failed",
+        retries: maxAttempts,
+        error: "Verification failed after autofix attempts",
+    };
+}