cclaw-cli 7.7.1 → 8.1.0

package/dist/content/review-prompts.js

@@ -1,104 +0,0 @@
-export const REVIEW_PROMPTS = {
-    "brainstorm-self-review.md": `# Brainstorm Self-Review Prompt
-
-Use this before asking the user to approve the brainstorm artifact.
-
-## Calibration
-
-Only flag issues that would cause a real downstream scope/design mistake:
-wrong problem, no real alternative, hidden scope growth, missing user reaction,
-or a recommendation that does not trace to the user's answer.
-
-Do not flag prose style, wording preferences, section length, or missing detail
-that would not change the scope/design decision.
-
-## Checks
-
-| Category | What to check |
-|---|---|
-| Premise | Is this the right problem and the direct path? |
-| Alternatives | Are there 2-3 meaningfully different options, including exactly one challenger with high/higher upside? |
-| User reaction | Does the selected direction trace to the user's reaction/concerns? |
-| Scope protection | Does the Not Doing list prevent silent enlargement? |
-| Handoff | Is the next-stage handoff explicit and track-aware? |
-
-## Output
-
-Write the result into \`## Self-Review Notes\`:
-
-\`\`\`markdown
-- Status: Approved | Issues Found
-- Patches applied:
-  - <specific patch or None>
-- Remaining concerns:
-  - <concern or None>
-\`\`\`
-`,
-    "scope-ceo-review.md": `# Scope CEO Review Prompt
-
-Use this after drafting scope boundaries and before user approval.
-
-## Calibration
-
-Think like a founder reviewing whether this is the right product slice. Flag
-only issues that would materially change scope, sequencing, leverage, or user
-value. Do not nitpick wording.
-
-## Checks
-
-| Category | What to check |
-|---|---|
-| Premise | Are we solving the right problem now? |
-| Leverage | Are we using existing code, constraints, and platform strengths? |
-| 10-star delta | Is there a better high-leverage scope move worth cherry-picking? |
-| Boundary | Are accepted, deferred, and excluded items unambiguous? |
-| Mode fit | Does the selected mode match the evidence: SCOPE EXPANSION, SELECTIVE EXPANSION, HOLD SCOPE, or SCOPE REDUCTION? |
-| Downstream refs | Are R-IDs and D-XX decision IDs ready for design/spec/plan? |
-
-## Output
-
-Record in \`## Outside Voice Findings\` or the stage-specific outside voice loop section:
-
-\`\`\`markdown
-| ID | Dimension | Finding | Disposition | Rationale |
-|---|---|---|---|---|
-| CEO-1 | <dimension> | <issue> | accept/reject/defer | <why> |
-\`\`\`
-`,
-    "design-eng-review.md": `# Design Engineering Review Prompt
-
-Use this after drafting design and before handing to spec.
-
-## Calibration
-
-Think like a senior engineer reviewing whether implementation can proceed
-without hidden architecture risk. Flag only issues that would cause wrong code,
-rework, missing failure behavior, or unverifiable acceptance criteria.
-
-## Checks
-
-| Category | What to check |
-|---|---|
-| Architecture | Are component boundaries concrete and aligned with scope? |
-| Data flow | Are inputs, outputs, persistence, and async/sync edges explicit? |
-| Failure modes | Does every meaningful failure have detection, rescue, and user-visible behavior? |
-| Traceability | Do design decisions reference relevant R-IDs and D-XX decision IDs? |
-| Verification | Is each risky choice testable by spec/plan/TDD? |
-| Overbuild | Is any architecture stronger than the locked scope actually needs? |
-
-## Output
-
-Record findings in the design artifact's review section:
-
-\`\`\`markdown
-## Engineering Review
-**Status:** Approved | Issues Found
-
-**Issues:**
-- [R#/D-XX]: <specific issue> — <why it matters>
-
-**Recommendations:**
-- <advisory item or None>
-\`\`\`
-`
-};

package/dist/content/runtime-shared-snippets.d.ts

