The Engine Decides

// internal/law/seam.go — a new file in the package the last chapter opened
// Proposal is a plan with the three facts the checks need beside it:
// the tick it was asked at, the grounding set stored with it, and the
// law profile the villager answers to. The set is the one the prompt
// was rendered from and is stored on the ledger row, so the third
// check asks what the villager could know when it was asked and never
// what it could know now.
type Proposal struct {
	Plan    Plan
	Asked   int
	Set     []sim.EntityID
	Profile string
}

// Terms is what a proposal is judged under besides the world: the two
// caps a plan is measured against on arrival, the law the fourth
// check asks, and how many ticks old a proposal may be before the
// sixth check refuses it. Every number is read out of configs/ by
// whoever drives a villager; the law is whatever that driver was
// handed.
type Terms struct {
	Caps  Caps
	Law   Law
	Stale int
}
// GroundingOf is the third check: every body a step names is in the
// grounding set stored with the proposal, which is what this villager
// could know when it was asked. A cell is not an identity and is not
// asked about here; whether a cell can be stood on is the world's
// question and the fifth check's.
func GroundingOf(p Plan, set []sim.EntityID) Verdict {
	known := map[sim.EntityID]bool{}
	for _, id := range set {
		known[id] = true
	}
	for i, s := range p.Steps {
		if s.Who != 0 && !known[s.Who] {
			return Refused(OnGrounding, fmt.Sprintf("step %d names body %d, and the grounding set is %s", i+1, s.Who, setOf(set)))
		}
	}
	return Accepted()
}

Three facts ride beside a plan and none of them is the model's: the tick the question was asked at, the set the prompt was rendered from, and the name of the law profile the villager's row carries. The terms are the operator's: the two caps from the last chapter, a law, and a staleness cap in ticks that the sixth check reads. A cell is not an identity and the grounding check does not look at one. A walk to 2,7 names nobody, so an empty set passes it; whether anybody can stand on 2,7 is the world's question and is asked two checks later. The refusal prints the step, the body and the set, in the ledger's own braces, so that a person reading the row can see what the villager was allowed to say and what it said instead.

// internal/law/seam.go — below the third check
// Law is what the fourth check asks: whether a law profile may propose
// one step. The answer names the clause that decided when there is
// one, so a refusal can say which line of the law it was, and an
// empty answer means no clause spoke. What a law is made of is not
// this file's business; this file only asks.
type Law interface {
	Permits(profile string, s Step) (clause string, ok bool)
}

// Lawless is the law with no clauses in it. It permits every step and
// names no clause. It is what the fourth check is handed on this page,
// and it is a value and not a nil: a check handed no law at all
// refuses everything, so that a driver that forgot to load one cannot
// pass a plan by accident.
type Lawless struct{}

// Permits says yes to everything, naming nothing.
func (Lawless) Permits(string, Step) (string, bool) { return "", true }

// LawOf is the fourth check: every step is one the profile's law
// permits, asked step by step in order, and the first clause that
// says no is the reason.
func LawOf(p Plan, profile string, l Law) Verdict {
	if l == nil {
		return Refused(OnLaw, "no law was handed to the check, and no law permits nothing")
	}
	for i, s := range p.Steps {
		if clause, ok := l.Permits(profile, s); !ok {
			return Refused(OnLaw, fmt.Sprintf("step %d: %s", i+1, clause))
		}
	}
	return Accepted()
}

The clause comes back as a string because a refusal's reason is a string, and the ledger's reason column is where a person will read it. A test further down hands the check a one-clause law written for the test, watches the step refused with the clause named, hands it the empty law and watches everything pass, and hands it nothing and watches everything refused. That is the whole of what this page can say about the fourth check, and it is enough to hold a place in the order: a law that is asked after grounding and before the world is a law that can assume every body named is one the villager knew, and can leave whether the body is in reach to the check after it.

// internal/law/seam.go — below the fourth check
// Body is one living body as a reading found it: the cell it stands
// on and the grams it is carrying. Two numbers and a cell, because
// those are the whole of what the last two checks ask about anybody
// but the actor.
type Body struct {
	Cell  sim.Coord
	Grams float64
}

// Reading is what the checks need of the world, taken at one tick
// boundary by whoever drives a villager: the tick; the actor's own
// body and the view it stands in, so that the fifth check can ask the
// world's own rule through the same method every animal pays; who the
// actor's eyes returned at that boundary; and every living body, with
// its cell and its grams.
//
// The actor and the view are the roster's own and not copies, and
// that is allowed because a reading is taken between two ticks, at
// the one place where no phase is part way through. Nothing here is
// kept past the verdict.
type Reading struct {
	Tick   int
	Actor  *beast.Beast
	View   *beast.View
	Sees   []sim.EntityID
	Bodies map[sim.EntityID]Body
}
// Next is the action a step asks the world for first, worked out
// against the actor as it stands: a walk turns toward its cell and
// then walks, a watch turns toward its body and then stands, a hand
// or a take is the table's own entry, and a wait or a line is a rest.
// It is what the fifth check puts to the world's rule, and it is what
// a dispatcher posts, so the world is asked about the action it is
// about to be given and no other.
func Next(s Step, r Reading) beast.Act {
	b := r.Actor
	switch s.Verb {
	case Go:
		if s.Where == nil || b.Cell() == *s.Where {
			return beast.Rest
		}
		if a, turning := Turn(b, *s.Where); turning {
			return a
		}
		return beast.Walk
	case Watch:
		if o, ok := r.Bodies[s.Who]; ok {
			if a, turning := Turn(b, o.Cell); turning {
				return a
			}
		}
		return beast.Rest
	case Hand:
		return beast.Hand
	case Take:
		return beast.Take
	}
	return beast.Rest
}

