@cloverleaf/reference-impl 0.7.3 → 0.7.5

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cloverleaf",
   "description": "Cloverleaf reference implementation — Claude Code skills for task scaffolding and the Delivery pipeline (implementer, documenter, reviewer, UI reviewer with multi-viewport visual diff, QA, merge, release).",
-  "version": "0.6.5",
+  "version": "0.7.5",
   "author": {
     "name": "Renato D'Arrigo",
     "email": "renato.darrigo@gmail.com"

package/README.md

@@ -166,6 +166,38 @@ npm test        # run the Vitest suite
 npm run test:watch
 ```
 
+## Plans vs RFC-direct tasks
+
+Cloverleaf has two ways to get from an approved RFC to executed Tasks. Both are first-class; the right one depends on the size and shape of the work.
+
+**Plan-task (Discovery flow):** Operator invokes `/cloverleaf-discover`. The Plan agent decomposes the RFC into a Plan with a `task_dag`; the operator approves the decomposition at `task_batch_gate`; tasks are materialised under the Plan; the walker drives them through Delivery. Use this when the work spans ≥3 related tasks AND there's value in reviewing the decomposition before any task materializes (the gate is a checkpoint, not ceremony).
+
+**RFC-direct task (skip the Plan layer):** Operator invokes `/cloverleaf-new-task --rfc=<RFC-ID> "<brief>"`. A single task is created with `context.rfc` set and `parent` absent — no Plan, no `task_batch_gate`. Use this for:
+
+- **Hotfixes after a Plan has delivered** — a small bug or polish item surfaces after the Plan's tasks are all merged. Creating a new Plan for one task is pure overhead; an RFC-direct task is faster and equally trackable.
+- **Incremental RFC progress without batch decomposition** — operator hasn't yet decided how to decompose the next chunk of work, but a single concrete task is clear. Create it now; defer the Plan formation until later (or skip Plans entirely if the work continues to arrive one task at a time).
+
+### Auto-advance: how the walker treats them
+
+When the walker (`/cloverleaf-run-plan`) finishes a Plan's final task, it asks `cloverleaf-cli rfc-tasks <repo_root> <RFC-ID>` whether the parent RFC can also advance from `approved` to `completed`. The check considers BOTH sibling Plans AND RFC-direct tasks under the same RFC:
+
+- An **in-flight** Plan (`drafting`/`gate-pending`/`approved`) OR standalone task (any non-terminal state) blocks the RFC advance — there's still work pending under this RFC.
+- A **delivered** Plan (`completed`) OR standalone task (`merged`) counts toward the at-least-one-delivered requirement — the RFC must have produced at least one successful piece of work to advance.
+- If all delivered work was rejected/escalated, the operator decides: abandon the RFC, re-decompose, or accept the RFC as not-shippable. The walker won't auto-advance.
+
+### Operator visibility
+
+```bash
+cloverleaf-cli rfc-tasks <repo_root> <RFC-ID>            # compact JSON
+cloverleaf-cli rfc-tasks <repo_root> <RFC-ID> --pretty   # indented for humans
+```
+
+Returns the RFC's status, all sibling Plans (with their child tasks), all standalone tasks, and a summary block with in-flight/delivered counts plus `can_auto_advance_rfc`. Pure read; no side effects.
+
+### The tradeoff to name
+
+Skipping the Plan = skipping `task_batch_gate`. That's the right tradeoff for hotfixes (one task; no decomposition to review) and for one-task-at-a-time incremental work. It's the wrong tradeoff for a large multi-task scope where the human's review of the decomposition is the load-bearing checkpoint. Plans are a checkpoint, not ceremony.
+
 ## License
 
 MIT — see [../LICENSE](../LICENSE).

package/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.5

package/dist/cli.mjs

@@ -20,6 +20,7 @@
  *   load-rfc <repoRoot> <id>
  *   save-rfc <repoRoot> <filePath>
  *   advance-rfc <repoRoot> <id> <toStatus> <agent|human> [gate]
+ *   rfc-tasks <repoRoot> <rfcId> [--pretty]
  *   load-spike <repoRoot> <id>
  *   save-spike <repoRoot> <filePath>
  *   advance-spike <repoRoot> <id> <toStatus> <agent|human>
@@ -63,6 +64,7 @@ import { computeReadyTasks, detectCycle } from './dag-walker.mjs';
 import { readWalkState, writeWalkState, walkStatePath } from './walk-state.mjs';
 import { loadWalkerConfig } from './walker-config.mjs';
 import { classifyFiles } from './scope-check.mjs';
+import { computeRfcTasksView } from './rfc-tasks.mjs';
 function die(msg, code = 1) {
     process.stderr.write(msg + '\n');
     process.exit(code);
@@ -87,6 +89,7 @@ function usage(msg) {
         '  load-rfc <repoRoot> <id>\n' +
         '  save-rfc <repoRoot> <filePath>\n' +
         '  advance-rfc <repoRoot> <id> <toStatus> <agent|human> [gate]\n' +
+        '  rfc-tasks <repoRoot> <rfcId> [--pretty]\n' +
         '  load-spike <repoRoot> <id>\n' +
         '  save-spike <repoRoot> <filePath>\n' +
         '  advance-spike <repoRoot> <id> <toStatus> <agent|human>\n' +
@@ -367,6 +370,25 @@ try {
             advanceRfcStatus(repoRoot, id, toStatus, actor, opts);
             break;
         }
+        case 'rfc-tasks': {
+            const positional = rest.filter((a) => !a.startsWith('--'));
+            const flags = rest.filter((a) => a.startsWith('--'));
+            const [repoRoot, rfcId] = positional;
+            if (!repoRoot || !rfcId)
+                usage('rfc-tasks <repoRoot> <rfcId> [--pretty]');
+            const pretty = flags.includes('--pretty');
+            let view;
+            try {
+                view = computeRfcTasksView(repoRoot, rfcId);
+            }
+            catch (err) {
+                process.stderr.write(`cloverleaf-cli rfc-tasks: ${err instanceof Error ? err.message : String(err)}\n`);
+                process.exit(2);
+            }
+            process.stdout.write(pretty ? JSON.stringify(view, null, 2) : JSON.stringify(view));
+            process.stdout.write('\n');
+            break;
+        }
         case 'load-spike': {
             const positional = rest.filter((a) => !a.startsWith('--'));
             const flags = rest.filter((a) => a.startsWith('--'));

package/dist/rfc-tasks.mjs

@@ -0,0 +1,83 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { plansDir, tasksDir, rfcsDir } from './paths.mjs';
+/**
+ * A task is "standalone" (RFC-direct) iff it has no parent (absent or null)
+ * AND it has a non-empty context.rfc.id. See
+ * docs/superpowers/specs/2026-05-12-rfc-direct-tasks-design.md §"Discriminator".
+ */
+export function isStandaloneTask(task) {
+    const parent = task.parent;
+    if (parent != null)
+        return false;
+    const ctx = task.context;
+    const rfc = ctx?.rfc;
+    return !!(rfc && typeof rfc.id === 'string' && rfc.id.length > 0);
+}
+const PLAN_INFLIGHT = new Set(['drafting', 'gate-pending', 'approved']);
+const TASK_TERMINAL = new Set(['merged', 'rejected', 'escalated']);
+export function computeRfcTasksView(repoRoot, rfcId) {
+    const rfcPath = join(rfcsDir(repoRoot), `${rfcId}.json`);
+    if (!existsSync(rfcPath)) {
+        throw new Error(`rfc ${rfcId} not found at ${rfcPath}`);
+    }
+    const rfc = JSON.parse(readFileSync(rfcPath, 'utf-8'));
+    // Load all plans of this RFC + their child task statuses
+    const plans = [];
+    const plansDirPath = plansDir(repoRoot);
+    if (existsSync(plansDirPath)) {
+        for (const f of readdirSync(plansDirPath)) {
+            if (!f.endsWith('.json'))
+                continue;
+            const plan = JSON.parse(readFileSync(join(plansDirPath, f), 'utf-8'));
+            if (plan.parent_rfc?.project !== rfc.project || plan.parent_rfc.id !== rfc.id)
+                continue;
+            const tasks = [];
+            for (const node of plan.task_dag?.nodes ?? []) {
+                const taskPath = join(tasksDir(repoRoot), `${node.id}.json`);
+                if (!existsSync(taskPath))
+                    continue;
+                const t = JSON.parse(readFileSync(taskPath, 'utf-8'));
+                tasks.push({ id: t.id, status: t.status });
+            }
+            plans.push({ project: plan.project, id: plan.id, status: plan.status, tasks });
+        }
+    }
+    plans.sort((a, b) => a.id.localeCompare(b.id));
+    // Load standalone tasks: parent absent/null AND context.rfc matches
+    const standalone = [];
+    const tasksDirPath = tasksDir(repoRoot);
+    if (existsSync(tasksDirPath)) {
+        for (const f of readdirSync(tasksDirPath)) {
+            if (!f.endsWith('.json'))
+                continue;
+            const t = JSON.parse(readFileSync(join(tasksDirPath, f), 'utf-8'));
+            if (!isStandaloneTask(t))
+                continue;
+            const ctxRfc = t.context.rfc;
+            if (ctxRfc.project !== rfc.project || ctxRfc.id !== rfc.id)
+                continue;
+            standalone.push({ id: t.id, status: t.status });
+        }
+    }
+    standalone.sort((a, b) => a.id.localeCompare(b.id));
+    const inflight_plans = plans.filter(p => PLAN_INFLIGHT.has(p.status)).length;
+    const inflight_standalone = standalone.filter(t => !TASK_TERMINAL.has(t.status)).length;
+    const delivered_plans = plans.filter(p => p.status === 'completed').length;
+    const delivered_standalone = standalone.filter(t => t.status === 'merged').length;
+    const can_auto_advance_rfc = rfc.status === 'approved' &&
+        inflight_plans + inflight_standalone === 0 &&
+        delivered_plans + delivered_standalone > 0;
+    return {
+        rfc: { project: rfc.project, id: rfc.id, status: rfc.status },
+        plans,
+        standalone_tasks: standalone,
+        summary: {
+            inflight_plans,
+            inflight_standalone,
+            delivered_plans,
+            delivered_standalone,
+            can_auto_advance_rfc,
+        },
+    };
+}

package/lib/cli.ts

@@ -20,6 +20,7 @@
  *   load-rfc <repoRoot> <id>
  *   save-rfc <repoRoot> <filePath>
  *   advance-rfc <repoRoot> <id> <toStatus> <agent|human> [gate]
+ *   rfc-tasks <repoRoot> <rfcId> [--pretty]
  *   load-spike <repoRoot> <id>
  *   save-spike <repoRoot> <filePath>
  *   advance-spike <repoRoot> <id> <toStatus> <agent|human>
@@ -66,6 +67,7 @@ import { readWalkState, writeWalkState, walkStatePath } from './walk-state.js';
 import { loadWalkerConfig } from './walker-config.js';
 import { classifyFiles } from './scope-check.js';
 import type { SiblingScope } from './scope-check.js';
+import { computeRfcTasksView, type RfcTasksView } from './rfc-tasks.js';
 
 function die(msg: string, code = 1): never {
   process.stderr.write(msg + '\n');
@@ -92,6 +94,7 @@ function usage(msg?: string): never {
       '  load-rfc <repoRoot> <id>\n' +
       '  save-rfc <repoRoot> <filePath>\n' +
       '  advance-rfc <repoRoot> <id> <toStatus> <agent|human> [gate]\n' +
+      '  rfc-tasks <repoRoot> <rfcId> [--pretty]\n' +
       '  load-spike <repoRoot> <id>\n' +
       '  save-spike <repoRoot> <filePath>\n' +
       '  advance-spike <repoRoot> <id> <toStatus> <agent|human>\n' +
@@ -383,6 +386,24 @@ try {
       break;
     }
 
+    case 'rfc-tasks': {
+      const positional = rest.filter((a) => !a.startsWith('--'));
+      const flags = rest.filter((a) => a.startsWith('--'));
+      const [repoRoot, rfcId] = positional;
+      if (!repoRoot || !rfcId) usage('rfc-tasks <repoRoot> <rfcId> [--pretty]');
+      const pretty = flags.includes('--pretty');
+      let view: RfcTasksView;
+      try {
+        view = computeRfcTasksView(repoRoot, rfcId);
+      } catch (err) {
+        process.stderr.write(`cloverleaf-cli rfc-tasks: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(2);
+      }
+      process.stdout.write(pretty ? JSON.stringify(view, null, 2) : JSON.stringify(view));
+      process.stdout.write('\n');
+      break;
+    }
+
     case 'load-spike': {
       const positional = rest.filter((a) => !a.startsWith('--'));
       const flags = rest.filter((a) => a.startsWith('--'));

package/lib/rfc-tasks.ts

@@ -0,0 +1,112 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { plansDir, tasksDir, rfcsDir } from './paths.js';
+import type { TaskDoc } from './task.js';
+import type { PlanDoc } from './plan.js';
+
+/**
+ * A task is "standalone" (RFC-direct) iff it has no parent (absent or null)
+ * AND it has a non-empty context.rfc.id. See
+ * docs/superpowers/specs/2026-05-12-rfc-direct-tasks-design.md §"Discriminator".
+ */
+export function isStandaloneTask(task: TaskDoc): boolean {
+  const parent = (task as Record<string, unknown>).parent;
+  if (parent != null) return false;
+  const ctx = task.context as Record<string, unknown> | undefined;
+  const rfc = ctx?.rfc as { project?: string; id?: string } | undefined;
+  return !!(rfc && typeof rfc.id === 'string' && rfc.id.length > 0);
+}
+
+export interface RfcSummary {
+  inflight_plans: number;
+  inflight_standalone: number;
+  delivered_plans: number;
+  delivered_standalone: number;
+  can_auto_advance_rfc: boolean;
+}
+
+export interface RfcTasksView {
+  rfc: { project: string; id: string; status: string };
+  plans: Array<{
+    project: string;
+    id: string;
+    status: string;
+    tasks: Array<{ id: string; status: string }>;
+  }>;
+  standalone_tasks: Array<{ id: string; status: string }>;
+  summary: RfcSummary;
+}
+
+const PLAN_INFLIGHT = new Set(['drafting', 'gate-pending', 'approved']);
+const TASK_TERMINAL = new Set(['merged', 'rejected', 'escalated']);
+
+export function computeRfcTasksView(repoRoot: string, rfcId: string): RfcTasksView {
+  const rfcPath = join(rfcsDir(repoRoot), `${rfcId}.json`);
+  if (!existsSync(rfcPath)) {
+    throw new Error(`rfc ${rfcId} not found at ${rfcPath}`);
+  }
+  const rfc = JSON.parse(readFileSync(rfcPath, 'utf-8')) as {
+    project: string; id: string; status: string;
+  };
+
+  // Load all plans of this RFC + their child task statuses
+  const plans: RfcTasksView['plans'] = [];
+  const plansDirPath = plansDir(repoRoot);
+  if (existsSync(plansDirPath)) {
+    for (const f of readdirSync(plansDirPath)) {
+      if (!f.endsWith('.json')) continue;
+      const plan = JSON.parse(readFileSync(join(plansDirPath, f), 'utf-8')) as PlanDoc;
+      if (plan.parent_rfc?.project !== rfc.project || plan.parent_rfc.id !== rfc.id) continue;
+
+      const tasks: Array<{ id: string; status: string }> = [];
+      for (const node of plan.task_dag?.nodes ?? []) {
+        const taskPath = join(tasksDir(repoRoot), `${node.id}.json`);
+        if (!existsSync(taskPath)) continue;
+        const t = JSON.parse(readFileSync(taskPath, 'utf-8')) as { id: string; status: string };
+        tasks.push({ id: t.id, status: t.status });
+      }
+      plans.push({ project: plan.project, id: plan.id, status: plan.status, tasks });
+    }
+  }
+  plans.sort((a, b) => a.id.localeCompare(b.id));
+
+  // Load standalone tasks: parent absent/null AND context.rfc matches
+  const standalone: Array<{ id: string; status: string }> = [];
+  const tasksDirPath = tasksDir(repoRoot);
+  if (existsSync(tasksDirPath)) {
+    for (const f of readdirSync(tasksDirPath)) {
+      if (!f.endsWith('.json')) continue;
+      const t = JSON.parse(readFileSync(join(tasksDirPath, f), 'utf-8')) as TaskDoc;
+      if (!isStandaloneTask(t)) continue;
+      const ctxRfc = (t.context as Record<string, unknown>).rfc as {
+        project?: string; id?: string;
+      };
+      if (ctxRfc.project !== rfc.project || ctxRfc.id !== rfc.id) continue;
+      standalone.push({ id: t.id, status: t.status });
+    }
+  }
+  standalone.sort((a, b) => a.id.localeCompare(b.id));
+
+  const inflight_plans = plans.filter(p => PLAN_INFLIGHT.has(p.status)).length;
+  const inflight_standalone = standalone.filter(t => !TASK_TERMINAL.has(t.status)).length;
+  const delivered_plans = plans.filter(p => p.status === 'completed').length;
+  const delivered_standalone = standalone.filter(t => t.status === 'merged').length;
+
+  const can_auto_advance_rfc =
+    rfc.status === 'approved' &&
+    inflight_plans + inflight_standalone === 0 &&
+    delivered_plans + delivered_standalone > 0;
+
+  return {
+    rfc: { project: rfc.project, id: rfc.id, status: rfc.status },
+    plans,
+    standalone_tasks: standalone,
+    summary: {
+      inflight_plans,
+      inflight_standalone,
+      delivered_plans,
+      delivered_standalone,
+      can_auto_advance_rfc,
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloverleaf/reference-impl",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Reference implementation of the Cloverleaf methodology as Claude Code skills. Implements the Tight Loop (Implementer + Reviewer).",
   "type": "module",
   "license": "MIT",
@@ -40,6 +40,7 @@
     "cloverleaf-cli": "./dist/cli.mjs"
   },
   "scripts": {
+    "pretest": "node scripts/check-standard-prepped.mjs",
     "test": "tsc --noEmit && vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
@@ -48,7 +49,7 @@
     "prepublishOnly": "node scripts/check-standard-prepped.mjs && npm test && npm run build"
   },
   "dependencies": {
-    "@cloverleaf/standard": "^0.5.0",
+    "@cloverleaf/standard": "^0.6.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "axe-core": "^4.10.0",

package/skills/cloverleaf-new-task/SKILL.md

@@ -32,13 +32,23 @@ The user has invoked this skill with a brief. Your job: turn the brief into a st
      "owner": { "kind": "agent", "id": "implementer" },
      "project": "<project>",
      "title": "<concise title derived from brief>",
-     "context": {},
+     "context": <see "context.rfc injection" below>,
      "acceptance_criteria": ["<criterion 1>", "<criterion 2>", "..."],
      "definition_of_done": ["<terminal statement of completion>"],
      "risk_class": "low"
    }
    ```
 
+   **`context.rfc` injection:**
+
+   - If the brief includes `--rfc=<RFC-ID>` (e.g. `/cloverleaf-new-task --rfc=CLV-9 "Brief text..."`), read `<repo_root>/.cloverleaf/rfcs/<RFC-ID>.json` and inject the workItemRef shape:
+     ```json
+     "context": { "rfc": { "project": "<rfc-project-field>", "id": "<RFC-ID>" } }
+     ```
+     The `project` field comes from the loaded RFC document, NOT the task's own project (a task in project FOO may legitimately reference an RFC in project BAR).
+   - If `<repo_root>/.cloverleaf/rfcs/<RFC-ID>.json` does not exist, abort and ask the user to verify the RFC ID. Do not write the task file.
+   - If `--rfc=<ID>` is not passed, leave `context` as `{}` — same as pre-v0.7.4 behavior.
+
    Derive 2-5 acceptance criteria from the brief. Each must be verifiable. Derive one or more Definition of Done strings as an array.
 
 5. Write the file to `<repo_root>/.cloverleaf/tasks/<allocated-id>.json`.
@@ -65,6 +75,7 @@ The user has invoked this skill with a brief. Your job: turn the brief into a st
 ## Rules
 
 - Do not guess at acceptance criteria. If the brief is too vague (e.g., "make it faster" with no target), ask the user a clarifying question before writing the file.
+- **`--rfc=<ID>` flag:** When the brief includes `--rfc=<RFC-ID>`, the task's `context.rfc` is populated from the on-disk RFC document (see step 4). This is the canonical way to scaffold an **RFC-direct task** (no Plan parent, no `task_batch_gate`) — used for hotfixes after a Plan has delivered, or for incremental RFC progress without forming a Plan. The walker's RFC auto-advance treats RFC-direct tasks as first-class: an in-flight one blocks RFC completion; a merged one counts toward delivery. See `reference-impl/README.md` § "Plans vs RFC-direct tasks" for the full pattern docs and when to pick this over `/cloverleaf-discover`. If `--rfc` is omitted, `context` is left empty.
 - **risk_class inference:** `risk_class` determines the Delivery pipeline (`"low"` → fast lane; `"high"` → full pipeline). Rules:
   1. If the user passed `--risk=high` or `--risk=low` as a flag on the skill invocation, honor it.
   2. Otherwise, set `risk_class: "high"` when the brief OR any acceptance criterion matches (case-insensitive) any of these keywords:

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

@@ -280,7 +280,41 @@ description: Autonomous DAG walker for Cloverleaf Plans. Given a PLAN-ID in stat
    - `awaiting_final_gate: [ ... ]` — user said `n`; re-invoke `/cloverleaf-merge <TASK-ID>` to retry.
    - `unreachable: [ ... ]` — descendants of escalated tasks.
 
-   If every task in the plan's `task_dag.nodes` has `state: "merged"`, print: "✓ Plan `<PLAN-ID>` complete."
+   **Plan completion (Standard 0.6.0+).** If every task in the plan's `task_dag.nodes` has `state: "merged"` AND the Plan's on-disk `status` is `"approved"`, advance the Plan to `completed`:
+
+   ```bash
+   cloverleaf-cli advance-plan <repo_root> <PLAN-ID> completed agent
+   git -C <repo_root> add .cloverleaf/plans/<PLAN-ID>.json .cloverleaf/events/
+   git -C <repo_root> commit -m "cloverleaf: plan <PLAN-ID> completed (all tasks merged)"
+   ```
+
+   This closes the previous state-sync gap where Plans whose tasks were all merged stayed at `status: "approved"` indefinitely. Skip the advance if the Plan is already at `completed` (idempotent re-runs of `/cloverleaf-run-plan` on a fully-merged plan must not error). After the advance, print: "✓ Plan `<PLAN-ID>` completed (status advanced approved → completed)."
+
+   If not every task is merged (some escalated or awaiting), do NOT advance the Plan. Print the partial-completion report from the bullets above.
+
+   **RFC auto-advance (Standard 0.6.0+ + rfc-tasks 0.7.5+).** Immediately after the Plan-advance commit lands, ask `cloverleaf-cli rfc-tasks` whether the parent RFC can also advance to `completed`. The CLI considers BOTH sibling Plans AND RFC-direct (standalone) tasks under the same `parent_rfc` — an in-flight standalone task blocks the advance, a merged standalone task counts toward the at-least-one-delivered requirement.
+
+   ```bash
+   PARENT_RFC_ID=$(jq -r '.parent_rfc.id' <repo_root>/.cloverleaf/plans/<PLAN-ID>.json)
+
+   RFC_VIEW=$(cloverleaf-cli rfc-tasks <repo_root> "$PARENT_RFC_ID")
+   CAN_ADVANCE=$(echo "$RFC_VIEW" | jq -r '.summary.can_auto_advance_rfc')
+
+   if [ "$CAN_ADVANCE" = "true" ]; then
+     DELIVERED=$(echo "$RFC_VIEW" | jq -r '"\(.summary.delivered_plans) plans, \(.summary.delivered_standalone) standalone tasks"')
+     cloverleaf-cli advance-rfc <repo_root> "$PARENT_RFC_ID" completed agent
+     git -C <repo_root> add .cloverleaf/rfcs/"$PARENT_RFC_ID".json .cloverleaf/events/
+     git -C <repo_root> commit -m "cloverleaf: rfc $PARENT_RFC_ID completed ($DELIVERED delivered, 0 in-flight)"
+     echo "✓ RFC $PARENT_RFC_ID advanced approved → completed."
+   fi
+   ```
+
+   Skip conditions encoded in `can_auto_advance_rfc`:
+   - RFC is not at `approved` (already terminal, abandoned, or somehow still pre-approval).
+   - Any sibling Plan is in-flight (`drafting`, `gate-pending`, or `approved`) OR any standalone task is in a non-terminal state.
+   - No Plan reached `completed` AND no standalone task reached `merged` — the RFC has nothing delivered (e.g. all child Plans were rejected); operator must decide whether to abandon or re-decompose.
+
+   Idempotent: the `rfc.status === "approved"` guard inside `can_auto_advance_rfc` makes re-runs of `/cloverleaf-run-plan` against a fully-merged plan safe.
 
    ## Next steps (release publishing)
 
@@ -358,3 +392,5 @@ The concrete policy JSON is the same one used during the CLV-16..CLV-20 dogfood
 ## 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.
+
+**RFC-direct task participation in RFC auto-advance.** Tasks with no `parent` field but with `context.rfc` set (created via `/cloverleaf-new-task --rfc=<RFC-ID>`) are *first-class* participants in the `can_auto_advance_rfc` check. They block the advance when in-flight; they count toward delivery when merged. See `cloverleaf-cli rfc-tasks <repo_root> <RFC-ID>` for the categorized view this dispatch reads from, or `reference-impl/README.md` § "Plans vs RFC-direct tasks" for the user-facing pattern docs.