cclaw-cli 7.7.1 → 8.1.1

package/dist/content/stages/schema-types.d.ts

@@ -1,203 +0,0 @@
-import type { FlowStage } from "../../types.js";
-export interface StageGate {
-    id: string;
-    description: string;
-    tier?: "required" | "recommended";
-}
-export interface ReviewSection {
-    title: string;
-    evaluationPoints: string[];
-    stopGate: boolean;
-}
-export interface CrossStageTrace {
-    readsFrom: string[];
-    writesTo: string[];
-    traceabilityRule: string;
-}
-export interface ArtifactValidation {
-    section: string;
-    required: boolean;
-    tier?: "required" | "recommended";
-    validationRule: string;
-}
-export type StageSubagentName = "researcher" | "architect" | "spec-validator" | "spec-document-reviewer" | "coherence-reviewer" | "scope-guardian-reviewer" | "feasibility-reviewer" | "slice-builder" | "release-reviewer" | "planner" | "product-discovery" | "divergent-thinker" | "critic" | "reviewer" | "security-reviewer" | "integration-overseer" | "doc-updater" | "fixer";
-export type StageSubagentDispatchClass = "stage-specialist" | "worker" | "review-lens";
-export type StageSubagentReturnSchema = "planning-return" | "product-return" | "critic-return" | "review-return" | "security-return" | "tdd-return" | "docs-return" | "worker-return" | "fixer-return" | "research-return" | "architecture-return" | "spec-validation-return" | "release-return";
-export interface StageAutoSubagentDispatch {
-    agent: StageSubagentName;
-    /**
-     * - `mandatory` — must be dispatched (or explicitly waived) before stage transition.
-     * - `proactive` — should be dispatched automatically when context matches `when`.
-     */
-    mode: "mandatory" | "proactive";
-    /**
-     * Minimum complexity tier where this dispatch policy applies.
-     * Defaults to `standard` for mandatory/proactive dispatches when omitted.
-     */
-    requiredAtTier?: StageComplexityTier;
-    when: string;
-    purpose: string;
-    requiresUserGate: boolean;
-    /**
-     * When this delegation may run relative to the adaptive elicitation Q&A loop.
-     * - `pre-elicitation` — run before any user dialogue (rare; only for trivial info-gathering).
-     * - `post-elicitation` — run only after the Q&A loop converges (default for brainstorm/scope/design
-     *   so subagents do not preempt the user dialogue).
-     * - `any` — no ordering constraint (default for stages that do not run elicitation:
-     *   spec/plan/tdd/review/ship).
-     */
-    runPhase?: "pre-elicitation" | "post-elicitation" | "any";
-    /** Role category used by generated routing tables and lifecycle checks. */
-    dispatchClass?: StageSubagentDispatchClass;
-    /** Strict status/evidence contract the dispatched agent must return. */
-    returnSchema?: StageSubagentReturnSchema;
-    /** Optional skill folder the dispatched agent should load as additional context. */
-    skill?: string;
-    /**
-     * When true on a proactive dispatch row for brainstorm/scope/design, the trace
-     * gate keeps this rule even when `discoveryMode` is `lean` or `guided`.
-     */
-    essentialAcrossModes?: boolean;
-}
-export type StageComplexityTier = "lightweight" | "standard" | "deep";
-export interface StagePhilosophy {
-    hardGate: string;
-    ironLaw: string;
-    purpose: string;
-    whenToUse: string[];
-    whenNotToUse: string[];
-    commonRationalizations: string[];
-}
-export interface StageExecutionModel {
-    interactionProtocol: string[];
-    process: string[];
-    /**
-     * Optional custom mermaid `flowchart` body (without the fenced `mermaid`
-     * code block) that overrides the auto-generated linear flowchart in the
-     * rendered `## Process` section. Use for stages whose state machine is
-     * non-linear (loops, conditional branches) — otherwise leave unset and
-     * let the renderer derive a simple `A --> B --> C` chart from `process`.
-     */
-    processFlow?: string;
-    checklist: string[];
-    requiredGates: StageGate[];
-    requiredEvidence: string[];
-    inputs: string[];
-    requiredContext: string[];
-    researchPlaybooks?: string[];
-    blockers: string[];
-    exitCriteria: string[];
-    /**
-     * Optional platform-specific notes (Windows/macOS/Linux path separators,
-     * PowerShell vs cmd, harness-specific tool names). Rendered under
-     * "## Platform Notes" when present. Omit when the stage is
-     * platform-agnostic.
-     */
-    platformNotes?: string[];
-}
-export interface StageArtifactRules {
-    artifactFile: string;
-    completionStatus: string[];
-    crossStageTrace: CrossStageTrace;
-    artifactValidation: ArtifactValidation[];
-    trivialOverrideSections?: string[];
-}
-export interface StageReviewLens {
-    outputs: string[];
-    reviewSections: ReviewSection[];
-    mandatoryDelegations: string[];
-    reviewLoop?: StageReviewLoop;
-}
-export interface StageReviewLensInput {
-    outputs: string[];
-    reviewSections: ReviewSection[];
-    reviewLoop?: StageReviewLoop;
-}
-export interface StageReviewLoop {
-    stage: "scope" | "design";
-    checklist: string[];
-    maxIterations: number;
-    targetScore: number;
-}
-export interface StageSchema {
-    schemaShape: "v2";
-    stage: FlowStage;
-    skillFolder: string;
-    skillName: string;
-    skillDescription: string;
-    complexityTier: StageComplexityTier;
-    philosophy: StagePhilosophy;
-    executionModel: StageExecutionModel;
-    artifactRules: StageArtifactRules;
-    reviewLens: StageReviewLens;
-    hardGate: string;
-    /**
-     * One-line "Iron Law" punchcard — the single rule that, if broken,
-     * invalidates the stage outright. Rendered in ALL-CAPS wrapped in
-     * <EXTREMELY-IMPORTANT> XML markers at the very top of the skill body.
-     * Reference: Superpowers (obra) "NO PRODUCTION CODE WITHOUT A FAILING
-     * TEST FIRST".
-     */
-    ironLaw: string;
-    purpose: string;
-    whenToUse: string[];
-    whenNotToUse: string[];
-    interactionProtocol: string[];
-    process: string[];
-    /** See {@link StageExecutionModel.processFlow}. */
-    processFlow?: string;
-    /** See {@link StageExecutionModel.platformNotes}. */
-    platformNotes?: string[];
-    requiredGates: StageGate[];
-    requiredEvidence: string[];
-    inputs: string[];
-    requiredContext: string[];
-    /** In-thread research procedures for this stage (`.cclaw/skills/research/*.md`). */
-    researchPlaybooks?: string[];
-    outputs: string[];
-    blockers: string[];
-    exitCriteria: string[];
-    /**
-     * Consolidated "Common Rationalizations" list — things an agent is likely to
-     * talk itself into that should stop the stage. Rendered under the
-     * "Anti-Patterns & Red Flags" heading in the generated SKILL.md. Replaces
-     * the former split between `antiPatterns` and `redFlags`, which produced
-     * near-duplicate entries and forced downstream code to merge them anyway.
-     */
-    commonRationalizations: string[];
-    artifactFile: string;
-    next: FlowStage | "done";
-    checklist: string[];
-    reviewSections: ReviewSection[];
-    completionStatus: string[];
-    crossStageTrace: CrossStageTrace;
-    artifactValidation: ArtifactValidation[];
-    /** When true, stage skill includes batch auto-execute guidance (tdd). */
-    batchExecutionAllowed?: boolean;
-    /** Sections that remain required even when the trivial-change escape hatch is active (design only). */
-    trivialOverrideSections?: string[];
-    /** Agent names that MUST be dispatched (or waived) before stage transition — derived from mandatory auto-subagent rows. */
-    mandatoryDelegations: string[];
-    /** Optional shared outside-voice loop config for scope/design stages. */
-    reviewLoop?: StageReviewLoop;
-}
-export type StageSchemaLegacyInput = Omit<StageSchema, "schemaShape" | "philosophy" | "executionModel" | "artifactRules" | "reviewLens" | "mandatoryDelegations" | "complexityTier"> & {
-    schemaShape?: "legacy";
-    complexityTier?: StageComplexityTier;
-};
-export interface StageSchemaV2Input {
-    schemaShape: "v2";
-    stage: FlowStage;
-    skillFolder: string;
-    skillName: string;
-    skillDescription: string;
-    complexityTier?: StageComplexityTier;
-    philosophy: StagePhilosophy;
-    executionModel: StageExecutionModel;
-    artifactRules: StageArtifactRules;
-    reviewLens: StageReviewLensInput;
-    next: FlowStage | "done";
-    /** When true, stage skill includes batch auto-execute guidance (tdd). */
-    batchExecutionAllowed?: boolean;
-}
-export type StageSchemaInput = StageSchemaLegacyInput | StageSchemaV2Input;

