@popoverai/dotrequirements 0.24.2 → 0.24.3

package/README.md

@@ -249,7 +249,6 @@ Generate behavioral requirements from an existing codebase. Packs the codebase,
 dotreq cts run --scope src                 # full pipeline end-to-end
 dotreq cts run --scope src --fresh         # discard cache and start over
 dotreq cts run --scope src --ignore-requirements   # run against a codebase that already has its own .requirements/
-dotreq cts skill-install                   # install the conversational skill wrapper
 ```
 
 `cts` shells out to `claude -p` and uses whatever auth mode you've configured for Claude Code. Each pipeline stage is also runnable on its own (`dotreq cts pack`, `plan-loop`, `fan-out`, `compose`, `edit-loop`, `present`) for partial re-runs and debugging.

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

@@ -38,6 +38,12 @@ export interface CachePaths {
     specFinal: string;
     /** Final pipeline summary JSON, surfaced by present and consumed by wrappers. */
     pipelineSummary: string;
+    /**
+     * Conversational orchestrator outline — single YAML file that evolves
+     * across the run (Phase 2b refactor). Carries content + review.thread
+     * lifecycle state inline. Distinct from the legacy outline-N.json files.
+     */
+    outline: string;
 }
 export declare function cachePaths(projectRoot: string): CachePaths;
 export declare function ensureCacheDir(projectRoot: string): CachePaths;

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

@@ -29,6 +29,7 @@ export function cachePaths(projectRoot) {
         specReviewTurn: (n) => join(root, `spec-review-${n}.json`),
         specFinal: join(root, "spec-final.md"),
         pipelineSummary: join(root, "pipeline-summary.json"),
+        outline: join(root, "outline.yaml"),
     };
 }
 export function ensureCacheDir(projectRoot) {

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

@@ -0,0 +1,69 @@
+/**
+ * Dispatch-context composition for the conversational orchestrator.
+ *
+ * The orchestrator's PreToolUse hook calls `dotrequirements cts dispatch-context
+ * <dispatch-id>` to fetch the composed prompt that should be injected into a
+ * cts-worker subagent's first turn (per CTSO-CLI-1).
+ *
+ * Recognized dispatch IDs:
+ * - `phase1-test` — mechanical plumbing test (Phase 1)
+ * - `planner-initial` — initial planner dispatch; writes outline.yaml
+ * - `planner-revise-<turn>` — revising planner dispatch; reads the prior
+ *   outline.yaml (with its review.thread), applies the latest thread
+ *   entry's revisions, writes a new outline.yaml. `<turn>` is the round
+ *   number being PRODUCED (turn 2 = first revision).
+ *
+ * Future phases will add `specifier-<area>`, `editor-<area>`, etc.
+ *
+ * Requirements covered:
+ * - CTSO-CLI-1: CLI exposes commands that return dispatch instructions
+ * - CTSO-CONV-2: orchestrator iterates on the planner's outline until approved
+ */
+export interface DispatchContext {
+    /**
+     * The full composed prompt the worker subagent should receive as its first
+     * turn. Includes the persona body + paths + any prior-round context needed
+     * to ground the worker's behavior.
+     */
+    prompt: string;
+}
+/** Phase 1 dispatch-id used to validate the mechanical plumbing end-to-end. */
+export declare const PHASE1_TEST_DISPATCH_ID = "phase1-test";
+/** Phase 1 token the test worker echoes back. */
+export declare const PHASE1_TEST_TOKEN = "PHASE1-WORKER-OK token=CTS9X";
+/** Phase 2 dispatch-id for the initial planner pass. */
+export declare const PLANNER_INITIAL_DISPATCH_ID = "planner-initial";
+/**
+ * Phase 2b dispatch-id prefix for planner revise dispatches. Suffix is the
+ * turn number being PRODUCED (e.g., `planner-revise-2` produces the
+ * second turn's outline, reading the prior outline + its latest review
+ * thread entry as inputs).
+ */
+export declare const PLANNER_REVISE_DISPATCH_ID_PREFIX = "planner-revise-";
+/**
+ * Phase 3 dispatch-id prefix for specifier dispatches. Suffix is the area's
+ * prefix from the approved outline (e.g., `specifier-PLAN` runs the
+ * specifier for the PLAN area).
+ */
+export declare const SPECIFIER_DISPATCH_ID_PREFIX = "specifier-";
+/**
+ * Phase 4 dispatch-id prefix for editor dispatches. Suffix is the area's
+ * prefix (e.g., `editor-PLAN` revises the PLAN area's partial based on
+ * the latest area.review.thread entry's revisions).
+ */
+export declare const EDITOR_DISPATCH_ID_PREFIX = "editor-";
+export interface ComposeDispatchOptions {
+    /**
+     * Project root used to resolve cache paths. Defaults to `findProjectRoot()`
+     * starting from cwd. Tests pass a temp directory.
+     */
+    projectRoot?: string;
+}
+/**
+ * Compose the dispatch context for a given dispatch-id.
+ *
+ * @returns the composed dispatch context, or `null` if the id is unknown
+ *          or required inputs (cache files) are missing.
+ */
+export declare function composeDispatchContext(dispatchId: string, options?: ComposeDispatchOptions): DispatchContext | null;
+//# sourceMappingURL=dispatch.d.ts.map

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

@@ -0,0 +1,484 @@
+/**
+ * Dispatch-context composition for the conversational orchestrator.
+ *
+ * The orchestrator's PreToolUse hook calls `dotrequirements cts dispatch-context
+ * <dispatch-id>` to fetch the composed prompt that should be injected into a
+ * cts-worker subagent's first turn (per CTSO-CLI-1).
+ *
+ * Recognized dispatch IDs:
+ * - `phase1-test` — mechanical plumbing test (Phase 1)
+ * - `planner-initial` — initial planner dispatch; writes outline.yaml
+ * - `planner-revise-<turn>` — revising planner dispatch; reads the prior
+ *   outline.yaml (with its review.thread), applies the latest thread
+ *   entry's revisions, writes a new outline.yaml. `<turn>` is the round
+ *   number being PRODUCED (turn 2 = first revision).
+ *
+ * Future phases will add `specifier-<area>`, `editor-<area>`, etc.
+ *
+ * Requirements covered:
+ * - CTSO-CLI-1: CLI exposes commands that return dispatch instructions
+ * - CTSO-CONV-2: orchestrator iterates on the planner's outline until approved
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { findProjectRoot } from "../utils/project-settings.js";
+import { cachePaths } from "./cache.js";
+import { sanitizeAreaName } from "./fan-out.js";
+import { EDITOR_PROMPT } from "./prompts/editor.js";
+import { PLANNER_INITIAL_PROMPT } from "./prompts/planner-initial.js";
+import { PLANNER_REVISE_PROMPT } from "./prompts/planner-revise.js";
+import { SPECIFIER_PROMPT } from "./prompts/specifier.js";
+import { parseConversationalOutline, } from "./schemas.js";
+/** Phase 1 dispatch-id used to validate the mechanical plumbing end-to-end. */
+export const PHASE1_TEST_DISPATCH_ID = "phase1-test";
+/** Phase 1 token the test worker echoes back. */
+export const PHASE1_TEST_TOKEN = "PHASE1-WORKER-OK token=CTS9X";
+/** Phase 2 dispatch-id for the initial planner pass. */
+export const PLANNER_INITIAL_DISPATCH_ID = "planner-initial";
+/**
+ * Phase 2b dispatch-id prefix for planner revise dispatches. Suffix is the
+ * turn number being PRODUCED (e.g., `planner-revise-2` produces the
+ * second turn's outline, reading the prior outline + its latest review
+ * thread entry as inputs).
+ */
+export const PLANNER_REVISE_DISPATCH_ID_PREFIX = "planner-revise-";
+/**
+ * Phase 3 dispatch-id prefix for specifier dispatches. Suffix is the area's
+ * prefix from the approved outline (e.g., `specifier-PLAN` runs the
+ * specifier for the PLAN area).
+ */
+export const SPECIFIER_DISPATCH_ID_PREFIX = "specifier-";
+/**
+ * Phase 4 dispatch-id prefix for editor dispatches. Suffix is the area's
+ * prefix (e.g., `editor-PLAN` revises the PLAN area's partial based on
+ * the latest area.review.thread entry's revisions).
+ */
+export const EDITOR_DISPATCH_ID_PREFIX = "editor-";
+/**
+ * Compose the dispatch context for a given dispatch-id.
+ *
+ * @returns the composed dispatch context, or `null` if the id is unknown
+ *          or required inputs (cache files) are missing.
+ */
+export function composeDispatchContext(dispatchId, options = {}) {
+    if (dispatchId === PHASE1_TEST_DISPATCH_ID) {
+        return composePhase1Test();
+    }
+    if (dispatchId === PLANNER_INITIAL_DISPATCH_ID) {
+        return composePlannerInitial(options);
+    }
+    if (dispatchId.startsWith(PLANNER_REVISE_DISPATCH_ID_PREFIX)) {
+        const turnText = dispatchId.slice(PLANNER_REVISE_DISPATCH_ID_PREFIX.length);
+        const turn = Number.parseInt(turnText, 10);
+        if (!Number.isFinite(turn) || turn < 2 || String(turn) !== turnText) {
+            return null;
+        }
+        return composePlannerRevise(turn, options);
+    }
+    if (dispatchId.startsWith(SPECIFIER_DISPATCH_ID_PREFIX)) {
+        const areaPrefix = dispatchId.slice(SPECIFIER_DISPATCH_ID_PREFIX.length);
+        if (!areaPrefix)
+            return null;
+        return composeSpecifier(areaPrefix, options);
+    }
+    if (dispatchId.startsWith(EDITOR_DISPATCH_ID_PREFIX)) {
+        const areaPrefix = dispatchId.slice(EDITOR_DISPATCH_ID_PREFIX.length);
+        if (!areaPrefix)
+            return null;
+        return composeEditor(areaPrefix, options);
+    }
+    return null;
+}
+function composePhase1Test() {
+    return {
+        prompt: [
+            "You are the Phase 1 mechanical-plumbing test worker for the",
+            "codebase-to-spec conversational orchestrator.",
+            "",
+            "Reply with exactly the following text and nothing else:",
+            "",
+            PHASE1_TEST_TOKEN,
+        ].join("\n"),
+    };
+}
+/**
+ * YAML overlay applied on top of both planner prompts. Overrides their
+ * "output JSON" instructions and adds per-area customer guidance.
+ *
+ * Designed as a single shared block since the schema, customer guidance,
+ * and format override apply identically to initial + revise dispatches.
+ */
+const PLANNER_YAML_OVERLAY = `---
+
+## Output format — read carefully, this OVERRIDES the system prompt above
+
+The system prompt above instructs you to output a JSON object. **This dispatch overrides that.** Your output format is YAML, not JSON. Follow the YAML schema below.
+
+The schema also includes per-area \`customers\` and renames \`files\` to \`source_files\`. Both are new fields not present in the system prompt's schema description.
+
+## YAML output schema
+
+Your output is a YAML document with this structure (every field below is required unless marked optional):
+
+\`\`\`yaml
+title: <string>
+defaultPrefix: <uppercase identifier, distinct from any area prefix>
+summary: |
+  <multi-line prose summarizing the system: what it is, who it's for>
+review: # OPTIONAL — present only when revising; preserve from input verbatim
+  result: approved | needs-revision
+  thread:
+    - result: approved | needs-revision
+      revisions: # only when result is needs-revision; ≥1 entries
+        - <string>
+areas:
+  - name: <string — read in customer vocabulary>
+    prefix: <uppercase identifier, unique within document>
+    description: |
+      <multi-line prose grounding this area in customer behavior>
+    source_files: [<file paths from the pack>]
+    customers:
+      - description: |
+          <multi-line prose: SPECIFIC, area-scoped customer description>
+\`\`\`
+
+## Per-area customer guidance (NEW field — read carefully)
+
+For EACH area, identify the customer(s) who care about that area's behaviors. Write each customer description fresh, specific to who interacts with THAT area:
+
+- Not "developer" but "a CTS operator at the planning checkpoint, deciding whether CTS understood their codebase well enough to fan-out specifiers"
+- Not "user" but the concrete role and the specific situation they're in when this area's behaviors matter
+- The same role appearing in multiple areas may have DIFFERENT needs at different moments; describe each occurrence freshly
+- If you find yourself writing the same generic description across areas, that's a smell — either your customers aren't specific enough OR your areas aren't customer-distinct
+
+There is no project-level customer list. Each area's customers are defined inline, area-scoped.
+
+## Schema validation reminders
+
+- \`defaultPrefix\` and each area's \`prefix\` must be uppercase alphanumeric/underscore (regex: \`/^[A-Z][A-Z0-9_]*$/\`).
+- Area prefixes must be unique within the document AND distinct from \`defaultPrefix\`.
+- \`source_files\` paths must match the \`File: <path>\` headers in the pack exactly.
+- Each area must have ≥1 customer with a non-empty \`description\`.
+`;
+function composePlannerInitial(options) {
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    if (!existsSync(paths.overview)) {
+        return null;
+    }
+    const prompt = [
+        PLANNER_INITIAL_PROMPT,
+        "",
+        PLANNER_YAML_OVERLAY,
+        "",
+        "---",
+        "",
+        "## Your task for this dispatch",
+        "",
+        `Read the compressed packed codebase at: ${paths.overview}`,
+        "",
+        `Produce the outline YAML conforming to the schema above and write it to: ${paths.outline}`,
+        "",
+        "Do NOT include a `review` field — that section is added by the conversational orchestrator after you finish. Only emit the content fields.",
+        "",
+        "Do not output YAML in your reply — only write it to the file. When the file is written, end your response with a brief one-line confirmation noting the file path.",
+    ].join("\n");
+    return { prompt };
+}
+/**
+ * Resolve the CLI invocation prefix worker subagents should use when running
+ * `cts validate` and `cts style-check` on their partials. Resolved at module
+ * load so every dispatch composed in this run uses the same prefix:
+ *
+ * 1. `DOTREQUIREMENTS_CLI` env var if set (same override the cts-worker
+ *    hook script uses — keeps the two resolution paths consistent).
+ * 2. `node <process.argv[1]>` — points the worker at the exact CLI binary
+ *    the user just invoked. The worker subagent runs Bash on the same
+ *    machine in the same project, so reproducing the user's CLI is more
+ *    reliable than hoping `dotrequirements` on PATH resolves to the same
+ *    version.
+ */
+function resolveCliInvocation() {
+    if (process.env.DOTREQUIREMENTS_CLI)
+        return process.env.DOTREQUIREMENTS_CLI;
+    return `node ${process.argv[1]}`;
+}
+const LOCAL_CLI_INVOCATION = resolveCliInvocation();
+/**
+ * Overlay for the specifier dispatch. Inserted between the legacy
+ * SPECIFIER_PROMPT and the per-dispatch task instructions. Reinforces:
+ * - Customer-grounding discipline (per-area customers from outline.yaml)
+ * - source.txt as the read source for area files
+ * - Validate + style-check workflow
+ */
+const SPECIFIER_OVERLAY = `---
+
+## Updated context — read carefully
+
+The system prompt above gives you the discipline for producing a behavioral spec. This dispatch supplies the specific area you're working on, the customer-grounding for that area (from the approved outline), and the validate/style-check commands you must run on your own draft.
+
+## Customer-grounding (the area's customers from the approved outline)
+
+The customers below are area-scoped — each describes who interacts with THIS area's behaviors and what they're trying to do at this point in the system. Ground your requirements in these specific customer needs. Use the personas the outline names; don't substitute generic "user" / "developer" framings.
+
+## Output format
+
+The PARTIAL FILE is your primary deliverable. Markdown with fenced \`dotrequirements\` blocks per the format rules in the system prompt above. Do NOT include YAML frontmatter, H1 title, summary paragraph, or area H2 — the composer adds those downstream.
+
+## Workflow (legacy CTS-SPEC-3 — REQUIRED)
+
+After writing your initial draft, you MUST run validate then style-check on your own partial via Bash. Apply MUST FIX and SHOULD FIX findings via Edit. Style-check runs at most twice. Specific Bash commands appear in the task section below.
+`;
+function composeSpecifier(areaPrefix, options) {
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    if (!existsSync(paths.outline) || !existsSync(paths.source)) {
+        return null;
+    }
+    // Parse and validate the outline. The outline must be approved (or we
+    // wouldn't be fanning out specifiers).
+    let outline;
+    try {
+        outline = parseConversationalOutline(readFileSync(paths.outline, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    if (!outline.review || outline.review.result !== "approved") {
+        return null;
+    }
+    const area = outline.areas.find((a) => a.prefix === areaPrefix);
+    if (!area)
+        return null;
+    const partialPath = paths.partial(sanitizeAreaName(area.name));
+    const outlineYaml = readFileSync(paths.outline, "utf-8");
+    const customersBlock = area.customers
+        .map((c, i) => `${i + 1}. ${c.description.trim()}`)
+        .join("\n\n");
+    const prompt = [
+        SPECIFIER_PROMPT,
+        "",
+        SPECIFIER_OVERLAY,
+        "",
+        "---",
+        "",
+        "## Your area",
+        "",
+        `Name: ${area.name}`,
+        `Prefix: ${area.prefix}`,
+        `Document defaultPrefix: ${outline.defaultPrefix}`,
+        `Requirement ID form: ${outline.defaultPrefix}-${area.prefix}-<N> (sequential, 1-indexed, no zero-padding)`,
+        "",
+        "### Description (from the approved outline)",
+        "",
+        area.description.trim(),
+        "",
+        "### Customers (area-scoped — ground your requirements in these)",
+        "",
+        customersBlock,
+        "",
+        "### Source files in this area",
+        "",
+        ...area.source_files.map((f) => `- ${f}`),
+        "",
+        `Read these files from the uncompressed pack at ${paths.source} (grep for \`File: <name>\` headers to find each one's content). You can also read them directly from the worktree if you know the paths. You may consult other files in the pack (e.g., tests, READMEs) for behaviors documented outside this area's primary files.`,
+        "",
+        "---",
+        "",
+        "## Full outline (for cross-area awareness — what is in scope vs. not)",
+        "",
+        "```yaml",
+        outlineYaml.trim(),
+        "```",
+        "",
+        "---",
+        "",
+        "## Your task for this dispatch",
+        "",
+        `Write your partial to: ${partialPath}`,
+        "",
+        "Then run validate (REQUIRED) and style-check (REQUIRED) on your own partial via Bash:",
+        "",
+        `- Validate: \`${LOCAL_CLI_INVOCATION} cts validate ${partialPath}\``,
+        `- Style-check: \`${LOCAL_CLI_INVOCATION} cts style-check ${partialPath}\``,
+        "",
+        "Follow the three-phase workflow (Draft → Validate → Style-check) from the system prompt. Apply MUST FIX and SHOULD FIX findings via Edit. Cap style-check at two runs.",
+        "",
+        'End with a short confirmation: "Done. Partial saved to <path>."',
+    ].join("\n");
+    return { prompt };
+}
+const EDITOR_OVERLAY = `---
+
+## Updated context — read carefully
+
+The system prompt above describes editing a composed spec **document**. **This dispatch scopes you to ONE partial spec for ONE behavioral area**, not the composed document. The partial is the work-in-progress for one area; CA reviewed it and flagged revisions you must apply.
+
+## Critique shape (different from the legacy reviewer's shape)
+
+Our orchestrator uses a simpler critique shape. You receive a list of \`revisions\` — concrete directives to apply. There are NO categorized findings (no coverage_gaps / framing_errors / cross_area_issues / internal_mechanics_drift). Just revisions.
+
+You are in **apply-mode-equivalent**: apply each revision in the list as written. Do not introduce changes beyond the listed revisions. Do not restructure unflagged content. If a revision is ambiguous, apply your best literal interpretation and note the ambiguity in your final stdout confirmation.
+
+## Customer-grounding (the area's customers from outline)
+
+The customers below are area-scoped. Maintain the customer-grounded framing of existing requirements; any new requirements you add must name the same personas the existing requirements use.
+
+## Workflow (REQUIRED — same as specifier)
+
+After applying revisions via Edit, you MUST run validate + style-check on the revised partial via Bash. Apply MUST FIX and SHOULD FIX findings via Edit. Style-check runs at most twice. Specific Bash commands appear in the task section below.
+`;
+function composeEditor(areaPrefix, options) {
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    if (!existsSync(paths.outline)) {
+        return null;
+    }
+    let outline;
+    try {
+        outline = parseConversationalOutline(readFileSync(paths.outline, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    const area = outline.areas.find((a) => a.prefix === areaPrefix);
+    if (!area)
+        return null;
+    // Editor only runs when the area has been reviewed and the latest review
+    // entry asks for revisions.
+    if (!area.review || area.review.result !== "needs-revision") {
+        return null;
+    }
+    const latestEntry = area.review.thread[area.review.thread.length - 1];
+    if (!latestEntry || latestEntry.result !== "needs-revision") {
+        return null;
+    }
+    const partialPath = paths.partial(sanitizeAreaName(area.name));
+    if (!existsSync(partialPath)) {
+        // Can't edit a partial that doesn't exist yet.
+        return null;
+    }
+    const currentPartial = readFileSync(partialPath, "utf-8");
+    const customersBlock = area.customers
+        .map((c, i) => `${i + 1}. ${c.description.trim()}`)
+        .join("\n\n");
+    const revisionsBlock = latestEntry.revisions
+        .map((r, i) => `${i + 1}. ${r.trim()}`)
+        .join("\n\n");
+    const prompt = [
+        EDITOR_PROMPT,
+        "",
+        EDITOR_OVERLAY,
+        "",
+        "---",
+        "",
+        "## Your area",
+        "",
+        `Name: ${area.name}`,
+        `Prefix: ${area.prefix}`,
+        `Document defaultPrefix: ${outline.defaultPrefix}`,
+        `Requirement ID form: ${outline.defaultPrefix}-${area.prefix}-<N>`,
+        "",
+        "### Description (from the approved outline)",
+        "",
+        area.description.trim(),
+        "",
+        "### Customers (area-scoped — preserve their grounding in your edits)",
+        "",
+        customersBlock,
+        "",
+        "---",
+        "",
+        "## Current partial (read via Read tool to load it into your view; the content is also embedded here for reference)",
+        "",
+        `Path: ${partialPath}`,
+        "",
+        "```markdown",
+        currentPartial.trim(),
+        "```",
+        "",
+        "---",
+        "",
+        "## Reviewer's revisions (apply each as written)",
+        "",
+        revisionsBlock,
+        "",
+        "---",
+        "",
+        "## Your task for this dispatch",
+        "",
+        `Use the Edit tool to apply each revision to the partial at ${partialPath}. Do not introduce changes beyond the listed revisions.`,
+        "",
+        "Then run validate (REQUIRED) and style-check (REQUIRED) on the revised partial via Bash:",
+        "",
+        `- Validate: \`${LOCAL_CLI_INVOCATION} cts validate ${partialPath}\``,
+        `- Style-check: \`${LOCAL_CLI_INVOCATION} cts style-check ${partialPath}\``,
+        "",
+        "Apply MUST FIX and SHOULD FIX findings from style-check via Edit. Cap style-check at two runs.",
+        "",
+        'End with a brief stdout confirmation summarizing the kinds of changes you made (e.g., "Applied 3 revisions: added 2 requirements about edge cases, rephrased 1 framing-error finding.").',
+    ].join("\n");
+    return { prompt };
+}
+function composePlannerRevise(turn, options) {
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    if (!existsSync(paths.overview) || !existsSync(paths.outline)) {
+        return null;
+    }
+    // Read and validate the current outline. The latest thread entry must
+    // be `needs-revision` for a revise dispatch to make sense.
+    let outline;
+    try {
+        outline = parseConversationalOutline(readFileSync(paths.outline, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    if (!outline.review || outline.review.result !== "needs-revision") {
+        return null;
+    }
+    const latestEntry = outline.review.thread[outline.review.thread.length - 1];
+    if (!latestEntry || latestEntry.result !== "needs-revision") {
+        return null;
+    }
+    const priorOutlineYaml = readFileSync(paths.outline, "utf-8");
+    const revisionsYaml = latestEntry.revisions
+        .map((r, i) => `- # revision ${i + 1}\n  ${r.split("\n").join("\n    ")}`)
+        .join("\n");
+    const prompt = [
+        PLANNER_REVISE_PROMPT,
+        "",
+        PLANNER_YAML_OVERLAY,
+        "",
+        "---",
+        "",
+        "## Inputs for this revision",
+        "",
+        `### Compressed packed codebase`,
+        `Path: ${paths.overview}`,
+        "",
+        `### Current outline.yaml (turn ${turn - 1})`,
+        "```yaml",
+        priorOutlineYaml.trim(),
+        "```",
+        "",
+        `### Reviewer's revisions (the latest \`review.thread\` entry's revisions, extracted)`,
+        "```yaml",
+        revisionsYaml,
+        "```",
+        "",
+        "---",
+        "",
+        "## Your task for this dispatch",
+        "",
+        "Apply each revision in the list as written. Preserve areas that the revisions don't touch.",
+        "",
+        "**IMPORTANT: Preserve the `review` section from the current outline verbatim.** Copy `review.result` and the entire `review.thread` array into your output exactly as they appear in the current outline. The orchestrator manages the review section; you must not modify it. After you write the file, the orchestrator will append a new review entry.",
+        "",
+        `Write the revised outline YAML to: ${paths.outline}`,
+        "",
+        "Do not output YAML in your reply — only write it to the file. End with a brief one-line confirmation noting the file path.",
+    ].join("\n");
+    return { prompt };
+}
+//# sourceMappingURL=dispatch.js.map