@popoverai/dotrequirements 0.26.0 → 0.26.2

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/dist/utils/env.js

@@ -23,7 +23,7 @@ export function loadEnvFile(cwd = process.cwd(), force = false) {
             const match = line.match(/^([^=]+)=(.*)$/);
             if (match) {
                 const key = match[1].trim();
-                const value = match[2].trim();
+                const value = stripSurroundingQuotes(match[2].trim());
                 // Set if force=true, or if not already in process.env
                 if (force || !process.env[key]) {
                     process.env[key] = value;
@@ -36,4 +36,20 @@ export function loadEnvFile(cwd = process.cwd(), force = false) {
         // The commands will error appropriately if env vars are missing
     }
 }
+/**
+ * Strip a single matching pair of surrounding single or double quotes from a
+ * value, matching dotenv behavior. Credentials written in standard
+ * dotenv/Next.js style (KEY="value") should not carry the quote characters
+ * into process.env. Mismatched or interior quotes are left untouched.
+ */
+function stripSurroundingQuotes(value) {
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if ((first === '"' || first === "'") && first === last) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
 //# sourceMappingURL=env.js.map

package/dist/utils/oauth-flow.js

@@ -32,6 +32,14 @@ export async function executeOAuthFlow() {
         port: 3010,
         timeoutMs: 120000,
     });
+    // Attach a no-op rejection handler immediately. startCallbackServer can
+    // reject synchronously-adjacent to creation (e.g. listen EADDRINUSE when the
+    // callback port is busy), but the real handler isn't awaited until after the
+    // browser launch below. Without this, an early rejection has no handler and
+    // Node escalates it to a fatal unhandledRejection, bypassing wrapCommand's
+    // clean CLI error formatting. The awaited `callbackPromise` below still sees
+    // the rejection and surfaces it as a normal thrown error.
+    callbackPromise.catch(() => { });
     // Build authorization URL
     const authUrl = buildAuthorizationUrl({
         clientId: WORKOS_CLIENT_ID,

package/dist/utils/project-settings.d.ts

@@ -54,6 +54,10 @@ export declare function readProjectSettings(projectRoot: string): ProjectSetting
 /**
  * Write project settings to .requirements/project-settings.json
  * Creates .requirements/ directory if it doesn't exist
+ *
+ * SETTINGS-2.3/2.4: fields being written replace the stored ones, but any
+ * other existing settings (defaultURL, browserTest, ...) survive — re-linking
+ * with fresh credentials must not erase the rest of the file.
  */
 export declare function writeProjectSettings(projectRoot: string, settings: ProjectSettings): void;
 /**

package/dist/utils/project-settings.js

@@ -106,6 +106,10 @@ export function readProjectSettings(projectRoot) {
 /**
  * Write project settings to .requirements/project-settings.json
  * Creates .requirements/ directory if it doesn't exist
+ *
+ * SETTINGS-2.3/2.4: fields being written replace the stored ones, but any
+ * other existing settings (defaultURL, browserTest, ...) survive — re-linking
+ * with fresh credentials must not erase the rest of the file.
  */
 export function writeProjectSettings(projectRoot, settings) {
     const requirementsDir = path.join(projectRoot, REQUIREMENTS_DIR);
@@ -114,7 +118,16 @@ export function writeProjectSettings(projectRoot, settings) {
     if (!fs.existsSync(requirementsDir)) {
         fs.mkdirSync(requirementsDir, { recursive: true });
     }
-    const content = `${JSON.stringify(settings, null, 2)}\n`;
+    let existing;
+    try {
+        existing = readProjectSettings(projectRoot);
+    }
+    catch {
+        // Unreadable or invalid existing file: nothing preservable, write fresh
+        existing = undefined;
+    }
+    const merged = existing ? { ...existing, ...settings } : settings;
+    const content = `${JSON.stringify(merged, null, 2)}\n`;
     fs.writeFileSync(settingsPath, content, "utf-8");
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popoverai/dotrequirements",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "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

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