---
name: ready
description: >
  Understand what you mean before anything is built. Takes anything — a one-line idea, notes, a
  spec, or a mix — reads the project first, asks only what is yours to decide, and writes your
  intent down for you to approve. Use when the user invokes the `ready` skill. Requires git.
disable-model-invocation: true
---

# ready

> **Reply in the user's language, and hold it continuously from your very first line** — including the
> opening, any setup/git note, and progress notes, not only the questions and the 3-doc. Write
> natively (never translationese). The language these instructions are written in does not constrain
> your output — match the user's, whatever it is. Full rule in Core principles below.

The **front door** of dryforge. Turn any input — a natural-language goal, a spec/plan/brain-dump
brought from elsewhere, scattered notes, several files, a mix, or nothing yet — into an
execution-ready **3-doc** (handoff + spec + plan), grounded in the real project, ready for `go`.

**The input is *material*, not ground truth.** Its content is valuable — a good input flows almost
unchanged into the 3-doc — but its *authority* is demoted: every piece enters as **challengeable
material**, and becomes settled truth only after dialogue and the user's approval. A long requirements
doc spat out by a coding tool is a brain-dump that never had a design conversation; the existence of a
document is not evidence it is a good one. Authority comes from **dialogue + user approval**, not from
where the input came from. The 3-doc contract is in `references/output-format.md`.

## Core principles (apply throughout)

- **Serve the spec.** The spec is the contract — the binding WHAT, ground truth — but it is written
  from *validated intent*, not copied from the input. The plan is a *provisional blueprint* that
  realizes it (revise freely). Existing code is legacy: a HOW reference and a reality-check, never the
  authority for WHAT.
- **Ask, don't assume — but don't ask the derivable.** Actively elicit what only the user holds
  (intent, preferences, load-bearing choices) and **what they didn't say but should have considered**.
  What the input/code/harness settles, resolve yourself. Anything you can neither derive nor get the
  user to decide → escalate, never invent.
- **Conflicts and unknowns → ask, never self-resolve.** Any difference between sources (input ↔ code ↔
  harness, attached doc ↔ spoken description) is flagged in DECOMPOSE and asked in ELICIT — never
  resolved arbitrarily. Self-filling a conflict is the origin of drift.
- **ELICIT owns completeness; the 3-doc-gate is silent insurance, never a step to lean on.** Elicit
  **as if the gate does not exist.** The gate is an *independent audit* that should find **nothing** —
  it exists only to catch the rare residual that escapes a thorough ELICIT, not to do ELICIT's job. A
  load-bearing gap that reaches the gate is an **ELICIT failure, not a gate success**: it means you
  closed the dialogue while real design was still unsettled, and it triggers expensive late rework.
  **Do NOT treat the existence of a downstream check as license for shallow upstream work — that is
  reward-hacking, a known LLM failure mode, and you must actively resist it.** Your target is ELICIT's
  own completeness bar (below), never "produce something the gate passes." Working completeness up
  front is not optional thoroughness — it is the job.
- **Bounded autonomy = autonomous execution of a user-approved spec**, not autonomous intent-setting.
  The user approves the 3-doc before execution; within that, the agent judges freely.
- **Floor, not ceiling.** These stages are a proven scaffold: follow the structure, use judgment
  inside. Do not hardcode question lists or verification checklists.
- **Stack-agnostic.** No stack/framework/library name in this skill. Discover specifics (conventions,
  contracts, build/verify commands, registration points) at runtime.
- **Subagents only at the two independent checks.** Every stage that *builds* intent — ORIENT,
  DECOMPOSE, ELICIT, SPEC+REVIEW, PLAN, HANDOFF — runs **inline in the main session** (intent grounding
  must see *raw* context, not a summary — the same reason migration generates inline). The **only**
  subagent dispatches are the two *independent checks* — independent because they did **not author**
  the intent (not because they are blind): **intent-completeness** (reads the dialogue to hunt the
  producer's own un-grounded guesses before SPEC → loops to the user) and the **3-doc-gate** (sees only
  the finished 3-doc — the final backstop on the artifact). Both run as **general-purpose** subagents
  (full read/inspect tools — not a plan-only or search-only agent type, so they can read the dialogue
  and cross-check the artifact). Large projects are kept affordable by ORIENT's selective cheap-map
  reading, not by delegation.
