Interview Flow

The shape

An interview collects the facts a document needs, one Module at a time, by conversation rather than by form. The user describes what they want, a library source is chosen, a working Document is created from it, and Goldie works through the Modules asking for what is still missing.

In plain terms: the client interview, conducted by the agent — one matter, one pass through the questions, in the order that makes sense rather than the order they happen to be filed in.

The rules it must satisfy

Server drives flow, model drives conversation

The deciding rule, and the one worth keeping verbatim. The server computes flow conditions, write safety and which Module is actionable next, deterministically, and hands the model a per-turn brief. The model never decides Module order, never recalls field keys from memory, and never confirms its own writes.

The model stays irreplaceable for phrasing a question from a block's guide, extracting several fields from one messy answer, judging skip/defer/infer, and explaining the document. Handing it the flow as well was the shared root cause of the two failure classes this architecture was built to remove: several sequential completions per turn, and write fumbles from key guessing.

Agenda-driven turns

The server assembles the brief — the agenda — deterministically and injects it ephemerally for one turn. It is never stored as conversation. The term is defined in the glossary.

A turn is one sendMessage call

One call in, one turn, plus the single kickoff turn issued when the interview starts. Multi-step tool execution inside a call is within one turn, never several: turn count counts calls, not model steps. The turn kinds in the turn audit log label turns that already happened; they do not define what one is.

When Goldie may start a turn without being spoken to is the agent turn policy, which governs, and is not restated here.

Interview progress is a fact per folio

Each data Block carries its own interviewStatus and, where it was not simply answered, a reason. A Module's status is derived from the Blocks beneath it and never written directly. A question is done when it is answered or deliberately skipped — that ruling governs. The axis itself is in Status Axes.

Shared facts live in the data pool, once

Party details, jurisdiction and other document-wide facts are collected on the Document's data_pool Module, whose Blocks are all data Blocks. Other Modules read the pool by handle and never hold their own copy, so editing a pool field once updates every Block that reads it. Write authority sits with the Block that owns the field; consumers reference, never write.

The transcript is not the record

The conversation lives in the agent thread store. What the interview extracts — the collected values and the progress — is a fact on the folio. Neither is derived from the other at read time, and the transcript is never the source for what was collected.

Never leak internal vocabulary

Two audiences exist and nothing crosses between them: field keys, flow conditions, tool results and write mechanics are addressed to the agent; the reply is addressed to the person. A reply names the field's label, says what is blocking in ordinary words, and never quotes a snake_case key, a dotted path, or storage mechanics. This is the audience split One Block Notification Channel draws, applied to the interview turn.

It earned its place: on 2026-07-31 a live reply quoted the flow-condition path data_pool.data.has_children_under_18 and explained itself in write mechanics ("re-run the Guardians write"). One layer is never enough — the brief must pair every key it hands the model with a lawyer-readable label, the prompt must ban the vocabulary outright, and the interview's own eval must fail on a leak.

In plain terms: the client reads the letter, not the file note.

Where the live pieces are

Goldie's live instructions are authored Markdown under convex/goldie/instructions/; that folder's ASSEMBLY.md says which brief reaches which turn. The interview's own prompts were deleted with the interview surface and return with it.

The local skill runs a simpler filesystem-backed version of the same interview shape — see Local Skills. The grammar is shared: Module order as sequence position, field-level flow.condition, per-folio status, and data_pool reads. Only the persistence differs.