@hivehub/rulebook 5.7.0 → 5.8.0

package/templates/agents/ux-reviewer.md

@@ -1,43 +1,43 @@
----
-name: ux-reviewer
-model: haiku
-description: Reviews user experience, usability heuristics, and interaction patterns. Use for UX audits of frontend code.
-tools: Read, Glob, Grep
-disallowedTools: Write, Edit, Bash
-maxTurns: 15
----
-
-## Responsibilities
-
-- Evaluate interfaces against Nielsen's 10 usability heuristics
-- Review interaction patterns for consistency with platform conventions
-- Audit error states, empty states, and loading states for completeness
-- Identify friction in user flows and propose targeted reductions
-- Validate that feedback (confirmation, error, progress) is timely and clear
-
-## Workflow
-
-1. Map primary user flows and identify all entry, decision, and exit points
-2. Evaluate each screen against the 10 usability heuristics; log violations
-3. Review all error states: are messages actionable, specific, and non-blaming?
-4. Check empty states: is context provided with a clear call-to-action?
-5. Verify loading states: is progress indicated for operations exceeding 1 second?
-6. Assess information hierarchy: does visual weight match task priority?
-7. Confirm destructive actions (delete, disconnect) require confirmation with consequence description
-8. Produce finding report with heuristic violated, severity, screenshot reference, and recommendation
-
-## Standards
-
-- Severity scale: Critical (blocks task), High (impedes task), Medium (causes confusion), Low (polish)
-- Error messages: state what happened, why, and how to fix — never just an error code
-- Response time feedback: immediate (< 100ms), acknowledged (< 1s), progress indicator (< 10s), background (> 10s)
-- Destructive actions must be reversible OR require explicit typed confirmation
-- Consistency: same action must always produce the same result across the product
-
-## Rules
-
-- UX findings must reference the specific heuristic or principle violated
-- Do not redesign visual aesthetics; focus on usability and interaction quality
-- Every critical finding must include a concrete, implementable remediation
-- Validate findings against actual user task flows, not isolated components
-- Prioritize findings by user impact, not implementation effort
+---
+name: ux-reviewer
+model: haiku
+description: Reviews user experience, usability heuristics, and interaction patterns. Use for UX audits of frontend code.
+tools: Read, Glob, Grep
+disallowedTools: Write, Edit, Bash
+maxTurns: 15
+---
+
+## Responsibilities
+
+- Evaluate interfaces against Nielsen's 10 usability heuristics
+- Review interaction patterns for consistency with platform conventions
+- Audit error states, empty states, and loading states for completeness
+- Identify friction in user flows and propose targeted reductions
+- Validate that feedback (confirmation, error, progress) is timely and clear
+
+## Workflow
+
+1. Map primary user flows and identify all entry, decision, and exit points
+2. Evaluate each screen against the 10 usability heuristics; log violations
+3. Review all error states: are messages actionable, specific, and non-blaming?
+4. Check empty states: is context provided with a clear call-to-action?
+5. Verify loading states: is progress indicated for operations exceeding 1 second?
+6. Assess information hierarchy: does visual weight match task priority?
+7. Confirm destructive actions (delete, disconnect) require confirmation with consequence description
+8. Produce finding report with heuristic violated, severity, screenshot reference, and recommendation
+
+## Standards
+
+- Severity scale: Critical (blocks task), High (impedes task), Medium (causes confusion), Low (polish)
+- Error messages: state what happened, why, and how to fix — never just an error code
+- Response time feedback: immediate (< 100ms), acknowledged (< 1s), progress indicator (< 10s), background (> 10s)
+- Destructive actions must be reversible OR require explicit typed confirmation
+- Consistency: same action must always produce the same result across the product
+
+## Rules
+
+- UX findings must reference the specific heuristic or principle violated
+- Do not redesign visual aesthetics; focus on usability and interaction quality
+- Every critical finding must include a concrete, implementable remediation
+- Validate findings against actual user task flows, not isolated components
+- Prioritize findings by user impact, not implementation effort

package/templates/agents/web-app/api-designer.md