@@ -1,8 +0,0 @@
-/**
- * Shared runtime snippets interpolated into generated hook/plugin scripts.
- *
- * Keep these string helpers minimal and dependency-free so both runtimes
- * (node hooks and OpenCode plugin) stay in sync without duplicating constants.
- */
-export declare const SHARED_FLOW_AND_KNOWLEDGE_SNIPPETS = "\nfunction summarizeFlowState(rawState) {\n  const state =\n    rawState && typeof rawState === \"object\" && !Array.isArray(rawState)\n      ? rawState\n      : {};\n  return {\n    stage: typeof state.currentStage === \"string\" ? state.currentStage : \"none\",\n    completed: Array.isArray(state.completedStages) ? state.completedStages.length : 0,\n    activeRunId: typeof state.activeRunId === \"string\" ? state.activeRunId : \"none\"\n  };\n}\n\nfunction parseKnowledgeDigest(rawKnowledge, currentStage, maxRows = 6) {\n  const text = typeof rawKnowledge === \"string\" ? rawKnowledge : \"\";\n  if (text.trim().length === 0) {\n    return { learningsCount: 0, lines: [] };\n  }\n  const rows = text\n    .split(/\\r?\\n/gu)\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0);\n  let learningsCount = 0;\n  const parsedRows = [];\n  for (const line of rows) {\n    if (line.startsWith(\"{\")) learningsCount += 1;\n    try {\n      const parsed = JSON.parse(line);\n      if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) continue;\n      parsedRows.push(parsed);\n    } catch {\n      // ignore malformed knowledge line in digest\n    }\n  }\n  const lines = parsedRows\n    .filter((row) => {\n      const stage = typeof row.stage === \"string\" ? row.stage : null;\n      return stage === null || stage === currentStage;\n    })\n    .slice(-maxRows)\n    .reverse()\n    .map((row) => {\n      const confidence = typeof row.confidence === \"string\" ? row.confidence : \"unknown\";\n      const stage = typeof row.stage === \"string\" ? row.stage : \"global\";\n      const trigger = typeof row.trigger === \"string\" ? row.trigger : \"trigger\";\n      const action = typeof row.action === \"string\" ? row.action : \"action\";\n      return \"- [\" + confidence + \" \u2022 \" + stage + \"] \" + trigger + \" -> \" + action;\n    });\n  return { learningsCount, lines };\n}\n\nfunction activeArtifactsPathLabel(runtimeRoot) {\n  return String(runtimeRoot || \".cclaw\") + \"/artifacts/\";\n}\n";
-export declare const SHARED_STAGE_SUPPORT_SNIPPETS = "\nconst STAGE_IDS = [\"brainstorm\", \"scope\", \"design\", \"spec\", \"plan\", \"tdd\", \"review\", \"ship\"];\nconst REVIEW_PROMPT_BY_STAGE = {\n  brainstorm: \"brainstorm-self-review.md\",\n  scope: \"scope-ceo-review.md\",\n  design: \"design-eng-review.md\"\n};\nconst REVIEW_PROMPT_FILES = Object.values(REVIEW_PROMPT_BY_STAGE);\n\nfunction isKnownStageId(stage) {\n  return typeof stage === \"string\" && STAGE_IDS.includes(stage);\n}\n\nfunction reviewPromptFileName(stage) {\n  if (!isKnownStageId(stage)) return null;\n  const name = REVIEW_PROMPT_BY_STAGE[stage];\n  return typeof name === \"string\" ? name : null;\n}\n";

package/dist/content/runtime-shared-snippets.js

@@ -1,80 +0,0 @@
-/**
- * Shared runtime snippets interpolated into generated hook/plugin scripts.
- *
- * Keep these string helpers minimal and dependency-free so both runtimes
- * (node hooks and OpenCode plugin) stay in sync without duplicating constants.
- */
-export const SHARED_FLOW_AND_KNOWLEDGE_SNIPPETS = `
-function summarizeFlowState(rawState) {
-  const state =
-    rawState && typeof rawState === "object" && !Array.isArray(rawState)
-      ? rawState
-      : {};
-  return {
-    stage: typeof state.currentStage === "string" ? state.currentStage : "none",
-    completed: Array.isArray(state.completedStages) ? state.completedStages.length : 0,
-    activeRunId: typeof state.activeRunId === "string" ? state.activeRunId : "none"
-  };
-}
-
-function parseKnowledgeDigest(rawKnowledge, currentStage, maxRows = 6) {
-  const text = typeof rawKnowledge === "string" ? rawKnowledge : "";
-  if (text.trim().length === 0) {
-    return { learningsCount: 0, lines: [] };
-  }
-  const rows = text
-    .split(/\\r?\\n/gu)
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0);
-  let learningsCount = 0;
-  const parsedRows = [];
-  for (const line of rows) {
-    if (line.startsWith("{")) learningsCount += 1;
-    try {
-      const parsed = JSON.parse(line);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-      parsedRows.push(parsed);
-    } catch {
-      // ignore malformed knowledge line in digest
-    }
-  }
-  const lines = parsedRows
-    .filter((row) => {
-      const stage = typeof row.stage === "string" ? row.stage : null;
-      return stage === null || stage === currentStage;
-    })
-    .slice(-maxRows)
-    .reverse()
-    .map((row) => {
-      const confidence = typeof row.confidence === "string" ? row.confidence : "unknown";
-      const stage = typeof row.stage === "string" ? row.stage : "global";
-      const trigger = typeof row.trigger === "string" ? row.trigger : "trigger";
-      const action = typeof row.action === "string" ? row.action : "action";
-      return "- [" + confidence + " • " + stage + "] " + trigger + " -> " + action;
-    });
-  return { learningsCount, lines };
-}
-
-function activeArtifactsPathLabel(runtimeRoot) {
-  return String(runtimeRoot || ".cclaw") + "/artifacts/";
-}
-`;
-export const SHARED_STAGE_SUPPORT_SNIPPETS = `
-const STAGE_IDS = ["brainstorm", "scope", "design", "spec", "plan", "tdd", "review", "ship"];
-const REVIEW_PROMPT_BY_STAGE = {
-  brainstorm: "brainstorm-self-review.md",
-  scope: "scope-ceo-review.md",
-  design: "design-eng-review.md"
-};
-const REVIEW_PROMPT_FILES = Object.values(REVIEW_PROMPT_BY_STAGE);
-
-function isKnownStageId(stage) {
-  return typeof stage === "string" && STAGE_IDS.includes(stage);
-}
-
-function reviewPromptFileName(stage) {
-  if (!isKnownStageId(stage)) return null;
-  const name = REVIEW_PROMPT_BY_STAGE[stage];
-  return typeof name === "string" ? name : null;
-}
-`;

