@popoverai/dotrequirements 0.25.0 → 0.26.1

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

@@ -1,85 +0,0 @@
-/**
- * Specifier worker: run a single specifier for one area.
- *
- * The specifier is given its slice + the outline + a target partial path, and
- * it orchestrates its own work via tools (Read, Write, Edit, Grep, Glob, Bash).
- * Self-style-check happens via `Bash dotrequirements cts style-check <path>`.
- *
- * Requirements covered:
- * - CTS-SPEC-1: per-area worker invocation
- * - CTS-SPEC-2: write partial to known path via Write tool
- * - CTS-SPEC-3: self-style-check via Bash
- * - CTS-SPEC-4: access to the full pack for cross-area context
- * - CTS-SPEC-5: failure detection and retry orchestrated by fan-out (this file
- *   produces a single attempt; fan-out wraps it with retry policy)
- */
-import { existsSync, statSync } from "node:fs";
-import { runClaude } from "./claude.js";
-import { SPECIFIER_PROMPT } from "./prompts/specifier.js";
-function buildUserMessage(ctx) {
-    return [
-        `You are specifying ONE area of the system.`,
-        ``,
-        `Area name: ${ctx.area.name}`,
-        `Area description: ${ctx.area.description}`,
-        `Document defaultPrefix: ${ctx.outline.defaultPrefix}`,
-        `Area prefix: ${ctx.area.prefix}`,
-        ``,
-        `## Customers this area serves`,
-        `(Pick one of these as the named persona for your requirements. Do not invent a different customer. If none of these is a real user of the software — e.g., all entries describe a contributor to this codebase — follow the AREA-LACKS-CUSTOMER escape in your system prompt instead of writing requirements.)`,
-        `\`\`\`json`,
-        JSON.stringify(ctx.area.customers, null, 2),
-        `\`\`\``,
-        `Use full requirement IDs of the form: ${ctx.outline.defaultPrefix}-${ctx.area.prefix}-1, ${ctx.outline.defaultPrefix}-${ctx.area.prefix}-2, etc. (sequential, 1-indexed, no zero-padding).`,
-        ``,
-        `## Paths`,
-        `- Slice (your area's files): ${ctx.slicePath}`,
-        `- Full uncompressed pack (for discovering behaviors in tests/recipes/docs): ${ctx.fullPackPath}`,
-        `- Where to write your partial: ${ctx.partialPath}`,
-        `- Validate command (run FIRST after writing your draft — deterministic syntax check):`,
-        `    Bash: ${ctx.validateCommand} ${ctx.partialPath}`,
-        `- Style-check command (run SECOND, only after validate passes — AI clarity feedback):`,
-        `    Bash: ${ctx.styleCheckCommand} ${ctx.partialPath}`,
-        ``,
-        `## Full system outline (so you know what is in scope vs. not)`,
-        `\`\`\`json`,
-        JSON.stringify(ctx.outline, null, 2),
-        `\`\`\``,
-        ``,
-        `Follow the three-phase workflow in your system prompt: draft (Phase A) → validate (Phase B) → style-check (Phase C) → confirm.`,
-    ].join("\n");
-}
-/**
- * Run a single specifier. Returns details about whether it succeeded.
- */
-export async function runSpecifier(ctx) {
-    const runner = ctx.runner ?? runClaude;
-    const result = await runner({
-        systemPrompt: SPECIFIER_PROMPT,
-        userMessage: buildUserMessage(ctx),
-        model: ctx.model,
-        tools: ["Read", "Write", "Edit", "Grep", "Glob", "Bash"],
-        addDirs: ctx.addDirs,
-    });
-    // Inspect the partial file to determine whether the specifier wrote
-    // something usable.
-    let wrotePartial = false;
-    let partialBytes = 0;
-    if (existsSync(ctx.partialPath)) {
-        try {
-            partialBytes = statSync(ctx.partialPath).size;
-            wrotePartial = partialBytes > 0;
-        }
-        catch {
-            // ignore; treat as not written
-        }
-    }
-    return {
-        wrotePartial,
-        partialBytes,
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
-    };
-}
-//# sourceMappingURL=specifier.js.map

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

