Wayfinder Backlog Model Grill Status

Source: user request to adapt Matt Pocock's wayfinder into Harness as a backlog-native decision frontier above implementation delivery.

Branch Dashboard

Parked Branches

• Legacy backlog-first coexistence and migration. Existing items stay untouched; no bulk migration is designed in this work.

Glossary

Terms

• Backlog root: The project-level backlog container that functions as the wayfinder map. Avoid: map issue, wiki map, docs-only project map.
• Fog: A root-level backlog item that tracks a real but not-yet-sharp area of uncertainty. Avoid: task, epic, story, map item.
• Grilling ticket: A module-scoped backlog item for human decision closure. Avoid: implementation story.
• Research ticket: A module-scoped backlog item for fact-finding that can be answered through code, docs, external sources, or readonly investigation. Avoid: implementation story.
• Prototype ticket: A module-scoped backlog item for learning through an artifact, such as a throwaway UI, design reference, experiment, or proof. Avoid: implementation story.
• Epic: An accepted implementation capability boundary that maps to one future SPEC.md. Avoid: fog, generic container, execution board.
• Story: An accepted product-facing implementation slice under an epic. Avoid: plan task, file chore.
• Wayfinder frontier: The current set of unclear or unresolved decisions that need routing before delivery scope is accepted. Avoid: separate map artifact, implementation backlog, provider schema.
• First-class backlog item: A provider-visible backlog object that can be assigned, searched, linked, and closed. Avoid: metadata wrapper, hidden planning note, docs-only tracker, implicit child list.
• Wayfinder primitive: The lean frontier-discovery skill/block that identifies fog, decisions, and next-route candidates. Avoid: provider writer, phase wrapper, backlog schema owner.
• Finder phase: The higher-order Harness workflow skill that composes the wayfinder primitive with backlog-native routing and references. Avoid: replacement for wayfinder, implementation phase.
• Progressive-disclosure reference: A linked skill reference loaded only when a specific branch needs its detail. Avoid: bundled mega-reference, duplicated inline guidance, docs-only theory.
• Route selection: The wayfinder primitive decision tree that chooses whether the frontier needs grilling, research, prototype, or implementation backlog work. Avoid: provider materialization, implementation planning.
• Spec compiler: create-spec compiling a closed decision frontier into authoritative SPEC.md without conducting its own requirements interview. Avoid: requirements interviewer, backlog writer, implementation planner.
• Verification seam: The highest useful observable boundary through which required behavior can be proven. Avoid: concrete test case, test command, implementation task.
• Research report: The single consolidated, claim-cited source artifact produced for durable research work before optional wiki ingest. Avoid: canonical wiki page, per-agent scratch report, unverified summary.
• Prototype verdict: The explicitly accepted answer and evidence produced by a disposable prototype. Avoid: prototype code, implementation authorization, design guess.
• Requirements phase: The graph-based workflow that closes human requirements, compiles the authoritative spec, and projects the delivery backlog. Avoid: research router, prototype router, delivery phase.
• Requirements handoff: The workflow-owned runtime record that preserves validated requirements gate state for deterministic resume. Avoid: authoring handoff, grill transcript, spec authority, provider state.

Relationships

