cclaw-cli 0.51.19 → 0.51.22

package/dist/artifact-linter.js

@@ -485,15 +485,39 @@ const SCOPE_MODE_SHORT_TOKEN_REGEX = /\b(?:hold(?:[\s_-]?scope)?|selective(?:[\s
 // not the wording of the rationale.
 const NEXT_STAGE_HANDOFF_REGEX = /(?:`(?:design|spec)`|\bdesign\b|\bspec\b|next[-\s_]stage|next stage|handoff|hand[-\s]off)/iu;
 function hasCanonicalScopeMode(body) {
-    if (SCOPE_MODE_FULL_REGEX.test(body))
-        return true;
+    // Strict: a Mode: / Selected mode: line that picks exactly ONE canonical mode
+    // is the strongest signal. The template scaffolding contains all four mode
+    // tokens inside an instructional `(one of ...)` placeholder; we ignore that
+    // line so authors who never replace the scaffolding still fail validation.
     for (const match of body.matchAll(new RegExp(SCOPE_MODE_LINE_REGEX, "giu"))) {
-        const value = match[1] ?? "";
-        if (SCOPE_MODE_SHORT_TOKEN_REGEX.test(value))
+        const raw = (match[1] ?? "").trim();
+        const sanitized = raw.replace(/\(.*?\)/gu, "").trim();
+        if (sanitized.length === 0)
+            continue;
+        if (countCanonicalModeMentions(sanitized) === 1)
+            return true;
+        if (countCanonicalModeMentions(sanitized) === 0 && SCOPE_MODE_SHORT_TOKEN_REGEX.test(sanitized))
+            return true;
+    }
+    // Fallback: any line outside an instructional `(one of ...)` placeholder
+    // names exactly one mode. Block lines that list multiple modes (the
+    // unfilled template) or are wrapped in an instructional parenthetical.
+    for (const rawLine of body.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        if (/\(\s*one\s+of\b/iu.test(line))
+            continue;
+        const sanitized = line.replace(/\(.*?\)/gu, "");
+        if (countCanonicalModeMentions(sanitized) === 1)
             return true;
     }
     return false;
 }
+function countCanonicalModeMentions(text) {
+    const matches = text.match(new RegExp(SCOPE_MODE_FULL_REGEX, "giu"));
+    return matches ? matches.length : 0;
+}
 function validatePremiseChallenge(sectionBody) {
     // gstack-style premise challenge requires a real Q/A structure (table or
     // list), not free-form prose. The validation is *structural* only — we do
@@ -1051,10 +1075,12 @@ function validateTddGreenEvidence(sectionBody) {
     };
 }
 function validateVerificationLadder(sectionBody) {
-    if (!/highest tier reached/iu.test(sectionBody)) {
+    const hasTextLine = /highest tier reached/iu.test(sectionBody);
+    const hasCanonicalTable = hasVerificationLadderTableRow(sectionBody);
+    if (!hasTextLine && !hasCanonicalTable) {
         return {
             ok: false,
-            details: "Verification Ladder must include a 'Highest tier reached' line."
+            details: "Verification Ladder must include either a 'Highest tier reached' line or a canonical table row (Slice | Tier reached | Evidence) with non-empty tier and evidence."
         };
     }
     if (!/\b(static|command|behavioral|human)\b/iu.test(sectionBody)) {
@@ -1074,6 +1100,49 @@ function validateVerificationLadder(sectionBody) {
         details: "Verification Ladder includes tier + evidence fields."
     };
 }
+function hasVerificationLadderTableRow(sectionBody) {
+    const lines = sectionBody.split(/\r?\n/u);
+    let sawHeader = false;
+    let sawSeparator = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|")) {
+            sawHeader = false;
+            sawSeparator = false;
+            continue;
+        }
+        const cells = trimmed
+            .replace(/^\|/u, "")
+            .replace(/\|$/u, "")
+            .split("|")
+            .map((cell) => cell.trim());
+        if (!sawHeader) {
+            const lowered = cells.map((cell) => cell.toLowerCase());
+            const hasTierColumn = lowered.some((cell) => /tier(?:\s+reached)?/u.test(cell));
+            const hasEvidenceColumn = lowered.some((cell) => cell.includes("evidence"));
+            if (hasTierColumn && hasEvidenceColumn) {
+                sawHeader = true;
+                continue;
+            }
+            continue;
+        }
+        if (!sawSeparator) {
+            if (cells.every((cell) => /^[:\-\s]+$/u.test(cell))) {
+                sawSeparator = true;
+                continue;
+            }
+            sawHeader = false;
+            continue;
+        }
+        if (cells.length >= 2 && cells.some((cell) => /\b(static|command|behavioral|human)\b/iu.test(cell))) {
+            const evidenceCellHasContent = cells.some((cell) => cell.length > 0 && !/^\s*$/u.test(cell) && !/^[:\-\s]+$/u.test(cell));
+            if (evidenceCellHasContent) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 const LEARNING_TYPE_SET = new Set(["rule", "pattern", "lesson", "compound"]);
 const LEARNING_CONFIDENCE_SET = new Set(["high", "medium", "low"]);
 const LEARNING_SEVERITY_SET = new Set(["critical", "important", "suggestion"]);
@@ -1786,6 +1855,20 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
                         ? "Selected Direction is traceable to prior user reaction."
                         : "Selected Direction is not traceable to user reaction. Add `## Approach Reaction` before it, or mention the user's reaction/concerns in the rationale."
                 });
+                // Track-aware handoff: standard track goes to `scope`; medium track
+                // goes directly to `spec`; the quick track skips brainstorm entirely.
+                // We accept either canonical successor token plus a generic
+                // `next-stage` / `handoff` phrase to preserve i18n flexibility.
+                const handoffTrace = /(?:`(?:scope|spec)`|\bscope\b|\bspec\b|next[-\s_]stage|next stage|\bhandoff\b|hand[-\s]off)/iu.test(directionBody);
+                findings.push({
+                    section: "Direction Next-Stage Handoff",
+                    required: true,
+                    rule: "Selected Direction must record the track-aware next-stage handoff (mention `scope` for standard, `spec` for medium, or include a `Next-stage handoff:` line).",
+                    found: handoffTrace,
+                    details: handoffTrace
+                        ? "Selected Direction names the next-stage handoff."
+                        : "Selected Direction is missing a next-stage handoff token. Mention `scope` (standard) or `spec` (medium), or add a `Next-stage handoff:` line so downstream stages can trace the contract."
+                });
             }
         }
         const shortCircuitBody = brainstormShortCircuitBody;

package/dist/config.d.ts

@@ -1,4 +1,11 @@
 import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack } from "./types.js";
+export interface ConfigWarningState {
+    emitted: Set<string>;
+}
+export interface ReadConfigOptions {
+    warningState?: ConfigWarningState;
+}
+export declare function createConfigWarningState(): ConfigWarningState;
 export declare class InvalidConfigError extends Error {
     constructor(message: string);
 }
@@ -34,7 +41,7 @@ export declare function createDefaultConfig(harnesses?: HarnessId[], defaultTrac
  * never surprise a user who intentionally cleared the list.
  */
 export declare function detectLanguageRulePacks(projectRoot: string): Promise<LanguageRulePack[]>;
-export declare function readConfig(projectRoot: string): Promise<CclawConfig>;
+export declare function readConfig(projectRoot: string, options?: ReadConfigOptions): Promise<CclawConfig>;
 /**
  * Fields that live on the populated runtime `CclawConfig` but are considered
  * "advanced" — we keep them in the in-memory object so downstream callers

package/dist/config.js

@@ -56,13 +56,15 @@ const MINIMAL_CONFIG_KEYS = [
 ];
 const DEFAULT_SLICE_REVIEW_THRESHOLD = 5;
 const DEFAULT_SLICE_REVIEW_TRACKS = ["standard"];
-const emittedConfigWarnings = new Set();
-function emitConfigWarningOnce(code, message) {
+export function createConfigWarningState() {
+    return { emitted: new Set() };
+}
+function emitConfigWarningOnce(warningState, code, message) {
     const key = `${code}:${message}`;
-    if (emittedConfigWarnings.has(key)) {
+    if (warningState.emitted.has(key)) {
         return;
     }
-    emittedConfigWarnings.add(key);
+    warningState.emitted.add(key);
     process.emitWarning(message, { code });
 }
 function sameStringArray(a, b) {
@@ -196,7 +198,8 @@ export async function detectLanguageRulePacks(projectRoot) {
     }
     return [...new Set(detected)];
 }
-export async function readConfig(projectRoot) {
+export async function readConfig(projectRoot, options = {}) {
+    const warningState = options.warningState ?? createConfigWarningState();
     const fullPath = configPath(projectRoot);
     if (!(await exists(fullPath))) {
         return createDefaultConfig();
@@ -269,7 +272,7 @@ export async function readConfig(projectRoot) {
     if (tddTestGlobsRaw !== undefined &&
         explicitTddTestPathPatterns !== undefined &&
         !sameStringArray(tddTestGlobs, explicitTddTestPathPatterns)) {
-        emitConfigWarningOnce("CCLAW_CONFIG_DEPRECATED_TDD_TEST_GLOBS", `[cclaw] Both "tddTestGlobs" (deprecated) and "tdd.testPathPatterns" are set in ${fullPath}. ` +
+        emitConfigWarningOnce(warningState, "CCLAW_CONFIG_DEPRECATED_TDD_TEST_GLOBS", `[cclaw] Both "tddTestGlobs" (deprecated) and "tdd.testPathPatterns" are set in ${fullPath}. ` +
             `Using "tdd.testPathPatterns".`);
     }
     const resolvedTddTestPathPatterns = [

package/dist/content/examples.js

@@ -48,6 +48,7 @@ const STAGE_EXAMPLES = {
 - **Approach:** A — Reusable validation module
 - **Rationale:** based on user reaction favoring fast delivery and lower complexity, shared TS module gives consistent behavior in CI/local, avoids script duplication, and stays within the no-new-dependency constraint.
 - **Approval:** approved
+- **Next-stage handoff:** \`scope\` — carry the locked stack constraints and the validator module boundary forward.
 
 ## Design
 

package/dist/content/hook-events.js

@@ -1,8 +1,5 @@
-import { HOOK_MANIFEST_HARNESSES, semanticEventCoverage } from "./hook-manifest.js";
+import { semanticEventCoverage } from "./hook-manifest.js";
 export { HOOK_SEMANTIC_EVENTS } from "./hook-manifest.js";
-function isManifestHarness(value) {
-    return HOOK_MANIFEST_HARNESSES.includes(value);
-}
 /**
  * OpenCode is covered by the inline plugin (`opencode-plugin.ts`), not
  * by the generated `run-hook.mjs` dispatcher. We keep its semantic
@@ -28,4 +25,3 @@ export const HOOK_EVENTS_BY_HARNESS = Object.freeze({
     codex: semanticEventCoverage("codex"),
     opencode: OPENCODE_SEMANTIC_COVERAGE
 });
-void isManifestHarness;

package/dist/content/hook-manifest.d.ts

@@ -45,14 +45,12 @@ export interface HookHandlerSpec {
     description: string;
     /**
      * Semantic event id used by `HOOK_EVENTS_BY_HARNESS` / docs.
-     * `null` means this handler contributes no semantic coverage row
-     * (e.g. `verify-current-state` on codex is a supplementary guard,
-     * not a top-level semantic event).
+     * `null` means this handler contributes no semantic coverage row.
      */
     semantic: HookSemanticEvent | null;
     bindings: Partial<Record<HookManifestHarness, HookBinding[]>>;
 }
-export declare const HOOK_SEMANTIC_EVENTS: readonly ["session_rehydrate", "pre_tool_prompt_guard", "pre_tool_workflow_guard", "post_tool_context_monitor", "stop_handoff", "precompact_compat"];
+export declare const HOOK_SEMANTIC_EVENTS: readonly ["session_rehydrate", "pre_tool_prompt_guard", "pre_tool_workflow_guard", "post_tool_context_monitor", "stop_handoff", "precompact_compat", "strict_state_verify"];
 export type HookSemanticEvent = (typeof HOOK_SEMANTIC_EVENTS)[number];
 export declare const HOOK_MANIFEST: readonly HookHandlerSpec[];
 export interface EventGroup {

package/dist/content/hook-manifest.js

@@ -35,7 +35,8 @@ export const HOOK_SEMANTIC_EVENTS = [
     "pre_tool_workflow_guard",
     "post_tool_context_monitor",
     "stop_handoff",
-    "precompact_compat"
+    "precompact_compat",
+    "strict_state_verify"
 ];
 export const HOOK_MANIFEST = [
     {
@@ -112,8 +113,8 @@ export const HOOK_MANIFEST = [
     },
     {
         handler: "verify-current-state",
-        description: "Supplementary codex guard that runs on UserPromptSubmit to assert the live state matches the flow.",
-        semantic: null,
+        description: "Supplementary Codex strict-mode guard that runs on UserPromptSubmit to assert the live state matches the flow.",
+        semantic: "strict_state_verify",
         bindings: {
             codex: [{ event: "UserPromptSubmit" }]
         }

package/dist/content/meta-skill.js

@@ -14,7 +14,7 @@ description: "Routing brain for cclaw. Decide whether to start/resume a stage, a
 1. User message in current turn.
 2. Active stage skill and command contract.
 3. This routing file.
-4. Contextual utility skills.
+4. Generated cclaw helper skills, research playbooks, and enabled rule packs.
 5. Default model behavior.
 
 If the user explicitly overrides a stage rule, record it in the artifact.
@@ -25,9 +25,7 @@ ${conversationLanguagePolicyMarkdown()}
 If \`.cclaw/state/flow-state.json\` exists and \`currentStage\` is set,
 load the matching stage SKILL before producing **substantive** work
 (artifact edits, code, structured clarifying questions). Do not improvise
-from memory. Also load a contextual utility skill when the task clearly
-triggers it (security, performance, debugging, docs, finishing-a-branch,
-verification-before-completion).
+from memory. Load only generated helper surfaces that actually exist in this install: \`subagent-dev\`, \`parallel-dispatch\`, \`session\`, \`iron-laws\`, research playbooks, review prompts, or enabled language rule packs under \`.cclaw/rules/lang/\`. Do not invent helper-skill names beyond those generated surfaces.
 
 Substantive vs. non-substantive:
 
@@ -70,7 +68,7 @@ Task arrives
 | Class | Route |
 |---|---|
 | non-trivial software work | \`/cc <idea>\` |
-| trivial software fix | \`/cc <idea>\` (quick/medium track as recommended) |
+| trivial software fix | \`/cc <idea>\` (quick track) |
 | bugfix with clear repro | \`/cc <idea>\` and enforce RED-first in tdd |
 | pure question / conversation | answer directly |
 | non-software work | answer directly |
@@ -115,10 +113,10 @@ Use the current stage skill plus \`.cclaw/state/flow-state.json\` for orientatio
 
 Use built-in judgment only when triggered by the current task:
 
-- security, performance, debugging, docs, and CI/CD review lenses
-- verification discipline before completion claims
-- branch-finishing discipline during ship/finalization
-- iron-laws as policy arbitration when instructions conflict
+- generated subagent context skills for mandatory review/delegation contracts
+- research playbooks and review prompts when a stage explicitly calls for them
+- inline verification and ship/finalization sections in the active stage skill
+- \`iron-laws\` as policy arbitration when instructions conflict
 - language rule packs from \`.cclaw/config.yaml\` when enabled
 
 ## Protocol Behavior

package/dist/content/next-command.js

@@ -112,7 +112,7 @@ ${ralphLoopContractSnippet()}
 - If \`track === "quick"\`, the critical path is **spec → tdd → review → ship**. When advancing, skip any stage listed in \`skippedStages\` — i.e. after the current stage completes, pick the next stage that is NOT in \`skippedStages\`.
 - If \`track === "medium"\`, the critical path is **brainstorm → spec → plan → tdd → review → ship**. Scope and design are intentionally skipped unless the run is reclassified to standard.
 - If \`track === "standard"\`, advance through all 8 stages in their natural order.
-- Never reintroduce a skipped stage mid-run. If the user wants upstream scoping work, they must archive the run and start a new one with \`track: "standard"\`.
+- Never manually reintroduce a skipped stage mid-run. If evidence shows the track was wrong, stop and use the managed start-flow helper with \`--reclassify\`; only that managed reclassification may add upstream stages back into the active track.
 
 ## Resume Semantics
 
@@ -130,7 +130,7 @@ When orchestrated by another skill/subagent, emit exactly one JSON envelope and
 no narrative text:
 
 \`\`\`json
-{"version":"1","kind":"gate-result","stage":"review","payload":{"command":"/cc-next","decision":"resume_or_advance","nextStage":"ship"},"emittedAt":"<ISO-8601>"}
+{"version":"1","kind":"gate-result","stage":"<currentStage>","payload":{"command":"/cc-next","decision":"resume_or_advance","nextStage":"<nextStage>"},"emittedAt":"<ISO-8601>"}
 \`\`\`
 
 Validate envelopes with:

package/dist/content/node-hooks.js

@@ -265,15 +265,6 @@ async function writeJsonFile(filePath, value) {
   });
 }
 
-async function fileExists(filePath) {
-  try {
-    await fs.stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 async function readTextFile(filePath, fallback = "") {
   try {
     return await fs.readFile(filePath, "utf8");
@@ -625,7 +616,7 @@ function isCodeLikePath(rawPath) {
 }
 
 function isMutatingTool(toolLower) {
-  return /^(write|edit|multiedit|multi_edit|delete|applypatch|apply_patch)$/u.test(toolLower);
+  return /^(write|edit|multiedit|multi_edit|delete|applypatch|apply_patch|notebookedit|notebook_edit)$/u.test(toolLower);
 }
 
 function isExecutionOrMutatingTool(toolLower) {
@@ -871,8 +862,6 @@ async function buildKnowledgeDigest(root, currentStage, prereadRaw) {
       const action = typeof row.action === "string" ? row.action : "action";
       return "- [" + confidence + " • " + stage + " • " + domain + "] " + trigger + " -> " + action;
     });
-  const body =
-    relevant.length > 0 ? relevant.join("\\n") : "(no matching entries for current stage)";
   return {
     digestLines: relevant,
     learningsCount
@@ -1128,12 +1117,21 @@ async function handleStopHandoff(runtime) {
     return 1;
   }
 
+  const closeoutObj = toObject(state.raw.closeout) || {};
+  const shipSubstate = typeof closeoutObj.shipSubstate === "string" ? closeoutObj.shipSubstate : "idle";
+  const closeoutContext =
+    state.currentStage === "ship" || shipSubstate !== "idle"
+      ? " closeout.shipSubstate=" + shipSubstate + "; closeout chain=retro -> compound -> archive; continue closeout with /cc-next."
+      : "";
+
   const message =
     "Cclaw: session ending (stage=" +
     state.currentStage +
     ", run=" +
     state.activeRunId +
-    "). Active artifacts stay in " +
+    ")." +
+    closeoutContext +
+    " Active artifacts stay in " +
     RUNTIME_ROOT +
     "/artifacts until archive. Before stopping: (1) confirm flow-state reflects reality, (2) ensure artifact changes match current intent, (3) if you discovered a non-obvious rule/pattern during stage work, add it to the current artifact ## Learnings section so stage-complete can harvest it, (4) commit or revert pending changes.";
 
@@ -1164,7 +1162,7 @@ async function handlePromptGuard(runtime) {
   const payloadLower = toLower(payloadText);
   const reasons = [];
 
-  if (/^(write|edit|multiedit|multi_edit|delete|applypatch|runcommand|shell|terminal|execcommand)$/u.test(toolLower)) {
+  if (/^(write|edit|multiedit|multi_edit|delete|applypatch|notebookedit|runcommand|shell|terminal|execcommand)$/u.test(toolLower)) {
     // Artifacts, runs, and knowledge writes are part of normal stage flow.
     // Guard only managed internals that should be mutated via installer/CLI.
     if (/\\.cclaw\\/(state|hooks|skills|commands|agents)/u.test(payloadLower)) {
@@ -1661,9 +1659,10 @@ async function handleVerifyCurrentState(runtime) {
 function normalizeHookName(rawName) {
   const value = normalizeText(rawName).toLowerCase();
   if (value === "session-start") return "session-start";
-  if (value === "stop-handoff") return "stop-handoff";
+  if (value === "stop-handoff" || value === "stop") return "stop-handoff";
   if (value === "stop-checkpoint") return "stop-handoff";
-  if (value === "pre-compact") return "pre-compact";
+  if (value === "pre-compact" || value === "precompact") return "pre-compact";
+  if (value === "session-rehydrate") return "session-start";
   if (value === "prompt-guard") return "prompt-guard";
   if (value === "workflow-guard") return "workflow-guard";
   if (value === "context-monitor") return "context-monitor";

package/dist/content/observe.js

@@ -1,5 +1,5 @@
 import { RUNTIME_ROOT } from "../constants.js";
-import { HOOK_MANIFEST, groupBindingsByEvent } from "./hook-manifest.js";
+import { groupBindingsByEvent } from "./hook-manifest.js";
 function hookDispatcherCommand(hookName) {
     // Dispatch through the polyglot .cmd wrapper so Windows harnesses can run
     // hooks even when command execution happens under CMD-style shells.
@@ -78,9 +78,7 @@ export function codexHooksJsonWithObservation() {
  * manifest without importing the private generator helpers.
  */
 export function hookManifestSnapshot() {
-    return (HOOK_MANIFEST.length === 0
-        ? ["claude", "cursor", "codex"]
-        : ["claude", "cursor", "codex"]).map((harness) => ({
+    return ["claude", "cursor", "codex"].map((harness) => ({
         harness,
         events: groupBindingsByEvent(harness)
     }));

package/dist/content/opencode-plugin.js

@@ -463,11 +463,10 @@ export default function cclawPlugin(ctx) {
    * \`DEFAULT_STRICTNESS = advisory\`, so the plugin can no longer
    * accidentally be the stricter half of a mismatched pair.
    */
-  function readConfigStrictness() {
+  async function readConfigStrictness() {
     try {
       if (!existsSync(configPath)) return "";
-      const { readFileSync } = require("node:fs");
-      const raw = readFileSync(configPath, "utf8");
+      const raw = await readFileText(configPath);
       if (typeof raw !== "string" || raw.length === 0) return "";
       const match = raw.match(/^\\s*strictness\\s*:\\s*([A-Za-z0-9_-]+)/m);
       return match && typeof match[1] === "string" ? match[1].trim().toLowerCase() : "";
@@ -476,7 +475,7 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function resolveStrictness() {
+  async function resolveStrictness() {
     const envRaw = typeof process.env.CCLAW_STRICTNESS === "string"
       ? process.env.CCLAW_STRICTNESS.trim().toLowerCase()
       : "";
@@ -484,7 +483,7 @@ export default function cclawPlugin(ctx) {
     if (envRaw === "advisory" || envRaw === "off" || envRaw === "disabled" || envRaw === "none") {
       return "advisory";
     }
-    const fileRaw = readConfigStrictness();
+    const fileRaw = await readConfigStrictness();
     if (fileRaw === "strict") return "strict";
     return "advisory";
   }
@@ -683,7 +682,7 @@ export default function cclawPlugin(ctx) {
           );
           return;
         }
-        const strictness = resolveStrictness();
+        const strictness = await resolveStrictness();
         if (strictness !== "strict") {
           // Advisory mode (the default) — every guard refusal is a hint,
           // not a hard stop. Users report the "failure" as a log line

package/dist/content/review-loop.js

@@ -456,6 +456,9 @@ export function buildReviewLoopEnvelope(args) {
 function formatScore(value) {
     return clampScore(value).toFixed(3);
 }
+function reviewLoopHeading(stage) {
+    return stage === "scope" ? "Scope Outside Voice Loop" : "Design Outside Voice Loop";
+}
 function finalEnvelopeScore(envelope) {
     if (envelope.iterations.length === 0)
         return 0;
@@ -486,7 +489,8 @@ export function renderReviewLoopSummarySection(envelope) {
         })
             .join("\n")
         : "| 0 | 0.000 | 0 |";
-    return `## Spec Review Loop
+    const heading = reviewLoopHeading(envelope.stage);
+    return `## ${heading}
 | Iteration | Quality Score | Findings |
 |---|---|---|
 ${rows}
@@ -498,9 +502,14 @@ ${rows}
 export function upsertReviewLoopSummary(markdown, envelope) {
     const withHeader = upsertReviewLoopHeader(markdown, envelope);
     const section = renderReviewLoopSummarySection(envelope);
-    const headingRe = /^##\s+Spec Review Loop\s*$/m;
-    const match = headingRe.exec(withHeader);
-    if (!match || match.index < 0) {
+    const headingCandidates = [reviewLoopHeading(envelope.stage), "Spec Review Loop"];
+    const match = headingCandidates
+        .map((heading) => {
+        const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+        return new RegExp(`^##\\s+${escapedHeading}\\s*$`, "m").exec(withHeader);
+    })
+        .find((candidate) => candidate !== null && candidate.index >= 0);
+    if (!match) {
         const needsBreak = withHeader.endsWith("\n") ? "" : "\n";
         return `${withHeader}${needsBreak}\n${section}\n`;
     }
@@ -613,7 +622,8 @@ function parseHeaderMeta(markdown) {
     };
 }
 export function extractReviewLoopEnvelopeFromArtifact(markdown, stage, artifactPath) {
-    const sectionBody = extractH2Section(markdown, "Spec Review Loop");
+    const sectionBody = extractH2Section(markdown, reviewLoopHeading(stage))
+        ?? extractH2Section(markdown, "Spec Review Loop");
     if (!sectionBody)
         return null;
     const iterations = parseIterationsTable(sectionBody);

package/dist/content/review-prompts.js

@@ -57,7 +57,7 @@ value. Do not nitpick wording.
 
 ## Output
 
-Record in \`## Outside Voice Findings\` or \`## Spec Review Loop\`:
+Record in \`## Outside Voice Findings\` or the stage-specific outside voice loop section:
 
 \`\`\`markdown
 | ID | Dimension | Finding | Disposition | Rationale |

package/dist/content/skills.js

@@ -168,7 +168,7 @@ Apply concise turn announces: one announce per batch boundary (or when risk/plan
 changes materially), then execute tasks without repetitive boilerplate.
 
 Detailed walkthrough:
-Use the current plan artifact for batch order and keep RED -> GREEN -> REFACTOR evidence in the TDD artifact.
+Use the active track's upstream artifact for ordering: plan slices on standard/medium, or spec acceptance items / bug reproduction slices on quick. Keep RED -> GREEN -> REFACTOR evidence in the TDD artifact.
 `;
 }
 function crossStageTraceBlock(trace) {
@@ -386,6 +386,7 @@ ${philosophy.purpose}
 
 ## Complexity Tier
 - Active tier: \`${schema.complexityTier}\`
+- Scale-to-complexity rule: execute required gates and artifact sections, but keep optional/deep sections compact unless risk, novelty, or configuration triggers them. Do not mechanically expand lightweight work into a strategy workshop.
 - Mandatory delegations at this tier: ${mandatoryDelegationSummary}
 - Track render context: \`${trackContext.track}\` (${trackContext.usesPlanTerminology ? "plan-first wording" : "acceptance-first wording"})
 
@@ -452,7 +453,7 @@ ${reviewLens.outputs.map((item) => `- ${item}`).join("\n")}
 ${reviewSectionsBlock(reviewLens.reviewSections)}
 
 ## Shared Stage Guidance
-- Follow the handoff menu: advance, revise, pause, rewind, or archive only when the user explicitly chooses it.
+- At STOP/closeout points, offer the shared handoff choices only when a user decision is needed.
 - Carry upstream decisions forward explicitly; record drift instead of silently changing direction.
 - Before closeout, fill \`## Learnings\` with \`- None this stage.\` or 1-3 strict JSON bullets.
 - Keep decisions explicit: context, options, chosen option, rationale, risk, and rollback.

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

@@ -47,7 +47,6 @@ export declare function stageSchema(stage: FlowStage, track?: FlowTrack): StageS
 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 nextCclawCommand(stage: FlowStage): 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;

package/dist/content/stage-schema.js

@@ -227,6 +227,7 @@ const REQUIRED_GATE_IDS = {
     review: (track) => [
         "review_layer1_spec_compliance",
         "review_layer2_security",
+        "review_layer_coverage_complete",
         "review_criticals_resolved",
         "review_army_json_valid",
         ...(track === "quick" ? [] : ["review_trace_matrix_clean"])
@@ -258,7 +259,7 @@ const REQUIRED_ARTIFACT_SECTIONS = {
         "Deployment & Rollout",
         "Completion Dashboard"
     ],
-    spec: ["Acceptance Criteria", "Edge Cases", "Assumptions Before Finalization", "Testability Map", "Approval"],
+    spec: ["Acceptance Criteria", "Edge Cases", "Assumptions Before Finalization", "Acceptance Mapping", "Approval"],
     plan: ["Task List", "Dependency Batches", "Acceptance Mapping", "Execution Posture", "WAIT_FOR_CONFIRM"],
     tdd: ["Test Discovery", "System-Wide Impact Check", "RED Evidence", "GREEN Evidence", "REFACTOR Notes", "Traceability", "Verification Ladder"],
     review: ["Layer 1 Verdict", "Review Findings Contract", "Severity Summary", "Final Verdict"],
@@ -577,10 +578,6 @@ export function stageRecommendedGateIds(stage, track = "standard") {
         .filter((gate) => gate.tier === "recommended")
         .map((gate) => gate.id);
 }
-export function nextCclawCommand(stage) {
-    const next = stageSchema(stage).next;
-    return next === "done" ? "none" : `/cc-${next}`;
-}
 export function buildTransitionRules() {
     const rules = [];
     const seen = new Set();

package/dist/content/stages/brainstorm.js

@@ -40,10 +40,10 @@ export const BRAINSTORM = {
             "**Classify depth and scope** — pick Lightweight / Standard / Deep; decompose independent subsystems before deeper work.",
             "**Premise check (one pass)** — answer the three gstack-style questions in the artifact body: *Right problem? Direct path? What if we do nothing?* Take a position; do not hedge.",
             "**Reframe with How Might We** — write a single `How Might We …?` line that names the user, the desired outcome, and the constraint. This is the altitude check before approaches.",
-            "**Sharpening questions (3-5)** — capture decision-changing question/answer pairs in the `Sharpening Questions` table with the actual decision impact; if a question would not change architecture/scope/UX, state the assumption and skip it.",
+            "**Sharpening questions (3-5)** — capture decision-changing question/answer pairs in the `Sharpening Questions` table with the actual decision impact; only non-critical preference/default assumptions may continue. STOP and ask on scope, architecture, security, data loss, public API, migration, auth/pricing, or user-approval uncertainty.",
             "**Use compact discovery for simple apps** — for concrete low-risk asks (todo app, landing page, local widget), do one context pass, compare one baseline and one challenger, then ask for one explicit approval; do not drag the user through a full workshop.",
             "**Short-circuit concrete asks** — for unambiguous implementation-only requests, write a compact brainstorm stub (context, problem, approved intent, constraints, assumptions) and ask for one explicit approval.",
-            "**Ask only decision-changing questions** — one at a time; if answers would not change approach, state the assumption and continue.",
+            "**Ask only decision-changing questions** — one at a time; if answers would not change approach and are non-critical preference/default assumptions, state the assumption and continue; STOP on scope, architecture, security, data loss, public API, migration, auth/pricing, or user approval uncertainty.",
             "**Compare 2-3 distinct approaches with stable Role/Upside columns** — Role values are `baseline` | `challenger` | `wild-card`; Upside is `low` | `modest` | `high` | `higher`; include real trade-offs and reuse notes; include exactly one challenger with explicit `high` or `higher` upside.",
             "**Collect reaction before recommending** — ask which option feels closest and what concern remains, then recommend based on that reaction.",
             "**Write the `Not Doing` list** — name 3-5 things this brainstorm explicitly is not committing to (vs. deferred). This protects scope from silent enlargement and the next stage from rework.",
@@ -55,7 +55,7 @@ export const BRAINSTORM = {
             "Start from observed project context; if the idea is vague, first narrow the project type with **one** structured question, then keep going.",
             "Lead with the premise check (right problem / direct path / what if nothing) and the `How Might We` reframing before approaches; both go in the artifact, not just the chat.",
             "Ask at most one question per turn, only when decision-changing; if using a structured question tool, send exactly one question object, not a multi-question form.",
-            "If likely answers do not change architecture or scope boundaries, choose the default and state the assumption inline.",
+            "Only non-critical preference/default assumptions may continue inline. STOP and ask when uncertainty affects scope, architecture, security, data loss, public API, migration, auth/pricing, or user approval.",
             "For simple greenfield web apps, present a compact A/B choice with one recommended path and one higher-upside challenger; keep the artifact concise but structurally complete (Context, Premise, How Might We, Sharpening Questions, Approaches, Reaction, Selected Direction, Not Doing).",
             "Show approaches before the recommendation; include a higher-upside challenger and gather reaction first.",
             "Self-review before approval: re-read the artifact, fix contradictions/placeholders/weak trade-offs, then ask for approval. Do not ask for approval on a draft you have not re-read.",