@davidorex/pi-jit-agents 0.14.6 → 0.28.0

package/templates/audit-finding-verifier/task.md

@@ -0,0 +1,59 @@
+Verify whether the following audit findings have been resolved.
+
+## Audit Findings
+
+{% for finding in audit.findings %}
+### Finding: {{ finding.id }}
+
+**Description**: {{ finding.description }}
+**Severity**: {{ finding.severity | default("unspecified") }}
+**Category**: {{ finding.category | default("unspecified") }}
+**Principle**: {{ finding.principle | default("unspecified") }}
+
+**Locations**:
+{% for loc in finding.locations %}
+- `{{ loc.file }}` {% if loc.line %}line {{ loc.line }}{% endif %} {% if loc.description %} — {{ loc.description }}{% endif %}
+{% endfor %}
+
+{% if finding.fix %}
+**Fix suggestion**: {{ finding.fix.suggestion | default("none") }}
+{% endif %}
+
+{% if finding.resolution and finding.resolution.status == 'passed' %}
+*Previously marked as resolved — re-verify.*
+{% endif %}
+---
+{% endfor %}
+
+## Implementation Results
+
+{% if implementation_results is iterable and implementation_results is not string %}
+{% for result in implementation_results %}
+- {{ result.spec_name | default(result.name | default("task")) }}: {{ result.status | default("unknown") }}
+{% endfor %}
+{% else %}
+```json
+{{ implementation_results | dump(2) }}
+```
+{% endif %}
+
+{% if conformance_reference %}
+## Conformance Reference
+
+```json
+{{ conformance_reference | dump(2) }}
+```
+{% endif %}
+
+## Instructions
+
+For EACH finding above:
+
+1. Read the code at the referenced location(s)
+2. Determine if the finding's described issue is addressed
+3. Record your verdict: `passed`, `failed`, or `needs_inspect`
+4. Provide specific evidence (code snippet, file:line reference)
+
+Do NOT use grep exit codes as evidence. Read the code and assess whether the issue described in the finding is genuinely resolved.
+
+Produce JSON output with a `findings` array containing one entry per finding, plus summary statistics.

package/templates/audit-fixer/task.md

@@ -0,0 +1,67 @@
+## Audit Findings to Fix
+
+### Principle: {{ task.principle }}
+### Category: {{ task.category }}
+### Severity: {{ task.severity }}
+
+### Findings
+
+{% for finding in task.findings %}
+#### {{ finding.id }}: {{ finding.description }}
+
+{% for loc in finding.locations %}
+- `{{ loc.file }}` lines {{ loc.lines | join(', ') }}
+{% endfor %}
+
+{% if finding.fix %}
+**Fix**: {{ finding.fix.suggestion }}
+{% if finding.fix.verify_method == "grep" %}
+**Verify**: pattern `{{ finding.fix.verify_pattern }}` should NOT match after fix
+{% endif %}
+{% endif %}
+
+{% endfor %}
+
+### Files to Modify
+
+{% for file in task.files %}
+- `{{ file }}`
+{% endfor %}
+
+### Acceptance Criteria
+
+{% for criterion in task.acceptance_criteria %}
+- {{ criterion }}
+{% endfor %}
+
+{% if conformance_reference %}
+### Conformance Reference
+
+{% for principle in conformance_reference.principles %}
+{% if principle.id == task.principle.split(':')[0] %}
+#### {{ principle.name }}
+
+{{ principle.description }}
+
+{% for rule in principle.rules %}
+- **{{ rule.id }}**: {{ rule.rule }}
+{% if rule.examples %}
+  - Correct: `{{ rule.examples[0] }}`
+{% endif %}
+{% if rule.anti_patterns %}
+  - Wrong: `{{ rule.anti_patterns[0] }}`
+{% endif %}
+{% endfor %}
+{% endif %}
+{% endfor %}
+{% endif %}
+
+## Instructions
+
+1. Read the files listed above to understand the current code
+2. Fix each finding according to the fix suggestion
+3. Ensure fixes follow the conformance reference principles
+4. Run the test suite: `node --experimental-strip-types --test src/*.test.ts`
+5. Fix any test failures caused by your changes
+
+Produce a JSON result conforming to the execution-results schema.

package/templates/audit-results-router/task.md