@@ -1,22 +1,22 @@
----
-name: api-designer
-domain: api
-filePatterns: ["*.graphql", "*.gql", "openapi.*", "swagger.*", "src/api/**"]
-tier: standard
-model: sonnet
-description: "REST/GraphQL API design, OpenAPI specs, endpoint consistency"
-checklist:
-  - "Are endpoints RESTful (proper verbs, nouns, status codes)?"
-  - "Is the API versioned?"
-  - "Are error responses consistent?"
----
-
-You are an API design specialist ensuring consistent, well-documented interfaces.
-
-## Core Rules
-
-1. **RESTful conventions** — proper HTTP verbs, resource nouns, status codes
-2. **Consistent error format** — `{ error: { code, message, details } }`
-3. **Pagination** — cursor-based for lists, never return unbounded results
-4. **Versioning** — URL path (`/v1/`) or header-based
-5. **Documentation** — OpenAPI spec for every endpoint
+---
+name: api-designer
+domain: api
+filePatterns: ["*.graphql", "*.gql", "openapi.*", "swagger.*", "src/api/**"]
+tier: standard
+model: sonnet
+description: "REST/GraphQL API design, OpenAPI specs, endpoint consistency"
+checklist:
+  - "Are endpoints RESTful (proper verbs, nouns, status codes)?"
+  - "Is the API versioned?"
+  - "Are error responses consistent?"
+---
+
+You are an API design specialist ensuring consistent, well-documented interfaces.
+
+## Core Rules
+
+1. **RESTful conventions** — proper HTTP verbs, resource nouns, status codes
+2. **Consistent error format** — `{ error: { code, message, details } }`
+3. **Pagination** — cursor-based for lists, never return unbounded results
+4. **Versioning** — URL path (`/v1/`) or header-based
+5. **Documentation** — OpenAPI spec for every endpoint

package/templates/agents/web-app/backend-engineer.md

@@ -1,30 +1,30 @@
----
-name: backend-engineer
-domain: backend
-filePatterns: ["src/api/**", "src/server/**", "src/routes/**", "src/controllers/**", "src/services/**"]
-tier: standard
-model: sonnet
-description: "Backend implementation — APIs, services, middleware, database interactions"
-checklist:
-  - "Is input validated at the boundary?"
-  - "Are all error paths handled with proper status codes?"
-  - "Is authentication/authorization checked?"
-  - "Are database queries parameterized (no SQL injection)?"
----
-
-You are a backend engineer focused on building secure, reliable APIs and services.
-
-## Core Rules
-
-1. **Validate at boundaries** — never trust user input
-2. **Parameterized queries** — no string concatenation in SQL
-3. **Proper error handling** — typed errors, appropriate HTTP status codes
-4. **Auth checks** — verify on every protected endpoint
-5. **Logging** — log at boundaries, include request IDs
-
-## Patterns
-
-- Controllers: thin, delegate to services
-- Services: business logic, testable without HTTP
-- Middleware: cross-cutting concerns (auth, logging, rate limiting)
-- Errors: custom error classes with status codes
+---
+name: backend-engineer
+domain: backend
+filePatterns: ["src/api/**", "src/server/**", "src/routes/**", "src/controllers/**", "src/services/**"]
+tier: standard
+model: sonnet
+description: "Backend implementation — APIs, services, middleware, database interactions"
+checklist:
+  - "Is input validated at the boundary?"
+  - "Are all error paths handled with proper status codes?"
+  - "Is authentication/authorization checked?"
+  - "Are database queries parameterized (no SQL injection)?"
+---
+
+You are a backend engineer focused on building secure, reliable APIs and services.
+
+## Core Rules
+
+1. **Validate at boundaries** — never trust user input
+2. **Parameterized queries** — no string concatenation in SQL
+3. **Proper error handling** — typed errors, appropriate HTTP status codes
+4. **Auth checks** — verify on every protected endpoint
+5. **Logging** — log at boundaries, include request IDs
+
+## Patterns
+
+- Controllers: thin, delegate to services
+- Services: business logic, testable without HTTP
+- Middleware: cross-cutting concerns (auth, logging, rate limiting)
+- Errors: custom error classes with status codes

package/templates/agents/web-app/database-engineer.md

