Relurpify

Chapter 1 — The Repo Is the Map

Fri, 23 Oct 2026 18:29:44 +0000

# Chapter 1 — The Repo Is the Map

Book 1 put you in the kitchen: you ran doctor, approved a diff, watched a governed turn from the operator’s chair. This book walks you into the building itself. And like any building worth entering, Relurpify comes with a blueprint — one that is unusual in one respect: the blueprint checks itself. The map of this repository is not a diagram in a document that drifts the first time someone renames a package. It is a data structure in the tree, enforced by a gate that reads the real import graph. When the map and the territory disagree, CI fails.

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 1 — The Second Seam

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

# Chapter 1 — The Second Seam

Book 1 taught you to hire a line cook with a work permit. This book hands you the forge. By the last page you will have added a new kind of worker to the framework itself — a paradigm, declared in the same language the shipped ones speak, proved at every test layer the framework runs, and shaped into a contribution you could merge. You will never look at an agent framework the same way again. That is not a promise about your feelings; it is a promise about what you will be able to read.

Getting Started

Mon, 19 Oct 2026 18:58:18 +0000

# Getting Started

Audience: new users and developers who want a working relurpish workspace. Purpose: from zero to a first completed agent turn. Prerequisites: none; this is the starting doc.

# Prerequisites

Requirement	Version / notes
Go	1.25+
Container runtime	Docker; plus gVisor `runsc` for the default `gvisor` sandbox backend (the `docker` backend needs Docker alone)
Model backend	Ollama (default, endpoint `http://localhost:11434`), LM Studio (`http://localhost:1234`), any OpenAI-compatible endpoint, or the built-in `offline` scripted model
OS	Linux or macOS (amd64 / arm64)
git	Recommended in the workspace; the diff and verify tooling works best on a clean repository

# 1. Build

From the repository root:

Chapter 2 — The Constitution, Enforced

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

# Chapter 2 — The Constitution, Enforced

Every sufficiently old codebase has a constitution: the set of rules everyone claims to follow and no tool enforces. It lives in a CONTRIBUTING file, it is enforced by code review and good intentions, and it loses one clause per quarter to “just this once.” Chapter 1 showed you that Relurpify’s map cannot drift silently. This chapter shows the same is true of its law: seven architecture decision records, each with a mechanism that makes it non-optional — and, because the maintainers know fences can rot, a gate that watches the fences themselves.

Chapter 2 — Speak Model

Fri, 23 Oct 2026 18:00:40 +0000

# Chapter 2 — Speak Model

Last chapter ended with a leak. Asked to explain a function, the model answered in prose that looked like a tool call — {"thought":…,"action":"file_list","tool":"file_list",…} — and the runtime closed the run having done nothing. Four seconds, twenty-nine tokens, no work.

Here is the builder’s translation of that failure: the runtime never reads the model’s mind. It consumes a structured decision, and the decision was not structured. The seam between “what the model said” and “what the agent can act on” is a Go interface, it has six normative rules about streaming, and this chapter puts you on the implementing side of it. By the end you will have written a model — a scripted, deterministic, table-driven fake — that satisfies the same contract the Ollama transport satisfies, and every remaining chapter of this book will drive the critic through it.

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 — The Surfaces, Graded

Fri, 23 Oct 2026 18:30:27 +0000

# Chapter 3 — The Surfaces, Graded

Chapter 1 gave you the map; Chapter 2 gave you the law. This chapter inventories what the tree offers — every surface a caller can touch — and, more interestingly, how the project grades its own promises about them. The handoff corpus labels each claim high, medium, or low, where high means “declared in a named type, a flag/command definition, or a normative doc” (devdocs/HANDOFF-docs/API_SURFACES.md:7-9). The stability column runs from stable through semi-stable and internal down to the grade no other project prints: the Go package API is explicitly not stable (devdocs/HANDOFF-docs/API_SURFACES.md:32).

Chapter 3 — The Lay of the Layering

Fri, 23 Oct 2026 18:02:23 +0000

# Chapter 3 — The Lay of the Layering

Every mature codebase has architecture rules. Most keep them in a diagram, and the diagram rots the first time someone merges against it. Relurpify keeps its rules in programs that run in CI and fail loudly — and in this chapter you learn to read them, break one on purpose, and feel how fast the law answers. By the end, make lint-arch stops being a ritual and becomes what it is: the fastest code review you will ever get.

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.

The Relurpish Guide

Mon, 19 Oct 2026 18:58:18 +0000

# The Relurpish Guide

Audience: anyone driving the Euclo coding agent from the terminal. Purpose: daily use of the relurpish TUI — the screen, the commands, approvals, and recipes. Prerequisites: a working workspace; see Getting started .

# Starting and stopping

relurpish chat --workspace .

Flag	Meaning
`--workspace <dir>`	Workspace root (default: current directory)
`--hitl-mode governed\|permissive`	Who answers approval requests (default: `governed`)
`--sandbox-backend gvisor\|docker`	Sandbox execution backend (default: `gvisor`)
`--offline`	Shorthand for `--inference-provider offline`
`--inference-provider <name>`	`ollama`, `lmstudio`, `offline`
`--inference-model <name>`	Backend default model; the workspace config governs agent turns
`--inference-endpoint <url>`	Provider endpoint (Ollama default: `http://localhost:11434`)