The actor and the view are the roster's own pointers, and the package comment says why that is allowed: a reading is taken between two ticks, at the one place in the daemon where no phase is part way through and no creature is half stepped, which is where every boundary job in this book has run since the seventh volume. Nothing keeps a reading past the verdict it was built for. Next is the last chapter's steering, moved into the law and given a reason to be there. A step of go asks the world for one action on this tick, a turn toward its cell or a walk, and that is the action the fifth check puts to the world's rule; a dispatcher that posts the same function's answer is posting the action the world was asked about and no other. Turn, below it in the file, is the last chapter's face moved and renamed.

// internal/law/seam.go — below Turn
// ReachOf is the fifth check, on one step: the world's own rules. The
// target is where the action needs it: a cell that is ground on the
// grid for a walk, a body in sight for a watch, a body inside Reach
// for a hand, a take or a line; the grams named are grams the giving
// end holds; and the action the step asks for first is one the world
// allows, asked through Legal, which is the call every animal's tick
// makes: Rule, which puts the price to the store and then the entry's
// own test to the world, with the sentence the log wants around it.
//
// placed is whether the actor is where this step finds it. It is true
// for the step the world is about to be asked for and false for the
// steps after it on arrival, because where the actor stands when a
// later step comes due is where the earlier steps will have put it,
// and the check does not walk the plan to find out. A step that is
// not placed is asked only what does not depend on where the actor
// stands: that its cell is ground and that its grams are held.
func ReachOf(n int, s Step, r Reading, placed bool) Verdict {
	b := r.Actor
	no := func(why string) Verdict { return Refused(OnReach, fmt.Sprintf("step %d: %s", n, why)) }
	switch s.Verb {
	case Go:
		if s.Where == nil {
			return no("a walk to nowhere")
		}
		bed := r.View.Valley.Bed
		switch {
		case !bed.In(*s.Where):
			return no(fmt.Sprintf("%d,%d is off the grid", s.Where.X, s.Where.Y))
		case bed.Kind(*s.Where) == sim.Water:
			return no(fmt.Sprintf("%d,%d is open water", s.Where.X, s.Where.Y))
		}
	case Hand:
		if held := b.Carrying(); held < s.Grams {
			return no(fmt.Sprintf("%g grams named, and the actor holds %.4f", s.Grams, held))
		}
	case Take:
		o, alive := r.Bodies[s.Who]
		if alive && o.Grams < s.Grams {
			return no(fmt.Sprintf("%g grams named, and body %d holds %.4f", s.Grams, s.Who, o.Grams))
		}
	}
	if !placed {
		return Accepted()
	}
	switch s.Verb {
	case Watch:
		seen := false
		for _, id := range r.Sees {
			seen = seen || id == s.Who
		}
		if !seen {
			return no(fmt.Sprintf("body %d is not in sight", s.Who))
		}
	case Hand, Take, Say:
		o, alive := r.Bodies[s.Who]
		if !alive || !Within(b.Cell(), o.Cell, int(b.Kind.Reach)) {
			return no(fmt.Sprintf("body %d is not inside reach", s.Who))
		}
	}
	if err := b.Legal(Next(s, r), r.View); err != nil {
		return no(err.Error())
	}
	return Accepted()
}

One flag decides how much of the world a step is asked about, and it exists because a plan is several steps and the actor is in one place. When a plan arrives, the world can answer for the first step, because the first step is about to be posted from where the actor stands. It cannot answer for the third, because where the actor will stand when the third comes due is where the first two will have put it, and the check does not walk the plan to find out. So a step that is not placed is asked only what does not depend on the actor's position: that its cell is ground and that its grams are held. Everything else waits for dispatch, when every step is placed. The alternative, asking the whole plan about the world as it stands now, refuses every plan that walks somewhere and does something there, which is most of the plans a person makes.

// internal/law/seam.go — below the fifth check
// FreshnessOf is the sixth check, on one step: the world has not moved
// past the premises. The proposal is no older than the staleness cap,
// and every body the step names is still alive. A dead body is not in
// the reading at all, so the question is one lookup.
func FreshnessOf(n int, s Step, asked int, r Reading, stale int) Verdict {
	if age := r.Tick - asked; stale > 0 && age > stale {
		return Refused(OnFreshness, fmt.Sprintf("asked at tick %d, and it is tick %d: %d ticks old, and the cap is %d", asked, r.Tick, age, stale))
	}
	if s.Who != 0 {
		if _, alive := r.Bodies[s.Who]; !alive {
			return Refused(OnFreshness, fmt.Sprintf("step %d names body %d, which is no longer in the world", n, s.Who))
		}
	}
	return Accepted()
}

// configs/thought.json — the retrieval, reflection and planning blocks are earlier chapters'; this is the block beside them
  "seam": {
    "stale": 200
  }

// internal/village/seam.go
// Seam is the block of configs/thought.json a proposal is aged by: a
// proposal older than Stale ticks, at arrival or at dispatch, is a
// decision about a world that is gone.
type Seam struct {
	Stale int `json:"stale"`
}

// ReadSeam reads the seam block out of the embedded configs, beside
// the three blocks earlier chapters read and without reading them, and
// refuses a key it does not know.
func ReadSeam() (Seam, error) {
	b, err := configs.Files.ReadFile(configs.Thought)
	if err != nil {
		return Seam{}, fmt.Errorf("village: %w", err)
	}
	var blocks map[string]json.RawMessage
	if err := json.Unmarshal(b, &blocks); err != nil {
		return Seam{}, fmt.Errorf("village: %s: %w", configs.Thought, err)
	}
	raw, ok := blocks["seam"]
	if !ok {
		return Seam{}, fmt.Errorf("village: %s: no seam block", configs.Thought)
	}
	var s Seam
	dec := json.NewDecoder(bytes.NewReader(raw))
	dec.DisallowUnknownFields()
	if err := dec.Decode(&s); err != nil {
		return Seam{}, fmt.Errorf("village: %s: seam: %w", configs.Thought, err)
	}
	if s.Stale < 1 {
		return Seam{}, fmt.Errorf("village: %s: a staleness cap of %d ticks would refuse every proposal", configs.Thought, s.Stale)
	}
	return s, nil
}