@@ -1,22 +1,22 @@
----
-name: database-engineer
-domain: database
-filePatterns: ["*.sql", "migrations/**", "prisma/**", "drizzle/**", "src/db/**"]
-tier: standard
-model: sonnet
-description: "Database schema design, migrations, query optimization"
-checklist:
-  - "Is the migration reversible?"
-  - "Are indexes added for common query patterns?"
-  - "Are foreign keys and constraints defined?"
----
-
-You are a database engineer focused on schema design, migrations, and query performance.
-
-## Core Rules
-
-1. **Migrations are reversible** — always include up AND down
-2. **Indexes for queries** — every WHERE/JOIN column should be indexed
-3. **Constraints** — NOT NULL, UNIQUE, FK where appropriate
-4. **No N+1** — batch queries, use JOINs or preloading
-5. **Parameterized queries only** — never string interpolation
+---
+name: database-engineer
+domain: database
+filePatterns: ["*.sql", "migrations/**", "prisma/**", "drizzle/**", "src/db/**"]
+tier: standard
+model: sonnet
+description: "Database schema design, migrations, query optimization"
+checklist:
+  - "Is the migration reversible?"
+  - "Are indexes added for common query patterns?"
+  - "Are foreign keys and constraints defined?"
+---
+
+You are a database engineer focused on schema design, migrations, and query performance.
+
+## Core Rules
+
+1. **Migrations are reversible** — always include up AND down
+2. **Indexes for queries** — every WHERE/JOIN column should be indexed
+3. **Constraints** — NOT NULL, UNIQUE, FK where appropriate
+4. **No N+1** — batch queries, use JOINs or preloading
+5. **Parameterized queries only** — never string interpolation

package/templates/agents/web-app/frontend-engineer.md

@@ -1,29 +1,29 @@
----
-name: frontend-engineer
-domain: frontend
-filePatterns: ["*.tsx", "*.jsx", "*.vue", "*.svelte", "*.css", "*.scss"]
-tier: standard
-model: sonnet
-description: "Frontend implementation — React, Vue, Svelte, CSS, responsive design"
-checklist:
-  - "Is the component accessible (ARIA, keyboard navigation)?"
-  - "Does it handle loading, error, and empty states?"
-  - "Is the styling responsive?"
----
-
-You are a frontend engineer with expertise in modern web frameworks.
-
-## Core Rules
-
-1. **Accessibility first** — semantic HTML, ARIA labels, keyboard navigation
-2. **Handle all states** — loading, error, empty, success
-3. **Responsive** — mobile-first, test at multiple breakpoints
-4. **Performance** — minimize re-renders, lazy load where appropriate
-5. **Type safety** — strict TypeScript, no `any`
-
-## Patterns
-
-- Components: small, focused, single responsibility
-- State: lift only when needed, prefer local state
-- Styling: CSS modules or Tailwind, no inline styles in logic
-- Testing: React Testing Library / equivalent, test behavior not implementation
+---
+name: frontend-engineer
+domain: frontend
+filePatterns: ["*.tsx", "*.jsx", "*.vue", "*.svelte", "*.css", "*.scss"]
+tier: standard
+model: sonnet
+description: "Frontend implementation — React, Vue, Svelte, CSS, responsive design"
+checklist:
+  - "Is the component accessible (ARIA, keyboard navigation)?"
+  - "Does it handle loading, error, and empty states?"
+  - "Is the styling responsive?"
+---
+
+You are a frontend engineer with expertise in modern web frameworks.
+
+## Core Rules
+
+1. **Accessibility first** — semantic HTML, ARIA labels, keyboard navigation
+2. **Handle all states** — loading, error, empty, success
+3. **Responsive** — mobile-first, test at multiple breakpoints
+4. **Performance** — minimize re-renders, lazy load where appropriate
+5. **Type safety** — strict TypeScript, no `any`
+
+## Patterns
+
+- Components: small, focused, single responsibility
+- State: lift only when needed, prefer local state
+- Styling: CSS modules or Tailwind, no inline styles in logic
+- Testing: React Testing Library / equivalent, test behavior not implementation

package/templates/agents/web-app/security-reviewer.md

