Finder Phase [BETA]

Finder Phase is the beta entrypoint for work that is too large for one agent session and still wrapped in fog.

Use it before choosing requirements, research, prototype, design, or delivery. It names the current decision frontier, uses wayfinder to choose the next route, and delegates backlog materialization to write-backlog when tracker items need to exist.

Use this when: a loose idea is broad, unclear, or too foggy to route directly into a normal phase.
It gives you: a backlog-native frontier with fog, grilling, research, prototype, epic, or story work placed in the right lane.
It ends with: an updated frontier, a selected next phase or skill, and a concise handoff.
Wrapped phase/skills: $finder-phase, $wayfinder, $write-backlog, plus routed use of $requirements-phase, $parallel-research, $prototype, $design-phase, $delivery-phase, $debugging-phase, $review-phase, or $docs-ingest-phase.

Runtime Graph

Finder Phase is the routing layer above the other Harness phases. The graph shows the split: finder-phase manages the frontier, wayfinder selects the next kind, write-backlog writes tracker state, and the existing phases do the specialized work.

Reading The Frontier

Wayfinding treats a huge unclear effort as navigation, not execution. The first job is to name the destination, then expose the edge of what is currently knowable.

The backlog root is the living map. Wiki pages, specs, grill logs, and notes are evidence.
The map grows when an answer reveals new decisions, investigations, or experiments.
The map shrinks when those questions close, move out of scope, or become accepted implementation work.
The frontier is the open edge: sharp enough to route, small enough for one agent session, and ready for the right phase.
Fog is in-scope uncertainty that is still too coarse to ticket. It stays visible without pretending the future is already sliced.

Conceptual Model

Finder Phase uses a shared conceptual shape:

Project / Backlog root
  Fog
  Module / Milestone
    Grilling
    Research
    Prototype
    Epic
      Story

Each level means something different.

fog is anticipation. It names the unclear areas that are likely to matter later.
grilling, research, and prototype are learning tickets. They close into accepted decisions, sourced answers, or concrete artifacts.
epic and story are accepted implementation scope. They appear only after the learning work has made the route clear enough to build.
module or milestone is the grouping surface for concrete work. Fog stays at the root until it can graduate into one of those groups.

The tracker only needs to preserve those meanings. write-backlog handles the storage mechanics; Finder Phase cares whether uncertainty is becoming visible, smaller, and routed to the right next move.

Existing Phases Under Finder Phase

Phase	Routed when	Closes with
Brainstorming Requirements And Backlog	The frontier needs human or product decision closure.	Accepted decision and a resolved `grilling` item.
`$parallel-research`	Docs, code, APIs, external systems, or readonly investigation can answer the unknown.	Resolved `research` item with sources and answer.
`prototype`	The frontier needs learning through an artifact or experiment.	Resolved `prototype` item with artifact and accepted direction.
Design	Product, UX, or system shape is unresolved before implementation scope is stable.	Approved design artifacts or a routed blocker.
Implementation	Accepted `epic` and `story` scope exists.	Implemented, validated, reviewed change.
Debugging	The frontier is a runtime symptom or broken flow.	Proven cause, bounded fix, and rerun evidence.
Review	The frontier is inspection of a branch, plan, pull request, or artifact.	Findings, missing checks, or approval signal.
Docs Update	Accepted or proven knowledge needs durable docs.	Routed docs update or recorded no-op.

Flow

Invoke $finder-phase when the idea is too large, too foggy, or too early for a normal phase.
Establish the frontier: name the idea, known evidence, backlog root, and current fog.
Use $wayfinder to classify the next kind: fog, grilling, research, prototype, epic, or story.
Keep fog at the backlog root.
For concrete non-fog work, choose or propose a module or milestone before backlog writing.
Use $write-backlog when the route should become backlog items.
Route the selected item into the owning Harness phase or skill.
Close the pass with the updated frontier, selected route, evidence, open questions, and handoff.

Decision Points

If the idea is broad and unclear, keep it in Finder Phase before requirements.
If a human decision is missing, route to grilling.
If readonly evidence can answer the question, route to research.
If learning needs an artifact, route to prototype.
If product or system shape is still unresolved, route to design.
If accepted epics and stories exist, route to delivery.
If the frontier is a runtime symptom, route to debugging.

Terminal Outcome

The operator can see what is still fog, what route was selected, what backlog item or phase owns the next move, and what evidence supports that route.

The next agent should not have to infer whether the work belongs in requirements, research, prototype, design, delivery, debugging, review, or docs. Finder Phase names that route first.

Validation

Check that the handoff names the frontier, selected kind, placement, next phase or skill, backlog materialization status, unresolved blockers, and the evidence that drove the route.

On this page