@davidorex/pi-workflows 0.14.6 → 0.28.0

package/templates/plan-decomposer/task.md

@@ -1,46 +0,0 @@
-## Phase: {{ phase.name }}
-
-### Intent
-{{ phase.intent }}
-
-### Success Criteria
-{% for criterion in phase.success_criteria %}
-- {{ criterion.criterion }} (verify: {{ criterion.verify_method }})
-{% endfor %}
-
-### Specs
-{% if phase.specs %}
-{% for spec in phase.specs %}
-- **{{ spec.id }}**: {{ spec.name }}
-{% endfor %}
-{% endif %}
-
-### Current Architecture
-{% for module in architecture.modules %}
-- **{{ module.name }}** ({{ module.file }}): {{ module.responsibility }}
-{% endfor %}
-
-### Conventions
-{% for rule in conventions.rules %}
-- {{ rule.id }}: {{ rule.description }} ({{ rule.enforcement }})
-{% endfor %}
-
-## Instructions
-
-Decompose this phase into implementation plans. Each plan should be a focused unit of work that one agent can complete in a single context window.
-
-Before creating plans:
-1. Read source files referenced in the architecture to understand existing patterns
-2. Identify logical boundaries — which specs or features are independent
-3. Determine which plans can run in parallel (independent file sets)
-
-For each plan, produce:
-- **name**: short identifier for the plan
-- **intent**: what this plan accomplishes and why
-- **tasks**: concrete list of things to do (create files, add tests, wire up)
-- **files_to_change**: paths that will be created or modified
-- **acceptance_criteria**: how to know the plan is done
-- **context_needed**: files or modules the implementing agent should read first
-- **parallel_group**: group name — plans in the same group can run concurrently (independent file sets get the same group; dependent plans get different groups)
-
-Output a JSON object with a `plans` array conforming to the plan-breakdown schema.

package/templates/project-definer/task.md

@@ -1,67 +0,0 @@
-## Vision Statement
-
-{{ vision }}
-
-{% if context %}
-## Additional Context
-
-{{ context }}
-{% endif %}
-
-## Instructions
-
-Produce a structured project identity from the vision statement above. Extract, infer, or derive each field — do not leave gaps where the vision provides signal.
-
-### Fields to produce
-
-1. **name** — short, lowercase-hyphenated project identifier
-2. **description** — 1-3 sentences capturing what the project does and why it matters
-3. **core_value** — one sentence a stakeholder outside the project could understand
-4. **target_users** — array of user roles or personas who benefit
-5. **constraints** — array of `{ type, description }` objects reflecting real limitations from the vision
-   - type examples: "technical", "organizational", "timeline", "budget", "regulatory", "compatibility"
-6. **scope_boundaries** — `{ in: [...], out: [...] }` capturing what is and is not in scope
-   - `out` is especially important: document what a reader might assume is in scope but is not
-7. **goals** — array of `{ id, description, success_criteria: [...] }` objects
-   - IDs: G-001, G-002, etc.
-   - success_criteria: measurable or verifiable statements (not aspirational)
-8. **status** — set to `"inception"`
-
-{% if stack %}
-### Stack
-
-The following technology stack has been specified:
-
-{% for item in stack %}
-- {{ item }}
-{% endfor %}
-
-Include these in the output `stack` array.
-{% endif %}
-
-{% if repository %}
-### Repository
-
-Repository: {{ repository }}
-
-Include this in the output `repository` field.
-{% endif %}
-
-### Output format
-
-Produce a single JSON object. Every required field must be present. The object should conform to the project block schema:
-
-```json
-{
-  "name": "string (required)",
-  "description": "string (required)",
-  "core_value": "string (required)",
-  "target_users": ["string"],
-  "constraints": [{ "type": "string", "description": "string" }],
-  "scope_boundaries": { "in": ["string"], "out": ["string"] },
-  "goals": [{ "id": "G-001", "description": "string", "success_criteria": ["string"] }],
-  "status": "inception",
-  "repository": "string (if provided)",
-  "stack": ["string (if provided)"]
-}
-```

package/templates/project-inferrer/task.md