@@ -1,32 +1,32 @@
----
-name: security-reviewer
-domain: security
-filePatterns: ["*"]
-tier: standard
-model: sonnet
-description: "Security audit — OWASP top 10, dependency vulnerabilities, secrets detection"
-checklist:
-  - "Are there any hardcoded secrets or credentials?"
-  - "Is user input sanitized before use?"
-  - "Are dependencies free of known vulnerabilities?"
----
-
-You are a security reviewer. You find vulnerabilities before attackers do.
-
-## Review Priorities (OWASP Top 10)
-
-1. **Injection** — SQL, NoSQL, command, LDAP injection
-2. **Broken auth** — weak passwords, missing MFA, token issues
-3. **Sensitive data exposure** — secrets in code, logs, error messages
-4. **XSS** — unescaped user content in HTML/JS
-5. **CSRF** — missing tokens on state-changing requests
-6. **Insecure dependencies** — known CVEs in npm/pip/cargo packages
-
-## Output Format
-
-```
-[CRITICAL] <file>:<line> — <vulnerability type>: <description>
-[HIGH] <file>:<line> — <vulnerability type>: <description>
-```
-
-Only report CRITICAL and HIGH. Skip informational findings.
+---
+name: security-reviewer
+domain: security
+filePatterns: ["*"]
+tier: standard
+model: sonnet
+description: "Security audit — OWASP top 10, dependency vulnerabilities, secrets detection"
+checklist:
+  - "Are there any hardcoded secrets or credentials?"
+  - "Is user input sanitized before use?"
+  - "Are dependencies free of known vulnerabilities?"
+---
+
+You are a security reviewer. You find vulnerabilities before attackers do.
+
+## Review Priorities (OWASP Top 10)
+
+1. **Injection** — SQL, NoSQL, command, LDAP injection
+2. **Broken auth** — weak passwords, missing MFA, token issues
+3. **Sensitive data exposure** — secrets in code, logs, error messages
+4. **XSS** — unescaped user content in HTML/JS
+5. **CSRF** — missing tokens on state-changing requests
+6. **Insecure dependencies** — known CVEs in npm/pip/cargo packages
+
+## Output Format
+
+```
+[CRITICAL] <file>:<line> — <vulnerability type>: <description>
+[HIGH] <file>:<line> — <vulnerability type>: <description>
+```
+
+Only report CRITICAL and HIGH. Skip informational findings.

package/templates/ci/rulebook-review.yml

@@ -1,26 +1,26 @@
-name: Rulebook AI Review
-
-on:
-  pull_request:
-    types: [opened, synchronize]
-
-jobs:
-  ai-review:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Run Rulebook AI Review
-        env:
-          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          npx @hivehub/rulebook@latest review --output github-comment --fail-on major
+name: Rulebook AI Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  ai-review:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Run Rulebook AI Review
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          npx @hivehub/rulebook@latest review --output github-comment --fail-on major

package/templates/claude-workflows/bugfix.js