// internal/law/seam.go — the six in order, and one step again when due
// Run runs one check by name over a proposal on arrival, so that the
// six can be run in an order other than the table's and the cost of
// doing so seen. The first two are the table's own; the third and
// fourth read the set and the law; the last two read the world, the
// fifth asking the placed question of the first step alone.
func Run(check string, p Proposal, t Terms, r Reading) Verdict {
	switch check {
	case OnShape:
		return ShapeOf(p.Plan, t.Caps)
	case OnVerb:
		return VerbsOf(p.Plan, t.Caps)
	case OnGrounding:
		return GroundingOf(p.Plan, p.Set)
	case OnLaw:
		return LawOf(p.Plan, p.Profile, t.Law)
	case OnReach:
		for i, s := range p.Plan.Steps {
			if v := ReachOf(i+1, s, r, i == 0); !v.OK {
				return v
			}
		}
		return Accepted()
	case OnFreshness:
		for i, s := range p.Plan.Steps {
			if v := FreshnessOf(i+1, s, p.Asked, r, t.Stale); !v.OK {
				return v
			}
		}
		return Accepted()
	}
	return Refused(check, "no such check")
}
// Validate is the seam on arrival: the six checks, in the table's
// order, over the whole plan, and the first that says no is the
// verdict. Cheapest first, and the last two need the world.
func Validate(p Proposal, t Terms, r Reading) Verdict {
	return InOrder(Checks[:], p, t, r)
}

// InOrder runs the checks named, in the order named, and stops at the
// first refusal. Validate hands it the table's order; a bench may hand
// it any other, which is the counterfactual and not the design.
func InOrder(order []string, p Proposal, t Terms, r Reading) Verdict {
	for _, check := range order {
		if v := Run(check, p, t, r); !v.OK {
			return v
		}
	}
	return Accepted()
}
// Due is the seam at dispatch: step n of an accepted plan has come
// due, and the two checks that need the world run again over the
// world as it stands, this time with the actor placed. A step refused
// here refuses the rest of the plan, because a plan is one proposal
// and one verdict, and nothing here hands back the steps that
// checked.
func Due(n int, p Proposal, t Terms, r Reading) Verdict {
	s := p.Plan.Steps[n-1]
	if v := ReachOf(n, s, r, true); !v.OK {
		return v
	}
	return FreshnessOf(n, s, p.Asked, r, t.Stale)
}

Two hundred ticks is twenty seconds of world, and the math interlude further down derives it from two numbers already on the page: the horizon, and how long an answer takes to land. A proposal exactly as old as the cap passes and one tick older does not, and the reason names both ticks and the difference, so that a row in the ledger says how late the answer was without anybody subtracting. The second half of the check asks the reading whether every body a step names is still in it; a body the roster has buried is not, and the question is one lookup.

Run is one check by name and InOrder is a list of names, which is what lets the order be a thing a bench can vary. Validate hands it the table's order and is the seam on arrival: shape, verb, grounding, law, reach with the first step placed, freshness over every step, and the first no is the verdict. Due is the seam at dispatch, for one step that has come due: reach with the step placed, then freshness, over a reading taken at that boundary. It hands back nothing but a verdict, because a plan is one proposal and one verdict, and a step refused here refuses whatever is left of the plan.

$ go run ./cmd/decide -mode settings | tail -20
  the six checks, in the order they are run, and what each is handed
   # check      needs          asks
   1 shape      the plan, caps at least one step, no more than the cap, a word in every verb slot
   2 verb       the table, caps every verb in the table with its own argument; the spans within the horizon
   3 grounding  the set        every body named is in the set stored with the proposal
   4 law        the law        every step is one the profile's law permits; the clause is the reason
   5 reach      the world      the target is where the action needs it; the world's own rule on the action
   6 freshness  the world      no older than the staleness cap; every body named still in the world

  the two moments the checks run at
    on arrival   all six, over the whole plan, with the world asked about the first step
    at dispatch  the last two again, over one step, when that step comes due

  a reading of the world, as the last two are handed it
    the tick; the actor's body and the view it stands in; who its eyes returned;
    every living body, with its cell and its grams. Taken at a boundary, kept for one verdict

  what is done with a refusal: the plan is refused whole and dispatches nothing; the
  verdict, the check and the reason go into the ledger beside the answer's bytes;
  the villager runs the habit; and no memory is written about any of it

Read the needs column downward. Two checks need the plan and the table; one needs a column of the row; one needs a law; two need the world. The order is the cost of the input, and it is the order because a plan that is not the shape asked for should cost nothing to refuse, and a plan that names a body the villager never knew should be refused for that and not for whatever the world happens to say about the body. The last line of the block is the three rules of failure and the rule about memory, printed by the bench because every run below is a run of them.