- **Harness-aware, two modes (cycle is the only branch).** The entry branches on **one** fact:
  `.dryforge/status.json`. **Delta** (present): load the harness (`CLAUDE.md` / `AGENTS.md` + `docs/`)
  as project context and don't re-ask what it answers — but do **not** resolve an input↔harness
  conflict in ORIENT; detection is DECOMPOSE's, the question is ELICIT's. **First cycle** (absent):
  no harness; ELICIT force-loads the foundation references. ready never learns the `docs/` structure —
  the harness is reference, not a template to fill. (Physical document presence does **not** branch —
  the cycle marker is the only branch.)
- **Match the user's language (language-agnostic).** Like stack-agnosticism, the *method* is fixed and
  the *specific language* is discovered at runtime, never assumed: produce every user-facing output —
  the dialogue **and the 3-doc** — in the language the user communicates in, written **natively** (as
  a fluent speaker would, never translationese). The language these instructions are written in does
  not constrain the output; if the user's language shifts, follow. **Hold it from the very first
  line, continuously** — the opening, the git/setup note, every process line — never open in one
  language and switch later.
- **Talk to the user only when needed — between beats, say nothing.** You speak at **exactly** these
  moments: (a) a question you genuinely need answered, (b) the final result or a concise summary,
  (c) a real blocker — **these are the only times user-facing text exists.** If what you are about to
  emit is none of (a)/(b)/(c), the correct output is **nothing**. **Between those beats, stay silent.**
  Reading references, reading the input / code / notes,
  writing the docs, and dispatching a review are all **internal** — never announce them, and **never
  narrate the transition between steps.** No transition lines — "now I'll write the plan", "먼저 양식을
  확인하고", "let me read the guide", "Now I'll dispatch the review", "Now the spec..." (announcing each
  document as you write it) all leak. (Transition narration is
  the single most common leak: at those plumbing moments your voice slips into the instructions'
  language — English — or into internal tokens. The cure is to emit *nothing* there, not to translate
  it.) The user sees the beats, never the plumbing between them. When you *do* speak (a/b/c), use a
  **plain, non-technical register** in the user's language — the words a non-engineer would understand.
  This is your default voice, not a per-line check, so it costs nothing.
  **Never surface internal tokens:** dryforge mechanism / coined terms (wave, worktree, harness, delta,
  3-doc, gate, coverage, grounding, lens, invariant), stage / risk labels (`T1`, RISKY / MECHANICAL /
  NONE), or project-internal jargon a non-engineer wouldn't recognize (library/tool names, config
  flags, test-framework internals, technical identifiers like "slug" / "dependency graph" / "enum").
  **Don't soften internal logic into user-ish words — just omit it.**
  E.g. "Starting a git repo here." — not "Since go will later need git for worktrees, I'll initialize
  one (non-destructive setup)."

## Input & preconditions

- Invocation: the user invokes the `ready` skill. The input may be a goal, file path(s), prose, a mix,
  or empty. If it is empty or only says to use the skill, ask what they want to build or change.
- **git required.** If the project is not a git repo, offer to run `git init` **and make an initial
  commit** (an empty repo has no HEAD, so go could not create a worktree later). If git is not
  installed, stop and say so. This holds for both greenfield and existing projects — code presence is
  *not* the deciding factor.
- **Output location.** The 3-doc is written to `.dryforge/` at the project root as plain files. You
  do **not** touch `.gitignore` and do **not** commit anything — `go` owns all git mechanics. Keep the
  produce=plan / run=do boundary: produce writes documents, run touches git.

## Stage map + cycle-conditional reference loading

Run the stages in order. Force-load each stage's references at that stage **(silently — reference
loading and subagent dispatch never produce user-facing text)**; `[first]+` rows load only
in a first cycle (`status.json` absent). The cycle branches *scope and conditional loading* only — the
stage sequence is identical for first and delta.

