explore — pass 1 layer enum + bail-out + pass 2 layer x frame divergence → designs/<slug>-explore.md

AUDIENCE

Skill body in SPEC-ADJACENT so glyph register per glyph skill. Output file (designs/<slug>-explore.md) is user-reviewing surface so steno register per steno skill (readable symbols → & | §, not heavy math glyphs).

Position in funnel

/sdd:design is front door. /sdd:explore is optional escape hatch every "I don't know what shapes are possible" — pre-design phase that enumerates abstraction layers and surfaces options across them. User-invoked only; not auto-route from design.

Output is tradeoff matrix @ designs/<slug>-explore.md (distinct suffix from designs/<slug>.md per design-lifecycle invariant — sibling artifact, distinct lifecycle; not FOLD-IN candidate). Matrix feeds /sdd:design (pick a shape, commit) or /sdd:spec direct amend (bail-out path, single-line fix).

One-shot so no convergence loop. User re-runs w/ constraint shift if matrix unsatisfying.

Loop

1. read SPEC.md in root → degrade gracefully if absent
2. pass 1 — layer enumeration (single sub-agent, critic-only — block below)
3. bail-out gate — pass 1 emits clearly-dominant layer w/ rest dismissed → skip pass 2, emit single-row matrix + direct-path recommendation. Hard rule, not heuristic-soft.
4. pass 2 — layer x frame divergence (N=4 parallel sub-agents, generator-only — block below) — fires only when bail-out gate not trips
5. focus — score (1 sub-agent, critic-only) + cluster (1 sub-agent, critic-only) → top 3–5 surviving options seed ## Options matrix
6. persist — write designs/<slug>-explore.md per template

Total sub-agent cost: 7 calls on full path (1 + 4 + 1 + 1); 1 call on bail-out.

Pass 1 — Layer enumeration

Single general-purpose Agent call, critic-only system prompt. Input: topic + SPEC.md excerpt (exists ?) + user-cited files / symbols (exists ?). Output: ordered list of abstraction layers where the problem could be intervened, 1-line rationale per layer and "rejected" tail w/ 1-line dismissal each.

Layer enumeration forces a layer sweep before any shape generation. This is the load-bearing mechanic — it surfaces affordances (library kwargs, dispatcher options, transport flags) that frame-only divergence misses.

Pass 1 critic block (copy verbatim per call; parameterized by <topic>, <spec_excerpt>, <user_refs>)

You are a layer enumerator. Your only job is to list abstraction layers where the topic could be intervened. You DO NOT propose shapes, score, recommend, or pick a winner. Enumerate only.

Topic: <topic>

SPEC.md excerpt (may be empty if no SPEC.md present):
<spec_excerpt>

User-cited files / symbols (may be empty):
<user_refs>

Procedure:
1. Identify abstraction layers where the topic could be addressed. Examples (non-exhaustive): library affordance (a kwarg, a built-in flag), dispatcher / orchestrator, transport, retry / backoff, config / capability, contract / interface, data shape / schema, runtime supervisor, build / packaging.
2. For each layer, write one line: `<layer-name> — <1-line rationale why this layer could carry the intervention>`.
3. Rank layers in order of dominance. If one layer is clearly dominant (a known affordance already exists, or the problem reduces to a single configuration choice at that layer), say so explicitly in the output by prepending `DOMINANT:` to that line.
4. Add a "rejected" tail: layers considered and dismissed, one line each w/ 1-line dismissal rationale.

Output schema (no preamble, no trailing summary):

## Layers

1. [DOMINANT: ]<layer-name> — <rationale>
2. <layer-name> — <rationale>
...

## Rejected

- <layer-name> — <dismissal>
- <layer-name> — <dismissal>

Stop after Rejected. Do not propose shapes, do not score, do not recommend.

Bail-out gate (hard rule)

After pass 1 returns, main thread inspects the layer enumeration. Bail-out condition:

• Pass 1 output contains line prefixed DOMINANT: and "## Rejected" tail contains ≥ 1 dismissal explaining why other layers fail.

Bail-out trips → skip pass 2 entirely. Emit single-row matrix:

• ## Layers considered is pass 1 output verbatim
• ## Options is single row, the dominant layer's named fix
• ## Recommended next step is one of:
• /sdd:spec <amend-text> — direct amend (single-line / single-kwarg fix at dominant layer)
• /sdd:design <layer> — single-layer fix needs shape choice, hand off to design

Bail-out is structural, not heuristic. Prevents burn-rate on constrained-fit problems where the answer is one configuration change.

User re-runs w/ --constraint=<X> if bail-out felt premature.

Pass 2 — Layer x Frame divergence

Fires only when bail-out gate not trips.

Phase 2a — Layer + frame selection

1. Take top 4 layers from pass 1 ranking (excluding DOMINANT: if one was emitted but bail-out gate didn't trip due to missing rejection tail).
2. Read frame library @ pilot-spec/skills/explore/frames.yaml → vantages tagged by CS-vocab category.
3. Pair each layer w/ one cognitive frame from the library (default rotation: distinct frame per layer, mechanical, not skip).
4. Emit selected (layer, frame) pairs to user as 1 line each every transparency (not wait-state).

Frame is within-layer style modulator; layer carries primary divergence axis. 4 branches mechanically cover 4 distinct layers.

Phase 2b — Diverge (parallel, isolated)

Spawn 4 general-purpose Agent calls in a single response (parallel dispatch every true isolation; sequential calls share no context but lose latency parallelism). every call:

• Agent type: general-purpose
• System prompt: Generator block (canonical, copy verbatim — see below)
• User prompt: topic + (layer, frame) pair + SPEC.md excerpt (exists ?)
• Output: proposal under that layer x frame pairing, structured per output schema

Branches share no context across calls so anchoring mechanically prevented. Generator-only system prompt forbids evaluation / scoring / critique / "but I should mention" hedges.

#### Generator block (copy verbatim per branch — parameterized by <layer>, <frame.name>, <frame.vantage>, <topic>, <spec_excerpt>)

You are a design generator operating at one specific abstraction layer under one specific vantage. Your only job is to propose a shape for the topic at that layer under that vantage. You DO NOT evaluate, score, critique, compare alternatives, hedge, or mention what other layers or vantages might say. Generate only.

Layer: <layer>
Vantage: <frame.name>
Vantage prompt: <frame.vantage>

Language discipline: respond strictly in computer-science vocabulary. If
your vantage suggests an analogy from another discipline (biology,
economics, pedagogy, etc.), translate the analogy into CS primitives
(types, processes, queues, protocols, data structures, scheduling,
capabilities, state machines) *before* you state it. Do not output non-CS
metaphors verbatim. If a CS translation does not exist for the analogy,
drop the analogy.

Topic: <topic>

SPEC.md context (may be empty if no SPEC.md present):
<spec_excerpt>

Produce a proposal under this exact schema (no preamble, no trailing summary):

## Shape
[named structures, types, key decisions at the specified layer]

## Mechanism
[how the shape works in one or two paragraphs — concrete moves at the layer, not abstract goals]

## Cost
[what this costs: complexity, latency, tokens, surface area, lock-in]

## Trap flag
[1 line: name the most likely failure mode of this proposal, or `none-obvious` if no clear trap]

Output the four sections above and stop. Do not add summary, comparison, or recommendation.

Phase 2c — Focus (sequential, critic-only)

After all 4 branches return:

1. Score — 1 sub-agent call (general-purpose), critic-only system prompt.
2. Cluster — 1 sub-agent call (general-purpose), critic-only system prompt.

Both prompts copy verbatim per call (mechanical, not improvise).

#### Score block (copy verbatim)

You are a critic. Your only job is to score four design proposals against weighted criteria. You DO NOT generate new proposals, propose merged shapes, or write your own design. Score only.

Criteria and weights:
- Feasibility (0-5, weight 2): can this be built with the constraints in the SPEC.md excerpt?
- Spec fit (0-5, weight 2): does this respect the §V invariants and §C constraints?
- Cost discipline (0-5, weight 1): is the cost section honest and proportional?
- Surface area (0-5, weight 1): does this add or contain complexity?
- Risk-of-trap (0-5, weight 1, INVERTED — high score means LOW risk): how recoverable is the trap flag the generator named?

Output a pipe-table with one row per proposal, in the order received. Schema:

id|layer|feasibility|spec_fit|cost|surface|risk_inv|weighted_total|trap_flag

`weighted_total` = 2*feasibility + 2*spec_fit + 1*cost + 1*surface + 1*risk_inv (max 35).

`trap_flag` is the verbatim trap-flag line from the generator (NOT your re-rating). If the generator wrote `none-obvious`, write `none-obvious`. If the generator named a trap that is itself disqualifying (e.g. "violates a §V invariant cited in SPEC.md excerpt"), append ` | TRAP` to the row.

Output only the pipe-table. No preamble, no trailing notes.

#### Cluster block (copy verbatim)

You are a critic. Your only job is to cluster four scored design proposals by shape similarity and pick representatives. You DO NOT generate new proposals or merge proposals into novel shapes. Cluster and select only.

Input: four proposals (full body) + a pipe-table of weighted scores including trap flags.

Procedure:
1. Drop any proposal whose row in the score table ends with `TRAP` — disqualified, not eligible for representation.
2. Group surviving proposals by structural similarity: same key named structure, same control flow, same persistence shape, etc. Aim for 3–5 surviving options; identical-cluster collapse OK if proposals are near-duplicates.
3. For each cluster, pick the highest weighted_total proposal as the representative.
4. Order representatives by weighted_total descending. Cap at 5; emit fewer if trap filter shrinks the pool.

Output schema (no preamble, no trailing summary):

## Options table

|id|layer|surface change|reversibility|lock-in|one-liner|
|---|---|---|---|---|---|
|<id>|<layer>|<surface>|<rev>|<lock>|<one-liner>|
...

Columns:
- id: representative proposal id
- layer: which abstraction layer this option intervenes at
- surface change: one phrase naming what surface mutates (e.g. "Tool kwarg", "config flag", "new module", "interface change")
- reversibility: low / medium / high — how hard to back out if option fails
- lock-in: low / medium / high — how much downstream code couples to this option
- one-liner: ≤ 12-word summary of the shape

## Cluster notes
[1-3 lines: which proposals merged into which cluster, and which (if any) were trap-dropped]

Stop after Cluster notes. Do not synthesize a recommended choice — the recommended next step is decided by the main thread after user reviews the matrix.

Phase 2d — Seed matrix

Main thread copies the cluster output verbatim into the in-progress draft under ## Options. Recommended-next-step line composed by main thread after matrix populated (see persist template below).

Output template (file body)

Body in steno per steno skill (user-reviewing surface):

# <title>

## Problem

[1 paragraph restating the problem in explore's own words — framing visible & auditable]

## Layers considered

[pass 1 output verbatim: ordered list of layers w/ 1-line rationale, + "## Rejected" tail w/ 1-line dismissal each]

## Options

[pass 2 cluster output verbatim: pipe-table — Layer | Surface change | Reversibility | Lock-in | One-liner — 3–5 rows; cluster notes appended below table]

## Recommended next step

[exactly one of:
  (a) `/sdd:design <chosen-option>` — pick row N from matrix, commit shape via design
  (b) `/sdd:spec <amend-text>` — bail-out fired, direct amend (single-line / single-kwarg fix)
  (c) `/sdd:explore <topic> --constraint=<X>` — answer space still open, re-run w/ constraint shift]

Bail-out variant: ## Options is single row (the dominant layer's named fix); ## Recommended next step is (b) /sdd:spec or (a) /sdd:design <layer>.

Forbidden sections every explore output:

• not ## Open Questions — explore ends at the matrix, no convergence loop
• not A | B | C alternatives — option matrix replaces shape alternatives
• not ## Effect on in-flight SPEC items — explore not proposes SPEC.md edits
• not ## Success criterion — no criterion until design picks shape
• not ## Design decisions — no decisions to record at explore phase

Code reads

Reactive only. not preemptive scans.

• not allowed: grep repo "to find context" — pass 1 enumerator + pass 2 generators propose from user's framing + SPEC.md + layer / frame.
• ✓ allowed: user cites file:line or symbol or path → read that target.

Cap: ≤ 2 reads/turn @ main thread. Sub-agents inherit cap in system prompts (read budget bounded by topic + spec excerpt + layer + frame).

SPEC.md degradation

SPEC.md in root absent → flag once: "exploring without SPEC anchor; §V/§B/§T citations omitted; spec_excerpt field passed empty to sub-agents". Continue.

Convergence gate

Ready iff matrix populated and ## Recommended next step populated. not user-confirmation gate mid-loop — explore is one-shot. User reviews persisted matrix post-write; re-run w/ constraint shift if matrix unsatisfying.

Distinct from sdd:design convergence-gate invariant (Open Questions empty); explore has no Open Questions surface so that gate not applies.

Title and slug

Draft body opens w/ # <title> heading. Slug derivation same as sister design skill: short kebab-case, ≤ 5 words, ≤ 50 chars; collision → -<n> suffix.

Filename: designs/<slug>-explore.md (sibling to designs/<slug>.md per design-lifecycle invariant; -explore suffix prevents collision).

Persist

1. ensure designs/ dir exists @ repo root → create if missing.
2. derive slug per § above.
3. write body (steno-encoded per template) to designs/<slug>-explore.md.
4. show file path + summary to user.

not commit. Caller may stage manually or feed output to /sdd:design <option> or /sdd:spec <amend-text>. Design file persists in working tree post-persist; user removes or preserves manually.

Boundary

not mutate SPEC.md. Explore output not FOLD-IN candidate per design-lifecycle invariant — /sdd:spec fold-in accepts designs/<slug>.md only, not designs/<slug>-explore.md.

not overwrite designs/<slug>.md (distinct suffix so collision impossible).

not root-cause debugging — that belongs to the backprop skill (user route is /sdd:spec <bug intent>, gate → BACKPROP). Explore = layer enumeration + option matrix, not "why is this broken".

Escape hatch

"just file it" or "skip the explore" or "I already know the layer" → stop. Hand verbatim intent to /sdd:design <layer> (single-pass propose-shape) or /sdd:spec (direct amend) or /gh:issue (file as GitHub issue).

"too many options, just pick one" → recommend swap to /sdd:design once user has narrowed the layer mentally.

OUTPUT — "Next" block

Heading ## Next; 1–5 atomic items per Next-block contract; positional dispatch. Optional ## Hint (≤ 3 lines) precedes when bail-out fired or matrix needs explanation. Post-persist items lead w/ /sdd:design <option> (pick a row) or /sdd:spec <amend-text> (bail-out path).

Example after persist (full-path matrix populated):

## Next

1. /sdd:design <option-id> — pick a row from the matrix and commit shape via design
2. /sdd:explore <topic> --constraint=<X> — re-run w/ constraint shift if matrix unsatisfying
3. /sdd:spec — direct amend if matrix surfaces a one-line fix at a known layer

Example after bail-out (single-row matrix):

## Next

1. /sdd:spec <amend-text> — bail-out fired, single-line fix at dominant layer
2. /sdd:design <layer> — single-layer fix needs shape choice, hand off to design
3. /sdd:explore <topic> --constraint=<X> — re-run if bail-out felt premature