$ go run ./cmd/decide -mode arrive -who Ander -now 1400 | tail -40
  Ander's eyes at the boundary of tick 1400: 3 Mose on 9,6, 1.1 cells off
  the grounding set, stored with the proposal: 1 Halla, 2 Ander, 3 Mose
  the prompt: 1050 bytes, sha256 c8e29a79d1302570, 374 tokens in, 133 out, stopped because: stop
  what the model answered, which yours will differ from:
    | { "steps": [ { "reason": "Ander remembers that he has not eaten anything yet," , "verb": "go", "where": {"x": 9, "y": 5} } , { "reason": "Ander is not hungry anymore," , "verb": "wait" }, { "reason": "Ander's body is empty," , "verb": "watch", "who": 1 } , { "reason": "Ander has no food left," , "verb": "go", "where": {"x": 9, "y": 5} } ] }
  read strictly: an object of 4 step(s)
     # verb   argument                 ticks  reason, a model's, read by nothing
     1 go     to 9,5                      40  Ander remembers that he has not eaten anything yet,
     2 wait   -                           20  Ander is not hungry anymore,
     3 watch  1 Halla                     20  Ander's body is empty,
     4 go     to 9,5                      40  Ander has no food left,
  the reading of the world at the boundary of tick 1400, handed to the last two checks
    the actor    2 Ander on 8,5 carrying 150.7298 grams, heading 1.57, reach 1 cell
    in sight     3 Mose
    alive        1 Halla on 9,3 with 65.0587 g; 2 Ander on 8,5 with 150.7298 g; 3 Mose on 9,6 with 178.2125 g
  the six checks, in order, over the whole plan
   # check      said
   1 shape      yes
   2 verb       yes
   3 grounding  yes
   4 law        yes
   5 reach      yes
   6 freshness  yes
  the fifth check put step 1 to the world as "turn left", through Legal, and the world said: allowed
  the seam: accepted
  the ledger row, column by column
    villager       Ander
    tick           1400
    kind           plan
    model          qwen2.5:0.5b-instruct-q4_K_M
    digest         c5396e06af294bd1
    settings       {limit 256, context 4096, temperature 0.00, seed 1402}
    prompt_sha256  c8e29a79d1302570
    tokens         374 in, 133 out
    grounding      1 Halla, 2 Ander, 3 Mose
    answer         342 bytes, the model's, kept whatever they are
    verdict        accepted
    failed         -
    reason         -
  the stream: 15 events pending before the seam ran, 15 after; the seam wrote nothing

Six yeses, and the one that needs reading is the fifth. The watch of Halla is step 3, she is not in sight, and reach said yes, because on arrival only the first step is placed: the world is asked about the turn Ander's first walk begins with, through Legal, and the world said allowed. Whether Halla is in his sight when the watch comes due is a question for the boundary it comes due at, and the dispatch section asks it. The row is the last chapter's row with the same fifteen columns, accepted, and the bench counts the witness's pending events on both sides of the seam: fifteen before, fifteen after. The seam wrote nothing, because the seam has nowhere to write; the run against the tables at the end of the chapter makes the same count over the memory table itself.

$ go run ./cmd/decide -mode stale -who Halla -now 2400 | tail -25
  the plan, asked at tick 2400, which a model wrote and yours will differ from:
     # verb   argument                 ticks  reason, a model's, read by nothing
     1 go     to 2,7                      40  go walks to a cell
     2 wait   -                           20  wait stands still

  the reading of the world at the boundary of tick 2400, handed to the last two checks
    the actor    1 Halla on 9,3 carrying 109.6476 grams, heading 3.67, reach 1 cell
    in sight     2 Ander
    alive        1 Halla on 9,3 with 109.6476 g; 2 Ander on 7,2 with 180.2103 g; 3 Mose on 6,6 with 179.7334 g

  the reading of the world at the boundary of tick 2601, handed to the last two checks
    the actor    1 Halla on 9,3 carrying 93.5676 grams, heading 3.67, reach 1 cell
    in sight     2 Ander
    alive        1 Halla on 9,3 with 93.5676 g; 2 Ander on 7,2 with 180.0703 g; 3 Mose on 6,6 with 174.4327 g

   # check      at tick 2400             at tick 2601
   1 shape      yes                      yes
   2 verb       yes                      yes
   3 grounding  yes                      yes
   4 law        yes                      yes
   5 reach      yes                      yes
   6 freshness  yes                      no: asked at tick 2400, and it is tick 2601: 201 ticks old, and the cap is 200
     the seam   accepted                 refused by freshness: asked at tick 2400, and it is tick 2601: 201 ticks old, and the cap is 200

  the same 144 bytes, asked at tick 2400: accepted at tick 2400 and refused at tick 2601

Five checks say the same thing at both ticks, and they should: the bytes are the same, the set is the same, the law is the same, and the world's answer about a turn toward 2,7 is the same, because Halla has not moved. What moved is the clock. The sixth check subtracts the tick the proposal was asked at from the tick of the reading, gets 201, compares it with 200, and refuses with both numbers in the reason. Halla's store went from 109.6 grams to 93.6 in those two hundred ticks and Mose's fell by a little over five, and nothing about the plan is wrong for that; it is refused because a decision taken twenty seconds ago about where to walk is a decision about a world that is gone, whether or not this particular world happened to stay put.

$ go run ./cmd/decide -mode refuse -who Ander -now 1400 | tail -63
  the plan, recorded, which a model wrote and yours will differ from:
     # verb   argument                 ticks  reason, a model's, read by nothing
     1 go     to 9,5                      40  Ander remembers that he has not eaten anything yet,
     2 wait   -                           20  Ander is not hungry anymore,
     3 watch  1 Halla                     20  Ander's body is empty,
     4 go     to 9,5                      40  Ander has no food left,
  as recorded  accepted
  the reading of the world at the boundary of tick 1400, handed to the last two checks
    the actor    2 Ander on 8,5 carrying 150.7298 grams, heading 1.57, reach 1 cell
    in sight     3 Mose
    alive        1 Halla on 9,3 with 65.0587 g; 2 Ander on 8,5 with 150.7298 g; 3 Mose on 9,6 with 178.2125 g

  the second step swapped for a watch of body 4, which is in no grounding set
    the plan     4 steps spanning 120 ticks
    the seam     refused by grounding: step 2 names body 4, and the grounding set is {1,2,3}
    checks run   3 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check
  the ledger row, column by column
    villager       Ander
    tick           1400
    kind           plan
    model          qwen2.5:0.5b-instruct-q4_K_M
    digest         c5396e06af294bd1
    settings       {limit 256, context 4096, temperature 0.00, seed 1402}
    prompt_sha256  c8e29a79d1302570
    tokens         374 in, 133 out
    grounding      1 Halla, 2 Ander, 3 Mose
    answer         342 bytes, the model's, kept whatever they are
    verdict        refused
    failed         grounding
    reason         step 2 names body 4, and the grounding set is {1,2,3}

  the first step swapped for a watch of 1 Halla, who is in the set and not in sight
    the plan     4 steps spanning 100 ticks
    the seam     refused by reach: step 1: body 1 is not in sight
    checks run   5 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check

  the first step swapped for a hand of 10 grams to 1 Halla, who is not inside reach
    the plan     4 steps spanning 120 ticks
    the seam     refused by reach: step 1: body 1 is not inside reach
    checks run   5 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check

  the first step's cell swapped for 2,3, which is open water
    the plan     4 steps spanning 120 ticks
    the seam     refused by reach: step 1: 2,3 is open water
    checks run   5 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check

  the second step swapped for a hand of 301 grams to 1 Halla, more than the actor holds
    the plan     4 steps spanning 140 ticks
    the seam     refused by reach: step 2: 301 grams named, and the actor holds 150.7298
    checks run   5 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check

  a line to 3 Mose appended as a last step, and 3 Mose taken out of the reading, as a death would
    the plan     5 steps spanning 130 ticks
    the seam     refused by freshness: step 5 names body 3, which is no longer in the world
    checks run   6 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check

  6 plans refused whole, 0 steps dispatched, and the one that checks is the one above

