cclaw-cli 0.51.8 → 0.51.9

package/dist/artifact-linter.js

@@ -252,7 +252,7 @@ function meaningfulLineCount(sectionBody) {
         .filter((line) => line.length > 0)
         .filter((line) => !line.startsWith("<!--"))
         .filter((line) => !/^[-:| ]+$/u.test(line))
-        .filter((line) => /[A-Za-z0-9]/u.test(line))
+        .filter((line) => /[\p{L}\p{N}]/u.test(line))
         .length;
 }
 function lineHasToken(line, token) {
@@ -366,11 +366,16 @@ function getMarkdownTableRows(sectionBody) {
 }
 function getApproachRows(sectionBody) {
     const tableRows = getMarkdownTableRows(sectionBody).map((row) => row.join(" "));
+    const headingRows = sectionBody
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => /^#{3,6}\s+\S/u.test(line))
+        .map((line) => line.replace(/^#{3,6}\s+/u, ""));
     const bulletRows = sectionBody
         .split(/\r?\n/u)
         .map((line) => line.trim())
         .filter((line) => /^(?:[-*]|\d+\.)\s+\S/u.test(line));
-    return [...tableRows, ...bulletRows];
+    return [...tableRows, ...headingRows, ...bulletRows];
 }
 function hasSemanticChallenger(row) {
     const normalized = row

package/dist/content/stages/scope.js

@@ -46,31 +46,31 @@ export const SCOPE = {
     executionModel: {
         checklist: [
             "**Compact CEO pass first** — read brainstorm, name the job-to-be-done, challenge whether this is the right product slice, and propose the highest-leverage scope in one pass. For simple apps, keep this to a tight scope contract instead of a full strategy workshop.",
-            "**Pick one of four gstack modes** — SCOPE EXPANSION, SELECTIVE EXPANSION, HOLD SCOPE, or SCOPE REDUCTION. State why and what user signal would change the mode.",
+            "**Pick one of four gstack modes with the user** — SCOPE EXPANSION, SELECTIVE EXPANSION, HOLD SCOPE, or SCOPE REDUCTION. Recommend one, state why and what signal would change it, then STOP for the user's mode/scope approval before writing the final artifact.",
             "**Draft the 10-star vs current-slice boundary** — show what would make the product meaningfully better, then explicitly choose what ships now, what is deferred, and what is excluded without using vague `later/for now` placeholders.",
             "**Premise and leverage check** — test right problem, direct path, no-action outcome, existing-code leverage, and reversibility before asking the user anything.",
             "**Compare implementation alternatives** — include minimum viable, product-grade, and ideal architecture options with effort/risk/reuse, then recommend one.",
-            "**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 `## Spec Review Loop` before asking approval.",
+            "**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 `## Spec Review Loop`, but do not treat it as user approval.",
             "**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** — include in-scope/out-of-scope, discretion areas, deferred items, locked decisions, error/rescue notes, completion dashboard, scope summary, next-stage handoff, and explicit approval."
+            "**Write the scope contract after approval** — include in-scope/out-of-scope, discretion areas, deferred items, locked decisions, error/rescue notes, completion dashboard, scope summary, next-stage handoff, and explicit approval evidence."
         ],
         interactionProtocol: [
             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"),
-            "Do not walk the full checklist by default. Lead with an opinionated scope contract and the one decision that matters most.",
-            "For simple web-app flows, default to HOLD SCOPE or SELECTIVE EXPANSION, show the exact in/out/deferred contract, and ask for one approval.",
+            "Do not walk the full checklist by default. Lead with a proposed scope contract and the one decision that matters most; label the mode as recommended, not selected, until the user answers.",
+            "For simple web-app flows, default to HOLD SCOPE or SELECTIVE EXPANSION, show the exact in/out/deferred contract as a proposal, and STOP for one explicit approval before writing the final scope artifact or completing the stage.",
             "Challenge premise first, take a firm position, and name one concrete condition that would change it.",
             "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; otherwise state the assumption and move on.",
             "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 \`## Spec Review Loop\` table using ${reviewLoopPolicySummary("scope")}`,
-            "**STOP.** Wait for explicit approval of the scope contract before advancing.",
-            "**STOP BEFORE ADVANCE.** Mandatory delegation `planner` must be completed or explicitly waived. If no isolated planner is available, use `--waive-delegation=planner --waiver-reason=\"role-switch scope self-review completed\"`. Then close with `node .cclaw/hooks/stage-complete.mjs scope --passed=scope_mode_selected,scope_contract_written,scope_user_approved --evidence-json '{\"scope_mode_selected\":\"<mode + rationale>\",\"scope_contract_written\":\"<artifact path + sections>\"}'`. Do not include `scope_user_approved` manually; stage-complete auto-hydrates its review-loop envelope from `## Spec Review Loop`."
+            "**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` must be completed or explicitly waived. If no isolated planner is available, use `--waive-delegation=planner --waiver-reason=\"role-switch scope self-review completed\"`. Then close with `node .cclaw/hooks/stage-complete.mjs scope --passed=scope_mode_selected,scope_contract_written,scope_user_approved --evidence-json '{\"scope_mode_selected\":\"<user-approved mode + rationale>\",\"scope_contract_written\":\"<artifact path + sections>\",\"scope_user_approved\":\"<explicit user approval quote or summary>\"}'`. `scope_user_approved` must cite the user's approval; review-loop evidence alone is not approval."
         ],
         process: [
             "Run configured pre-scope audit only when enabled.",
             "Run the gstack-style CEO scope pass scaled to risk: job-to-be-done, premise challenge, 10-star upside, smallest useful wedge, and what would change the recommendation.",
             "Compare minimum viable, product-grade, and ideal architecture scope alternatives with explicit reuse/effort/risk.",
-            "Select scope mode with explicit rationale; ask for user opt-in only when changing or expanding scope.",
+            "Recommend a scope mode with explicit rationale, then ask for user opt-in before treating it as selected.",
             "Run outside voice / adversarial self-check before final approval and record a valid `## Spec Review Loop` table.",
             "Write explicit scope contract, discretion areas, deferred items, error/rescue registry, and D-XX locked decisions.",
             "Produce scope summary, completion dashboard, and exact next-stage handoff before asking final approval."
@@ -89,7 +89,7 @@ export const SCOPE = {
             "Locked Decisions section lists stable D-XX IDs for non-negotiable boundaries.",
             "Premise challenge findings documented.",
             "Outside Voice findings and dispositions are recorded (accept/reject/defer with rationale) before final approval.",
-            `Spec review loop summary includes a table with columns Iteration, Quality Score, Findings, plus Stop reason, Target score, and Max iterations. stage-complete auto-hydrates scope_user_approved evidence from this section. ${reviewLoopPolicySummary("scope")}`,
+            `Spec review loop summary includes a table with columns Iteration, Quality Score, Findings, plus Stop reason, Target score, and Max iterations. This is outside-voice evidence only; it does not satisfy user approval. ${reviewLoopPolicySummary("scope")}`,
             reviewLoopSecondOpinionSummary("scope"),
             "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.",

package/dist/content/start-command.js

@@ -70,7 +70,7 @@ ${conversationLanguagePolicyMarkdown()}
    Skip detection quietly if no markers are found — do NOT invent a stack.
 
 5. Read \`${flowPath}\`.
-6. If flow already has completed stages, warn the user that starting a new tracked flow will reset progress. Ask for confirmation before proceeding.
+6. If flow already has completed stages, warn the user that starting a new tracked flow will reset progress. Ask for confirmation before proceeding. A fresh init placeholder state with \`completedStages: []\`, no passed gates, and no \`00-idea.md\` is **not** an active flow; do not ask the user to resume it.
 7. **Track heuristic** — classify the idea text and **recommend** a track (the user can override before any state mutation):
    - First, load \`${RUNTIME_ROOT}/config.yaml\`. If \`trackHeuristics\` is defined, apply those per-track vocabulary hints (\`fallback\`, \`tracks.<id>.{triggers,veto}\`) on top of the built-in defaults. Evaluation order is always \`standard -> medium -> quick\` (narrow-to-broad).
    - **quick** (\`spec → tdd → review → ship\`) — single-purpose work where the spec is essentially already known.
@@ -152,7 +152,7 @@ description: "Unified entry point for the cclaw flow. No args = resume/next. Wit
 
 ## HARD-GATE
 
-Do **not** silently discard an existing flow when the user provides a prompt. If completed stages exist, inform and confirm before resetting.
+Do **not** silently discard an existing flow when the user provides a prompt. If completed stages exist, inform and confirm before resetting. A freshly initialized placeholder state with \`completedStages: []\`, no passed gates, and no \`${RUNTIME_ROOT}/artifacts/00-idea.md\` is not an active flow; classify the prompt and start normally.
 
 ${conversationLanguagePolicyMarkdown()}
 ## Protocol
@@ -168,6 +168,7 @@ ${conversationLanguagePolicyMarkdown()}
    - Inform: "You have an active flow at stage **{currentStage}** with {N} completed stages. Starting a new tracked flow will reset progress."
    - Ask: "Continue with reset? (A) Yes, start fresh (B) No, resume current flow"
    - If (B) → switch to Path B behavior.
+   If \`completedStages\` is empty, all gate \`passed\` arrays are empty, and \`${RUNTIME_ROOT}/artifacts/00-idea.md\` is missing, treat it as a fresh init placeholder — do **not** ask whether to continue the current flow.
 7. **Classify the idea** using the heuristic below and present one compact Start framing summary (class, track, stack, origin docs, seed recalls, next action). Wait for explicit confirmation or override before mutating any state only when reset/conflict/ambiguity makes it necessary.
    - If \`${RUNTIME_ROOT}/config.yaml\` defines \`trackHeuristics\`, apply those vocabulary hints (\`fallback\`, \`tracks.<id>.{triggers,veto}\`) on top of built-in defaults. Evaluation order is fixed: \`standard -> medium -> quick\`. (Honest note: this is advisory prose; the LLM applies it, not a Node-level router.)
 

package/dist/internal/advance-stage.js

@@ -19,7 +19,6 @@ import { runTddLoopStatusCommand } from "./tdd-loop-status.js";
 import { runTddRedEvidenceCommand } from "./tdd-red-evidence.js";
 import { extractReviewLoopEnvelopeFromArtifact } from "../content/review-loop.js";
 const AUTO_REVIEW_LOOP_GATE_BY_STAGE = {
-    scope: "scope_user_approved",
     design: "design_architecture_locked"
 };
 function unique(values) {
@@ -163,6 +162,30 @@ function validateReviewLoopGateEvidence(stage, evidence) {
     }
     return null;
 }
+function validateUserApprovalEvidence(evidence) {
+    const normalized = evidence.trim();
+    if (normalized.length === 0) {
+        return "must cite explicit user approval.";
+    }
+    const reviewLoopEnvelope = (() => {
+        try {
+            return pickReviewLoopEnvelope(JSON.parse(normalized));
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (reviewLoopEnvelope) {
+        return "must cite explicit user approval; review-loop evidence is outside-voice evidence, not user approval.";
+    }
+    if (/\b(?:approved|approval|user approved|confirmed|accepted|yes|ok)\b/iu.test(normalized)) {
+        return null;
+    }
+    if (/\b(?:утвержд(?:аю|ено|ен|ена)|подтвержд(?:аю|ено|ен|ена)|соглас(?:ен|на|овано)|да|ок|принято)\b/iu.test(normalized)) {
+        return null;
+    }
+    return "must cite explicit user approval (for example `user approved the scope contract` or `пользователь утвердил scope`).";
+}
 // Per-gate validators keyed by `${stage}:${gateId}`. Returning a non-null
 // string surfaces the reason as an `advance-stage` failure so evidence is
 // guaranteed to carry the structural breadcrumbs downstream tooling
@@ -186,7 +209,7 @@ const GATE_EVIDENCE_VALIDATORS = {
         }
         return null;
     },
-    "scope:scope_user_approved": (evidence) => validateReviewLoopGateEvidence("scope", evidence),
+    "scope:scope_user_approved": (evidence) => validateUserApprovalEvidence(evidence),
     "design:design_architecture_locked": (evidence) => validateReviewLoopGateEvidence("design", evidence)
 };
 function validateGateEvidenceShape(stage, gateId, evidence) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.51.8",
+  "version": "0.51.9",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {