claude-flow-novice 2.0.0 → 2.0.1

package/.claude/agents/agent-principles/agent-type-guidelines.md

@@ -24,6 +24,14 @@ Tasks:
   - Configuration parsing
 
 Expected Improvement: +43% quality vs Minimal
+
+Validation Hooks:
+  - agent-template-validator (validates SQLite lifecycle, ACL declarations)
+  - cfn-loop-memory-validator (validates ACL levels for memory operations)
+  - test-coverage-validator (validates ≥80% line, ≥75% branch coverage)
+
+ACL Level: 1 (Private - agent-scoped data)
+SQLite: Persist confidence scores, implementation notes
 ```
 
 **Complex Tasks:** Use MINIMAL
@@ -37,6 +45,14 @@ Tasks:
   - Async runtime design
 
 Expected Improvement: +31% quality vs Code-Heavy
+
+Validation Hooks:
+  - agent-template-validator (validates SQLite lifecycle, ACL declarations)
+  - cfn-loop-memory-validator (validates ACL levels for memory operations)
+  - test-coverage-validator (validates ≥80% line, ≥75% branch coverage)
+
+ACL Level: 1 (Private - agent-scoped data)
+SQLite: Persist confidence scores, implementation notes
 ```
 
 **Example Agents:**
@@ -71,6 +87,16 @@ Apply same principles but validate with testing:
 - Need flexibility to identify novel issues
 - Trust AI's pattern recognition
 
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+- `cfn-loop-memory-validator` (validates ACL levels for memory operations)
+
+**ACL Level:** 3 (Swarm - shared across validation team)
+
+**SQLite Requirements:**
+- Persist review feedback, validation consensus
+- Store findings with appropriate ACL for team access
+
 **Key Responsibilities:**
 - Assess code quality, readability, and maintainability
 - Identify bugs, security issues, and performance problems
@@ -111,6 +137,17 @@ Apply same principles but validate with testing:
 - Over-constraining limits creative solutions
 - Need to consider trade-offs dynamically
 
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+- `cfn-loop-memory-validator` (validates ACL levels for memory operations)
+
+**ACL Level:** 3 (Swarm - coordinate multiple agents)
+
+**SQLite Requirements:**
+- Persist ADRs (Architecture Decision Records) with 1 year retention
+- Store design decisions with appropriate ACL for team access
+- All architectural decisions MUST persist to SQLite for audit trail
+
 **Core Responsibilities:**
 - Design system architectures from requirements
 - Make strategic technical decisions
@@ -148,6 +185,16 @@ Framework for evaluating options with explicit trade-off documentation.
 - Examples show proper assertion style
 - But test strategy needs metadata structure
 
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+- `test-coverage-validator` (validates ≥80% line, ≥75% branch coverage)
+
+**ACL Level:** 3 (Swarm - shared across validation team)
+
+**SQLite Requirements:**
+- Persist test results, coverage metrics
+- Store test strategy with appropriate ACL for team access
+
 **Test Patterns:**
 
 ### Rust Testing Pattern
@@ -230,6 +277,15 @@ Test Categories:
 - Let evidence guide conclusions
 - Need flexibility in methodology
 
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+
+**ACL Level:** 1 (Private) or 3 (Swarm) depending on context
+
+**SQLite Requirements:**
+- Persist research findings, competitive analysis
+- Store with appropriate ACL based on sharing requirements
+
 **Core Responsibilities:**
 - Research technologies, patterns, and best practices
 - Analyze trade-offs and alternatives
