@cloverleaf/reference-impl 0.7.1 → 0.7.3

package/dist/cli.mjs

@@ -590,6 +590,9 @@ try {
                             stdio: ['pipe', 'pipe', 'pipe'],
                         });
                         const sibling = JSON.parse(raw);
+                        // Skip siblings that are already merged — they no longer contest scope
+                        if (sibling['status'] === 'merged')
+                            continue;
                         const scope = sibling['scope'];
                         const files = Array.isArray(scope?.['files_touched'])
                             ? scope['files_touched'].filter((x) => typeof x === 'string')

package/lib/cli.ts

@@ -604,6 +604,8 @@ try {
               stdio: ['pipe', 'pipe', 'pipe'],
             });
             const sibling = JSON.parse(raw) as Record<string, unknown>;
+            // Skip siblings that are already merged — they no longer contest scope
+            if (sibling['status'] === 'merged') continue;
             const scope = sibling['scope'] as Record<string, unknown> | undefined;
             const files = Array.isArray(scope?.['files_touched'])
               ? (scope!['files_touched'] as unknown[]).filter((x): x is string => typeof x === 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloverleaf/reference-impl",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Reference implementation of the Cloverleaf methodology as Claude Code skills. Implements the Tight Loop (Implementer + Reviewer).",
   "type": "module",
   "license": "MIT",

package/prompts/plan.md

@@ -89,3 +89,11 @@ Dependencies:
 **How to compute the diff inline:**
 - **Logical** edges: edges you explicitly declared in `task_dag.edges` for sequencing reasons.
 - **Inferred from file overlap**: edges the system will auto-compute by comparing `scope.files_touched` across tasks. For the summary, compute these yourself: for each pair of tasks (A, B) where A has lower task-number, if `scope.files_touched` sets overlap, list an inferred edge A → B with the overlapping paths. Do NOT add these to `task_dag.edges` — list them only in this summary so the human can sanity-check before approval.
+
+**Partial-scope warning:** Count the tasks where `scope.files_touched` is absent or an empty array. If that count is greater than zero, append the following warning line at the bottom of the gate-pending summary (substituting the actual task IDs), then add an advisory note that the walker will silent-skip scope enforcement on those tasks:
+
+```
+⚠ Tasks without scope.files_touched: <CLV-XX, CLV-YY>
+```
+
+Omit this warning line entirely when every task has a non-empty `scope.files_touched`.

package/skills/cloverleaf-run-plan/SKILL.md

@@ -111,11 +111,23 @@ description: Autonomous DAG walker for Cloverleaf Plans. Given a PLAN-ID in stat
 
       Record the returned `session_id`, `worktree_path`, and `branch_name` in walk-state with `state: "running"`, `started_at: <now>`, `last_seq: 0`. Persist via `walk-state-write`.
 
-      Immediately after `mcp__claw-drive__start_session` returns, attach a Monitor tool stream for the new session:
+      Immediately after `mcp__claw-drive__start_session` returns, read the `notification_contract` from the session response and validate it:
+
+      ```bash
+      IDLE_AFTER=$(echo "$START_SESSION_RESPONSE" | jq -r '.notification_contract.idle_after_seconds // 600')
+      EXPECTED_TOKENS="DONE NEEDS-INPUT"
+      for tok in $EXPECTED_TOKENS; do
+        if ! echo "$START_SESSION_RESPONSE" | jq -e ".notification_contract.vocabulary | index(\"$tok\")" > /dev/null 2>&1; then
+          echo "WARNING: notification_contract.vocabulary missing expected token '$tok' — vocab drift detected" >&2
+        fi
+      done
+      ```
+
+      Then attach a Monitor tool stream for the new session:
 
       ```
       Monitor(
-        watch_command: "claw-drive watch <session_id> --since 0 --idle-after 600",
+        watch_command: "claw-drive watch <session_id> --since 0 --idle-after $IDLE_AFTER",
         persistent: true,
         timeout_ms: 3600000
       )
@@ -127,13 +139,13 @@ description: Autonomous DAG walker for Cloverleaf Plans. Given a PLAN-ID in stat
 
       ```
       Monitor(
-        watch_command: "claw-drive watch <session_id> --since <last_seq> --idle-after 600",
+        watch_command: "claw-drive watch <session_id> --since <last_seq> --idle-after $IDLE_AFTER",
         persistent: true,
         timeout_ms: 3600000
       )
       ```
 
-      The `--idle-after 600` flag instructs claw-drive to emit a synthetic `idle` event if a session produces no output for 600 seconds (10 minutes), enabling the walker to detect stalled sessions without polling.
+      The `--idle-after $IDLE_AFTER` flag instructs claw-drive to emit a synthetic `idle` event if a session produces no output for `$IDLE_AFTER` seconds, enabling the walker to detect stalled sessions without polling.
 
    d. **Handle events.** Dispatch each incoming Monitor event by type:
 
@@ -342,3 +354,7 @@ The concrete policy JSON is the same one used during the CLV-16..CLV-20 dogfood
 - Final-gate drain is serial across tasks — one prompt, one decision.
 - The walker exits after the loop reports the final status; it does not auto-retry escalated tasks.
 - Scope-contested merges are escalated, never auto-resolved.
+
+## Notes
+
+**Vocab dependency.** The walker reads `notification_contract.vocabulary` from the `start_session` response advisorily — if the expected tokens (`DONE`, `NEEDS-INPUT`) are absent it warns to stderr but continues. The authoritative source of truth for which tokens Session B will emit is the SDK's `--driven-tokens` flag passed when claw-drive spawns the session. A mismatch between the contract and the actual flag signals a version skew between the claw-drive server and the reference-impl skill; upgrade both components together to keep them in sync.