# Working by recipe

A house needs judgments that no deterministic code can make: which topic a document
belongs to, whether two name forms are one person, what a volume is about. In the house
software each of these is a route: code builds the context, a model judges once without
tools, code checks the verdict and applies it. A recipe hands you that route to run
yourself, on your own model, with the skills of the author door.

## Three ways to judge in a house

| Way | What the house does | Status |
|---|---|---|
| Free-hand | nothing; you decide what to read and what to assert | today |
| By recipe | nothing; the recipe tells you the route, the prompt and the checks | today |
| Guided | builds the context, hands you prompt and answer form, checks and applies your verdict | planned, not yet available; see `the-list-of-open-work` |

## The four recipes, and their order

| Order | Recipe | Judgment |
|---|---|---|
| 1 | `recipe-assign-topics` | which of the owner's topics a document belongs to |
| 2 | `recipe-resolve-names` | which name forms in a text are persons, places, organizations |
| 3 | `recipe-merge-name-forms` | which of those identities are the same individual |
| 4 | `recipe-summarise-a-volume` | a digest per document, so that a search finds the right one |

The order is that of the house software: outline, topics, names, digest. There is no recipe
for outlining. Outlining is only safe as a program: the model returns nothing but block
marks, and code builds the new version behind three locks against text loss. By hand you
would rewrite the whole text, which is the error the route exists to prevent. Outlining
is planned as guided work and not yet available.

So use the recipes on documents that arrive with structure (Markdown, or HTML from a web capture). For
documents that arrive as raw text and still need outlining, wait: an outline creates a
new version of the document, and work done on the old version will be offered again. No
skill tells the two apart yet. Look at the export: headings and paragraphs mean structure;
one unbroken run of lines means raw text.

A digest is a document too, and `list_documents` returns it. The first three recipes skip
digests: the aspect `Verdichtung` in `overview` names a collection, and `list_collection`
on it lists them.

## How to run a judgment

1. Fetch the context with the skills the recipe names, and build the input exactly as
   shown. The form of the input is part of the prompt.
2. Judge with the prompt as given. If you can delegate, hand prompt and input to a
   sub-agent without tools, one call per unit: that is how the route runs in the house
   software, and it keeps your own context from colouring the verdict.
3. Produce the answer form before you act. A verdict you cannot write in that form is not
   one.
4. Run the checks of the recipe on your own verdict. They are the guards of the route, in
   words.
5. Apply with the skills the recipe names, in its order.

`read_skill` shows the arguments of a skill, not its answer. Where a recipe needs a value
from an answer, it names the field, such as `stored.id`.

## Where the prompts come from

Each recipe names the file and commit of its prompt in the house software. There the
prompts ran in production on one German estate of diaries, letters and chronicles, and
they name that corpus and use German examples. Here every prompt is **adapted**: the rules
of judgment are kept sentence for sentence, the corpus is no longer named, and examples
are English. In this form none has run at scale. Rules that depend on the language of your
documents say so; adjust their examples to your corpus.

## What no recipe does

- **No guard runs in the house.** It accepts what you assert. One example, tried on a
  running house: `merge_into` joins a person to an organization without complaint.
- **No stamp is written.** The routes mark what they judged with stamps computed by
  code. A recipe writes none, so nothing tells a later visitor what you already judged
  except the facts you left. Guided work (planned) will offer those documents again and
  show what already stands.
- **No lock.** Two agents following the same recipe at once do the work twice. Asserting
  the same fact twice is harmless; merging is not.

## Say who judged

A house keeps who said what. Name yourself once, then leave a note where you judged:

```
name_speaker {"name": "<your name and model>"}
add_note {"thing_id": "<what you judged>", "author_id": "<speaker.id>",
          "text": "<recipe, verdict in a sentence>", "time": "2026-10-02T21:30:00"}
```

`name_speaker` finds the same speaker again by its name. `time` is wall time to the
second, in that form. Take the moment your run began and pass it with every note of the
run: a call that is repeated then writes nothing, where a note without `time` is written
again each second. Name the thing in the text. The same words by the same author at the
same time are one note, and at a second thing it is attached again (`is_new: false`,
`appended: true`), not written anew.

## Words you will meet

The house software grew in German. `Thema` is topic, `Umschreibung` its description,
`Verdichtung` a digest, `fassung` a version, `Ort` a place, `Organisation` an
organization, `Erwähnung` a mention.

## Go deeper

- [recipe-assign-topics](recipe-assign-topics.md)
- [recipe-resolve-names](recipe-resolve-names.md)
- [recipe-merge-name-forms](recipe-merge-name-forms.md)
- [recipe-summarise-a-volume](recipe-summarise-a-volume.md)
- [who-does-the-thinking](who-does-the-thinking.md)
- [the-list-of-open-work](the-list-of-open-work.md)