cclaw-cli 0.5.8 → 0.5.9

package/dist/artifact-linter.js

@@ -118,6 +118,22 @@ function tokensFromRule(rule) {
     }
     return [];
 }
+/**
+ * Extract required keywords from validation rules that contain comma-separated
+ * concept lists. Activates only for rules with structured enumerations like
+ * "failure modes, error surface, data-flow paths" — not for short rules.
+ */
+function extractRequiredKeywords(rule) {
+    const colonMatch = /:\s*(.+)$/u.exec(rule);
+    if (!colonMatch)
+        return [];
+    const tail = colonMatch[1];
+    const parts = tail.split(/,\s*(?:and\s+)?/u).map((p) => p.trim().replace(/\.$/u, ""));
+    const phrases = parts.filter((p) => p.length >= 4 && !/^(must|should|at least|if |or )/iu.test(p));
+    if (phrases.length < 3)
+        return [];
+    return phrases;
+}
 function validateSectionBody(sectionBody, rule) {
     const bodyLines = sectionBody.split(/\r?\n/).map((line) => line.trim());
     const meaningful = meaningfulLineCount(sectionBody);
@@ -185,6 +201,19 @@ function validateSectionBody(sectionBody, rule) {
             }
         }
     }
+    const keywords = extractRequiredKeywords(rule);
+    if (keywords.length > 0) {
+        const bodyLower = sectionBody.toLowerCase();
+        const found = keywords.filter((kw) => bodyLower.includes(kw.toLowerCase()));
+        const threshold = Math.ceil(keywords.length * 0.5);
+        if (found.length < threshold) {
+            const missing = keywords.filter((kw) => !bodyLower.includes(kw.toLowerCase()));
+            return {
+                ok: false,
+                details: `Rule expects keywords (${threshold}/${keywords.length} minimum): missing ${missing.join(", ")}.`
+            };
+        }
+    }
     return {
         ok: true,
         details: "Section heading and content satisfy lint heuristics."

package/dist/content/examples.js

@@ -73,6 +73,14 @@ The original premise (“add notifications”) was reframed to **“ensure users
 | **12-MONTH IDEAL** | Unified notification center with reliable multi-channel fan-out and user-level routing preferences. |
 | **Alignment verdict** | Aligned: this scope builds the durability foundation without prematurely committing to channel expansion. |
 
+### Mode-Specific Analysis
+
+**Selected mode:** SELECTIVE EXPANSION
+
+- **Hold-scope baseline:** SSE live updates + REST fallback is the minimum that meets the "know when action is needed" reframe. Accepted as baseline.
+- **Expansion evaluated — degraded-state UX (accepted):** Adding an explicit "live updates paused" banner and polling fallback turns a reliability gap into a visible, recoverable state. Low incremental effort (S), high user trust payoff.
+- **Expansion evaluated — real-time channel upgrade (deferred):** WebSocket channel provides lower latency but requires new infra (connection pool, auth handshake). Not justified for current load; deferred to post-v1 validation.
+
 ### Implementation Alternatives
 
 | Option | Summary | Effort (S/M/L/XL) | Risk | Pros | Cons | Reuses |

package/dist/content/observe.js

@@ -309,10 +309,15 @@ is_plan_mode_safe_tool() {
     todowrite|todoread|todo_write|todo_read) return 0 ;;
     webfetch|websearch|web_fetch|web_search|fetchmcpresource) return 0 ;;
     switchmode|switch_mode) return 0 ;;
+    task|delegate) return 0 ;;
     *) return 1 ;;
   esac
 }
 
+is_cclaw_cli_payload() {
+  printf '%s' "$1" | grep -Eq '(cclaw |npx cclaw |/cc-|/cc[^[:alnum:]_-])'
+}
+
 is_preimplementation_stage() {
   case "$1" in
     brainstorm|scope|design|spec|plan) return 0 ;;
@@ -370,7 +375,7 @@ fi
 
 if is_preimplementation_stage "$CURRENT_STAGE" && ! is_plan_mode_safe_tool "$TOOL_LOWER"; then
   if ! is_mutating_tool "$TOOL_LOWER"; then