@@ -0,0 +1,37 @@
+Review the audit fix results and produce a routing manifest.
+
+## Implementation Results
+
+{% if implementation_results is iterable and implementation_results is not string %}
+{% for result in implementation_results %}
+### Task: {{ result.spec_name | default(result.name | default("unnamed")) }}
+
+- Status: {{ result.status | default("unknown") }}
+{% if result.decisions %}
+- Decisions: {{ result.decisions | length }}
+{% endif %}
+{% if result.issues %}
+- Issues flagged: {{ result.issues | length }}
+{% endif %}
+{% endfor %}
+{% else %}
+```json
+{{ implementation_results | dump(2) }}
+```
+{% endif %}
+
+## Verification Results
+
+```json
+{{ verification | dump(2) }}
+```
+
+## Instructions
+
+Produce a routing manifest with:
+
+1. **decisions** — validated decisions from implementation results (with complete id, description, rationale fields)
+2. **new_issues** — genuine issues that should be tracked (with stable id, description, status: "open", category, priority)
+3. **summary** — accurate summary of what was completed, what failed, what needs inspection
+
+Only include items that are well-formed and represent genuine project artifacts. Do not route items that are missing required fields or describe hypothetical concerns.

package/templates/decomposer/task.md

@@ -0,0 +1,56 @@
+## Decomposition Request
+
+**Gap:** {{ gap.id }} — {{ gap.description }}
+
+## Investigation Findings
+
+**Complexity:** {{ investigation.complexity }}
+**Summary:** {{ investigation.summary }}
+
+### Affected Files
+{% for f in investigation.affected_files %}
+- `{{ f.path }}` — {{ f.role }}: {{ f.current_behavior }}
+{% endfor %}
+
+### Constraints
+{% for c in investigation.constraints %}
+- {{ c }}
+{% endfor %}
+
+### Risks
+{% for r in investigation.risks %}
+- {{ r }}
+{% endfor %}
+
+{% if research %}
+## Research Findings
+
+### Patterns
+{% for p in research.patterns %}
+- **{{ p.name }}**: {{ p.description }} — {{ p.applicability }}
+{% endfor %}
+
+### Recommendations
+{% for r in research.recommendations %}
+- {{ r }}
+{% endfor %}
+{% endif %}
+
+## Instructions
+
+Decompose this gap into implementation specs. Each spec is a unit of work for a single implementing agent.
+
+1. Break the work into the smallest meaningful units
+2. Declare file targets for each spec
+3. Set `depends_on` for specs that must be sequential (shared files, interface dependencies)
+4. Mark `parallel_safe` for specs that can run concurrently
+5. Write acceptance criteria that are verifiable (grep patterns, test commands, not "it works")
+6. Estimate complexity per spec
+
+## Required Output Schema
+
+You MUST produce JSON conforming exactly to this schema. Every required field must be present.
+
+```json
+{{ output_schema }}
+```

package/templates/explorer/system.md

@@ -0,0 +1,3 @@
+You are a code explorer. Given a path, produce a comprehensive structural overview as JSON.
+
+Include files with their sizes, exports, imports, and line counts. Identify types, interfaces, and key functions. Map dependencies between files.

package/templates/explorer/task.md

@@ -0,0 +1,9 @@
+Explore the code at `{{ path }}`.
+
+Produce a JSON object with:
+- `files`: array of { path, type, language, lines, exports, imports }
+- `types`: array of { name, file, line, kind, definition }
+- `dependencies`: array of { from, to, type }
+- `entryPoints`: array of file paths that serve as entry points
+
+Write your findings as valid JSON.

package/templates/gap-identifier/task.md