@@ -1,51 +0,0 @@
-/**
- * Pipeline summary generation.
- *
- * Reads cached artifacts to assemble a structured summary of what the
- * pipeline produced. Surfaced both as JSON (parseable by wrappers like the
- * skill) and as a short human-readable block.
- *
- * Requirements covered:
- * - CTS-PRESENT-4: Final pipeline summary is surfaced
- * - CTS-OBSERVE-2 (partial): structured failure information available
- */
-import type { CachePaths } from "./cache.js";
-import { type Outline } from "./schemas.js";
-export interface PipelineSummary {
-    totalAreas: number;
-    totalRequirements: number;
-    outline: {
-        turnsUsed: number;
-        finalVerdict: string | null;
-        residualNotes: string[];
-    };
-    specifiers: {
-        completed: number;
-        missing: number;
-        /** Area names that have no usable partial. */
-        missingAreas: string[];
-    };
-    specReview: {
-        turnsUsed: number;
-        finalVerdict: string | null;
-        residualNotes: string[];
-    };
-    outputs: {
-        /** Paths under .requirements/ that were written. */
-        paths: string[];
-    };
-}
-export interface BuildSummaryInput {
-    outline: Outline;
-    paths: CachePaths;
-    /** Paths the present stage wrote (under .requirements/). */
-    outputPaths: string[];
-}
-export declare function buildPipelineSummary(input: BuildSummaryInput): PipelineSummary;
-/**
- * Render a short human-readable block for the summary. Designed to fit on a
- * small number of lines (CTS-PRESENT-4.2). Wrappers that want richer
- * presentation can read the JSON form instead.
- */
-export declare function renderSummaryText(summary: PipelineSummary): string;
-//# sourceMappingURL=summary.d.ts.map

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

