Cooking Agentic Thoughts with Relurpify on Relurpify

Chapter 1 — A Line Cook with a Work Permit

Fri, 23 Oct 2026 17:38:17 +0000

# Chapter 1 — A Line Cook with a Work Permit

You want help in your kitchen. Two candidates walk in.

The first one is brilliant, tireless, and wants root on your laptop. You hand over the keys, turn your back, and hope. When the sauce catches fire, you will not know who turned up the flame, when, or why.

Chapter 2 — One Turn, Watched Closely

Fri, 23 Oct 2026 17:52:54 +0000

# Chapter 2 — One Turn, Watched Closely

An order comes into the kitchen: “The slugify function is broken. Fix it and prove the tests pass.”

In most tools, that order disappears into a box marked “AI” and comes out some time later with edits attached. You grade the result and wonder, in the permanent low hum of agent-assisted development: what did it actually do in there?

Chapter 3 — Own the Kitchen

Fri, 23 Oct 2026 17:49:34 +0000

# Chapter 3 — Own the Kitchen

For two chapters you have cooked in a kitchen someone else stocked. The model was a default. The posture dials sat wherever the template put them. Ninety-nine tools, ten recipes, twenty-nine prompts, four security policies — all of it materialized into your project by a command you ran once, and all of it yours now.

Chapter 4 — Your First Thoughtrecipe

Fri, 23 Oct 2026 18:16:26 +0000

# Chapter 4 — Your First Thoughtrecipe

Until today, every choice the agent made on your behalf came from recipes someone else wrote. You watched the lattice score twelve candidates, and you took its word that the winner was right.

The shelf marked euclo/ is yours now, and it takes text files. This chapter you write one from an empty file — a trigger, a goal, a capture — and then you make the runtime prove a sentence that has never been true in this kitchen before: it ran because you said so. The receipt will read decided_by: "pinned", and by the end of the chapter you will know exactly what that line cost and what it bought.

Chapter 5 — The Recipe Toolkit

Fri, 23 Oct 2026 18:52:48 +0000

# Chapter 5 — The Recipe Toolkit

Chapter 4’s recipe had one idea: read a thing, explain it. Real kitchen work is not one idea. It is inspect, decide, confirm with the boss, act, prove — and when the boss says no, that answer has to go somewhere.

This chapter adds the rest of the authoring language: types that make findings checkable, routes that make behavior conditional, an ask user gate that puts a decision in your hands mid-recipe, the delegation and pipeline constructs, and the verification vocabulary that lets a recipe prove its own work. You will build triage — a recipe with all of it — and meet, honestly, the point where a small local model and an ambitious recipe disagree about what fits in a turn.

Chapter 6 — Line Cooks: The Linear Paradigms

Fri, 23 Oct 2026 21:11:35 +0000

# Chapter 6 — Line Cooks: The Linear Paradigms

Every recipe you have written binds its agent to one paradigm — react — and every turn you have watched ran the same shape: think, act, observe, repeat, bounded. It works. It is also one knife in a drawer of eight.

The recipe language declares the full set, and each paradigm is a different shape of thinking: an iteration loop, a staged line, a chain of isolated prompts, a review cycle, planners of three kinds, a shared board. This chapter teaches the four linear ones — the paradigms whose control flow you can draw as a line — with their mechanics verified in the framework’s own source, three real recipes you will write, and the captured truth about what each costs on a small local model.

Chapter 7 — Chefs and the Kitchen Board: Planning Paradigms

Fri, 23 Oct 2026 21:29:13 +0000

# Chapter 7 — Chefs and the Kitchen Board: Planning Paradigms

A line cook executes. A chef decides what to execute — and sometimes the decision is the deliverable: the plan itself, checked and signed, before any pan is hot.

The remaining four paradigms are the planning family. Where the linear set (Chapter 6) draws lines and loops, these draw decompositions: planner produces a plan and checks it, rewoo plans every tool call up front so the model reads the world once, htn decomposes tasks into methods, and blackboard lets specialists contribute to a shared board in whatever order the board dictates. Same method as last chapter — contract first, recipe second, receipts always — plus the craft question this family exists for: when does planning beat doing?

Chapter 8 — The Prompt DSL

Fri, 23 Oct 2026 22:55:42 +0000

# Chapter 8 — The Prompt DSL

Every turn you have run had a voice the model heard before it heard you: a system prompt telling it what it is, which tools exist, how to answer. Through seven chapters that voice was the shipped corpus’s. You have edited recipes, postures, policies — but the house style, the sentences that shape every decision, stayed factory-set.

