@cloverleaf/reference-impl 0.10.1 → 0.11.1

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.10.0",
+  "version": "0.11.0",
   "author": {
     "name": "Renato D'Arrigo",
     "email": "renato.darrigo@gmail.com"

package/VERSION

@@ -1 +1 @@
-0.10.1
+0.11.1

package/dist/chair.mjs

@@ -0,0 +1,74 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { getPluginRoot } from './plugin-path.mjs';
+/**
+ * Resolve the chair prompt to an absolute path. A profile `chair.prompt` points at
+ * a custom prompt under <repoRoot>/.cloverleaf/prompts/ (exist-checked); omitted →
+ * the shipped built-in prompts/chair.md.
+ */
+export function resolveChairPrompt(chair, repoRoot) {
+    if (chair?.prompt !== undefined) {
+        const p = join(repoRoot, '.cloverleaf', 'prompts', chair.prompt);
+        if (!existsSync(p)) {
+            throw new Error(`council: chair prompt not found at ${p}`);
+        }
+        return p;
+    }
+    return join(getPluginRoot(), 'prompts', 'chair.md');
+}
+/**
+ * Render a readable deliberation packet from the member verdicts + their feedback
+ * envelopes (supplied inline by the orchestrator) for the chair prompt's
+ * {{member_verdicts}} placeholder. Pure — no disk read.
+ */
+export function buildChairContext(members) {
+    return members
+        .map((m) => {
+        const tags = [m.blocking === false ? 'advisory' : 'blocking', `weight ${m.weight ?? 1}`].join(', ');
+        const lines = [`### ${m.member} — ${m.verdict} (${tags})`];
+        if (m.envelope?.summary)
+            lines.push(m.envelope.summary);
+        for (const f of m.envelope?.findings ?? []) {
+            const loc = f.location?.file ? ` [${f.location.file}${f.location.line ? `:${f.location.line}` : ''}]` : '';
+            lines.push(`- (${f.severity ?? 'info'}) ${f.message ?? ''}${loc}`);
+        }
+        return lines.join('\n');
+    })
+        .join('\n\n');
+}
+/**
+ * Normalize the chair agent's raw output into a CouncilVerdict. Fail-closed on a
+ * malformed shape. Re-asserts the escalate invariant: a member `escalate` forces the
+ * council verdict to `escalate` regardless of the chair's output (the chair may raise
+ * a bounce to escalate but can never lower an escalate).
+ */
+export function finalizeChairVerdict(raw, members) {
+    const escalators = members.filter((m) => m.verdict === 'escalate');
+    if (escalators.length > 0) {
+        return {
+            verdict: 'escalate',
+            rule: 'chair',
+            members,
+            rationale: `escalated by ${escalators.map((m) => m.member).join(', ')} (chair cannot lower an escalate)`,
+        };
+    }
+    if (raw === null || typeof raw !== 'object') {
+        throw new Error('chair-verdict: chair output is not an object');
+    }
+    if (raw.verdict !== 'pass' && raw.verdict !== 'bounce' && raw.verdict !== 'escalate') {
+        throw new Error(`chair-verdict: invalid verdict '${String(raw.verdict)}'`);
+    }
+    const ids = new Set(members.map((m) => m.member));
+    const forward = (raw.forward ?? []).filter((f) => typeof f === 'string');
+    for (const f of forward) {
+        if (!ids.has(f))
+            throw new Error(`chair-verdict: forward names unknown member '${f}'`);
+    }
+    return {
+        verdict: raw.verdict,
+        rule: 'chair',
+        members,
+        rationale: typeof raw.rationale === 'string' ? raw.rationale : '',
+        ...(raw.verdict === 'bounce' ? { forward } : {}),
+    };
+}

package/dist/cli.mjs

@@ -45,6 +45,8 @@
  *   council-plan <repoRoot> <taskId> [gateKey] [--changed-files=a,b,c]
  *   aggregate-verdicts <membersJson> <rule> [--weighted-threshold=N]
  *   apply-council-verdict <repoRoot> <taskId> <gate> <councilVerdictJson>
+ *   chair-context <chairMemberInputsJson>
+ *   chair-verdict <chairRawJson> <membersJson>
  */
 import { readFileSync, mkdirSync, copyFileSync, appendFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
@@ -77,6 +79,7 @@ import { loadSecretPatternsConfig, scanSecrets } from './secret-scan.mjs';
 import { classifyTaskSecurity } from './security-classify.mjs';
 import { resolveCouncilPlan, applyCouncilVerdict } from './council.mjs';
 import { aggregate } from './aggregation.mjs';
+import { buildChairContext, finalizeChairVerdict } from './chair.mjs';
 function die(msg, code = 1) {
     process.stderr.write(msg + '\n');
     process.exit(code);
@@ -125,6 +128,8 @@ function usage(msg) {
         '  council-plan <repoRoot> <taskId> [gateKey] [--changed-files=a,b,c]\n' +
         '  aggregate-verdicts <membersJson> <rule> [--weighted-threshold=N]\n' +
         '  apply-council-verdict <repoRoot> <taskId> <gate> <councilVerdictJson>\n' +
+        '  chair-context <chairMemberInputsJson>\n' +
+        '  chair-verdict <chairRawJson> <membersJson>\n' +
         '  set-task-field <repoRoot> <taskId> <field> <value>\n');
     process.exit(2);
 }
@@ -860,6 +865,23 @@ try {
             process.stdout.write(JSON.stringify(result) + '\n');
             break;
         }
+        case 'chair-context': {
+            const [inputsJson] = rest;
+            if (!inputsJson)
+                usage('chair-context requires <chairMemberInputsJson>');
+            const inputs = JSON.parse(inputsJson);
+            process.stdout.write(buildChairContext(inputs) + '\n');
+            break;
+        }
+        case 'chair-verdict': {
+            const [rawJson, membersJson] = rest;
+            if (!rawJson || !membersJson)
+                usage('chair-verdict requires <chairRawJson> <membersJson>');
+            const raw = JSON.parse(rawJson);
+            const members = JSON.parse(membersJson);
+            process.stdout.write(JSON.stringify(finalizeChairVerdict(raw, members)) + '\n');
+            break;
+        }
         case 'set-task-field': {
             const [repoRoot, taskId, field, value] = rest;
             if (!repoRoot || !taskId || !field || value === undefined)

package/dist/council.mjs

@@ -1,9 +1,13 @@
 import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { loadCouncilConfigWithSource } from './council-config.mjs';
 import { loadTask, saveTask, advanceStatus } from './task.mjs';
 import { writeCouncilResult } from './council-result.mjs';
+import { resolveChairPrompt } from './chair.mjs';
 import { classifyTaskSecurity } from './security-classify.mjs';
 import { loadAffectedRoutesConfig, computeAffectedRoutes } from './affected-routes.mjs';
+import { getPluginRoot } from './plugin-path.mjs';
 export function evaluateWhen(predicate, ctx) {
     switch (predicate) {
         case undefined:
@@ -46,6 +50,33 @@ export function resolveChangedFiles(repoRoot, taskId, opts = {}) {
         return [];
     }
 }
+const BUILTIN_PROMPTS = {
+    reviewer: 'reviewer.md',
+    security: 'security-reviewer.md',
+    ui: 'ui-reviewer.md',
+    qa: 'qa.md',
+};
+/**
+ * Resolve a council member to the absolute path of its prompt. A member with a
+ * `prompt` field is a custom role → <repoRoot>/.cloverleaf/prompts/<file> (exist-checked,
+ * since it is user-authored and easily mistyped); a bare built-in id → the shipped prompt
+ * under the plugin root, deliberately NOT exist-checked (built-ins ship with the plugin, so
+ * a missing one is a broken install that surfaces at prompt read-time, not user error).
+ */
+export function resolveMemberPrompt(member, repoRoot) {
+    if (member.prompt !== undefined) {
+        const p = join(repoRoot, '.cloverleaf', 'prompts', member.prompt);
+        if (!existsSync(p)) {
+            throw new Error(`council: custom member '${member.member}' prompt not found at ${p}`);
+        }
+        return p;
+    }
+    const builtin = BUILTIN_PROMPTS[member.member];
+    if (builtin === undefined) {
+        throw new Error(`council: unknown member '${member.member}' (no built-in prompt and no 'prompt' field)`);
+    }
+    return join(getPluginRoot(), 'prompts', builtin);
+}
 export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', opts = {}) {
     const { config, source } = loadCouncilConfigWithSource(repoRoot);
     const task = loadTask(repoRoot, taskId);
@@ -72,11 +103,16 @@ export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', op
     for (const round of profile.rounds) {
         const active = round
             .filter((member) => evaluateWhen(member.when, ctx))
-            .map((member) => ({ member: member.member, blocking: member.blocking !== false, weight: member.weight ?? 1 }));
+            .map((member) => ({
+            member: member.member,
+            blocking: member.blocking !== false,
+            weight: member.weight ?? 1,
+            promptPath: resolveMemberPrompt(member, repoRoot),
+        }));
         if (active.length > 0)
             rounds.push(active);
     }
-    return {
+    const plan = {
         gate: gateKey,
         profile: profileName,
         mode,
@@ -85,6 +121,10 @@ export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', op
         on_round_bounce: profile.on_round_bounce ?? 'stop',
         source,
     };
+    if (profile.aggregation === 'chair') {
+        plan.chair = { promptPath: resolveChairPrompt(profile.chair, repoRoot) };
+    }
+    return plan;
 }
 /**
  * Drive the FSM transition implied by a council verdict (the runner's terminal step).
@@ -144,6 +184,7 @@ export function applyCouncilVerdict(repoRoot, taskId, gate, council) {
         ...(qaTraversedAdministratively
             ? { walk_note: 'qa state traversed administratively; no qa member ran' }
             : {}),
+        ...(council.forward !== undefined ? { forward: council.forward } : {}),
         security: {
             member_verdict: securityMember ? securityMember.verdict : 'absent',
             gating_verdict_set: council.verdict === 'pass' ? 'pass' : null,

package/lib/aggregation.ts

@@ -16,9 +16,10 @@ export interface MemberVerdict {
 
 export interface CouncilVerdict {
   verdict: Verdict;
-  rule: ThresholdRule;
+  rule: ThresholdRule | 'chair';
   rationale: string;
   members: MemberVerdict[];
+  forward?: string[]; // chair-curated member ids to forward to the Implementer (bounce only)
 }
 
 export function aggregate(

package/lib/chair.ts

@@ -0,0 +1,94 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { getPluginRoot } from './plugin-path.js';
+import type { Verdict } from './feedback.js';
+import type { MemberVerdict, CouncilVerdict } from './aggregation.js';
+
+export interface ChairRawVerdict {
+  verdict: Verdict;
+  rationale: string;
+  forward?: string[]; // member ids whose feedback to forward (bounce only)
+}
+
+export interface ChairMemberInput {
+  member: string;
+  verdict: Verdict;
+  blocking?: boolean;
+  weight?: number;
+  envelope?: {
+    summary?: string;
+    findings?: Array<{ severity?: string; message?: string; location?: { file?: string; line?: number } }>;
+  };
+}
+
+/**
+ * Resolve the chair prompt to an absolute path. A profile `chair.prompt` points at
+ * a custom prompt under <repoRoot>/.cloverleaf/prompts/ (exist-checked); omitted →
+ * the shipped built-in prompts/chair.md.
+ */
+export function resolveChairPrompt(chair: { prompt?: string } | undefined, repoRoot: string): string {
+  if (chair?.prompt !== undefined) {
+    const p = join(repoRoot, '.cloverleaf', 'prompts', chair.prompt);
+    if (!existsSync(p)) {
+      throw new Error(`council: chair prompt not found at ${p}`);
+    }
+    return p;
+  }
+  return join(getPluginRoot(), 'prompts', 'chair.md');
+}
+
+/**
+ * Render a readable deliberation packet from the member verdicts + their feedback
+ * envelopes (supplied inline by the orchestrator) for the chair prompt's
+ * {{member_verdicts}} placeholder. Pure — no disk read.
+ */
+export function buildChairContext(members: ChairMemberInput[]): string {
+  return members
+    .map((m) => {
+      const tags = [m.blocking === false ? 'advisory' : 'blocking', `weight ${m.weight ?? 1}`].join(', ');
+      const lines: string[] = [`### ${m.member} — ${m.verdict} (${tags})`];
+      if (m.envelope?.summary) lines.push(m.envelope.summary);
+      for (const f of m.envelope?.findings ?? []) {
+        const loc = f.location?.file ? ` [${f.location.file}${f.location.line ? `:${f.location.line}` : ''}]` : '';
+        lines.push(`- (${f.severity ?? 'info'}) ${f.message ?? ''}${loc}`);
+      }
+      return lines.join('\n');
+    })
+    .join('\n\n');
+}
+
+/**
+ * Normalize the chair agent's raw output into a CouncilVerdict. Fail-closed on a
+ * malformed shape. Re-asserts the escalate invariant: a member `escalate` forces the
+ * council verdict to `escalate` regardless of the chair's output (the chair may raise
+ * a bounce to escalate but can never lower an escalate).
+ */
+export function finalizeChairVerdict(raw: ChairRawVerdict, members: MemberVerdict[]): CouncilVerdict {
+  const escalators = members.filter((m) => m.verdict === 'escalate');
+  if (escalators.length > 0) {
+    return {
+      verdict: 'escalate',
+      rule: 'chair',
+      members,
+      rationale: `escalated by ${escalators.map((m) => m.member).join(', ')} (chair cannot lower an escalate)`,
+    };
+  }
+  if (raw === null || typeof raw !== 'object') {
+    throw new Error('chair-verdict: chair output is not an object');
+  }
+  if (raw.verdict !== 'pass' && raw.verdict !== 'bounce' && raw.verdict !== 'escalate') {
+    throw new Error(`chair-verdict: invalid verdict '${String(raw.verdict)}'`);
+  }
+  const ids = new Set(members.map((m) => m.member));
+  const forward = (raw.forward ?? []).filter((f): f is string => typeof f === 'string');
+  for (const f of forward) {
+    if (!ids.has(f)) throw new Error(`chair-verdict: forward names unknown member '${f}'`);
+  }
+  return {
+    verdict: raw.verdict,
+    rule: 'chair',
+    members,
+    rationale: typeof raw.rationale === 'string' ? raw.rationale : '',
+    ...(raw.verdict === 'bounce' ? { forward } : {}),
+  };
+}

package/lib/cli.ts

@@ -45,6 +45,8 @@
  *   council-plan <repoRoot> <taskId> [gateKey] [--changed-files=a,b,c]
  *   aggregate-verdicts <membersJson> <rule> [--weighted-threshold=N]
  *   apply-council-verdict <repoRoot> <taskId> <gate> <councilVerdictJson>
+ *   chair-context <chairMemberInputsJson>
+ *   chair-verdict <chairRawJson> <membersJson>
  */
 
 import { readFileSync, mkdirSync, copyFileSync, appendFileSync, existsSync } from 'node:fs';
@@ -80,6 +82,7 @@ import { loadSecretPatternsConfig, scanSecrets } from './secret-scan.js';
 import { classifyTaskSecurity } from './security-classify.js';
 import { resolveCouncilPlan, applyCouncilVerdict } from './council.js';
 import { aggregate, type MemberVerdict, type ThresholdRule, type CouncilVerdict } from './aggregation.js';
+import { buildChairContext, finalizeChairVerdict, type ChairMemberInput, type ChairRawVerdict } from './chair.js';
 
 function die(msg: string, code = 1): never {
   process.stderr.write(msg + '\n');
@@ -130,6 +133,8 @@ function usage(msg?: string): never {
       '  council-plan <repoRoot> <taskId> [gateKey] [--changed-files=a,b,c]\n' +
       '  aggregate-verdicts <membersJson> <rule> [--weighted-threshold=N]\n' +
       '  apply-council-verdict <repoRoot> <taskId> <gate> <councilVerdictJson>\n' +
+      '  chair-context <chairMemberInputsJson>\n' +
+      '  chair-verdict <chairRawJson> <membersJson>\n' +
       '  set-task-field <repoRoot> <taskId> <field> <value>\n'
   );
   process.exit(2);
@@ -884,6 +889,23 @@ try {
       break;
     }
 
+    case 'chair-context': {
+      const [inputsJson] = rest;
+      if (!inputsJson) usage('chair-context requires <chairMemberInputsJson>');
+      const inputs = JSON.parse(inputsJson) as ChairMemberInput[];
+      process.stdout.write(buildChairContext(inputs) + '\n');
+      break;
+    }
+
+    case 'chair-verdict': {
+      const [rawJson, membersJson] = rest;
+      if (!rawJson || !membersJson) usage('chair-verdict requires <chairRawJson> <membersJson>');
+      const raw = JSON.parse(rawJson) as ChairRawVerdict;
+      const members = JSON.parse(membersJson) as MemberVerdict[];
+      process.stdout.write(JSON.stringify(finalizeChairVerdict(raw, members)) + '\n');
+      break;
+    }
+
     case 'set-task-field': {
       const [repoRoot, taskId, field, value] = rest;
       if (!repoRoot || !taskId || !field || value === undefined)

package/lib/council-config.ts

@@ -9,7 +9,8 @@ const DEFAULT_CONFIG = join(here, '..', 'config', 'council.json');
 export type WhenPredicate = 'always' | 'security_class:high' | 'ui_changes';
 
 export interface CouncilMember {
-  member: string; // built-in id: 'reviewer' | 'security' | 'ui' | 'qa'
+  member: string; // built-in id ('reviewer' | 'security' | 'ui' | 'qa') or a custom role id
+  prompt?: string; // custom-role prompt filename, resolved under .cloverleaf/prompts/
   when?: WhenPredicate; // default 'always'
   blocking?: boolean; // default true
   weight?: number; // default 1
@@ -17,7 +18,8 @@ export interface CouncilMember {
 
 export interface CouncilProfile {
   rounds: CouncilMember[][];
-  aggregation: ThresholdRule;
+  aggregation: ThresholdRule | 'chair';
+  chair?: { prompt?: string }; // only when aggregation === 'chair'; omit prompt → built-in chair.md
   on_round_bounce?: 'stop' | 'continue'; // default 'stop'
 }
 

package/lib/council-result.ts

@@ -14,11 +14,12 @@ export interface CouncilResultMember {
 export interface CouncilResult {
   gate: string;
   final_verdict: Verdict;
-  rule: ThresholdRule;
+  rule: ThresholdRule | 'chair';
   rationale: string;
   members: CouncilResultMember[];
   walk: string[]; // states walked, e.g. ["review","automated-gates","qa","final-gate"]
   walk_note?: string; // set when a state was traversed administratively (e.g. qa with no qa member)
+  forward?: string[]; // chair-curated forwarded member ids (bounce only)
   security: {
     member_verdict: Verdict | 'absent';
     gating_verdict_set: 'pass' | null; // security_review_verdict the council set, if any

package/lib/council.ts

@@ -1,15 +1,20 @@
 import { execFileSync } from 'node:child_process';
-import { loadCouncilConfigWithSource, type CouncilConfig, type GateBinding, type WhenPredicate } from './council-config.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadCouncilConfigWithSource, type CouncilConfig, type GateBinding, type WhenPredicate, type CouncilMember } from './council-config.js';
 import type { ThresholdRule, CouncilVerdict } from './aggregation.js';
 import { loadTask, saveTask, advanceStatus } from './task.js';
 import { writeCouncilResult, type CouncilResult } from './council-result.js';
+import { resolveChairPrompt } from './chair.js';
 import { classifyTaskSecurity } from './security-classify.js';
 import { loadAffectedRoutesConfig, computeAffectedRoutes } from './affected-routes.js';
+import { getPluginRoot } from './plugin-path.js';
 
 export interface ResolvedMember {
   member: string;
   blocking: boolean;
   weight: number;
+  promptPath: string;
 }
 
 export interface CouncilPlan {
@@ -17,7 +22,8 @@ export interface CouncilPlan {
   profile: string | null; // null → no council bound (today's behavior)
   mode: 'decisive' | 'advisory';
   rounds: ResolvedMember[][];
-  aggregation: ThresholdRule;
+  aggregation: ThresholdRule | 'chair';
+  chair?: { promptPath: string }; // resolved iff aggregation === 'chair'
   on_round_bounce: 'stop' | 'continue';
   source: 'consumer' | 'default';
 }
@@ -70,6 +76,35 @@ export function resolveChangedFiles(repoRoot: string, taskId: string, opts: { ch
   }
 }
 
+const BUILTIN_PROMPTS: Record<string, string> = {
+  reviewer: 'reviewer.md',
+  security: 'security-reviewer.md',
+  ui: 'ui-reviewer.md',
+  qa: 'qa.md',
+};
+
+/**
+ * Resolve a council member to the absolute path of its prompt. A member with a
+ * `prompt` field is a custom role → <repoRoot>/.cloverleaf/prompts/<file> (exist-checked,
+ * since it is user-authored and easily mistyped); a bare built-in id → the shipped prompt
+ * under the plugin root, deliberately NOT exist-checked (built-ins ship with the plugin, so
+ * a missing one is a broken install that surfaces at prompt read-time, not user error).
+ */
+export function resolveMemberPrompt(member: CouncilMember, repoRoot: string): string {
+  if (member.prompt !== undefined) {
+    const p = join(repoRoot, '.cloverleaf', 'prompts', member.prompt);
+    if (!existsSync(p)) {
+      throw new Error(`council: custom member '${member.member}' prompt not found at ${p}`);
+    }
+    return p;
+  }
+  const builtin = BUILTIN_PROMPTS[member.member];
+  if (builtin === undefined) {
+    throw new Error(`council: unknown member '${member.member}' (no built-in prompt and no 'prompt' field)`);
+  }
+  return join(getPluginRoot(), 'prompts', builtin);
+}
+
 export function resolveCouncilPlan(
   repoRoot: string,
   taskId: string,
@@ -106,11 +141,16 @@ export function resolveCouncilPlan(
   for (const round of profile.rounds) {
     const active = round
       .filter((member) => evaluateWhen(member.when, ctx))
-      .map((member) => ({ member: member.member, blocking: member.blocking !== false, weight: member.weight ?? 1 }));
+      .map((member) => ({
+        member: member.member,
+        blocking: member.blocking !== false,
+        weight: member.weight ?? 1,
+        promptPath: resolveMemberPrompt(member, repoRoot),
+      }));
     if (active.length > 0) rounds.push(active);
   }
 
-  return {
+  const plan: CouncilPlan = {
     gate: gateKey,
     profile: profileName,
     mode,
@@ -119,6 +159,10 @@ export function resolveCouncilPlan(
     on_round_bounce: profile.on_round_bounce ?? 'stop',
     source,
   };
+  if (profile.aggregation === 'chair') {
+    plan.chair = { promptPath: resolveChairPrompt(profile.chair, repoRoot) };
+  }
+  return plan;
 }
 
 /**
@@ -188,6 +232,7 @@ export function applyCouncilVerdict(
     ...(qaTraversedAdministratively
       ? { walk_note: 'qa state traversed administratively; no qa member ran' }
       : {}),
+    ...(council.forward !== undefined ? { forward: council.forward } : {}),
     security: {
       member_verdict: securityMember ? securityMember.verdict : 'absent',
       gating_verdict_set: council.verdict === 'pass' ? 'pass' : null,

package/package.json

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

package/prompts/chair.md

@@ -0,0 +1,43 @@
+# Chair Subagent
+
+You are the Cloverleaf Council Chair. Your job: read every council member's verdict and feedback and render the **council's** verdict on this task's review gate. You judge the members' verdicts — you do NOT review the code yourself.
+
+## Inputs
+
+- `task`: the Cloverleaf Task document (JSON): {{task}}
+- `repo_root`: absolute path to the consumer repo: {{repo_root}}
+- `member_verdicts`: each council member's verdict, severity, and feedback (summary + findings). This is your evidence:
+
+{{member_verdicts}}
+
+## Your process
+
+1. Read the task's `acceptance_criteria` and `definition_of_done` for context.
+2. Weigh each member's verdict and findings. A member may have bounced on a non-substantive issue, or several members may point at the same underlying defect.
+3. Decide the council verdict:
+   - `pass` — the members' concerns, taken together, do not warrant rework (e.g. a lone stylistic bounce).
+   - `bounce` — the branch needs rework. Choose which members' feedback the Implementer should act on.
+   - `escalate` — a hard blocker needs a human. You may **raise a bounce to escalate**; you can **never lower an escalate** — a member escalation is already final and never reaches you.
+4. On a `bounce`, set `forward` to the ids of the members whose feedback the Implementer should prioritize. Forwarding fewer, higher-signal members beats forwarding all of them. Your `rationale` frames what to fix.
+
+## Output
+
+Return a single JSON object to stdout:
+
+```json
+{
+  "verdict": "pass" | "bounce" | "escalate",
+  "rationale": "Why the council reached this verdict, and (on a bounce) what the Implementer should focus on.",
+  "forward": ["security", "qa"]
+}
+```
+
+- `forward` is only meaningful on a `bounce`; use `[]` (or omit) on `pass` / `escalate`.
+- Every `forward` id MUST be a member present in the input above.
+
+## Rules
+
+- You review **verdicts, not code**. Do not open a diff or run tests; judge the members' reports.
+- Do NOT modify any files. You are read-only.
+- Each council member emits a `{verdict, summary, findings}` feedback envelope; an unparseable envelope has already been rejected by the orchestrator, so you can trust the envelopes you receive.
+- Prefer a smaller, higher-signal `forward` set — the Implementer acts on what you forward.

package/prompts/implementer.md

@@ -24,7 +24,7 @@ You are the Cloverleaf Implementer agent. Your job: take a Task and produce work
 
    **Scope nudge.** Your declared scope is `task.scope.files_touched`. You may freely modify any file listed there. If you discover during implementation that you need to touch a file outside that list, you may do so only if no sibling task in the same Plan declares that file — the walker auto-extends your scope on merge. If a file you need is already declared by a sibling task, that is a contested modification: stop, surface the conflict to the human, and do not merge. The walker enforces this at merge time and will refuse contested merges; auto-resolution is never attempted.
 
-2. If `feedback` is present, re-read each finding; plan how to address them.
+2. If `feedback` is present, re-read each finding; plan how to address them. If the prior bounce came from a chair council (`.cloverleaf/runs/<task.id>/council/task.review.json` has `rule: "chair"`), prioritize the members listed in its `forward` array and the chair's `rationale`.
 3. Create a new branch named `cloverleaf/<task.id>` from `base_branch` using `git checkout -b cloverleaf/<task.id>`.
 4. Implement the code + tests needed to satisfy every acceptance criterion.
 5. Run the project's tests. Your test rules are provided as `{{test_rules}}` — a JSON object `{ rules: [...] }` whose `rules` is a list of `{cwd, match, command}` entries; each `match` is a list of glob patterns. For each rule whose `match` covers a file you changed, run its `command` in its `cwd`. All must pass. (If no rule matches your changes, there is nothing to run.)

package/skills/cloverleaf-run/SKILL.md

@@ -130,19 +130,20 @@ Initialize `council_bounces = 0`.
 
 7.1 **Produce the branch.** Run the Implementer (`/cloverleaf-implement <TASK-ID>` steps); for `risk_class: "high"` also run the Documenter (`/cloverleaf-document <TASK-ID>` steps). The task reaches `review`.
 
-7.2 **Run the council members (verdict-only).** Re-run `cloverleaf-cli council-plan <repo_root> <TASK-ID> task.review` to get `plan.rounds`, `plan.aggregation`, `plan.on_round_bounce`. For each round **in order**, for each member in the round, dispatch the member's prompt as a **read-only** subagent and capture its `{verdict, summary, findings}` envelope — do **not** advance state:
-   - `reviewer` → `prompts/reviewer.md`, feedback prefix `r`
-   - `security` → `prompts/security-reviewer.md`, prefix `s`
-   - `ui` → `prompts/ui-reviewer.md`, prefix `u`
-   - `qa` → `prompts/qa.md`, prefix `q`
+7.2 **Run the council members (verdict-only).** Re-run `cloverleaf-cli council-plan <repo_root> <TASK-ID> task.review` to get `plan.rounds`, `plan.aggregation`, `plan.on_round_bounce`, and (for a chair profile) `plan.chair`. For each round **in order**, for each active member in the round, dispatch its prompt at `plan.rounds[<round>][<member>].promptPath` as a **read-only** subagent and capture its `{verdict, summary, findings}` envelope — do **not** advance state. (Built-in members resolve to the shipped `reviewer`/`security-reviewer`/`ui-reviewer`/`qa` prompts; a custom role resolves to `.cloverleaf/prompts/<file>.md`.)
 
    **Dispatch conventions:** invoke the Task tool in foreground (default — never `run_in_background`); do not poll with foreground `sleep`. Substitute `{{task}}`, `{{branch}}` (`cloverleaf/<TASK-ID>`), `{{base_branch}}` (`main`), `{{repo_root}}`, `{{diff}}` (`git diff main..cloverleaf/<TASK-ID> -- ':(exclude).cloverleaf/'`).
 
-   Persist each member's envelope: `echo '<envelope>' > /tmp/clv-council-<member>.json && cloverleaf-cli write-feedback <repo_root> <TASK-ID> /tmp/clv-council-<member>.json --prefix=<r|s|u|q>`. Collect a members array `[{ "member": "<id>", "verdict": "<pass|bounce|escalate>", "blocking": <plan member blocking>, "weight": <plan member weight> }]`.
+   Persist each member's envelope: `echo '<envelope>' > /tmp/clv-council-<member>.json && cloverleaf-cli write-feedback <repo_root> <TASK-ID> /tmp/clv-council-<member>.json --prefix=<prefix>`, where `<prefix>` is `r`/`s`/`u`/`q` for the built-ins and the **member id** for a custom role. Collect a members array `[{ "member": "<id>", "verdict": "<pass|bounce|escalate>", "blocking": <plan member blocking>, "weight": <plan member weight> }]`.
 
    **Short-circuit:** if any member returns `escalate`, stop immediately. Otherwise, after each round, if `plan.on_round_bounce === "stop"` and any **blocking** member in that round returned `bounce`, stop before the next round. Always finish the members already running in the current round (batched).
 
-7.3 **Aggregate.** Map `plan.aggregation` to the CLI rule argument: a string passes through; `{ "quorum": k }` → `quorum:k`. Run `cloverleaf-cli aggregate-verdicts '<members-json>' <rule>` and capture the council verdict JSON.
+7.3 **Reach the council verdict.**
+   - **If `plan.aggregation === "chair"`:**
+     - If **any member returned `escalate`**, the council verdict is `{"verdict":"escalate","rule":"chair","rationale":"escalated by <escalating member ids>","members":[<members array>]}` — do **not** dispatch the chair (a member escalate is final; the chair may raise a bounce to escalate but can never lower one).
+     - Else if **no blocking member bounced and none escalated** (all blocking members passed), the council verdict is `{"verdict":"pass","rule":"chair","rationale":"all blocking members passed; chair not convened","members":[<members array>],"forward":[]}` — do **not** dispatch the chair.
+     - Otherwise (a blocking member bounced; no member escalated) **dispatch the chair.** Build enriched inputs `[{ "member", "verdict", "blocking", "weight", "envelope": <the member's /tmp/clv-council-<member>.json object> }]`; run `context=$(cloverleaf-cli chair-context '<enriched-inputs-json>')`. Dispatch the chair prompt at `plan.chair.promptPath` as a **read-only** foreground subagent, substituting `{{task}}`, `{{repo_root}}`, and `{{member_verdicts}}` = `$context`; capture its `{verdict, rationale, forward}` output. Then run `cloverleaf-cli chair-verdict '<chair-raw-json>' '<members-json>'` and capture the council verdict JSON.
+   - **Else (deterministic):** map `plan.aggregation` to the CLI rule (a string passes through; `{ "quorum": k }` → `quorum:k`) and run `cloverleaf-cli aggregate-verdicts '<members-json>' <rule>`; capture the council verdict JSON.
 
 7.4 **Apply.** Run `cloverleaf-cli apply-council-verdict <repo_root> <TASK-ID> task.review '<council-verdict-json>'`. The FSM walk may self-commit some transitions (e.g. `security_class → high`, the rework verdict-reset), so the wrap-up commit can find nothing staged — that is expected. Commit the remainder: `git add .cloverleaf/ && (git diff --cached --quiet || git commit -m "cloverleaf: <TASK-ID> council review (<verdict>)")`.
 
@@ -151,7 +152,7 @@ Initialize `council_bounces = 0`.
    - `implementing` (bounce) → `council_bounces += 1`. If `council_bounces >= 3`, escalate (section 6). Else return to 7.1.
    - `escalated` → stop and surface to the user (review `.cloverleaf/feedback/` and `.cloverleaf/runs/<TASK-ID>/council/task.review.json`).
 
-The council result artifact at `.cloverleaf/runs/<TASK-ID>/council/task.review.json` records per-member verdicts, the aggregate, and the security basis (incl. an omitted or out-voted `security` member). On any member-dispatch failure or unparseable envelope, stop and report — never treat a failed member as a pass.
+On a chair **bounce**, the result artifact's `forward` array names the members whose feedback the Implementer should prioritize; the chair `rationale` frames them. The council result artifact at `.cloverleaf/runs/<TASK-ID>/council/task.review.json` records per-member verdicts, the aggregate (or chair) verdict, `forward` (for a chair bounce), and the security basis (incl. an omitted or out-voted `security` member). On any member-dispatch failure or unparseable envelope, stop and report — never treat a failed member as a pass.
 
 ## Rules