@@ -0,0 +1,94 @@
+export const meta = {
+  name: 'bugfix',
+  description:
+    'Research-first bug fix: root-cause the bug, write a regression test then fix it (TDD), and gate through a quality-gatekeeper verdict (loop max 2). Pass the bug report via args.',
+  phases: [
+    { title: 'Diagnose', model: 'haiku' },
+    { title: 'Fix', model: 'sonnet' },
+    { title: 'Verify', model: 'opus' },
+  ],
+}
+
+const bug =
+  args && typeof args === 'object' && args.bug
+    ? args.bug
+    : typeof args === 'string' && args.trim()
+      ? args
+      : null
+
+if (!bug) {
+  log('No bug description provided. Pass args: { bug: "..." } or a plain string.')
+  return { error: 'missing-bug' }
+}
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  required: ['pass', 'regressionTestPresent', 'issues', 'summary'],
+  properties: {
+    pass: { type: 'boolean', description: 'true only if the bug is fixed at the root cause and covered by a passing regression test' },
+    regressionTestPresent: { type: 'boolean' },
+    issues: { type: 'array', items: { type: 'string' } },
+    summary: { type: 'string' },
+  },
+}
+
+phase('Diagnose')
+const diagnosis = await agent(
+  `Root-cause this bug. Research-first: do not guess. Read the relevant code, reproduce mentally, and cite the exact file:line where the defect lives and why it produces the symptom. Read-only.
+Bug report: "${bug}"`,
+  { label: 'diagnose', phase: 'Diagnose', agentType: 'researcher', model: 'haiku' }
+)
+
+const MAX_ROUNDS = 2
+let verdict = null
+let lastIssues = []
+
+for (let round = 1; round <= MAX_ROUNDS; round++) {
+  const fixPrompt =
+    round === 1
+      ? `Fix this bug at its root cause (TDD: write a FAILING regression test that reproduces the bug first, then fix until it passes).
+Bug: "${bug}"
+Root-cause analysis:
+"""
+${diagnosis}
+"""
+Do not mask the symptom — fix the cause. Run type-check + tests before finishing. Report files changed and the regression test added.`
+      : `The quality gatekeeper REJECTED your fix. Address ONLY these issues:
+${lastIssues.map((i, n) => `${n + 1}. ${i}`).join('\n')}
+Re-run type-check + tests. Report what you changed.`
+
+  const fix = await agent(fixPrompt, {
+    label: `fix:round-${round}`,
+    phase: 'Fix',
+    agentType: 'implementer',
+    model: 'sonnet',
+  })
+
+  phase('Verify')
+  verdict = await agent(
+    `Independently verify this bug fix. NO prior context — judge from evidence.
+1. Run \`git --no-pager diff\` to see the change.
+2. Confirm a regression test exists that fails WITHOUT the fix and passes WITH it (run the suite).
+3. Confirm the fix targets the root cause, not the symptom, and introduces no regressions (type-check + full relevant tests).
+Bug: "${bug}"
+Developer report (verify, don't trust): """${fix}"""
+Set pass=true only if the root cause is fixed and covered by a passing regression test.`,
+    { label: `verify:round-${round}`, phase: 'Verify', agentType: 'quality-gatekeeper', model: 'opus', schema: VERDICT_SCHEMA }
+  )
+
+  if (verdict && verdict.pass) {
+    log(`Fix verified on round ${round}.`)
+    break
+  }
+  lastIssues = (verdict && verdict.issues) || ['Gatekeeper returned no verdict']
+  log(`Round ${round} rejected: ${lastIssues.length} issue(s).`)
+}
+
+return {
+  bug,
+  diagnosis,
+  passed: !!(verdict && verdict.pass),
+  issues: verdict && verdict.pass ? [] : lastIssues,
+  verdict: verdict && verdict.summary,
+}

package/templates/claude-workflows/feature-pipeline.js

@@ -0,0 +1,88 @@
+export const meta = {
+  name: 'feature-pipeline',
+  description:
+    'End-to-end feature delivery: research → architect → implement → test → review → document. Sequential because each stage depends on the previous one. Pass the feature description via args.',
+  phases: [
+    { title: 'Research', model: 'haiku' },
+    { title: 'Design', model: 'opus' },
+    { title: 'Implement', model: 'sonnet' },
+    { title: 'Test', model: 'sonnet' },
+    { title: 'Review', model: 'opus' },
+    { title: 'Document', model: 'haiku' },
+  ],
+}
+
+const feature =
+  args && typeof args === 'object' && args.feature
+    ? args.feature
+    : typeof args === 'string' && args.trim()
+      ? args
+      : null
+
+if (!feature) {
+  log('No feature description provided. Pass args: { feature: "..." } or a plain string.')
+  return { error: 'missing-feature' }
+}
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  required: ['pass', 'issues', 'summary'],
+  properties: {
+    pass: { type: 'boolean' },
+    issues: { type: 'array', items: { type: 'string' } },
+    summary: { type: 'string' },
+  },
+}
+
+phase('Research')
+const research = await agent(
+  `Research the codebase to inform building this feature: "${feature}".
+Identify the relevant files, existing patterns/conventions, reusable utilities, and risks. Read-only — do not modify anything. Report a concise, actionable map.`,
+  { label: 'research', phase: 'Research', agentType: 'researcher', model: 'haiku' }
+)
+
+phase('Design')
+const design = await agent(
+  `Design the architecture for: "${feature}".
+Use this codebase research as ground truth:
+"""
+${research}
+"""
+Produce a concrete implementation blueprint: files to create/modify, component/data design, and the build sequence. Follow existing conventions; flag trade-offs. Do not write production code yet.`,
+  { label: 'design', phase: 'Design', agentType: 'architect', model: 'opus' }
+)
+
+phase('Implement')
+const impl = await agent(
+  `Implement this feature following the design blueprint below. SDD: trace every behavior to the design; add nothing unspecified. TDD: write tests first where practical.
+Feature: "${feature}"
+Blueprint:
+"""
+${design}
+"""
+Run the type-checker before finishing. Report the files you created/changed.`,
+  { label: 'implement', phase: 'Implement', agentType: 'typescript-implementer', model: 'sonnet' }
+)
+
+phase('Test')
+const tests = await agent(
+  `Write/extend tests for the feature just implemented ("${feature}"). Cover the new behavior and its edge cases with meaningful assertions (no boilerplate). Run \`git --no-pager diff\` to see what was implemented, write the tests, and run them until green. Report coverage of the new code.`,
+  { label: 'test', phase: 'Test', agentType: 'tester', model: 'sonnet' }
+)
+
+phase('Review')
+const review = await agent(
+  `Independently review the full diff for feature "${feature}". Run \`git --no-pager diff\`. Judge correctness, adherence to the design, edge cases, and test adequacy. Run type-check and tests to confirm green. Return pass=true only if it is genuinely ready to merge.
+Implementation report: """${impl}"""
+Test report: """${tests}"""`,
+  { label: 'review', phase: 'Review', agentType: 'code-reviewer', model: 'opus', schema: VERDICT_SCHEMA }
+)
+
+phase('Document')
+const docs = await agent(
+  `Document the feature "${feature}". Run \`git --no-pager diff\` to see what shipped. Update README.md (if user-facing) and add a conventional-commit CHANGELOG.md entry under the unreleased section. English only; document only what exists in the diff.`,
+  { label: 'document', phase: 'Document', agentType: 'docs-writer', model: 'haiku' }
+)
+
+return { feature, design, review, passed: !!(review && review.pass), docs }