Chapter 9 — Prompt Engineering, with a Metronome

Fri, 23 Oct 2026 23:10:24 +0000

# Chapter 9 — Prompt Engineering, with a Metronome

Here is the uncomfortable truth about the last three chapters: everything you authored — recipes, prompts, postures — was verified the expensive way. You ran a turn, watched the feed, read the receipts, and you were the regression suite. A recipe change that silently breaks behavior is found the same way a chef finds a missing ingredient: by tasting everything, every service, forever.

Chapter 10 — Rewriting the House Style

Fri, 23 Oct 2026 23:26:17 +0000

# Chapter 10 — Rewriting the House Style

Every kitchen has house style. Not the recipes — the habits: taste before seasoning, clean as you go, the way everyone plates a dish without being told. For seven chapters you worked under this kitchen’s shipped habits, encoded in sentences the model reads before it reads you. Chapter 8 let you add one line. This chapter asks the bigger question: which sentences actually reach the model, and who gets to write them?

Chapter 11 — Out of the Loop, Not Out of Mind

Fri, 23 Oct 2026 23:51:46 +0000

# Chapter 11 — Out of the Loop, Not Out of Mind

The driving lesson from the wider agentic-engineering world goes: in-loop (hands on the wheel) → out-loop (cruise control, you in the seat) → the aspiration some call zero-touch engineering (the robotaxi). The same world’s honest critique answers itself: a loop running unattended is also a loop failing unattended, and the failures scale with the autonomy.

Labs — Cooking Agentic Thoughts with Relurpify

Fri, 23 Oct 2026 23:52:15 +0000

# Labs — Cooking Agentic Thoughts with Relurpify

This folder holds every artifact the book builds, exactly as it reads at the end of the chapter that introduced it. It is the book’s cumulative code listing; Appendix D is generated from it.

# Layout

ch01-stringkit/ — the stringkit demo repo as seeded in Chapter 1 (buggy slugify, one intentionally failing test, captured transcript).
ch02-first-turn/ — the Chapter 2 receipts command card and the captured two-turn session table.
ch03-workspace-baseline/ — the annotated workspace.yaml, the counted tree inventory, and the captured Chapter 3 experiments.
ch04-explain-test/ — the reader’s first recipe, the pin acknowledgment, and both route-selection receipts (pinned vs lattice).
ch05-triage/ — the full-toolkit triage recipe, the zero-model gate_demo recipe, the captured linter errors, and the frame finding.
ch06-linear-paradigms/ — the three linear-paradigm recipes, the three-layer validation story, and the contract pointers.
ch07-planning-paradigms/ — the planning-family recipes, the captured governance catch, and the llm_calls counter flag.
ch08-prompts/ — the edited react system prompt, the resolution receipt shape, and the two flagged doc-vs-build deltas.
ch09-agent-tests/ — the stringkit regression suite, the red capture with its OSB receipt chain, and the three infra gotchas.
ch10-house-style/ — the live prompts with the chapter’s edits, the drafting recipe, the wiring finding, and the ladder cheat.
ch11-out-of-loop/ — the final exam: the queued repair’s transcript, diff, closing receipt, and the supervision command card.
verify.sh — the tiered verifier. See below.

# Prerequisites

The relurpify binaries built from tag BETA-RC1-FALL2026 (go build -o relurpish ./app/relurpish, go build -o relurplint ./app/relurplint). Source builds report relurpish dev (commit none, built unknown).
Python 3 with pytest for the stringkit chapters.
Ollama serving gemma4:e4b — the book’s model backend (the materialization default). The offline scripted backend appears only where the book says so (deterministic test tiers).
Docker (and gVisor runsc on Linux for the default sandbox backend) for the tiers that boot the runtime.

# The verifier

./verify.sh ch01          # runs the Chapter 1 check

Tiers, and what each one honestly proves:

Chapter 2 lab — captured receipts and the command card

Fri, 23 Oct 2026 17:38:17 +0000

# Chapter 2 lab — captured receipts and the command card

This chapter’s turns were executed for real (Linux, Ollama 0.40.8 serving gemma4:e4b, pytest 9.1.1, Go-built relurpish from the tree that became BETA-RC1-FALL2026). The session was driven through a correctly sized pseudo-terminal by an expect-style script (drive_demo.py in the author’s capture kit), keystroke by keystroke: boot → task → approval banner → s → completion. Everything the chapter quotes exists on disk in the demo workspace.

