/define

name: define
description: 'Manifest builder. Turns shared understanding into a verifiable Manifest with Deliverables, Acceptance Criteria, Global Invariants, and an Initial Approach. Use when planning features, scoping refactors, debugging complex issues, or when the user asks to define, scope, plan, spec out, make a manifest, or break down a task.'
argument-hint: '[task] [<manifest-path> to amend] [--babysit <pr-url>]'
user-invocable: true

Encode the conversation's shared understanding as a Manifest at `~/.manifest-dev/manifests/manifest-<ts>.md` (create the dir; fall back to a writable temp path only if home is not writable); how you interview is yours. No shared understanding in the transcript → invoke `figure-out` first, propagating `--autonomous` when the caller is unattended. A manifest path in the arguments means amend: targeted changes only, IDs stable, no renumbering.

figure-out reaches understanding of the *problem*; this skill owns the *encoding* calls — invariant versus guidance, what a gate ranges over, where it binds, its kind. Surface the load-bearing ones with a recommended answer; auto-decide the rest and mark them `(auto)` with a matching `ASM-*`.

An amendment from an unattended executor is unattended: self-answer within the caller's delegation, ask no questions, and wait for no approval. Validate a delegated Appetite revision before applying it: the broader work serves the requested outcome, its benefit justifies the added complexity and maintenance, it has not already been done as excess, and it crosses no explicit exclusion or binding requirement. Preserve those requirements unless user steering explicitly changes them. A request outside that delegation returns an evidenced blocker without changing the Manifest. Record material autonomous decisions as `(auto)` items with matching `ASM-*` entries naming the rationale and impact if wrong.

The Manifest is the acceptance contract — what the user accepts as "I'd ship the outcome of executing this" — and `/do` executes it later with none of this conversation's context, so everything binding lives in the gate texts themselves. That gives a floor that isn't ceremony:

• Follow the schema in `references/SCHEMA.md` exactly — it is what the executor

parses, and it carries the ceiling invariant every manifest ships verbatim.

• Open Intent with the **Problem**: one specific story of what breaks or grates

today, the baseline everything else is pitched against. A session that cannot name a pain has found a stop signal, not an empty field — return to figure-out, or conclude there is nothing worth building. Appetite follows: the size of change the problem is worth, bounding complexity and surface rather than time.

• Cut each **Deliverable** as a slice that can be finished on its own and

exercised end-to-end — put in front of its real use, not merely inspected as present — which is what lets its criteria judge whether it works rather than whether it exists. A slice cut along a layer ("the data model", "the sources") can only be gated on existence, and *it compiles* or *the file exists* are inspections rather than uses. A request framed as layers is the requester's convenience: re-cut it, don't encode it. Order least-proven first within real dependencies, so an unworkable direction surfaces while there is room to turn.

• Every Acceptance Criterion and Global Invariant is one text — title, body,

optional why — stating what done means, the evidence to inspect, and the threshold between PASS and FAIL, precise enough that two evaluations read the same thing. The title never adds a requirement the body omits, and the why binds nothing.

• Every gate declares "Judgment gate." or "Deterministic gate." — never

inferred; an executor handed an undeclared kind is broken by it. A gate mixing a command with a judgment is a judgment gate.

• Bind the **outcome**, not the mechanism that serves it: if the executor met the

intent a better way and the gate would still go false, it is pinning a means — raise it until it isn't, stopping at what the work leaves behind can judge. The test reaches means, never ends: where a mechanism was deliberately chosen as the thing that must hold, it *is* the outcome, and raising it away is the erosion this discipline exists to prevent. Make that choosing legible — in the gate's why where nothing else shows it — so a later reader can tell a deliberate mechanism from an incidental one.

• Write a gate so it ranges over its **region**, not an inventory: where the

criterion is *no X anywhere in R*, the body makes the evaluator enumerate R and derive the instances, so tomorrow's instance is caught too. Make the procedure exact rather than the list. An Acceptance Criterion's region is its Deliverable's surface; a Global Invariant's is the Manifest's, bounded by Appetite.

• Anything whose violation would be unsafe or irreversible becomes a Global

Invariant — never Process Guidance, never dropped for resisting verification. Where only part of it is judgable from the artifacts, gate that part and record the rest as an `ASM-*` naming what enforces it instead.

• Encode every explicit Out of bounds exclusion once as a Global Invariant;

anticipated omissions that may change belong in the advisory plan.

• A criterion the user pinned by *reacting* to something concrete — a mock, a

reference, a chosen direction — is a success criterion, not flavor. Encode it as a gate, judged against what the reaction named. Never route one to the advisory layer, where it can be weighed away.

• Triage Known Assumptions by what being wrong would cost: work redone is an

assumption and belongs in `ASM-*`; an approach invalidated is not — settle that gap now, as a gate where it must not be departed from or as Initial Approach direction where it is guidance. Left as an assumption it surfaces mid-run, where a stalled unattended execution costs far more.

• A criterion