package/dist/content/stages/schema-types.js

@@ -1 +0,0 @@
-export {};

package/dist/content/stages/scope.d.ts

@@ -1,2 +0,0 @@
-import type { StageSchemaInput } from "./schema-types.js";
-export declare const SCOPE: StageSchemaInput;

package/dist/content/stages/scope.js

@@ -1,254 +0,0 @@
-import { REVIEW_LOOP_CHECKLISTS, reviewLoopPolicySummary } from "../review-loop.js";
-import { decisionProtocolInstruction } from "../decision-protocol.js";
-// ---------------------------------------------------------------------------
-// SCOPE — reference: gstack CEO review
-// ---------------------------------------------------------------------------
-export const SCOPE = {
-    schemaShape: "v2",
-    stage: "scope",
-    complexityTier: "standard",
-    skillFolder: "scope",
-    skillName: "scope",
-    skillDescription: "Strategic contract stage. Select HOLD/SELECTIVE/EXPAND/REDUCE mode, lock the slice and boundaries, and hand stable discretion zones to design.",
-    philosophy: {
-        hardGate: "Do NOT begin architecture, design, or code. This stage produces scope decisions only. Do not silently add or remove scope — every change is an explicit user opt-in.",
-        ironLaw: "EVERY SCOPE CHANGE IS AN EXPLICIT USER OPT-IN — NEVER A SILENT ENLARGEMENT OR TRIM.",
-        purpose: "Decide the right scope before technical lock-in using explicit mode selection and the brainstorm premise as carry-forward (not re-authored).",
-        whenToUse: [
-            "After brainstorm approval",
-            "Before architecture/design lock-in",
-            "When ambition vs feasibility trade-off is unclear"
-        ],
-        whenNotToUse: [
-            "Brainstorm has not been approved yet",
-            "Scope boundaries are already locked and user requested no scope changes",
-            "The work is a pure implementation or debugging pass within existing scope"
-        ],
-        commonRationalizations: [
-            "Skipping pre-scope audit because the task looks small",
-            "Scope silently expanded during discussion",
-            "No explicit out-of-scope section",
-            "Re-authoring brainstorm's `## Premise Check` instead of citing it via Upstream Handoff (premise carry-forward only)",
-            "Enumerating Implementation Alternatives in scope (architecture-tier choice belongs to design)",
-            "Sycophantic agreement without evidence-based pushback",
-            "Hedged recommendations that avoid taking a position",
-            "Batching multiple scope issues into one question",
-            "Re-arguing for smaller scope after user rejects reduction",
-            "Using scope-reduction placeholders (`v1`, `for now`, `we can do later`) instead of explicit user-approved boundaries",
-            "No selected mode in artifact",
-            "Mode selected without heuristic justification",
-            "No discretion section (or explicit `None`) in artifact",
-            "No deferred/not-in-scope section",
-            "No user approval marker",
-            "Missing Locked Decisions section or decisions without D-XX IDs",
-            "Skipping outside-voice review loop and treating first draft as final"
-        ]
-    },
-    executionModel: {
-        checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the scope forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:in-out]`). Continue until every forcing-question topic id is tagged on a row OR the Q&A Ralph Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then propose the scope contract draft, recommend a mode, or dispatch any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
-            "**Scope forcing questions (must be covered or explicitly waived)** — `in-out: what is definitely in/out`; `locked-upstream: which upstream decisions are locked`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:in-out]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage. removed the counterfactual `rollback` and `failure-modes` topics from scope forcing questions; Design still owns the Failure Mode Table and rollback evidence.",
-            "**Scope contract first** — read brainstorm handoff, name upstream decisions used, explicit drift, confidence, unresolved questions, and next-stage risk hints; draft the in-scope/out-of-scope/deferred/discretion contract before any design choice.",
-            "**Premise carry-forward (do NOT re-author)** — brainstorm OWNS the premise check (right problem / direct path). Cite brainstorm's `## Premise Check` section in `## Upstream Handoff > Decisions carried forward`. Add a row to `## Premise Drift` only when the scope-stage Q&A surfaced NEW evidence that materially changes the brainstorm answer (e.g. new constraint, new user signal). Otherwise mark `Premise Drift: None` — do not duplicate the brainstorm premise table.",
-            "**Conditional 10-star boundary** — for deep/high-risk/product-strategy work, show what would make the product meaningfully better, then explicitly choose what ships now, what is deferred, and what is excluded without vague `later/for now` placeholders. Skip this for straightforward repair work and record `not needed: compact scope`.",
-            "**Pick one operational mode with the user** — HOLD SCOPE preserves focus; SELECTIVE EXPANSION cherry-picks high-leverage reference ideas; SCOPE EXPANSION explores ambitious alternatives; SCOPE REDUCTION cuts to the essential wedge. Recommend one, state why and what signal would change it, then keep elicitation focused until the user either approves or asks to proceed with draft boundaries.",
-            "**Product-discovery is REQUIRED for SELECTIVE / SCOPE EXPANSION (hard gate)** — If the resolved scope mode is SELECTIVE EXPANSION or SCOPE EXPANSION, run \`product-discovery\` in proactive mode **after** adaptive elicitation converges and **before** \`stage-complete\`. Do not complete this stage until the delegation ledger shows \`product-discovery\` as \`completed\` with non-empty \`evidenceRefs\` pointing at this scope artifact. HOLD SCOPE and SCOPE REDUCTION do not require this row.",
-            "**Run mode-specific analysis only to needed depth** — lean discovery keeps the selected-mode row compact; guided adds the standard contract rows; deep may add Landscape Check, Taste Calibration, Reference Pattern Registry, Reference Pull, Ambitious Alternatives, and Ruthless Minimum Slice evidence when mode/risk warrants it.",
-            "**Decision-driver contract** — list weighted decision drivers (value, risk, reversibility, effort, timeline) and score candidate scope moves so the selected mode and boundaries are evidence-backed, not preference-led.",
-            "**Architecture handoff (do NOT pick architecture tier here)** — design OWNS architecture choice (minimum-viable / product-grade / ideal). Scope only picks the SCOPE MODE (HOLD/SELECTIVE/EXPAND/REDUCE) and boundary; record in `## Scope Contract > Design handoff` what design must decide (e.g. `architecture-tier`, `framework`, `data-model`). Do NOT enumerate Implementation Alternatives in scope.",
-            "**Constraints (carry-forward from brainstorm/external sources)** — record explicit external/regulatory/system/integration constraints in `## Scope Contract > Constraints`. Spec OWNS testable assumptions (`## Assumptions Before Finalization`); do NOT duplicate constraint material as assumption material.",
-            "**Run outside voice before final approval** — for simple/low-risk scope, record one concise adversarial self-check row; for complex/high-risk/configured scope, iterate until threshold. Record the loop summary in `## Scope Outside Voice Loop`, but do not treat it as user approval.",
-            "**Run Early-Loop / Concern Ledger discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates. (This is the producer-critic concern ledger, not the Q&A Ralph Loop used for elicitation convergence.)",
-            "**Ask only one decision-changing question** — if the user rejects the contract but is unsure, offer 3-4 concrete scope moves instead of open-ended interrogation.",
-            "**Write the scope contract after approval** — include selected mode, in scope, out of scope, requirements, locked decisions, discretion areas, deferred ideas, accepted/rejected reference ideas, success definition, design handoff, completion dashboard, and explicit approval evidence."
-        ],
-        interactionProtocol: [
-            "\"Strong success criteria let you loop independently. Weak criteria require constant clarification.\"",
-            decisionProtocolInstruction("scope mode selection", "present expand/selective/hold/reduce as labeled options with trade-offs and mark one as (recommended)", "recommend the option that best covers the prime-directive failure modes, four data-flow paths, observability, and deferred handling for the in-scope set with the smallest blast radius. Base your recommendation on default heuristics: greenfield -> expand, enhancement -> selective, bugfix/hotfix/refactor -> hold, broad blast radius -> reduce"),
-            "Run the shared adaptive elicitation cycle from `.cclaw/skills/adaptive-elicitation/SKILL.md`, including stop-signal handling (RU/EN/UA), smart-skip, conditional grilling triggers, and append-only `## Q&A Log` updates.",
-            "**Lead with adaptive elicitation, not with a proposed contract.** First walk scope forcing questions one-at-a-time per `adaptive-elicitation` skill. Only AFTER the Q&A loop converges (forcing-Qs answered/waived OR user stop-signal row recorded) propose the scope contract draft for approval. Lean discovery may compress: ask the smallest forcing-Q set that satisfies the convergence floor, then propose contract.",
-            "For low-risk concrete asks, keep the proposal compact but still explicit: recommend (do not auto-select) one mode, show exact in/out/deferred boundaries, and request explicit approval before finalizing the artifact or completing the stage.",
-            "Cite brainstorm's premise via `## Upstream Handoff` and take a firm position on whether scope-stage Q&A surfaced any premise drift; do NOT re-author the brainstorm Premise Check table.",
-            "Push back on weak framing: vague scope needs a specific user/problem, platform vision needs a narrow wedge, social proof needs behavioral evidence.",
-            "Resolve one structural scope issue at a time. Only non-critical preference/default assumptions may continue; STOP on uncertainty about scope boundary, architecture commitment, security, data loss, public API, migration, auth/pricing, or required user approval.",
-            "If the user says no but cannot name the change, offer concrete moves: keep scope, add one obvious adjacent capability, reduce to wedge, or re-open stack/product direction.",
-            "Before final approval, record outside-voice findings and a `## Scope Outside Voice Loop` table per the Scope Outside Voice Loop policy above.",
-            "**STOP.** Wait for explicit user approval of the scope mode and scope contract before writing final approval language or advancing.",
-            "**STOP BEFORE ADVANCE.** Mandatory delegation `planner` runs **AFTER user approval of the scope contract**, not before Q&A. Sequence is: Q&A loop -> propose contract -> user approval -> `planner` delegation -> `stage-complete`. If you delegate `planner` before the Q&A loop converges, you violate the elicitation contract and the linter will block stage-complete via `qa_log_unconverged`. Legal fulfillment modes for `planner`: (a) **harness-native Task tool** — run the delegation, then record the lifecycle row via `node .cclaw/hooks/delegation-record.mjs --stage=scope --agent=planner --mode=mandatory --status=completed --span-id=<uuid> --dispatch-surface=cursor-task --agent-definition-path=<agent-md-path> --evidence-ref=<artifact#section>` (the helper sets `fulfillmentMode: \"generic-dispatch\"` automatically); (b) **role-switch** — announce `## cclaw role-switch: scope/planner (mandatory)`, write the planner output/evidence into the scope artifact, then record the row with `--dispatch-surface=role-switch --agent-definition-path=<artifact-anchor>` (helper sets `fulfillmentMode: \"role-switch\"` automatically); (c) **cclaw subagent helper** if available, with `--dispatch-surface=isolated`. Run `node .cclaw/hooks/stage-complete.mjs scope` from the tool layer (do not paste the command into chat); report only the resulting summary.",
-            "Investigation discipline: follow the shared `## Investigation Discipline` block (search -> graph/impact -> narrow read of 1-3 files -> draft); pass repo-relative paths and refs to any delegated planner/critic instead of pasting upstream content.",
-            "Behavior anchor: see the shared `## Behavior anchor` block in this skill — the bad/good pair anchors how this stage's `Scope Contract` must trace each row to a recorded user signal."
-        ],
-        process: [
-            "Run pre-scope system audit (git log/diff/stash + debt-marker scan) — scope OWNS the repo audit; design will only diff the blast radius since this scope baseline.",
-            "Cite brainstorm's premise check via Upstream Handoff; record `## Premise Drift` only when the scope-stage Q&A surfaced new evidence that materially changes brainstorm's answer.",
-            "Run the scope pass scaled to risk: default to job-to-be-done plus explicit scope contract; add 10-star upside, smallest useful wedge, and change conditions only for deep/high-risk scope.",
-            "Recommend a scope mode (HOLD/SELECTIVE/EXPAND/REDUCE) with explicit rationale, then ask for user opt-in before treating it as selected. Do NOT enumerate architecture alternatives — design owns architecture choice.",
-            "Run outside voice / adversarial self-check before final approval and record a valid `## Scope Outside Voice Loop` table.",
-            "Write explicit scope contract, discretion areas, deferred items, error/rescue registry, constraints (external/regulatory/system), and D-XX locked decisions.",
-            "Produce scope summary, completion dashboard, and exact next-stage handoff before asking final approval."
-        ],
-        requiredGates: [
-            { id: "scope_mode_selected", description: "One scope mode was explicitly selected." },
-            { id: "scope_contract_written", description: "In-scope/out-of-scope contract is documented." },
-            { id: "scope_user_approved", description: "User approved the final scope direction." }
-        ],
-        requiredEvidence: [
-            "Artifact written to `.cclaw/artifacts/02-scope-<slug>.md`.",
-            "Pre-Scope System Audit findings are captured (git log/diff/stash/debt markers).",
-            "In-scope and out-of-scope lists are explicit.",
-            "Discretion areas are explicit (or marked as `None`).",
-            "Selected mode and rationale are documented using HOLD SCOPE, SELECTIVE EXPANSION, SCOPE EXPANSION, or SCOPE REDUCTION.",
-            "When selected mode is SCOPE EXPANSION or SELECTIVE EXPANSION, active-run delegation ledger includes a completed `product-discovery` row with non-empty `evidenceRefs`.",
-            "Scope Contract captures requirements, locked decisions, discretion areas, accepted/rejected/deferred reference ideas from the Reference Pattern Registry, success definition, and design handoff.",
-            "Decision Drivers section records weighted criteria and per-option scores used to choose mode and boundary moves.",
-            "Scope Completeness Score is recorded (0.00-1.00) with the explicit blocker list for any remaining uncertainty.",
-            "Locked Decisions section lists stable D-XX IDs for non-negotiable boundaries.",
-            "Premise carry-forward recorded: brainstorm `## Premise Check` cited in `## Upstream Handoff > Decisions carried forward`; `## Premise Drift` is `None` unless new scope-stage evidence materially changes brainstorm's answer.",
-            "Constraints (external/regulatory/system/integration) recorded in `## Scope Contract > Constraints` — spec must reference these in `## Constraints and Assumptions`, not restate them.",
-            "Outside Voice findings and dispositions are recorded (accept/reject/defer with rationale) before final approval.",
-            "Scope outside-voice loop summary includes a table with columns Iteration, Quality Score, Findings, plus Stop reason, Target score, Max iterations, and unresolved concerns. This is outside-voice evidence only; it does not satisfy user approval.",
-            "Early-loop status is reflected via `Victory Detector` / `Critic Pass` sections and `.cclaw/state/early-loop.json` when concerns remain.",
-            "When a second opinion is used, record source, critique frame, and disposition (accept/reject/defer) with rationale.",
-            "Deferred items list with one-line rationale for each.",
-            "When an upside deferred idea is parked, a seed file is created under `.cclaw/seeds/` and referenced in the artifact.",
-            "Completion dashboard lists per-section status, critical/open gaps, decision count, and unresolved items (or `None`).",
-            "Scope Summary includes a next-stage handoff naming the track-aware successor (`design` for standard, `spec` for medium) and the decisions/artifacts it must carry forward."
-        ],
-        inputs: ["brainstorm artifact", "timeline constraints", "product priorities"],
-        requiredContext: [
-            "approved brainstorm direction with selected option and non-goals",
-            "existing capabilities and reusable components",
-            "delivery deadlines and risk tolerance"
-        ],
-        researchPlaybooks: [
-            "research/git-history.md"
-        ],
-        blockers: [
-            "scope mode not selected",
-            "in/out boundaries ambiguous",
-            "discretion areas undefined",
-            "critical premise disagreement unresolved"
-        ],
-        exitCriteria: [
-            "scope contract approved by user",
-            "discretion areas recorded explicitly",
-            "required gates marked satisfied",
-            "deferred list recorded explicitly",
-            "locked decisions captured with stable D-XX IDs",
-            "completion dashboard produced",
-            "scope summary produced"
-        ],
-        platformNotes: [
-            "Scope contract paths must be repo-relative with forward slashes so they resolve identically on Windows, macOS, and Linux (`src/pkg/mod.ts`, NOT `src\\pkg\\mod.ts`).",
-            "When invoking `git log`/`git diff` for the Pre-Scope audit, wrap glob patterns in single quotes on POSIX shells and double quotes on PowerShell (`git log -- 'src/**/*.ts'` vs `git log -- \"src/**/*.ts\"`). Document the command with the quoting style you actually ran.",
-            "Do not hard-code machine-specific absolute paths (home dirs, drive letters) into the scope contract — keep boundaries repo-relative."
-        ]
-    },
-    artifactRules: {
-        artifactFile: "02-scope-<slug>.md",
-        completionStatus: ["DONE", "DONE_WITH_CONCERNS", "BLOCKED"],
-        crossStageTrace: {
-            readsFrom: [".cclaw/artifacts/01-brainstorm-<slug>.md"],
-            writesTo: [".cclaw/artifacts/02-scope-<slug>.md"],
-            traceabilityRule: "Every scope boundary must be traceable to a brainstorm decision. Every downstream design choice must stay within the scope contract."
-        },
-        artifactValidation: [
-            { section: "Upstream Handoff", required: false, validationRule: "Summarizes brainstorm/idea decisions, constraints, open questions, and explicit drift before scope decisions." },
-            { section: "Pre-Scope System Audit", required: true, validationRule: "Must capture git log -30, git diff --stat, git stash list, and debt-marker scan (TODO/FIXME/XXX/HACK). Scope OWNS the repo audit; design will only diff the blast radius since this scope baseline." },
-            { section: "Prime Directives", required: false, validationRule: "For each scoped capability: named failure modes, explicit error surface, four data-flow paths, interaction edge cases, observability expectations, and deferred-item handling." },
-            { section: "Premise Drift", required: false, validationRule: "Optional carry-forward marker: brainstorm OWNS the premise check. State `None` unless scope-stage Q&A surfaced new evidence (constraint, user signal, regulatory change) that materially changes brainstorm's `## Premise Check` answer; in that case record one or more drift rows citing the new evidence and the affected brainstorm question." },
-            { section: "Scope Contract", required: true, validationRule: "Canonical contract: selected mode, in scope, out of scope, requirements, locked decisions, discretion areas, deferred ideas, accepted/rejected reference ideas, constraints (external/regulatory/system/integration), success definition, and design handoff. Architecture choice is delegated to design — do NOT enumerate Implementation Alternatives here." },
-            { section: "Decision Drivers", required: false, validationRule: "Recommended: weighted decision drivers (value, risk, reversibility, effort, timeline) with scored options and the selected boundary rationale." },
-            { section: "Scope Completeness Score", required: false, validationRule: "Recommended: score 0.00-1.00 plus unresolved blockers and the escalation trigger when confidence is low." },
-            { section: "Landscape Check", required: false, validationRule: "Optional evidence heading for EXPAND/SELECTIVE/deep modes: include reference insight and impact on scope, or omit for compact HOLD SCOPE." },
-            { section: "Taste Calibration", required: false, validationRule: "Optional evidence heading: reference 2-3 strong in-repo modules/files that define the quality bar or justify omission." },
-            { section: "Reference Pattern Registry", required: false, validationRule: "Recommended for SELECTIVE/EXPAND/deep scope: table of pattern/source, accepted/rejected/deferred disposition, invariant to preserve, and boundary impact. Compact HOLD SCOPE may state `Not needed - compact scope`." },
-            { section: "Reference Pull", required: false, validationRule: "Optional evidence heading: cite ideas pulled from `<repo-relative references dir>` or state no reference pull was needed for compact HOLD SCOPE." },
-            { section: "Ambitious Alternatives", required: false, validationRule: "Optional evidence heading for SCOPE EXPANSION/SELECTIVE: list larger alternatives considered and their disposition." },
-            { section: "Ruthless Minimum Slice", required: false, validationRule: "Optional evidence heading for SCOPE REDUCTION or high-risk scope: define the smallest useful wedge and what it proves." },
-            { section: "Requirements", required: false, validationRule: "Table of stable requirement IDs (R1, R2, R3…) one per row with observable outcome, priority, and source. IDs are assigned once and never renumbered across scope/design/spec/plan/review; dropped requirements stay with Priority `DROPPED`." },
-            { section: "Locked Decisions", required: false, validationRule: "List of stable locked decisions, each with a unique `D-XX` ID. IDs are stable across edits so downstream stages can reference them; renumbering or duplicating IDs breaks the cross-stage traceability check." },
-            { section: "Scope Mode", required: true, validationRule: "Must state selected mode and rationale with default heuristic justification." },
-            { section: "Mode-Specific Analysis", required: false, validationRule: "Default path: one selected-mode row with rationale. Deep/complex scope only: document the expanded analysis matching the selected mode." },
-            { section: "In Scope / Out of Scope", required: true, validationRule: "Two separate explicit lists. Canonical form is one `## In Scope / Out of Scope` section with `### In Scope` and `### Out of Scope`; legacy split `## In Scope` and `## Out of Scope` headings are accepted. Out-of-scope must not be empty." },
-            { section: "Discretion Areas", required: false, validationRule: "Explicit list of implementer decision zones, or 'None' if scope is fully locked." },
-            { section: "Deferred Items", required: false, validationRule: "Each item has one-line rationale. If empty, state 'None' explicitly." },
-            { section: "Error & Rescue Registry", required: false, validationRule: "Each scoped capability has: failure mode, detection method, fallback decision." },
-            { section: "Outside Voice Findings", required: false, validationRule: "Must list external/adversarial findings and disposition (accept/reject/defer) with rationale." },
-            { section: "Scope Outside Voice Loop", required: false, validationRule: `Must record iterations, quality score per iteration, stop reason, and unresolved concerns. Enforce ${reviewLoopPolicySummary("scope")}` },
-            { section: "Victory Detector", required: false, validationRule: "Recommended early-loop checkpoint: cite `.cclaw/state/early-loop.json`, current iteration/maxIterations, open concern count, convergence status, and iterate/ready/escalate decision." },
-            { section: "Critic Pass", required: false, validationRule: "Recommended producer/critic log contract: each iteration appends one JSONL row to `.cclaw/state/early-loop-log.jsonl` with runId, stage, iteration, and open concerns." },
-            { section: "Completion Dashboard", required: true, validationRule: "Lists per-review-section status, count of critical/open gaps, resolved decisions, and unresolved decisions (or 'None')." },
-            { section: "Scope Summary", required: true, validationRule: "Compact recap of the locked scope. Must name the selected mode using one canonical token, confidence, explicit drift from brainstorm, unresolved questions, and the track-aware next-stage handoff (`design` for standard, `spec` for medium); the linter checks structure, not English wording." }
-        ]
-    },
-    reviewLens: {
-        outputs: ["scope mode decision", "scope contract", "discretion areas list", "deferred scope list", "scope summary", "scope completion dashboard"],
-        reviewLoop: {
-            stage: "scope",
-            checklist: REVIEW_LOOP_CHECKLISTS.scope.map((dimension) => dimension.id),
-            maxIterations: 3,
-            targetScore: 0.8
-        },
-        reviewSections: [
-            {
-                title: "Scope Boundary Audit",
-                evaluationPoints: [
-                    "Are all in-scope items justified by the problem statement?",
-                    "Are any in-scope items actually solving a proxy problem instead of the real one?",
-                    "Could any in-scope item be deferred without blocking the core objective?"
-                ],
-                stopGate: true
-            },
-            {
-                title: "Deferred Items Review",
-                evaluationPoints: [
-                    "Does each deferred item have a one-line rationale?",
-                    "Are any deferred items actually blockers for the core scope?",
-                    "Will deferring these items create technical debt that is expensive to unwind?"
-                ],
-                stopGate: true
-            },
-            {
-                title: "Risk and Reversibility Check",
-                evaluationPoints: [
-                    "For each major scope decision: is it reversible?",
-                    "What is the blast radius if this decision is wrong?",
-                    "Are there hidden dependencies between in-scope and out-of-scope items?"
-                ],
-                stopGate: true
-            },
-            {
-                title: "Existing-Code Reuse Check",
-                evaluationPoints: [
-                    "Has every sub-problem been mapped to existing code?",
-                    "Is the plan rebuilding anything that already exists?",
-                    "Are there integration opportunities that reduce new code?",
-                    "Have you searched for built-in or library solutions before scoping custom work?"
-                ],
-                stopGate: true
-            },
-            {
-                title: "Error & Rescue Scope Check",
-                evaluationPoints: [
-                    "For every new capability: what breaks if it fails?",
-                    "Is failure detection in scope or deferred? If deferred, is that acceptable?",
-                    "Are there rescue/fallback paths for critical user journeys?",
-                    "Is observability (logging, metrics, alerts) explicitly in or out of scope?"
-                ],
-                stopGate: true
-            },
-            {
-                title: "Outside Voice Reconciliation",
-                evaluationPoints: [
-                    "Were adversarial findings categorized as accept/reject/defer with rationale?",
-                    "Did any rejected finding still expose a real gap in assumptions?",
-                    "Is quality score trajectory improving across iterations?",
-                    "Did the review loop stop because quality threshold was met (>=0.8) or because retry budget was exhausted?"
-                ],
-                stopGate: true
-            }
-        ]
-    },
-    next: "design"
-};

package/dist/content/stages/ship.d.ts

@@ -1,2 +0,0 @@
-import type { StageSchemaInput } from "./schema-types.js";
-export declare const SHIP: StageSchemaInput;