@@ -0,0 +1,103 @@
+Identify gaps in the project at `{{ path }}`.
+
+## Architecture
+
+{% if architecture.overview %}
+{{ architecture.overview }}
+{% endif %}
+
+### Modules
+{% if architecture.modules is defined %}
+{% for m in architecture.modules %}
+- **{{ m.name }}** (`{{ m.file }}`{% if m.lines %}, {{ m.lines }} lines{% endif %}): {{ m.responsibility }}
+{% endfor %}
+{% endif %}
+
+{% if architecture.patterns is defined %}
+### Patterns
+{% for p in architecture.patterns %}
+- **{{ p.name }}**: {{ p.description }}{% if p.used_in %} — used in: {{ p.used_in | join(", ") }}{% endif %}
+{% endfor %}
+{% endif %}
+
+{% if architecture.boundaries is defined %}
+### Boundaries
+{% for b in architecture.boundaries %}
+- {{ b }}
+{% endfor %}
+{% endif %}
+
+## Codebase Analysis
+
+{% if exploration.files is defined %}
+### Files ({{ exploration.files | length }} total)
+{% 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 %}
+
+## Instructions
+
+Cross-reference the architecture and analysis to identify gaps. Use targeted reads to verify findings.
+
+### Gap categories to check
+
+1. **missing** — functionality that should exist based on architecture but doesn't
+   - Test files for source modules (find test files, compare against source)
+   - Error handling for public APIs
+   - Documentation for exported interfaces
+   - Schema validation for user-facing inputs
+
+2. **incomplete** — partially implemented functionality
+   - TODO/FIXME/HACK comments (`grep -r "TODO\|FIXME\|HACK"`)
+   - Stub or placeholder implementations
+   - Functions that return hardcoded values or throw "not implemented"
+
+3. **defect** — likely bugs or incorrect behavior
+   - Uncaught promise rejections, missing null checks
+   - Type assertions that bypass safety (`as any`, `!` operator overuse)
+   - Error paths that swallow exceptions silently
+
+4. **technical-debt** — code that works but hampers maintenance
+   - Duplicated logic across modules
+   - Outdated patterns inconsistent with the rest of the codebase
+   - Overly complex functions (high cyclomatic complexity)
+
+5. **improvement** — opportunities to improve existing working code
+   - Performance bottlenecks
+   - Missing caching or memoization for expensive operations
+   - Public APIs that could be more ergonomic
+
+6. **question** — ambiguities requiring human or further investigation
+   - Unclear design decisions without documented rationale
+   - Behavior that could be intentional or accidental
+
+### Gap ID format
+
+Use the pattern: `gap-{abbrev}-{nnn}` where abbrev is:
+- `miss` for missing, `inc` for incomplete, `def` for defect
+- `debt` for technical-debt, `imp` for improvement, `q` for question
+
+### Priority calibration
+
+- **critical**: blocks further development or causes data loss
+- **high**: significant impact on reliability, correctness, or developer experience
+- **medium**: notable but workable; should be addressed in normal development
+- **low**: minor cleanup or cosmetic; address opportunistically
+
+Set `source` to `"agent"` for all gaps. Set `status` to `"open"` for all gaps.
+
+## Required Output Schema
+
+You MUST produce JSON conforming exactly to this schema. Every required field must be present.
+
+```json
+{{ output_schema }}
+```

package/templates/gap-resolution-assessor/task.md

@@ -0,0 +1,48 @@
+Assess whether the implementation resolves this gap.
+
+## Gap
+
+**ID**: {{ gap.id }}
+**Description**: {{ gap.description }}
+**Category**: {{ gap.category | default("unspecified") }}
+**Priority**: {{ gap.priority | default("unspecified") }}
+
+## Investigation Findings
+
+```json
+{{ investigation | dump(2) }}
+```
+
+## Implementation Results
+
+{% if implementation_results is iterable and implementation_results is not string %}
+{% for result in implementation_results %}
+### Spec: {{ result.spec_name | default("unnamed") }}
+- Status: {{ result.status | default("unknown") }}
+- Files changed: {{ result.files_changed | default([]) | join(", ") }}
+{% if result.commit_hash %}- Commit: {{ result.commit_hash }}{% endif %}
+{% endfor %}
+{% else %}
+```json
+{{ implementation_results | dump(2) }}
+```
+{% endif %}
+
+## Check Results
+
+- Status: {{ check_results.status }}
+{% if check_results.errors | length > 0 %}
+- Errors:
+{% for err in check_results.errors %}
+  - {{ err }}
+{% endfor %}
+{% endif %}
+
+## Instructions
+
+1. Read the gap description above. Understand what root cause it identifies.
+2. Examine the implementation results — what files were changed and what was the stated work.
+3. Run `git diff HEAD~{{ implementation_results | length | default(1) }}` (or appropriate range) to see actual code changes.
+4. Judge: do the code changes address the root cause described in the gap?
+5. If tests failed or lint errors exist, the gap is NOT resolved regardless of code quality.
+6. Produce your assessment as JSON.

package/templates/handoff-writer/task.md