package/dist/content/session-hooks.d.ts

@@ -1,7 +0,0 @@
-/**
- * Session guidelines content for Cclaw.
- * Describes recommended behavior at session boundaries.
- * Pure markdown generation — no runtime logic.
- */
-export declare function sessionHooksSkillMarkdown(): string;
-export declare function sessionHooksAgentsMdBlock(): string;

package/dist/content/session-hooks.js

@@ -1,107 +0,0 @@
-/**
- * Session guidelines content for Cclaw.
- * Describes recommended behavior at session boundaries.
- * Pure markdown generation — no runtime logic.
- */
-export function sessionHooksSkillMarkdown() {
-    return `---
-name: session
-description: "Session boundary guidelines: what to do when a session starts, ends, or reaches a stop condition."
----
-
-# Session Guidelines
-
-## Overview
-
-This skill defines recommended behavior at **session boundaries** — start, stop, and resume. These guidelines help agents maintain continuity, avoid losing context, and enforce quality gates at natural breakpoints.
-
-These are prompt-discipline guidelines that complement the real hooks cclaw generates. The hooks handle automatic context injection at session start/stop; these guidelines cover manual steps the agent should follow.
-
-## HARD-GATE
-
-**Never end a session with uncommitted or untested changes.** If you must stop, leave a short handoff in the current artifact or commit message.
-
-## Session Start Protocol
-
-When a new session begins in any harness:
-
-1. **Read flow state:** Load \`.cclaw/state/flow-state.json\` to find the current stage and completed stages.
-2. **Load knowledge:** Use the session-injected knowledge digest first; stream \`.cclaw/knowledge.jsonl\` only when the digest is missing or insufficient.
-3. **Check for in-progress work:** If the last stage is incomplete, remind the user and offer to resume.
-4. **Load iron laws:** Read \`.cclaw/state/iron-laws.json\` to know which laws are strict in this repo.
-5. **Read AGENTS.md:** The cclaw block contains routing and rules — follow them.
-
-### What to show the user at session start
-
-\`\`\`
-Cclaw flow state: [current stage] ([N] of 8 stages completed)
-Knowledge highlights: [rule/pattern 1], [rule/pattern 2], [rule/pattern 3]
-Next action: /cc to continue or start work, /cc-cancel to cancel, or describe what you'd like to do.
-\`\`\`
-
-## Session Stop Protocol
-
-Before ending a session or when context is full:
-
-1. **Verify no pending changes:** All modified files must be either committed or explicitly reverted.
-2. **Update flow state:** Mark the current stage as its actual status (DONE / DONE_WITH_CONCERNS / BLOCKED).
-3. **Capture knowledge:** If any non-obvious reusable insight appears during stage work, add a strict JSON bullet to the current artifact \`## Learnings\`; stage completion harvests it into \`.cclaw/knowledge.jsonl\`.
-4. **Leave handoff context:** Put blockers and remaining work in the current stage artifact, not a separate state file.
-
-### Stop conditions (agent must halt and report)
-
-- Repeated verification failure (3+ attempts at the same check)
-- Unclear requirements that block progress
-- Security concern discovered that needs human review
-- Context window approaching limit — compact or hand off
-
-## Session Resume Protocol
-
-When resuming work after a break:
-
-1. Re-read \`.cclaw/state/flow-state.json\` (may have changed externally).
-2. Re-read the current stage's artifact to verify it matches the last handoff.
-3. Re-load the knowledge digest first, then scan \`.cclaw/knowledge.jsonl\` only if the digest lacks enough evidence.
-4. Continue from the last incomplete step — do not restart the stage.
-
-### Optional session-history scan for compound
-
-During post-ship \`post_ship_review\`, ask before scanning external session history. If the user opts in, inspect only relevant Cursor/Claude/Codex transcripts for repeated failures or process lessons, summarize matches, and then apply the same overlap/refresh/supersede rules before touching \`.cclaw/knowledge.jsonl\`.
-
-## Context Management
-
-When approaching context limits:
-
-1. **Prefer subagents** for deep investigation (results return as summary, not full context).
-2. **Compact strategically** — at logical breakpoints (after a stage completes), not mid-task.
-3. **Never compact during:** active debugging, mid-refactor, or while holding uncommitted changes.
-4. **After compaction:** re-read flow state and current artifact before continuing.
-
-## Common Rationalizations
-
-| Rationalization | Reality |
-|---|---|
-| "I'll remember where I was" | Context is lost between sessions. Write it down. |
-| "This is almost done, no need for handoff" | "Almost done" is the most dangerous state — changes are half-applied. |
-| "The tests will tell me the state" | Tests tell you pass/fail, not intent or remaining work. |
-
-## Red Flags
-
-- Ending a session with modified but uncommitted files
-- No flow state update after completing work
-- Restarting a stage from scratch instead of resuming from artifact context
-- Ignoring knowledge from prior sessions
-`;
-}
-export function sessionHooksAgentsMdBlock() {
-    return `### Session Guidelines
-
-Session boundary behavior (real hooks inject context automatically; guidelines cover manual steps):
-- **Start:** Hooks inject flow state + knowledge snapshot. Check for in-progress work, show status.
-- **Stop:** Hooks remind about handoff. Verify no pending changes, update the current artifact handoff, and capture reusable knowledge in \`## Learnings\`; stage completion harvests it.
-- **Resume:** Re-read state, verify artifact, re-load knowledge, continue from last step. For compound closeout, optional session-history scans require user opt-in.
-
-Skill: \`.cclaw/skills/session/SKILL.md\`
-Policy: \`.cclaw/skills/iron-laws/SKILL.md\`
-`;
-}