Quit with ctrl+c.

Chapter 4 — Configuration and the One Boundary

Fri, 23 Oct 2026 18:30:27 +0000

# Chapter 4 — Configuration and the One Boundary

Most codebases do not have a configuration boundary; they have configuration weather — environment reads scattered through packages, each shaping behavior slightly differently under shells, CI, and services. ADR-001’s context line records that exact past (docs/ARCHITECTURE.md:237-238), and its decision is correspondingly absolute: one package reads the environment, once, at boot, and hands resolved objects to everyone else.

Chapter 4 — Your First Graph

Fri, 23 Oct 2026 18:24:02 +0000

# Chapter 4 — Your First Graph

You own a model now — a scripted one that always says what it means. But a model alone is not an agent; it is a component. In this framework, an agent is a graph: typed nodes, wired by edges, executed as a deterministic state machine while a single envelope threads through. This chapter you build one with your own hands — implement the node interface before you meet the shipped nodes, build, seal, execute, break the wiring on purpose, and read your first preflight report.

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 5 — Nodes That Govern Themselves

Fri, 23 Oct 2026 18:37:41 +0000

# Chapter 5 — Nodes That Govern Themselves

Last chapter you built a machine that runs. This chapter you build one that can be trusted — because its nodes carry their own government with them. In most frameworks, safety is a wrapper: a middleware that inspects your component from the outside and hopes it understands what it sees. Relurpify types governance into the node itself. A node does not merely do something; it declares what it will do, how often it may be done, where it prefers to run, and what recovery owes it — and the graph validates those declarations before a single node executes.

Chapter 5 — The Governance Engine

Fri, 23 Oct 2026 18:30:55 +0000

# Chapter 5 — The Governance Engine

Chapters 3 and 4 covered what the runtime offers and how it is fed. This chapter covers the part that says no. Eleven packages under governance/ form one engine: they classify what a capability claims, derive how dangerous it is, evaluate policy over a vocabulary the rest of the tree cannot touch, escalate to a human when the answer is “ask,” write every decision into a tamper-evident chain, and refuse egress that cannot be proven public. What the engine never does is act: it decides, and other subsystems execute — a division the Chapter 1 DAG enforces by forbidding governance from ever importing execution.

The Recipe DSL (thoughtrecipes)

Mon, 19 Oct 2026 18:58:18 +0000

# The Recipe DSL (thoughtrecipes)

Audience: authors of agent workflows. Purpose: the complete syntax and semantics of .erpe recipe files. Prerequisites: a workspace with relurpify_cfg/euclo/ (Getting started ); tool-name resolution is described in Configuration .

# What a recipe is

A recipe is a single declarative file describing one agentic workflow: how it is triggered, what tool vocabulary its steps may use, which paradigms execute, which capabilities are invoked, and how state flows between steps via capture.

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 6 — Parallel Boards and Retrieved Context

Fri, 23 Oct 2026 18:53:54 +0000

# Chapter 6 — Parallel Boards and Retrieved Context

Two critics are better than one — if they are independent, if their verdicts reach you without overwriting each other, and if you can say exactly which critic said what. That is a concurrency problem with a governance flavor, and the graph runtime has an opinion about how it should go: branches run against immutable snapshots of the graph and clones of the envelope, and their changes merge in edge-declaration order, with conflicts recorded rather than rejected. This chapter you build the ensemble, wire the retrieval and streaming seams, and — the milestone — run the whole thing as a program. Part II ends with a working, hand-composed critic pipeline in Go that you can execute from a shell.

Chapter 6 — Sandbox and Governed Execution

Fri, 23 Oct 2026 18:30:55 +0000

# Chapter 6 — Sandbox and Governed Execution

Chapter 5’s engine said yes to one tool call. This chapter follows that call all the way down — through admission, policy, approval, and into a container with no network — and then all the way back up, where the result is classified before the model is allowed to see it. That last clause is the chapter’s thesis: in this runtime, permission decides what the agent may do, and a separate, monotone decision decides what the agent may see. ADR-004 (“all execution is sandboxed”) and ADR-003 (fail closed) meet in the middle of a single tool call.

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 7 — Contracts Are the DSL

Fri, 23 Oct 2026 20:37:38 +0000

# Chapter 7 — Contracts Are the DSL

Your pipeline runs from a shell. Now comes the question that separates a program from a paradigm: can a recipe say so? By the end of Part III, agent fixer uses critic will load, lint, and run — and the foundation is laid here, in a struct. In this framework the recipe grammar for your paradigm is not a parser you write; it is data you declare. The loader reads it, the linter replays it, and the contract’s own unit test polices it. The DSL is a registry lookup away.

Chapter 7 — The Knowledge Substrate

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

# Chapter 7 — The Knowledge Substrate