@@ -263,6 +319,16 @@ Test Categories:
 - Deployment checklists are essential
 - Balance structure with flexibility
 
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+- `cfn-loop-memory-validator` (validates ACL levels for memory operations)
+
+**ACL Level:** 3 (Swarm - coordinate with team)
+
+**SQLite Requirements:**
+- Persist deployment logs, infrastructure state
+- Store pipeline configurations with appropriate ACL
+
 **Pipeline Structure:**
 
 ```yaml
@@ -315,6 +381,75 @@ Deployment Process:
 
 ---
 
+## 7. Coordinator Agents
+
+**Recommended Format:** METADATA
+
+**Rationale:**
+- Coordination involves structured workflows
+- Multi-agent orchestration requires clear patterns
+- Blocking coordination needs explicit signal handling
+- Balance structure with flexibility for agent management
+
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+- `cfn-loop-memory-validator` (validates ACL levels for memory operations)
+- `blocking-coordination-validator` (validates HMAC secrets, signal ACK patterns, state machine logic)
+
+**ACL Level:** 3 (Swarm - coordinate multiple agents)
+
+**SQLite Requirements:**
+- Persist coordination signals, agent assignments
+- Store task delegation and progress tracking
+- All coordination state MUST persist for recovery
+
+**Blocking Coordination Requirements:**
+- Import `BlockingCoordinationSignals` and `CoordinatorTimeoutHandler`
+- Use HMAC secret from `process.env.BLOCKING_COORDINATION_SECRET`
+- Implement signal sending and ACK waiting patterns
+- Handle timeout scenarios with graceful degradation
+
+**Core Responsibilities:**
+- Orchestrate multi-agent workflows
+- Manage task delegation and dependencies
+- Handle blocking coordination with signal ACK protocol
+- Monitor agent progress and handle failures
+
+**Example:** Coordinator agents in CFN Loop phases
+
+---
+
+## 8. Product Owner Agent (CFN Loop 4 Only)
+
+**Recommended Format:** MINIMAL
+
+**Rationale:**
+- Strategic GOAP decisions require high-level reasoning
+- Must evaluate complex trade-offs
+- Context-sensitive decision making
+- No over-specification to allow flexible analysis
+
+**Validation Hooks:**
+- `agent-template-validator` (validates SQLite lifecycle, ACL declarations)
+- `cfn-loop-memory-validator` (validates ACL levels for memory operations)
+
+**ACL Level:** 4 (Project - strategic decisions)
+
+**SQLite Requirements:**
+- Persist GOAP decisions (PROCEED/DEFER/ESCALATE) with 365 day retention for compliance
+- Store backlog items with appropriate ACL for project access
+- All strategic decisions MUST persist to SQLite for audit trail
+
+**Core Responsibilities:**
+- Make autonomous GOAP decisions after Loop 2 consensus validation
+- Evaluate PROCEED (relaunch Loop 3) vs DEFER (approve, backlog issues) vs ESCALATE (human review)
+- Manage backlog items and prioritization
+- Ensure compliance with retention policies
+
+**Example:** Product Owner agent in CFN Loop 4 decision gate
+
+---
+
 ## Agent Selection Guide
 
 **Core Development**: coder, tester, reviewer
@@ -322,7 +457,9 @@ Deployment Process:
 **Frontend**: coder (specialized), mobile-dev
 **Quality**: tester, reviewer, security-specialist, perf-analyzer
 **Planning**: researcher, planner, architect
+**Coordination**: coordinator (with blocking-coordination-validator)
 **Operations**: devops-engineer, cicd-engineer
 **Documentation**: api-docs, researcher
+**Strategic**: product-owner (CFN Loop 4 only)
 
 **Select agents based on actual task needs, not predefined patterns.**

package/.claude/agents/agent-principles/format-selection.md

@@ -19,6 +19,10 @@
 - **Structure**: Role definition + Core principles + Minimal constraints
 - **Philosophy**: Trust the AI's reasoning; provide direction, not prescription
 
+**Validation Hooks Required:**
+- `agent-template-validator` (MANDATORY - validates SQLite lifecycle hooks)
+- `cfn-loop-memory-validator` (MANDATORY - validates ACL levels)
+
 **Why Minimal Works for Complex Tasks:**
 - Avoids over-constraining the solution space
 - Allows creative application of principles
@@ -41,6 +45,12 @@
 - **Structure**: Detailed specifications + Requirements + Structured examples
 - **Philosophy**: Provide scaffolding through metadata; guide without examples
 
+**Validation Hooks Required:**
+- `agent-template-validator` (MANDATORY - validates SQLite lifecycle hooks)
+- `cfn-loop-memory-validator` (MANDATORY - validates ACL levels)
+- `test-coverage-validator` (MANDATORY - validates ≥80% line, ≥75% branch coverage)
+- `blocking-coordination-validator` (if coordinator - validates HMAC secrets, signal ACK patterns)
+
 **Why Metadata Works for Medium Tasks:**
 - Provides structure without over-prescribing implementation
 - Ensures completeness through checklists
@@ -63,6 +73,12 @@
 - **Structure**: Detailed examples + Code patterns + Step-by-step guidance
 - **Philosophy**: Show exactly what good looks like; prime with concrete examples
 
+**Validation Hooks Required:**
+- `agent-template-validator` (MANDATORY - validates SQLite lifecycle hooks)
+- `cfn-loop-memory-validator` (MANDATORY - validates ACL levels)
+- `test-coverage-validator` (MANDATORY - validates ≥80% line, ≥75% branch coverage)
+- `blocking-coordination-validator` (if coordinator - validates HMAC secrets, signal ACK patterns)
+
 **Why Code-Heavy Works for Basic Tasks:**
 - Concrete examples reduce ambiguity
 - Patterns prime the AI for correct idioms
@@ -187,14 +203,18 @@ Priming Effect:
 Is the task BASIC (parsing, simple logic, CRUD)?
   → Use CODE-HEAVY format (+43% quality improvement)
   → Example: tests/benchmarking-tests/test-agent-code-heavy.md
+  → Add to frontmatter: validation_hooks: [agent-template-validator, cfn-loop-memory-validator, test-coverage-validator]
 
 Is the task COMPLEX with clear requirements (architecture, review)?
   → Use MINIMAL format (avoid over-constraining)
   → Example: architecture/system-architect.md
+  → Add to frontmatter: validation_hooks: [agent-template-validator, cfn-loop-memory-validator]
 
 Is the task MEDIUM complexity with structured steps?
   → Use METADATA format (structured guidance)
   → Example: development/backend/dev-backend-api.md
+  → Add to frontmatter: validation_hooks: [agent-template-validator, cfn-loop-memory-validator, test-coverage-validator]
+  → If coordinator: Also add blocking-coordination-validator
 ```
 
 ## The Three Golden Rules

