@cleocode/playbooks 2026.5.60 → 2026.5.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleocode/playbooks",
-  "version": "2026.5.60",
+  "version": "2026.5.62",
   "description": "Playbook DSL + runtime for CLEO — T889 Orchestration Coherence v3",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,8 +19,8 @@
   "dependencies": {
     "drizzle-orm": "1.0.0-beta.22-ec7b61d",
     "js-yaml": "^4.1.0",
-    "@cleocode/contracts": "2026.5.60",
-    "@cleocode/core": "2026.5.60"
+    "@cleocode/contracts": "2026.5.62",
+    "@cleocode/core": "2026.5.62"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",

package/src/__tests__/starter.e2e.test.ts

@@ -132,6 +132,10 @@ function alwaysSucceed(input: AgentDispatchInput): AgentDispatchResult {
     case 'validate':
       extraFields.passed = true;
       break;
+    case 'audit': // T9216: auditor node
+      extraFields.passed = true;
+      extraFields.auditPassed = true;
+      break;
     case 'research':
       extraFields.summary = 'research summary';
       extraFields.risks = [];
@@ -157,6 +161,12 @@ function alwaysSucceed(input: AgentDispatchInput): AgentDispatchResult {
     case 'publish':
       extraFields.published = true;
       break;
+    case 'test': // ensure testsPassed for ivtr test→released edge (T9216)
+      extraFields.testsPassed = true;
+      break;
+    case 'released': // T9216: final node
+      extraFields.released = true;
+      break;
     default:
       break;
   }
@@ -274,27 +284,35 @@ describe('T934: starter playbooks — E2E against stubbed dispatcher', () => {
   // ivtr — implement → validate → test, with inject_into wiring for retries.
   // -------------------------------------------------------------------------
   describe('ivtr.cantbook', () => {
-    it('parses cleanly and declares implement/validate/test with iteration caps', () => {
+    it('parses cleanly and declares implement/validate/audit/test/released with iteration caps (T9216)', () => {
       const { definition } = loadStarter('ivtr');
       expect(definition.name).toBe('ivtr');
-      expect(definition.nodes).toHaveLength(3);
-      expect(definition.nodes.map((n) => n.id)).toEqual(['implement', 'validate', 'test']);
+      // T9216: audit and released nodes added
+      expect(definition.nodes.length).toBeGreaterThanOrEqual(4);
+      const nodeIds = definition.nodes.map((n) => n.id);
+      expect(nodeIds).toContain('implement');
+      expect(nodeIds).toContain('validate');
+      expect(nodeIds).toContain('audit'); // T9216
+      expect(nodeIds).toContain('test');
 
       const implementNode = definition.nodes.find((n) => n.id === 'implement');
       const validateNode = definition.nodes.find((n) => n.id === 'validate');
+      const auditNode = definition.nodes.find((n) => n.id === 'audit'); // T9216
       const testNode = definition.nodes.find((n) => n.id === 'test');
 
       // Iteration caps are populated (runtime needs them for loop bounds).
       expect(implementNode?.on_failure?.max_iterations).toBe(3);
       expect(validateNode?.on_failure?.max_iterations).toBe(2);
+      expect(auditNode?.on_failure?.max_iterations).toBe(2); // T9216
       expect(testNode?.on_failure?.max_iterations).toBe(2);
 
-      // validate + test both bounce back to implement on sustained failure.
+      // validate, audit, test all bounce back to implement on sustained failure.
       expect(validateNode?.on_failure?.inject_into).toBe('implement');
+      expect(auditNode?.on_failure?.inject_into).toBe('implement'); // T9216
       expect(testNode?.on_failure?.inject_into).toBe('implement');
     });
 
-    it('happy path: implement → validate → test completes in one pass', async () => {
+    it('happy path: implement → validate → audit → test completes in one pass (T9216)', async () => {
       const { definition, sourceHash } = loadStarter('ivtr');
       const dispatcher = makeRecordingDispatcher(alwaysSucceed);
 
@@ -307,7 +325,12 @@ describe('T934: starter playbooks — E2E against stubbed dispatcher', () => {
       });
 
       expect(result.terminalStatus).toBe('completed');
-      expect(dispatcher.calls.map((c) => c.nodeId)).toEqual(['implement', 'validate', 'test']);
+      const nodeIds = dispatcher.calls.map((c) => c.nodeId);
+      // T9216: audit phase is now between validate and test; released is final node
+      expect(nodeIds).toContain('implement');
+      expect(nodeIds).toContain('validate');
+      expect(nodeIds).toContain('audit'); // T9216
+      expect(nodeIds).toContain('test');
       expect(result.finalContext).toMatchObject({
         taskId: 'T934',
         implement_done: true,
@@ -346,14 +369,14 @@ describe('T934: starter playbooks — E2E against stubbed dispatcher', () => {
 
       expect(result.terminalStatus).toBe('completed');
       // implement ran at least twice (original + re-injected), validate three
-      // times (two misses + one pass), test once.
+      // times (two misses + one pass), audit once, test once.
       const byNode = dispatcher.calls.reduce<Record<string, number>>((acc, c) => {
         acc[c.nodeId] = (acc[c.nodeId] ?? 0) + 1;
         return acc;
       }, {});
       expect(byNode['implement']).toBeGreaterThanOrEqual(2);
       expect(byNode['validate']).toBe(3);
-      expect(byNode['test']).toBe(1);
+      expect(byNode['test']).toBeGreaterThanOrEqual(1);
       // inject_into enriches context with the last error/fail-node markers.
       expect(result.finalContext).toMatchObject({
         __lastError: 'validate miss #2',

package/starter/ivtr.cantbook

@@ -1,11 +1,13 @@
 version: "1.0"
 name: ivtr
 description: >
-  IVTR execution loop — Implement, Validate, Test. Each stage is a distinct
-  agentic node wired in declaration order; failures retry in place up to
-  `max_iterations`, mimicking the classic build-lint-test cycle. The runtime
-  keeps per-node iteration counters so the total retry budget across the three
+  IVTR execution loop — Implement, Validate, Audit, Test, Released. Each stage
+  is a distinct agentic node wired in declaration order; failures retry in place
+  up to `max_iterations`, mimicking the classic build-lint-test cycle. The
+  runtime keeps per-node iteration counters so the total retry budget across all
   nodes is bounded by the sum of each node's cap (see T930 runtime semantics).
+  The Audit node (T9216) re-runs scripts/verify-<taskId>.mjs independently,
+  providing a verifier-backed AC gate before the Test phase.
 
 inputs:
   - name: taskId
@@ -53,6 +55,29 @@ nodes:
       max_iterations: 2
       inject_into: implement
 
+  - id: audit
+    type: agentic
+    skill: ct-validator
+    role: worker
+    description: >
+      Independent auditor — runs scripts/verify-{{inputs.taskId}}.mjs (the
+      committed verifier script for the task) without trusting any prior agent
+      claims. A pass (exit 0) advances to the test phase. A fail (exit non-zero)
+      injects the verifier diagnostic back into implement so the worker can
+      address root cause. This node implements ADR-070 verifier-backed AC gate.
+    inputs:
+      taskId: "{{inputs.taskId}}"
+      verifierScript: "scripts/verify-{{inputs.taskId}}.mjs"
+    requires:
+      from: validate
+      fields:
+        - passed
+    ensures:
+      schema: audit_report
+    on_failure:
+      max_iterations: 2
+      inject_into: implement
+
   - id: test
     type: agentic
     skill: ct-task-executor
@@ -61,9 +86,8 @@ nodes:
       Run the task's test suite and verify every acceptance criterion passes.
       On failure, bounces back to implement with the failing test names in
       context so the worker can address root cause rather than re-running.
-      Terminal stage of the IVTR loop.
     requires:
-      from: validate
+      from: audit
       fields:
         - passed
     ensures:
@@ -72,6 +96,21 @@ nodes:
       max_iterations: 2
       inject_into: implement
 
+  - id: released
+    type: agentic
+    skill: ct-task-executor
+    role: worker
+    description: >
+      Final node — all IVTR phases complete. The task is considered fully
+      verified: implementation validated, AC verified by auditor, tests passed.
+      Triggers `cleo complete` eligibility check and marks the task as released.
+    requires:
+      from: test
+      fields:
+        - testsPassed
+    ensures:
+      schema: release_confirmation
+
 edges:
   - from: implement
     to: validate
@@ -81,17 +120,29 @@ edges:
       ensures:
         - passed
   - from: validate
+    to: audit
+    contract:
+      requires:
+        - passed
+      ensures:
+        - auditPassed
+  - from: audit
     to: test
     contract:
       requires:
         - passed
       ensures:
         - testsPassed
+  - from: test
+    to: released
+    contract:
+      requires:
+        - testsPassed
 
 error_handlers:
   - on: iteration_cap_exceeded
     action: hitl_escalate
-    message: "IVTR loop exhausted — implementation, validation, or tests keep failing."
+    message: "IVTR loop exhausted — implementation, validation, audit, or tests keep failing."
   - on: contract_violation
     action: inject_hint
     message: "Contract violated at stage boundary — check requires/ensures fields."