Everything a governed turn learns has to live somewhere, and Chapters 5 and 6 left a trail of it: observations, tool results, file reads, all classified and audited. This chapter opens the world that trail lands in — the knowledge substrate under context/knowledge/ — because Chapter 8’s bi-directional compiler is nothing more (and nothing less) than this world’s reader and writer. Before you can understand compilation, you need to know what is being compiled: the chunk, its sixteen kinds of edges, the Badger-backed store that keeps adjacency in RAM, the AST index that lets an agent navigate code without loading it, and the working memory that holds a turn’s mutable state.

The Prompt DSL

Mon, 19 Oct 2026 18:58:18 +0000

# The Prompt DSL

Audience: prompt authors and recipe authors who bind prompts. Purpose: the .prompt file format, the registry, and how the runtime resolves prompts. Prerequisites: Configuration for where prompts live; RECIPE_DSL for import prompt.

# What a prompt file is

A .prompt file is a unit of model-facing text owned by the prompt layer, not by agent code: front matter (identity, tags, variable declarations) plus a markdown body. System and user prompts live in prompt files; Go code must not embed them.

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 8 — The Critic Agent

Fri, 23 Oct 2026 20:46:59 +0000

# Chapter 8 — The Critic Agent

Last chapter the contract promised an agent. This chapter you write it — and you write it the way the framework’s authors write paradigms: against the runtime surface, with the governance bar stated in the type system, the phases structured as prompts, and every claim pinned by a test driven by the fake model you built in Chapter 2. When this chapter is done, cognitionzoo/critic contains a complete paradigm: contract, agent, and prompt file. What it will not yet have is a runtime that hands it work — that is the Chapter 9 wiring, and knowing exactly what is missing is part of this chapter’s lesson.

Chapter 8 — Compilation and Grounding: the BKC

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

# Chapter 8 — Compilation and Grounding: the BKC

Chapter 7 built the world; this chapter is its compiler — in both directions. The read path turns a query and a chunk graph into a deterministically compiled, digest-fingerprinted context artifact. The write path turns what a governed turn learned back into chunks, at a barrier designed so the two directions can never race. Invalidation joins them — staleness flows from the write side backward into the read side’s cache — and a stream trigger delivers compiled context to the model mid-turn, not just at its start. Together: the bi-directional knowledge compiler, the BKC.

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 9 — Address It From the DSL

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

# Chapter 9 — Address It From the DSL

Everything exists; nothing is addressable. paradigm.Registry carries the critic’s contract, the agent runs under governance, the prompt file validates — and agent fixer uses critic still fails at load with unsupported agent paradigm in any runtime that has not linked the package. This chapter closes that gap: four small edits that teach the framework to believe, the goldens that pin the grammar, the linter that replays the loader, and the payoff — a recipe, loaded and run against stringkit, with the telemetry receipts to prove which route the runtime took. Part III ends here: critic is a DSL-addressable paradigm.

Chapter 9 — Runtime, Sessions, and the Sidecar

Fri, 23 Oct 2026 20:38:34 +0000

# Chapter 9 — Runtime, Sessions, and the Sidecar

Everything so far happened inside one process: the governed turn, the compiler, the substrate. This chapter pulls the camera back to the runtime’s shape — who opens a workspace session, what a thoughtrecipe becomes on its way to a graph, and why the durable work of knowledge maintenance belongs to a second process that communicates with the first through files and nothing else.

Configuration

Mon, 19 Oct 2026 18:58:18 +0000

# Configuration

Audience: users and framework developers who configure a workspace. Purpose: the complete relurpify_cfg/ reference: every file, its keys, and the validation rules. Prerequisites: Getting started ; environment variables live there, not here.

# Where configuration lives

All workspace configuration lives in relurpify_cfg/ at the workspace root. The tree is generated from an embedded template bundle; doctor materializes it once on an empty workspace and never overwrites your edits (--fix is the explicit overwrite). Treat the tree like source code: it is what the runtime loads and relurplint validates.

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 10 — Test It Like the Framework Does

Fri, 23 Oct 2026 22:27:58 +0000

# Chapter 10 — Test It Like the Framework Does

Your paradigm has three proofs so far: thirty-eight unit tests (the fake model’s domain), a golden triple (the DSL’s domain), and one live TUI run (the operator’s domain). This chapter adds the framework’s own test layer — agenttest — where behavior is asserted from the outside: real runs, real receipts, structured assertions in three tiers. You will write the critic’s suite, watch three subsystems fight over your prompt’s wording, meet the ratchet that guards the committed catalog, and learn where the tape seam is honest about its own limits. By the end you will know what the framework considers proof at this layer — and what it refuses to certify.

Chapter 10 — Telemetry as the Nervous System

Fri, 23 Oct 2026 20:45:11 +0000

# Chapter 10 — Telemetry as the Nervous System

Every chapter of Part II left a trace. Chapter 5 decided and audited; Chapter 6 admitted and executed; Chapter 7 stored; Chapter 8 compiled and grounded; Chapter 9 drained a spool. This chapter is where all of those traces converge — because in this runtime they converge by design, into one output leg: an OpenTelemetry export that turns the runtime’s internal event vocabulary into the three OTel signals, writes them as local OTLP-JSON segments, forwards them to a collector when one is configured, and projects every record through a privacy boundary before it leaves the process.

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.

