@popoverai/dotrequirements 0.26.0 → 0.26.1

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

package/dist/codebase-to-spec/outline-review-loop.js

@@ -1,187 +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 { randomUUID } from "node:crypto";
-import { runClaude } from "./claude.js";
-import { runInitialPlanner, runRevisingPlanner, } from "./planner.js";
-import { OUTLINE_REVIEWER_PROMPT } from "./prompts/outline-reviewer.js";
-import { OUTLINE_REVIEW_JSON_SCHEMA, parseOutlineReview, } from "./schemas.js";
-export const DEFAULT_OUTLINE_LOOP_MAX_TURNS = 3;
-function reviewerUserMessageInitial(overviewPath, outline) {
-    return [
-        `Initial outline review.`,
-        ``,
-        `The compressed packed codebase is at: ${overviewPath}`,
-        ``,
-        `## Outline`,
-        `\`\`\`json`,
-        JSON.stringify(outline, null, 2),
-        `\`\`\``,
-        ``,
-        `Read the codebase if you need to verify file paths or coverage gaps, then produce your critique JSON.`,
-    ].join("\n");
-}
-function reviewerUserMessageRevised(turn, overviewPath, outline, nudge) {
-    const parts = [
-        `Review turn ${turn}. The planner has revised the outline based on your prior feedback.`,
-        ``,
-    ];
-    if (nudge) {
-        parts.push(nudge, ``);
-    }
-    parts.push(`The codebase pack at ${overviewPath} is unchanged.`, ``, `## Revised outline`, `\`\`\`json`, JSON.stringify(outline, null, 2), `\`\`\``, ``, `Compare this outline to the prior one. Report on what was fixed, what is still open, and what (if anything) was introduced as a new issue. Then produce your critique JSON.`);
-    return parts.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 outline, but if it is close, lean toward \`approved-with-revisions\` over \`requires-another-review\`. Reserve \`requires-another-review\` for genuine structural problems that the planner has not addressed despite prior feedback.`;
-}
-async function callReviewer(args) {
-    const result = await args.runner({
-        systemPrompt: OUTLINE_REVIEWER_PROMPT,
-        userMessage: args.userMessage,
-        model: args.model,
-        tools: ["Read", "Grep"],
-        addDirs: args.addDirs,
-        jsonSchema: OUTLINE_REVIEW_JSON_SCHEMA,
-        session: {
-            kind: args.isFirstTurn ? "fresh" : "resume",
-            sessionId: args.sessionId,
-        },
-    });
-    if (result.exitCode !== 0) {
-        throw new Error(`Outline reviewer failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
-    }
-    // On parse failure, retry the same turn once before failing.
-    // CTS-PLAN-2 requirement: "on validation failure the CLI logs the parse error
-    // and retries the same turn once before failing the loop"
-    try {
-        return parseOutlineReview(result.stdout);
-    }
-    catch (err) {
-        // Retry once
-        const retry = await args.runner({
-            systemPrompt: OUTLINE_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"],
-            addDirs: args.addDirs,
-            jsonSchema: OUTLINE_REVIEW_JSON_SCHEMA,
-            session: { kind: "resume", sessionId: args.sessionId },
-        });
-        if (retry.exitCode !== 0) {
-            throw new Error(`Outline reviewer retry failed (exit ${retry.exitCode}): ${retry.stderr || retry.stdout}`);
-        }
-        return parseOutlineReview(retry.stdout);
-    }
-}
-/**
- * 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 async function runOutlineReviewLoop(options) {
-    const { overviewPath, addDirs, maxTurns = DEFAULT_OUTLINE_LOOP_MAX_TURNS, runner = runClaude, model, progress, sessionId = randomUUID(), } = options;
-    const plannerCtx = { overviewPath, addDirs, runner, model };
-    // Turn 1 — initial planner + initial reviewer
-    progress?.emit({
-        stage: "plan",
-        step: "planner-initial",
-        message: "Generating initial outline",
-    });
-    const outline1 = await runInitialPlanner(plannerCtx);
-    const outlinesByTurn = [outline1];
-    const reviewsByTurn = [];
-    progress?.emit({
-        stage: "outline-review",
-        step: "turn-1",
-        message: `Reviewing initial outline (${outline1.areas.length} areas)`,
-    });
-    let currentOutline = outline1;
-    let review = await callReviewer({
-        runner,
-        sessionId,
-        isFirstTurn: true,
-        userMessage: reviewerUserMessageInitial(overviewPath, outline1),
-        addDirs,
-        model,
-    });
-    reviewsByTurn.push(review);
-    progress?.emit({
-        stage: "outline-review",
-        step: "turn-1",
-        message: `Verdict: ${review.verdict}`,
-        data: { verdict: review.verdict },
-    });
-    let turn = 1;
-    while (review.verdict === "requires-another-review" && turn < maxTurns) {
-        turn++;
-        progress?.emit({
-            stage: "plan",
-            step: `revise-turn-${turn}`,
-            message: "Revising outline based on critique",
-        });
-        currentOutline = await runRevisingPlanner(plannerCtx, currentOutline, review);
-        outlinesByTurn.push(currentOutline);
-        const nudge = turn >= maxTurns - 1 && turn !== maxTurns
-            ? convergenceNudge(turn, maxTurns)
-            : undefined;
-        progress?.emit({
-            stage: "outline-review",
-            step: `turn-${turn}`,
-            message: `Reviewing revised outline (turn ${turn}/${maxTurns})`,
-            data: { turn, maxTurns, nudge: !!nudge },
-        });
-        review = await callReviewer({
-            runner,
-            sessionId,
-            isFirstTurn: false,
-            userMessage: reviewerUserMessageRevised(turn, overviewPath, currentOutline, nudge),
-            addDirs,
-            model,
-        });
-        reviewsByTurn.push(review);
-        progress?.emit({
-            stage: "outline-review",
-            step: `turn-${turn}`,
-            message: `Verdict: ${review.verdict}`,
-            data: { verdict: review.verdict },
-        });
-    }
-    const hitMaxTurns = review.verdict === "requires-another-review" && turn >= maxTurns;
-    // If the verdict ended on approved-with-revisions, run the planner once
-    // more to apply the listed revisions. Same agent as the revise loop; the
-    // difference is that we proceed to fan-out instead of looping back to
-    // review.
-    if (review.verdict === "approved-with-revisions" &&
-        review.revisions.length > 0) {
-        progress?.emit({
-            stage: "plan",
-            step: "apply-revisions",
-            message: `Applying ${review.revisions.length} revision(s)`,
-        });
-        currentOutline = await runRevisingPlanner(plannerCtx, currentOutline, review);
-        outlinesByTurn.push(currentOutline);
-    }
-    return {
-        outline: currentOutline,
-        outlinesByTurn,
-        reviewsByTurn,
-        finalVerdict: review.verdict,
-        turnsUsed: turn,
-        hitMaxTurns,
-    };
-}
-//# sourceMappingURL=outline-review-loop.js.map

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

@@ -1,41 +0,0 @@
-/**
- * Planner functions (initial and revise).
- *
- * Two modes correspond to two places the planner is invoked:
- * - initial: first outline from the compressed pack (CTS-PLAN-1)
- * - revise:  address reviewer feedback — works for both
- *            `requires-another-review` (CTS-PLAN-5) and
- *            `approved-with-revisions` (CTS-PLAN-4). The orchestration
- *            decides whether to loop back to the reviewer or proceed to
- *            fan-out.
- *
- * Each mode is stateless — a fresh claude -p session per call.
- */
-import { type ClaudeRunner } from "./claude.js";
-import { type Outline, type OutlineReview } from "./schemas.js";
-export interface PlannerContext {
-    /** Path to the compressed pack file (readable by the spawned agent). */
-    overviewPath: string;
-    /** Directories the agent should have read access to (e.g., the cache dir). */
-    addDirs: string[];
-    /** Optional claude runner override (for tests). */
-    runner?: ClaudeRunner;
-    /** Optional model override. */
-    model?: string;
-}
-/**
- * Run the planner in initial mode and return a parsed outline.
- * Requirement: CTS-PLAN-1
- */
-export declare function runInitialPlanner(ctx: PlannerContext): Promise<Outline>;
-/**
- * Run the planner in revise mode — produce a new outline that addresses the
- * reviewer's output. Handles both verdicts that trigger another planner pass:
- * `requires-another-review` (categorized findings, judgment-based) and
- * `approved-with-revisions` (explicit revisions list). The same prompt handles
- * both shapes; the prompt switches behavior based on what's in the review.
- *
- * Requirements: CTS-PLAN-4, CTS-PLAN-5
- */
-export declare function runRevisingPlanner(ctx: PlannerContext, priorOutline: Outline, review: OutlineReview): Promise<Outline>;
-//# sourceMappingURL=planner.d.ts.map