package/dist/content/skills-elicitation.d.ts

@@ -1 +0,0 @@
-export declare function adaptiveElicitationSkillMarkdown(): string;

package/dist/content/skills-elicitation.js

@@ -1,167 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-import { questionBudgetHint } from "../track-heuristics.js";
-const ELICITATION_STAGES = ["brainstorm", "scope", "design"];
-function renderQuestionBudgetHintTable() {
-    const rows = [];
-    for (const mode of ["lean", "guided", "deep"]) {
-        for (const stage of ELICITATION_STAGES) {
-            const hint = questionBudgetHint(mode, stage);
-            rows.push(`| \`${mode}\` | \`${stage}\` | ${hint.min} | ${hint.recommended} | ${hint.hardCapWarning} |`);
-        }
-    }
-    return `| Discovery mode | Stage | Min | Recommended | Hard cap warning |
-|---|---|---|---|---|
-${rows.join("\n")}`;
-}
-export function adaptiveElicitationSkillMarkdown() {
-    const budgetTable = renderQuestionBudgetHintTable();
-    return `---
-name: adaptive-elicitation
-description: "Harness-native one-question-at-a-time dialogue for brainstorm/scope/design with stop signals, smart-skip, and append-only Q&A logging. Walking forcing questions in order is mandatory; the linter blocks stage-complete when Q&A Log is below floor."
----
-
-# Adaptive Elicitation
-
-Pinned anchor: "Don't tell it what to do, give it success criteria and watch it go."
-
-## Anti-pattern (BAD examples — never do these)
-
-These behaviors are the exact reason this skill exists. The linter will block your stage-complete if you do them.
-
-- **Bad**: User asks for a "simple web app" -> agent asks 1 question about stack -> 1 question about auth -> drafts the brainstorm artifact and asks for approval.
-- **Good**: User asks for a "simple web app" -> agent asks Q1 (what pain) -> Q2 (direct path) -> Q3 (first operator/user) -> Q4 (no-go boundaries) -> self-eval: clear -> drafts the brainstorm artifact.
-
-- **Bad**: Agent immediately dispatches a subagent (\`product-discovery\`, \`critic\`, \`planner\`) at the start of brainstorm/scope/design to "gather context" before any user dialogue.
-- **Good**: Agent walks the Q&A loop with the user first; subagent dispatch happens only after the user approves the elicitation outcome.
-
-- **Bad**: Agent batches 3-5 grill questions into one large message and asks the user to answer them all at once.
-- **Good**: Agent asks one grill question, waits, logs the answer, asks the next.
-
-- **Bad**: Agent skips forcing questions because it "already has a good idea" of the answer.
-- **Good**: Agent asks the forcing question; if the user's reply confirms the assumption, log it as \`asked (confirmed assumption)\` and move on. Do not silently skip.
-
-## HARD-GATE (machine-enforced)
-
-- User does not run cclaw manually. Do not tell the user to run CLI commands for answers.
-- Ask exactly one question per turn and wait for the answer before asking the next one.
-- Use harness-native question tools first; prose fallback is allowed only when the tool is unavailable.
-- Keep a running Q&A trace in the active artifact under \`## Q&A Log\` in \`${RUNTIME_ROOT}/artifacts/\` as append-only rows.
-- **Early-loop ledger discipline**: Never append \`.cclaw/state/early-loop-log.jsonl\` rows whose \`iteration\` exceeds the active \`maxIterations\`. If the cap fired, escalate or accept convergence outcomes—do not bump the iteration counter afterward. \`deriveEarlyLoopStatus\` clamps persistence, but the log source should stay honest too.
-- **Convergence floor (a.k.a. "Q&A Ralph Loop" / "Elicitation Convergence")**: do NOT advance the stage (do NOT call \`stage-complete.mjs\`) until Q&A converges. The machine contract matches \`evaluateQaLogFloor\` in \`src/artifact-linter/shared.ts\` (rule \`qa_log_unconverged\`). Pass when ANY holds: (a) every forcing-question topic id is tagged \`[topic:<id>]\` on at least one \`## Q&A Log\` row; (b) the Q&A Ralph Loop detector fires (last 2 substantive rows are non-decision-changing: \`skip\`/\`continue\`/\`no-change\`/\`done\`/etc.) **and** the log has at least \`max(2, questionBudgetHint(discoveryMode, stage).min)\` substantive rows — **unless** \`discoveryMode\` is \`guided\` or \`deep\` with pending forcing-topic ids (then the Q&A Ralph Loop alone cannot pass until topics are tagged, a stop-signal is recorded, or \`--skip-questions\` downgrades the finding to advisory); (c) an explicit user stop-signal row; or (d) \`--skip-questions\` was persisted (unconverged is advisory only). made \`[topic:<id>]\` mandatory (no English keyword fallback). The "Q&A Ralph Loop" is the elicitation-stage convergence mechanism; the producer/critic Concern Ledger that drives early-stage iteration is the **Early-Loop**, persisted in \`.cclaw/state/early-loop-log.jsonl\` and \`early-loop.json\` — they are different machines, do not conflate them.
-- **NEVER run shell hash commands** (\`shasum\`, \`sha256sum\`, \`md5sum\`, \`Get-FileHash\`, \`certutil\`, etc.) to compute artifact hashes. If a linter ever asks you for a hash, that is a linter bug — report failure and stop, do not auto-fix in bash.
-- **NEVER paste cclaw command lines into chat** (e.g. \`node .cclaw/hooks/stage-complete.mjs ... --evidence-json '{...}'\`). Run them via the tool layer; report only the resulting summary. The user does not run cclaw manually and seeing the command line is noise.
-
-## Harness Question Surface
-
-Preferred native tool names:
-- Claude Code: \`AskUserQuestion\`
-- Codex: \`request_user_input\`
-- Gemini: \`ask_user\`
-- Cursor: \`AskQuestion\`
-
-If unavailable, ask one concise prose question and explicitly wait for chat answer.
-
-## Core Protocol
-
-1. Ask one decision-changing question via the harness-native question tool.
-2. Wait for the answer.
-3. Append one row to \`## Q&A Log\`: \`Turn | Question | User answer (1-line) | Decision impact\`.
-4. Self-evaluate:
-   - What did I learn?
-   - Is context enough to draft now? (yes/no + reason)
-   - Have I covered all stage forcing questions in order? (yes/no + which remain)
-   - If forcing questions remain or context is incomplete, what is the next decision-changing question?
-5. Repeat until **all forcing questions are answered/skipped/waived AND self-evaluation says context is sufficient**, OR user records an explicit stop-signal row.
-
-## Question Shape Rules
-
-- Prefer single-select multiple choice when one direction/priority/next step must be chosen.
-- Use multi-select only for compatible sets (goals, constraints, non-goals).
-- Smart-skip: if a question is already answered earlier (directly or implicitly), log \`skipped (already covered: turn N)\` instead of skipping silently. The smart-skip row counts as a substantive Q&A Log entry for floor purposes.
-
-## Stop Signals (Natural Language)
-
-Treat these as stop-and-draft signals:
-- RU: "достаточно", "хватит", "давай драфт", "хватит вопросов"
-- EN: "enough", "skip", "just draft it", "stop asking", "move on", "no more questions"
-- UA: "досить", "вистачить", "давай драфт", "рухаємось далі"
-
-Label disambiguation: The word **skip** is a valid stop phrase during brainstorm/scope/design Q&A. In ship closeout retros, compound clustering, or any structured retro ask, expose **no changes** / **accept as-is** for the passive option instead of wording it as "skip" so agents do not mix elicitation stop-signals with closeout choreography.
-
-When detected:
-- Append a Q&A Log row exactly like: \`Turn N | (stop-signal) | <user quote> | stop-and-draft\` — this row satisfies the linter floor escape hatch.
-- Do not ask another question in this stage loop.
-- Move to drafting with available context.
-- For the next internal agent-only call to advance-stage, pass \`--skip-questions\`. **The user never sees or types this flag.**
-
-## Conditional Grilling (Only On Risk Triggers)
-
-When one of these triggers appears, continue the elicitation loop with sharper questions **one at a time** (do NOT batch them):
-- Irreversibility (data deletion, schema migration, breaking API/contract)
-- Security/auth boundary changes
-- Domain-model ambiguity with multiple plausible invariants
-
-Each grill question follows the same Core Protocol: ask one, wait, log, self-eval, ask next.
-
-Do not ask extra questions "for theater" on simple low-risk work.
-
-## Question Budget Hint (\`questionBudgetHint\` — min rows feed the convergence floor)
-
-Source of truth: \`questionBudgetHint(discoveryMode, stage)\`. The \`Min\` column is **not advisory** for the Q&A Ralph Loop exit: \`evaluateQaLogFloor\` requires at least \`max(2, Min)\` substantive rows before the no-new-decisions path can converge (other exits — full topic coverage, stop-signal, \`--skip-questions\` advisory — ignore that minimum). \`Recommended\` and \`Hard cap warning\` remain pacing hints for the harness.
-
-${budgetTable}
-
-Default mapping note: \`lean\` maps to a lightweight specialist tier on early stages, \`guided\` to standard, \`deep\` to deep; risk signals can escalate further.
-
-**Walk the forcing questions list one-by-one in order, asking each as a separate turn.** Do NOT batch. Do NOT pick favorites — go in order. For each question record one of:
-- \`asked\` — question was asked and answered.
-- \`asked (confirmed assumption)\` — question was asked, user confirmed your prior reading.
-- \`skipped (already covered: turn N)\` — answered implicitly by an earlier reply; cite the turn.
-- \`waived (user override)\` — user explicitly waived this question.
-
-### Topic tagging (MANDATORY for forcing-question rows)
-
-Each forcing question has a stable topic id (kebab-case ASCII, e.g. \`pain\`, \`direct-path\`, \`data-flow\`). Tag the matching Q&A Log row's \`Decision impact\` cell with \`[topic:<id>]\` so the linter can verify coverage in any natural language. This is a **HARD requirement** in the linter no longer keyword-matches English question prose, so an un-tagged row does NOT count toward coverage even if the answer fully addresses the topic.
-
-RU example (after asking \`pain\` in Russian):
-
-\`\`\`
-| Turn | Question | User answer (1-line) | Decision impact |
-|---|---|---|---|
-| 1 | Какую боль мы решаем? | Регистрация занимает 30 минут. | scope-shaping [topic:pain] |
-\`\`\`
-
-Multiple tags in one row are allowed when one answer covers several topics: \`[topic:pain] [topic:direct-path]\`. Stop-signal rows do NOT need a tag.
-
-Stage forcing question lists (id → topic):
-
-- **Brainstorm**:
-  - \`pain\` — What pain are we solving?
-  - \`direct-path\` — What is the most direct path?
-  - \`operator\` — Who is the operator/user impacted first?
-  - \`no-go\` — What are non-negotiable no-go boundaries?
-- **Scope**:
-  - \`in-out\` — What is definitely in and definitely out?
-  - \`locked-upstream\` — Which decisions are already locked upstream?
-- **Design**:
-  - \`data-flow\` — What is the data flow end-to-end?
-  - \`seams\` — Where are the seams/interfaces and ownership boundaries?
-  - \`invariants\` — Which invariants must always hold?
-  - \`not-refactor\` — What will we explicitly NOT refactor now?
-
-## One-Way Override (Irreversible Decisions)
-
-For irreversible moves (deletion, schema migration, breaking API):
-- Ask for explicit confirmation even if user asked to stop questions.
-- Proceed only after explicit override ("I understand the irreversible risk; proceed").
-- Record the override in \`## Q&A Log\` and in the stage artifact decision section.
-
-## Completion Rule
-
-Continue asking forcing questions in order until one of:
-- (a) all forcing questions for the stage are answered/skipped/waived AND self-evaluation says context is sufficient, OR
-- (b) user records an explicit stop-signal row in \`## Q&A Log\`, OR
-- (c) the \`hard cap warning\` count is reached and you compressed the remaining forcing questions into one final batched ask (not skip).
-
-Do NOT exit the loop after the first 1-2 questions just because you can draft something. The point of the loop is to surface the user's actual constraints, not to confirm your initial reading.`;
-}