Chapter 11 — Passing the Gates

Fri, 23 Oct 2026 22:45:38 +0000

# Chapter 11 — Passing the Gates

Everything you have built — the package, the contract, the agent, the wiring, the suite — now faces the gauntlet: the same gates every contributor’s PR runs. This chapter is the gauntlet as curriculum. You will run each gate, meet the failures your contribution causes, and fix every one at the cause — never at the gate. Three of the failures you meet are the best teachers in the book: one catches a real integration gap in your agent, one teaches how the framework keeps its configuration honest, and one hands you the coverage philosophy in a single output line. When the last gate goes green, the contribution is real in the only currency this repository trades in.

Chapter 11 — The Test Estate

Fri, 23 Oct 2026 21:02:00 +0000

# Chapter 11 — The Test Estate

Everything Chapters 5–10 taught you about the runtime — decisions, sandbox, substrate, compiler, sidecar, telemetry — is held in place by a test estate with three layers and a vocabulary of its own. This chapter tours the estate as a working system, then goes deep on its centerpiece: agenttest, the automated benchmark-testing suite for Euclo — how a suite is written, how the runner executes it, and how the Outcome-Security-Benchmark (OSB) assertion model grades what a run did.

Architecture

Tue, 13 Oct 2026 04:19:16 +0000

# Architecture

Audience: framework developers and contributors who need to reason about the whole system. Purpose: the system shape, the rules that hold it together, and what happens during boot and a turn. Prerequisites: the glossary ; Getting started for a running workspace.

# System overview

Relurpify is a modular monolith: one Go module that compiles to a small set of local binaries. There are no microservices and no network broker; nothing listens on a socket in the default flow. The app process and a background runner process cooperate through an atomic file spool.

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 12 — Meet a Real Model

Fri, 23 Oct 2026 23:13:06 +0000

# Chapter 12 — Meet a Real Model

Every proof so far rode a metronome: the fake model, the scripted conformance queues, the offline backend. The metronome taught you the framework’s shape — but a paradigm is only honest about real models after it has met one. This chapter hands the clock over. You will run the critic against the live gemma4:e4b, watch it refuse to rubber-stamp a weak draft, watch the recipe path degrade a verdict format and recover honestly, and classify what you saw in the framework’s own flake vocabulary. One chapter from now, the book hands you the PR.

Chapter 12 — Your First PR

Fri, 23 Oct 2026 21:16:08 +0000

# Chapter 12 — Your First PR

Eleven chapters of map, law, offers, and machinery — and now the door. This chapter walks the merge path end to end: the ground rules (DCO, commit style, the charter), the gates as writing discipline rather than review obstacles, the pull-request checklist annotated by the chapters that taught each line, the release path that turns main into artifacts, and finally the pathway map — the per-subsystem answer to “where does a first PR plausibly land?” — with the worked example the book has been walking toward since Chapter 1: the dangling context/knowledge/grounding.go:680 reference, fixed here as a complete, real walkthrough. Branch, diff, sign-off, gates, PR body — captured in a scratch clone at the pin.

Labs — Agent Construction with Relurpify

Fri, 23 Oct 2026 18:24:47 +0000

# Labs — Agent Construction 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

stringkit/ — the demo repo, reset for book 2 (D11): slugify strips punctuation, both tests pass, and no seeded failure is carried over from book 1. The critic you build in this book reads and critiques code against this library; chapters that need a broken state seed their own.
testdata/overlay/ — from Chapter 2 on, one folder per chapter (ch02-fake-model/, …, ch13-final/) holding the files the reader has added or changed by that chapter’s end, at true repo-root-relative paths. The folder is named testdata/ on purpose: the Go toolchain (and the repository’s own AST gates) ignore testdata directories, so the lab source of truth never pollutes gate scans; verify.sh copies the overlay into place. Chapter 1 has no overlay: its baseline is the unmodified repository.
transcripts/ — captured output from real runs: ch01-baseline.md holds the build, vet, make lint-arch, doctor, and turn transcripts quoted in Chapter 1; ch02-critic-package.md and ch03-gate-failures.md hold the Chapters 2–3 captures.
verify.sh — the tiered verifier. See below.

# Where the book’s Go code lives (D13)

Every file the book writes is self-contained in one sub-package, cognitionzoo/critic/ — the critic agent and everything that supports it. The overlay mirrors that path; nothing else in the repository is modified except the one registration import in Chapter 9, which is the act of declaring a paradigm. Two sequencing rules the repository’s own consumer gate forces, and the book obeys from the first line:

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.

Lab — ch01-repo-map

Fri, 23 Oct 2026 17:20:04 +0000

# Lab — ch01-repo-map