-    if ! printf '%s' "$PAYLOAD_LOWER" | grep -Eq '\.cclaw/'; then
+    if ! printf '%s' "$PAYLOAD_LOWER" | grep -Eq '\.cclaw/' && ! is_cclaw_cli_payload "$PAYLOAD_LOWER"; then
       if [ -n "$REASONS" ]; then
         REASONS="$REASONS,non_safe_tool_in_plan_stage_\${CURRENT_STAGE}"
       else
@@ -393,9 +398,10 @@ fi
 SHOULD_RECORD_FLOW_READ=0
 case "$TOOL_LOWER" in
   read|readfile|open|view|cat) SHOULD_RECORD_FLOW_READ=1 ;;
+  shell|runcommand|run_command|execcommand|exec_command|terminal) SHOULD_RECORD_FLOW_READ=1 ;;
 esac
 
-if [ "$SHOULD_RECORD_FLOW_READ" -eq 1 ] && printf '%s' "$PAYLOAD_LOWER" | grep -Eq '\.cclaw/state/flow-state\.json'; then
+if [ "$SHOULD_RECORD_FLOW_READ" -eq 1 ] && printf '%s' "$PAYLOAD_LOWER" | grep -Eq '(\.cclaw/state/flow-state\.json|cclaw doctor|cclaw sync)'; then
   TMP_STATE_FILE="$GUARD_STATE_FILE.tmp.$$"
   if command -v jq >/dev/null 2>&1 && [ -f "$GUARD_STATE_FILE" ]; then
     jq --arg ts "$TS" --argjson epoch "$NOW_EPOCH" '

package/dist/content/skills.js

