@kody-ade/engine 0.1.0

package/dist/pipeline.js

@@ -0,0 +1,213 @@
+import * as fs from "fs";
+import * as path from "path";
+import { STAGES } from "./definitions.js";
+import { ensureFeatureBranch, syncWithDefault } from "./git-utils.js";
+import { setLifecycleLabel } from "./github-api.js";
+import { logger, ciGroup, ciGroupEnd } from "./logger.js";
+import { loadState, writeState, initState } from "./pipeline/state.js";
+import { filterByComplexity } from "./pipeline/complexity.js";
+import { getExecutor } from "./pipeline/executor-registry.js";
+import { applyPreStageLabel, checkQuestionsAfterStage, autoDetectComplexity, commitAfterStage, postSkippedStagesComment, } from "./pipeline/hooks.js";
+import { autoLearn } from "./learning/auto-learn.js";
+import { runRetrospective } from "./retrospective.js";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function ensureFeatureBranchIfNeeded(ctx) {
+    if (!ctx.input.issueNumber || ctx.input.dryRun)
+        return;
+    try {
+        const taskMdPath = path.join(ctx.taskDir, "task.md");
+        const title = fs.existsSync(taskMdPath)
+            ? fs.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50)
+            : ctx.taskId;
+        ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
+        syncWithDefault(ctx.projectDir);
+    }
+    catch (err) {
+        logger.warn(`  Failed to create/sync feature branch: ${err}`);
+    }
+}
+// ─── Lock ───────────────────────────────────────────────────────────────────
+function acquireLock(taskDir) {
+    const lockPath = path.join(taskDir, ".lock");
+    if (fs.existsSync(lockPath)) {
+        try {
+            const pid = parseInt(fs.readFileSync(lockPath, "utf-8").trim(), 10);
+            try {
+                process.kill(pid, 0);
+                throw new Error(`Pipeline already running (PID ${pid})`);
+            }
+            catch (e) {
+                if (e.code !== "ESRCH")
+                    throw e;
+                // PID not alive — stale lock, safe to overwrite
+            }
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith("Pipeline already"))
+                throw e;
+            // Corrupt lock file — overwrite
+        }
+    }
+    fs.writeFileSync(lockPath, String(process.pid));
+}
+function releaseLock(taskDir) {
+    try {
+        fs.unlinkSync(path.join(taskDir, ".lock"));
+    }
+    catch { /* ignore */ }
+}
+// ─── Pipeline Loop ──────────────────────────────────────────────────────────
+export async function runPipeline(ctx) {
+    acquireLock(ctx.taskDir);
+    try {
+        return await runPipelineInner(ctx);
+    }
+    finally {
+        releaseLock(ctx.taskDir);
+    }
+}
+async function runPipelineInner(ctx) {
+    const pipelineStartTime = Date.now();
+    let state = loadState(ctx.taskId, ctx.taskDir);
+    if (!state) {
+        state = initState(ctx.taskId);
+        writeState(state, ctx.taskDir);
+    }
+    // Reset for rerun
+    if (state.state !== "running") {
+        state.state = "running";
+        for (const stage of STAGES) {
+            const s = state.stages[stage.name];
+            if (s.state === "running" || s.state === "failed" || s.state === "timeout") {
+                state.stages[stage.name] = { ...s, state: "pending" };
+            }
+        }
+        writeState(state, ctx.taskDir);
+    }
+    const fromStage = ctx.input.fromStage;
+    let startExecution = !fromStage;
+    logger.info(`Pipeline started: ${ctx.taskId}`);
+    logger.info(`Stages: ${STAGES.map((s) => s.name).join(" → ")}`);
+    if (fromStage)
+        logger.info(`Resuming from: ${fromStage}`);
+    if (ctx.input.issueNumber && !ctx.input.local) {
+        const initialPhase = ctx.input.mode === "rerun" ? "building" : "planning";
+        setLifecycleLabel(ctx.input.issueNumber, initialPhase);
+    }
+    ensureFeatureBranchIfNeeded(ctx);
+    let complexity = ctx.input.complexity ?? "high";
+    let activeStages = filterByComplexity(STAGES, complexity);
+    let skippedStagesCommentPosted = false;
+    for (const def of STAGES) {
+        // fromStage skip
+        if (!startExecution) {
+            if (def.name === fromStage) {
+                startExecution = true;
+            }
+            else {
+                continue;
+            }
+        }
+        if (state.stages[def.name].state === "completed") {
+            logger.info(`[${def.name}] already completed, skipping`);
+            continue;
+        }
+        // Complexity skip
+        if (!activeStages.find((s) => s.name === def.name)) {
+            logger.info(`[${def.name}] skipped (complexity: ${complexity})`);
+            state.stages[def.name] = { state: "completed", retries: 0, outputFile: undefined };
+            writeState(state, ctx.taskDir);
+            if (!skippedStagesCommentPosted) {
+                postSkippedStagesComment(ctx, complexity, activeStages);
+                skippedStagesCommentPosted = true;
+            }
+            continue;
+        }
+        ciGroup(`Stage: ${def.name}`);
+        state.stages[def.name] = { state: "running", startedAt: new Date().toISOString(), retries: 0 };
+        writeState(state, ctx.taskDir);
+        logger.info(`[${def.name}] starting...`);
+        applyPreStageLabel(ctx, def);
+        // Execute stage via registry
+        let result;
+        try {
+            result = await getExecutor(def.name)(ctx, def);
+        }
+        catch (error) {
+            result = {
+                outcome: "failed",
+                retries: 0,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+        ciGroupEnd();
+        if (result.outcome === "completed") {
+            state.stages[def.name] = {
+                state: "completed",
+                completedAt: new Date().toISOString(),
+                retries: result.retries,
+                outputFile: result.outputFile,
+            };
+            logger.info(`[${def.name}] ✓ completed`);
+            const paused = checkQuestionsAfterStage(ctx, def, state);
+            if (paused)
+                return paused;
+            const detected = autoDetectComplexity(ctx, def);
+            if (detected) {
+                complexity = detected.complexity;
+                activeStages = detected.activeStages;
+            }
+            commitAfterStage(ctx, def);
+        }
+        else {
+            // Failed or timed out
+            const isTimeout = result.outcome === "timed_out";
+            state.stages[def.name] = {
+                state: isTimeout ? "timeout" : "failed",
+                retries: result.retries,
+                error: isTimeout ? "Stage timed out" : (result.error ?? "Stage failed"),
+            };
+            state.state = "failed";
+            writeState(state, ctx.taskDir);
+            logger.error(`[${def.name}] ${isTimeout ? "⏱ timed out" : `✗ failed: ${result.error}`}`);
+            if (ctx.input.issueNumber && !ctx.input.local) {
+                setLifecycleLabel(ctx.input.issueNumber, "failed");
+            }
+            break;
+        }
+        writeState(state, ctx.taskDir);
+    }
+    const allCompleted = STAGES.every((s) => state.stages[s.name].state === "completed");
+    if (allCompleted) {
+        state.state = "completed";
+        writeState(state, ctx.taskDir);
+        logger.info(`Pipeline completed: ${ctx.taskId}`);
+        if (ctx.input.issueNumber && !ctx.input.local) {
+            setLifecycleLabel(ctx.input.issueNumber, "done");
+        }
+        autoLearn(ctx);
+    }
+    await runRetrospective(ctx, state, pipelineStartTime).catch(() => { });
+    return state;
+}
+// ─── Status Display ─────────────────────────────────────────────────────────
+export function printStatus(taskId, taskDir) {
+    const state = loadState(taskId, taskDir);
+    if (!state) {
+        console.log(`No status found for task ${taskId}`);
+        return;
+    }
+    console.log(`\nTask: ${state.taskId}`);
+    console.log(`State: ${state.state}`);
+    console.log(`Created: ${state.createdAt}`);
+    console.log(`Updated: ${state.updatedAt}\n`);
+    for (const stage of STAGES) {
+        const s = state.stages[stage.name];
+        const icon = s.state === "completed" ? "✓" :
+            s.state === "failed" ? "✗" :
+                s.state === "running" ? "▶" :
+                    s.state === "timeout" ? "⏱" : "○";
+        const extra = s.error ? ` — ${s.error}` : "";
+        console.log(`  ${icon} ${stage.name}: ${s.state}${extra}`);
+    }
+}

package/dist/preflight.d.ts

@@ -0,0 +1 @@
+export declare function runPreflight(): void;

package/dist/preflight.js

@@ -0,0 +1,69 @@
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import { logger } from "./logger.js";
+function check(name, fn) {
+    try {
+        const detail = fn() ?? undefined;
+        return { name, ok: true, detail };
+    }
+    catch {
+        return { name, ok: false };
+    }
+}
+export function runPreflight() {
+    const checks = [
+        check("claude CLI", () => {
+            const v = execFileSync("claude", ["--version"], {
+                encoding: "utf-8",
+                timeout: 10_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            return v;
+        }),
+        check("git repo", () => {
+            execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+                encoding: "utf-8",
+                timeout: 5_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }),
+        check("pnpm", () => {
+            const v = execFileSync("pnpm", ["--version"], {
+                encoding: "utf-8",
+                timeout: 5_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            return v;
+        }),
+        check("node >= 18", () => {
+            const v = execFileSync("node", ["--version"], {
+                encoding: "utf-8",
+                timeout: 5_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            const major = parseInt(v.replace("v", "").split(".")[0], 10);
+            if (major < 18)
+                throw new Error(`Node ${v} < 18`);
+            return v;
+        }),
+        check("gh CLI", () => {
+            const v = execFileSync("gh", ["--version"], {
+                encoding: "utf-8",
+                timeout: 5_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim().split("\n")[0];
+            return v;
+        }),
+        check("package.json", () => {
+            if (!fs.existsSync("package.json"))
+                throw new Error("not found");
+        }),
+    ];
+    const failed = checks.filter((c) => !c.ok);
+    for (const c of checks) {
+        logger.info(`  ${c.ok ? "✓" : "✗"} ${c.name}${c.detail ? ` (${c.detail})` : ""}`);
+    }
+    if (failed.length > 0) {
+        throw new Error(`Preflight failed: ${failed.map((c) => c.name).join(", ")}`);
+    }
+}

package/dist/retrospective.d.ts

@@ -0,0 +1,26 @@
+import type { StageName, PipelineStatus, PipelineContext } from "./types.js";
+export interface RetrospectiveEntry {
+    timestamp: string;
+    taskId: string;
+    outcome: "completed" | "failed";
+    durationMs: number;
+    stageResults: Record<string, {
+        state: string;
+        retries: number;
+        durationMs?: number;
+        error?: string;
+    }>;
+    failedStage?: StageName;
+    observation: string;
+    patternMatch: string | null;
+    suggestion: string;
+    pipelineFlaw: {
+        component: string;
+        issue: string;
+        evidence: string;
+    } | null;
+}
+export declare function collectRunContext(ctx: PipelineContext, state: PipelineStatus, pipelineStartTime: number): string;
+export declare function readPreviousRetrospectives(projectDir: string, limit?: number): RetrospectiveEntry[];
+export declare function appendRetrospectiveEntry(projectDir: string, entry: RetrospectiveEntry): void;
+export declare function runRetrospective(ctx: PipelineContext, state: PipelineStatus, pipelineStartTime: number): Promise<void>;

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>;