Chapter 3 lab — workspace baseline

Fri, 23 Oct 2026 17:49:47 +0000

# Chapter 3 lab — workspace baseline

The captured state of every experiment in “Own the Kitchen,” on the verification machine (Linux, Ollama 0.40.8 serving gemma4:e4b, binaries built from the tree that became BETA-RC1-FALL2026).

# Files

workspace-annotated.yaml — the materialized workspace.yaml, trimmed to the keys the chapter teaches, with the captured values.
experiment-log.md — every hands-on step with its captured output.

# Reproduce

From your workspace root, with your built binaries:

Chapter 3 experiment log — captured outputs

Fri, 23 Oct 2026 17:50:13 +0000

# Chapter 3 experiment log — captured outputs

# 1. First relurplint run

$ relurplint --check all --workspace .
relurplint: all checks passed (0 diagnostics)
(exit 0)

# 2. Tree inventory (counted)

model/provider/  : 4 (ollama, lmstudio, openai_compatible, offline)
model/profiles/  : 3 (default.llm.yaml, gemma4.llm.yaml, qwen2.5-coder.llm.yaml)
security/        : 4 (sandbox, shell, localtool, workspaceingestion .policy.yaml)
tools/           : 99 manifests — file 6, git 5, lsp 7, search 3, test 5,
                   shell 73 (in 8 category subdirectories under tools/shell/)
prompts/         : 29 files (agents/, framework/, named/)
euclo/           : 10 .erpe recipes + families.yaml

Verification: find relurpify_cfg/tools -name "*.yaml" | wc -l → 99; find relurpify_cfg/tools/shell -name "*.yaml" | wc -l → 73; find relurpify_cfg/prompts -name "*.prompt" | wc -l → 29.

Chapter 4 lab — explain_test

Fri, 23 Oct 2026 18:16:11 +0000

# Chapter 4 lab — explain_test

The first reader-authored recipe, exactly as captured.

# Files

explain_test.erpe — the recipe as written in the hands-on (byte-identical to the workspace copy used for the captures).
captures.md — the captured receipts.

# Reproduce

# grammar, types, symbols, lowering — no registry
relurplint --check recipes --workspace .

# in the TUI
/recipe                                      # find euclo.thoughtrecipe.explain_test
/recipe euclo.thoughtrecipe.explain_test     # pin for this session
# …give an explanation task…
/recipe clear                                # return selection to the lattice

# the proof
jq -c 'select(.resourceLogs) | .resourceLogs[]?.scopeLogs[]?.logRecords[]?
       | select(.eventName=="euclo.route.selected")' \
    .relurpify_state/telemetry/otlp/*.jsonl | tail -1

Captured rule: restart relurpish after any recipe edit — registration and pin validation both read the boot-time registry.

Chapter 4 captures

Fri, 23 Oct 2026 18:16:11 +0000

# Chapter 4 captures

# Pin acknowledgment (real boot, 220×50 pty)

Pinned recipe for this session: euclo.thoughtrecipe.explain_test (dispatch runs exactly this recipe; /recipe clear to unpin)

# Route selection, pinned vs unpinned (real telemetry)

Turn	`decided_by`	`candidate_count`	family
Unpinned explanation ask (before pin)	`lattice:score`	14	`investigation`
Pinned explanation ask	`pinned`	1	`investigation`

The 14 (not 12 as in Chapter 2) includes the two new candidate files added after that chapter — registration changed the lattice’s candidate set immediately.

Chapter 5 lab — triage and gate_demo

Fri, 23 Oct 2026 18:52:14 +0000

# Chapter 5 lab — triage and gate_demo

The chapter’s two recipes and the captured evidence.

# Files

triage.erpe — the full-toolkit recipe (types, typed captures, provenance annotation, ask user gate, route with a run-in-branch repairer). Lints green; verified registered, pinned, and dispatched.
gate_demo.erpe — the zero-model-call route+gate recipe used to verify ask user machinery in isolation. Lints green; route as the sole execution construct is valid.
captures.md — linter errors, dispatch receipts, the frame finding.

# Reproduce

relurplint --check recipes --workspace .   # both recipes: 0 diagnostics
# in the TUI, after a restart so both register:
/recipe euclo.thoughtrecipe.triage         # pin
# dispatch a triage task; read the receipt:

jq -c 'select(.resourceLogs) | .resourceLogs[]?.scopeLogs[]?.logRecords[]?
       | select(.eventName=="euclo.route.selected")' \
    .relurpify_state/telemetry/otlp/*.jsonl | tail -1