@@ -143,6 +143,8 @@ function stageCompletionProtocol(schema) {
     const gateIds = schema.requiredGates.map((g) => g.id);
     const gateList = gateIds.map((id) => `\`${id}\``).join(", ");
     const nextStage = schema.next === "done" ? null : schema.next;
+    const mandatory = schema.mandatoryDelegations;
+    const delegationLogRel = `${RUNTIME_ROOT}/state/delegation-log.json`;
     const stateUpdate = nextStage
         ? `   - Set \`currentStage\` to \`"${nextStage}"\`
    - Add \`"${stage}"\` to \`completedStages\` array
@@ -151,23 +153,33 @@ function stageCompletionProtocol(schema) {
         : `   - Add \`"${stage}"\` to \`completedStages\` array
    - Move all gate IDs for this stage (${gateList}) into \`stageGateCatalog.${stage}.passed\`
    - Clear \`stageGateCatalog.${stage}.blocked\``;
+    const delegationBlock = mandatory.length > 0
+        ? `0. **Delegation pre-flight** (BLOCKING):
+   - Mandatory agents for this stage: ${mandatory.map((a) => `\`${a}\``).join(", ")}.
+   - For each mandatory agent: confirm it was dispatched (via Task/delegate) and completed, OR record an explicit waiver with reason in \`${delegationLogRel}\`.
+   - Write a JSON entry per agent: \`{ "stage": "${stage}", "agent": "<name>", "mode": "mandatory", "status": "completed"|"waived", "waiverReason": "<if waived>", "ts": "<ISO timestamp>" }\`.
+   - If the harness does not support delegation, record status \`"waived"\` with reason \`"harness_limitation"\`.
+   - **Do NOT proceed to step 1 until every mandatory agent has an entry in the delegation log.**
+`
+        : "";
     let nextAction;
     if (nextStage) {
         const nextSchema = stageSchema(nextStage);
         const nextDescription = nextSchema.skillDescription.charAt(0).toLowerCase() + nextSchema.skillDescription.slice(1);
-        nextAction = `3. Tell the user:\n\n   > **Stage \`${stage}\` complete.** Next: **${nextStage}** — ${nextDescription}\n   >\n   > Run \`/cc-next\` to continue.`;
+        nextAction = `4. Tell the user:\n\n   > **Stage \`${stage}\` complete.** Next: **${nextStage}** — ${nextDescription}\n   >\n   > Run \`/cc-next\` to continue.`;
     }
     else {
-        nextAction = `3. Tell the user:\n\n   > **Flow complete.** All stages finished. The project is ready for release.`;
+        nextAction = `4. Tell the user:\n\n   > **Flow complete.** All stages finished. The project is ready for release.`;
     }
     return `## Stage Completion Protocol
 
 When all required gates are satisfied and the artifact is written:
 
-1. **Update \`${RUNTIME_ROOT}/state/flow-state.json\`:**
+${delegationBlock}1. **Update \`${RUNTIME_ROOT}/state/flow-state.json\`:**
 ${stateUpdate}
    - For each passed gate, add an entry to \`guardEvidence\`: \`"<gate_id>": "<artifact path or excerpt proving the gate>"\`. Do NOT leave \`guardEvidence\` empty.
 2. **Persist artifact** at \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`. Do NOT manually copy into \`${RUNTIME_ROOT}/runs/\`; archival is handled by \`cclaw archive\`.
+3. **Doctor pre-flight** — Run \`npx cclaw doctor\` (or the installed cclaw binary). If any check fails, resolve the issue (missing delegation entry, artifact section, gate evidence) and re-run until all checks pass. Do NOT proceed to the next step while doctor reports failures.
 ${nextAction}
 
 **STOP.** Do not load the next stage skill yourself. The user will run \`/cc-next\` when ready (same session or new session).

package/dist/content/stage-schema.js

@@ -352,12 +352,15 @@ const SCOPE = {
         { section: "Premise Challenge", required: true, validationRule: "Must contain explicit answers to: right problem? direct path? what if nothing?" },
         { section: "Implementation Alternatives", required: true, validationRule: "2-3 options with Name, Summary, Effort, Risk, Pros, Cons, and Reuses. Must include minimal viable and ideal architecture options." },
         { section: "Scope Mode", required: true, validationRule: "Must state selected mode and rationale with default heuristic justification." },
+        { section: "Mode-Specific Analysis", required: true, validationRule: "Must document the analysis matching the selected scope mode: EXPAND (10x and delight opportunities), SELECTIVE (hold-scope baseline then cherry-picked expansions), HOLD (minimum-change-set hardening), REDUCE (ruthless cuts and follow-up split)." },
         { section: "In Scope / Out of Scope", required: true, validationRule: "Two separate explicit lists. Out-of-scope must not be empty." },
         { section: "Discretion Areas", required: true, validationRule: "Explicit list of implementer decision zones, or 'None' if scope is fully locked." },
         { section: "Deferred Items", required: true, validationRule: "Each item has one-line rationale. If empty, state 'None' explicitly." },
         { section: "Error & Rescue Registry", required: true, validationRule: "Each scoped capability has: failure mode, detection method, fallback decision." },
         { section: "Completion Dashboard", required: true, validationRule: "Lists checklist findings, count of resolved decisions, and unresolved decisions (or 'None')." },
-        { section: "Scope Summary", required: true, validationRule: "Clean summary: mode, strongest challenges, recommended path, accepted scope, deferred, excluded." }
+        { section: "Scope Summary", required: true, validationRule: "Clean summary: mode, strongest challenges, recommended path, accepted scope, deferred, excluded." },
+        { section: "Dream State Mapping", required: false, validationRule: "If present (complex projects): CURRENT STATE, THIS PLAN, 12-MONTH IDEAL, and alignment verdict." },
+        { section: "Temporal Interrogation", required: false, validationRule: "If present (complex projects): timeline simulation table with decision pressures and lock-now vs defer verdicts." }
     ],
     namedAntiPattern: {
         title: "Scope Is Obvious From Context",

package/dist/content/templates.js

@@ -76,6 +76,14 @@ export const ARTIFACT_TEMPLATES = {
 - [ ] hold
 - [ ] reduce
 
+## Mode-Specific Analysis
+- **Selected mode:**
+- **Analysis:**
+  - (EXPAND: 10x opportunities, delight features)
+  - (SELECTIVE: hold-scope baseline, cherry-picked expansions)
+  - (HOLD: minimum-change-set hardening)
+  - (REDUCE: ruthless cuts, follow-up split)
+
 ## In Scope / Out of Scope
 
 ### In Scope

package/package.json

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