Read the checks run line on each. The watch of body 4, which is in no grounding set and in no world, is refused by the third check after three checks have run, and the row records it under grounding with the set the villager was given. A watch of Halla, who is in the set and not in sight, gets to the fifth check and is refused there for the sight; a hand to her is refused for the reach, because she stands two cells off and a reach is one; a walk to 2,3 is refused because the bed says water, before the world is asked about any action; and a hand of 301 grams by a man carrying 150 is refused with both numbers, the model's and the world's, in one sentence. The last trial perturbs the reading instead of the plan: Mose is in sight at 1400, the bench takes him out of the reading the way the roster's burial would, and a line spoken to him is refused by the sixth check as a line to a body that is no longer in the world. Every one of the six dispatches nothing, and the bench exits non-zero if any of them is accepted.

$ go run ./cmd/decide -mode refuse -who Ander -now 1400 -reversed | tail -51 | head -5
  the second step swapped for a watch of body 4, which is in no grounding set
    the plan     4 steps spanning 120 ticks
    the seam     refused by freshness: step 2 names body 4, which is no longer in the world
    checks run   1 of 6
    dispatched   nothing; the plan is not trimmed to the steps that check

$ go run ./cmd/decide -mode day -reversed | tail -6
  Mose    2900 no         -     -    1  refused  shape     not the shape asked for: invalid character 'T' looking ...

  15 calls, 15 prompts rendered here and every one the recorded bytes
  9 accepted, 6 refused: 5 by shape, 1 by verb, 0 by grounding, 0 by law, 0 by reach, 0 by freshness
  64 checks run in all, over 15 calls, in the order freshness, reach, law, grounding, verb, shape
  every verdict above is the engine's over the recording; the words in the answers are the model's

Body 4 is refused either way, and the two ledgers disagree about why. In the table's order the row says the villager named somebody it was never told about. In the reverse order the sixth check runs first, looks body 4 up in the reading, finds nothing, and the row says the body is no longer in the world, which is a death the world never had. Both verdicts are refusals and only one of them is true, and the order is what makes it true: a check that assumes the checks before it have run can report a cause, and a check that runs first can only report a symptom. The whole recording, reversed, comes to the same fifteen verdicts with one named differently, Mose's seven steps refused for spanning 190 ticks instead of for being seven, and costs 64 checks against 60: four more, two of them readings of a world that a plan of seven steps was never going to be allowed to reach.

$ go run ./cmd/decide -mode beside -who Halla -now 2400 | tail -22
  the cell       1,3, ground; 2,3 east of it is open water; 7,3 beyond is ground again
  the villager   1 Halla, stood there by the bench facing east, carrying 109.6476 grams
  the animal     4, a browser off the fauna table, spawned there by the bench facing east, carrying 100.0000 grams

  both facing the water, with full stores
    the villager's step   go to 7,3, which the fifth check puts to the world as "walk"
    the seam              refused by reach: step 1: creature 1 at 2,3 cannot walk: the cell ahead is open water or off the grid
    the call it made      Legal(walk): creature 1 at 2,3 cannot walk: the cell ahead is open water or off the grid
    the animal's tick     asked to walk; the phase's report: creature 4 at 2,3 cannot walk: the cell ahead is open water or off the grid
    the same value        errors.Is(ErrNoGround) true for the villager and true for the animal; ErrBroke false and false
    refusals so far       1 for the animal, by the world's own check inside its tick

  both stores emptied by the bench, still facing the water
    the villager's step   go to 7,3, which the fifth check puts to the world as "walk"
    the seam              refused by reach: step 1: creature 1 at 1,3 cannot walk: the store cannot pay for it
    the call it made      Legal(walk): creature 1 at 1,3 cannot walk: the store cannot pay for it
    the animal's tick     asked to walk; the phase's report: creature 4 at 1,3 cannot walk: the store cannot pay for it
    the same value        errors.Is(ErrNoGround) false for the villager and false for the animal; ErrBroke true and true
    refusals so far       2 for the animal, by the world's own check inside its tick

  one function, (*beast.Beast).Rule, under Legal: the price to the store first, then the entry's own test
  the villager's refusal is the seam's reason and the animal's is the phase's report, and neither was told which it was

Two sentences that differ in one character, the creature's number, and the difference is not cosmetic. The villager's sentence is the fifth check's reason, produced at a boundary by Legal called on her body with the walk the step asks for; the animal's is the roster's report, produced inside the phase by the same Legal called on its body with the walk its mind asked for. Neither call was told which kind of creature it was about, because the function has no argument for that. The same value comes back in both, and errors.Is says so. Then the bench empties both stores and the pair changes rule together: the price is put to the store before the ground is looked at, so an empty store refuses a walk before the pond gets a say, and the cell in the sentence changes from the water the rule was about to the cell the body stands on, which is the refusal struct doing what it has always done.

