@cloverleaf/reference-impl 0.11.1 → 0.13.0

package/dist/council.mjs

@@ -3,10 +3,15 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadCouncilConfigWithSource } from './council-config.mjs';
 import { loadTask, saveTask, advanceStatus } from './task.mjs';
+import { loadPlan } from './plan.mjs';
+import { loadRfc } from './rfc.mjs';
 import { writeCouncilResult } from './council-result.mjs';
 import { resolveChairPrompt } from './chair.mjs';
 import { classifyTaskSecurity } from './security-classify.mjs';
+import { writeFeedback } from './feedback.mjs';
 import { loadAffectedRoutesConfig, computeAffectedRoutes } from './affected-routes.mjs';
+import { loadQaRulesDocument } from './qa-rules.mjs';
+import { loadUiReviewConfig } from './ui-review-config.mjs';
 import { getPluginRoot } from './plugin-path.mjs';
 export function evaluateWhen(predicate, ctx) {
     switch (predicate) {
@@ -50,12 +55,46 @@ export function resolveChangedFiles(repoRoot, taskId, opts = {}) {
         return [];
     }
 }
-const BUILTIN_PROMPTS = {
+/**
+ * The built-in council members and the shipped prompt each one resolves to.
+ * Exported as the single source of truth for "which members are built in":
+ * `tests/council.test.ts` walks it to assert every built-in prompt's declared
+ * tokens are covered by BASE_TOKENS ∪ MEMBER_TOKENS, so a prompt cannot gain a
+ * token that no one resolves.
+ */
+export const BUILTIN_PROMPTS = {
     reviewer: 'reviewer.md',
     security: 'security-reviewer.md',
     ui: 'ui-reviewer.md',
     qa: 'qa.md',
 };
+/**
+ * Council gate → FSM binding. `task.review` is the collapsed delivery council
+ * (decisive); `task.plan_review` is decisive-capable (agent bounce to pending);
+ * `task.final_gate` and the two discovery gates are advisory (post-only, human
+ * drives the transition). Advisory-only gates route to postAdvisoryVerdict.
+ */
+export const GATE_DESCRIPTORS = {
+    'task.review': { state: 'council', advisoryOnly: false },
+    'task.plan_review': { state: 'tactical-plan', advisoryOnly: false },
+    'task.final_gate': { state: 'final-gate', advisoryOnly: true },
+    'plan.task_batch': { state: 'task_batch_gate', advisoryOnly: true, kind: 'plan' },
+    'rfc.strategy_gate': { state: 'rfc_strategy_gate', advisoryOnly: true, kind: 'rfc' },
+};
+// Load any work item's status/doc by the gate's "type." prefix (task | plan | rfc).
+function workItemTypeOf(gate) {
+    const t = gate.split('.')[0];
+    if (t === 'task' || t === 'plan' || t === 'rfc')
+        return t;
+    throw new Error(`council: gate '${gate}' has no task/plan/rfc type prefix`);
+}
+function loadWorkItemDoc(repoRoot, type, id) {
+    if (type === 'plan')
+        return loadPlan(repoRoot, id);
+    if (type === 'rfc')
+        return loadRfc(repoRoot, id);
+    return loadTask(repoRoot, id);
+}
 /**
  * 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,
@@ -77,10 +116,86 @@ export function resolveMemberPrompt(member, repoRoot) {
     }
     return join(getPluginRoot(), 'prompts', builtin);
 }
-export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', opts = {}) {
+/**
+ * Extra tokens each built-in member's prompt declares, beyond the five the runner
+ * always supplies. Kept adjacent to the resolver so a prompt gaining a token is a
+ * one-line change in TS with a test behind it, rather than silent drift in skill prose.
+ *
+ * `preview_port` is listed because `ui-reviewer.md` genuinely declares it — but it is
+ * deliberately not resolved (see `resolveSubstitutions`). This map is the prompts'
+ * contract; the resolver is the subset planning can answer honestly.
+ *
+ * `tests/council.test.ts` pins this map against the prompts themselves: every
+ * `{{token}}` a built-in prompt declares must appear here or in BASE_TOKENS. That
+ * completeness check is what makes `cloverleaf-run` §7.2's "never dispatch with an
+ * unresolved token" rule safe — otherwise a prompt-only token stalls its member.
+ */
+export const MEMBER_TOKENS = {
+    reviewer: ['test_rules'],
+    security: [],
+    qa: ['qa_rules'],
+    ui: ['affected_routes', 'preview_port', 'ui_review_config', 'taskId'],
+};
+/**
+ * Resolve a member's extra prompt tokens. Side-effect free by contract: it reads
+ * config and reuses values the plan already computed, and never allocates, writes,
+ * or starts anything — `council-plan` is a query, and callers re-run it freely.
+ *
+ * A token that cannot be answered honestly at planning time is **omitted** rather
+ * than filled with a placeholder. An absent key leaves a visible `{{token}}` for
+ * whoever dispatches the member; a fabricated value is silently wrong, which is the
+ * exact failure mode this map exists to prevent.
+ */
+function resolveSubstitutions(memberId, repoRoot, ctx) {
+    const out = {};
+    for (const token of MEMBER_TOKENS[memberId] ?? []) {
+        switch (token) {
+            // Both carry the qa-rules *document* (`{ rules: [...] }`) — the shape
+            // reviewer.md and qa.md document — not loadQaRulesConfig()'s bare array.
+            case 'test_rules':
+            case 'qa_rules':
+                out[token] = JSON.stringify(loadQaRulesDocument(repoRoot));
+                break;
+            case 'ui_review_config':
+                out[token] = JSON.stringify(loadUiReviewConfig(repoRoot));
+                break;
+            case 'affected_routes':
+                // Diff-dependent, so available only on a code gate; the plan already
+                // computed it to evaluate the `ui_changes` predicate.
+                if (ctx.affectedRoutes !== undefined)
+                    out[token] = JSON.stringify(ctx.affectedRoutes);
+                break;
+            case 'taskId':
+                // The run-artifact directory ui-reviewer.md writes its state.json sidecar
+                // into. A pure value already in hand, so it is always resolved: leaving it
+                // literal makes lib/ui-review-state.ts read a path that cannot exist, and
+                // the baselines-hold then fails open.
+                out[token] = ctx.workItemId;
+                break;
+            case 'preview_port':
+                // Deliberately unresolved: there is no configured preview port and no
+                // side-effect-free way to derive one — lib/ports.ts offers only
+                // getFreePort(), which *allocates*. Whoever dispatches the ui member
+                // allocates it there, as the standalone ui-review skill does.
+                break;
+            default: {
+                // Exhaustiveness guard. A token added to MEMBER_TOKENS with no case above
+                // would otherwise be dropped silently — the exact drift this map exists to
+                // prevent — so make it a compile error instead.
+                const unhandled = token;
+                throw new Error(`council: no resolver for member token '${String(unhandled)}'`);
+            }
+        }
+    }
+    return out;
+}
+export function resolveCouncilPlan(repoRoot, workItemId, gateKey = 'task.review', opts = {}) {
     const { config, source } = loadCouncilConfigWithSource(repoRoot);
-    const task = loadTask(repoRoot, taskId);
-    const { profile: profileName, mode } = resolveBinding(config.gates[gateKey], task);
+    const type = workItemTypeOf(gateKey);
+    const doc = loadWorkItemDoc(repoRoot, type, workItemId);
+    const binding = resolveBinding(config.gates[gateKey], doc);
+    const profileName = binding.profile;
+    const mode = GATE_DESCRIPTORS[gateKey]?.advisoryOnly ? 'advisory' : binding.mode;
     const empty = {
         gate: gateKey, profile: null, mode, rounds: [],
         aggregation: 'any-veto', on_round_bounce: 'stop', source,
@@ -94,11 +209,17 @@ export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', op
         }
         return empty; // unknown profile → fail toward today's behavior
     }
-    const changed = resolveChangedFiles(repoRoot, taskId, opts);
-    const securityHigh = classifyTaskSecurity(repoRoot, taskId, { changedFiles: changed }).effective === 'high';
-    const affected = computeAffectedRoutes(changed, loadAffectedRoutesConfig(repoRoot));
-    const uiChanges = affected === 'all' || affected.length > 0;
-    const ctx = { securityHigh, uiChanges };
+    // The when-context (security/ui) is a code-kind (task delivery) concern only.
+    // `affectedRoutes` outlives the predicate: the ui member's {{affected_routes}}
+    // token is the same value, so it is computed once and threaded to both.
+    let ctx = { securityHigh: false, uiChanges: false };
+    let affectedRoutes;
+    if (type === 'task') {
+        const changed = resolveChangedFiles(repoRoot, workItemId, opts);
+        const securityHigh = classifyTaskSecurity(repoRoot, workItemId, { changedFiles: changed }).effective === 'high';
+        affectedRoutes = computeAffectedRoutes(changed, loadAffectedRoutesConfig(repoRoot));
+        ctx = { securityHigh, uiChanges: affectedRoutes === 'all' || affectedRoutes.length > 0 };
+    }
     const rounds = [];
     for (const round of profile.rounds) {
         const active = round
@@ -108,6 +229,7 @@ export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', op
             blocking: member.blocking !== false,
             weight: member.weight ?? 1,
             promptPath: resolveMemberPrompt(member, repoRoot),
+            substitutions: resolveSubstitutions(member.member, repoRoot, { workItemId, affectedRoutes }),
         }));
         if (active.length > 0)
             rounds.push(active);
