100%

Goal

Prove the genre inversion end-to-end on ONE proof fixture (bug:BUG-05-010): render one dossier-genre package.md via the new template carrying ONE real tier (dependency graph) + a per-tier VERDICT + the section DIG DEEPER block, generated from scripts/intel-query.sh surfaces. A vertical slice through generate -> template -> render that establishes the dossier-shape interface every later section fans out from and consumes.

bug:BUG-05-010 is the proof FIXTURE only — the runtime selects the real target via the existing --target <kind>:<ref> arg (per R3 target-kind-aware selection; the worked example already treats the target as a parameter). The skeleton hard-wires no entry point; it passes the fixture through --target exactly as a production caller passes any bug:/symbol:/diff:/plan-section: ref.

Scope boundary (prototype vs production entry point). This section legitimately scopes a PROTOTYPE render path proven against mock/cached intel-surface fixtures with an injected resolver_fn — that is the correct walking-skeleton shape. It does NOT carry the production-entry-point wiring: generate() defaults resolver_fn=None (legacy/empty path), and neither _cmd_generate (scripts/intel_package_runtime/__main__.py:35) nor heal._regenerate_and_persist threads a real resolver. Threading the production resolver_fn into those real entry points is the L12 production-entry-point obligation (per .claude/rules/layer-coverage.md §1 L12) surfaced at the reopen — owned by work item w-18edfbb5 (target-kind-tiers s-aa802633, completed-by tests s-15e599fa; see the Implementation Sketch resolver-scope boundary), NOT by this skeleton. The L12 hole is a plan-level scope gap at this skeleton’s depends-on boundary, not a defect in this section’s own prototype scope.

Implementation Sketch

  • Wire the proof slice through the EXISTING Jinja2 dossier renderer render_package() (scripts/intel_package_runtime/render.py:484 — the SINGLE dossier render entry point per w-44d31868, rendered through a StrictUndefined env). render_md remains the legacy ### surface - N rows counts-manifest fallback for the resolver_fn-absent legacy dispatch branch. The skeleton adds NO throwaway render_dossier() prototype — render_dossier()/_render_tier()/_tier_dig_deeper() are already retired; the genre-inversion proof runs through render_package() directly. The skeleton’s job is to drive ONE tier + verdict + DIG DEEPER through render_package() on the proof fixture, not to stand up a parallel renderer.
  • Wire ONE tier (adjacency rows from surfaces.py) + a verdict slot + a DIG DEEPER fenced block into the prototype path. The skeleton ALSO lands the minimal surfaces.py adjacency-row builder that SOURCES the intra-set CALLS rows the tier renders. The builder FIRST resolves the bug:BUG-05-010 fixture to its objective symbol set (the implicated cypher/symbols lookup), THEN queries callers+callees/cypher on those resolved symbols — never on the raw bug id. The full tier-selector set lands in genre-inversion-tiers (s-1fe9a664), but the skeleton sources its own one tier end-to-end rather than assuming the rows pre-exist.
  • Verdict-slot shape — PINNED to the worked example’s verdict-line form (intel-package-example.md §3.6): one VERDICT: <one-line assessment> line emitted immediately under the tier block, plain text, machine-greppable on the VERDICT: prefix. verdict-synthesis (s-1c925ea6) fills this defined interface; it does not invent a new slot shape.
  • Golden test (see Work Items) asserts the rendered slice against the approved worked example intel-package-example.md §3.1 (adjacency) + §3 DIG DEEPER, with a paired positive + negative assertion driven off cached/mock intel-surface fixtures.
  • The skeleton proves R1 (synthesis not bundling), R2 (machine-readable, no flowcharts), R5 (DIG DEEPER block) on one fixture before the tier catalogue lands in section 01. The dossier shape it emits — one tier block + VERDICT: line + DIG DEEPER block — is the dossier-shape interface this plan’s successor sections build on (forward-declared here; each successor body details how it extends the shape): genre-inversion-tiers (s-1fe9a664) fans the one wired tier out to the full catalogue, verdict-synthesis (s-1c925ea6) fills the VERDICT: slot, template-render (s-5254300c) extends the existing render_package() Jinja2 template (templates/package.md.j2) to the full per-tier dossier layout.
  • Resolver scope boundary — read carefully. target-kind-tiers (s-aa802633) owns the tier-SELECTION layer: tier-selection inversion, TARGET_KINDS reconciliation, and the boolean is_resolvable validity gate. It does NOT own the production per-kind objective-symbol resolver. The DISTINCT deliverable — a real resolver_fn that resolves a bug:/plan-section:/diff:/subsystem: ref to its objective symbol set AND is threaded into the production entry points (_cmd_generate at scripts/intel_package_runtime/__main__.py:35 + heal._regenerate_and_persist) — is owned by work item w-18edfbb5 (target-kind-tiers s-aa802633, completed-by tests s-15e599fa). This skeleton’s surfaces.py adjacency-row builder resolves the bug:BUG-05-010 FIXTURE to objective symbols inside the prototype slice with an injected resolver_fn; the production resolver and its CLI/heal wiring are explicitly NOT this section’s deliverable. Do not read the genre-inversion forward-references above as a claim that s-aa802633 already ships the resolver — it ships tier selection; w-18edfbb5 ships the resolver.