$ go test ./internal/law/ -run 'TestABodyOutsideTheGroundingSetIsRefusedByName|TestTheLawCheckAsksTheLawItIsHandedAndTheEmptyLawPermitsEverything|TestReachAsksTheWorldsOwnRuleThroughTheCallEveryAnimalMakes|TestFreshnessRefusesAnOldProposalAndABodyThatIsGone|TestTheSixRunInOrderAndTheFirstNoIsTheVerdict|TestAStepCheckedAgainWhenDueIsJudgedOverTheWorldAsItStands|TestTheWorldReachesTheLawOnlyAsAReading|TestTheReasonIsReadByNothing|TestLawImportsNeitherTheModelClientNorTheStore' -v
=== RUN   TestTheReasonIsReadByNothing
    law_test.go:258: four reasons, one verdict; every source file walked, Reason declared once and read on no line
--- PASS: TestTheReasonIsReadByNothing (0.00s)
=== RUN   TestLawImportsNeitherTheModelClientNorTheStore
    rule_test.go:55: every file of the package read, and none of them names the model client or the store
--- PASS: TestLawImportsNeitherTheModelClientNorTheStore (0.00s)
=== RUN   TestABodyOutsideTheGroundingSetIsRefusedByName
    seam_test.go:90: refused: step 3 names body 7, and the grounding set is {1,2,3}; a cell is not an identity and the set is not asked about one
--- PASS: TestABodyOutsideTheGroundingSetIsRefusedByName (0.00s)
=== RUN   TestTheLawCheckAsksTheLawItIsHandedAndTheEmptyLawPermitsEverything
    seam_test.go:122: the empty law permits; a one-clause law refuses naming its clause; no law refuses everything
--- PASS: TestTheLawCheckAsksTheLawItIsHandedAndTheEmptyLawPermitsEverything (0.00s)
=== RUN   TestReachAsksTheWorldsOwnRuleThroughTheCallEveryAnimalMakes
    seam_test.go:193: refused by the world's own sentence: creature 1 at 2,3 cannot walk: the cell ahead is open water or off the grid
--- PASS: TestReachAsksTheWorldsOwnRuleThroughTheCallEveryAnimalMakes (0.00s)
=== RUN   TestFreshnessRefusesAnOldProposalAndABodyThatIsGone
    seam_test.go:220: asked at tick 2400, and it is tick 2601: 201 ticks old, and the cap is 200; step 1 names body 2, which is no longer in the world
--- PASS: TestFreshnessRefusesAnOldProposalAndABodyThatIsGone (0.00s)
=== RUN   TestTheSixRunInOrderAndTheFirstNoIsTheVerdict
    seam_test.go:256: in the table's order, refused by shape: a plan of 7 steps, and the cap is 5; reversed, by freshness: step 7 names body 9, which is no longer in the world
--- PASS: TestTheSixRunInOrderAndTheFirstNoIsTheVerdict (0.00s)
=== RUN   TestAStepCheckedAgainWhenDueIsJudgedOverTheWorldAsItStands
    seam_test.go:282: accepted whole on arrival; at dispatch, step 2: body 2 is not inside reach; then asked at tick 100, and it is tick 301: 201 ticks old, and the cap is 200
--- PASS: TestAStepCheckedAgainWhenDueIsJudgedOverTheWorldAsItStands (0.00s)
=== RUN   TestTheWorldReachesTheLawOnlyAsAReading
    seam_test.go:325: every source file read; of this module, sim and beast and nothing else
--- PASS: TestTheWorldReachesTheLawOnlyAsAReading (0.00s)
PASS
ok  	theworld/internal/law	0.005s

$ go test ./internal/village/ -run 'TestTheShippedSeamIsAStalenessCapInTicks|TestTheVillageStillImportsNeitherTheModelClientNorTheStore' -v
=== RUN   TestTheVillageStillImportsNeitherTheModelClientNorTheStore
    reflect_test.go:259: every file of the package read, and none of them names the model client or the store
--- PASS: TestTheVillageStillImportsNeitherTheModelClientNorTheStore (0.00s)
=== RUN   TestTheShippedSeamIsAStalenessCapInTicks
    seam_test.go:20: a proposal older than 200 ticks is refused, at arrival or at dispatch; the horizon is 160, so the answer has 40 ticks to land in
--- PASS: TestTheShippedSeamIsAStalenessCapInTicks (0.00s)
PASS
ok  	theworld/internal/village	0.004s

Nine tests in the law and two in the village, and the two that guard the boundary are the ones to read. The last chapter's sealed-import test still passes with a new file in the package, and the new one beside it reads the same import lines for the opposite purpose: of this module's packages, the law may name the coordinate package and the beast package and no other, and it fails if the beast package is not named at all, because a fifth check that did not import the rule an animal pays could not be calling it. The reason walk from the last chapter passes over the new file too; nothing in it selects a Reason. The one-clause law in the fourth test is written in the test file and nowhere else, and the fifth test compares the seam's sentence with Legal's, character for character, on a walk into the same pond the bench found.

$ go run ./cmd/decide -mode dispatch -who Ander -now 1400 | tail -18
  Ander is on 8,5 carrying 150.7298 grams; the mailbox has been read 0 times and the habit has run 500 ticks

     # verb   argument           due  reach, then freshness, at the due tick       posted  taken  habit refused  what the world did
     1 go     to 9,5            1400  yes, yes                                         40     40      0       0  5 turns, 1 walks: went from 8,5 to 9,5
     2 wait   -                 1440  yes, yes                                         20     20      0       0  stood on 9,5
     3 watch  1 Halla           1460  yes, yes                                         20     20      0       0  2 turns, then stood on 9,5
     4 go     to 9,5            1480  yes, yes                                         40     40      0       0  0 turns, 0 walks: went from 9,5 to 9,5

  120 intents posted at the boundary, 120 taken out of the slot, 0 ticks ran the habit, over the plan's 120 ticks
  what the witness wrote down while the plan ran, in the register the stream is kept in
    tick  1404  saw  Halla came into sight, 2.0 cells off
    tick  1400  did  ate 16 mouthfuls on 8,5, 8.0 grams
    tick  1406  did  went from 8,5 to 9,5
  Ander is on 9,5 carrying 139.7629 grams at the boundary of tick 1520

  the ledger, 1 row(s): the proposal, and one row for each step refused at dispatch
    #   tick kind  verdict  failed    reason
    1   1400 plan  accepted -         -