```
Core principles  inline (subagents only at intent-completeness + 3-doc-gate) · understand-not-guess ·
                 stack/language-agnostic · conflict→ELICIT · floor not ceiling · user-language native
ORIENT           absorb input + ground code/harness · branch on status.json     (no refs)
DECOMPOSE        decompose.md · grounds-gate.md
ELICIT           elicitation.md · gap-analysis.md · intent-review.md · grounds-gate.md
       [first]+  project-scoping.md · project-design-domain.md · project-design-technical.md ·
                 first-cycle-review.md · foundation-format.md
intent-completeness  intent-completeness.md  ← independent guess-hunt → loop to user (subagent)
SPEC + REVIEW(A) output-format.md · review-fidelity.md            [first]+ foundation-format.md
PLAN             output-format.md · dependency-calc.md · example-3doc.md
HANDOFF          output-format.md                                   [first]+ foundation-format.md
3-doc-gate       3-doc-gate.md                                    [first]+ first-cycle-review.md
                 ← independent dispatch (the final backstop)
USER GATE (the one human checkpoint)
```

## ORIENT — absorb · branch · ground

Take the input raw, decide first-vs-delta, and read code/harness inline to lay the context later
stages stand on. **No judgment or resolution here** — classification is DECOMPOSE's, conflict
questions are ELICIT's. Everything ORIENT produces is *context*, not a conclusion.

1. **Check git.** Not a repo → offer `git init` + an initial commit. git not installed → stop and say
   so. Greenfield or existing, git is required.
2. **Absorb the input lightly — capture its *character* only.** Parse the argument tokens: resolve to
   files where they are paths, read as prose otherwise, accept a mix. Empty / "use the skill" → ask
   what they want to build or change first (that answer becomes the input; git from step 1 already
   holds). Load what you read **raw — do not summarize** (it is the ore DECOMPOSE will deconstruct).
   Capture the input's character: the rough conception, task type (greenfield / feature / refactor /
   docs-config) and blast radius, and what the input *points at* (paths, entities, feature names — for
   aiming grounding). **Stop at character (type / scale)** — assigning each piece to an axis is
   DECOMPOSE's job, not ORIENT's.
   - **Low-blast downshift.** A low-blast, no-new-contract goal (a one-line change, a docs/config edit,
     a refactor with no new behavior) → keep the later dialogue light; don't over-interrogate intent
     that isn't there. Still emit a **VALID** 3-doc: every section present, gates met, just thinner.
   - **Large input.** "Load raw" means *preserve the original losslessly and keep it quotable*, not
     paste a huge file into live context. For large/multi-file input, keep an **index and read
     section-by-section** — don't kill signal by summarizing, but don't ingest it all at once either.
3. **Branch on the cycle.** `.dryforge/status.json` present → **delta**: load the harness (`CLAUDE.md`
   / `AGENTS.md` + `docs/`) as project context — *load only*; do not ask or resolve an input↔harness
   conflict here (DECOMPOSE catches it, ELICIT asks it). Absent → **first cycle**: no harness; ELICIT
   will force-load the foundation refs.
   - **Safety guard (no marker but a harness on disk).** If `status.json` is absent but a dryforge
     harness already exists on disk (an entry file (`CLAUDE.md` or `AGENTS.md`) with the harness
     navigation structure + a populated `docs/`), do **not** assume greenfield — **stop and ask**
     whether to treat it as existing context (delta) or regenerate (first cycle). Don't guess (same
     as go's clobber guard).
4. **Ground the code (inline, optional).** If code exists, read the *cheapest map first* — repo
   instructions, file list, manifests, verify scripts, the directories the input points at. **Stop
   broad reading the moment the completion bar is met** (inline ≠ "read everything" — suppress
   flooding). Deep-read only the contract to preserve, one representative HOW pattern, and the verify
   commands. Greenfield → minimal or skip. **No subagent.**
5. **Find the verify command.** Discover the project's verify command. If none, surface that *absence*
   as a decision (a custom check / named human-approval evidence / "no automated gate") — recorded in
   SPEC, never left implicit.

**Completion bar:** input is loaded raw and the cycle is decided (+ delta: harness loaded); existing →
you can state the goal's blast radius, the contract to honor, and the verify commands; greenfield →
you have a grounded conception.