Spec References

  • scripts/intel_package_runtime/render.py — render_package() at :484 is the single Jinja2 dossier renderer (per w-44d31868); render_md is the legacy counts-manifest fallback for the resolver_fn-absent branch
  • scripts/intel_package_runtime/surfaces.py (adjacency-row source for the one wired tier)
  • intel-package-example.md §3.1 (approved adjacency shape — golden positive reference), §3 DIG DEEPER blocks, §3.6 (VERDICT: line form — the pinned verdict-slot interface)
  • intel-package-rebuild-notes.md R1, R2, R3 (target-kind-aware selection via --target), R5

Work Items

  • Drive one tier (dependency-graph adjacency) through the EXISTING Jinja2 render_package() path (render.py:484): a minimal surfaces.py adjacency-row builder sources the tier rows + a VERDICT: <line> slot (pinned to intel-package-example.md §3.6 verdict-line form) + a DIG DEEPER fenced block, rendered for the --target bug:BUG-05-010 proof fixture from intel-query surfaces. No render_dossier() prototype — render_package() is the single dossier renderer (w-44d31868); the skeleton proves the genre inversion through it, not a parallel path.
  • Golden test asserting against the output of an end-to-end generate(--target bug:BUG-05-010) call (not render() in isolation), deterministic via cached/mock intel-surface fixtures (no live Neo4j dependency), with two explicit assertions:
    • POSITIVE: the rendered slice matches intel-package-example.md §3.1 (adjacency rows) + §3 (DIG DEEPER block) + carries one VERDICT: line of the pinned form.
    • NEGATIVE: the rendered slice contains zero ### surface - N rows counts-manifest substrings (proving the genre inversion away from the counts-manifest renderer).
    • PIN: the adjacency builder resolves the bug fixture to objective symbols before querying CALLS; callers/callees are NEVER invoked on the raw bug: id (asserted against the mock-fixture call log).
    • NEGATIVE (R2 no-flowcharts): the rendered slice contains zero diagram/mermaid markup (no ```mermaid, no flowchart/graph TD, no box-drawing) — proving R2 machine-readable density, not just the counts-manifest inversion.

Layer Coverage

The golden test (w-74ad9225) drives an end-to-end generate(--target bug:BUG-05-010) call against cached/mock intel-surface fixtures with resolver_fn injected (test_walking_skeleton.py is one of the three resolver_fn-injecting test files). That is the correct, deterministic coverage for a walking-skeleton prototype, but it is seam-injected: it does not exercise the real production _cmd_generate entry point with the live resolver.

  • L12 (production execution entry point — python -m scripts.intel_package_runtime generate --target bug:BUG-05-010 on a REAL target WITHOUT an injected resolver_fn, asserting a non-empty dossier-genre package.md): OWNED-ELSEWHERE by work item w-18edfbb5 (target-kind-tiers s-aa802633, completed-by tests s-15e599fa). This skeleton certifies complete on the seam-injected prototype coverage above; the production-path L12 assertion is the resolver work item’s deliverable and is tracked by success criterion sc-0012 (see plan.json success_criteria[]). This section does NOT certify L12 on its own seam-injected coverage.