git:20260906.78f19d8 to git:20260906.babedab

---

name: sketch

description: "Recognize and revise concrete sketches to discover a form when descriptions cannot settle intent. Type: (FitUnrecognized, Hybrid, SKETCH-RECOGNIZE-CYCLE, FormIntentSeed) → RecognizedForm"

---

# Hypotyposis Protocol

Discover what a form should be by encountering concrete sketches and marking what does not fit, until the user recognizes a specific version as the form for a stated purpose. Type: `(FitUnrecognized, Hybrid, SKETCH-RECOGNIZE-CYCLE, FormIntentSeed) → RecognizedForm`.

## Definition

**Hypotyposis** (ὑποτύπωσις): an outline or sketch — a first drawing of a position rather than its finished statement. A dialogical act for the moment when a form has to be made and the intent behind it cannot yet be settled from descriptions: the user can say what is wrong with a thing in front of them long before they can say what the thing should be, because good fit has no positive description of its own while each misfit is immediate and can be pointed at (Alexander, 1964). So the protocol runs the other way round from a specification: the user settles each round's focus, the perception it needs, and its variants at a spec gate before anything is made; the AI produces the sketches; the user marks a specific version — what does not fit and what to keep — as first-class utterances; the AI revises the retained version under those marks; and the loop ends when the user recognizes one version as the form for a stated purpose and names where it lives.