package/.claude/agents/agent-principles/prompt-engineering.md

@@ -112,6 +112,47 @@ npx claude-flow@alpha hooks post-edit [FILE_PATH] --memory-key "agent/step" --st
 - Coordinates with other agents via memory
 - Maintains system-wide standards
 
+### Four Production-Ready Validators
+
+All agents integrate with these validators automatically:
+
+**1. Agent Template Validator** (Priority 1 - CRITICAL)
+- Validates SQLite lifecycle hooks (spawn, update, terminate)
+- Validates ACL level declarations (1-5)
+- Validates error handling patterns (SQLite failures, Redis connection loss)
+- Validates blocking coordination imports (coordinators only)
+- Automation: 95% (WASM-accelerated pattern matching)
+- Execution time: <2s
+
+**2. CFN Loop Memory Pattern Validator** (Priority 2 - HIGH)
+- Validates ACL level correctness (Loop 3: Private=1, Loop 2: Swarm=3, Loop 4: Project=4)
+- Validates memory key format (`cfn/phase-{id}/loop{N}/...`)
+- Validates TTL values match retention policies (Loop 4: 365 days)
+- Validates encryption for sensitive data
+- Automation: 90% (deterministic rule matching)
+- Execution time: <2s
+
+**3. Test Coverage Validator** (Priority 3 - MEDIUM)
+- Validates line coverage ≥ 80%
+- Validates branch coverage ≥ 75%
+- Validates function coverage ≥ 80%
+- Validates agent lifecycle tests present
+- Automation: 100% (quantitative metrics)
+- Execution time: <2s
+
+**4. Blocking Coordination Validator** (Priority 4 - MEDIUM)
+- Validates required imports (BlockingCoordinationSignals, CoordinatorTimeoutHandler)
+- Validates HMAC secret environment variable usage
+- Validates signal sending/receiving patterns present
+- Hybrid validation: Spawns reviewer agent for state machine logic
+- Automation: 60% (complex logic requires semantic review)
+- Execution time: <5s (includes agent review)
+
+**Composite Validation:**
+- Hooks compose for comprehensive validation (<5s total)
+- Results merge for actionable recommendations
+- False positive rate: <2%
+
 ---
 
 ## 6. Anti-Patterns to Avoid