@@ -128,23 +250,36 @@ export function resolveCouncilPlan(repoRoot, taskId, gateKey = 'task.review', op
 }
 /**
  * Drive the FSM transition implied by a council verdict (the runner's terminal step).
- * Council-authoritative: on a pass it records the council's gating verdict so the
- * v0.8.1 security precondition is satisfied for any high-security gated transition;
- * the per-member basis (incl. an omitted or out-voted `security` member) is written
- * to the result artifact. Walks the minimal legal path to the lane's pre-merge state.
+ * Routes by gate: `task.review` → the collapsed decisive delivery council; the
+ * decisive `task.plan_review` → the plan-review council; advisory-only gates
+ * (task.final_gate and the two discovery gates) → postAdvisoryVerdict, which
+ * records the verdict and drives no transition.
  */
-export function applyCouncilVerdict(repoRoot, taskId, gate, council) {
-    if (gate !== 'task.review') {
-        throw new Error(`apply-council-verdict: gate '${gate}' is not supported yet — the FSM walk is hardcoded for the ` +
-            `task.review → merge lane. Binding other gates needs a gate-aware walk (council Slice 3).`);
+export function applyCouncilVerdict(repoRoot, workItemId, gate, council) {
+    const desc = GATE_DESCRIPTORS[gate];
+    if (!desc) {
+        throw new Error(`apply-council-verdict: gate '${gate}' is not supported; supported gates: ${Object.keys(GATE_DESCRIPTORS).join(', ')}.`);
+    }
+    if (desc.advisoryOnly) {
+        return postAdvisoryVerdict(repoRoot, workItemId, gate, desc.state, council);
     }
+    if (gate === 'task.plan_review') {
+        return applyDecisivePlanReview(repoRoot, workItemId, gate, council);
+    }
+    return applyDeliveryCouncil(repoRoot, workItemId, gate, council); // task.review — collapsed council phase
+}
+/** Decisive delivery council (task.review at the collapsed `council` state). */
+function applyDeliveryCouncil(repoRoot, taskId, gate, council) {
     const task = loadTask(repoRoot, taskId);
-    if (task.status !== 'review') {
-        throw new Error(`apply-council-verdict: task ${taskId} is '${task.status}', expected 'review'`);
+    if (task.status !== 'council') {
+        throw new Error(`apply-council-verdict: task ${taskId} is '${task.status}', expected 'council'`);
     }
-    const lane = task.risk_class === 'high' ? 'full' : 'fast';
     const securityMember = council.members.find((m) => m.member === 'security');
-    const walk = ['review'];
+    const highSecurity = task.security_class === 'high';
+    // No security verdict to report? Ask the profile what it intended — before any
+    // transition mutates the task the gate binding selects a profile from.
+    const plannedSecurity = securityMember === undefined ? resolvePlannedSecurity(repoRoot, taskId, gate) : null;
+    const walk = ['council'];
     if (council.verdict === 'escalate') {
         advanceStatus(repoRoot, taskId, 'escalated', 'agent');
         walk.push('escalated');
@@ -154,42 +289,29 @@ export function applyCouncilVerdict(repoRoot, taskId, gate, council) {
         walk.push('implementing');
     }
     else {
-        // pass — minimal legal walk; review→automated-gates resets the security verdict,
-        // so set the council's gating verdict AFTER that transition.
-        advanceStatus(repoRoot, taskId, 'automated-gates', 'agent');
-        walk.push('automated-gates');
-        const atGates = loadTask(repoRoot, taskId);
-        atGates.security_review_verdict = 'pass';
-        saveTask(repoRoot, atGates);
-        if (lane === 'full') {
-            advanceStatus(repoRoot, taskId, 'qa', 'agent', { path: 'full_pipeline' });
-            walk.push('qa');
-            advanceStatus(repoRoot, taskId, 'final-gate', 'agent', { path: 'full_pipeline' });
-            walk.push('final-gate');
+        // pass → council → final-gate; record the council's authoritative security verdict for high tasks
+        // (the v0.8.1 guarantee's backstop, now that the FSM no longer enforces it mechanically).
+        advanceStatus(repoRoot, taskId, 'final-gate', 'agent');
+        walk.push('final-gate');
+        if (highSecurity) {
+            const atGate = loadTask(repoRoot, taskId);
+            atGate.security_review_verdict = 'pass';
+            saveTask(repoRoot, atGate);
         }
     }
-    const qaTraversedAdministratively = lane === 'full' && walk.includes('qa') && !council.members.some((m) => m.member === 'qa');
     const result = {
         gate,
         final_verdict: council.verdict,
         rule: council.rule,
         rationale: council.rationale,
-        members: council.members.map((m) => ({
-            member: m.member,
-            verdict: m.verdict,
-            blocking: m.blocking !== false,
-            weight: m.weight ?? 1,
-        })),
+        members: council.members.map((m) => ({ member: m.member, verdict: m.verdict, blocking: m.blocking !== false, weight: m.weight ?? 1 })),
         walk,
-        ...(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,
+            gating_verdict_set: council.verdict === 'pass' && highSecurity ? 'pass' : null,
             basis: !securityMember
-                ? 'no security member configured; advanced under council authority'
+                ? securityBasisWhenAbsent(plannedSecurity, council)
                 : securityMember.verdict === 'pass'
                     ? 'security member passed'
                     : `security member returned '${securityMember.verdict}'; council ${council.verdict} by rule ${JSON.stringify(council.rule)}`,
@@ -198,3 +320,163 @@ export function applyCouncilVerdict(repoRoot, taskId, gate, council) {
     writeCouncilResult(repoRoot, taskId, result);
     return result;
 }
+/**
+ * Resolve what the profile bound to `gate` planned for the `security` member on this task.
+ *
+ * `council.members` names only the members that actually *ran*, so a missing security
+ * verdict is ambiguous on its own. The resolved plan disambiguates it — with one honest
+ * limitation: `resolveCouncilPlan` filters `when`-inactive members out, so a member
+ * excluded by its `when` predicate and a profile that never listed one both come back
+ * `planned: false`. Both are truthfully "no security member for this task", so they share
+ * one basis string rather than a distinction this cannot actually make.
+ *
+ * Two deliberate properties:
+ * - Returns null rather than throwing. Plan resolution reads consumer config and can fail
+ *   on, say, a mistyped member id; an audit string is not worth failing a terminal apply
+ *   step over, and a run whose plan will not resolve says exactly that.
+ * - Called only when there is no security verdict to explain: for a task-kind gate
+ *   `resolveCouncilPlan` runs a `git diff`, so this adds one git invocation to the apply
+ *   path, and it should stay at most one.
+ */
+function resolvePlannedSecurity(repoRoot, taskId, gate) {
+    try {
+        const plan = resolveCouncilPlan(repoRoot, taskId, gate);
+        // Earliest occurrence wins: if a member is planned twice, the first round is the
+        // earliest point the council could have run it.
+        const memberRounds = new Map();
+        plan.rounds.forEach((round, index) => {
+            for (const m of round)
+                if (!memberRounds.has(m.member))
+                    memberRounds.set(m.member, index);
+        });
+        return {
+            securityRound: memberRounds.get('security') ?? null,
+            memberRounds,
+            stopsOnRoundBounce: plan.on_round_bounce === 'stop',
+        };
+    }
+    catch (err) {
+        process.stderr.write(`apply-council-verdict: could not resolve the council plan for gate '${gate}' on ${taskId} (${err instanceof Error ? err.message : String(err)}); the result artifact will record the security basis as unknown.\n`);
+        return null;
+    }
+}
+/**
+ * The `security.basis` for a run that recorded no security verdict. Each string states only
+ * what that run can prove, so a cause is named only when the run satisfies one of the
+ * council's two stop rules *in a round that could have preceded security's own*:
+ *
+ * - an `escalate` from any member stops the council immediately, so an escalator in an
+ *   earlier round — or in security's own round, cutting off a concurrently dispatched
+ *   member — explains the absence; one in a *later* round cannot, since that round ran only
+ *   because security's round completed;
+ * - a **blocking** `bounce` stops the council "before the next round" under
+ *   `on_round_bounce: stop`, so it explains the absence only from a *strictly earlier*
+ *   round. A same-round bounce cannot un-dispatch a member already running alongside it.
+ *
+ * Anything else — a non-blocking bounce, a stop rule that fired too late, a member the
+ * runner never dispatched or whose envelope was lost — leaves the absence unexplained, and
+ * the artifact says so rather than naming a cause that would point the auditor away from
+ * the real anomaly.
+ */
+function securityBasisWhenAbsent(planned, council) {
+    if (planned === null) {
+        return 'no security member ran; the council plan could not be resolved, so whether one was configured is unknown';
+    }
+    const securityRound = planned.securityRound;
+    if (securityRound === null) {
+        // Covers both a profile with no security member and one excluded by its `when`
+        // predicate — indistinguishable here, and the wording claims no more than that.
+        const outcome = council.verdict === 'bounce' ? 'council bounced to implementing'
+            : council.verdict === 'escalate' ? 'council escalated'
+                : 'advanced under council authority';
+        return `no security member in this task's resolved council plan; ${outcome}`;
+    }
+    // Did a stop rule fire in a round at/before `latestRound`? A member the plan does not
+    // name cannot be ordered against security's round, so it never explains the absence.
+    const stoppedBy = (verdict, latestRound, blockingOnly) => council.members.some((m) => {
+        const round = planned.memberRounds.get(m.member);
+        return m.verdict === verdict && round !== undefined && round <= latestRound && (!blockingOnly || m.blocking !== false);
+    });
+    if (stoppedBy('escalate', securityRound, false)) {
+        return 'security member configured for this task but not reached: another member escalated and the council short-circuited; no security verdict recorded';
+    }
+    if (planned.stopsOnRoundBounce && stoppedBy('bounce', securityRound - 1, true)) {
+        return "security member configured for this task but not reached: an earlier round's blocking member bounced and the profile stops on a round bounce; no security verdict recorded";
+    }
+    return 'security member configured for this task but did not run; no security verdict recorded';
+}
+/** Decisive plan-review council (task.plan_review at tactical-plan). */
+function applyDecisivePlanReview(repoRoot, taskId, gate, council) {
+    const task = loadTask(repoRoot, taskId);
+    if (task.status !== 'tactical-plan') {
+        throw new Error(`apply-council-verdict: task ${taskId} is '${task.status}', expected 'tactical-plan' for gate '${gate}'`);
+    }
+    const walk = ['tactical-plan'];
+    if (council.verdict === 'escalate') {
+        advanceStatus(repoRoot, taskId, 'escalated', 'agent');
+        walk.push('escalated');
+    }
+    else if (council.verdict === 'bounce') {
+        advanceStatus(repoRoot, taskId, 'pending', 'agent', { gate: 'per_task_plan_review' });
+        walk.push('pending');
+    }
+    else {
+        advanceStatus(repoRoot, taskId, 'implementing', 'agent');
+        walk.push('implementing');
+    }
+    const result = {
+        gate,
+        final_verdict: council.verdict,
+        rule: council.rule,
+        rationale: council.rationale,
+        members: council.members.map((m) => ({ member: m.member, verdict: m.verdict, blocking: m.blocking !== false, weight: m.weight ?? 1 })),
+        walk,
+        ...(council.forward !== undefined ? { forward: council.forward } : {}),
+    };
+    writeCouncilResult(repoRoot, taskId, result);
+    return result;
+}
+/**
+ * Advisory-gate terminal step: record the council verdict + post a feedback
+ * envelope, and drive NO transition — the human owns every transition at an
+ * advisory gate. The verdict (including an escalate) is recorded verbatim;
+ * because nothing is transitioned, the un-lowerable-escalate invariant holds
+ * trivially. Generalized over work-item kind: the gate's `type.` prefix selects
+ * task | plan | rfc. Used for task.final_gate (final-gate) and the discovery
+ * gates plan.task_batch (task_batch_gate) / rfc.strategy_gate (rfc_strategy_gate).
+ */
+export function postAdvisoryVerdict(repoRoot, workItemId, gate, expectedState, council) {
+    const type = workItemTypeOf(gate);
+    const status = String(loadWorkItemDoc(repoRoot, type, workItemId).status ?? '');
+    if (status !== expectedState) {
+        throw new Error(`apply-council-verdict: ${type} ${workItemId} is '${status}', expected '${expectedState}' for advisory gate '${gate}'`);
+    }
+    const m = workItemId.match(/^(.+)-(\d+)$/);
+    if (!m)
+        throw new Error(`apply-council-verdict: invalid work-item id '${workItemId}'`);
+    const project = m[1];
+    writeFeedback(repoRoot, {
+        project,
+        taskId: workItemId,
+        prefix: 'c',
+        envelope: { verdict: council.verdict, summary: council.rationale, findings: [] },
+    });
+    const result = {
+        gate,
+        mode: 'advisory',
+        final_verdict: council.verdict,
+        rule: council.rule,
+        rationale: council.rationale,
+        members: council.members.map((mm) => ({
+            member: mm.member,
+            verdict: mm.verdict,
+            blocking: mm.blocking !== false,
+            weight: mm.weight ?? 1,
+        })),
+        walk: [expectedState],
+        walk_note: 'advisory: verdict posted; human drives the transition',
+        ...(council.forward !== undefined ? { forward: council.forward } : {}),
+    };
+    writeCouncilResult(repoRoot, workItemId, result);
+    return result;
+}

package/dist/events.mjs

@@ -9,12 +9,7 @@ function actorObject(kind) {
     return { kind, id };
 }
 export function formatReason(opts) {
-    const parts = [];
-    if (opts.gate)
-        parts.push(`gate=${opts.gate}`);
-    if (opts.path)
-        parts.push(`path=${opts.path}`);
-    return parts.length > 0 ? parts.join('; ') : undefined;
+    return opts.gate ? `gate=${opts.gate}` : undefined;
 }
 /**
  * Emits a status-transition event to `.cloverleaf/events/`.
@@ -33,8 +28,8 @@ export function emitStatusTransition(repoRoot, params) {
     const seqStr = String(seq).padStart(3, '0');
     const filename = `${workItemId}-${seqStr}-status.json`;
     const filePath = join(eventsDir(repoRoot), filename);
-    // Build reason from gate and/or path if provided (schema only allows reason, not gate/path at top level).
-    const reason = formatReason({ gate: params.gate, path: params.path });
+    // Build reason from the gate if provided (the schema allows only `reason` at top level).
+    const reason = formatReason({ gate: params.gate });
     const doc = {
         event_id: randomUUID(),
         event_type: 'status_transition',

package/dist/ids.mjs

@@ -22,6 +22,13 @@ export function nextEventId(repoRoot, workItemId) {
     // simultaneously. A global per-project counter (the pre-v0.6 scheme) produced
     // filename collisions when the walker merged sibling feature branches. Per-work-item
     // scoping means each task's counter is independent; merges union cleanly.
+    //
+    // The `(\d+)` segment is load-bearing, not cosmetic: `.cloverleaf/events/` in
+    // long-lived repos also contains pre-v0.6 files named `<PROJECT>-<NNN>-status.json`
+    // (a global counter), whose names collide with the task-id namespace — e.g.
+    // `CLV-109-status.json` is the 109th project event, not an event for task CLV-109.
+    // Loosening this regex to a bare prefix match would fold unrelated tasks' history
+    // into a task's counter, including transitions through states retired in 0.8.0.
     const re = new RegExp(`^${escapeRegex(workItemId)}-(\\d+)-(status|gate)\\.json$`);
     const nums = readdirSync(dir)
         .map((f) => f.match(re))

package/dist/qa-rules.mjs

@@ -10,20 +10,36 @@ function loadDefaultRules() {
     const doc = JSON.parse(readFileSync(DEFAULT_CONFIG, 'utf-8'));
     return Array.isArray(doc.rules) ? doc.rules : [];
 }
-export function loadQaRulesConfig(repoRoot) {
+/**
+ * The qa-rules document in the shape the prompts consume it: the `{ rules: [...] }`
+ * object, not a bare array. `reviewer.md` ({{test_rules}}), `implementer.md`
+ * ({{test_rules}}) and `qa.md` ({{qa_rules}}) all document the token as an object —
+ * 0.10.1 shipped a fix precisely because `qa.md` had described it as an array, and an
+ * agent iterating a non-existent top-level array is the bug that fix closed. Callers
+ * substituting one of those tokens must stringify THIS, never `loadQaRulesConfig()`.
+ *
+ * Precedence matches what the standalone skills `cat`: the consumer's
+ * `.cloverleaf/config/qa-rules.json` when it exists and parses to a `rules` array,
+ * otherwise the packaged default.
+ */
+export function loadQaRulesDocument(repoRoot) {
     const consumerPath = join(repoRoot, '.cloverleaf', 'config', 'qa-rules.json');
     if (existsSync(consumerPath)) {
         try {
             const doc = JSON.parse(readFileSync(consumerPath, 'utf-8'));
             if (Array.isArray(doc.rules)) {
-                return doc.rules;
+                return { rules: doc.rules };
             }
         }
         catch {
             // fall through
         }
     }
-    return loadDefaultRules();
+    return { rules: loadDefaultRules() };
+}
+/** The rules array alone, for callers that select/execute commands rather than prompt with them. */
+export function loadQaRulesConfig(repoRoot) {
+    return loadQaRulesDocument(repoRoot).rules;
 }
 export function selectTestCommands(changedFiles, rules) {
     return rules.filter((rule) => matchesUiPaths(changedFiles, rule.match));

package/dist/task.mjs

@@ -27,9 +27,10 @@ export function advanceStatus(repoRoot, taskId, toStatus, actor, options = {}) {
     let task = loadTask(repoRoot, taskId);
     const from = task.status;
     const sm = loadStateMachine('task');
-    const targetTransition = sm.transitions.find((t) => t.from === from && t.to === toStatus);
-    // Security-gate writeback: classify the task's security and upgrade if needed.
-    if (targetTransition?.security_gate) {
+    // Security classification at council entry: a declared-low task whose diff touches a
+    // sensitive path is upgraded to security_class:high so the delivery council runs its
+    // blocking security member. (v0.8.0: replaces the retired security_gate FSM annotation.)
+    if (from === 'documenting' && toStatus === 'council') {
         let classification;
         try {
             classification = classifyTaskSecurity(repoRoot, taskId);
@@ -58,27 +59,19 @@ export function advanceStatus(repoRoot, taskId, toStatus, actor, options = {}) {
             task = { ...upgraded };
         }
     }
-    const riskClass = options.path === 'fast_lane' ? 'low'
-        : options.path === 'full_pipeline' ? 'high'
-            : (task.risk_class ?? 'low');
     const workItemForValidator = {
         type: 'task',
         id: task.id,
         project: task.project,
         status: task.status,
-        risk_class: riskClass,
+        risk_class: task.risk_class ?? 'low',
         security_class: task.security_class,
         security_review_verdict: task.security_review_verdict,
         context: { rfc: { project: task.project, id: task.id } },
         definition_of_done: task.definition_of_done,
         acceptance_criteria: task.acceptance_criteria,
     };
-    const resetsVerdict = targetTransition?.resets_security_verdict === true;
-    const proposed = {
-        ...task,
-        status: toStatus,
-        ...(resetsVerdict ? { security_review_verdict: null } : {}),
-    };
+    const proposed = { ...task, status: toStatus };
     advanceWorkItemStatus({
         repoRoot,
         workItemType: 'task',
@@ -92,18 +85,6 @@ export function advanceStatus(repoRoot, taskId, toStatus, actor, options = {}) {
         save: (p) => saveTask(repoRoot, p),
         proposed,
         gate: options.gate,
-        path: options.path,
     });
-    // After a successful status change + verdict reset, emit a single commit covering both.
-    if (resetsVerdict) {
-        const taskFilePath = join(tasksDir(repoRoot), `${taskId}.json`);
-        try {
-            execFileSync('git', ['-C', repoRoot, 'add', taskFilePath], { stdio: 'pipe' });
-            execFileSync('git', ['-C', repoRoot, 'commit', '-m', `cloverleaf: ${taskId} status ${from} → ${toStatus}; security_review_verdict → null (rework)`], { stdio: 'pipe' });
-        }
-        catch {
-            // No-op: commit is best-effort when running outside a git repo (e.g., test environments).
-        }
-    }
     return proposed;
 }

package/dist/work-item.mjs

@@ -10,8 +10,8 @@ export function loadStateMachine(type) {
     return JSON.parse(readFileSync(`${pkgDir}/state-machines/${type}.json`, 'utf-8'));
 }
 export function advanceWorkItemStatus(params) {
-    const { repoRoot, workItemType, project, id, from, to, actor, stateMachine, validateFixture, save, gate, path } = params;
-    const reason = formatReason({ gate, path });
+    const { repoRoot, workItemType, project, id, from, to, actor, stateMachine, validateFixture, save, gate } = params;
+    const reason = formatReason({ gate });
     const event = {
         event_id: randomUUID(),
         event_type: 'status_transition',
@@ -45,7 +45,6 @@ export function advanceWorkItemStatus(params) {
         to,
         actor,
         gate,
-        path,
     });
     try {
         save(params.proposed);