@@ -1,183 +0,0 @@
-/**
- * Pipeline summary generation.
- *
- * Reads cached artifacts to assemble a structured summary of what the
- * pipeline produced. Surfaced both as JSON (parseable by wrappers like the
- * skill) and as a short human-readable block.
- *
- * Requirements covered:
- * - CTS-PRESENT-4: Final pipeline summary is surfaced
- * - CTS-OBSERVE-2 (partial): structured failure information available
- */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { sanitizeAreaName } from "./fan-out.js";
-import { parseOutlineReview, parseSpecReview, } from "./schemas.js";
-/**
- * Count top-level requirements in a file by counting fenced
- * \`\`\`dotrequirements blocks. Each block represents one root requirement
- * (CTS-OBSERVE-2 counts each requirement ID once, excluding child criteria).
- */
-function countRequirementsInFile(path) {
-    if (!existsSync(path))
-        return 0;
-    const content = readFileSync(path, "utf-8");
-    const matches = content.match(/```dotrequirements\b/g);
-    return matches ? matches.length : 0;
-}
-/**
- * Look at outline-review-N.json files in the cache and return how many turns
- * ran and what the final verdict was. Returns {turnsUsed: 0, finalVerdict: null}
- * if no review artifacts exist.
- */
-function summarizeOutlineReview(paths) {
-    let n = 0;
-    let lastReviewPath = null;
-    while (true) {
-        const path = paths.outlineReviewTurn(n + 1);
-        if (!existsSync(path))
-            break;
-        n++;
-        lastReviewPath = path;
-    }
-    if (!lastReviewPath)
-        return { turnsUsed: 0, finalVerdict: null, residualNotes: [] };
-    try {
-        const review = parseOutlineReview(readFileSync(lastReviewPath, "utf-8"));
-        const notes = [];
-        // Surface unresolved findings as residual notes if verdict isn't 'approved'.
-        if (review.verdict !== "approved") {
-            for (const cat of [
-                ["coverage_gap", review.coverage_gaps],
-                ["framing_error", review.framing_errors],
-                ["granularity", review.granularity_issues],
-                ["file_assignment", review.file_assignment_issues],
-            ]) {
-                for (const note of cat[1]) {
-                    notes.push(`outline.${cat[0]}: ${note}`);
-                }
-            }
-        }
-        return { turnsUsed: n, finalVerdict: review.verdict, residualNotes: notes };
-    }
-    catch {
-        return { turnsUsed: n, finalVerdict: null, residualNotes: [] };
-    }
-}
-function summarizeSpecReview(paths) {
-    let n = 0;
-    let lastReviewPath = null;
-    while (true) {
-        const path = paths.specReviewTurn(n + 1);
-        if (!existsSync(path))
-            break;
-        n++;
-        lastReviewPath = path;
-    }
-    if (!lastReviewPath)
-        return { turnsUsed: 0, finalVerdict: null, residualNotes: [] };
-    try {
-        const review = parseSpecReview(readFileSync(lastReviewPath, "utf-8"));
-        const notes = [];
-        if (review.verdict !== "approved") {
-            for (const cat of [
-                ["coverage_gap", review.coverage_gaps],
-                ["framing_error", review.framing_errors],
-                ["cross_area", review.cross_area_issues],
-                ["internal_mechanics", review.internal_mechanics_drift],
-            ]) {
-                for (const note of cat[1]) {
-                    notes.push(`spec.${cat[0]}: ${note}`);
-                }
-            }
-        }
-        return { turnsUsed: n, finalVerdict: review.verdict, residualNotes: notes };
-    }
-    catch {
-        return { turnsUsed: n, finalVerdict: null, residualNotes: [] };
-    }
-}
-function summarizeSpecifiers(outline, paths) {
-    let completed = 0;
-    const missingAreas = [];
-    for (const area of outline.areas) {
-        const partialPath = paths.partial(sanitizeAreaName(area.name));
-        if (!existsSync(partialPath)) {
-            missingAreas.push(area.name);
-            continue;
-        }
-        const content = readFileSync(partialPath, "utf-8").trim();
-        if (!content ||
-            content.startsWith("_(missing partial") ||
-            content.startsWith("_(no files")) {
-            missingAreas.push(area.name);
-            continue;
-        }
-        completed++;
-    }
-    return { completed, missing: missingAreas.length, missingAreas };
-}
-export function buildPipelineSummary(input) {
-    const { outline, paths, outputPaths } = input;
-    const outlineReview = summarizeOutlineReview(paths);
-    const specReview = summarizeSpecReview(paths);
-    const specifiers = summarizeSpecifiers(outline, paths);
-    // Count top-level requirements across all written .requirements/ files.
-    let totalRequirements = 0;
-    for (const path of outputPaths) {
-        totalRequirements += countRequirementsInFile(path);
-    }
-    // Fall back to counting the final cached spec if nothing was written (e.g.
-    // dry-run / interrupted) — that way the summary still reflects what the
-    // pipeline produced.
-    if (totalRequirements === 0 && existsSync(paths.specFinal)) {
-        totalRequirements = countRequirementsInFile(paths.specFinal);
-    }
-    return {
-        totalAreas: outline.areas.length,
-        totalRequirements,
-        outline: outlineReview,
-        specifiers,
-        specReview,
-        outputs: { paths: outputPaths },
-    };
-}
-/**
- * Render a short human-readable block for the summary. Designed to fit on a
- * small number of lines (CTS-PRESENT-4.2). Wrappers that want richer
- * presentation can read the JSON form instead.
- */
-export function renderSummaryText(summary) {
-    const lines = [];
-    lines.push(`Pipeline summary:`);
-    lines.push(`  Areas:               ${summary.totalAreas}`);
-    lines.push(`  Top-level reqs:      ${summary.totalRequirements}`);
-    lines.push(`  Outline review:      ${summary.outline.turnsUsed} turn(s), verdict: ${summary.outline.finalVerdict ?? "n/a"}`);
-    lines.push(`  Specifiers:          ${summary.specifiers.completed} completed, ${summary.specifiers.missing} missing`);
-    lines.push(`  Spec review:         ${summary.specReview.turnsUsed} turn(s), verdict: ${summary.specReview.finalVerdict ?? "n/a"}`);
-    lines.push(`  Output files:`);
-    for (const path of summary.outputs.paths) {
-        lines.push(`    - ${path}`);
-    }
-    if (summary.outline.residualNotes.length ||
-        summary.specReview.residualNotes.length) {
-        lines.push(``);
-        lines.push(`  Residual notes (worth reviewing manually):`);
-        for (const note of [
-            ...summary.outline.residualNotes,
-            ...summary.specReview.residualNotes,
-        ]) {
-            lines.push(`    - ${note}`);
-        }
-    }
-    if (summary.specifiers.missingAreas.length) {
-        lines.push(``);
-        lines.push(`  Missing specifier output for:`);
-        for (const area of summary.specifiers.missingAreas) {
-            lines.push(`    - ${area}`);
-        }
-    }
-    return lines.join("\n");
-}
-/** Suppress unused-var warning. */
-void statSync;
-//# sourceMappingURL=summary.js.map

package/dist/commands/codebase-to-spec/compose.d.ts

@@ -1,14 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec compose` subcommand.
- *
- * Assembles per-area partials into a single composed Markdown document.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `compose` subcommand
- * - CTS-COMPOSE-1, CTS-COMPOSE-2
- */
-export interface ComposeCmdOptions {
-    projectRoot?: string;
-}
-export declare function composeCommand(options?: ComposeCmdOptions): Promise<void>;
-//# sourceMappingURL=compose.d.ts.map

package/dist/commands/codebase-to-spec/compose.js

@@ -1,57 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec compose` subcommand.
- *
- * Assembles per-area partials into a single composed Markdown document.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `compose` subcommand
- * - CTS-COMPOSE-1, CTS-COMPOSE-2
- */
-import { existsSync } from "node:fs";
-import { cachePaths } from "../../codebase-to-spec/cache.js";
-import { runCompose } from "../../codebase-to-spec/compose.js";
-import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { StdoutProgress } from "../../codebase-to-spec/progress.js";
-import { findProjectRoot } from "../../utils/project-settings.js";
-import { readFinalOutline } from "./plan-loop.js";
-export async function composeCommand(options = {}) {
-    const progress = new StdoutProgress();
-    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
-    const paths = cachePaths(projectRoot);
-    if (!existsSync(paths.outlineFinal)) {
-        process.stderr.write(`Missing outline at ${paths.outlineFinal}. Run \`dotrequirements cts plan-loop\` first.\n`);
-        process.exitCode = ExitCode.MissingInput;
-        return;
-    }
-    const outline = readFinalOutline(projectRoot);
-    progress.emit({
-        stage: "compose",
-        step: "start",
-        message: `Composing spec from ${outline.areas.length} area partials`,
-    });
-    const result = runCompose({
-        outline,
-        partialPathFor: (sanitized) => paths.partial(sanitized),
-        composedPath: paths.composedSpec,
-    });
-    progress.emit({
-        stage: "compose",
-        step: "done",
-        message: `Composed spec → ${result.composedPath} (${result.partialsIncluded} partials included, ${result.partialsMissing} missing)`,
-        data: {
-            partialsIncluded: result.partialsIncluded,
-            partialsMissing: result.partialsMissing,
-        },
-    });
-    if (result.validationError) {
-        process.stderr.write(`Composed spec failed validation:\n${result.validationError}\n`);
-        process.exitCode = ExitCode.StageFailed;
-        return;
-    }
-    progress.emit({
-        stage: "compose",
-        step: "validation-ok",
-        message: "Composed spec passed schema validation",
-    });
-}
-//# sourceMappingURL=compose.js.map