• Backlog root contains root-level Fog and module/milestone groups.
• Fog anticipates future modules, tickets, epics, and stories.
• Fog is a module candidate, not an execution container.
• Grilling ticket, Research ticket, Prototype ticket, and Epic belong under a module/milestone.
• Story belongs under exactly one Epic.
• Epic remains the SPEC.md anchor for delivery.
• Wayfinder frontier sits above Backlog root state and is expressed through backlog items rather than a separate map artifact.
• write-backlog materializes accepted Wayfinder frontier routing decisions into provider-specific backlog structure.
• fog, grilling, research, prototype, epic, and story are each represented as a First-class backlog item in the target provider.
• Finder phase includes or invokes the Wayfinder primitive.
• Finder phase routes frontier outputs into grilling, research, prototype, epic, or story backlog items.
• Finder phase uses Progressive-disclosure reference files for Harness-specific depth.
• Finder phase owns frontier lifecycle and root routing.
• write-backlog owns backlog item taxonomy and provider materialization.
• Wayfinder primitive owns Route selection.
• write-backlog receives delegated backlog materialization after Route selection.
• Spec compiler consumes closed research, prototype, and grilling decisions before write-backlog projects provider items.
• Research report is a source/learning artifact that docs-ingest-phase may synthesize into routed wiki knowledge.
• Prototype verdict may enter SPEC.md; disposable prototype code does not.
• Requirements phase delegates human closure to requirements-grill, compilation to the Spec compiler, and provider projection to write-backlog.
• Requirements phase updates one Requirements handoff after every selected gate.
• Finder phase routes into research, prototype, the Requirements phase, or delivery; it does not directly own their inner gates.

Axioms

• Harness wayfinder does not create a separate map item; the project/backlog root is the map.
• Fog is root-level only.
• A fog item is not delivery-eligible and is not a SPEC.md anchor.
• Fog does not have child tickets by default.
• Sharpening a fog item first chooses or creates a module/milestone, then creates concrete tickets there.
• Concrete grilling, research, prototype, epic, and story items must live under a module/milestone.
• grilling, research, and prototype tickets must close into accepted decisions before they create or update implementation epic or story items.
• epic and story keep the strict write-backlog delivery contract: epics anchor specs, stories are product-facing slices, and neither should become plan tasks.
• There is no canonical kind umbrella term or cross-provider Kind field.
• Provider representations may vary, but the semantics of fog, grilling, research, prototype, epic, and story do not.
• wayfinder decides which directly named backlog concept the frontier needs next; write-backlog writes it into the backlog correctly.
• fog, grilling, research, prototype, epic, and story must all be first-class backlog items in every supported provider.
• First-class backlog items must be visible, assignable, searchable, linkable, and closeable in the target provider.
• Keep wayfinder as a lean standalone primitive/block.
• Harness-specific backlog integration belongs in the higher-order phase skill, not in the lean wayfinder primitive.
• The higher-order Harness skill slug is finder-phase.
• Keep finder-phase/SKILL.md lean: inline ordered core steps, branch selection pointers, always-needed rules, and completion criteria.
• Inline what every finder-phase branch needs; disclose what only some branches need.
• Keep each behavior in one source of truth.
• finder-phase links to write-backlog for backlog materialization instead of duplicating provider or taxonomy rules.
• Reference filenames describe knowledge surfaces; steps and actions stay in SKILL.md.
• finder-phase is model-invoked.
• finder-phase routes before requirements-phase when a loose idea is too large for one session and wrapped in fog.
• The wayfinder primitive owns route selection; write-backlog owns backlog materialization.
• The lean wayfinder primitive lives in the normal /skills folder and can sit in the planning default pack with finder-phase.
• finder-phase/SKILL.md contains trigger, core loop, route-selection steps, completion criteria, and reference pointers only.
• finder-phase output is an updated backlog frontier plus concise handoff; wiki docs are not the living map.
• grilling, research, and prototype closure notes include the answer, accepted direction, artifacts, and created or updated epics/stories.
• finder-phase does not auto-resolve every frontier item; it routes resolution to the appropriate child flow and reconciles the result.
• Durable research produces one consolidated primary-source-cited report before optional docs-ingest-phase synthesis.
• Prototype code remains disposable; the full prototype is retained off main as primary evidence and only explicitly accepted implications enter the spec.
• create-spec is a no-interview compiler of a closed decision frontier.
• SPEC.md precedes final delivery backlog projection and remains provider-neutral authority.
• write-backlog owns tracer-bullet completeness, blocker-graph validation, immediate provider projection, and agent readiness without absorbing concrete planning.
• A closed and confirmed grill compiles directly into SPEC.md; no delivery backlog is created first.
• Research, prototype, and grilling are alternative Wayfinder routes. After any child flow returns, Wayfinder recomputes the frontier and may route to grilling, research, another prototype, or create-spec.
• write-backlog performs no separate post-spec approval stop; it validates readiness and writes immediately or fails before provider mutation.
• Successful spec compilation emits readiness: agent-ready and spec-written; failure writes no partial spec.
• Pre-spec intake/frontier items resolve into the spec and are not promoted silently into delivery epics.
• No legacy epic/story migration is part of v1.
• Shared skill edits start in /Users/stefan/Desktop/repos/wearedevpunks-skills, not Harness mirrors.
• requirements-phase is authored as a Durable Workflow Graph with explicit gates, guards, cold resume, and durable handoffs.
• requirements-phase owns requirements-grill -> create-spec -> write-backlog; research and prototype remain Finder-owned routes above it.
• delivery-phase begins at planning and does not own requirements, spec compilation, or backlog projection.
• Direct create-plan behavior remains unchanged and retains its existing minimal planning grill.
• The requirements router selects exactly one gate from current evidence: grill, spec, backlog, terminal completion, Finder return, or blocker.
• <planning-surface>/REQUIREMENTS-HANDOFF.md is the durable runtime handoff; its route suggestion is advisory and never outranks current evidence.
• Finder is the top-level lifecycle router; requirements-phase owns spec and backlog readiness, and delivery-phase begins at planning.
• Finder never directly invokes requirements-grill, create-spec, or write-backlog.