```

── FLOW ──

Hypotyposis(I) → detect(I, ctx) →

[¬fit_unrecognized(I, ctx)] no_activation_relay → exit (NoActivationRelay)

bind(I) → Λ.history (each prior item as Settled | Candidate, provenance kept) → Λ.round := 1 →

Qround(Λ) → Stop → R →

[R = Adjust(rev)] revise(draft, rev) → re-present Qround -- pre-production loop

[R = Approve(settlements, supersessions)] settle(spec) ∧ promote(settlements) ∧ supersede(supersessions) → produce(spec, Λ) → Sk →

present(Sk) → Qfit(Sk, spec.focus) → Stop → M →

[M = Fit(w)] Λ.fit_witnesses ∪= {w} → Λ.round += 1 → Qround -- one focus adequate; the loop continues

[M = Finish(rec)] Λ.recognition := Some(rec) → Qplace → Stop → P → harvest → account →

[retention verified] RecognizedForm

[retention failed] declare → Qplace (re-presented with the failure; the same location is admissible)

[M = Withdraw] account → EarlyExit

[either party, at any gate: recognition needs no further encounter ∨ activation premise collapsed]

dissolution_relay → account → DissolutionExit

[either party, at any gate: a sibling deficit is demonstrated ∨ a realization the round requires is unavailable]

boundary_relay → account → BoundaryExit

── MORPHISM ──

FormIntentSeed

→ detect -- deficit predicate over the utterance and accumulated context (silent analysis)

→ bind -- prior material enters the history as Settled or Candidate, provenance kept

→ specify_round -- Constitution: focus, realization, and targets settled; provisional coordinates promoted, superseded, or held

→ recognize -- Constitution: marks on a specific version — Marks | Fit | Finish | Withdraw

→ record -- track: every mark, and every interpretation read from it, enters the append-only history; interpretations stay provisional

→ harvest -- active commitments, recognition witness, trace, and residual recorded before release

→ account -- per-sketch retain-or-release disposition, verified

→ RecognizedForm

requires: form_purpose_in_scope(I) -- runtime checkpoint (Phase 0): the work is about to make a form

deficit: FitUnrecognized -- activation precondition (Layer 1/2)

preserves: utterance(I) -- I.utterance is read-only; the history accumulates beside it

invariant: Concretum Retention -- a brief that revises does so on a retained parent; a sketch under judgment is never regenerated from coordinates alone

invariant: Commitment Provenance Preservation -- a prior constitutive act stays recorded; a later user act may supersede its operative determination; AI inference alone never supersedes a user commitment

invariant: Recognition over Description -- fit is the user's recognition of a specific version for a stated purpose

── TYPES ──

I = FormIntentSeed { utterance: String, prior: List(ReferencedMaterial) }

-- Input type: morphism processes I uniformly; prior is source-neutral — a settled direction, a resolved intent,

-- a candidate field, an existing artifact, a prior session's record — each named by the user or already in context

ReferencedMaterial = { source: String, content: String } -- what it is and where it came from; no sibling type is a runtime dependency

Binding = Settled(Coordinate) | Candidate(ReferencedMaterial) -- how a prior item enters the history at bind: a commitment the user already made, or material to draw on

fit_unrecognized(I, ctx) = a form-making purpose is in scope

∧ decision-relevant intent remains underdetermined

∧ encountering and revising a concrete proposal is what would constitute that intent

∧ the resolution sought is a recognized form with its commitments and residuals

Axis = String -- emergent label: "information unit", "reading order", "density", "tone"

Focus = Axis | Question(String) -- what this round filters attention toward; an unexpected misfit on any other axis stays admissible

Value = String -- a determination on an axis, in the user's words or read off the sketch

RoundSpec = { focus: Focus, realization: Realization, targets: NonEmptyList(VariantBrief) }

-- k = |targets| is settled here; a count the user already settled relays on later rounds

Supersession = { of: Coordinate, by: Optional(Coordinate) } -- the user's act on a coordinate in view: by = Some(c') replaces it with a determination the user states (c' enters Settled, basis Utterance), by = None retires it with nothing in its place

R = Round-spec gate answer ∈ {Approve(settlements, supersessions), Adjust(revision)}

-- Approve names which provisional coordinates become Settled and which coordinates — Provisional or Settled — the user supersedes (either set possibly empty); Adjust revises focus, realization, or targets and re-presents before anything is produced

SketchRef = { id: ℕ, round: ℕ } -- identity of one version; the harvest and every mark point at one of these

Concretum = Text(value) | Artifact(versioned_ref) -- Text: narration carried in session text; Artifact: a file under temp isolation, versioned at creation

Sketch = { ref: SketchRef, parents: List(SketchRef), concretum: Concretum, rendered_from: snapshot(active_coords), focus: Focus }

Anchor = Element(locator) | Region(bounds) | Whole | Span(text) -- where on a sketch a mark points; Whole admits "something is missing here" with nothing to point at

Mark = Misfit { sketch: SketchRef, anchor: Anchor, utterance: String, axis: Optional(Axis) }

| Keep { sketch: SketchRef, anchor: Anchor, utterance: String }

-- a user utterance anchored on a version; Keep is the positive half of mixed feedback and is retained, never dropped

Status = Provisional | Settled

-- interpret() yields Provisional only; Settled requires the user's act at Qround or a convention already on record

-- Superseded is appended by supersede at Qround and nowhere else: the user's act is its only producer, so an AI interpretation the user rejects leaves provisional(Λ) and a determination the user replaces leaves active_coords

active_coords(Λ) = fold(Λ.history) -- the operative determinations now: per axis, the latest Settled coordinate with no Superseded(it, _) after it — Superseded(c, Some(c')) makes c' operative in c's place, Superseded(c, None) retires c with nothing in its place; Provisional ones shown beside

FitWitness = { sketch: SketchRef, context_revision: ℕ, scope: Focus, utterance: String }

-- adequacy on one focus for one version; stale once its sketch is superseded or the context revision moves — shown as stale, never reused silently

Recognition = { target: SketchRef, context_revision: ℕ, purpose_scope: String, residual: Set(Axis) }

-- target must be a presented, retained version; Finish is recognition of the assembled form, not of one focus

M = Recognition gate answer ∈ {Marks(Set(Mark)), Fit(FitWitness), Finish(Recognition), Withdraw}

-- Marks(∅) is read as Stop, never as Fit; silence yields the turn again; a response carrying both marks and a finish is parsed as Marks — recognition names an unmarked version

-- status: recognition witness. It carries no implementation commitment and is not an executable specification

Disposition ∈ {Retained(Location), Released, ReleaseFailed(reason), RetainFailed(reason)}

-- Retained is written only once verification holds: the reference resolves to the recognized version's exact concretum. RetainFailed sends control back to Qplace; ReleaseFailed is declared with a handoff

TraceEntry = (Mark → Optional(Coordinate) → Optional(SketchRef) → Recognized | Superseded | Residual)

-- what each mark became: its interpretation, the revision it drove, and how it ended

ExitCause ∈ {NotActivated, Recognized, Withdrawn, BoundaryReached, Dissolved}

RecognizedForm = single record { commitments: Set(Coordinate) (Settled only), witness: Fixture, recognition: Recognition,

NoActivationRelay = the non-activation basis stated: the failed predicate with its evidence, or — on the AI-detected path — the user's decline at the first Qround, cited; a sibling deficit visible in the same scan is named as a finding and left to the session

EarlyExit = withdrawal at any gate: partial trace over completed rounds + account enforced + residual declared (no RecognizedForm returned; any prior recognition remains in the partial trace)

BoundaryExit = the unresolved obligation named — a sibling deficit demonstrated, or a realization the round requires that this session cannot supply — with account enforced; which protocol takes it is the session's, never this record's

DissolutionExit = the deficit dissolved during a circulation: the sharpened description made the form recognizable without a further encounter, or the activation premise collapsed; declared by either party with its basis, the surviving determinations relayed, account enforced

Initiator ∈ {UserInvoked, AIDetected} -- bound at activation; informs the Hybrid first-gate semantics

Phase ∈ {0, 1, 2, 3, 4, 5, 6}

── A-BINDING ──

bind(I) = explicit_arg ∪ recent_form_intent ∪ surfaced_fit_gap

Priority: explicit_arg > recent_form_intent > surfaced_fit_gap

/sketch "what to make" → I = FormIntentSeed with utterance; prior = material the utterance names or that is already in context

/sketch (alone) → I = the most recent form-making intent in session

"I'd know it when I see it" → I = the utterance under discussion (AI-detected path; the first Qround confirms or declines the run)

── PHASE TRANSITIONS ──

Phase 0: I → detect(I, ctx) → fit_unrecognized? -- silent analysis

[false] Λ.exit := NotActivated → no_activation_relay → exit (NoActivationRelay)

[true] → Phase 1

Phase 1: bind(I) → Λ.history := Bound(each prior item) → Λ.round := 1 → Phase 2 -- track; Settled where the user already committed, Candidate otherwise

Phase 2: draft(RoundSpec, provisional(Λ)) → Qround(Λ) → Stop → R -- round-spec gate [Tool]

[R = Adjust(rev)] revise(draft, rev) → re-present Qround -- nothing is produced under an unsettled spec

[R = Approve(settlements, supersessions)] Λ.spec := draft → promote(settlements) → Λ.history ++= Promoted(each) → supersede(supersessions) → Λ.history ++= Superseded(each of, by) → Λ.context_revision += 1 where either set is non-empty → Phase 3

-- free responses declared pre-gate: question a focus (answered, gate re-presented); contest the activation premise (dissolution arm → Phase 6); name a boundary (boundary arm → Phase 6); withdraw (Phase 6, EarlyExit arm)

-- on the AI-detected path, the first Qround is also the confirm-or-decline of the run: Adjust or Approve confirms; a free-response decline sets Λ.exit := NotActivated and exits as NoActivationRelay with the decline as its basis (nothing produced, nothing to account)

[|Λ.spec.targets| > 1, conditional] produce_delegate(∥ one sketch per executor, temp-isolated) [Tool]

-- every sketch records its concretum and a versioned reference at creation; existing project files stay unchanged

Phase 4: present(Sk) → acquire(marks) → Qfit(Sk, Λ.spec.focus) → Stop → M -- recognition gate [Tool]

[M = Fit(w)] Λ.fit_witnesses ∪= {w} → Λ.history ++= Witnessed(w) → Λ.round += 1 → Phase 2

[M = Finish(rec)] Λ.recognition := Some(rec) → Phase 5

[M = Withdraw] → Phase 6 (EarlyExit arm)

-- free responses declared pre-gate: interrogate a sketch (answered within its placeholder status, gate re-presented); ask for a different realization (a spec revision — Phase 2 with the revision named, no new round counted); contest the premise (dissolution arm); name a boundary (boundary arm)

-- Marks(∅) is Stop; a mixed response keeps its Keep marks; a response naming a version that was not presented is answered, never parsed as Finish

Phase 5: Qplace(Λ.recognition.target) → Stop → P -- placement gate [Tool]

-- RE-ENTERED from Phase 6 on RetainFailed: the failure is declared before the gate; the user names a location again — the same one is admissible — or withdraws

Phase 6: account → [a terminal arm] Λ.exit := cause → terminal -- all arms [Tool]; the RetainFailed arm returns to Phase 5 with Λ.exit still None

[withdrawal at any gate] release(all) → EarlyExit

[dissolution arm] release(all) → DissolutionExit

[boundary arm] release(all) → BoundaryExit

-- release: per sketch, the destruction read off its concretum (a no-op for Text) → verify absence → Disposition; a failure retries once, then is declared ReleaseFailed with a handoff, never silent

-- Λ.dispositions is append-only; a sketch's disposition is its latest entry, so a RetainFailed is superseded by the Retained a later Place verifies

── LOOP ──

Each round re-enters Phase 2 with the history it accumulated; the round counter is visible at every Qround and Qfit.

No fixed round cap: a round that re-enters a Constitution gate is dialogue, and the user can withdraw at any gate.

Variant count is settled per round at Qround; a count the user already settled relays until they revise it.

Continue until: RecognizedForm (Finish + placement + account) OR EarlyExit OR DissolutionExit OR BoundaryExit.

── CONVERGENCE ──

disposition(s) = the latest entry for s.ref in Λ.dispositions

accounted(Λ) = ∀ s ∈ Λ.sketches: disposition(s) is defined -- every sketch has a declared disposition

∧ ∀ s: disposition(s) ∈ {ReleaseFailed(_), RetainFailed(_)} ⇒ handoff_declared(s) -- failures are declared, never silent

recognition_ready(Λ) = Λ.recognition = Some(rec)

∧ rec.target ∈ presented(Λ.sketches) ∧ disposition(rec.target) = Retained(Λ.fixture.ref) -- retention verified, never assumed

∧ rec.context_revision = Λ.context_revision

∧ Λ.fixture ≠ None -- Qplace settled

∧ residual_declared(Λ) ∧ trace_declared(Λ)

converged(Λ) = accounted(Λ) ∧ ((Λ.exit = Recognized ∧ recognition_ready(Λ)) ∨ (Λ.exit = Dissolved ∧ basis_declared(Λ)))

result equations:

NoActivationRelay ⇔ Λ.exit = NotActivated -- nothing produced; nothing to account

RecognizedForm ⇔ Λ.exit = Recognized ∧ recognition_ready(Λ) ∧ accounted(Λ)

EarlyExit ⇔ Λ.exit = Withdrawn ∧ accounted(Λ) -- non-convergent

BoundaryExit ⇔ Λ.exit = BoundaryReached ∧ obligation_named(Λ) ∧ accounted(Λ) -- non-convergent; the session routes it

DissolutionExit ⇔ Λ.exit = Dissolved ∧ basis_declared(Λ) ∧ accounted(Λ) -- convergent stand-down: no form was owed

── TOOL GROUNDING ──

-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed

Phase 0 detect (sense) → Internal analysis (deficit predicate over the utterance and accumulated context; no external tool)

Phase 0 no_activation_relay (extension) → TextPresent+Proceed (the non-activation basis — the failed predicate with its evidence, or the user's decline at the first Qround on the AI-detected path; a sibling deficit seen in the scan is named as a finding and left to the session; not activated)

Phase 1 bind (track) → Internal state update (prior material enters Λ.history as Settled or Candidate with provenance; the round counter starts)

Phase 2 revise (track) → Internal state update (Adjust branch: the draft revised as named before re-presenting)

Phase 2 settle (track) → Internal state update (Approve branch: Λ.spec committed; each provisional coordinate the user named becomes Settled with a Promoted event; each coordinate the user superseded takes a Superseded event — with the replacement they stated, or none; unnamed ones stay as they were)

Phase 3 produce_delegate (dispatch) → delegate (conditional: more than one target; parallel topology: one sketch per executor, each temp-isolated with its reference registered; subordinate to the active runtime policy)

Phase 4 Qfit (constitution) → present (mandatory recognition gate on a specific version: Marks, Fit on this focus, Finish for a stated purpose, Withdraw; Marks(∅) is Stop; the pre-gate text declares the free-response paths — interrogate, ask for another realization, contest the premise, name a boundary)

dissolution_relay (extension) → TextPresent+Proceed (either party, at any gate: the sharpened description made the form recognizable without a further encounter, or the activation premise collapsed; state the basis, relay the Settled commitments and every mark recorded, run account, stand down as DissolutionExit — a success, not an abandonment)

boundary_relay (extension) → TextPresent+Proceed (either party, at any gate: a sibling deficit is demonstrated, or a realization this round requires is one this session cannot supply; name the obligation and its basis, relay the harvest so far, run account, exit as BoundaryExit; the next protocol is the session's to choose)

withdraw (extension) → TextPresent+Proceed (explicit free-response exit at any gate: partial trace + residual declared; account enforced; EarlyExit. A hard interrupt yields no turn, so account cannot run: temp isolation's bounded lifecycle is the backstop)

converge (extension) → TextPresent+Proceed (transformation trace: marks → interpretations → revisions → recognition; the recognized version, its placement, Settled commitments, Provisional coordinates, residual axes, and every disposition)

seam (extension) → TextPresent+Proceed (fires at deactivation: a user-declared chain naming the next protocol settles the next move — proceed to it, citing that settling source; the RecognizedForm enters it as prior material, its fixture a recognition witness and nothing more. This protocol declares no wired outbound edge of its own. Every Constitution gate inside this protocol and inside the next fires unchanged)

── MODE STATE ──

Λ = { phase: Phase, I: FormIntentSeed, round: ℕ,

context_revision: ℕ, -- advances when the accumulated context moves outside the marks: a new user utterance about the form, a spec revision, a promoted or superseded coordinate

spec: Option(RoundSpec), -- this round's settled spec; None until Approve

sketches: List(Sketch), -- every version produced, retained for revision until account

fit_witnesses: Set(FitWitness), -- with staleness derived from sketches and context_revision

recognition: Option(Recognition),

fixture: Option(Fixture),

dispositions: List<(SketchRef, Disposition)>, -- append-only; a sketch's disposition is its latest entry, one defined per sketch by terminal (invariant: accounted)

exit: Option(ExitCause),

initiator: Initiator,

active: Bool, cause_tag: String }

-- Guard: no sketch is produced before a Qround approval covers its brief — phase < 3 ⇒ sketches = ∅ on round 1; a later round holds prior sketches and produces nothing until its Qround settles

── COMPOSITION ──

*: product — (D₁ × D₂) → (R₁ × R₂). Form resolution emergent via session context.

```

