@davidorex/pi-workflows 0.26.0 → 0.28.1

package/templates/items/tasks.md

@@ -1,29 +0,0 @@
-{#-
-  Per-item macro for the `tasks` block (Plan 8 / per-item-macros wave 4).
-
-  Block schema: .project/schemas/tasks.schema.json. Each item is one task
-  inside data.tasks[]. Required: id (^TASK-\d{3,}$), description, status.
-  Optional: phase (string|integer), files, acceptance_criteria, depends_on
-  (other task IDs), assigned_agent, verification (verification ID), notes.
-
-  When status === "completed", schema additionally requires verification
-  (the if/then conditional in the schema).
-
-  Cross-block reference recursion (depends_on, verification) is delegated to
-  shared/render-helpers.md — see that file for the depth contract, ambient
-  globals, and empty-array convention. verification is rendered as a single
-  inline reference (one ID) rather than a list.
-
-  Files field:
-    files[] is a list of code paths, not project-block IDs. Rendered inline
-    as a comma-separated list; never recursed.
--#}
-{% from "shared/render-helpers.md" import render_id_list_inline, render_id_single_inline %}
-
-{% macro render_task(t, depth=0) %}
-{% if t %}- **{{ t.id }}** [{{ t.status }}]: {{ enforceBudget(t.description, "tasks", "tasks.items.description") }}{% if t.phase %} (phase {{ t.phase }}){% endif %}{% if t.files %} — files: {{ t.files | join(", ") }}{% endif %}
-{% if t.acceptance_criteria %}  Criteria: {% for ac in t.acceptance_criteria %}{{ enforceBudget(ac, "tasks", "tasks.items.acceptance_criteria.items") }}{% if not loop.last %}; {% endif %}{% endfor %}
-{% endif %}{% if t.assigned_agent %}  Assigned agent: {{ t.assigned_agent }}
-{% endif %}{% if t.notes %}  Notes: {{ enforceBudget(t.notes, "tasks", "tasks.items.notes") }}
-{% endif %}{{ render_id_list_inline("Depends on", t.depends_on, depth) }}{{ render_id_single_inline("Verification", t.verification, depth) }}{% endif %}
-{% endmacro %}

package/templates/phase-author/task.md

@@ -1,82 +0,0 @@
-## Intent
-
-{{ intent }}
-
-## Existing Phases
-
-{% for phase in phases %}
-- Phase {{ phase.number }}: {{ phase.name }} ({{ phase.status }})
-{% endfor %}
-
-{% if architecture and architecture.modules %}
-## Current Architecture
-
-{% for module in architecture.modules %}
-- **{{ module.name }}** ({{ module.file }}, {{ module.lines }} lines): {{ module.responsibility }}
-{% endfor %}
-
-{% if architecture.compilation_pipeline %}
-### Compilation Pipeline
-{% for stage in architecture.compilation_pipeline %}
-{{ loop.index }}. **{{ stage.stage }}**: {{ stage.description }}
-{% endfor %}
-{% endif %}
-{% endif %}
-
-{% if conventions and conventions.rules %}
-## Conventions
-
-{% for rule in conventions.rules %}
-- {{ rule.id }}: {{ rule.description }} ({{ rule.enforcement }})
-{% endfor %}
-{% endif %}
-
-{% if gaps and gaps.gaps %}
-## Current Gaps
-
-{% for gap in gaps.gaps %}
-{% if gap.status == "open" %}
-- [{{ gap.priority }}] {{ gap.id }}: {{ gap.description }}
-{% endif %}
-{% endfor %}
-{% endif %}
-
-{% if inventory %}
-## Current Inventory
-
-{% if inventory.step_types %}- Step types: {{ inventory.step_types | length }}
-{% endif %}{% if inventory.agent_specs %}- Agent specs: {{ inventory.agent_specs | length }}
-{% endif %}{% if inventory.schemas %}- Schemas: {{ inventory.schemas | length }}
-{% endif %}{% if inventory.test_count is defined %}- Tests: {{ inventory.test_count }}
-{% endif %}{% endif %}
-
-## Instructions
-
-Convert the intent above into a structured phase spec. Read the codebase to understand what exists and what the intent requires.
-
-1. **Determine the phase number** — next after the highest existing phase number
-2. **Write a clear intent statement** — what this phase accomplishes and why
-3. **Define success criteria** — each with a verify_method:
-   - `command`: can be verified by running a shell command (test suite, grep, validate)
-   - `inspect`: requires reading files and assessing content
-   - `human`: requires human judgment
-4. **Decompose into specs** — each spec is a focused unit of work:
-   - Sequential numbering continuing from the last spec in the previous phase
-   - Clear intent per spec
-   - Concrete acceptance criteria (strings, each independently checkable)
-   - Specs should be ordered by dependency — earlier specs don't depend on later ones
-5. **Identify dependencies** — which phase numbers this phase depends on
-6. **List artifacts produced** — file paths this phase will create or modify
-
-### Sizing guidance
-
-- Each spec should be completable by one agent in one context window
-- If a spec needs more than ~5 files changed, split it
-- If a spec has more than ~5 acceptance criteria, it might be doing too much
-- Group related changes (e.g., schema + instance + validation test = one spec)
-
-### Cross-reference gaps
-
-Check if any existing open gaps are addressed by this phase. If so, note that in the spec intent — the gap can be marked resolved when the spec completes.
-
-Produce a JSON object conforming to the phase schema.

package/templates/plan-creator/task.md

@@ -1,143 +0,0 @@
-## Project Identity
-
-**Name:** {{ project.name }}
-**Description:** {{ project.description }}
-**Core Value:** {{ project.core_value }}
-**Status:** {{ project.status }}
-{% if project.stack %}
-
-### Stack
-{% for item in project.stack %}
-- {{ item }}
-{% endfor %}
-{% endif %}
-
-## Requirements Summary
-
-{% for req in requirements.requirements %}
-{% if req.priority == "must" %}
-- **{{ req.id }}** [must/{{ req.type }}]: {{ req.description }}
-{% endif %}
-{% endfor %}
-{% for req in requirements.requirements %}
-{% if req.priority == "should" %}
-- **{{ req.id }}** [should/{{ req.type }}]: {{ req.description }}
-{% endif %}
-{% endfor %}
-{% for req in requirements.requirements %}
-{% if req.priority == "could" %}
-- **{{ req.id }}** [could/{{ req.type }}]: {{ req.description }}
-{% endif %}
-{% endfor %}
-
-## Architecture
-
-**Overview:** {{ architecture.overview }}
-
-### Modules
-{% for module in architecture.modules %}
-- **{{ module.name }}** (`{{ module.file }}`): {{ module.responsibility }}{% if module.dependencies %} [depends: {{ module.dependencies | join(", ") }}]{% endif %}
-{% endfor %}
-
-### Patterns
-{% for pattern in architecture.patterns %}
-- **{{ pattern.name }}**: {{ pattern.description }} (used in: {{ pattern.used_in | join(", ") }})
-{% endfor %}
-
-### Boundaries
-{% for boundary in architecture.boundaries %}
-- {{ boundary }}
-{% endfor %}
-
-{% if existing_files %}
-## Existing Project Files
-
-The project directory already contains these files:
-{% for file in existing_files %}
-- {{ file }}
-{% endfor %}
-
-Account for existing structure — do not plan to recreate files that already exist unless they need modification.
-{% endif %}
-
-## Instructions
-
-Create implementation phases and tasks that build this project incrementally. The plan should take the project from its current state ({{ project.status }}) to a working system that satisfies all "must" requirements and addresses "should" requirements.
-
-### Phase guidelines
-
-1. **Phase 1** — Foundation: project structure, core module scaffolding, configuration, initial tests
-2. **Phase 2+** — Layer functionality in priority order: "must" requirements first, then "should"
-3. **Final phase** — Integration, documentation, and verification
-4. Each phase should represent a meaningful milestone — the project is more capable after each phase
-5. A phase with more than 8-10 tasks is likely too large — split it
-
-### For each phase, provide:
-
-- **number** — sequential starting at 1
-- **name** — short descriptive name
-- **intent** — what this phase accomplishes and why it comes at this point
-- **goal** — what is true after this phase that was not true before
-- **status** — `"planned"`
-- **success_criteria** — array of `{ criterion, verify_method }` (verify_method: "command", "inspect", or "test")
-- **dependencies** — array of phase numbers this depends on (empty for phase 1)
-- **inputs** — what this phase needs from prior phases or external sources
-- **outputs** — what this phase produces for later phases or users
-
-### For each task, provide:
-
-- **id** — unique, formatted as T-001, T-002, etc.
-- **description** — clear statement of what to do
-- **status** — `"planned"`
-- **phase** — phase number this belongs to
-- **files** — array of file paths this task creates or modifies
-- **acceptance_criteria** — array of specific, verifiable statements
-- **depends_on** — array of task IDs this depends on (empty if none)
-- **notes** — optional: any implementation guidance or caveats
-
-### Task sizing
-
-- Each task should be completable by one agent in one context window
-- A task touching more than 3-5 files likely needs splitting
-- A task with more than 5 acceptance criteria may be doing too much
-- Group related changes: schema + implementation + test = one task when files are few
-
-### Traceability
-
-- Every "must" requirement should be addressed by at least one task
-- Every task's files should map to at least one architecture module
-- Note requirement IDs in task descriptions or notes where the mapping is clear
-
-### Output format
-
-Produce a single JSON object with two arrays:
-
-```json
-{
-  "phases": [
-    {
-      "number": 1,
-      "name": "string",
-      "intent": "string",
-      "goal": "string",
-      "status": "planned",
-      "success_criteria": [{ "criterion": "string", "verify_method": "command" }],
-      "dependencies": [],
-      "inputs": ["string"],
-      "outputs": ["string"]
-    }
-  ],
-  "tasks": [
-    {
-      "id": "T-001",
-      "description": "string",
-      "status": "planned",
-      "phase": 1,
-      "files": ["src/file.ts"],
-      "acceptance_criteria": ["string"],
-      "depends_on": [],
-      "notes": "optional string"
-    }
-  ]
-}
-```

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,137 +0,0 @@
-{#- Block rendering macros — whole-block forms as derived views over per-item macros.
-
-    Plan 8 (Wave 4) refactor: each whole-block macro that has a per-item sibling
-    in templates/items/<kind>.md delegates to that per-item macro by mapping
-    over the items array. Per-item macros own field rendering; whole-block macros
-    own the surrounding heading and the null/empty guard.
-
-    v0.24.2 follow-up (Item 3 of 2026-05-02 residual-debt patch): the
-    repeated `{% if data and data.<key> [and data.<key> | length > 0] %}` +
-    `## <Heading>` + `{% for x in data.<key> %}{{ render_<kind>_item(x) }}
-    {% endfor %}` shape that previously lived inline in render_requirements,
-    render_domain, render_tasks, and render_issues now routes through the
-    `render_whole_block_truthy` / `render_whole_block_nonempty` scaffolds in
-    shared/render-helpers.md. The guard / heading / loop chassis lives once
-    in render-helpers; each whole-block macro here is the per-kind binding
-    (heading text, items slice, per-item macro inside the `{% call %}` body).
-    Output stays byte-identical to the prior inline shape — the two
-    truthy-vs-nonempty helpers preserve the empty-array surface each
-    delegator originally shipped (tasks/issues/domain emit `## <Heading>`
-    with empty array; requirements emits nothing — both regimes are kept
-    explicitly so existing consumers see no diff).
-
-    Imports for downstream consumers (unchanged signatures):
-        {% from "shared/macros.md" import render_project, render_architecture,
-                                          render_requirements, render_conformance,
-                                          render_domain, render_tasks, render_issues,
-                                          render_conventions,
-                                          render_exploration, render_exploration_full %}
-
-    Each macro:
-      - null/empty guard via the helper or local conditional,
-      - markdown heading (via the helper for list kinds; inline for the
-        singletons and the heading-bearing block-level shapes),
-      - delegation loop calling the per-item macro per item.
-
-    Retired in Plan 8:
-      - render_decisions(data) — legacy whole-block decisions macro deleted.
-        The new lifecycle decisions block has its own per-item macro
-        (templates/items/decisions.md ships render_decision + alias
-        render_decisions). The legacy macro rendered fields (decision,
-        rationale) that no longer match the current decisions.schema.json.
-      - render_gap(gap) — legacy single-item validation-concept macro deleted.
-        The framework-gaps.json block uses Plan 7's render_framework_gap in
-        templates/items/framework-gaps.md.
-
-    Retained as-is:
-      - render_exploration(exploration) and render_exploration_full(exploration)
-        are workflow-step output formatters (rendering exploration payloads
-        emitted by exploration agents), not project-block renderers. They do
-        not fit the per-item refactor pattern and stay unchanged. -#}
-
-{% from "shared/render-helpers.md" import render_whole_block_truthy, render_whole_block_nonempty %}
-
-{% from "items/project.md" import render_project_item %}
-{% macro render_project(data) %}
-{% if data %}{{ render_project_item(data) }}{% endif %}
-{% endmacro %}
-
-{% from "items/architecture.md" import render_architecture_item %}
-{% macro render_architecture(data) %}
-{% if data %}{{ render_architecture_item(data) }}{% endif %}
-{% endmacro %}
-
-{% from "items/requirements.md" import render_requirement %}
-{% macro render_requirements(data) %}{% call(req) render_whole_block_nonempty("Requirements", data.requirements if data else None) %}{{ render_requirement(req) }}{% endcall %}{% endmacro %}
-
-{% from "items/conformance.md" import render_conformance_principle %}
-{% macro render_conformance(data) %}
-{% if data and data.principles %}
-## Conformance Reference
-{% if data.name %}**{{ data.name }}**{% endif %}
-{% for p in data.principles %}{{ render_conformance_principle(p) }}{% endfor %}
-{% endif %}
-{% endmacro %}
-
-{% from "items/domain.md" import render_domain_entry %}
-{% macro render_domain(data) %}{% call(e) render_whole_block_truthy("Domain Knowledge", data.entries if data else None) %}{{ render_domain_entry(e) }}{% endcall %}{% endmacro %}
-
-{% from "items/tasks.md" import render_task %}
-{% macro render_tasks(data) %}{% call(t) render_whole_block_truthy("Tasks", data.tasks if data else None) %}{{ render_task(t) }}{% endcall %}{% endmacro %}
-
-{% from "items/issues.md" import render_issue %}
-{% macro render_issues(data) %}{% call(i) render_whole_block_truthy("Issues", data.issues if data else None) %}{{ render_issue(i) }}{% endcall %}{% endmacro %}
-
-{#- Authored fresh in Plan 8: render_conventions did not previously exist in
-    macros.md despite README references implying it did. The block-level
-    header surfaces test_conventions, lint_command, and lint_scope (all
-    optional) before iterating rules through render_convention.
-
-    Block schema: .project/schemas/conventions.schema.json. Required: rules.
-    Optional: test_conventions { runner_command, file_pattern }, lint_command,
-    lint_scope. -#}
-{% from "items/conventions.md" import render_convention %}
-{% macro render_conventions(data) %}
-{% if data and data.rules %}
-## Conventions
-{% if data.test_conventions %}
-**Tests:** `{{ data.test_conventions.runner_command }}` (pattern: `{{ data.test_conventions.file_pattern }}`)
-{% endif %}{% if data.lint_command %}**Lint:** `{{ data.lint_command }}`{% if data.lint_scope %} (scope: {{ data.lint_scope }}){% endif %}
-{% endif %}
-{% for rule in data.rules %}{{ render_convention(rule) }}{% 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 %}