Flagged Ambiguities

• "Fog" could sound like a parent bucket for research or grilling. Resolution: fog is root-level anticipation of future module/ticket shape, not the parent of execution tickets.
• "Backlog" previously meant accepted implementation scope only. Resolution: wayfinder expands backlog into a project planning graph, while delivery eligibility remains restricted to accepted epic and story items.
• "Map" could imply a separate tracker item. Resolution: no map item; the project/backlog root is the map.
• "Kind" was previously accepted as Harness' stable taxonomy and provider field. Superseded resolution: remove the umbrella term/field and name fog, grilling, research, prototype, epic, and story directly.
• "write-backlog owner" could imply absorbing wayfinder. Resolution: wayfinder remains a separate routing/orchestration skill; write-backlog owns backlog structure and provider payload materialization.
• "Lightweight wrapper" could make fog and learning work invisible to provider workflows. Resolution: no metadata-only wrappers; every directly named backlog concept is a first-class provider backlog item.
• "finder-phase" was proposed as tentative language. Resolution: finder-phase is the accepted skill slug for the higher-order Harness phase above the lean wayfinder primitive.
• "Reference split" could become tidiness-only file splitting. Resolution: split only by branch need and source-of-truth ownership, following writing-great-skills.
• "Taxonomy reference" could be duplicated in both finder-phase and write-backlog. Resolution: write-backlog owns backlog taxonomy/provider materialization; finder-phase links to it.
• "Migration" could expand v1 into provider cleanup. Resolution: legacy backlog-first coexistence and migration are parked as out of priority; existing items remain untouched.
• "Prototype bypasses grilling" could imply either a mandatory grill or a mandatory bypass. Resolution: neither is invariant; Wayfinder selects the next route from the unresolved frontier after prototype completion.

Current Handoff

• Branch percentages: all active design branches are 100%; the decision frontier is empty and shared understanding is confirmed.
• Parked branches: legacy backlog-first coexistence and migration.
• Remaining non-design validation work: source-to-bundle-to-active receipt parity and the wiki research-route sync gap require implementation-time validation after the reopened grill closes.
• Recommended next planning direction: run create-spec to compile the closed refactor decisions into an agent-ready specification before graph authoring or implementation.

Current Round

• Round: R8
• Current frontier: empty
• Shared-understanding confirmation: confirmed