@@ -204,9 +245,20 @@ capabilities:                       # OPTIONAL: Array of capability tags
   - rust
   - error-handling
   - concurrent-programming
-lifecycle:                          # OPTIONAL: Hooks for agent lifecycle
-  pre_task: "npx claude-flow@alpha hooks pre-task"
-  post_task: "npx claude-flow@alpha hooks post-task"
+validation_hooks:                   # REQUIRED: Auto-triggered validators
+  - agent-template-validator        # MANDATORY for all agents
+  - cfn-loop-memory-validator       # MANDATORY for all agents
+  - test-coverage-validator         # For implementers/testers
+  - blocking-coordination-validator # For coordinators only
+lifecycle:                          # REQUIRED: Hooks for SQLite lifecycle
+  pre_task: |
+    sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at)
+                     VALUES ('${AGENT_ID}', '${AGENT_TYPE}', 'active', CURRENT_TIMESTAMP)"
+  post_task: |
+    sqlite-cli exec "UPDATE agents
+                     SET status = 'completed', confidence = ${CONFIDENCE_SCORE},
+                         completed_at = CURRENT_TIMESTAMP
+                     WHERE id = '${AGENT_ID}'"
 hooks:                             # OPTIONAL: Integration points
   memory_key: "agent-name/context"
   validation: "post-edit"
@@ -265,17 +317,20 @@ npx claude-flow@alpha hooks post-edit [FILE_PATH] --memory-key "agent/step" --st
 
 Every agent should integrate with the Claude Flow hook system for coordination:
 
-#### 1. Pre-Task Hook
+#### 1. Pre-Task Hook (SQLite Lifecycle)
 
 ```bash
-npx claude-flow@alpha hooks pre-task --description "Implementing authentication system"
+# Register agent in SQLite on spawn (executed by lifecycle.pre_task)
+sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at)
+                 VALUES ('${AGENT_ID}', '${AGENT_TYPE}', 'active', CURRENT_TIMESTAMP)"
 ```
 
 **Purpose:**
 - Initialize task context
-- Set up memory namespace
+- Register agent in SQLite for audit trail
+- Set up memory namespace with appropriate ACL level
 - Log task start
-- Coordinate with other agents
+- Coordinate with other agents via Redis pub/sub
 
 #### 2. Post-Edit Hook (MANDATORY)
 
@@ -300,59 +355,98 @@ npx claude-flow@alpha hooks post-edit src/auth/login.rs \
 - 📊 Coverage metrics
 - 🤖 Improvement suggestions
 
-#### 3. Post-Task Hook
+#### 3. Post-Task Hook (SQLite Lifecycle)
 
 ```bash
-npx claude-flow@alpha hooks post-task --task-id "auth-implementation"
+# Update agent status and confidence on completion (executed by lifecycle.post_task)
+sqlite-cli exec "UPDATE agents
+                 SET status = 'completed',
+                     confidence = ${CONFIDENCE_SCORE},
+                     completed_at = CURRENT_TIMESTAMP
+                 WHERE id = '${AGENT_ID}'"
 ```
 
 **Purpose:**
 - Finalize task
