@popoverai/dotrequirements 0.26.0 → 0.26.1

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

@@ -12,10 +12,10 @@
  * - CTSO-CONV-3: orchestrator dispatches an editor when revisions are needed
  */
 import { existsSync, readFileSync } from "node:fs";
+import { sanitizeAreaName } from "../../codebase-to-spec/area-name.js";
 import { cachePaths } from "../../codebase-to-spec/cache.js";
 import { EDITOR_DISPATCH_ID_PREFIX } from "../../codebase-to-spec/dispatch.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { sanitizeAreaName } from "../../codebase-to-spec/fan-out.js";
 import { parseConversationalOutline, } from "../../codebase-to-spec/schemas.js";
 import { findProjectRoot } from "../../utils/project-settings.js";
 export async function dispatchEditorCommand(areaPrefix) {

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

@@ -10,10 +10,10 @@
  * the orchestrator should approve the outline before fan-out.
  */
 import { existsSync, readFileSync } from "node:fs";
+import { sanitizeAreaName } from "../../codebase-to-spec/area-name.js";
 import { cachePaths } from "../../codebase-to-spec/cache.js";
 import { SPECIFIER_DISPATCH_ID_PREFIX } from "../../codebase-to-spec/dispatch.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { sanitizeAreaName } from "../../codebase-to-spec/fan-out.js";
 import { parseConversationalOutline, } from "../../codebase-to-spec/schemas.js";
 import { findProjectRoot } from "../../utils/project-settings.js";
 export async function dispatchSpecCommand() {

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

@@ -5,30 +5,23 @@
  * be invoked granularly (e.g., `dotrequirements cts pack`) per CTS-CLI-2.
  */
 import { installCtsAbortHandlers } from "../../codebase-to-spec/progress.js";
-import { composeCommand } from "./compose.js";
 import { composeOrchestratorCommand } from "./compose-orchestrator.js";
 import { dispatchContextCommand } from "./dispatch-context.js";
 import { dispatchEditorCommand } from "./dispatch-editor.js";
 import { dispatchPlannerCommand } from "./dispatch-planner.js";
 import { dispatchSpecCommand } from "./dispatch-spec.js";
-import { editLoopCommand } from "./edit-loop.js";
-import { fanOutCommand } from "./fan-out.js";
 import { packCommand } from "./pack.js";
-import { planLoopCommand } from "./plan-loop.js";
-import { presentCommand } from "./present.js";
 import { presentOrchestratorCommand } from "./present-orchestrator.js";
-import { runCommand } from "./run.js";
 import { skillInstallCommand } from "./skill-install.js";
-import { specifyAreaCommand } from "./specify-area.js";
 import { styleCheckCommand } from "./style-check.js";
 import { validateCommand } from "./validate.js";
 /**
  * Marker used to hide a command from `--help` output without removing it.
- * Used for dark-ship: the conversational orchestrator's plumbing commands and
- * the skill-install entry point ship in the npm package but aren't surfaced
- * in help listings or documentation. They remain fully invocable (the
- * orchestrator skill calls them by name) — they just don't pollute the
- * user-facing CLI surface until we flip the default path in Phase 6.
+ * The conversational orchestrator's plumbing commands (the `dispatch-*` payload
+ * builders and the `-orchestrator` compose/present variants) and the
+ * skill-install entry point ship in the npm package but aren't surfaced in help
+ * listings — they're invoked by name by the orchestrator skill and workflow,
+ * not by users, so they stay out of the user-facing CLI surface.
  */
 const HIDDEN = { hidden: true };
 export function registerCodebaseToSpec(program) {
@@ -37,9 +30,8 @@ export function registerCodebaseToSpec(program) {
         .alias("cts")
         .description("Generate dotrequirements behavioral specifications from a codebase");
     // Install SIGTERM/SIGINT handlers for every cts subcommand so an interrupted
-    // pipeline emits a structured `pipeline/aborted` line before exiting
-    // (CTS-OBSERVE-1.5). preAction fires after argv parsing and before the
-    // subcommand action runs.
+    // stage emits a structured `pipeline/aborted` line before exiting. preAction
+    // fires after argv parsing and before the subcommand action runs.
     cts.hook("preAction", () => {
         installCtsAbortHandlers();
     });
@@ -52,31 +44,6 @@ export function registerCodebaseToSpec(program) {
         .option("--budget <tokens>", "Override the working-context budget (in tokens)", (v) => parseInt(v, 10))
         .option("--ignore-requirements", "Exclude `.requirements/**` from the pack (use when testing cts against a codebase whose existing requirements should not influence the output)")
         .action((opts) => packCommand({ ...opts, budgetTokens: opts.budget }));
-    cts
-        .command("plan-loop")
-        .description("Run the planner + outline review loop on the cached pack")
-        .option("--max-turns <n>", "Hard cap on review turns", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by the planner and reviewer")
-        .action((opts) => planLoopCommand({
-        maxTurns: opts.maxTurns,
-        model: opts.model,
-    }));
-    cts
-        .command("specify-area <name>")
-        .description("Run the specifier for one named area from the cached outline")
-        .option("--model <name>", "Override the model used by the specifier")
-        .action((name, opts) => specifyAreaCommand(name, {
-        model: opts.model,
-    }));
-    cts
-        .command("fan-out")
-        .description("Run all specifiers in parallel for areas in the cached outline")
-        .option("-c, --concurrency <n>", "Max concurrent specifiers", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by specifiers")
-        .action((opts) => fanOutCommand({
-        concurrency: opts.concurrency,
-        model: opts.model,
-    }));
     cts
         .command("validate <partial-path>")
         .description("Validate the schema/syntax of a partial-spec file (deterministic, offline)")
@@ -86,69 +53,6 @@ export function registerCodebaseToSpec(program) {
         .description("Run a local style-check on a partial-spec file (severity-categorized feedback)")
         .option("--model <name>", "Override the model used for the check")
         .action((partialPath, opts) => styleCheckCommand(partialPath, { model: opts.model }));
-    cts
-        .command("compose")
-        .description("Assemble per-area partials into a single composed spec")
-        .action(() => composeCommand());
-    cts
-        .command("edit-loop")
-        .description("Run the spec reviewer + editor loop on the composed spec")
-        .option("--max-turns <n>", "Hard cap on edit-loop turns", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by the reviewer and editor")
-        .action((opts) => editLoopCommand({
-        maxTurns: opts.maxTurns,
-        model: opts.model,
-    }));
-    cts
-        .command("present")
-        .description("Write the final spec to .requirements/ and emit a pipeline summary")
-        .option("--interactive", "Force interactive mode (override TTY detection)")
-        .option("--non-interactive", "Force non-interactive mode (override TTY detection)")
-        .option("--overwrite", "Replace existing .requirements/ files without prompting")
-        .option("--skip-existing", "Leave existing .requirements/ files untouched")
-        .option("--ignore-requirements", "Write output to `.requirements/cts/` instead of `.requirements/` (use together with `cts pack --ignore-requirements` when isolating cts from an existing requirements directory)")
-        .action((opts) => {
-        const forceMode = opts.interactive
-            ? "interactive"
-            : opts.nonInteractive
-                ? "non-interactive"
-                : undefined;
-        return presentCommand({
-            forceMode,
-            overwrite: opts.overwrite,
-            skipExisting: opts.skipExisting,
-            ignoreRequirements: opts.ignoreRequirements,
-        });
-    });
-    cts
-        .command("run")
-        .description("Run the full pipeline (pack → plan → specify → compose → edit → present)")
-        .option("-s, --scope <path>", "Limit to files under this path (subdir of project root)")
-        .option("--fresh", "Clear the cache before running")
-        .option("--budget <tokens>", "Override the working-context budget (in tokens)", (v) => parseInt(v, 10))
-        .option("--max-turns <n>", "Hard cap on outline review turns", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by agent calls")
-        .option("--interactive", "Force interactive mode for the present stage")
-        .option("--non-interactive", "Force non-interactive mode for the present stage")
-        .option("--overwrite", "Replace existing .requirements/ files without prompting")
-        .option("--skip-existing", "Leave existing .requirements/ files untouched")
-        .option("--ignore-requirements", "Exclude `.requirements/**` from the pack and write output to `.requirements/cts/` instead of `.requirements/` (use when testing cts against a codebase whose existing requirements should not influence the output)")
-        .action((opts) => {
-        const forceMode = opts.interactive
-            ? "interactive"
-            : opts.nonInteractive
-                ? "non-interactive"
-                : undefined;
-        return runCommand({
-            ...opts,
-            budgetTokens: opts.budget,
-            maxTurns: opts.maxTurns,
-            forceMode,
-            overwrite: opts.overwrite,
-            skipExisting: opts.skipExisting,
-            ignoreRequirements: opts.ignoreRequirements,
-        });
-    });
     cts
         .command("dispatch-context <dispatch-id>", HIDDEN)
         .description("Return the composed prompt for a worker dispatch as JSON on stdout (run by cts-worker subagents to fetch their dispatch prompt)")

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

@@ -12,7 +12,7 @@
  */
 import { resolve } from "node:path";
 import { checkBudget, countTokensInFileExact, DEFAULT_BUDGET_TOKENS, formatBudgetExceededMessage, } from "../../codebase-to-spec/budget.js";
-import { clearCache, ensureCacheDir } from "../../codebase-to-spec/cache.js";
+import { clearCache, ensureCacheDir, writeRunConfig, } from "../../codebase-to-spec/cache.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
 import { runPack } from "../../codebase-to-spec/pack.js";
 import { StdoutProgress } from "../../codebase-to-spec/progress.js";
@@ -35,6 +35,13 @@ export async function packCommand(rawOptions = {}) {
         clearCache(projectRoot);
     }
     const paths = ensureCacheDir(projectRoot);
+    // Record the isolation decision once, here, so later stages (present) honor
+    // it without the caller — or the orchestrating agent — having to carry it
+    // across the run. Written on every pack so a re-pack without the flag clears
+    // a stale isolated marker. See CTS-PRESENT-5.2.
+    writeRunConfig(projectRoot, {
+        isolated: rawOptions.ignoreRequirements === true,
+    });
     const scope = rawOptions.scope
         ? resolve(projectRoot, rawOptions.scope)
         : undefined;

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

@@ -8,13 +8,15 @@
  * rather than specFinal.
  *
  * Requirements covered:
- * - CTS-PRESENT-1..4 (reuses the legacy present logic)
+ * - CTS-PRESENT-1..3 (shared present logic in present.ts)
  * - CTSO-INTEG-1: orchestrator uses existing deterministic stages unchanged
  */
 export interface PresentOrchestratorOptions {
     forceMode?: "interactive" | "non-interactive";
     overwrite?: boolean;
     skipExisting?: boolean;
+    /** Override the project root, mainly for tests. */
+    projectRoot?: string;
 }
 export declare function presentOrchestratorCommand(options?: PresentOrchestratorOptions): Promise<void>;
 //# sourceMappingURL=present-orchestrator.d.ts.map

package/dist/commands/codebase-to-spec/present-orchestrator.js

@@ -8,11 +8,11 @@
  * rather than specFinal.
  *
  * Requirements covered:
- * - CTS-PRESENT-1..4 (reuses the legacy present logic)
+ * - CTS-PRESENT-1..3 (shared present logic in present.ts)
  * - CTSO-INTEG-1: orchestrator uses existing deterministic stages unchanged
  */
 import { existsSync, readFileSync } from "node:fs";
-import { cachePaths } from "../../codebase-to-spec/cache.js";
+import { cachePaths, readRunConfig } from "../../codebase-to-spec/cache.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
 import { detectMode } from "../../codebase-to-spec/interactive.js";
 import { runPresent, } from "../../codebase-to-spec/present.js";
@@ -31,7 +31,7 @@ function resolvePolicy(isInteractive, options) {
     return "fail-fast";
 }
 export async function presentOrchestratorCommand(options = {}) {
-    const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
     const paths = cachePaths(projectRoot);
     if (!existsSync(paths.outline)) {
         process.stderr.write(`No outline.yaml found at ${paths.outline}. Run the orchestrator's planner first.\n`);
@@ -60,11 +60,17 @@ export async function presentOrchestratorCommand(options = {}) {
         return;
     }
     const legacyOutline = conversationalOutlineToLegacy(outline);
+    // Honor the isolation decision recorded at pack time (CTS-PRESENT-5.2). When
+    // the run is isolated, write under `.requirements/cts/` so the existing
+    // requirements directory is never overwritten — the choice rides the cache,
+    // not the agent's memory, so it holds even across a resumed or compacted run.
+    const { isolated } = readRunConfig(projectRoot);
     const result = await runPresent({
         outline: legacyOutline,
         finalSpecPath: paths.composedSpec,
         projectRoot,
         overwritePolicy: policy,
+        outputSubdir: isolated ? "cts" : undefined,
     });
     if (!result.allWritten) {
         if (result.conflictPath) {
@@ -76,6 +82,7 @@ export async function presentOrchestratorCommand(options = {}) {
     for (const action of result.actions) {
         process.stdout.write(`  ${action.action}: ${action.path}\n`);
     }
-    process.stdout.write(`Wrote ${result.actions.filter((a) => a.action === "created" || a.action === "overwrote").length} file(s) to .requirements/\n`);
+    const outputDirLabel = isolated ? ".requirements/cts/" : ".requirements/";
+    process.stdout.write(`Wrote ${result.actions.filter((a) => a.action === "created" || a.action === "overwrote").length} file(s) to ${outputDirLabel}\n`);
 }
 //# sourceMappingURL=present-orchestrator.js.map

package/dist/templates/skills/codebase-to-spec/SKILL.md

@@ -19,7 +19,7 @@ Do **not** use for new-feature design (use the `dotreq-requirements` skill), bug
 
 This skill runs its pipeline as a dynamic Workflow. If the `Workflow` tool is not available in this environment, **stop** and tell the user:
 
-> "codebase-to-spec runs as a dynamic workflow, which this Claude Code version/configuration doesn't support. For CI or headless use, run `{{DOTREQ_CLI}} cts run --scope <path>` instead."
+> "codebase-to-spec runs as a dynamic workflow, which this Claude Code version/configuration doesn't support. Update to a build with dynamic-workflow support to run it."
 
 Do not attempt a non-workflow fallback.
 
@@ -33,9 +33,15 @@ If the user gave a scope (a path), use it. Otherwise ask one concise question:
 
 For large codebases, encourage scoping to a single area — the pack has a context budget.
 
+**Isolation check.** Before packing, check whether the target project already has a dotrequirements spec (a `.requirements/` directory). If it does, the user is likely re-running CTS on an already-specced codebase — often a dogfood or a quality eval — and the present stage would otherwise write over that spec. Offer an isolated run:
+
+> "This project already has a `.requirements/` spec. Want me to isolate this run — ignore the existing spec as input, and write my output to `.requirements/cts/` so I never touch what's there? Or proceed normally and treat the existing spec as part of the codebase?"
+
+On accept, run pack with `--ignore-requirements` in step 2; the decision is recorded with the run, so present honors it automatically — you don't pass it again. On decline, or when there's no `.requirements/`, pack normally. (CTSO-CONV-9.)
+
 ### 2. Pack (deterministic)
 
-Run `{{DOTREQ_CLI}} cts pack --scope <PATH>` via Bash. Deterministic, no LLM. It emits `[CTS] pack/done` then `pack/budget-ok`, or exits **10 (BudgetExceeded)** if the compressed pack is too large. On BudgetExceeded, surface the limit and offer a narrower scope (back to step 1).
+Run `{{DOTREQ_CLI}} cts pack --scope <PATH>` via Bash — add `--ignore-requirements` if the user accepted isolation in step 1. Deterministic, no LLM. It emits `[CTS] pack/done` then `pack/budget-ok`, or exits **10 (BudgetExceeded)** if the compressed pack is too large. On BudgetExceeded, surface the limit and offer a narrower scope (back to step 1).
 
 **Stale install gate.** If pack also emits a `pack/stale-version` line, this install of codebase-to-spec is out of date. Before launching the workflow, tell the user (naming both versions from the line) and offer to refresh:
 
@@ -66,7 +72,7 @@ The workflow returns one of:
 ### 5. Present (deterministic)
 
 On `status: "done"`, the workflow has already composed the spec and run the cross-area pass. Write the final file(s):
-- `{{DOTREQ_CLI}} cts present-orchestrator` — writes the composed spec to file(s) under `.requirements/`.
+- `{{DOTREQ_CLI}} cts present-orchestrator` — writes the composed spec to file(s) under `.requirements/`. For an isolated run (step 1), it writes under `.requirements/cts/` instead — it reads the decision recorded at pack time, so you pass no flag here.
 
 `present-orchestrator` errors on existing-file conflicts unless given `--overwrite` or `--skip-existing`. When a conflict is reported, ask the user which they want, then re-run with that flag.
 
@@ -104,4 +110,4 @@ If the user declines the team-review offer, note that it stands for later and do
 
 ## Host portability
 
-This skill requires Claude Code with dynamic-workflow support (it launches the `specify-codebase` workflow). On hosts without it, or for CI/headless use, the legacy `{{DOTREQ_CLI}} cts run` CLI runs the same pipeline non-interactively.
+This skill requires Claude Code with dynamic-workflow support (it launches the `specify-codebase` workflow). There is no non-workflow fallback; on hosts without dynamic-workflow support, codebase-to-spec is unavailable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popoverai/dotrequirements",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "description": "Requirements tracking CLI, test harness, and MCP server",
   "type": "module",
   "bin": {

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

@@ -1,54 +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 { type ClaudeRunner } from "./claude.js";
-import type { ProgressEmitter } from "./progress.js";
-import { type SpecReview } from "./schemas.js";
-export declare const DEFAULT_EDIT_LOOP_MAX_TURNS = 6;
-export interface EditLoopOptions {
-    /** Path to the composed spec (input). */
-    composedSpecPath: string;
-    /**
-     * Resolver: given a turn number (1-indexed), return the path the editor's
-     * output for that turn should land at. Loop persists each version.
-     */
-    specVersionFor: (turn: number) => string;
-    /** Path to the codebase pack. */
-    fullPackPath: string;
-    /** Directories for filesystem access. */
-    addDirs: string[];
-    maxTurns?: number;
-    runner?: ClaudeRunner;
-    model?: string;
-    progress?: ProgressEmitter;
-    /** Override session id (for tests / reproducibility). */
-    sessionId?: string;
-}
-export interface EditLoopResult {
-    /** Path to the final spec (post-edit if applicable). */
-    finalSpecPath: string;
-    /** Per-turn spec paths (turn 1 is the composed-spec copy, then each revision). */
-    specPathsByTurn: string[];
-    /** Per-turn reviewer results. */
-    reviewsByTurn: SpecReview[];
-    /** The final reviewer verdict. */
-    finalVerdict: SpecReview["verdict"];
-    /** Number of review turns used. */
-    turnsUsed: number;
-    /** True if the loop hit max-turns without converging. */
-    hitMaxTurns: boolean;
-}
-export declare function runEditLoop(options: EditLoopOptions): Promise<EditLoopResult>;
-//# sourceMappingURL=edit-loop.d.ts.map

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