package/dist/content/stage-command.d.ts

@@ -1,2 +0,0 @@
-import type { FlowStage } from "../types.js";
-export declare function stageCommandShimMarkdown(stage: FlowStage): string;

package/dist/content/stage-command.js

@@ -1,17 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-import { stageSkillFolder } from "./skills.js";
-export function stageCommandShimMarkdown(stage) {
-    const skillPath = `${RUNTIME_ROOT}/skills/${stageSkillFolder(stage)}/SKILL.md`;
-    return `# /cc-${stage}
-
-This is a thin compatibility shim for the \`${stage}\` flow stage.
-
-Load and follow the authoritative stage skill:
-
-- \`${skillPath}\`
-
-Normal stage resume and advancement uses \`/cc\`. Use \`/cc\` to read
-\`.cclaw/state/flow-state.json\`, select the active stage, and advance only after
-that stage's gates pass. Do not duplicate the stage protocol here.
-`;
-}

package/dist/content/stage-schema.d.ts

@@ -1,117 +0,0 @@
-import type { DiscoveryMode, FlowStage, FlowTrack, TransitionRule } from "../types.js";
-import type { StageComplexityTier, StageAutoSubagentDispatch, StageSchema } from "./stages/schema-types.js";
-export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageComplexityTier, StageExecutionModel, StagePhilosophy, StageArtifactRules, StageReviewLoop, StageReviewLens, StageAutoSubagentDispatch, StageGate, StageSchemaLegacyInput, StageSchema, StageSchemaInput, StageSchemaV2Input } from "./stages/schema-types.js";
-export declare const SKILL_ENVELOPE_KINDS: readonly ["stage-output", "gate-result", "delegation-record"];
-export type SkillEnvelopeKind = (typeof SKILL_ENVELOPE_KINDS)[number];
-export declare const NON_FLOW_ENVELOPE_STAGE: "non-flow";
-export type SkillEnvelopeStage = FlowStage | typeof NON_FLOW_ENVELOPE_STAGE;
-export interface SkillEnvelope {
-    version: "1";
-    kind: SkillEnvelopeKind;
-    stage: SkillEnvelopeStage;
-    payload: unknown;
-    emittedAt: string;
-    agent?: string;
-}
-export interface SkillEnvelopeValidation {
-    ok: boolean;
-    errors: string[];
-}
-export interface StageStackAwareReviewRoute {
-    stack: string;
-    agent: "reviewer";
-    signals: string[];
-    focus: string;
-}
-export interface StageDelegationDispatchRule {
-    agent: string;
-    mode: "mandatory" | "proactive";
-    when: string;
-    purpose: string;
-    requiresUserGate: boolean;
-    requiredAtTier?: StageComplexityTier;
-    dispatchClass: NonNullable<StageAutoSubagentDispatch["dispatchClass"]>;
-    returnSchema: NonNullable<StageAutoSubagentDispatch["returnSchema"]>;
-    skill?: string;
-}
-export interface StageDelegationSummary {
-    stage: FlowStage;
-    mandatoryAgents: string[];
-    proactiveAgents: string[];
-    primaryAgents: string[];
-    dispatchRules: StageDelegationDispatchRule[];
-    stackAwareRoutes: StageStackAwareReviewRoute[];
-}
-export declare function reviewStackAwareRoutes(): StageStackAwareReviewRoute[];
-export declare function reviewStackAwareRoutingSummary(): string;
-/**
- * Canonical delegation summary derived from STAGE_AUTO_SUBAGENT_DISPATCH.
- *
- * Keep all generated routing surfaces (skills, AGENTS.md) on this helper so
- * stage->agent defaults are maintained in one place.
- */
-export declare function stageDelegationSummary(complexityTier?: StageComplexityTier): StageDelegationSummary[];
-export declare function validateSkillEnvelope(value: unknown): SkillEnvelopeValidation;
-export declare function parseSkillEnvelope(raw: string): SkillEnvelope | null;
-/** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
-export declare function mandatoryDelegationsForStage(stage: FlowStage, complexityTier?: StageComplexityTier): string[];
-/**
- * Track-aware mandatory delegation lookup.
- *
- * Returns `[]` (skip the gate entirely) when the run is on a small-fix
- * track or classified as a software bugfix:
- *
- *   - `track === "quick"` — the quick track is for trivial single-purpose
- *     fixes (landing-page copy, doc edits, config tweaks). Mandatory
- *     subagent dispatch is theatre on that surface area.
- *   - `taskClass === "software-bugfix"` — bugfixes carry a RED-first
- *     repro contract; the test author + reviewer in the tdd/review
- *     stages already cover the safety surface, so mandatory upstream
- *     delegation only burns tokens.
- *
- * Otherwise returns the registered mandatory list for the stage at the
- * given tier. Callers (gate-evidence, advance-stage validator,
- * subagents.ts table generator) MUST go through this helper instead of
- * `mandatoryDelegationsForStage` so the track-aware drop applies
- * uniformly.
- *
- * NOTE: the user query also calls this `lite/quick`. There is no `lite`
- * FlowTrack — the closest concept in cclaw is the `quick` track plus the
- * brainstorm `lightweight` complexity tier. We key on the FlowTrack
- * because the run-level decision is what matters at gate time;
- * complexity tier is a per-stage knob that doesn't survive the dispatch
- * boundary.
- */
-export type MandatoryDelegationTaskClass = "software-standard" | "software-trivial" | "software-bugfix";
-export declare function mandatoryAgentsFor(stage: FlowStage, track: FlowTrack, taskClass?: MandatoryDelegationTaskClass | null, complexityTier?: StageComplexityTier, discoveryMode?: DiscoveryMode): string[];
-/**
- * Track-aware artifact validation demotion.
- *
- * Mirrors `mandatoryAgentsFor`'s skip logic for the small-fix lanes.
- * Returns `true` when artifact-level "advanced" validation rules
- * (architecture-diagram async/failure edges, interaction edge-case
- * mandatory rows, stale-diagram drift check, expansion-strategist
- * delegation) should be DEMOTED from required → advisory.
- *
- *   - `track === "quick"` — quick-tier runs (single-purpose
- *     landing-page edits, doc tweaks, config nudges). The advanced
- *     checks fire on architecture surfaces a quick-track artifact
- *     usually doesn't have.
- *   - `taskClass === "software-bugfix"` — bugfixes carry RED-first
- *     repro coverage; tdd/review own the safety surface.
- *
- * When this returns `true`, the linter still runs the rules and prints
- * their findings (so authors see them as advisory info), but does NOT
- * block stage advance. An audit event of type
- * `artifact_validation_demoted_by_track` is appended to
- * `delegation-events.jsonl` once per stage advance for traceability.
- */
-export declare function shouldDemoteArtifactValidationByTrack(track: FlowTrack, taskClass?: MandatoryDelegationTaskClass | null): boolean;
-export declare function stageSchema(stage: FlowStage, track?: FlowTrack, discoveryMode?: DiscoveryMode, taskClass?: MandatoryDelegationTaskClass | null): StageSchema;
-export declare function orderedStageSchemas(track?: FlowTrack): StageSchema[];
-export declare function stageGateIds(stage: FlowStage, track?: FlowTrack): string[];
-export declare function stageRecommendedGateIds(stage: FlowStage, track?: FlowTrack): string[];
-export declare function buildTransitionRules(): TransitionRule[];
-export declare function stagePolicyNeedles(stage: FlowStage, track?: FlowTrack): string[];
-export declare function stageTrackRenderContext(track?: FlowTrack): import("./track-render-context.js").TrackRenderContext;
-export declare function stageAutoSubagentDispatch(stage: FlowStage): StageAutoSubagentDispatch[];