@@ -0,0 +1,101 @@
+Capture a handoff snapshot for the project at `{{ path }}`.
+
+## Current Project State
+
+{% if project_state.blocks_status %}
+### Block Availability
+
+| Block | Available |
+|-------|-----------|
+{% for name, available in project_state.blocks_status %}
+| {{ name }} | {{ "yes" if available else "NO — absent" }} |
+{% endfor %}
+{% endif %}
+
+{% if project_state.project %}
+### Project
+**{{ project_state.project.name | default("unnamed") }}** — {{ project_state.project.description | default("no description") }}
+Status: {{ project_state.project.status | default("unknown") }}
+{% endif %}
+
+{% if project_state.phases and project_state.phases | length > 0 %}
+### Phases
+{% for phase in project_state.phases %}
+- Phase {{ phase.number | default(loop.index) }}: {{ phase.name | default("unnamed") }} ({{ phase.status | default("unknown") }})
+{% endfor %}
+{% endif %}
+
+{% if project_state.blockSummaries %}
+### Block Summaries
+{% for block in project_state.blockSummaries %}
+- **{{ block.name }}**: {{ block.count | default("?") }} entries
+{% endfor %}
+{% endif %}
+
+{% if project_state.gaps %}
+### Open Gaps
+{% for gap in project_state.gaps %}
+{% if gap.status == "open" %}
+- [{{ gap.priority }}] {{ gap.id }}: {{ gap.description }}
+{% endif %}
+{% endfor %}
+{% endif %}
+
+{% if project_state.decisions %}
+### Recent Decisions
+{% for decision in project_state.decisions %}
+- {{ decision.id | default("?") }}: {{ decision.description | default(decision.title | default("no description")) }}
+{% endfor %}
+{% endif %}
+
+{% if project_state.recentCommits %}
+### Recent Commits
+{% for commit in project_state.recentCommits %}
+- `{{ commit.sha | default("?") | truncate(7, true, "") }}` {{ commit.message | default("no message") }}
+{% endfor %}
+{% endif %}
+
+## Instructions
+
+Synthesize the project state above into a handoff block that enables a future agent or human to resume work seamlessly.
+
+1. **context** — Write a paragraph capturing:
+   - What was being worked on (current phase, recent commits, active changes)
+   - The current state of thinking (what decisions were made, what approach is being taken)
+   - Any momentum or direction that should be preserved
+
+2. **timestamp** — Current datetime in ISO 8601 format (e.g., 2026-03-18T14:30:00Z)
+
+3. **current_phase** — The phase currently being worked on (number or name)
+
+4. **current_tasks** — Task IDs currently in progress (from project state if available, otherwise infer from recent activity)
+
+5. **blockers** — Anything preventing progress:
+   - Unresolved decisions that block implementation
+   - Failing tests or broken builds
+   - Missing dependencies or external requirements
+   - Only include genuine blockers, not wishes
+
+6. **next_actions** — Concrete next steps, ordered by priority:
+   - What should the next session do first?
+   - What's the next logical step in the current phase?
+   - Keep to 3-5 actionable items
+
+7. **open_questions** — Genuine unknowns requiring input:
+   - Design decisions that need human judgment
+   - Ambiguities discovered during development
+   - Technical choices with trade-offs that haven't been resolved
+
+8. **key_decisions_pending** — Decision IDs from the project state that need resolution
+
+9. **files_in_flux** — Files with incomplete or in-progress changes (NOT every recently committed file — only files that have partial work)
+
+Read project blocks if needed to get more detail than the summary provides. Focus on in-flight state, not project overview.
+
+## Required Output Schema
+
+You MUST produce JSON conforming exactly to this schema. Every required field must be present.
+
+```json
+{{ output_schema }}
+```

package/templates/investigator/task.md

@@ -0,0 +1,30 @@
+## Gap to Investigate
+
+**ID:** {{ gap.id }}
+**Description:** {{ gap.description }}
+**Category:** {{ gap.category }}
+**Priority:** {{ gap.priority }}
+{% if gap.details %}
+**Details:** {{ gap.details }}
+{% endif %}
+
+## Instructions
+
+Produce structured findings for this gap. Scope your investigation to the minimum needed:
+
+1. If the gap names specific files, read those. If not, use `find` or `ls` to identify candidates — don't read file contents unless you need to confirm behavior.
+2. For each affected file: what it does, what needs to change.
+3. List hard constraints (existing tests, interfaces, conventions that must not break).
+4. Note risks only if non-obvious.
+5. Set `needs_research` to true only if the solution requires knowledge you don't have. Most gaps don't.
+6. Complexity: `low` = single concern, mechanical. `medium` = multiple files, design choices. `high` = architectural.
+
+Match your depth to the gap's category and priority. A `cleanup/low` gap needs a few lines of findings, not a codebase survey.
+
+## Required Output Schema
+
+You MUST produce JSON conforming exactly to this schema. Every required field must be present.
+
+```json
+{{ output_schema }}
+```