+- Update SQLite with final confidence score and status
 - Export metrics
 - Update coordination state
 - Trigger downstream agents
 
-#### 4. Session Management
-
-```bash
-# Restore session context
-npx claude-flow@alpha hooks session-restore --session-id "swarm-auth-2025-09-30"
+#### 4. SQLite Error Handling (Best Practices)
 
-# End session and export metrics
-npx claude-flow@alpha hooks session-end --export-metrics true
+```javascript
+// Retry with exponential backoff for transient errors
+try {
+  await sqlite.memoryAdapter.set(key, value, { aclLevel: 1 });
+} catch (error) {
+  if (error.code === 'SQLITE_BUSY') {
+    await retryWithBackoff(() => sqlite.memoryAdapter.set(key, value, { aclLevel: 1 }));
+  } else if (error.code === 'SQLITE_LOCKED') {
+    await waitForLockRelease(key);
+  } else {
+    console.error('SQLite failure:', error);
+    // Fallback to Redis for non-critical data (ACL level < 4)
+    if (aclLevel < 4) {
+      await redis.set(key, value);
+    } else {
+      throw new Error('Cannot write critical data to fallback store');
+    }
+  }
+}
 ```
 
+**Error Handling Requirements:**
+- All SQLite operations MUST have try-catch blocks
+- Implement retry logic with exponential backoff for SQLITE_BUSY errors
+- Graceful degradation for non-critical data (ACL < 4)
+- Critical data (ACL = 4) MUST NOT fall back to Redis
+
 ---
 
-## Memory Coordination
+## Memory Coordination (SQLite with ACL)
 
-Agents share context through the memory system:
+Agents share context through the SQLite memory system with ACL enforcement:
 
 ```javascript
-// Store context for other agents
-npx claude-flow@alpha memory store \
-  --key "architect/design/decision" \
-  --value '{"pattern": "microservices", "rationale": "..."}'
-
-// Retrieve context from other agents
-npx claude-flow@alpha memory retrieve \
-  --key "architect/design/decision"
+// Store context for other agents with appropriate ACL level
+await sqlite.memoryAdapter.set(
+  "architect/design/decision",
+  { pattern: "microservices", rationale: "..." },
+  { aclLevel: 3, ttl: 31536000 }  // Swarm level, 1 year retention
+);
+
+// Retrieve context from other agents (ACL enforced)
+const decision = await sqlite.memoryAdapter.get("architect/design/decision");
 ```
 
 **Memory Key Patterns:**
 ```
 {agent-type}/{domain}/{aspect}
 
-Examples:
-- architect/auth/design
+Standard Agent Patterns (ACL Level 1 - Private):
+- agent/{agentId}/confidence/{taskId}
 - coder/auth/implementation
+
+Validation Team Patterns (ACL Level 3 - Swarm):
 - reviewer/auth/feedback
 - tester/auth/coverage