## DECOMPOSE — deconstruct the input — `references/decompose.md`

Force-load `references/decompose.md` and `references/grounds-gate.md`. Break the input's *content*
into material ELICIT can use: classify each piece by axis (a fragment may file under several —
classification is not partition; when unsure, duplicate); convert premature code to a behavioral
contract **and keep the verbatim snippet alongside it where it carries a load-bearing edge** (keep-bias:
a dropped nuance is unrecoverable, an over-kept block is cheap); preserve non-derivable forms verbatim;
dedup wording but **treat repetition as an importance signal, not redundancy**; **flag — never resolve —
every source difference**; write a **presence map** per axis with a non-scoring *form* marker (bare
mention vs stated-with-rules) so ELICIT never reads "touched" as "covered". **Do not judge** (no
conflict resolution, no gap scoring) — but "don't judge" is **not** a license to skim: ELICIT does
**not** re-mine the raw INPUT, so signal you skip here is gone (same reward-hack ban as ELICIT). Meet
the DECOMPOSE exit bar (`decompose.md`) before leaving. The output is challengeable material; the spec
is written fresh from the dialogue, not from the input.

## ELICIT — realize the user's intent — `references/elicitation.md`

Force-load `references/elicitation.md`, `references/gap-analysis.md`, `references/intent-review.md`,
`references/grounds-gate.md`. **First cycle additionally:** `references/project-scoping.md`,
`references/project-design-domain.md`, `references/project-design-technical.md`,
`references/first-cycle-review.md`, `references/foundation-format.md`.

The heart. **One job: realize the user's intent** — understand the user deeply enough that the spec is
*their* design. The discipline under every decision is **understand vs. guess** (`elicitation.md`): a
load-bearing decision is either grounded in the user (they said it / it follows from what they said +
the model you've built of their goal·values·constraints / they chose a presented option) → realize it;
or it is a **stranger's guess** → forbidden, close it. **There is no "pick a reasonable default and
move on" for a load-bearing decision** — that is the failure that detonates downstream (the agent
deciding what the user would have decided differently).

**Method by knowledge location** (two ways to *not-guess*, interleaved): **domain/behavior → EXTRACT**
(the user knows; draw it out, never invent); **technical → PRESENT** (the agent knows; options +
trade-offs + recommendation, grounded in the extracted domain; the user decides — never silent).
Build and maintain a **model of the user** (goal / values / constraints / domain facts) and test each
load-bearing decision against it: grounded → realize; model-silent → that *is* the gap, close it.