## Scope Boundary

The transformation the moment needs decides between neighbors; a sibling deficit seen in the scan or demonstrated in a round is named as a finding at the boundary, and the session chooses what takes it.

- `/preview` — recognize and settle a direction among named alternatives; its probes are discarded. Here the resolution sought is a form, and the recognized version is kept; a direction settled by `/preview` can enter as prior material.

- `/elicit` — resolve intent by reverse-tracing decision coordinates from externalized cognition. Here encountering and revising sketches constitutes the remaining form intent; readable prior material may already exist.

- `/contextualize` — adjudicate a result's fit against application context held fixed within the run, with adaptation directed by the user. Here encountering sketches develops the form intent itself.

- `/ideate` — a thin field of ideas widened, nothing selected. Here a form is recognized.

## Mode Activation

`/sketch` is directly invocable. On the AI-detected path, cite evidence of `FitUnrecognized`; the first `Qround` confirms or declines the run. Loaded safety boundaries, capability restrictions, and explicit user instructions continue to bind while Hypotyposis is active.

Heuristic discovery cues are a plan that cannot reach its first draft, a description rewritten instead of made, a request to see something before saying more, and an explicit "I'd know it when I see it". They establish grounds to run Phase 0 rather than activation predicates.

## Protocol

### Phase 0: Detection (Silent)