package/dist/commands/codebase-to-spec/edit-loop.d.ts

@@ -1,16 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec edit-loop` subcommand.
- *
- * Runs the spec review + editor loop over the composed spec.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `edit-loop` subcommand
- * - CTS-EDIT-1..6: end-to-end loop behavior
- */
-export interface EditLoopCmdOptions {
-    maxTurns?: number;
-    model?: string;
-    projectRoot?: string;
-}
-export declare function editLoopCommand(rawOptions?: EditLoopCmdOptions): Promise<void>;
-//# sourceMappingURL=edit-loop.d.ts.map

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

@@ -1,83 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec edit-loop` subcommand.
- *
- * Runs the spec review + editor loop over the composed spec.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `edit-loop` subcommand
- * - CTS-EDIT-1..6: end-to-end loop behavior
- */
-import { copyFileSync, existsSync, writeFileSync } from "node:fs";
-import { cachePaths } from "../../codebase-to-spec/cache.js";
-import { DEFAULT_EDIT_LOOP_MAX_TURNS, runEditLoop, } from "../../codebase-to-spec/edit-loop.js";
-import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { StdoutProgress } from "../../codebase-to-spec/progress.js";
-import { findProjectRoot } from "../../utils/project-settings.js";
-export async function editLoopCommand(rawOptions = {}) {
-    const progress = new StdoutProgress();
-    const projectRoot = rawOptions.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
-    const paths = cachePaths(projectRoot);
-    const maxTurns = rawOptions.maxTurns ?? DEFAULT_EDIT_LOOP_MAX_TURNS;
-    if (!existsSync(paths.composedSpec)) {
-        process.stderr.write(`Missing composed spec at ${paths.composedSpec}. Run \`dotrequirements cts compose\` first.\n`);
-        process.exitCode = ExitCode.MissingInput;
-        return;
-    }
-    if (!existsSync(paths.source)) {
-        process.stderr.write(`Missing uncompressed pack at ${paths.source}. Run \`dotrequirements cts pack\` first.\n`);
-        process.exitCode = ExitCode.MissingInput;
-        return;
-    }
-    progress.emit({
-        stage: "spec-review",
-        step: "start",
-        message: `Starting spec review + edit loop (max-turns=${maxTurns})`,
-    });
-    let result;
-    try {
-        result = await runEditLoop({
-            composedSpecPath: paths.composedSpec,
-            specVersionFor: (turn) => paths.specVersion(turn),
-            fullPackPath: paths.source,
-            addDirs: [paths.root],
-            maxTurns,
-            model: rawOptions.model,
-            progress,
-        });
-    }
-    catch (err) {
-        process.stderr.write(`\nEdit loop failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        process.exitCode = ExitCode.StageFailed;
-        return;
-    }
-    // Persist per-turn reviewer output (JSON).
-    result.reviewsByTurn.forEach((review, idx) => {
-        writeFileSync(paths.specReviewTurn(idx + 1), `${JSON.stringify(review, null, 2)}\n`, "utf-8");
-    });
-    if (result.hitMaxTurns) {
-        progress.emit({
-            stage: "spec-review",
-            step: "max-turns-hit",
-            message: `Loop hit max-turns (${maxTurns}) without converging. Using latest spec anyway.`,
-            data: { turnsUsed: result.turnsUsed, finalVerdict: result.finalVerdict },
-        });
-        process.exitCode = ExitCode.MaxTurnsHit;
-    }
-    else {
-        progress.emit({
-            stage: "spec-review",
-            step: "done",
-            message: `Edit loop converged at turn ${result.turnsUsed} with verdict: ${result.finalVerdict}`,
-            data: { turnsUsed: result.turnsUsed, finalVerdict: result.finalVerdict },
-        });
-    }
-    // Copy the final post-edit spec to a stable path so downstream stages
-    // (present) and external tooling have a predictable location.
-    copyFileSync(result.finalSpecPath, paths.specFinal);
-    progress.emit({
-        stage: "spec-review",
-        step: "final-spec",
-        message: `Final spec → ${paths.specFinal}`,
-    });
-}
-//# sourceMappingURL=edit-loop.js.map

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

@@ -1,19 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec fan-out` subcommand.
- *
- * Runs the specifier for every area in the cached outline, in parallel up to
- * a bounded concurrency limit, with retry-once on failure.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `fan-out` subcommand
- * - CTS-SPEC-1.2: bounded concurrent execution
- * - CTS-SPEC-5: failure detection + retry + non-blocking continuation
- */
-export interface FanOutCmdOptions {
-    concurrency?: number;
-    model?: string;
-    cliBinary?: string;
-    projectRoot?: string;
-}
-export declare function fanOutCommand(options?: FanOutCmdOptions): Promise<void>;
-//# sourceMappingURL=fan-out.d.ts.map

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

@@ -1,77 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec fan-out` subcommand.
- *
- * Runs the specifier for every area in the cached outline, in parallel up to
- * a bounded concurrency limit, with retry-once on failure.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `fan-out` subcommand
- * - CTS-SPEC-1.2: bounded concurrent execution
- * - CTS-SPEC-5: failure detection + retry + non-blocking continuation
- */
-import { existsSync } from "node:fs";
-import { cachePaths } from "../../codebase-to-spec/cache.js";
-import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { DEFAULT_FAN_OUT_CONCURRENCY, runFanOut, } from "../../codebase-to-spec/fan-out.js";
-import { StdoutProgress } from "../../codebase-to-spec/progress.js";
-import { findProjectRoot } from "../../utils/project-settings.js";
-import { readFinalOutline } from "./plan-loop.js";
-export async function fanOutCommand(options = {}) {
-    const progress = new StdoutProgress();
-    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
-    const paths = cachePaths(projectRoot);
-    const cliBinary = options.cliBinary ?? "dotrequirements";
-    if (!existsSync(paths.outlineFinal)) {
-        process.stderr.write(`Missing outline at ${paths.outlineFinal}. Run \`dotrequirements cts plan-loop\` first.\n`);
-        process.exitCode = ExitCode.MissingInput;
-        return;
-    }
-    if (!existsSync(paths.source)) {
-        process.stderr.write(`Missing uncompressed pack at ${paths.source}. Run \`dotrequirements cts pack\` first.\n`);
-        process.exitCode = ExitCode.MissingInput;
-        return;
-    }
-    const outline = readFinalOutline(projectRoot);
-    const concurrency = options.concurrency ?? DEFAULT_FAN_OUT_CONCURRENCY;
-    progress.emit({
-        stage: "specify",
-        step: "start",
-        message: `Fan-out: ${outline.areas.length} areas (concurrency=${concurrency})`,
-    });
-    const result = await runFanOut({
-        outline,
-        fullPackPath: paths.source,
-        partialPathFor: (sanitized) => paths.partial(sanitized),
-        slicePathFor: (sanitized) => `${paths.partialsDir}/slice-${sanitized}.txt`,
-        validateCommand: `${cliBinary} cts validate`,
-        styleCheckCommand: `${cliBinary} cts style-check`,
-        addDirs: [paths.root],
-        concurrency,
-        model: options.model,
-        progress,
-    });
-    // Summary
-    const failed = result.outcomes.filter((o) => o.status === "failed");
-    const completed = result.outcomes.filter((o) => o.status === "completed");
-    const skipped = result.outcomes.filter((o) => o.status === "skipped-resume");
-    progress.emit({
-        stage: "specify",
-        step: "summary",
-        message: `Completed: ${completed.length} / Skipped (resume): ${skipped.length} / Failed: ${failed.length}`,
-        data: {
-            completed: completed.length,
-            skipped: skipped.length,
-            failed: failed.length,
-        },
-    });
-    if (failed.length > 0) {
-        for (const o of failed) {
-            process.stderr.write(`  failed: ${o.area.name} (${o.area.prefix}) — ${o.failureCause ?? "unknown"}\n`);
-        }
-        // Per CTS-SPEC-5, a failed specifier does not block the rest of the
-        // pipeline; we still let the caller decide. Surface non-zero so wrappers
-        // can react if they care.
-        process.exitCode = ExitCode.StageFailed;
-    }
-}
-//# sourceMappingURL=fan-out.js.map

package/dist/commands/codebase-to-spec/plan-loop.d.ts

@@ -1,26 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec plan-loop` subcommand.
- *
- * Reads the compressed pack from the cache and runs the outline review loop
- * (planner → reviewer → revise → ... → approved). Writes per-turn artifacts
- * and the final outline.
- *
- * Requirements covered:
- * - CTS-CLI-2: `dotrequirements cts plan-loop` runs only the outline review loop and exits
- * - CTS-PLAN-1..6: end-to-end loop behavior
- * - CTS-RESUME-1.1: skip loop if outline-final.json exists
- * - CTS-OBSERVE-1, CTS-OBSERVE-2: progress + failure observability
- */
-import type { Outline } from "../../codebase-to-spec/schemas.js";
-export interface PlanLoopOptions {
-    maxTurns?: number;
-    model?: string;
-    progress?: import("../../codebase-to-spec/progress.js").ProgressEmitter;
-    projectRoot?: string;
-}
-export declare function planLoopCommand(rawOptions?: PlanLoopOptions): Promise<void>;
-/**
- * Helper used by `cts run` and tests to consume the outline that plan-loop wrote.
- */
-export declare function readFinalOutline(projectRoot: string): Outline;
-//# sourceMappingURL=plan-loop.d.ts.map