fix(#201): rewrite comprehensive tests with proper pytest-compatible functions

GENOME.md

@@ -1,16 +1,16 @@
 # GENOME.md — compounding-intelligence
 
-**Generated:** 2026-04-17
-**Repo:** Timmy_Foundation/compounding-intelligence
-**Description:** Turn 1B+ daily agent tokens into durable, compounding fleet intelligence.
+*Auto-generated codebase genome. Addresses timmy-home#676.*
 
 ---
 
 ## Project Overview
 
-Every agent session starts at zero. The same HTTP 405 gets rediscovered as a branch protection issue. The same token path gets searched from scratch. Intelligence evaporates when the session ends.
+**What:** A system that turns 1B+ daily agent tokens into durable, compounding fleet intelligence.
 
-Compounding-intelligence solves this with three pipelines forming a loop:
+**Why:** Every agent session starts at zero. The same mistakes get made repeatedly — the same HTTP 405 is rediscovered as a branch protection issue, the same token path is searched for from scratch. Intelligence evaporates when the session ends.
+
+**How:** Three pipelines form a compounding loop:
 
 ```
 SESSION ENDS → HARVESTER → KNOWLEDGE STORE → BOOTSTRAPPER → NEW SESSION STARTS SMARTER
@@ -18,234 +18,222 @@ SESSION ENDS → HARVESTER → KNOWLEDGE STORE → BOOTSTRAPPER → NEW SESSION
                          MEASURER → Prove it's working
 ```
 
-**Status:** Active development. Core pipelines implemented. 20+ scripts, 14 test files, knowledge store populated with real data.
+**Status:** Early stage. Template and test scaffolding exist. Core pipeline scripts (harvester.py, bootstrapper.py, measurer.py, session_reader.py) are planned but not yet implemented. The knowledge extraction prompt is complete and validated.
+
+---
 
 ## Architecture
 
 ```mermaid
 graph TD
-    TRANS[Session Transcripts<br/>~/.hermes/sessions/*.jsonl] --> READER[session_reader.py]
-    READER --> HARVESTER[harvester.py]
-    HARVESTER -->|LLM extraction| PROMPT[harvest-prompt.md]
-    HARVESTER --> DEDUP[deduplicate()]
-    DEDUP --> INDEX[knowledge/index.json]
-    DEDUP --> GLOBAL[knowledge/global/*.yaml]
-    DEDUP --> REPO[knowledge/repos/*.yaml]
-
-    INDEX --> BOOTSTRAPPER[bootstrapper.py]
-    BOOTSTRAPPER -->|filter + rank + truncate| CONTEXT[Bootstrap Context<br/>2k token injection]
-    CONTEXT --> SESSION[New Session starts smarter]
-
-    INDEX --> VALIDATOR[validate_knowledge.py]
-    INDEX --> STALENESS[knowledge_staleness_check.py]
-    INDEX --> GAPS[knowledge_gap_identifier.py]
-
-    TRANS --> SAMPLER[sampler.py]
-    SAMPLER -->|score + rank| BEST[High-value sessions]
-    BEST --> HARVESTER
-
-    TRANS --> METADATA[session_metadata.py]
-    METADATA --> SUMMARY[SessionSummary objects]
-
-    KNOWLEDGE --> DIFF[diff_analyzer.py]
-    DIFF --> PROPOSALS[improvement_proposals.py]
-    PROPOSALS --> PRIORITIES[priority_rebalancer.py]
+    A[Session Transcript<br/>.jsonl] --> B[Harvester]
+    B --> C{Extract Knowledge}
+    C --> D[knowledge/index.json]
+    C --> E[knowledge/global/*.md]
+    C --> F[knowledge/repos/{repo}.md]
+    C --> G[knowledge/agents/{agent}.md]
+    D --> H[Bootstrapper]
+    H --> I[Bootstrap Context<br/>2k token injection]
+    I --> J[New Session<br/>starts smarter]
+    J --> A
+    D --> K[Measurer]
+    K --> L[metrics/dashboard.md]
+    K --> M[Velocity / Hit Rate<br/>Error Reduction]
 ```
 
-## Entry Points
+### Pipeline 1: Harvester
 
-### Core Pipelines
+**Status:** Prompt designed. Script not implemented.
 
-| Script | Purpose | Key Functions |
-|--------|---------|---------------|
-| `harvester.py` | Extract knowledge from session transcripts | `harvest_session()`, `call_llm()`, `deduplicate()`, `validate_fact()` |
-| `bootstrapper.py` | Build pre-session context from knowledge store | `build_bootstrap_context()`, `filter_facts()`, `sort_facts()`, `truncate_to_tokens()` |
-| `session_reader.py` | Parse JSONL session transcripts | `read_session()`, `extract_conversation()`, `messages_to_text()` |
-| `sampler.py` | Score and rank sessions for harvesting value | `scan_session_fast()`, `score_session()` |
-| `session_metadata.py` | Extract structured metadata from sessions | `extract_session_metadata()`, `SessionSummary` |
+Reads finished session transcripts (JSONL). Uses `templates/harvest-prompt.md` to extract durable knowledge into five categories:
 
-### Analysis & Quality
+| Category | Description | Example |
+|----------|-------------|---------|
+| `fact` | Concrete, verifiable information | "Repository X has 5 files" |
+| `pitfall` | Errors encountered, wrong assumptions | "Token is at ~/.config/gitea/token, not env var" |
+| `pattern` | Successful action sequences | "Deploy: test → build → push → webhook" |
+| `tool-quirk` | Environment-specific behaviors | "URL format requires trailing slash" |
+| `question` | Identified but unanswered | "Need optimal batch size for harvesting" |
 
-| Script | Purpose |
-|--------|---------|
-| `validate_knowledge.py` | Validate knowledge index schema compliance |
-| `knowledge_staleness_check.py` | Detect stale knowledge (source changed since extraction) |
-| `knowledge_gap_identifier.py` | Find untested functions, undocumented APIs, missing tests |
-| `diff_analyzer.py` | Analyze code diffs for improvement signals |
-| `improvement_proposals.py` | Generate ranked improvement proposals |
-| `priority_rebalancer.py` | Rebalance priorities across proposals |
-| `automation_opportunity_finder.py` | Find manual steps that can be automated |
-| `dead_code_detector.py` | Detect unused code |
-| `dependency_graph.py` | Map dependency relationships |
-| `perf_bottleneck_finder.py` | Find performance bottlenecks |
-| `refactoring_opportunity_finder.py` | Identify refactoring targets |
-| `gitea_issue_parser.py` | Parse Gitea issues for knowledge extraction |
-
-### Automation
-
-| Script | Purpose |
-|--------|---------|
-| `session_pair_harvester.py` | Extract training pairs from sessions |
-
-## Data Flow
-
-```
-1. Session ends → .jsonl written to ~/.hermes/sessions/
-2. sampler.py scores sessions by age, recency, repo coverage
-3. harvester.py reads top sessions, calls LLM with harvest-prompt.md
-4. LLM extracts facts/pitfalls/patterns/quirks/questions
-5. deduplicate() checks against existing index via fact_fingerprint()
-6. validate_fact() checks schema compliance
-7. write_knowledge() appends to knowledge/index.json + per-repo YAML
-8. On next session start, bootstrapper.py:
-   a. Loads knowledge/index.json
-   b. Filters by session's repo and agent type
-   c. Sorts by confidence (high first), then recency
-   d. Truncates to 2k token budget
-   e. Injects as pre-context
-9. Agent starts with full situational awareness instead of zero
-```
-
-## Key Abstractions
-
-### Knowledge Item (fact/pitfall/pattern/quirk/question)
+Output schema per knowledge item:
 ```json
 {
-  "fact": "Gitea token is at ~/.config/gitea/token",
-  "category": "tool-quirk",
-  "repo": "global",
-  "confidence": 0.9,
-  "evidence": "Found during clone attempt",
-  "source_session": "2026-04-13_abc123",
-  "extracted_at": "2026-04-13T20:00:00Z"
+  "fact": "One sentence description",
+  "category": "fact|pitfall|pattern|tool-quirk|question",
+  "repo": "repo-name or 'global'",
+  "confidence": 0.0-1.0
 }
 ```
 
-### SessionSummary (session_metadata.py)
-Extracted metadata per session: duration, token count, tools used, repos touched, error count, outcome.
+### Pipeline 2: Bootstrapper
 
-### Gap / GapReport (knowledge_gap_identifier.py)
-Structured gap analysis: untested functions, undocumented APIs, missing tests. Severity: critical/high/medium/low.
+**Status:** Not implemented.
 
-### Knowledge Index (knowledge/index.json)
-Machine-readable fact store. 12KB, populated with real data. Categories: fact, pitfall, pattern, tool-quirk, question.
+Queries knowledge store before session start. Assembles a compact 2k-token context from relevant facts. Injects into session startup so the agent begins with full situational awareness.
 
-## Knowledge Store
+### Pipeline 3: Measurer
 
-```
-knowledge/
-├── index.json              # Master fact store (12KB, populated)
-├── SCHEMA.md               # Schema documentation
-├── global/
-│   ├── pitfalls.yaml       # Cross-repo pitfalls (2KB)
-│   └── tool-quirks.yaml    # Tool-specific quirks (2KB)
-├── repos/
-│   ├── hermes-agent.yaml   # hermes-agent knowledge (2KB)
-│   └── the-nexus.yaml      # the-nexus knowledge (2KB)
-└── agents/                 # Per-agent knowledge (empty)
-```
+**Status:** Not implemented.
 
-## API Surface
-
-### LLM API (consumed)
-| Provider | Endpoint | Usage |
-|----------|----------|-------|
-| Nous Research | `https://inference-api.nousresearch.com/v1` | Knowledge extraction |
-| Ollama | `http://localhost:11434/v1` | Local fallback |
-
-### File API (consumed/produced)
-| Path | Format | Direction |
-|------|--------|-----------|
-| `~/.hermes/sessions/*.jsonl` | JSONL | Input (session transcripts) |
-| `knowledge/index.json` | JSON | Output (master fact store) |
-| `knowledge/global/*.yaml` | YAML | Output (cross-repo knowledge) |
-| `knowledge/repos/*.yaml` | YAML | Output (per-repo knowledge) |
-| `templates/harvest-prompt.md` | Markdown | Config (extraction prompt) |
-
-## Test Coverage
-
-**14 test files** covering core pipelines:
-
-| Test File | Covers |
-|-----------|--------|
-| `test_harvest_prompt.py` | Prompt validation, hallucination detection |
-| `test_harvest_prompt_comprehensive.py` | Extended prompt testing |
-| `test_harvester_pipeline.py` | Harvester extraction + dedup |
-| `test_bootstrapper.py` | Context building, filtering, truncation |
-| `test_session_pair_harvester.py` | Training pair extraction |
-| `test_improvement_proposals.py` | Proposal generation |
-| `test_priority_rebalancer.py` | Priority scoring |
-| `test_knowledge_staleness.py` | Staleness detection |
-| `test_automation_opportunity_finder.py` | Automation detection |
-| `test_diff_analyzer.py` | Diff analysis |
-| `test_gitea_issue_parser.py` | Issue parsing |
-| `test_refactoring_opportunity_finder.py` | Refactoring signals |
-| `test_knowledge_gap_identifier.py` | Gap analysis |
-| `test_perf_bottleneck_finder.py` | Perf bottleneck detection |
-
-### Coverage Gaps
-
-1. **session_reader.py** — No dedicated test file (tested indirectly)
-2. **sampler.py** — No test file (scoring logic untested)
-3. **session_metadata.py** — No test file
-4. **validate_knowledge.py** — No test file
-5. **knowledge_staleness_check.py** — Tested but limited
-
-## Security Considerations
-
-### API Key Handling
-- `harvester.py` reads API key from `~/.hermes/auth.json` or env vars
-- Key passed to LLM API in request headers only
-- No key logging
-
-### Knowledge Integrity
-- `validate_fact()` checks schema before writing
-- `deduplicate()` prevents duplicate entries via fingerprint
-- `knowledge_staleness_check.py` detects when source code changed but knowledge didn't
-- Confidence scores prevent low-quality knowledge from polluting the store
-
-### File Safety
-- Knowledge writes are append-only (never deletes)
-- Bootstrap context is truncated to budget (no prompt injection via knowledge)
-- Session reader handles malformed JSONL gracefully
-
-## File Index
-
-```
-scripts/
-  harvester.py                          (473 lines) — Core knowledge extraction
-  bootstrapper.py                       (302 lines) — Pre-session context builder
-  session_reader.py                     (137 lines) — JSONL session parser
-  sampler.py                            (363 lines) — Session scoring + ranking
-  session_metadata.py                   (271 lines) — Session metadata extraction
-  validate_knowledge.py                  (44 lines) — Index validation
-  knowledge_staleness_check.py          (125 lines) — Staleness detection
-  knowledge_gap_identifier.py           (291 lines) — Gap analysis engine
-  diff_analyzer.py                      (203 lines) — Diff analysis
-  improvement_proposals.py              (518 lines) — Proposal generation
-  priority_rebalancer.py                (745 lines) — Priority scoring
-  automation_opportunity_finder.py      (600 lines) — Automation detection
-  dead_code_detector.py                 (270 lines) — Dead code detection
-  dependency_graph.py                   (220 lines) — Dependency mapping
-  perf_bottleneck_finder.py             (635 lines) — Perf analysis
-  refactoring_opportunity_finder.py      (46 lines) — Refactoring signals
-  gitea_issue_parser.py                 (140 lines) — Gitea issue parsing
-  session_pair_harvester.py             (224 lines) — Training pair extraction
-knowledge/
-  index.json                             (12KB)    — Master fact store
-  SCHEMA.md                              (3KB)     — Schema docs
-  global/pitfalls.yaml                   (2KB)     — Cross-repo pitfalls
-  global/tool-quirks.yaml                (2KB)     — Tool quirks
-  repos/hermes-agent.yaml                (2KB)     — Repo-specific knowledge
-  repos/the-nexus.yaml                   (2KB)     — Repo-specific knowledge
-templates/
-  harvest-prompt.md                      (4KB)     — Extraction prompt
-test_sessions/                            (5 files) — Sample transcripts
-tests/ + scripts/test_*                   (14 files)— Test suite
-```
-
-**Total:** ~6,500 lines of code across 18 scripts + 14 test files.
+Tracks compounding metrics: knowledge velocity (facts/day), error reduction (%), hit rate (knowledge used / knowledge available), task completion improvement.
 
 ---
 
-*Generated by Codebase Genome pipeline — Issue #676*
+## Directory Structure
+
+```
+compounding-intelligence/
+├── README.md                           # Project overview and architecture
+├── GENOME.md                           # This file (codebase genome)
+├── knowledge/                          # [PLANNED] Knowledge store
+│   ├── index.json                      # Machine-readable fact index
+│   ├── global/                         # Cross-repo knowledge
+│   ├── repos/{repo}.md                 # Per-repo knowledge
+│   └── agents/{agent}.md               # Agent-type notes
+├── scripts/
+│   ├── test_harvest_prompt.py          # Basic prompt validation (2.5KB)
+│   └── test_harvest_prompt_comprehensive.py  # Full prompt structure test (6.8KB)
+├── templates/
+│   └── harvest-prompt.md               # Knowledge extraction prompt (3.5KB)
+├── test_sessions/
+│   ├── session_success.jsonl           # Happy path test data
+│   ├── session_failure.jsonl           # Failure path test data
+│   ├── session_partial.jsonl           # Incomplete session test data
+│   ├── session_patterns.jsonl          # Pattern extraction test data
+│   └── session_questions.jsonl         # Question identification test data
+└── metrics/                            # [PLANNED] Compounding metrics
+    └── dashboard.md
+```
+
+---
+
+## Entry Points and Data Flow
+
+### Entry Point 1: Knowledge Extraction (Harvester)
+
+```
+Input:  Session transcript (JSONL)
+        ↓
+        templates/harvest-prompt.md (LLM prompt)
+        ↓
+        Knowledge items (JSON array)
+        ↓
+Output: knowledge/index.json + per-repo/per-agent markdown files
+```
+
+### Entry Point 2: Session Bootstrap (Bootstrapper)
+
+```
+Input:  Session context (repo, agent type, task type)
+        ↓
+        knowledge/index.json (query relevant facts)
+        ↓
+        2k-token bootstrap context
+        ↓
+Output: Injected into session startup
+```
+
+### Entry Point 3: Measurement (Measurer)
+
+```
+Input:  knowledge/index.json + session history
+        ↓
+        Velocity, hit rate, error reduction calculations
+        ↓
+Output: metrics/dashboard.md
+```
+
+---
+
+## Key Abstractions
+
+### Knowledge Item
+The atomic unit. One sentence, one category, one confidence score. Designed to be small enough that 1000 items fit in a 2k-token bootstrap context.
+
+### Knowledge Store
+A directory structure that mirrors the fleet's mental model:
+- `global/` — knowledge that applies everywhere (tool quirks, environment facts)
+- `repos/` — knowledge specific to each repo
+- `agents/` — knowledge specific to each agent type
+
+### Confidence Score
+0.0–1.0 scale. Defines how certain the harvester is about each extracted fact:
+- 0.9–1.0: Explicitly stated with verification
+- 0.7–0.8: Clearly implied by multiple data points
+- 0.5–0.6: Suggested but not fully verified
+- 0.3–0.4: Inferred from limited data
+- 0.1–0.2: Speculative or uncertain
+
+### Bootstrap Context
+The 2k-token injection that a new session receives. Assembled from the most relevant knowledge items for the current task, filtered by confidence > 0.7, deduplicated, and compressed.
+
+---
+
+## API Surface
+
+### Internal (scripts not yet implemented)
+
+| Script | Input | Output | Status |
+|--------|-------|--------|--------|
+| `harvester.py` | Session JSONL path | Knowledge items JSON | PLANNED |
+| `bootstrapper.py` | Repo + agent type | 2k-token context string | PLANNED |
+| `measurer.py` | Knowledge store path | Metrics JSON | PLANNED |
+| `session_reader.py` | Session JSONL path | Parsed transcript | PLANNED |
+
+### Prompt (templates/harvest-prompt.md)
+
+The extraction prompt is the core "API." It takes a session transcript and returns structured JSON. It defines:
+- Five extraction categories
+- Output format (JSON array of knowledge items)
+- Confidence scoring rubric
+- Constraints (no hallucination, specificity, relevance, brevity)
+- Example input/output pair
+
+---
+
+## Test Coverage
+
+### What Exists
+
+| File | Tests | Coverage |
+|------|-------|----------|
+| `scripts/test_harvest_prompt.py` | 2 tests | Prompt file existence, sample transcript |
+| `scripts/test_harvest_prompt_comprehensive.py` | 5 tests | Prompt structure, categories, fields, confidence scoring, size limits |
+| `test_sessions/*.jsonl` | 5 sessions | Success, failure, partial, patterns, questions |
+
+### What's Missing
+
+1. **Harvester integration test** — Does the prompt actually extract correct knowledge from real transcripts?
+2. **Bootstrapper test** — Does it assemble relevant context correctly?
+3. **Knowledge store test** — Does the index.json maintain consistency?
+4. **Confidence calibration test** — Do high-confidence facts actually prove true in later sessions?
+5. **Deduplication test** — Are duplicate facts across sessions handled?
+6. **Staleness test** — How does the system handle outdated knowledge?
+
+---
+
+## Security Considerations
+
+1. **No secrets in knowledge store** — The harvester must filter out API keys, tokens, and credentials from extracted facts. The prompt constraints mention this but there is no automated guard.
+
+2. **Knowledge poisoning** — A malicious or corrupted session could inject false facts. Confidence scoring partially mitigates this, but there is no verification step.
+
+3. **Access control** — The knowledge store has no access control. Any process that can read the directory can read all facts. In a multi-tenant setup, this is a concern.
+
+4. **Transcript privacy** — Session transcripts may contain user data. The harvester must not extract personally identifiable information into the knowledge store.
+
+---
+
+## The 100x Path (from README)
+
+```
+Month 1:  15,000 facts, sessions 20% faster
+Month 2:  45,000 facts, sessions 40% faster, first-try success up 30%
+Month 3:  90,000 facts, fleet measurably smarter per token
+```
+
+Each new session is better than the last. The intelligence compounds.
+
+---
+
+*Generated by codebase-genome pipeline. Ref: timmy-home#676.*

scripts/test_harvest_prompt_comprehensive.py

@@ -1,212 +1,72 @@
 #!/usr/bin/env python3
-"""
-Comprehensive test script for knowledge extraction prompt.
-Validates prompt structure, requirements, and consistency.
-"""
-
-import json
-import re
+"""Comprehensive tests for knowledge extraction prompt."""
+import json, re
 from pathlib import Path
 
-def test_prompt_structure():
-    """Test that the prompt has the required structure."""
-    prompt_path = Path("templates/harvest-prompt.md")
-    if not prompt_path.exists():
-        return False, "harvest-prompt.md not found"
-    
-    content = prompt_path.read_text()
-    
-    # Check for required sections
-    required_sections = [
-        "System Prompt",
-        "Instructions", 
-        "Categories",
-        "Output Format",
-        "Confidence Scoring",
-        "Constraints",
-        "Example"
-    ]
-    
-    for section in required_sections:
-        if section.lower() not in content.lower():
-            return False, f"Missing required section: {section}"
-    
-    # Check for required categories
-    required_categories = ["fact", "pitfall", "pattern", "tool-quirk", "question"]
-    for category in required_categories:
-        if category not in content:
-            return False, f"Missing required category: {category}"
-    
-    # Check for required output fields
-    required_fields = ["fact", "category", "repo", "confidence"]
-    for field in required_fields:
-        if field not in content:
-            return False, f"Missing required output field: {field}"
-    
-    # Check prompt size (should be ~1k tokens, roughly 4k chars)
-    if len(content) > 5000:
-        return False, f"Prompt too large: {len(content)} chars (max ~5000)"
-    
-    if len(content) < 1000:
-        return False, f"Prompt too small: {len(content)} chars (min ~1000)"
-    
+def check_prompt_structure():
+    p = Path("templates/harvest-prompt.md")
+    if not p.exists(): return False, "harvest-prompt.md not found"
+    c = p.read_text()
+    for s in ["System Prompt","Instructions","Categories","Output Format","Confidence Scoring","Constraints","Example"]:
+        if s.lower() not in c.lower(): return False, f"Missing section: {s}"
+    for cat in ["fact","pitfall","pattern","tool-quirk","question"]:
+        if cat not in c: return False, f"Missing category: {cat}"
+    if len(c) > 5000: return False, f"Too large: {len(c)}"
+    if len(c) < 1000: return False, f"Too small: {len(c)}"
     return True, "Prompt structure is valid"
 
+def check_confidence_scoring():
+    c = Path("templates/harvest-prompt.md").read_text()
+    for l in ["0.9-1.0","0.7-0.8","0.5-0.6","0.3-0.4","0.1-0.2"]:
+        if l not in c: return False, f"Missing level: {l}"
+    return True, "Confidence scoring defined"
+
+def check_example_quality():
+    c = Path("templates/harvest-prompt.md").read_text()
+    if "example" not in c.lower(): return False, "No examples"
+    m = re.search(r'"knowledge"', c[c.lower().find("example"):])
+    if not m: return False, "No JSON example"
+    return True, "Examples present"
+
+def check_constraint_coverage():
+    c = Path("templates/harvest-prompt.md").read_text()
+    for x in ["no hallucination","explicitly","partial","failed sessions"]:
+        if x not in c.lower(): return False, f"Missing: {x}"
+    return True, "Constraints covered"
+
+def check_test_sessions():
+    d = Path("test_sessions")
+    if not d.exists(): return False, "test_sessions/ not found"
+    files = list(d.glob("*.jsonl"))
+    if len(files) < 5: return False, f"Only {len(files)} sessions"
+    for f in files:
+        for i, line in enumerate(f.read_text().strip().split("\n"), 1):
+            try: json.loads(line)
+            except json.JSONDecodeError as e: return False, f"{f.name}:{i}: {e}"
+    return True, f"{len(files)} valid sessions"
+
+def test_prompt_structure():
+    passed, msg = check_prompt_structure()
+    assert passed, msg
+
 def test_confidence_scoring():
-    """Test that confidence scoring is properly defined."""
-    prompt_path = Path("templates/harvest-prompt.md")
-    content = prompt_path.read_text()
-    
-    # Check for confidence scale definitions
-    confidence_levels = [
-        ("0.9-1.0", "explicitly stated"),
-        ("0.7-0.8", "clearly implied"),
-        ("0.5-0.6", "suggested"),
-        ("0.3-0.4", "inferred"),
-        ("0.1-0.2", "speculative")
-    ]
-    
-    for level, description in confidence_levels:
-        if level not in content:
-            return False, f"Missing confidence level: {level}"
-        if description.lower() not in content.lower():
-            return False, f"Missing confidence description: {description}"
-    
-    return True, "Confidence scoring is properly defined"
+    passed, msg = check_confidence_scoring()
+    assert passed, msg
 
 def test_example_quality():
-    """Test that examples are clear and complete."""
-    prompt_path = Path("templates/harvest-prompt.md")
-    content = prompt_path.read_text()
-    
-    # Check for example input/output
-    if "example" not in content.lower():
-        return False, "No examples provided"
-    
-    # Check that example includes all categories
-    example_section = content[content.lower().find("example"):]
-    
-    # Look for JSON example
-    json_match = re.search(r'\{[\s\S]*"knowledge"[\s\S]*\}', example_section)
-    if not json_match:
-        return False, "No JSON example found"
-    
-    example_json = json_match.group(0)
-    
-    # Check for all categories in example
-    for category in ["fact", "pitfall", "pattern", "tool-quirk", "question"]:
-        if category not in example_json:
-            return False, f"Example missing category: {category}"
-    
-    return True, "Examples are clear and complete"
+    passed, msg = check_example_quality()
+    assert passed, msg
 
 def test_constraint_coverage():
-    """Test that constraints cover all requirements."""
-    prompt_path = Path("templates/harvest-prompt.md")
-    content = prompt_path.read_text()
-    
-    required_constraints = [
-        "No hallucination",
-        "only extract",
-        "explicitly",
-        "partial",
-        "failed sessions",
-        "1k tokens"
-    ]
-    
-    for constraint in required_constraints:
-        if constraint.lower() not in content.lower():
-            return False, f"Missing constraint: {constraint}"
-    
-    return True, "Constraints cover all requirements"
+    passed, msg = check_constraint_coverage()
+    assert passed, msg
 
 def test_test_sessions():
-    """Test that test sessions exist and are valid."""
-    test_sessions_dir = Path("test_sessions")
-    if not test_sessions_dir.exists():
-        return False, "test_sessions directory not found"
-    
-    session_files = list(test_sessions_dir.glob("*.jsonl"))
-    if len(session_files) < 5:
-        return False, f"Only {len(session_files)} test sessions found, need 5"
-    
-    # Check each session file
-    for session_file in session_files:
-        content = session_file.read_text()
-        lines = content.strip().split("\n")
-        
-        # Check that each line is valid JSON
-        for i, line in enumerate(lines, 1):
-            try:
-                json.loads(line)
-            except json.JSONDecodeError as e:
-                return False, f"Invalid JSON in {session_file.name}, line {i}: {e}"
-    
-    return True, f"Found {len(session_files)} valid test sessions"
-
-def run_all_tests():
-    """Run all tests and return results."""
-    tests = [
-        ("Prompt Structure", test_prompt_structure),
-        ("Confidence Scoring", test_confidence_scoring),
-        ("Example Quality", test_example_quality),
-        ("Constraint Coverage", test_constraint_coverage),
-        ("Test Sessions", test_test_sessions)
-    ]
-    
-    results = []
-    all_passed = True
-    
-    for test_name, test_func in tests:
-        try:
-            passed, message = test_func()
-            results.append({
-                "test": test_name,
-                "passed": passed,
-                "message": message
-            })
-            if not passed:
-                all_passed = False
-        except Exception as e:
-            results.append({
-                "test": test_name,
-                "passed": False,
-                "message": f"Error: {str(e)}"
-            })
-            all_passed = False
-    
-    # Print results
-    print("=" * 60)
-    print("HARVEST PROMPT TEST RESULTS")
-    print("=" * 60)
-    
-    for result in results:
-        status = "✓ PASS" if result["passed"] else "✗ FAIL"
-        print(f"{status}: {result['test']}")
-        print(f"  {result['message']}")
-        print()
-    
-    print("=" * 60)
-    if all_passed:
-        print("ALL TESTS PASSED!")
-    else:
-        print("SOME TESTS FAILED!")
-    print("=" * 60)
-    
-    return all_passed, results
+    passed, msg = check_test_sessions()
+    assert passed, msg
 
 if __name__ == "__main__":
-    all_passed, results = run_all_tests()
-    
-    # Save results to file
-    with open("test_results.json", "w") as f:
-        json.dump({
-            "all_passed": all_passed,
-            "results": results,
-            "timestamp": "2026-04-14T19:05:00Z"
-        }, f, indent=2)
-    
-    print(f"Results saved to test_results.json")
-    
-    # Exit with appropriate code
-    exit(0 if all_passed else 1)
+    checks = [check_prompt_structure, check_confidence_scoring, check_example_quality, check_constraint_coverage, check_test_sessions]
+    for fn in checks:
+        ok, msg = fn()
+        print(f"{'PASS' if ok else 'FAIL'}: {fn.__name__} -- {msg}")