Chapter 5 captures

Fri, 23 Oct 2026 18:52:28 +0000

# Chapter 5 captures

# Two linter catches on the way to green (real errors)

# annotation after the destination (wrong position):
relurpify_cfg/euclo/triage.erpe: [error recipes.parse] ...:42:50: expected "->"

# vocabulary declaration inside a delegate block:
relurpify_cfg/euclo/triage.erpe: [error recipes.parse] ...:40:11: may invoke is only allowed in trigger and run blocks

Fixes: as claimed sits after the source type, before the arrow; per-step vocabulary requires run blocks (route branches included), not delegate.

Chapter 6 lab — the linear paradigms

Fri, 23 Oct 2026 21:11:52 +0000

# Chapter 6 lab — the linear paradigms

Three recipes, one per linear paradigm, plus the captured validation story.

# Files

add_truncate.erpe — pipeline: plan stage (read-only) → implement stage (write + pytest). Second stage reads the first stage’s capture.
summarize_funcs.erpe — chainer: three links, each prompt + from + capture. Links take prompt, never goal.
polish_docstring.erpe — reflection: review writes scratch.review/scratch.review_issues; revise when scratch.review contains issues: runs a declared fixer agent.

# Reproduce

relurplint --check recipes --workspace .   # 0 diagnostics
# restart relurpish so all three register, then pin and dispatch each:
#   /recipe euclo.thoughtrecipe.add_truncate
#   /recipe euclo.thoughtrecipe.summarize_funcs
#   /recipe euclo.thoughtrecipe.polish_docstring

Read the receipts after each dispatch:

Chapter 7 lab — the planning paradigms

Fri, 23 Oct 2026 21:29:27 +0000

# Chapter 7 lab — the planning paradigms

Three recipes covering planner, rewoo, and blackboard, plus the captured governance catch.

# Files

plan_repair.erpe — planner: plan → verify → summarize, no steps (the plan document is the product; modeled on the shipped plan.erpe).
rewoo_outline.erpe — rewoo: required plan + synthesize, no steps.
board_survey.erpe — blackboard: two authored sources (read [state.x] lanes, mandatory write), no do legs — the data-flow skeleton form.

# Reproduce

relurplint --check recipes --workspace .   # 0 diagnostics (first pass)
# restart relurpish, pin, dispatch:
#   /recipe euclo.thoughtrecipe.plan_repair

# Captured: governance catches a malformed tool call

The pinned plan_repair dispatch on the verification machine:

Chapter 8 lab — prompts

Fri, 23 Oct 2026 22:55:09 +0000

# Chapter 8 lab — prompts

The edited react system prompt and the chapter’s captured evidence.

# Files

agent.react.default.prompt — the workspace copy exactly as it reads at chapter end: shipped content plus one added guidance line (Before editing any file, read it in full.), lint green.

# Reproduce

relurplint --check prompts --workspace .   # 0 diagnostics
# restart relurpish so the registry reloads, then run any react turn and read:

jq -c 'select(.resourceLogs) | .resourceLogs[]?.scopeLogs[]?.logRecords[]?
       | select(.eventName=="prompt.resolved")' \
    .relurpify_state/telemetry/otlp/*.jsonl | tail -1

The resolution receipt’s shape (captured): the prompt ID rides in the task.id attribute, with cache_hit (false on first resolution after a fresh boot), blocks_included, duration_ms, and paradigm.

Chapter 9 lab — the metronome

Fri, 23 Oct 2026 23:10:42 +0000

# Chapter 9 lab — the metronome

The stringkit regression suite and the captured run that proves the harness works — in the negative.

# Files

euclo.stringkit.testsuite.yaml — the Chapter 2 slugify turn as an agenttest case (final form, with the earned excludes and the fixed assertion).

# Reproduce

# from the relurpify repository root (dev-agent built from ./tooling/dev-agent-cli)
dev-agent agenttest run \
  --suite /path/to/euclo.stringkit.testsuite.yaml \
  --workspace /path/to/relurpify \
  --out /path/to/output-dir

Requires Ollama serving gemma4:e4b (record profile). Replay requires a recorded tape.

Chapter 10 lab — house style

Fri, 23 Oct 2026 23:26:35 +0000

# Chapter 10 lab — house style

The live prompts with the chapter’s edits, the drafting recipe, and the wiring finding.

# Files