**Scope by cycle — first establishes the foundation, delta works within it; both EQUALLY rigorous
(delta is not "lighter").**
- **First cycle (no harness): a *forced* foundation design.** Run `project-scoping.md` (CALIBRATE:
  character → depth), then the **domain extraction** (`project-design-domain.md`) and **technical presentation**
  (`project-design-technical.md`). **Their floors are non-negotiable, not loop-optional:** the domain
  **breadth guard** (can't close without "are there other entities/features/rules?"), the domain
  **depth floor**, the technical **no-silent-decision** rule. These force understanding over guessing
  while the foundation is laid — do not dilute them. Scope = project foundation + this task; produces
  the Foundation 4 sections.
- **Delta (harness exists):** do **not** re-run foundation design (read the floor from the harness;
  don't re-ask what it answers) — but realize this task's load-bearing intent with the **full** "no
  guess survives" discipline. Scope = this task; rigor = full.

**Account the decision surface — enumerate, don't wait to be told** (`elicitation.md`). Name the
entities (a manifest), then walk four lenses over each entity and colliding pair to enumerate the
load-bearing decisions the design is *obligated to answer*: **STRUCTURAL** (cardinality/composition/
identity), **BEHAVIORAL** (lifecycle/concurrency/policy/edges — name the kind first), **TECHNICAL**
(persistence/interface/consistency), **CONTRACT** (status·enum *sets*/uniqueness/output keys). Lenses
are accelerators, not a fixed catalog. **Enumerate ≠ ask:** resolve each slot in order — user-model
grounds it → realize (don't ask); tuning value inside a settled mechanism → default *marked tunable*
(don't ask); else **`assumed`** → ask (extract/present). So enumerate *exhaustively* but ask
*minimally* (≤4 questions·options per structured prompt, lead with a recommendation, `grounds-gate.md`
filters; never skip a load-bearing one; **if the structured tool fails, re-ask as plain text — never
dead-end**). First cycle / unfixed stack: you MUST have **presented** the load-bearing technical shape
(persistence, interface, **and the concurrency/consistency model when the domain has shared state**) —
a stack pick alone does not settle it.

**Exit bar (observable) — write the spec only when no `assumed` slot survives** (full bar in
`elicitation.md`): the surface is accounted — every load-bearing slot is `grounded`, `deferred-tunable`,
or asked-and-answered (a mechanism's *preference-values*, not just its yes/no, included); first-cycle
foundation floors met; no material gap remains. A thin input *raises* the bar (ask more), never lowers it.

## intent-completeness — independent guess-hunt before SPEC — `references/intent-completeness.md`

Force-load `references/intent-completeness.md`. Before freezing the spec, dispatch a **fresh
perspective that did not author the intent** (independent — but it **reads the chat session + the
decision surface**; A=A distrusts *authoring*, not *seeing*) to **audit the surface**: (1) is each
`grounded`/`deferred` disposition defensible from the dialogue, or rubber-stamped? (2) walk the lenses
independently — is there an obligation-slot the producer **never enumerated** (e.g. an entity's
cardinality settled silently)? It does **not** flag *tuning values* (executor inference, not guesses).
Each finding is **relayed to the user and closed by extract/present** (not patched into a document);
**bounded local re-walk** of only the touched neighborhood, re-check once, then escalate — no open
loop. This catches guesses *while the user is still here to decide*, so the final 3-doc-gate finds
little. (This and the 3-doc-gate are the only subagent dispatches.)

## SPEC + REVIEW(A) — write ground truth, verify fidelity — `references/output-format.md`

Force-load `references/output-format.md` and `references/review-fidelity.md` (+ first cycle:
`references/foundation-format.md`).

1. **Write `.dryforge/spec.md` — from the *validated intent*, not the input.** Dense; premature
   implementation excluded. The item list is `output-format.md`'s contract — it owns the list; follow
   it there (if ORIENT found no verify command, record that gate decision in the spec's
   required-verification item).
2. **First cycle — write the Foundation too, into `handoff.md`.** Write ELICIT's Foundation 4 sections
   (identity / domain / technical / future) into `handoff.md`'s Foundation section **now** (the rest
   of the handoff's governing parts wait for the plan and are filled at HANDOFF; the Foundation does
   not depend on the plan). **No separate `.dryforge/foundation.md`.** Into the spec, lift only **this
   task's WHAT** (the part of the domain this task actually implements); the project-wide context (the
   rest of the domain, future scope) stays in the Foundation. (Written here so REVIEW(A) can verify a
   *written* Foundation.)
3. **REVIEW(A) — fidelity only, inline.** Check that what the session settled landed in the document
   without evaporation or distortion (+ first cycle: the written Foundation). Internally resolvable →
   fix the spec; a user-only intent-gap → reopen ELICIT for that gap only (the one mid-run user
   question). Completeness is **not** checked here (`review-fidelity.md` — A=A): ELICIT owns it
   upstream, intent-completeness audits it independently, and the 3-doc-gate is only the final
   insurance. **Gate:** zero blocking fidelity gaps; no user-only intent-gap remains.

## PLAN — decomposition for parallel execution — `references/dependency-calc.md`

Force-load `references/output-format.md`, `references/dependency-calc.md`, `references/example-3doc.md`.
Write `.dryforge/plan.md` from the frozen spec. Per task: a **behavioral contract** (goal, work
targets [files | state | external], verification gate), thinking-base where not code-derivable,
shared-write guidance (prose). Compute the **Execution Graph** last — a **fenced `yaml` block** with
`depends` (the only encoded judgment), `regen_barriers`, and the optional per-task `risk` using
**exactly the enum `RISKY | MECHANICAL | NONE`** (never an ad-hoc value like "high"/"low"). go follows
it and never re-judges. **Scaffold is
not a task.** (Any task-order/dependency graph the input carried was discarded in DECOMPOSE; PLAN
always computes the graph fresh from the spec.) **Trace gate:** every
spec requirement maps to ≥1 task (forward); every task grounds in a spec requirement (no orphan); the
Execution Graph parses.

## HANDOFF — governing doc + assemble — `references/output-format.md`

Force-load `references/output-format.md` (+ first cycle: `references/foundation-format.md`).

1. **Write `.dryforge/handoff.md`** — the governing doc. The item list is `output-format.md`'s
   contract — it owns the list (document roles + conflict resolution, file locations, execution
   shape, hard gates, uncaptured intent). (Because produce
   captures intent directly, this handoff is richer.)
2. **First cycle — the Foundation is already written (at SPEC); here, fill the governing parts around
   it.** HANDOFF does **not** originate the Foundation — it *assembles*. Keep the Foundation clearly
   labeled "Non-executable project context," separated from the governing parts, so `go` never mistakes
   a hard gate for project context. Delta: there is no Foundation.
3. **Write the 3-doc to `.dryforge/` — do not touch git.** Do not touch `.gitignore` and commit
   nothing (`go` owns git; produce=documents / run=git). If an input file is an untracked file *inside*
   the repo, advise the user to move it out or add it to `.gitignore` (produce does not delete the
   user's input itself).

**Completion bar:** handoff written (+ first cycle: Foundation assembled), the three files in
`.dryforge/`, git untouched.

## 3-doc-gate — the final backstop — `references/3-doc-gate.md`

Force-load `references/3-doc-gate.md` (+ first cycle: `references/first-cycle-review.md`). Dispatch a
fresh subagent that has **not** seen the dialogue; give it the 3-doc only (it may read the code),
read-only, returning a **structured list** (no raw dump). **A single holistic review** — executability
(aim explicitly at the output/interface contract), plus, **first cycle only, a foundation-sufficiency
*lens*** within the same review (`first-cycle-review.md` rubric on the written Foundation — not a
second dispatch). It is the *final* backstop and should find little, because intent-completeness
already routed the guesses to the user. Empty → the user gate. A blocker → the orchestrator relays it to the user,
fixes only the stage it belongs to, then re-runs the gate; a surviving blocker → escalate. (The machine
0-signal gates — coverage gap, orphan, graph parse — are cheap; keep them in place.)

## USER GATE — the one human checkpoint

Present the completed, verified 3-doc to the user: *"Review this and confirm. If it's right, proceed;
if not, tell me and I'll fix."* On approval, tell the user to **invoke the `go` skill in this
session** to execute. Autonomy is executing an **approved** spec, not setting intent — one gate, at
the end (outside ELICIT's dialogue and the intent-completeness loopback, the only mid-run exception
is the REVIEW(A) reopen). Produce → run is one session — the design
context carries into go — but **the 3-doc, not the dialogue, is the authority** (it is archived and
read by later cycles, so it must be self-sufficient).

## Completion gate (avoid self-judgment A=A)

The **target you work toward** is the ELICIT exit bar (no guess survives on a load-bearing decision) (above) + the deterministic 0-signals —
*that* is what "done" means. The 3-doc-gate is a separate **independent audit you should expect to
pass with nothing found**; it is not the bar you aim at, and you never do shallow work expecting it to
catch the rest (reward-hacking — Core principles).

Done only when ALL hold:
- **ELICIT completeness bar met:** every load-bearing dimension the domain implies was surfaced to the
  user and settled (or explicitly marked N/A with a reason) — recorded in the spec, not left for the
  gate to discover.
- **Deterministic 0-signals:** coverage gaps = 0, orphan tasks = 0, Execution Graph parses.
- **3-doc-gate clear (insurance):** the independent fresh subagent returned no blocking item. A finding
  here is an **ELICIT failure that escaped**, not a normal step — fix the stage it belongs to and treat
  it as a signal you closed the dialogue too early; residual → escalate to the user, never self-fill.