+- architect/auth/design
+
+CFN Loop Patterns:
+- cfn/phase-{id}/loop3/agent-{id}/{metric}  (ACL 1 - Private)
+- cfn/phase-{id}/loop2/validation/{validator-id}  (ACL 3 - Swarm)
+- cfn/phase-{id}/loop4/decision/{decision-type}  (ACL 4 - Project)
 ```
 
+**ACL Level Guidelines:**
+- **Level 1 (Private)**: Agent-scoped data, confidence scores, implementation notes
+- **Level 3 (Swarm)**: Validation team, coordination data, ADRs
+- **Level 4 (Project)**: Strategic decisions, GOAP results, compliance data (365 day retention)
+
 ---
 
-## Swarm Coordination
+## Swarm Coordination (with SQLite Lifecycle)
 
 When spawning multiple agents concurrently:
 
@@ -362,10 +456,46 @@ Task("Rust Coder", "Implement auth with proper error handling", "coder")
 Task("Unit Tester", "Write comprehensive tests for auth", "tester")
 Task("Code Reviewer", "Review auth implementation", "reviewer")
 
-// Each agent MUST:
-// 1. Run pre-task hook
-// 2. Execute work
-// 3. Run post-edit hook for each file
-// 4. Store results in memory
-// 5. Run post-task hook
+// Each agent MUST follow SQLite lifecycle:
+// 1. Pre-task hook: Register in SQLite (INSERT INTO agents)
+// 2. Execute work: Update status to 'in_progress'
+// 3. Post-edit hook: Validate with all 4 validators
+// 4. Store results: SQLite with appropriate ACL level
+// 5. Post-task hook: Update to 'completed' with confidence score
+```
+
+**Validation Hook Execution Sequence:**
+
+```bash
+# 1. Pre-task: Agent registration
+sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at) VALUES ('coder-1', 'coder', 'active', CURRENT_TIMESTAMP)"
+
+# 2. Work execution with progress updates
+sqlite-cli exec "UPDATE agents SET status = 'in_progress', updated_at = CURRENT_TIMESTAMP WHERE id = 'coder-1'"
+
+# 3. Post-edit: Run all applicable validators
+npx claude-flow@alpha hooks post-edit src/auth.js --memory-key "agent/coder-1/auth" --structured
+# → Triggers: agent-template-validator, cfn-loop-memory-validator, test-coverage-validator
+
+# 4. Store results with ACL
+sqlite-cli exec "INSERT INTO memory (key, value, acl_level, ttl) VALUES ('agent/coder-1/confidence/auth', '0.85', 1, 2592000)"
+
+# 5. Post-task: Finalization
+sqlite-cli exec "UPDATE agents SET status = 'completed', confidence = 0.85, completed_at = CURRENT_TIMESTAMP WHERE id = 'coder-1'"
+```
+
+**Coordinator-Specific Requirements:**
+
+Coordinator agents run additional validation with blocking-coordination-validator:
+
+```bash
+# Coordinators trigger all validators including blocking-coordination
+npx claude-flow@alpha hooks post-edit src/coordinator.js --memory-key "agent/coordinator-1/phase" --structured
+# → Triggers: agent-template-validator, cfn-loop-memory-validator, blocking-coordination-validator
+
+# Validates:
+# - HMAC secret usage (process.env.BLOCKING_COORDINATION_SECRET)
+# - Signal ACK patterns (sendSignal, waitForAck)
+# - Timeout configuration
+# - State machine logic (spawns reviewer agent for semantic validation)
 ```

package/.claude/agents/agent-principles/quality-metrics.md

@@ -56,7 +56,7 @@ Use this checklist before deploying an agent:
 
 ### Structure ✓
 - [ ] Valid YAML frontmatter
-- [ ] All required fields present (name, description, tools, model, color)
+- [ ] All required fields present (name, description, tools, model, color, validation_hooks, lifecycle)
 - [ ] Clear role definition in opening paragraph
 - [ ] Appropriate section structure
 
@@ -69,10 +69,31 @@ Use this checklist before deploying an agent:
 ### Content Quality ✓
 - [ ] Clear responsibilities defined
 - [ ] Approach/methodology explained
-- [ ] Integration points specified
+- [ ] Integration points specified (memory keys, ACL levels)
 - [ ] Success metrics defined
 - [ ] Post-edit validation hook included
 