@@ -1,56 +0,0 @@
-Infer the project identity for the project at `{{ path }}`.
-
-## Codebase Analysis
-
-{% if exploration.files is defined %}
-### Files ({{ exploration.files | length }} total)
-{% for file in exploration.files | batch(20) | first %}
-- `{{ file.path }}` ({{ file.language | default("unknown") }})
-{% endfor %}
-{% if exploration.files | length > 20 %}
-... and {{ exploration.files | length - 20 }} more files
-{% endif %}
-{% endif %}
-
-{% if exploration.entryPoints is defined %}
-### Entry Points
-{% for ep in exploration.entryPoints %}
-- `{{ ep }}`
-{% endfor %}
-{% endif %}
-
-## Instructions
-
-Read project metadata and documentation to determine the project's identity. Start with:
-- README.md (or equivalent)
-- Package manifest (package.json, Cargo.toml, pyproject.toml, go.mod, etc.)
-- CLAUDE.md or similar project instructions if present
-- CI/CD configuration if present
-
-Produce a project identity block:
-
-1. **name** — the project's canonical name (from package manifest, not directory name)
-2. **description** — concise summary of what the project does (2-3 sentences max)
-3. **core_value** — single sentence: why does this project exist? What value does it provide?
-4. **target_users** — who uses this? (e.g., "TypeScript developers", "DevOps engineers", "data scientists")
-5. **constraints** — each with `type` and `description`:
-   - Runtime constraints (Node.js version, browser support, etc.)
-   - Language constraints (TypeScript strict mode, ESM-only, etc.)
-   - Compatibility constraints (API stability, backward compat, etc.)
-6. **scope_boundaries**:
-   - `in`: what the project explicitly does
-   - `out`: what the project explicitly does not do (deferred or excluded)
-7. **goals** — each with `id`, `description`, and optional `success_criteria` array
-   - Only include goals evidenced by the codebase (README roadmap, issues, TODO markers)
-8. **status** — one of: inception, planning, development, maintenance, complete
-   - Infer from: version maturity, commit recency, test coverage, presence of CI
-9. **repository** — repository URL if discoverable from package manifest or git remote
-10. **stack** — primary technology choices only (language, framework, key libraries — not every dependency)
-
-## Required Output Schema
-
-You MUST produce JSON conforming exactly to this schema. Every required field must be present.
-
-```json
-{{ output_schema }}
-```

package/templates/requirements-gatherer/task.md

@@ -1,90 +0,0 @@
-## Project Identity
-
-**Name:** {{ project.name }}
-**Description:** {{ project.description }}
-**Core Value:** {{ project.core_value }}
-
-### Target Users
-{% for user in project.target_users %}
-- {{ user }}
-{% endfor %}
-
-### Constraints
-{% for constraint in project.constraints %}
-- [{{ constraint.type }}] {{ constraint.description }}
-{% endfor %}
-
-### Scope Boundaries
-
-**In scope:**
-{% for item in project.scope_boundaries.in %}
-- {{ item }}
-{% endfor %}
-
-**Out of scope:**
-{% for item in project.scope_boundaries.out %}
-- {{ item }}
-{% endfor %}
-
-### Goals
-{% for goal in project.goals %}
-- **{{ goal.id }}**: {{ goal.description }}
-  {% for criterion in goal.success_criteria %}- {{ criterion }}
-  {% endfor %}
-{% endfor %}
-
-{% if vision %}
-## Original Vision
-
-{{ vision }}
-{% endif %}
-
-## Instructions
-
-Derive requirements from the project identity above. Produce a comprehensive but proportionate set of requirements covering what the system must do (functional), quality attributes it must exhibit (non-functional), hard limits it must respect (constraint), and external connections it must support (integration).
-
-### For each requirement, provide:
-
-1. **id** — unique, formatted as REQ-001, REQ-002, etc.
-2. **description** — clear statement of what is required
-3. **type** — one of: `functional`, `non-functional`, `constraint`, `integration`
-4. **status** — set to `"proposed"` for all
-5. **priority** — MoSCoW: `must`, `should`, `could`, `wont`
-6. **acceptance_criteria** — array of specific, verifiable statements
-7. **source** — set to `"agent"` for all
-8. **depends_on** — array of other requirement IDs this depends on (empty array if none)
-
-### Priority guidance
-
-- **must**: the project fails without this — directly tied to core_value and essential goals
-- **should**: important for target users but the project could ship a minimal version without it
-- **could**: enhances the experience but is clearly secondary
-- **wont**: explicitly excluded — derive these from scope_boundaries.out
-
-### Coverage expectations
-
-- Every goal should map to at least one "must" requirement
-- Every constraint should appear as a "constraint" type requirement
-- Include at least one non-functional requirement for each quality attribute the project implies (performance, security, usability, reliability, etc. — only those that are relevant)
-- Include "wont" requirements for major items in scope_boundaries.out
-
-### Output format
-
-Produce a single JSON object with a `requirements` array:
-
-```json
-{
-  "requirements": [
-    {
-      "id": "REQ-001",
-      "description": "string",
-      "type": "functional",
-      "status": "proposed",
-      "priority": "must",
-      "acceptance_criteria": ["string"],
-      "source": "agent",
-      "depends_on": []
-    }
-  ]
-}
-```

