@popoverai/dotrequirements 0.25.0 → 0.26.1

package/dist/codebase-to-spec/edit-loop.js

@@ -1,195 +0,0 @@
-/**
- * Spec review + editor loop.
- *
- * Same structure as the outline review loop, scaled up for document-level
- * revision: stateful spec reviewer + stateless editor. The reviewer
- * persists across turns so it can compare prior spec versions to the latest.
- *
- * Requirements covered:
- * - CTS-EDIT-1: stateful spec reviewer
- * - CTS-EDIT-2: approved → proceed
- * - CTS-EDIT-3: approved-with-revisions → one mechanical edit pass
- * - CTS-EDIT-4: requires-another-review → revise & resubmit
- * - CTS-EDIT-5: editor operates on cohesive document
- * - CTS-EDIT-6: max-turns + convergence nudge
- */
-import { randomUUID } from "node:crypto";
-import { copyFileSync } from "node:fs";
-import { runClaude } from "./claude.js";
-import { runEditor } from "./editor.js";
-import { SPEC_REVIEWER_PROMPT } from "./prompts/spec-reviewer.js";
-import { parseSpecReview, SPEC_REVIEW_JSON_SCHEMA, } from "./schemas.js";
-export const DEFAULT_EDIT_LOOP_MAX_TURNS = 6;
-function reviewerUserMessageInitial(specPath, packPath) {
-    return [
-        `Initial spec review.`,
-        ``,
-        `Composed spec: ${specPath}`,
-        `Codebase pack: ${packPath}`,
-        ``,
-        `Read both via the Read tool, then produce your critique JSON.`,
-    ].join("\n");
-}
-function reviewerUserMessageRevised(turn, specPath, packPath, nudge) {
-    const lines = [
-        `Review turn ${turn}. The editor has revised the spec based on your prior feedback.`,
-        ``,
-    ];
-    if (nudge) {
-        lines.push(nudge, ``);
-    }
-    lines.push(`Revised spec: ${specPath}`, `Codebase pack at ${packPath} is unchanged.`, ``, `Read the revised spec, compare to the prior version, and produce your critique JSON.`);
-    return lines.join("\n");
-}
-function convergenceNudge(turn, maxTurns) {
-    return `CONVERGENCE NUDGE: This is review turn ${turn} of ${maxTurns} maximum. Please prioritize convergence. Your job is still to only approve a genuinely-ready spec, but if it is close, lean toward \`approved-with-revisions\` over \`requires-another-review\`. Reserve \`requires-another-review\` for genuine issues that the editor has not addressed despite prior feedback.`;
-}
-async function callReviewer(args) {
-    const result = await args.runner({
-        systemPrompt: SPEC_REVIEWER_PROMPT,
-        userMessage: args.userMessage,
-        model: args.model,
-        tools: ["Read", "Grep", "Glob"],
-        addDirs: args.addDirs,
-        jsonSchema: SPEC_REVIEW_JSON_SCHEMA,
-        session: {
-            kind: args.isFirstTurn ? "fresh" : "resume",
-            sessionId: args.sessionId,
-        },
-    });
-    if (result.exitCode !== 0) {
-        throw new Error(`Spec reviewer failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
-    }
-    // Retry-once on parse failure (CTS-EDIT-1 convention, same as outline loop).
-    try {
-        return parseSpecReview(result.stdout);
-    }
-    catch (err) {
-        const retry = await args.runner({
-            systemPrompt: SPEC_REVIEWER_PROMPT,
-            userMessage: `${args.userMessage}\n\n(Your prior output failed schema validation: ${err instanceof Error ? err.message : String(err)}. Please try again, emitting JSON only.)`,
-            model: args.model,
-            tools: ["Read", "Grep", "Glob"],
-            addDirs: args.addDirs,
-            jsonSchema: SPEC_REVIEW_JSON_SCHEMA,
-            session: { kind: "resume", sessionId: args.sessionId },
-        });
-        if (retry.exitCode !== 0) {
-            throw new Error(`Spec reviewer retry failed (exit ${retry.exitCode}): ${retry.stderr || retry.stdout}`);
-        }
-        return parseSpecReview(retry.stdout);
-    }
-}
-export async function runEditLoop(options) {
-    const { composedSpecPath, specVersionFor, fullPackPath, addDirs, maxTurns = DEFAULT_EDIT_LOOP_MAX_TURNS, runner = runClaude, model, progress, sessionId = randomUUID(), } = options;
-    // Turn 1: copy the composed spec to spec-v1 and review it.
-    const specV1 = specVersionFor(1);
-    copyFileSync(composedSpecPath, specV1);
-    progress?.emit({
-        stage: "spec-review",
-        step: "turn-1",
-        message: `Reviewing composed spec (${specV1})`,
-    });
-    let review = await callReviewer({
-        runner,
-        sessionId,
-        isFirstTurn: true,
-        userMessage: reviewerUserMessageInitial(specV1, fullPackPath),
-        addDirs,
-        model,
-    });
-    const specPathsByTurn = [specV1];
-    const reviewsByTurn = [review];
-    let currentSpecPath = specV1;
-    progress?.emit({
-        stage: "spec-review",
-        step: "turn-1",
-        message: `Verdict: ${review.verdict}`,
-        data: { verdict: review.verdict },
-    });
-    let turn = 1;
-    while (review.verdict === "requires-another-review" && turn < maxTurns) {
-        turn++;
-        const nextSpec = specVersionFor(turn);
-        progress?.emit({
-            stage: "spec-review",
-            step: `edit-turn-${turn}`,
-            message: `Editor revising spec (turn ${turn}/${maxTurns})`,
-        });
-        const editResult = await runEditor({
-            inputSpecPath: currentSpecPath,
-            outputSpecPath: nextSpec,
-            fullPackPath,
-            addDirs,
-            critique: review,
-            mode: "revise",
-            runner,
-            model,
-        });
-        if (!editResult.wroteSpec) {
-            throw new Error(`Editor produced no output spec at ${nextSpec} (exit ${editResult.exitCode}): ${editResult.stderr}`);
-        }
-        currentSpecPath = nextSpec;
-        specPathsByTurn.push(currentSpecPath);
-        const nudge = turn >= maxTurns - 1 && turn !== maxTurns
-            ? convergenceNudge(turn, maxTurns)
-            : undefined;
-        progress?.emit({
-            stage: "spec-review",
-            step: `turn-${turn}`,
-            message: `Reviewing revised spec (turn ${turn}/${maxTurns})`,
-            data: { turn, maxTurns, nudge: !!nudge },
-        });
-        review = await callReviewer({
-            runner,
-            sessionId,
-            isFirstTurn: false,
-            userMessage: reviewerUserMessageRevised(turn, currentSpecPath, fullPackPath, nudge),
-            addDirs,
-            model,
-        });
-        reviewsByTurn.push(review);
-        progress?.emit({
-            stage: "spec-review",
-            step: `turn-${turn}`,
-            message: `Verdict: ${review.verdict}`,
-            data: { verdict: review.verdict },
-        });
-    }
-    const hitMaxTurns = review.verdict === "requires-another-review" && turn >= maxTurns;
-    // approved-with-revisions → apply mechanical revisions to a final version.
-    if (review.verdict === "approved-with-revisions" &&
-        review.revisions.length > 0) {
-        const finalTurn = turn + 1;
-        const finalPath = specVersionFor(finalTurn);
-        progress?.emit({
-            stage: "spec-review",
-            step: "apply-revisions",
-            message: `Applying ${review.revisions.length} mechanical revision(s)`,
-        });
-        const applyResult = await runEditor({
-            inputSpecPath: currentSpecPath,
-            outputSpecPath: finalPath,
-            fullPackPath,
-            addDirs,
-            critique: review,
-            mode: "apply",
-            runner,
-            model,
-        });
-        if (!applyResult.wroteSpec) {
-            throw new Error(`Apply-mode editor produced no output spec at ${finalPath} (exit ${applyResult.exitCode}): ${applyResult.stderr}`);
-        }
-        currentSpecPath = finalPath;
-        specPathsByTurn.push(currentSpecPath);
-    }
-    return {
-        finalSpecPath: currentSpecPath,
-        specPathsByTurn,
-        reviewsByTurn,
-        finalVerdict: review.verdict,
-        turnsUsed: turn,
-        hitMaxTurns,
-    };
-}
-//# sourceMappingURL=edit-loop.js.map

package/dist/codebase-to-spec/editor.d.ts

@@ -1,54 +0,0 @@
-/**
- * Editor worker: revise the composed spec in place based on a reviewer's
- * critique.
- *
- * Two modes:
- * - apply: apply mechanical revisions verbatim (when verdict is `approved-with-revisions`)
- * - revise: address the critique using the editor's own judgment (when verdict is `requires-another-review`)
- *
- * Requirements covered:
- * - CTS-EDIT-3: approved-with-revisions triggers apply mode
- * - CTS-EDIT-4: requires-another-review triggers revise mode
- * - CTS-EDIT-5: editor operates on the cohesive document, reads codebase only on demand
- */
-import { type ClaudeRunner } from "./claude.js";
-import type { SpecReview } from "./schemas.js";
-export type EditorMode = "apply" | "revise";
-export interface EditorContext {
-    /**
-     * Input spec path. The editor reads from here.
-     * If `outputSpecPath` differs, the input is copied to the output path first
-     * (so the editor's in-place edits land on the output).
-     */
-    inputSpecPath: string;
-    /** Output spec path (may equal inputSpecPath for true in-place editing). */
-    outputSpecPath: string;
-    /** Path to the codebase pack the editor may consult on demand. */
-    fullPackPath: string;
-    /** Directories to grant filesystem access to. */
-    addDirs: string[];
-    /** Reviewer's critique. */
-    critique: SpecReview;
-    /** Apply or revise. */
-    mode: EditorMode;
-    runner?: ClaudeRunner;
-    model?: string;
-}
-export interface EditorResult {
-    /** True if the output file exists and is non-empty after the editor ran. */
-    wroteSpec: boolean;
-    /** Size of the output in bytes (0 if missing). */
-    outputBytes: number;
-    /** Process exit code. */
-    exitCode: number;
-    /** Captured stdout (one-line confirmation). */
-    stdout: string;
-    /** Captured stderr. */
-    stderr: string;
-}
-/**
- * Run the editor. If outputSpecPath differs from inputSpecPath, copy first
- * so the in-place edits land on the output.
- */
-export declare function runEditor(ctx: EditorContext): Promise<EditorResult>;
-//# sourceMappingURL=editor.d.ts.map

package/dist/codebase-to-spec/editor.js

@@ -1,74 +0,0 @@
-/**
- * Editor worker: revise the composed spec in place based on a reviewer's
- * critique.
- *
- * Two modes:
- * - apply: apply mechanical revisions verbatim (when verdict is `approved-with-revisions`)
- * - revise: address the critique using the editor's own judgment (when verdict is `requires-another-review`)
- *
- * Requirements covered:
- * - CTS-EDIT-3: approved-with-revisions triggers apply mode
- * - CTS-EDIT-4: requires-another-review triggers revise mode
- * - CTS-EDIT-5: editor operates on the cohesive document, reads codebase only on demand
- */
-import { copyFileSync, existsSync, statSync } from "node:fs";
-import { runClaude } from "./claude.js";
-import { EDITOR_PROMPT } from "./prompts/editor.js";
-function userMessage(ctx) {
-    const mode = ctx.mode === "apply" ? "APPLY" : "REVISE";
-    const lines = [
-        `Mode: ${mode}`,
-        ``,
-        `Spec to edit (in place via Edit tool): ${ctx.outputSpecPath}`,
-        `Codebase pack (consult only on demand): ${ctx.fullPackPath}`,
-        ``,
-        `## Reviewer critique`,
-        `\`\`\`json`,
-        JSON.stringify(ctx.critique, null, 2),
-        `\`\`\``,
-        ``,
-    ];
-    if (ctx.mode === "apply") {
-        lines.push(`You are in APPLY mode. The reviewer's verdict is \`approved-with-revisions\`. Apply each revision in the \`revisions\` array verbatim. Do not restructure. When done, output a one-line confirmation.`);
-    }
-    else {
-        lines.push(`You are in REVISE mode. The reviewer's verdict is \`requires-another-review\`. Address each finding using your judgment. Use the Edit tool for targeted changes. Consult the codebase only to verify specific findings before adding requirements.`);
-    }
-    return lines.join("\n");
-}
-/**
- * Run the editor. If outputSpecPath differs from inputSpecPath, copy first
- * so the in-place edits land on the output.
- */
-export async function runEditor(ctx) {
-    if (ctx.inputSpecPath !== ctx.outputSpecPath) {
-        copyFileSync(ctx.inputSpecPath, ctx.outputSpecPath);
-    }
-    const runner = ctx.runner ?? runClaude;
-    const result = await runner({
-        systemPrompt: EDITOR_PROMPT,
-        userMessage: userMessage(ctx),
-        model: ctx.model,
-        tools: ["Read", "Edit", "Grep", "Glob"],
-        addDirs: ctx.addDirs,
-    });
-    let wroteSpec = false;
-    let outputBytes = 0;
-    if (existsSync(ctx.outputSpecPath)) {
-        try {
-            outputBytes = statSync(ctx.outputSpecPath).size;
-            wroteSpec = outputBytes > 0;
-        }
-        catch {
-            // Treat as not written.
-        }
-    }
-    return {
-        wroteSpec,
-        outputBytes,
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
-    };
-}
-//# sourceMappingURL=editor.js.map

package/dist/codebase-to-spec/fan-out.d.ts

@@ -1,63 +0,0 @@
-/**
- * Specifier fan-out orchestrator.
- *
- * For each area in the outline, extract a slice, spawn a specifier worker,
- * and write the resulting partial to the cache. Workers run in parallel up
- * to a bounded concurrency limit. On per-area failure (no partial written,
- * empty partial), the worker is retried once; on second failure, the area
- * is recorded as failed for surfacing to the user.
- *
- * Requirements covered:
- * - CTS-SPEC-1.2: bounded concurrent execution
- * - CTS-SPEC-5: failed/empty specifier output is detected and retried
- * - CTS-OBSERVE-2.0: failure details are logged with area name + cause
- * - CTS-RESUME-1.2: existing non-empty partial means the specifier is skipped
- */
-import type { ClaudeRunner } from "./claude.js";
-import type { ProgressEmitter } from "./progress.js";
-import type { Area, Outline } from "./schemas.js";
-export declare const DEFAULT_FAN_OUT_CONCURRENCY = 8;
-export interface FanOutOptions {
-    outline: Outline;
-    /** Path to the uncompressed pack (slices come from here). */
-    fullPackPath: string;
-    /** Path resolver: given a sanitized area name, return the partial path. */
-    partialPathFor: (sanitizedAreaName: string) => string;
-    /** Path resolver: given a sanitized area name, return the slice path. */
-    slicePathFor: (sanitizedAreaName: string) => string;
-    /** Command (path + args) the specifier should run to invoke schema validation. Run before style-check. */
-    validateCommand: string;
-    /** Command (path + args) the specifier should run to invoke style-check. */
-    styleCheckCommand: string;
-    /** Directories the specifier needs filesystem access to. */
-    addDirs: string[];
-    concurrency?: number;
-    runner?: ClaudeRunner;
-    model?: string;
-    progress?: ProgressEmitter;
-}
-export interface AreaOutcome {
-    area: Area;
-    status: "completed" | "skipped-resume" | "failed";
-    /** Number of attempts made (1 = first attempt succeeded; 2 = retry succeeded; 2 with failed = retried and still failed). */
-    attempts: number;
-    /** Reason the area failed, if applicable. */
-    failureCause?: string;
-    /** Path to the partial (whether or not it was written successfully). */
-    partialPath: string;
-}
-export interface FanOutResult {
-    outcomes: AreaOutcome[];
-    /** True if every area produced a non-empty partial (either now or from cache). */
-    allSucceeded: boolean;
-}
-/**
- * Convert an area name to a stable filesystem-safe identifier.
- * E.g., "Reading & Editing Files" → "reading-editing-files"
- */
-export declare function sanitizeAreaName(name: string): string;
-/**
- * Run the fan-out: extract slices, invoke specifiers, retry on failure.
- */
-export declare function runFanOut(options: FanOutOptions): Promise<FanOutResult>;
-//# sourceMappingURL=fan-out.d.ts.map

package/dist/codebase-to-spec/fan-out.js

@@ -1,215 +0,0 @@
-/**
- * Specifier fan-out orchestrator.
- *
- * For each area in the outline, extract a slice, spawn a specifier worker,
- * and write the resulting partial to the cache. Workers run in parallel up
- * to a bounded concurrency limit. On per-area failure (no partial written,
- * empty partial), the worker is retried once; on second failure, the area
- * is recorded as failed for surfacing to the user.
- *
- * Requirements covered:
- * - CTS-SPEC-1.2: bounded concurrent execution
- * - CTS-SPEC-5: failed/empty specifier output is detected and retried
- * - CTS-OBSERVE-2.0: failure details are logged with area name + cause
- * - CTS-RESUME-1.2: existing non-empty partial means the specifier is skipped
- */
-import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { extractSlice } from "./slice.js";
-import { runSpecifier } from "./specifier.js";
-export const DEFAULT_FAN_OUT_CONCURRENCY = 8;
-/**
- * Convert an area name to a stable filesystem-safe identifier.
- * E.g., "Reading & Editing Files" → "reading-editing-files"
- */
-export function sanitizeAreaName(name) {
-    return (name
-        .replace(/[^A-Za-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .toLowerCase() || "area");
-}
-/**
- * Run a bounded-concurrency loop over items. Workers pull items off a shared
- * counter; at most `limit` workers run at a time.
- */
-async function withLimit(items, limit, fn) {
-    let next = 0;
-    async function worker() {
-        while (true) {
-            const i = next++;
-            if (i >= items.length)
-                return;
-            await fn(items[i], i);
-        }
-    }
-    const workerCount = Math.min(Math.max(1, limit), items.length);
-    const workers = Array.from({ length: workerCount }, () => worker());
-    await Promise.all(workers);
-}
-function partialIsUsable(path) {
-    if (!existsSync(path))
-        return false;
-    try {
-        return statSync(path).size > 0;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Run the fan-out: extract slices, invoke specifiers, retry on failure.
- */
-export async function runFanOut(options) {
-    const { outline, fullPackPath, partialPathFor, slicePathFor, validateCommand, styleCheckCommand, addDirs, concurrency = DEFAULT_FAN_OUT_CONCURRENCY, runner, model, progress, } = options;
-    if (!existsSync(fullPackPath)) {
-        throw new Error(`Missing full pack at ${fullPackPath}`);
-    }
-    // Sanitization is lossy ("Read & Write" and "read/write" both become
-    // "read-write"). If two areas collide, they'd share a partial file path and
-    // silently overwrite each other downstream. Catch this up front.
-    const sanitizedNames = new Map();
-    for (const area of outline.areas) {
-        const key = sanitizeAreaName(area.name);
-        const bucket = sanitizedNames.get(key) ?? [];
-        bucket.push(area.name);
-        sanitizedNames.set(key, bucket);
-    }
-    const collisions = [...sanitizedNames.entries()].filter(([, names]) => names.length > 1);
-    if (collisions.length > 0) {
-        const detail = collisions
-            .map(([key, names]) => `  "${key}" ← ${names.map((n) => `"${n}"`).join(", ")}`)
-            .join("\n");
-        throw new Error(`Outline contains area names that collide after sanitization. Rename them so each produces a unique partial file path:\n${detail}`);
-    }
-    const outcomes = outline.areas.map((area) => ({
-        area,
-        status: "failed",
-        attempts: 0,
-        partialPath: partialPathFor(sanitizeAreaName(area.name)),
-    }));
-    // Ensure partials directory exists for each area.
-    for (const outcome of outcomes) {
-        mkdirSync(dirname(outcome.partialPath), { recursive: true });
-    }
-    await withLimit(outcomes, concurrency, async (outcome) => {
-        const sanitized = sanitizeAreaName(outcome.area.name);
-        const slicePath = slicePathFor(sanitized);
-        // CTS-RESUME-1.2: skip if a non-empty partial exists from a prior run.
-        if (partialIsUsable(outcome.partialPath)) {
-            outcome.status = "skipped-resume";
-            outcome.attempts = 0;
-            progress?.emit({
-                stage: "specify",
-                step: outcome.area.prefix,
-                message: `(resume) skipping ${outcome.area.name} — partial exists`,
-            });
-            return;
-        }
-        // Extract this area's slice from the full pack.
-        if (outcome.area.files.length === 0) {
-            // No files assigned — write a stub partial so compose has something.
-            writeFileSync(outcome.partialPath, "_(no files assigned to this area)_\n", "utf-8");
-            outcome.status = "failed";
-            outcome.attempts = 0;
-            outcome.failureCause = "no files assigned in outline";
-            progress?.emit({
-                stage: "specify",
-                step: outcome.area.prefix,
-                message: `!! ${outcome.area.name} has no files; marking as failed`,
-            });
-            return;
-        }
-        let sliceMatched = 0;
-        try {
-            const sliceResult = extractSlice(fullPackPath, slicePath, outcome.area.files);
-            sliceMatched = sliceResult.matched;
-        }
-        catch (err) {
-            outcome.failureCause = `slice extraction failed: ${err instanceof Error ? err.message : String(err)}`;
-            progress?.emit({
-                stage: "specify",
-                step: outcome.area.prefix,
-                message: `!! ${outcome.failureCause}`,
-            });
-            return;
-        }
-        if (sliceMatched === 0) {
-            progress?.emit({
-                stage: "specify",
-                step: outcome.area.prefix,
-                message: `(warning) slice for ${outcome.area.name} matched 0 files; specifier will need to fall back to full-pack reads`,
-            });
-        }
-        // Attempt 1
-        progress?.emit({
-            stage: "specify",
-            step: outcome.area.prefix,
-            message: `Running specifier for ${outcome.area.name} (attempt 1/2)`,
-        });
-        outcome.attempts = 1;
-        const r1 = await runSpecifier({
-            outline,
-            area: outcome.area,
-            slicePath,
-            fullPackPath,
-            partialPath: outcome.partialPath,
-            validateCommand,
-            styleCheckCommand,
-            addDirs,
-            runner,
-            model,
-        });
-        if (r1.wrotePartial) {
-            outcome.status = "completed";
-            progress?.emit({
-                stage: "specify",
-                step: outcome.area.prefix,
-                message: `${outcome.area.name} done (${r1.partialBytes} bytes)`,
-            });
-            return;
-        }
-        // Attempt 2 (retry once on no/empty partial)
-        progress?.emit({
-            stage: "specify",
-            step: outcome.area.prefix,
-            message: `!! ${outcome.area.name} produced no partial; retrying (attempt 2/2)`,
-        });
-        outcome.attempts = 2;
-        const r2 = await runSpecifier({
-            outline,
-            area: outcome.area,
-            slicePath,
-            fullPackPath,
-            partialPath: outcome.partialPath,
-            validateCommand,
-            styleCheckCommand,
-            addDirs,
-            runner,
-            model,
-        });
-        if (r2.wrotePartial) {
-            outcome.status = "completed";
-            progress?.emit({
-                stage: "specify",
-                step: outcome.area.prefix,
-                message: `${outcome.area.name} done on retry (${r2.partialBytes} bytes)`,
-            });
-            return;
-        }
-        // Two failures — record and continue. CTS-SPEC-5 says other areas still proceed.
-        outcome.status = "failed";
-        outcome.failureCause =
-            r2.exitCode !== 0
-                ? `specifier exited with code ${r2.exitCode}: ${r2.stderr.slice(0, 200)}`
-                : "specifier wrote no partial (or empty partial) on both attempts";
-        writeFileSync(outcome.partialPath, `_(missing partial — specifier failed after retry: ${outcome.failureCause})_\n`, "utf-8");
-        progress?.emit({
-            stage: "specify",
-            step: outcome.area.prefix,
-            message: `!! ${outcome.area.name} failed: ${outcome.failureCause}`,
-        });
-    });
-    const allSucceeded = outcomes.every((o) => o.status === "completed" || o.status === "skipped-resume");
-    return { outcomes, allSucceeded };
-}
-//# sourceMappingURL=fan-out.js.map

package/dist/codebase-to-spec/outline-review-loop.d.ts

@@ -1,51 +0,0 @@
-/**
- * Outline review loop: planner → reviewer → revise → reviewer → ... → approved.
- *
- * The reviewer runs in a SINGLE stateful claude session across turns (so it
- * can compare prior outlines to the latest one). The planner is stateless —
- * each invocation is fresh.
- *
- * Requirements covered:
- * - CTS-PLAN-2: stateful reviewer session
- * - CTS-PLAN-3: approved → proceed
- * - CTS-PLAN-4: approved-with-revisions → one revision pass, then proceed
- * - CTS-PLAN-5: requires-another-review → revision loop
- * - CTS-PLAN-6: max-turns + convergence nudge
- */
-import { type ClaudeRunner } from "./claude.js";
-import type { ProgressEmitter } from "./progress.js";
-import { type Outline, type OutlineReview } from "./schemas.js";
-export declare const DEFAULT_OUTLINE_LOOP_MAX_TURNS = 3;
-export interface OutlineReviewLoopOptions {
-    overviewPath: string;
-    addDirs: string[];
-    maxTurns?: number;
-    runner?: ClaudeRunner;
-    model?: string;
-    progress?: ProgressEmitter;
-    /** Override session id (for tests and reproducibility). Otherwise random. */
-    sessionId?: string;
-}
-export interface OutlineReviewLoopResult {
-    /** The final outline after the loop converges (or hits max-turns). */
-    outline: Outline;
-    /** Per-turn outline snapshots (turn 1 is the initial, then each revision). */
-    outlinesByTurn: Outline[];
-    /** Per-turn reviewer results. */
-    reviewsByTurn: OutlineReview[];
-    /** The final reviewer verdict. */
-    finalVerdict: OutlineReview["verdict"];
-    /** Number of review turns used (= length of reviewsByTurn). */
-    turnsUsed: number;
-    /** True if the loop hit max-turns without converging. */
-    hitMaxTurns: boolean;
-}
-/**
- * Run the outline review loop end-to-end.
- *
- * Returns the final outline (after applying mechanical revisions if the
- * verdict was `approved-with-revisions`), the per-turn trace, and the final
- * verdict.
- */
-export declare function runOutlineReviewLoop(options: OutlineReviewLoopOptions): Promise<OutlineReviewLoopResult>;
-//# sourceMappingURL=outline-review-loop.d.ts.map