agent.react.default.prompt — live system prompt: shipped + two reader lines (Ch 8’s verification line, and the read-in-full line from Ch 8’s hands-on).
agent.react.default.user.prompt — live per-turn frame: shipped + the Ch 10 house line (When a task names a test, run it and report the real result.).
draft_prompt.erpe — the drafting recipe (level 6.5: machine-drafted, human-installed). Lints green.

# Captured: the edited user prompt resolves (real telemetry)

After restart + dispatch of “Run the tests in this workspace…”:

Chapter 11 lab — out of the loop

Fri, 23 Oct 2026 23:52:07 +0000

# Chapter 11 lab — out of the loop

The final exam: a queued repair, run out-of-loop, captured complete with its wobble.

# The captured arc (verification machine, gemma4:e4b on CPU)

Time	Event
+0:00	Boot; Postures banner (governed / deterministic)
+0:18	`/queue <slugify repair>` typed; mode picker surfaced — answered `2` (`local-edit-on`)
+0:27	Approval banner; `s` granted
+0:27 → +9:53	The loop runs: reads, a governed write, test runs
Result	Diff landed: correct slugify fix (`[^\w\s]` strip + whitespace→hyphen) and the module docstring mangled again — `pytest`: `1 error` (SyntaxError)
Closing receipt	`euclo.execution.complete` → `outcome: "success"`

The book’s first lesson at out-of-loop scale: complete is a claim; your tests are the fact. The supervisor’s burden is real.

Cooking Agentic Thoughts with Relurpify on Relurpify

Chapter 1 — A Line Cook with a Work Permit

# Chapter 1 — A Line Cook with a Work Permit

Chapter 2 — One Turn, Watched Closely

# Chapter 2 — One Turn, Watched Closely

Chapter 3 — Own the Kitchen

# Chapter 3 — Own the Kitchen

Chapter 4 — Your First Thoughtrecipe

# Chapter 4 — Your First Thoughtrecipe

Chapter 5 — The Recipe Toolkit

# Chapter 5 — The Recipe Toolkit

Chapter 6 — Line Cooks: The Linear Paradigms

# Chapter 6 — Line Cooks: The Linear Paradigms

Chapter 7 — Chefs and the Kitchen Board: Planning Paradigms

# Chapter 7 — Chefs and the Kitchen Board: Planning Paradigms

Chapter 8 — The Prompt DSL

# Chapter 8 — The Prompt DSL

Chapter 9 — Prompt Engineering, with a Metronome

# Chapter 9 — Prompt Engineering, with a Metronome

Chapter 10 — Rewriting the House Style

# Chapter 10 — Rewriting the House Style

Chapter 11 — Out of the Loop, Not Out of Mind

# Chapter 11 — Out of the Loop, Not Out of Mind

Labs — *Cooking Agentic Thoughts with Relurpify*

# Labs — Cooking Agentic Thoughts with Relurpify

# Layout

# Prerequisites

# The verifier

Chapter 2 lab — captured receipts and the command card

# Chapter 2 lab — captured receipts and the command card

Chapter 3 lab — workspace baseline

# Chapter 3 lab — workspace baseline

# Files

# Reproduce

Chapter 3 experiment log — captured outputs

# Chapter 3 experiment log — captured outputs

# 1. First relurplint run

# 2. Tree inventory (counted)

Chapter 4 lab — explain_test

# Chapter 4 lab — explain_test

# Files

# Reproduce

Chapter 4 captures

# Chapter 4 captures

# Pin acknowledgment (real boot, 220×50 pty)

# Route selection, pinned vs unpinned (real telemetry)

Chapter 5 lab — triage and gate_demo

# Chapter 5 lab — triage and gate_demo

# Files

# Reproduce

Chapter 5 captures

# Chapter 5 captures

# Two linter catches on the way to green (real errors)

Chapter 6 lab — the linear paradigms

# Chapter 6 lab — the linear paradigms

# Files

# Reproduce

Chapter 7 lab — the planning paradigms

# Chapter 7 lab — the planning paradigms

# Files

# Reproduce

# Captured: governance catches a malformed tool call

Chapter 8 lab — prompts

# Chapter 8 lab — prompts

# Files

# Reproduce

Chapter 9 lab — the metronome

# Chapter 9 lab — the metronome

# Files

# Reproduce

Chapter 10 lab — house style

# Chapter 10 lab — house style

# Files

# Captured: the edited user prompt resolves (real telemetry)

Chapter 11 lab — out of the loop

# Chapter 11 lab — out of the loop

# The captured arc (verification machine, gemma4:e4b on CPU)

Labs — Cooking Agentic Thoughts with Relurpify