package/templates/researcher/task.md

@@ -1,26 +0,0 @@
-## Research Request
-
-**Gap:** {{ gap.id }} — {{ gap.description }}
-
-## Questions
-
-{% for q in research_questions %}
-{{ loop.index }}. {{ q }}
-{% endfor %}
-
-## Instructions
-
-For each question:
-1. Answer based on known software engineering patterns, best practices, and established solutions
-2. Rate your confidence: `high` (well-known, widely used), `medium` (established but context-dependent), `low` (best guess)
-3. List sources where possible — documentation, known projects, pattern names
-
-Also identify applicable patterns and concrete recommendations.
-
-## Required Output Schema
-
-You MUST produce JSON conforming exactly to this schema. Every required field must be present.
-
-```json
-{{ output_schema }}
-```

package/templates/shared/macros.md

@@ -1,152 +0,0 @@
-{#- Block rendering macros — one per schema with agent prompt use cases.
-    Import via: {% from "shared/macros.md" import render_project, render_architecture %}
-    Each macro: null guard, markdown heading, field rendering. Missing data renders nothing. -#}
-
-{% macro render_project(data) %}
-{% if data %}
-## Project
-**{{ data.name }}** — {{ data.description }}
-{% if data.core_value %}Core value: {{ data.core_value }}{% endif %}
-{% if data.vision %}
-Vision: {{ data.vision }}{% endif %}
-{% if data.status %}Status: {{ data.status }}{% endif %}
-{% if data.target_users %}
-Target users: {{ data.target_users | join(", ") }}{% endif %}
-{% if data.constraints %}
-### Constraints
-{% for c in data.constraints %}- [{{ c.type }}] {{ c.description }}
-{% endfor %}{% endif %}
-{% if data.scope_boundaries %}
-### Scope
-**In:** {% for s in data.scope_boundaries.in %}{{ s }}{% if not loop.last %}, {% endif %}{% endfor %}
-
-**Out:** {% for s in data.scope_boundaries.out %}{{ s }}{% if not loop.last %}, {% endif %}{% endfor %}
-{% endif %}
-{% if data.goals %}
-### Goals
-{% for g in data.goals %}- **{{ g.id }}**: {{ g.description }}{% if g.success_criteria %} — criteria: {{ g.success_criteria | join("; ") }}{% endif %}
-{% endfor %}{% endif %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_architecture(data) %}
-{% if data %}
-## Architecture
-{% if data.overview %}{{ data.overview }}
-{% endif %}
-{% if data.modules %}
-### Modules
-{% for m in data.modules %}- **{{ m.name }}** (`{{ m.file }}`{% if m.lines %}, {{ m.lines }} lines{% endif %}): {{ m.responsibility }}{% if m.dependencies %} — deps: {{ m.dependencies | join(", ") }}{% endif %}
-{% endfor %}{% endif %}
-{% if data.patterns %}
-### Patterns
-{% for p in data.patterns %}- **{{ p.name }}**: {{ p.description }}{% if p.used_in %} — used in: {{ p.used_in | join(", ") }}{% endif %}
-{% endfor %}{% endif %}
-{% if data.boundaries %}
-### Boundaries
-{% for b in data.boundaries %}- {{ b }}
-{% endfor %}{% endif %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_requirements(data) %}
-{% if data and data.requirements and data.requirements | length > 0 %}
-## Requirements
-{% for r in data.requirements %}- **{{ r.id }}** [{{ r.priority }}] ({{ r.type }}, {{ r.status }}): {{ r.description }}{% if r.acceptance_criteria %}
-  Criteria: {{ r.acceptance_criteria | join("; ") }}{% endif %}
-{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_conformance(data) %}
-{% if data and data.principles %}
-## Conformance Reference
-{% if data.name %}**{{ data.name }}**{% endif %}
-{% for p in data.principles %}
-### {{ p.id }}: {{ p.name }}
-{% if p.description %}{{ p.description }}{% endif %}
-{% for r in p.rules %}- **{{ r.id }}**: {{ r.rule }}{% if r.severity %} [{{ r.severity }}]{% endif %}{% if r.check_method %} — check: {{ r.check_method }}{% endif %}
-{% if r.anti_patterns %}  Anti-patterns: {{ r.anti_patterns | join("; ") }}
-{% endif %}{% endfor %}
-{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_domain(data) %}
-{% if data and data.entries %}
-## Domain Knowledge
-{% for e in data.entries %}- **{{ e.id }}** [{{ e.category }}]: {{ e.title }}
-  {{ e.content }}{% if e.tags %} — tags: {{ e.tags | join(", ") }}{% endif %}
-{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_decisions(data) %}
-{% if data and data.decisions %}
-## Decisions
-{% for d in data.decisions %}- **{{ d.id }}** ({{ d.status }}): {{ d.decision }}
-  Rationale: {{ d.rationale }}{% if d.context %} — context: {{ d.context }}{% endif %}
-{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_tasks(data) %}
-{% if data and data.tasks %}
-## Tasks
-{% for t in data.tasks %}- **{{ t.id }}** [{{ t.status }}]: {{ t.description }}{% if t.phase %} (phase {{ t.phase }}){% endif %}{% if t.files %} — files: {{ t.files | join(", ") }}{% endif %}
-{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_issues(data) %}
-{% if data and data.issues %}
-## Issues
-{% for i in data.issues %}- **{{ i.id }}** [{{ i.priority }}, {{ i.status }}]: {{ i.title }}
-  {{ i.body }}{% if i.location %} — {{ i.location }}{% endif %}{% if i.package %} ({{ i.package }}){% endif %}
-{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_exploration(exploration) %}
-{% if exploration %}
-{% if exploration.files is defined %}
-## Prior Exploration
-{% for file in exploration.files %}- `{{ file.path }}` ({{ file.lines | default("?") }} lines){% if file.exports %}: {{ file.exports | length }} exports{% endif %}
-{% endfor %}{% endif %}
-{% if exploration.types is defined %}
-### Known Types
-{% for t in exploration.types %}- `{{ t.name }}` ({{ t.kind }}) in `{{ t.file }}`
-{% endfor %}{% endif %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_exploration_full(exploration) %}
-{% if exploration %}
-{% if exploration.files is defined %}
-### Files{% if exploration.files | length > 20 %} ({{ exploration.files | length }} total){% endif %}
-{% for file in exploration.files %}- `{{ file.path }}` ({{ file.language | default("unknown") }}, {{ file.lines | default("?") }} lines){% if file.exports %} — {{ file.exports | length }} exports{% endif %}
-{% endfor %}{% endif %}
-{% if exploration.types is defined %}
-### Types
-{% for t in exploration.types %}- `{{ t.name }}` ({{ t.kind }}) in `{{ t.file }}`
-{% endfor %}{% endif %}
-{% if exploration.dependencies is defined %}
-### Dependencies
-{% for d in exploration.dependencies %}- `{{ d.from }}` → `{{ d.to }}` ({{ d.type | default("import") }})
-{% endfor %}{% endif %}
-{% if exploration.entryPoints is defined %}
-### Entry Points
-{% for ep in exploration.entryPoints %}- `{{ ep }}`
-{% endfor %}{% endif %}
-{% endif %}
-{% endmacro %}
-
-{% macro render_gap(gap) %}
-{% if gap %}
-**ID:** {{ gap.id }}
-**Description:** {{ gap.description }}
-**Category:** {{ gap.category | default("unspecified") }}
-**Priority:** {{ gap.priority | default("unspecified") }}
-{% if gap.details %}**Details:** {{ gap.details }}{% endif %}
-{% endif %}
-{% endmacro %}

package/templates/spec-implementer/task.md

@@ -1,53 +0,0 @@
-## Plan: {{ spec.name }}
-
-### Intent
-{{ spec.intent | default(spec.description, true) }}
-
-{% if spec.tasks %}
-### Tasks
-{% for task in spec.tasks %}
-{{ loop.index }}. {{ task }}
-{% endfor %}
-{% endif %}
-
-### Files to Change
-{% for f in spec.files_to_change | default(spec.files, true) %}
-- `{{ f }}`
-{% endfor %}
-
-### Acceptance Criteria
-{% for criterion in spec.acceptance_criteria %}
-- {{ criterion }}
-{% endfor %}
-
-{% if spec.context_needed %}
-### Context to Read First
-{% for ctx in spec.context_needed %}
-- `{{ ctx }}`
-{% endfor %}
-{% endif %}
-
-### Architecture Reference
-{% for module in architecture.modules %}
-- **{{ module.name }}** ({{ module.file }}): {{ module.responsibility }}
-{% endfor %}
-
-### Conventions
-{% for rule in conventions.rules %}
-- {{ rule.id }}: {{ rule.description }} ({{ rule.enforcement }})
-{% endfor %}
-
-## Instructions
-
-Implement this plan. Follow these steps:
-
-1. **Read context first**: Read the files listed under "Context to Read First" and any related source files to understand existing patterns
-2. **Implement each task**: Work through the task list in order, writing code that follows the project conventions
-3. **Run tests**: After implementation, run the relevant test suite to verify your changes work
-4. **Validate acceptance criteria**: Confirm each acceptance criterion is met
-
-Produce a JSON result conforming to this schema:
-
-```json
-{{ output_schema }}
-```

package/templates/synthesizer/system.md

@@ -1,3 +0,0 @@
-You are a report synthesizer. You receive typed analysis data from three independent reviewers (structure, quality, patterns) and produce a unified synthesis as structured JSON.
-
-Every finding must trace to specific data from the input analyses. Do not invent findings that aren't grounded in the input data.

package/templates/synthesizer/task.md

@@ -1,38 +0,0 @@
-Synthesize the following analyses into a unified report.
-
-## Structure Analysis
-Architecture: {{ structure.architecture.organization }}
-Patterns: {% for p in structure.architecture.patterns %}{{ p }}{% if not loop.last %}, {% endif %}{% endfor %}
-
-### Modules
-{% for m in structure.modules %}
-- **{{ m.name }}**: {{ m.responsibility }} ({{ m.files | length }} files)
-{% endfor %}
-
-### Dependencies
-{% for d in structure.dependencies %}
-- `{{ d.from }}` → `{{ d.to }}` ({{ d.type }})
-{% endfor %}
-
-## Quality Analysis
-{% for c in quality.concerns %}
-- [{{ c.severity }}] {{ c.description }}{% if c.file %} in `{{ c.file }}`{% endif %}
-{% endfor %}
-
-### Test Coverage
-- Tested: {% for t in quality.testCoverage.tested %}`{{ t }}`{% if not loop.last %}, {% endif %}{% endfor %}
-- Untested: {% for t in quality.testCoverage.untested %}`{{ t }}`{% if not loop.last %}, {% endif %}{% endfor %}
-
-### Maintainability: {{ quality.maintainability.score }}
-
-## Pattern Analysis
-{% for p in patterns.patterns %}
-- **{{ p.name }}**: {{ p.usage }}{% if not p.correct %} ⚠️{% endif %}
-{% endfor %}
-
-### Recommendations
-{% for r in patterns.recommendations %}
-- [{{ r.priority }}] **{{ r.pattern }}**: {{ r.suggestion }}
-{% endfor %}
-
-Write your synthesis as JSON conforming to the output schema.

package/templates/task-verifier/task.md

@@ -1,44 +0,0 @@
-Verify whether the following task implementation satisfies its acceptance criteria.
-
-## Task: {{ task_id }}
-
-## Acceptance Criteria
-
-{% for criterion in acceptance_criteria %}
-{{ loop.index }}. {{ criterion }}
-{% endfor %}
-
-## Implementation Changes
-
-{% if changes is mapping %}
-{% if changes.tasks is defined %}
-### Worker Results
-- Status: {{ changes.status | default("unknown") }}
-{% for t in changes.tasks %}
-- **{{ t.name }}**: {{ t.status }}{% if t.files_modified %} (files: {{ t.files_modified | join(", ") }}){% endif %}
-{% if t.notes %} — {{ t.notes }}{% endif %}
-{% endfor %}
-{% else %}
-```json
-{{ changes | dump(2) }}
-```
-{% endif %}
-{% else %}
-{{ changes }}
-{% endif %}
-
-## Instructions
-
-For EACH acceptance criterion above:
-
-1. Read the relevant source files to understand the current code state
-2. If the criterion is verifiable by command (test, build, lint), run the command
-3. If the criterion requires code inspection, read the files and assess
-4. Record your verdict: `passed`, `failed`, or `skipped`
-5. Provide specific evidence (file:line references, command output, code snippets)
-
-Then produce a JSON verification entry:
-
-```json
-{{ output_schema }}
-```

package/templates/task-worker/task.md

@@ -1,52 +0,0 @@
-## Task: {{ task.id }}
-
-### Description
-{{ task.description }}
-
-{% if task.phase %}
-### Phase
-{{ task.phase }}
-{% endif %}
-
-### Files
-{% for f in task.files %}
-- `{{ f }}`
-{% endfor %}
-
-### Acceptance Criteria
-{% for criterion in task.acceptance_criteria %}
-- [ ] {{ criterion }}
-{% endfor %}
-
-{% if task.depends_on %}
-### Dependencies (completed)
-{% for dep in task.depends_on %}
-- {{ dep }}
-{% endfor %}
-{% endif %}
-
-{% if task.notes %}
-### Notes
-{{ task.notes }}
-{% endif %}
-
-{% if context %}
-### Context
-{{ context }}
-{% endif %}
-
-## Instructions
-
-Implement this task. Follow these steps:
-
-1. **Read the target files** listed above to understand the current state
-2. **Implement changes** that satisfy each acceptance criterion
-3. **Stay within scope** — only modify the files listed, unless a new file is strictly necessary
-4. **Run tests** after implementation to verify nothing is broken
-5. **Validate each criterion** — confirm every acceptance criterion is addressed
-
-Produce a JSON result conforming to this schema:
-
-```json
-{{ output_schema }}
-```

package/templates/verifier/task.md

@@ -1,57 +0,0 @@
-You are verifying the output of a prior step against declared success criteria.
-
-## Success Criteria
-
-{% for criterion in criteria %}
-- {{ criterion }}
-{% endfor %}
-
-## Step Output to Verify
-
-```json
-{{ step_output | dump(2) }}
-```
-
-{% if files_to_check %}
-## Files to Check
-
-{% for f in files_to_check %}
-- `{{ f }}`
-{% endfor %}
-{% endif %}
-
-## Instructions
-
-For each criterion, choose the appropriate verification method and execute it:
-
-1. **command** — Run a shell command (test suite, build, lint) and report exit code + output as evidence
-2. **grep** — Search for specific patterns in files and report matches as evidence
-3. **inspect** — Read files and assess their content (use your judgment)
-4. **human** — Flag items that require human eyes and explain why automation cannot verify them
-
-### Process
-
-1. Evaluate each success criterion using the most appropriate verify method
-2. For `command` criteria: actually run the command and capture the output
-3. For `grep` criteria: search the relevant files and report what you find
-4. For `inspect` criteria: read the files and assess whether they meet the criterion
-5. For `human` criteria: describe what needs to be checked and why it needs a person
-6. Build truth claims from your observations, marking each as `verified`, `failed`, or `uncertain`
-7. Check that all referenced artifacts exist and are substantive (not stubs)
-8. Compute an overall score as "N/M" where N = passed criteria, M = total criteria
-9. Set status: `passed` if all criteria pass, `gaps_found` if any fail, `human_needed` if any require human review
-
-### Output Format
-
-Produce JSON conforming to the verifier-output schema with these fields:
-
-- `status`: "passed" | "gaps_found" | "human_needed"
-- `score`: "N/M" format
-- `truths[]`: observable claims with status and evidence
-- `criteria_results[]`: one entry per criterion with verify_method, status, expected/actual outcome, evidence
-- `artifacts[]`: (optional) file paths checked with existence/substance status
-- `requirements_coverage[]`: (optional) requirement satisfaction mapping
-- `human_verification[]`: (optional) items needing human review
-- `gaps[]`: (optional) failed or uncertain truths with reasons
-
-Be thorough. Run actual commands. Read actual files. Report what you observe, not what you assume.