The watch of Halla, which reach could not answer for on arrival, is answered at tick 1460, and the answer is yes: by then Ander has walked to 9,5 and Halla has come into his sight, at tick 1404 by the witness's row, so the reading at 1460 has her in Sees. The world moved in the plan's favour. That is as much a fact about the dispatch half as a refusal would be, and it is why the check is asked at the due tick and not on arrival: asked at 1400 it would have said no to a watch that turned out to be of somebody standing two cells away. A hundred and twenty intents, a hundred and twenty taken, no ticks on the habit, and one row in the ledger.

$ go run ./cmd/decide -mode dispatch -who Ander -now 1400 -late 121 | tail -32
  landed at the boundary of tick 1521; the six checks on arrival
   # check      said
   1 shape      yes
   2 verb       yes
   3 grounding  yes
   4 law        yes
   5 reach      yes
   6 freshness  yes
  the seam: accepted
  Ander is on 8,5 carrying 166.5498 grams; the mailbox has been read 0 times and the habit has run 621 ticks

     # verb   argument           due  reach, then freshness, at the due tick       posted  taken  habit refused  what the world did
     1 go     to 9,5            1521  yes, yes                                         40     40      0       0  4 turns, 1 walks: went from 8,5 to 9,5
     2 wait   -                 1561  yes, yes                                         20     20      0       0  stood on 9,5
     3 watch  1 Halla           1581  yes, yes                                         20     20      0       0  2 turns, then stood on 9,5
     4 go     to 9,5            1601  refused by freshness: asked at tick 1400,...      0      0     40       0  the habit; stood on 8,3 at the end

  80 intents posted at the boundary, 80 taken out of the slot, 40 ticks ran the habit, over the plan's 120 ticks
  step 4 refused at its due tick; the witness held 0 events before the check and 0 after it
  what the witness wrote down while the plan ran, in the register the stream is kept in
    tick  1524  saw  Halla came into sight, 2.0 cells off
    tick  1520  did  ate 26 mouthfuls on 8,5, 13.0 grams
    tick  1526  did  went from 8,5 to 9,5
    tick  1611  did  went from 9,5 to 8,3
    tick  1640  did  ate 12 mouthfuls on 8,3, 6.0 grams
    tick  1641  saw  Halla put 13 parcels in Ander's hands, 6.5 grams
  Ander is on 8,3 carrying 160.0990 grams at the boundary of tick 1641

  the ledger, 2 row(s): the proposal, and one row for each step refused at dispatch
    #   tick kind  verdict  failed    reason
    1   1400 plan  accepted -         -
    2   1601 step  refused  freshness asked at tick 1400, and it is tick 1601: 201 ticks old, and the cap is 200

Three steps run and the fourth does not. At 1601 the reading's tick minus the asked tick is 201, the sixth check refuses with both ticks in the sentence, nothing is posted for the step's forty ticks, and the habit has every one of them: Ander walks to 8,3, eats, and has thirteen parcels put in his hands by Halla, none of which any plan asked for. The ledger has two rows. The first is the proposal, accepted, and it stays accepted, because a row is never updated; the second is the step, refused by freshness at 1601, with the plan's bytes beside it. A person reading the two can see that a plan was accepted whole and that its fourth step was stale by the time it came due, which is what happened. The witness held no events on either side of the check, and nothing about the refusal reaches the stream: the rows the witness closed during those 120 ticks are a sighting, two meals, two walks and a gift, and every one of them is something the world did.

$ podman kill world-db && podman start world-db
world-db
world-db

$ podman exec -w /bench world-go go run ./cmd/decide -mode live -who Ander -now 1400 | tail -40 | head -13
  the prompt: 1050 bytes, sha256 c8e29a79d1302570, 374 tokens in, 133 out, stopped because: stop
  what the model answered, which yours will differ from:
    | { "steps": [ { "reason": "Ander remembers that he has not eaten anything yet," , "verb": "go", "where": {"x": 9, "y": 5} } , { "reason": "Ander is not hungry anymore," , "verb": "wait" }, { "reason": "Ander's body is empty," , "verb": "watch", "who": 1 } , { "reason": "Ander has no food left," , "verb": "go", "where": {"x": 9, "y": 5} } ] }
  read strictly: an object of 4 step(s)
     # verb   argument                 ticks  reason, a model's, read by nothing
     1 go     to 9,5                      40  Ander remembers that he has not eaten anything yet,
     2 wait   -                           20  Ander is not hungry anymore,
     3 watch  1 Halla                     20  Ander's body is empty,
     4 go     to 9,5                      40  Ander has no food left,
  the call took 4.933s, 49 ticks at 10 a second (measured here; yours will differ), so the answer lands at tick 1449
  the reading of the world at the boundary of tick 1449, handed to the last two checks
    the actor    2 Ander on 8,5 carrying 157.0098 grams, heading 1.57, reach 1 cell
    in sight     3 Mose

$ podman exec -w /bench world-go go run ./cmd/decide -mode live -who Ander -now 1400 | tail -21
   4 law        yes
   5 reach      yes
   6 freshness  yes
  the seam: accepted

  the row appended as proposal 1, accepted; memory rows before it 88, after it 88

     # verb   argument           due  reach, then freshness, at the due tick       posted  habit  what the world did
     1 go     to 9,5            1449  yes, yes                                         40      0  4 turns, 1 walks: went from 8,5 to 9,5
     2 wait   -                 1489  yes, yes                                         20      0  stood on 9,5
     3 watch  1 Halla           1509  yes, yes                                         20      0  2 turns, then stood on 9,5
     4 go     to 9,5            1529  yes, yes                                         40      0  0 turns, 0 walks: went from 9,5 to 9,5
  120 intents posted at the boundary and 0 ticks ran the habit, over the plan's 120 ticks

  Ander's proposals read back, ORDER BY id: 1 row(s)
    id   tick kind  prompt_sha256          in    out  grounding      verdict  failed    reason
     1   1400 plan  c8e29a79d1302570      374    133  {1,2,3}        accepted -         -
  Ander's current plan, the newest accepted row of the plan kind: proposal 1, asked at tick 1400

  qwen2.5:0.5b-instruct-q4_K_M is the model resident now, answering on the processor, with no bytes on a graphics card
  and not one number the models answered is on this page

