@popoverai/dotrequirements 0.24.2 → 0.25.0

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

@@ -189,6 +189,250 @@ export const SPEC_REVIEW_JSON_SCHEMA = {
     ],
     additionalProperties: false,
 };
+// ---------- Conversational orchestrator outline (Phase 2b refactor) ----------
+//
+// The conversational orchestrator uses a single evolving `outline.yaml` as
+// the pipeline's substrate. The outline carries both the behavioral spec
+// content (areas, customers, source_files) AND its own lifecycle state
+// (review.result + review.thread). This is distinct from the legacy
+// `OutlineSchema` above, which the `cts run` pipeline still uses.
+//
+// Field naming uses "result" rather than "verdict" deliberately: review is
+// a collaborative interaction with the worker, not a juridical ruling.
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+export const ConversationalCustomerSchema = z.object({
+    description: z.string().min(1),
+});
+/**
+ * One entry in the review thread (project-level or per-area). Discriminated
+ * on `result`:
+ *
+ * - `approved`: no revisions required.
+ * - `needs-revision`: must include a non-empty `revisions` list — each
+ *   entry is a clear, actionable instruction for the next planner pass.
+ */
+export const ConversationalReviewEntrySchema = z.discriminatedUnion("result", [
+    z.object({
+        result: z.literal("approved"),
+    }),
+    z.object({
+        result: z.literal("needs-revision"),
+        revisions: z.array(z.string()).min(1),
+    }),
+]);
+/**
+ * Review state. Used both at the project level (outline.review) and per
+ * area (area.review). `result` mirrors the latest thread entry's result
+ * so callers can query state without walking the thread.
+ */
+export const ConversationalReviewSchema = z.object({
+    result: z.enum(["approved", "needs-revision"]),
+    thread: z.array(ConversationalReviewEntrySchema).min(1),
+});
+export const ConversationalAreaSchema = z.object({
+    name: z.string().min(1),
+    prefix: z
+        .string()
+        .regex(/^[A-Z][A-Z0-9_]*$/, "prefix must be uppercase alphanumeric/underscore"),
+    description: z.string().min(1),
+    source_files: z.array(z.string()).min(0),
+    customers: z.array(ConversationalCustomerSchema).min(1),
+    /**
+     * Per-area review state — same shape as the project-level review.
+     * Optional: planner output doesn't include it; CA adds it after reviewing
+     * a partial. Tracks the per-area iteration loop (specify → review →
+     * editor → re-review → approved) the same way `outline.review` tracks
+     * the outline iteration loop.
+     */
+    review: ConversationalReviewSchema.optional(),
+});
+export const ConversationalOutlineSchema = z.object({
+    title: z.string().min(1),
+    defaultPrefix: z
+        .string()
+        .regex(/^[A-Z][A-Z0-9_]*$/, "defaultPrefix must be uppercase alphanumeric/underscore"),
+    summary: z.string().min(1),
+    /**
+     * Outline-approval review (the outline iteration loop). `compose-orchestrator`
+     * gates composition on `review.result === "approved"`, so this field is
+     * distinct from and must never be conflated with `crossAreaReview` below.
+     */
+    review: ConversationalReviewSchema.optional(),
+    /**
+     * Document-level cross-area review state (CTSO-CONV-5). Recorded after the
+     * per-area partials are composed: the cross-area reviewer appends verdicts
+     * here and the compose-editor reads the latest entry's revisions — the same
+     * auditable thread pattern as `area.review`, kept at the top level because the
+     * review spans the whole composed spec rather than one area. Separate from
+     * `review` so cross-area iteration never disturbs outline approval.
+     */
+    crossAreaReview: ConversationalReviewSchema.optional(),
+    areas: z.array(ConversationalAreaSchema).min(1),
+});
+/**
+ * Parse YAML text against the conversational outline schema. Throws with
+ * a descriptive message on parse or validation failure.
+ */
+export function parseConversationalOutline(text) {
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        throw new Error(`Outline YAML is invalid: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return ConversationalOutlineSchema.parse(raw);
+}
+/**
+ * Synthesize a short customer `name` from a conversational customer's
+ * `description`. The orchestrator's `ConversationalCustomerSchema` only
+ * carries description, but the legacy `CustomerSchema` requires both
+ * `name` and `description`. Adapter use only — downstream compose/present
+ * stages don't read `name`, so this is a schema-shape bridge, not a
+ * semantic field.
+ *
+ * Heuristic: descriptions like "Priya, a CTS pipeline operator" yield
+ * "Priya" via first comma-segment. Otherwise truncate to 40 chars.
+ */
+function synthesizeCustomerName(description) {
+    const firstSegment = description.split(",")[0]?.trim() ?? "";
+    if (firstSegment.length > 0 && firstSegment.length <= 40) {
+        return firstSegment;
+    }
+    return description.slice(0, 40).trim() || description;
+}
+/**
+ * Adapt a conversational orchestrator outline to the legacy Outline shape
+ * for use with stages that still take the legacy schema (compose, present).
+ *
+ * Discards orchestrator-only fields (review); maps `source_files` → `files`;
+ * bridges the customer-shape difference by synthesizing a `name` from each
+ * conversational customer's description.
+ */
+export function conversationalOutlineToLegacy(outline) {
+    return {
+        title: outline.title,
+        defaultPrefix: outline.defaultPrefix,
+        summary: outline.summary,
+        areas: outline.areas.map((a) => ({
+            name: a.name,
+            description: a.description,
+            prefix: a.prefix,
+            files: a.source_files,
+            customers: a.customers.map((c) => ({
+                name: synthesizeCustomerName(c.description),
+                description: c.description,
+            })),
+        })),
+    };
+}
+/**
+ * Serialize a conversational outline back to YAML text. Uses literal-block
+ * multi-line strings (`|`) where possible for readability.
+ */
+export function stringifyConversationalOutline(outline) {
+    return stringifyYaml(outline, {
+        lineWidth: 0,
+        blockQuote: "literal",
+    });
+}
+// ---------- Workflow orchestrator worker I/O ----------
+//
+// The workflow orchestrator (the `specify-codebase` dynamic workflow) fans out
+// specifier / editor / reviewer subagents and receives their results back as
+// schema-validated values via the workflow runtime's `schema` option. The JSON
+// Schemas below are the contract the runtime constrains each agent to; the Zod
+// schemas validate the same shapes on the CLI/test side. Because the workflow
+// script can't import this module, the JSON Schemas are mirrored inline in the
+// workflow file; a template-sync test guards against drift.
+/**
+ * Result a specifier or editor worker returns to the workflow after writing
+ * (or skipping) an area's partial.
+ *
+ * - `drafted`: the worker composed and wrote the partial this run.
+ * - `skipped-resume`: a non-empty partial already existed, so the worker left
+ *   it in place (idempotent re-entry — see CTSO-INTEG-2).
+ */
+export const PartialResultStatusValues = ["drafted", "skipped-resume"];
+export const PartialResultSchema = z.object({
+    area_prefix: z.string().min(1),
+    partial_path: z.string().min(1),
+    status: z.enum(PartialResultStatusValues),
+    requirement_count: z.number().int().nonnegative().optional(),
+});
+export const PARTIAL_RESULT_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+        area_prefix: { type: "string" },
+        partial_path: { type: "string" },
+        status: {
+            type: "string",
+            enum: PartialResultStatusValues,
+        },
+        requirement_count: { type: "integer", minimum: 0 },
+    },
+    required: ["area_prefix", "partial_path", "status"],
+    additionalProperties: false,
+};
+/**
+ * Verdict a reviewer worker returns to the workflow. Same shape as one
+ * `ConversationalReviewEntry` (discriminated on `result`): `approved` carries
+ * no revisions; `needs-revision` must carry a non-empty `revisions` list. This
+ * verdict drives the per-area convergence loop (CTSO-CONV-4).
+ *
+ * The JSON Schema form is flat (result + optional revisions) — JSON Schema
+ * can't express the discriminated-union constraint as cleanly as Zod. The
+ * runtime retries on mismatch, the prompt instructs the reviewer to include
+ * revisions exactly when the result is needs-revision, and `parseReviewVerdict`
+ * enforces the stricter Zod constraint on the CLI side.
+ */
+export const REVIEW_VERDICT_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+        result: { type: "string", enum: ["approved", "needs-revision"] },
+        revisions: { type: "array", items: { type: "string" } },
+    },
+    required: ["result"],
+    additionalProperties: false,
+};
+/**
+ * Parse + validate a specifier/editor worker's JSON result.
+ */
+export function parsePartialResult(text) {
+    const trimmed = text.trim();
+    let raw;
+    try {
+        raw = JSON.parse(trimmed);
+    }
+    catch {
+        const match = trimmed.match(/(\{[\s\S]*\})/);
+        if (!match) {
+            throw new Error("Partial result is not valid JSON and contains no JSON object");
+        }
+        raw = JSON.parse(match[1]);
+    }
+    return PartialResultSchema.parse(raw);
+}
+/**
+ * Parse + validate a reviewer worker's JSON verdict. Reuses
+ * `ConversationalReviewEntrySchema`, so a `needs-revision` verdict requires a
+ * non-empty `revisions` list.
+ */
+export function parseReviewVerdict(text) {
+    const trimmed = text.trim();
+    let raw;
+    try {
+        raw = JSON.parse(trimmed);
+    }
+    catch {
+        const match = trimmed.match(/(\{[\s\S]*\})/);
+        if (!match) {
+            throw new Error("Review verdict is not valid JSON and contains no JSON object");
+        }
+        raw = JSON.parse(match[1]);
+    }
+    return ConversationalReviewEntrySchema.parse(raw);
+}
 export function parseSpecReview(text) {
     const trimmed = text.trim();
     let raw;

package/dist/codebase-to-spec/skill-install.d.ts

@@ -1,34 +1,42 @@
 /**
  * Skill installation logic for the codebase-to-spec skill.
  *
- * The skill is a thin conversational wrapper around `dotrequirements cts run`.
- * It ships as a SKILL.md template bundled in the CLI package, and this module
- * copies it into the host's skill directory (default: `.claude/skills/` for
- * Claude Code).
+ * Ships as a bundle: SKILL.md + cts-worker agent definition + the `codebase-to-spec`
+ * dynamic-workflow script. The skill body (the conversational orchestrator)
+ * launches the workflow, which dispatches cts-worker agents; both companions
+ * must be present for the skill to run. For `project` and `global` scope, all
+ * three pieces are installed in one shot (under the project's `.claude/` or the
+ * user's `~/.claude/`). Only a `custom` target dir is skill-only, because
+ * assistants do not auto-discover agents or workflows from arbitrary paths.
  *
  * Host portability (CTS-SKILL-5): the install logic supports any host that
  * follows the Agent Skills format. The default target is Claude Code's
  * convention; `--target-dir` lets users place the skill anywhere.
  *
  * Requirements covered:
- * - CTS-SKILL-1: skill artifact exists and points users at `dotrequirements cts run`
- * - CTS-SKILL-5: install logic is host-agnostic and works on any host with
- *   Agent Skills format support
+ * - CTS-SKILL-1, CTS-SKILL-5
+ * - CTSO-INSTALL-1 (bundles the skill, the cts-worker agent, and the workflow)
  */
 export type SkillInstallScope = "project" | "global" | "custom";
 export interface SkillInstallOptions {
     /**
-     * Where to install:
-     * - `project` (default): `<projectRoot>/.claude/skills/codebase-to-spec/`
-     * - `global`: `~/.claude/skills/codebase-to-spec/`
-     * - `custom`: requires `targetDir`
+     * Where to install. `project` and `global` install the full bundle (skill +
+     * cts-worker agent + specify-codebase workflow) under the corresponding
+     * `.claude/` base, so the skill can launch the workflow; `custom` installs
+     * the skill body only.
+     * - `project` (default): `<projectRoot>/.claude/{skills,agents,workflows}/`
+     * - `global`: `<globalRoot>/.claude/{skills,agents,workflows}/`
+     * - `custom`: `<targetDir>/codebase-to-spec/SKILL.md` only — Claude Code does
+     *   not auto-discover agents or workflows from an arbitrary directory
      */
     scope?: SkillInstallScope;
     /** Required when `scope === 'custom'`. The skill directory will be created here. */
     targetDir?: string;
     /** Project root (used when scope === 'project'). Defaults to cwd. */
     projectRoot?: string;
-    /** Overwrite existing SKILL.md if present. Default false. */
+    /** Home root for `global` scope (the parent of `.claude`). Defaults to homedir(); tests inject a temp dir. */
+    globalRoot?: string;
+    /** Overwrite existing SKILL.md / agent / workflow if present. Default false. */
     overwrite?: boolean;
 }
 export interface SkillInstallResult {
@@ -38,6 +46,11 @@ export interface SkillInstallResult {
     installed: boolean;
     /** True if an existing file was replaced. */
     overwrote: boolean;
+    /** Companion files installed alongside the skill (project + global scope). */
+    companions?: {
+        agentPath: string;
+        workflowPath: string;
+    };
 }
 /**
  * Resolve the directory in which the skill should live, given the user's
@@ -50,8 +63,22 @@ export declare function resolveSkillDir(options: SkillInstallOptions): string;
  */
 export declare function loadSkillTemplate(): string;
 /**
- * Install (or refuse to overwrite) the codebase-to-spec SKILL.md at the
- * resolved location.
+ * Load the bundled cts-worker agent definition template.
+ */
+export declare function loadAgentTemplate(): string;
+/**
+ * Load the bundled specify-codebase dynamic-workflow script template.
+ */
+export declare function loadWorkflowTemplate(): string;
+/**
+ * Install (or refuse to overwrite) the codebase-to-spec skill bundle.
+ *
+ * For `project` and `global` scope: installs the full bundle — the skill body,
+ * the cts-worker agent, and the specify-codebase workflow — under the matching
+ * `.claude/` base (the project's, or the user's `~/.claude/`).
+ *
+ * For `custom` scope: installs only the skill body, because Claude Code does
+ * not auto-discover agents or workflows from an arbitrary directory.
  */
 export declare function installSkill(options?: SkillInstallOptions): SkillInstallResult;
 //# sourceMappingURL=skill-install.d.ts.map

package/dist/codebase-to-spec/skill-install.js

@@ -1,19 +1,21 @@
 /**
  * Skill installation logic for the codebase-to-spec skill.
  *
- * The skill is a thin conversational wrapper around `dotrequirements cts run`.
- * It ships as a SKILL.md template bundled in the CLI package, and this module
- * copies it into the host's skill directory (default: `.claude/skills/` for
- * Claude Code).
+ * Ships as a bundle: SKILL.md + cts-worker agent definition + the `codebase-to-spec`
+ * dynamic-workflow script. The skill body (the conversational orchestrator)
+ * launches the workflow, which dispatches cts-worker agents; both companions
+ * must be present for the skill to run. For `project` and `global` scope, all
+ * three pieces are installed in one shot (under the project's `.claude/` or the
+ * user's `~/.claude/`). Only a `custom` target dir is skill-only, because
+ * assistants do not auto-discover agents or workflows from arbitrary paths.
  *
  * Host portability (CTS-SKILL-5): the install logic supports any host that
  * follows the Agent Skills format. The default target is Claude Code's
  * convention; `--target-dir` lets users place the skill anywhere.
  *
  * Requirements covered:
- * - CTS-SKILL-1: skill artifact exists and points users at `dotrequirements cts run`
- * - CTS-SKILL-5: install logic is host-agnostic and works on any host with
- *   Agent Skills format support
+ * - CTS-SKILL-1, CTS-SKILL-5
+ * - CTSO-INSTALL-1 (bundles the skill, the cts-worker agent, and the workflow)
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -32,7 +34,7 @@ export function resolveSkillDir(options) {
             return join(root, ".claude", "skills", "codebase-to-spec");
         }
         case "global":
-            return join(homedir(), ".claude", "skills", "codebase-to-spec");
+            return join(options.globalRoot ?? homedir(), ".claude", "skills", "codebase-to-spec");
         case "custom":
             if (!options.targetDir) {
                 throw new Error('targetDir is required when scope === "custom"');
@@ -49,31 +51,78 @@ export function loadSkillTemplate() {
     return loadTemplate("skills/codebase-to-spec/SKILL.md");
 }
 /**
- * Install (or refuse to overwrite) the codebase-to-spec SKILL.md at the
- * resolved location.
+ * Load the bundled cts-worker agent definition template.
+ */
+export function loadAgentTemplate() {
+    return loadTemplate("agents/cts-worker.md");
+}
+/**
+ * Load the bundled specify-codebase dynamic-workflow script template.
+ */
+export function loadWorkflowTemplate() {
+    return loadTemplate("workflows/specify-codebase.js");
+}
+/**
+ * Install (or refuse to overwrite) one template file at a target path.
+ * Returns true if a write happened.
+ */
+function installTemplateFile(templateContent, targetPath, overwrite, description) {
+    const exists = existsSync(targetPath);
+    if (exists && !overwrite) {
+        const onDisk = readFileSync(targetPath, "utf-8");
+        if (onDisk === templateContent) {
+            return { installed: false, overwrote: false };
+        }
+        throw new Error(`${description} already exists at ${targetPath} and differs from the bundled template. Pass --overwrite to replace it, or delete the file first.`);
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, templateContent, "utf-8");
+    return { installed: true, overwrote: exists };
+}
+/**
+ * Install (or refuse to overwrite) the codebase-to-spec skill bundle.
+ *
+ * For `project` and `global` scope: installs the full bundle — the skill body,
+ * the cts-worker agent, and the specify-codebase workflow — under the matching
+ * `.claude/` base (the project's, or the user's `~/.claude/`).
+ *
+ * For `custom` scope: installs only the skill body, because Claude Code does
+ * not auto-discover agents or workflows from an arbitrary directory.
  */
 export function installSkill(options = {}) {
     const skillDir = resolveSkillDir(options);
     const skillPath = join(skillDir, "SKILL.md");
-    const template = loadSkillTemplate();
-    const exists = existsSync(skillPath);
-    if (exists && !options.overwrite) {
-        // Idempotent no-op: if the on-disk content already matches the template,
-        // there's nothing to do and we shouldn't surface that as a conflict.
-        const onDisk = readFileSync(skillPath, "utf-8");
-        if (onDisk === template) {
-            return { installedPath: skillPath, installed: false, overwrote: false };
-        }
-        // Stale or hand-edited copy: refuse without --overwrite so we don't
-        // silently clobber user changes.
-        throw new Error(`SKILL.md already exists at ${skillPath} and differs from the bundled template. Pass --overwrite to replace it, or delete the file first.`);
+    const skillTemplate = loadSkillTemplate();
+    const skillResult = installTemplateFile(skillTemplate, skillPath, options.overwrite === true, "SKILL.md");
+    // A custom target dir is an arbitrary location CC won't read agents or
+    // workflows from, so it gets the skill body only. Project and global both
+    // install the full bundle under their `.claude/` base.
+    const scope = options.scope ?? "project";
+    if (scope === "custom") {
+        return {
+            installedPath: skillPath,
+            installed: skillResult.installed,
+            overwrote: skillResult.overwrote,
+        };
     }
-    mkdirSync(dirname(skillPath), { recursive: true });
-    writeFileSync(skillPath, template, "utf-8");
+    const claudeBase = scope === "global"
+        ? join(options.globalRoot ?? homedir(), ".claude")
+        : join(options.projectRoot ?? process.cwd(), ".claude");
+    const agentPath = join(claudeBase, "agents", "cts-worker.md");
+    const workflowPath = join(claudeBase, "workflows", "specify-codebase.js");
+    // Install the cts-worker agent definition.
+    installTemplateFile(loadAgentTemplate(), agentPath, options.overwrite === true, "cts-worker agent definition");
+    // Install the specify-codebase workflow script (discovered by name from
+    // .claude/workflows/; no settings registration needed, unlike a hook).
+    installTemplateFile(loadWorkflowTemplate(), workflowPath, options.overwrite === true, "specify-codebase workflow script");
     return {
         installedPath: skillPath,
-        installed: true,
-        overwrote: exists,
+        installed: skillResult.installed,
+        overwrote: skillResult.overwrote,
+        companions: {
+            agentPath,
+            workflowPath,
+        },
     };
 }
 //# sourceMappingURL=skill-install.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * `dotrequirements codebase-to-spec compose-orchestrator` subcommand.
+ *
+ * Conversational-orchestrator variant of `compose`. Reads outline.yaml
+ * (must be approved) + per-area partials, writes the composed spec to
+ * .dotrequirements-cache/spec-composed.md. Wraps the legacy `runCompose`
+ * by adapting outline.yaml to the legacy Outline shape.
+ *
+ * Requirements covered:
+ * - CTS-COMPOSE-1, CTS-COMPOSE-2 (reuses the legacy compose logic)
+ * - CTSO-INTEG-1: orchestrator uses existing deterministic stages unchanged
+ */
+export declare function composeOrchestratorCommand(): Promise<void>;
+//# sourceMappingURL=compose-orchestrator.d.ts.map

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

@@ -0,0 +1,54 @@
+/**
+ * `dotrequirements codebase-to-spec compose-orchestrator` subcommand.
+ *
+ * Conversational-orchestrator variant of `compose`. Reads outline.yaml
+ * (must be approved) + per-area partials, writes the composed spec to
+ * .dotrequirements-cache/spec-composed.md. Wraps the legacy `runCompose`
+ * by adapting outline.yaml to the legacy Outline shape.
+ *
+ * Requirements covered:
+ * - CTS-COMPOSE-1, CTS-COMPOSE-2 (reuses the legacy compose logic)
+ * - CTSO-INTEG-1: orchestrator uses existing deterministic stages unchanged
+ */
+import { existsSync, readFileSync } 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 { conversationalOutlineToLegacy, parseConversationalOutline, } from "../../codebase-to-spec/schemas.js";
+import { findProjectRoot } from "../../utils/project-settings.js";
+export async function composeOrchestratorCommand() {
+    const 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`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    let outline;
+    try {
+        outline = parseConversationalOutline(readFileSync(paths.outline, "utf-8"));
+    }
+    catch (err) {
+        process.stderr.write(`Outline at ${paths.outline} is invalid: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    if (!outline.review || outline.review.result !== "approved") {
+        process.stderr.write(`Outline at ${paths.outline} is not approved (review.result is "${outline.review?.result ?? "absent"}"). Approve the outline before composing.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    const legacyOutline = conversationalOutlineToLegacy(outline);
+    const result = runCompose({
+        outline: legacyOutline,
+        partialPathFor: (sanitized) => paths.partial(sanitized),
+        composedPath: paths.composedSpec,
+    });
+    process.stdout.write(`Composed spec → ${result.composedPath} (${result.partialsIncluded} partials included, ${result.partialsMissing} missing)\n`);
+    if (result.validationError) {
+        process.stderr.write(`Composed spec failed validation:\n${result.validationError}\n`);
+        process.exitCode = ExitCode.StageFailed;
+        return;
+    }
+}
+//# sourceMappingURL=compose-orchestrator.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * `dotrequirements codebase-to-spec dispatch-context <dispatch-id>` subcommand.
+ *
+ * Returns the composed prompt for a worker dispatch as a JSON object on stdout.
+ * Run by cts-worker subagents at the start of their turn to fetch the composed
+ * first-turn prompt for their dispatch-id (see the specify-codebase workflow).
+ */
+export declare function dispatchContextCommand(dispatchId: string): Promise<void>;
+//# sourceMappingURL=dispatch-context.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * `dotrequirements codebase-to-spec dispatch-context <dispatch-id>` subcommand.
+ *
+ * Returns the composed prompt for a worker dispatch as a JSON object on stdout.
+ * Run by cts-worker subagents at the start of their turn to fetch the composed
+ * first-turn prompt for their dispatch-id (see the specify-codebase workflow).
+ */
+import { composeDispatchContext } from "../../codebase-to-spec/dispatch.js";
+import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
+export async function dispatchContextCommand(dispatchId) {
+    const ctx = composeDispatchContext(dispatchId);
+    if (!ctx) {
+        process.stderr.write(`Unknown dispatch-id: ${dispatchId}\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    process.stdout.write(`${JSON.stringify(ctx)}\n`);
+}
+//# sourceMappingURL=dispatch-context.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * `dotrequirements codebase-to-spec dispatch-editor <area-prefix>` subcommand.
+ *
+ * Returns a dispatch payload for an editor pass on a specific area's partial.
+ * Validates that the area's `review.result` is `"needs-revision"` and that
+ * the partial file exists before scaffolding the dispatch.
+ *
+ * The worker overwrites the existing partial via Edit; the area.review.thread
+ * in outline.yaml stays where it is (the orchestrator manages it).
+ *
+ * Requirements covered:
+ * - CTSO-CONV-3: orchestrator dispatches an editor when revisions are needed
+ */
+export declare function dispatchEditorCommand(areaPrefix: string): Promise<void>;
+//# sourceMappingURL=dispatch-editor.d.ts.map

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

@@ -0,0 +1,70 @@
+/**
+ * `dotrequirements codebase-to-spec dispatch-editor <area-prefix>` subcommand.
+ *
+ * Returns a dispatch payload for an editor pass on a specific area's partial.
+ * Validates that the area's `review.result` is `"needs-revision"` and that
+ * the partial file exists before scaffolding the dispatch.
+ *
+ * The worker overwrites the existing partial via Edit; the area.review.thread
+ * in outline.yaml stays where it is (the orchestrator manages it).
+ *
+ * Requirements covered:
+ * - CTSO-CONV-3: orchestrator dispatches an editor when revisions are needed
+ */
+import { existsSync, readFileSync } from "node:fs";
+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) {
+    const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const paths = cachePaths(projectRoot);
+    if (!existsSync(paths.outline)) {
+        process.stderr.write(`No outline.yaml found at ${paths.outline}. Dispatch the planner first.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    let outline;
+    try {
+        outline = parseConversationalOutline(readFileSync(paths.outline, "utf-8"));
+    }
+    catch (err) {
+        process.stderr.write(`Outline at ${paths.outline} is invalid: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    const area = outline.areas.find((a) => a.prefix === areaPrefix);
+    if (!area) {
+        process.stderr.write(`No area with prefix "${areaPrefix}" in outline.yaml. Available prefixes: ${outline.areas
+            .map((a) => a.prefix)
+            .join(", ")}\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    if (!area.review) {
+        process.stderr.write(`Area "${areaPrefix}" has no review yet. Write a per-area review with result=needs-revision before dispatching the editor.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    if (area.review.result === "approved") {
+        process.stderr.write(`Area "${areaPrefix}" has review.result "approved" — nothing to revise. The partial is good as-is.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    const partialPath = paths.partial(sanitizeAreaName(area.name));
+    if (!existsSync(partialPath)) {
+        process.stderr.write(`Partial not found at ${partialPath}. Run the specifier for area "${areaPrefix}" before dispatching the editor.\n`);
+        process.exitCode = ExitCode.MissingInput;
+        return;
+    }
+    const payload = {
+        dispatch_id: `${EDITOR_DISPATCH_ID_PREFIX}${areaPrefix}`,
+        output_path: partialPath,
+        area_name: area.name,
+        area_prefix: area.prefix,
+    };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+//# sourceMappingURL=dispatch-editor.js.map