package/templates/items/architecture.md

@@ -0,0 +1,33 @@
+{#-
+  Per-item macro for the `architecture` block (Plan 8 / per-item-macros wave 4).
+
+  Singleton kind: architecture holds one record per repository describing
+  modules, patterns, boundaries, and (optionally) compilation_pipeline /
+  execution_model / dispatch_design. The "per-item" rendering operates on
+  the whole block payload as a single record; the whole-block delegator in
+  shared/macros.md passes its data argument straight through.
+
+  No cross-block references — depth parameter accepted for shape-uniformity
+  with the renderer-registry call convention; no helpers from
+  shared/render-helpers.md are needed.
+-#}
+
+{% macro render_architecture_item(a, depth=0) %}
+{% if a %}
+## Architecture
+{% if a.overview %}{{ a.overview }}
+{% endif %}
+{% if a.modules %}
+### Modules
+{% for m in a.modules %}- **{{ m.name }}** (`{{ m.file }}`{% if m.lines %}, {{ m.lines }} lines{% endif %}): {{ enforceBudget(m.responsibility, "architecture", "modules.items.responsibility") }}{% if m.dependencies %} — deps: {{ m.dependencies | join(", ") }}{% endif %}
+{% endfor %}{% endif %}
+{% if a.patterns %}
+### Patterns
+{% for p in a.patterns %}- **{{ p.name }}**: {{ enforceBudget(p.description, "architecture", "patterns.items.description") }}{% if p.used_in %} — used in: {{ p.used_in | join(", ") }}{% endif %}
+{% endfor %}{% endif %}
+{% if a.boundaries %}
+### Boundaries
+{% for b in a.boundaries %}- {{ b }}
+{% endfor %}{% endif %}
+{% endif %}
+{% endmacro %}

package/templates/items/conformance.md

@@ -0,0 +1,26 @@
+{#-
+  Per-item macro for the `conformance-reference` block (Plan 8 / per-item-macros wave 4).
+
+  Block schema: .project/schemas/conformance-reference.schema.json. The
+  block holds a name, scope, and principles[]. Each principle has nested
+  rules[]. The "per-item" granularity here is one principle (with its
+  rules) — the natural unit for prompt injection per the substrate spec.
+
+  No cross-block references — references are to source material (sources[]
+  at the block level), not to other block items. Depth parameter accepted
+  for renderer-registry shape-uniformity.
+
+  Companion whole-block macro:
+    render_conformance(data) in shared/macros.md emits the block-level
+    name + scope header, then iterates principles through this macro.
+-#}
+
+{% macro render_conformance_principle(p, depth=0) %}
+{% if p %}
+### {{ p.id }}: {{ p.name }}
+{% if p.description %}{{ enforceBudget(p.description, "conformance-reference", "principles.items.description") }}{% endif %}
+{% for r in p.rules %}- **{{ r.id }}**: {{ enforceBudget(r.rule, "conformance-reference", "principles.items.rules.items.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 %}
+{% endif %}
+{% endmacro %}

package/templates/items/conventions.md

@@ -0,0 +1,19 @@
+{#-
+  Per-item macro for the `conventions` block (Plan 8 / per-item-macros wave 4).
+
+  Block schema: .project/schemas/conventions.schema.json. Each item is one
+  rule object inside data.rules[] (id, description, enforcement, severity).
+
+  No cross-block references — conventions are leaf rules. Depth parameter
+  accepted for shape-uniformity; reserved for future schema additions.
+
+  Companion whole-block macro:
+    render_conventions(data) in shared/macros.md emits the test_conventions
+    and lint_command/lint_scope header fields once, then iterates rules
+    through this macro.
+-#}
+
+{% macro render_convention(rule, depth=0) %}
+{% if rule %}- **{{ rule.id }}** [{{ rule.severity }}, {{ rule.enforcement }}]: {{ enforceBudget(rule.description, "conventions", "rules.items.description") }}
+{% endif %}
+{% endmacro %}

package/templates/items/decisions.md

@@ -0,0 +1,47 @@
+{#-
+  Per-item macro for the `decisions` block.
+
+  Block schema: .project/schemas/decisions.schema.json (Plan 6 / per-item-macros wave 3).
+
+  Macro signature:
+    render_decision(dec, depth=0)
+      dec   — single decision object matching .decisions[*] in the schema
+      depth — integer recursion budget for cross-block reference inlining
+
+  Cross-block reference recursion (supersedes, superseded_by, related_findings,
+  related_features, related_gaps) is delegated to shared/render-helpers.md —
+  see that file for the depth contract, ambient globals, and empty-array
+  convention shared across all per-item macros.
+
+  References array (`references[]`):
+    Labelled pointers (label + optional path/lines/commit). NOT recursable —
+    references point to code paths, research docs, commit SHAs, external specs,
+    none of which are project blocks. Rendered inline as one bullet per ref.
+-#}
+{% from "shared/render-helpers.md" import render_id_list_block, render_id_single_block, render_optional_scalar %}
+
+{% macro render_decision(dec, depth=0) %}
+ID: {{ dec.id }}
+Title: {{ dec.title }}
+Status: {{ dec.status }}
+Created by: {{ dec.created_by }}
+Created at: {{ dec.created_at }}
+{{ render_optional_scalar("Enacted by", dec.enacted_by) }}{{ render_optional_scalar("Enacted at", dec.enacted_at) }}
+Context:
+{{ enforceBudget(dec.context, "decisions", "decisions.items.context") }}
+
+Decision:
+{{ enforceBudget(dec.decision, "decisions", "decisions.items.decision") }}
+
+Consequences:
+{% if dec.consequences and dec.consequences | length > 0 %}{% for c in dec.consequences %}  - {{ enforceBudget(c, "decisions", "decisions.items.consequences.items") }}
+{% endfor %}{% else %}  (none)
+{% endif %}{% if dec.options_considered is defined %}Options considered:
+{% if dec.options_considered | length > 0 %}{% for opt in dec.options_considered %}  - {{ opt.label }}: {{ opt.description }}
+{% if opt.tradeoffs %}    Tradeoffs: {{ opt.tradeoffs }}
+{% endif %}{% if opt.rejected_reason %}    Rejected reason: {{ opt.rejected_reason }}
+{% endif %}{% endfor %}{% else %}  (none)
+{% endif %}{% endif %}{{ render_id_list_block("Supersedes", dec.supersedes, depth) }}{{ render_id_single_block("Superseded by", dec.superseded_by, depth) }}{{ render_id_list_block("Related findings", dec.related_findings, depth) }}{{ render_id_list_block("Related features", dec.related_features, depth) }}{{ render_id_list_block("Related gaps", dec.related_gaps, depth) }}{% if dec.references is defined %}References:
+{% if dec.references | length > 0 %}{% for ref in dec.references %}  - {{ ref.label }}{% if ref.path %} — path: {{ ref.path }}{% if ref.lines %}:{{ ref.lines }}{% endif %}{% endif %}{% if ref.commit %} — commit: {{ ref.commit }}{% endif %}
+{% endfor %}{% else %}  (none)
+{% endif %}{% endif %}{% endmacro %}

package/templates/items/domain.md

@@ -0,0 +1,21 @@
+{#-
+  Per-item macro for the `domain` block (Plan 8 / per-item-macros wave 4).
+
+  Block schema: .project/schemas/domain.schema.json. Each item is one
+  knowledge entry inside data.entries[]. Required: id, title, content,
+  category. Optional: source, confidence, related_requirements (array of
+  REQ- IDs), tags.
+
+  Cross-block reference recursion (related_requirements) is delegated to
+  shared/render-helpers.md — see that file for the depth contract, ambient
+  globals, and empty-array convention.
+-#}
+{% from "shared/render-helpers.md" import render_id_list_inline %}
+
+{% macro render_domain_entry(e, depth=0) %}
+{% if e %}- **{{ e.id }}** [{{ e.category }}]: {{ e.title }}
+  {{ enforceBudget(e.content, "domain", "entries.items.content") }}{% if e.tags %} — tags: {{ e.tags | join(", ") }}{% endif %}
+{% if e.source %}  Source: {{ e.source }}
+{% endif %}{% if e.confidence %}  Confidence: {{ e.confidence }}
+{% endif %}{{ render_id_list_inline("Related requirements", e.related_requirements, depth) }}{% endif %}
+{% endmacro %}