Chapter: Relurpic Internals — Inside Look, Chapter 1 (“The Repo Is the Map”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: the chapter’s verification transcript, not a code artifact. Run the command card below in a clean clone at the pin and diff your deterministic outputs against transcript.txt. Nothing in this lab needs a model backend.

Testing

Tue, 13 Oct 2026 04:34:10 +0000

# Testing

Audience: contributors writing or running tests. Purpose: the three test layers, how to run each, and the supporting fixture systems (tapes, goldens, conformance). Prerequisites: Contributing↗ for gates and the coverage floor; a model backend for live layers.

# The three layers

Layer	What it exercises	Needs a model?	Entry point
Unit	One package, colocated `*_test.go`	no	`make test-unit`
Framework integration	Cross-seam behavior over real runtime state	no	`make test-integ`, `make test-scenario`
Agent end-to-end (agenttest)	The real agent against a real or replayed model	live: yes; replay: no	`dev-agent agenttest run`

make test-unit also runs the config lint and is offline-friendly with a 60-second budget. Integration tests live in testsuite/ and cover the authorization, capability, knowledge, manifest, network-boundary, and telemetry seams plus a security/redteam directory; shared builders construct workspaces, documents, policies, and envelopes.

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:

Lab — ch02-constitution

Fri, 23 Oct 2026 17:30:16 +0000

# Lab — ch02-constitution

Chapter: Relurpic Internals — Inside Look, Chapter 2 (“The Constitution, Enforced”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: the chapter’s verification transcript. You break ADR-001 (one environment boundary) with a one-line diff, watch two independent fence layers catch you, and revert. Run in a clean checkout; every step is reversible. No model backend needed.

Chapter 1 — baseline transcripts (captured)

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

# Chapter 1 — baseline transcripts (captured)

Every block below is real output from a real run on the verification machine: Linux 6.18, Go 1.27.3, Ollama 0.40.8 serving gemma4:e4b, Docker 29.9.2, runsc release-20260406.0, Python 3.14.8, pytest 9.1.1. The tree the binaries were built from reports service.version v0.0.0-20261020195847-1bc57c620296+dirty in its own telemetry. Scratch paths are normalized to ~/code/stringkit in the chapter; elisions are marked.

Chapter 2 — critic package transcripts (captured)

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

# Chapter 2 — critic package transcripts (captured)

Real output from the verification machine (same environment as ch01-baseline.md). The package under test is cognitionzoo/critic/, applied into a scratch clone by verify.sh build ch02.

# 1. First layout, first lesson: the consumer gate

The chapter’s first draft of the package was two production files (fake_model.go, fake_model_test.go) with no importer anywhere in the tree. make lint-arch in the scratch clone:

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.

Lab — ch03-surfaces

Fri, 23 Oct 2026 17:48:14 +0000

# Lab — ch03-surfaces

Chapter: Relurpic Internals — Inside Look, Chapter 3 (“The Surfaces, Graded”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: the verify-five-claims worksheet. Five high promises from the compatibility table (devdocs/HANDOFF-docs/API_SURFACES.md §9.1), each traced to its declaration site, with the captured evidence in transcript.txt — plus the one grading correction the chapter found. No model backend needed.

Code of Conduct

Tue, 13 Oct 2026 04:34:50 +0000

# Code of Conduct

Audience: everyone who interacts with the project. Purpose: the standards for participation and how enforcement works. Prerequisites: none.

# Our standard

Members of the project community are expected to behave professionally and respectfully.

Examples of behavior that contributes to a positive environment:

Using welcoming and inclusive language.
Being respectful of differing viewpoints and experiences.
Gracefully accepting constructive criticism.
Focusing on what is best for the community.
Showing empathy toward other community members.

Examples of unacceptable behavior:

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 3 — gate-failure transcripts (captured)

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

# Chapter 3 — gate-failure transcripts (captured)

Real output from the verification machine, produced in a scratch clone with the Chapter 2 overlay applied. Every violation below was planted, captured, and reverted (git checkout restores the file; make lint-arch ends green). The violations live only in this transcript.

# Beat 1 — env access in a `_test.go` file: the gate does not look

An os.Getenv("CRITIC_FALLBACK") planted in the critic package’s fake_model_impl_test.go — envcheck still passes, and its file count does not move:

Lab — ch04-config

Fri, 23 Oct 2026 17:57:05 +0000

# Lab — ch04-config

Chapter: Relurpic Internals — Inside Look, Chapter 4 (“Configuration and the One Boundary”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: the regenerate + drift transcript. You run the drift loop in both directions — edit the template bundle (the source of truth), then hand-edit the generated tree — and watch check-config-tree-drift fail both, pass after regeneration, and pass again after the full revert. Everything dirties tracked files and is reverted in-checkout; git status is clean at the end. No model backend needed.

Chapter 4 — graph tour transcripts (captured)

Fri, 23 Oct 2026 18:24:47 +0000

# Chapter 4 — graph tour transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 4 overlay (ch04-first-graph) adds cognitionzoo/critic/graph_tour_test.go — six tests covering build, seal, conditions, the visit cap, validation, and preflight — on top of the Chapter 2–3 package.

# Full critic package test run (ch02+ch03+ch04 overlays)

$ go test ./cognitionzoo/critic/... -count=1 -v
--- PASS: TestEnvelopeTour (0.00s)
--- PASS: TestFakeModelIsALanguageModel (0.00s)
--- PASS: TestGenerateStreamEmitsScriptedChunksInOrder (0.00s)
--- PASS: TestGenerateReturnsJoinedText (0.00s)
--- PASS: TestChatWithToolsReturnsScriptedToolCalls (0.00s)
--- PASS: TestTurnsCycleInOrder (0.00s)
--- PASS: TestGenerateStreamClosesOnCancellation (0.03s)
--- PASS: TestGenerateStreamDropsAndCountsOnSendContention (0.03s)
--- PASS: TestErrorInjectionFailsEveryMethod (0.00s)
--- PASS: TestEmptyScriptFailsCleanly (0.00s)
--- PASS: TestFirstGraphRuns (0.00s)
--- PASS: TestConditionalEdgesRoutes (0.00s)
--- PASS: TestGraphSealsOnExecute (0.00s)
--- PASS: TestVisitCapCatchesCycle (0.00s)
--- PASS: TestValidationCatchesBrokenWiring (0.00s)
--- PASS: TestPreflightGatesToolPlacement (0.00s)
PASS
ok  	codeburg.org/lexbit/relurpify/cognitionzoo/critic	0.059s

The six Chapter 4 tests, and what each asserts:

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.

Lab — ch05-governance

Fri, 23 Oct 2026 18:15:55 +0000

# Lab — ch05-governance

Chapter: Relurpic Internals — Inside Look, Chapter 5 (“The Governance Engine”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: the governed-turn + decision/audit transcript. A real governed turn runs through the product runtime (offline backend — no model backend or sandbox needed), followed by the full governance package suite. No code artifacts; the decision and audit shapes are recorded as the serialized JSON they use. The test harness doubles two enforcement seams (sandbox command runner, HITL approval) so the decisions are deterministic — Chapter 4 §4.4 and Chapter 5 §5.6 explain the cut.

Search

Mon, 01 Jan 0001 00:00:00 +0000

Type to search the full documentation index. Results are ranked by title and content matches.

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 — critic graph transcripts (captured)

Fri, 23 Oct 2026 18:36:27 +0000

# Chapter 5 — critic graph transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 5 overlay (ch05-critic-graph) adds cognitionzoo/critic/critic_graph_test.go — the critic pipeline as a hand-composed graph, plus contract-default and contract-validation tests — on top of the Chapter 2–4 package.

# Full critic package test run (ch02–ch05 overlays)

$ go test ./cognitionzoo/critic/... -count=1 -v        (20 tests)
--- PASS: TestCriticPipelineRevisesWhenFlagged (0.00s)
--- PASS: TestCriticPipelineDenialSkipsRevision (0.00s)
--- PASS: TestContractDefaultsAreTyped (0.00s)
--- PASS: TestContractValidationRefusesGarbage
    --- PASS: …/invalid_side_effect_class (0.00s)
    --- PASS: …/tool_node_must_declare_capabilities (0.00s)
--- PASS: TestEnvelopeTour
--- PASS: (…the nine Chapter 2 fake-model tests…)
--- PASS: (…the six Chapter 4 graph-tour tests…)
PASS
ok  	codeburg.org/lexbit/relurpify/cognitionzoo/critic	0.059s

The four Chapter 4→5 additions, and what each asserts:

Lab — ch06-sandbox

Fri, 23 Oct 2026 18:25:03 +0000

# Lab — ch06-sandbox

Chapter: Relurpic Internals — Inside Look, Chapter 6 (“Sandbox and Governed Execution”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: the tool-call journey, verified at both ends: the doctor’s readiness rows on a real machine (sandbox toolchain interrogated, degraded semantics live), the governed turn through the product path, and the enforcement machinery green. No model backend needed; Docker and runsc are welcome but their absence is itself a valid capture (degraded rows, never unsandboxed fallback).

Chapter 6 — ensemble & runner transcripts (captured)

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

# Chapter 6 — ensemble & runner transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 6 overlay (ch06-ensemble-runner) adds the package’s first production code — cognitionzoo/critic/ensemble.go and cognitionzoo/critic/cmd/critic-runner/main.go — plus ensemble_test.go.

# The critic-runner, offline end to end

$ go run ./cognitionzoo/critic/cmd/critic-runner
telemetry graph_start          node=
telemetry node_start           node=drafter
telemetry node_finish          node=drafter success=true
telemetry graph_start          node=
telemetry node_start           node=critic-2
telemetry graph_start          node=
telemetry graph_start          node=
telemetry node_finish          node=critic-2 success=true
telemetry node_start           node=branch-done-2
telemetry node_finish          node=branch-done-2 success=true
telemetry graph_finish         node= status=success
telemetry node_start           node=critic-0
telemetry node_finish           node=critic-0 success=true
telemetry node_start           node=branch-done-0
telemetry node_finish          node=branch-done-0 success=true
telemetry graph_finish         node= status=success
telemetry node_start           node=critic-1
telemetry node_finish          node=critic-1 success=true
telemetry node_start           node=branch-done-1
telemetry node_finish          node=branch-done-1 success=true
telemetry graph_finish         node= status=success
telemetry graph.branch_merged  node= branches=[critic-0 critic-1 critic-2] conflicted_keys=[] keys_deleted=0 keys_skipped=0 keys_written=6 refs_retrieval=0 refs_streamed=0 units_applied=3 winner_index=map[]
telemetry node_start           node=merge
telemetry node_finish          node=merge success=true
telemetry node_start           node=gate
telemetry node_finish          node=gate success=true
telemetry node_start           node=revise
telemetry node_finish          node=revise success=true
telemetry graph_start          node=
telemetry node_start           node=critic-2
…  [second re-review round: the three critics' second scripted turns,
    another graph.branch_merged, merge, gate — then done; elided]
telemetry graph_finish         node= status=success

result:     success=true node=done
ensemble:   size=3 verdict=clean
revisions:  1
final draft: a revised draft with error handling
preflight:  0 issues, 0 placements

Read the transcript: the nested graph_start events are the three parallel branches (each branch runs against its own structural snapshot and cloned envelope); graph.branch_merged reports the merge in edge declaration order (branches=[critic-0 critic-1 critic-2], units_applied=3, no conflicts, six keys written — three verdicts per round); the revise node fired once and the re-review passed clean.

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.

Lab — ch07-substrate

Fri, 23 Oct 2026 18:36:33 +0000

# Lab — ch07-substrate

Chapter: Relurpic Internals — Inside Look, Chapter 7 (“The Knowledge Substrate”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: index a seeded workspace and inspect the chunk graph — via the substrate’s own tests, which build real stores, index real files, and emit real events. No model backend, no sandbox, no manual workspace setup: every fixture is seeded and cleaned by the tests themselves.

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 — critic contract transcripts (captured)

Fri, 23 Oct 2026 20:36:30 +0000

# Chapter 7 — critic contract transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 7 overlay (ch07-critic-contract) adds the critic’s paradigm contract as production code (cognitionzoo/critic/contract.go, self-registering from init) plus its tests (contract_test.go).

# Package tests (ch02–ch07 overlays)

$ go test ./cognitionzoo/critic/... -count=1 -v        (30 tests)
--- PASS: TestCriticContractRegistered (0.00s)
--- PASS: TestContractCompleteness (0.00s)
--- PASS: TestRegistrationValidatesIntrinsics
    --- PASS: …/unknown_shape (0.00s)
    --- PASS: …/duplicate_directive (0.00s)
    --- PASS: …/requires_undeclared_directive (0.00s)
    --- PASS: …/order_rule_references_undeclared_directive (0.00s)
    --- PASS: …/case_pins_undeclared_directive (0.00s)
    --- PASS: …/declared_directive_without_a_case (0.00s)
    --- PASS: …/duplicate_registration (0.00s)
--- PASS: (…the twenty-three Chapter 2–6 tests…)
PASS
ok  	codeburg.org/lexbit/relurpify/cognitionzoo/critic	0.061s

TestCriticContractRegistered — the process-wide registry holds a critic contract: ShapeReviewLoop, Composes [react], directives exactly [critique revise] in declaration order, revise a predicate block requiring critique, an order rule present, no required directives (goal-only recipes preserved).
TestContractCompleteness — the mirror of every shipped paradigm’s own completeness test: every declared directive pinned by a conformance case, no case pinning an undeclared directive, and react (the Composes entry) resolved in the fully-populated registry.
TestRegistrationValidatesIntrinsics — a scoped registry driven through the seven intrinsic refusals, each captured verbatim from the validator: unknown execution shape "Whirlpool"; duplicate directive "critique"; directive "revise" requires undeclared directive "approve"; order rule references undeclared directive "polish"; conformance case "lab/ghost" pins undeclared directive "polish"; directive "revise" has no conformance case; and duplicate paradigm contract registration for "critic-lab".

# The registry now carries nine paradigms

The critic package’s init registers the contract in any binary that links it — including the runner:

Lab — ch08-bkc

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

# Lab — ch08-bkc

Chapter: Relurpic Internals — Inside Look, Chapter 8 (“Compilation and Grounding: the BKC”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: compile a context, verify the digest contract by replay, exercise the epoch-scoped cache, ground captures with trust floors, and confirm the stream-trigger delivery — via the compiler’s own tests, which run real stores and real digests. No model backend, no sandbox.

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 — critic agent transcripts (captured)

Fri, 23 Oct 2026 20:45:47 +0000

# Chapter 8 — critic agent transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 8 overlay (ch08-critic-agent) adds cognitionzoo/critic/critic.go (the agent), the workspace prompt file relurpify_cfg/prompts/agents/agent.critic.default.prompt, and cognitionzoo/critic/critic_agent_test.go.

# Package tests (ch02–ch08 overlays)

$ go test ./cognitionzoo/critic/... -count=1 -v        (32 tests)
--- PASS: TestCriticFailsClosedWithoutPermissionChecker (0.00s)
--- PASS: TestCritiqueWritesScratch (0.00s)
--- PASS: TestReviseFiresOnPredicateAndRecritiques (0.00s)
--- PASS: TestRevisionCapEndsLoopNormally (0.00s)
--- PASS: TestLibraryModeReportsWithoutRevision (0.00s)
--- PASS: TestCriticPromptFileLoadsAndValidates (0.00s)
--- PASS: (…the twenty-six Chapter 2–7 tests…)
PASS
ok  	codeburg.org/lexbit/relurpify/cognitionzoo/critic	0.061s

The six new tests, and what each pins:

Lab — ch09-runtime

Fri, 23 Oct 2026 20:38:53 +0000

# Lab — ch09-runtime

Chapter: Relurpic Internals — Inside Look, Chapter 9 (“Runtime, Sessions, and the Sidecar”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: queue a job, watch the runner drain it — with the sidecar built from source, since no release has ever carried it (decision D10). The runner self-submits a scheduled knowledge.refresh job via the spool, claims it, executes it, and completes it; the e2e suite then puts the whole jobs contract on record. No model backend, no sandbox.

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 — registration & DSL transcripts (captured)

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

# Chapter 9 — registration & DSL transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 9 overlay (ch09-registration) carries the registration wiring — modified copies of four repository files at their true paths, plus the recipe and golden fixtures — applied into a scratch clone; the main repository is never modified.

Lab — ch10-telemetry

Fri, 23 Oct 2026 20:45:32 +0000

# Lab — ch10-telemetry

Chapter: Relurpic Internals — Inside Look, Chapter 10 (“Telemetry as the Nervous System”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: reconstruct a run from telemetry alone. Boot a runtime in a scratch workspace with one script-safe command, then read the run back out of its OTLP-JSON segment with jq — event names, attribute keys, the projection boundary working. Plus the turn leg (AC-3) and the forwarding story (boxed). No model backend, no sandbox.

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 — agenttest transcripts (captured)

Fri, 23 Oct 2026 22:27:08 +0000

# Chapter 10 — agenttest transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts; live Ollama serving gemma4:e4b). The Chapter 10 overlay (ch10-agenttest) adds testsuite/agenttests/euclo.critic.testsuite.yaml and the suite-count ratchet bump in testsuite/agenttest/osb_coverage_test.go (24 → 26: +1 for this book’s suite, +1 for book 1’s euclo.stringkit.osb, committed alongside).

# 1. The green run

$ ./dev-agent agenttest run --suite testsuite/agenttests/euclo.critic.testsuite.yaml
euclo.critic.testsuite.yaml [record]: 2/2 passed (0 infra, 0 assertion)

Run 20261023-222227.638, per-case receipts from report.json:

Lab — ch11-test-estate

Fri, 23 Oct 2026 21:01:41 +0000

# Lab — ch11-test-estate

Chapter: Relurpic Internals — Inside Look, Chapter 11 (“The Test Estate”). Pin: tag BETA-RC1-FALL2026; captured at commit 1bc57c62029641dcc919c04a8076593794246409 while the tag is pending.

What this lab is: author one suite exercising all three OSB assertion kinds against the stringkit fixture, run it live, follow the tape lifecycle as far as the pin allows — and verify the replay half against the committed corpus. This is the book’s first model-dependent lab: Ollama serving gemma4:e4b (the Book 1 setup) is required for step 2.

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 — gates transcripts (captured)

Fri, 23 Oct 2026 22:44:47 +0000

# Chapter 11 — gates transcripts (captured)

Real output from the verification machine (same environment as the earlier transcripts). The Chapter 11 overlay (ch11-gates) adds: the critic’s conformance runners + fixtures (testsuite/conformance/), the regenerated paradigm_matrix.yaml, the streamed-context matrix entry, the legacy paradigm parity vectors (named/euclo/surface/paradigm_test.go), the coverage override for the runner main (tooling/coverage/overrides.yaml), and the two embedded-template sources (the recipe and the prompt — ADR-002). It also carries the D-2 fix to the agent itself (cognitionzoo/critic/critic.go — the critique phase now renders the compiled slice, mirroring reflection).

drop dangling design-doc reference in grounding comment

Fri, 23 Oct 2026 21:15:32 +0000

# drop dangling design-doc reference in grounding comment

What: drop a dangling design-doc reference from the CaptureKindForOrigin comment (3 lines, comment-only).

Why: the referenced plan doc (devdocs/plans/bkc-bidirectional-context-and-hermetic-dryrun-spec.md) no longer exists in the tree; repointing at devdocs/ would dangle for every public reader, since devdocs/ is not part of the clone. The sentence stands without the pointer.

Gates run: go build ./context/...; go test ./context/knowledge; make envcheck (1087 files scanned, PASS).

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.

Chapter 12 — live-model transcripts (captured)

Fri, 23 Oct 2026 23:12:18 +0000

# Chapter 12 — live-model transcripts (captured)

Real output from the verification machine: live Ollama 0.40.8 serving gemma4:e4b, Linux, the full ch02–ch12 overlay in a fresh scratch clone. The Chapter 12 overlay (ch12-live) adds the build-tagged live test (cognitionzoo/critic/live_critique_test.go, //go:build live) and the agenttest harness fix (testsuite/agenttest/execution.go fork: a permissive permission checker in the harness Deps, so governed-paradigm recipe runs are not refused before they start).