@cloverleaf/reference-impl 0.7.4 → 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.7.4",
+  "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.7.4
+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.4",
+  "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",

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

@@ -75,7 +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). Use this when scaffolding a standalone task linked to an RFC without a Plan parent — e.g., a hotfix-task pattern off an open RFC, as practiced by claw-crypto's CC-43/44 and CC-045..052. If `--rfc` is omitted, `context` is left empty; the task can be attached to a Plan later via Plan formation, or `context.rfc` can be edited in by hand.
+- **`--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

@@ -292,36 +292,29 @@ description: Autonomous DAG walker for Cloverleaf Plans. Given a PLAN-ID in stat
 
    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+).** Immediately after the Plan-advance commit lands, check whether the parent RFC can also advance to `completed`. Read the just-completed plan's `parent_rfc` (project + id), then scan all sibling plans of that RFC:
+   **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_PROJECT=$(jq -r '.parent_rfc.project' <repo_root>/.cloverleaf/plans/<PLAN-ID>.json)
    PARENT_RFC_ID=$(jq -r '.parent_rfc.id' <repo_root>/.cloverleaf/plans/<PLAN-ID>.json)
-   RFC_STATUS=$(jq -r '.status' <repo_root>/.cloverleaf/rfcs/"$PARENT_RFC_ID".json)
 
-   # Count sibling Plans still in-flight (drafting, gate-pending, or approved)
-   INFLIGHT=$(jq -s --arg proj "$PARENT_RFC_PROJECT" --arg id "$PARENT_RFC_ID" \
-     '[.[] | select(.parent_rfc.project == $proj and .parent_rfc.id == $id and (.status == "drafting" or .status == "gate-pending" or .status == "approved"))] | length' \
-     <repo_root>/.cloverleaf/plans/*.json)
+   RFC_VIEW=$(cloverleaf-cli rfc-tasks <repo_root> "$PARENT_RFC_ID")
+   CAN_ADVANCE=$(echo "$RFC_VIEW" | jq -r '.summary.can_auto_advance_rfc')
 
-   # Count sibling Plans in completed (need at least one to advance)
-   COMPLETED=$(jq -s --arg proj "$PARENT_RFC_PROJECT" --arg id "$PARENT_RFC_ID" \
-     '[.[] | select(.parent_rfc.project == $proj and .parent_rfc.id == $id and .status == "completed")] | length' \
-     <repo_root>/.cloverleaf/plans/*.json)
-
-   if [ "$RFC_STATUS" = "approved" ] && [ "$INFLIGHT" = "0" ] && [ "$COMPLETED" != "0" ]; then
+   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 ($COMPLETED sibling plans completed, 0 in-flight)"
+     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
    ```
 
-   Auto-advance rules in plain language:
-   - Skip entirely if the RFC's `status` is not `approved` (already terminal, already abandoned, or somehow still pre-approval — leave it).
-   - Skip if any sibling Plan is still in-flight (`drafting`, `gate-pending`, or `approved`) — more work is pending on this RFC.
-   - Skip if no sibling Plan is `completed` (all `rejected`) — the RFC's decomposition was uniformly rejected; operator must decide whether to abandon or re-decompose.
-   - Otherwise advance the RFC to `completed`. Idempotent: the status guard makes re-runs safe.
+   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)
 
@@ -399,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.