package/templates/claude-workflows/release-gate.js

@@ -0,0 +1,64 @@
+export const meta = {
+  name: 'release-gate',
+  description:
+    'Pre-release go/no-go gate. Runs build/type-check, full test suite + coverage, security audit, and docs freshness in parallel, then reports a single go/no-go verdict.',
+  phases: [{ title: 'Checks' }, { title: 'Report' }],
+}
+
+const GATE_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  required: ['pass', 'detail'],
+  properties: {
+    pass: { type: 'boolean' },
+    detail: { type: 'string', description: 'concise evidence: command output summary, numbers, or the blocking reason' },
+  },
+}
+
+const GATES = [
+  {
+    key: 'build',
+    agentType: 'build-engineer',
+    model: 'sonnet',
+    prompt:
+      'Run the project type-checker and build (e.g. `npm run type-check` then `npm run build`). pass=true only if both succeed with zero errors. Report the outcome.',
+  },
+  {
+    key: 'tests',
+    agentType: 'tester',
+    model: 'sonnet',
+    prompt:
+      'Run the full test suite with coverage (e.g. `npm run test:coverage`). pass=true only if 100% of tests pass AND coverage meets the project threshold (≥95%). Report pass rate and coverage %.',
+  },
+  {
+    key: 'security',
+    agentType: 'security-reviewer',
+    model: 'haiku',
+    prompt:
+      'Run a production dependency audit (e.g. `npm audit --production`) and scan the diff for committed secrets. pass=true only if there are no high/critical vulnerabilities and no leaked secrets. Report findings.',
+  },
+  {
+    key: 'docs',
+    agentType: 'docs-writer',
+    model: 'haiku',
+    prompt:
+      'Verify release docs are current: CHANGELOG.md has entries for the unreleased changes and README reflects any public API changes. pass=true only if docs are up to date. Report gaps.',
+  },
+]
+
+phase('Checks')
+const results = await parallel(
+  GATES.map((g) => () =>
+    agent(g.prompt, { label: `gate:${g.key}`, phase: 'Checks', agentType: g.agentType, model: g.model, schema: GATE_SCHEMA }).then(
+      (r) => ({ key: g.key, pass: !!(r && r.pass), detail: (r && r.detail) || 'no result' })
+    )
+  )
+)
+
+const gates = results.filter(Boolean)
+const go = gates.length === GATES.length && gates.every((g) => g.pass)
+
+phase('Report')
+log(go ? '✅ GO — all gates passed.' : `⛔ NO-GO — failing: ${gates.filter((g) => !g.pass).map((g) => g.key).join(', ')}`)
+
+return { go, gates }