+### Hook Validation System ✓
+- [ ] validation_hooks declared in frontmatter
+- [ ] agent-template-validator included (MANDATORY)
+- [ ] cfn-loop-memory-validator included (MANDATORY)
+- [ ] test-coverage-validator included (for implementers/testers)
+- [ ] blocking-coordination-validator included (for coordinators only)
+
+### SQLite Lifecycle Integration ✓
+- [ ] lifecycle.pre_task hook present (INSERT INTO agents)
+- [ ] lifecycle.post_task hook present (UPDATE agents SET status=completed)
+- [ ] ACL level declared (1=Private, 3=Swarm, 4=Project)
+- [ ] Error handling patterns implemented (retry logic, fallback)
+- [ ] Memory key patterns follow conventions
+
+### Blocking Coordination (Coordinators Only) ✓
+- [ ] BlockingCoordinationSignals import present
+- [ ] CoordinatorTimeoutHandler import present
+- [ ] HMAC secret from environment variable
+- [ ] Signal ACK patterns implemented
+- [ ] Timeout handling logic present
+
 ### Language-Specific ✓
 - [ ] If Rust: Format validated against benchmark findings
 - [ ] If other language: Format choice documented as hypothesis
@@ -84,6 +105,7 @@ Use this checklist before deploying an agent:
 - [ ] Quality metrics meet targets
 - [ ] Integration with hooks verified
 - [ ] Collaboration with other agents confirmed
+- [ ] SQLite persistence verified
 ```
 
 ### Post-Deployment Monitoring
@@ -96,18 +118,35 @@ Use this checklist before deploying an agent:
 - [ ] Track first-time success rate
 - [ ] Measure time to completion
 - [ ] Collect user feedback
+- [ ] Monitor SQLite persistence success rate (target: >99.9%)
 
 ### Quality Assurance
 - [ ] Review output quality regularly
 - [ ] Check adherence to format guidelines
 - [ ] Validate tool usage patterns
 - [ ] Assess collaboration effectiveness
+- [ ] Monitor ACL violation rate (target: 0% in production)
+
+### Hook Validation Metrics
+- [ ] Agent template validation pass rate (target: 100%)
+- [ ] CFN Loop ACL compliance rate (target: 100%)
+- [ ] Test coverage thresholds met (≥80% line, ≥75% branch)
+- [ ] Blocking coordination pattern correctness (coordinators: 100%)
+- [ ] Hook execution time (<5s composite)
+- [ ] False positive rate (<2%)
+
+### SQLite Integration Health
+- [ ] Agent lifecycle completion rate (>95%)
+- [ ] Memory persistence success rate (>99.9%)
+- [ ] Error handling effectiveness (retry success rate >90%)
+- [ ] Fallback activation rate (<1% for non-critical data)
 
 ### Continuous Improvement
 - [ ] Document failure modes
 - [ ] Refine based on metrics
 - [ ] Update with new patterns
 - [ ] Validate format choice periodically
+- [ ] Review and update hook validators
 ```
 
 ---
@@ -203,6 +242,48 @@ Agent Performance Metrics:
   user_satisfaction:
     target: ">4.5/5"
     measure: "Feedback from users"
+
+Hook Validation Metrics:
+  agent_template_validation_pass_rate:
+    target: "100%"
+    measure: "SQLite lifecycle, ACL, error handling validation pass rate"
+
+  cfn_loop_acl_compliance:
+    target: "100%"
+    measure: "Zero ACL violations in production"
+
+  test_coverage_compliance:
+    target: "≥80% line, ≥75% branch"
+    measure: "Test coverage thresholds met"
+
+  blocking_coordination_correctness:
+    target: "100% (coordinators)"
+    measure: "HMAC, signal ACK patterns validated"
+
+  hook_execution_time:
+    target: "<5s composite"
+    measure: "Total validation time for all hooks"
+
+  false_positive_rate:
+    target: "<2%"
+    measure: "Incorrect validation failures"
+
+SQLite Integration Metrics:
+  persistence_success_rate:
+    target: ">99.9%"
+    measure: "SQLite write operations successful"
+
+  agent_lifecycle_completion:
+    target: ">95%"
+    measure: "Agents complete full lifecycle (spawn → complete)"
+
+  error_recovery_success:
+    target: ">90%"
+    measure: "Retry operations successful on SQLITE_BUSY errors"
+
+  acl_violation_rate:
+    target: "0%"
+    measure: "Unauthorized data access attempts"
 ```
 
 ### Feedback Loop