Apply the deficit predicate in the Definition and cite the basis.

### Phase 1: Bind

Bring each prior item into the history as `Settled` only where the user settled it, as `Candidate` otherwise, with where it came from.

### Phase 2: Round Spec Gate

Lay out the pre-gate content TOOL GROUNDING's `Qround` entry names, then render `Qround`:

```

Settle this round before I make anything.

Options:

1. **Approve** — produce these variants under this focus; name which readings you now settle, reject, or replace, or none

2. **Adjust** — revise the focus, the perception, or the variants and re-present before anything is produced

```

Name questioning a focus, contesting the premise, naming a boundary, and stepping out as free-response paths.

### Phase 3: Production (Transform)

Produce under the settled spec as TOOL GROUNDING's `produce` entry states; every sketch carries its placeholder status visibly.

### Phase 4: Recognition Gate (Constitution)

Present as TOOL GROUNDING's `present` entry states, acquire the marks through the channel the host supplies, then render `Qfit`:

```

Which version are you marking, and what do you see?

Options:

1. **Mark** — point at what does not fit (and what to keep) on a named version; I revise from there

2. **Fit on this focus** — this version is adequate on this round's focus; the next round takes another focus

3. **Finish** — this version is the form, for the purpose you state, with the axes you leave open

```

Name interrogating a sketch, asking for a different perception, contesting the premise, naming a boundary, and withdrawing as free-response paths; they are not numbered options.

### Phase 5: Placement Gate (Constitution)

Present the recognized version and the capability it needs — a reference that outlives the session — and render `Qplace` with no default:

```

Where does the recognized version live from here?

Options:

```

When a retention failed, say so before re-presenting; the same location stays admissible.

## Rules

- **Round composition**: Use everyday language, put evidence and differential implications before the gate, and leave the gate to the question and options. Read `references/round-composition.md` before composing when wording must persist across rounds or phase placement is material.

- **Form feedback**: Derive each round's density from the current request; carry an explicit form instruction until countermanded. Change form directly. Content, wording, order, cadence, and turn boundaries fixed elsewhere remain fixed; state what changed and, where the instruction overlaps a fixed element, what stays and why.