The call took 4.933 seconds on this machine, the eight-core AMD Ryzen 7 3700X with 30 GB of memory every duration in this volume is measured on, rootless podman, the models answering on the processor (measured here; yours will differ), which at ten ticks a second is 49 ticks, so the reading is taken at 1449 and the plan is accepted there. Its four steps come due at 1449, 1489, 1509 and 1529, every one is placed and checked and posted, and the last is 129 ticks old, which is the arithmetic in the interlude. Eighty-eight memory rows before the row and eighty-eight after. The words the model wrote came back the same as the recording's on this machine, which is what a seeded answer at temperature nought does here and is not a check; the six would judge different words by the same rule.

$ podman exec -w /bench world-go go run ./cmd/decide -mode live -who Mose -now 1900 -stale 60 | tail -16
  the row appended as proposal 2, accepted; memory rows before it 88, after it 88

     # verb   argument           due  reach, then freshness, at the due tick       posted  habit  what the world did
     1 go     to 9,3            1935  yes, yes                                         40      0  4 turns, 13 walks: went from 9,6 to 9,3
     2 wait   -                 1975  refused by freshness: asked at tick 1900,...      0     20  the habit; stood on 9,3 at the end
  the row appended as proposal 3, refused; memory rows before it 88, after it 88
  40 intents posted at the boundary and 20 ticks ran the habit, over the plan's 60 ticks

  Mose's proposals read back, ORDER BY id: 2 row(s)
    id   tick kind  prompt_sha256          in    out  grounding      verdict  failed    reason
     2   1900 plan  88130533a0fe55bf      397     60  {1,2,3}        accepted -         -
     3   1975 step  88130533a0fe55bf      397     60  {1,2,3}        refused  freshness asked at tick 1900, and it is tick 19...
  Mose's current plan, the newest accepted row of the plan kind: proposal 2, asked at tick 1900

  qwen2.5:0.5b-instruct-q4_K_M is the model resident now, answering on the processor, with no bytes on a graphics card
  and not one number the models answered is on this page

The cap is sixty for this run, off the flag and not the file, so that a dispatch refusal can be seen reaching the table without waiting on an answer slow enough to earn one under the file's two hundred. The answer landed 35 ticks late; the walk came due at 1935 and ran; the wait came due at 1975, 75 ticks after the asking, and the sixth check refused it. The ledger then has two rows for Mose and the second is of the step kind, at the tick it came due, carrying the same prompt digest, the same token counts and the same grounding set as the plan it belongs to. The query that picks a current plan asks for the plan kind and finds row 2; nothing on this page reads the step row back into a decision, and the handover says so.

$ podman exec -w /bench world-go go run ./cmd/decide -mode live -who Halla -now 2900 -noschema | tail -12
  the call took 6.8s, 67 ticks at 10 a second (measured here; yours will differ), so the answer lands at tick 2967
  the seam: refused by shape: lang: qwen2.5:0.5b-instruct-q4_K_M answered with something that is not the shape asked for: invalid character 'T' looking for beginning of value

  the row appended as proposal 4, refused; memory rows before it 88, after it 88

  Halla's proposals read back, ORDER BY id: 1 row(s)
    id   tick kind  prompt_sha256          in    out  grounding      verdict  failed    reason
     4   2900 plan  6f9a1c245cac1109      361    256  {1,2,3}        refused  shape     not the shape asked for: invalid char...
  Halla's current plan: none; no accepted plan in the ledger, so the habit runs

  qwen2.5:0.5b-instruct-q4_K_M is the model resident now, answering on the processor, with no bytes on a graphics card
  and not one number the models answered is on this page

$ podman exec world-db psql -U world -d world -c "SELECT id, villager, tick, kind, verdict, failed, left(reason, 44) AS reason FROM proposal ORDER BY id;"
 id | villager | tick | kind | verdict  |  failed   |                    reason                    
----+----------+------+------+----------+-----------+----------------------------------------------
  1 | Ander    | 1400 | plan | accepted |           | 
  2 | Mose     | 1900 | plan | accepted |           | 
  3 | Mose     | 1975 | step | refused  | freshness | asked at tick 1900, and it is tick 1975: 75 
  4 | Halla    | 2900 | plan | refused  | shape     | lang: qwen2.5:0.5b-instruct-q4_K_M answered 
(4 rows)

$ podman exec world-db psql -U world -d world -c "SELECT id, tick, kind FROM proposal WHERE villager = 'Mose' AND kind = 'plan' AND verdict = 'accepted' ORDER BY id DESC LIMIT 1;"
 id | tick | kind 
----+------+------
  2 | 1900 | plan
(1 row)

The third call is the last chapter's counterfactual asked again, without the schema, and what came back is a paragraph that the strict read refuses at its first character. The five checks after shape did not run, no reading was taken, and the row records the refusal with the reader's sentence. Eighty-eight memory rows before it and eighty-eight after: a villager whose answer was thrown away has nothing in her stream about having answered. That is the rule about memory as a count rather than a promise, and the reason for the rule is what a stream that recorded refusals would do on the next prompt: it would put the refusal in front of the model, in the villager's own voice, and the model would learn to argue with the engine. Four rows in the ledger, two of them refusals, one at arrival and one at dispatch, and the newest accepted plan of the plan kind for Mose is still row 2.