@popoverai/dotrequirements 0.26.0 → 0.26.1

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

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

@@ -1,105 +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 { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { cachePaths } from "../../codebase-to-spec/cache.js";
-import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { DEFAULT_OUTLINE_LOOP_MAX_TURNS, runOutlineReviewLoop, } from "../../codebase-to-spec/outline-review-loop.js";
-import { StdoutProgress } from "../../codebase-to-spec/progress.js";
-import { findProjectRoot } from "../../utils/project-settings.js";
-export async function planLoopCommand(rawOptions = {}) {
-    const progress = rawOptions.progress ?? new StdoutProgress();
-    const projectRoot = rawOptions.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
-    const paths = cachePaths(projectRoot);
-    const maxTurns = rawOptions.maxTurns ?? DEFAULT_OUTLINE_LOOP_MAX_TURNS;
-    // Resume — if outline-final.json already exists, skip the loop entirely.
-    if (existsSync(paths.outlineFinal)) {
-        progress.emit({
-            stage: "plan",
-            step: "resume-skip",
-            message: `outline-final.json exists at ${paths.outlineFinal}; skipping plan loop`,
-        });
-        return;
-    }
-    // Require the compressed pack from the prior stage.
-    if (!existsSync(paths.overview)) {
-        process.stderr.write(`Missing compressed pack at ${paths.overview}. Run \`dotrequirements cts pack\` first.\n`);
-        process.exitCode = ExitCode.MissingInput;
-        return;
-    }
-    progress.emit({
-        stage: "plan",
-        step: "start",
-        message: `Starting plan + outline review loop (max-turns=${maxTurns})`,
-    });
-    let result;
-    try {
-        result = await runOutlineReviewLoop({
-            overviewPath: paths.overview,
-            addDirs: [paths.root],
-            maxTurns,
-            model: rawOptions.model,
-            progress,
-        });
-    }
-    catch (err) {
-        process.stderr.write(`\nPlan loop failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        process.exitCode = ExitCode.StageFailed;
-        return;
-    }
-    // Persist per-turn artifacts (one outline per turn, one review per turn) so
-    // we have full evidence and resumability.
-    result.outlinesByTurn.forEach((outline, idx) => {
-        const path = paths.outlineTurn(idx + 1);
-        writeFileSync(path, `${JSON.stringify(outline, null, 2)}\n`, "utf-8");
-    });
-    result.reviewsByTurn.forEach((review, idx) => {
-        const path = paths.outlineReviewTurn(idx + 1);
-        writeFileSync(path, `${JSON.stringify(review, null, 2)}\n`, "utf-8");
-    });
-    // Write the final outline.
-    writeFileSync(paths.outlineFinal, `${JSON.stringify(result.outline, null, 2)}\n`, "utf-8");
-    if (result.hitMaxTurns) {
-        progress.emit({
-            stage: "plan",
-            step: "max-turns-hit",
-            message: `Loop hit max-turns (${maxTurns}) without converging. Using latest outline anyway.`,
-            data: { turnsUsed: result.turnsUsed, finalVerdict: result.finalVerdict },
-        });
-        process.exitCode = ExitCode.MaxTurnsHit;
-    }
-    else {
-        progress.emit({
-            stage: "plan",
-            step: "done",
-            message: `Plan loop converged at turn ${result.turnsUsed} with verdict: ${result.finalVerdict}`,
-            data: { turnsUsed: result.turnsUsed, finalVerdict: result.finalVerdict },
-        });
-    }
-    progress.emit({
-        stage: "plan",
-        step: "outline-written",
-        message: `Final outline → ${paths.outlineFinal} (${result.outline.areas.length} areas)`,
-    });
-}
-/**
- * Helper used by `cts run` and tests to consume the outline that plan-loop wrote.
- */
-export function readFinalOutline(projectRoot) {
-    const paths = cachePaths(projectRoot);
-    if (!existsSync(paths.outlineFinal)) {
-        throw new Error(`Missing ${paths.outlineFinal}. Run \`cts plan-loop\` first.`);
-    }
-    return JSON.parse(readFileSync(paths.outlineFinal, "utf-8"));
-}
-//# sourceMappingURL=plan-loop.js.map

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

@@ -1,26 +0,0 @@
-/**
- * `dotrequirements codebase-to-spec present` subcommand.
- *
- * Writes the final spec to `.requirements/` and emits a pipeline summary.
- *
- * Requirements covered:
- * - CTS-CLI-2: granular `present` subcommand
- * - CTS-CLI-4: TTY-driven interactive/non-interactive selection
- * - CTS-PRESENT-1..4
- */
-export interface PresentCmdOptions {
-    /** Force --interactive or --non-interactive (overrides TTY detection). */
-    forceMode?: "interactive" | "non-interactive";
-    /** Replace existing .requirements/ files without prompting (non-interactive). */
-    overwrite?: boolean;
-    /** Skip writing files that would conflict (non-interactive). */
-    skipExisting?: boolean;
-    /**
-     * When true, write output under `.requirements/cts/` instead of
-     * `.requirements/`. See CTS-PRESENT-5.
-     */
-    ignoreRequirements?: boolean;
-    projectRoot?: string;
-}
-export declare function presentCommand(rawOptions?: PresentCmdOptions): Promise<void>;
-//# sourceMappingURL=present.d.ts.map