Patterns for a New Generation: AIF and EmbeddingsDOI: 10.XXXX/XXXXXXX.XXXXXXXConference: 32nd Conference on Pattern Languages of Programs, People, and Practices; October 12–15, 2025; Skamania Lodge, Columbia River Gorge, Washington, USA.ISBN: 978-1-941652-22-0DOI: 10.64346/PLoP2025p24CCS: Software and its engineering Software creation and management Software development process management Software development methods Design patternsCCS: Computing methodologies Artificial intelligence Distributed artificial intelligence Intelligent agentsCCS: Applied computing Operations researchCCS: Computing methodologies Modeling and simulation

If you want the agent to run live — to observe, deliberate, and act on a schedule, accumulating trace and precision over real time without a human pressing the button. However a scheduler that fires ticks which cache or no-op (because nothing downstream can change) satisfies the letter of “live operation” while the organism is dead, and every firing writes a green “it ran” row that hides the inertia. Then install the scheduled entrypoint, but gate “live” on evidence that a tick changed observable state (a dial moved, a hole closed), not merely that it fired; when the loop can only no-op, disable the schedule rather than let it paint green. Because liveness is a property of state change, not of the scheduler firing — a cron over a sealed loop is a clock ticking in an empty room.

Operational witness (2026-07-14): the hourly entrypoint completed a production-shaped opportunity as a reviewed Git commit plus a Futon1b implementation/discharge, closed the cohort record as grounded-change, and queued an operator QA item. The scheduler firing alone is not counted as that witness; the external dial movement is. Current status (2026-07-31): the hourly schedule was operator-disabled the following day, after a stop-line, and no cron is installed; runs since then — including the specimen above — have been on-demand clicks. We report this rather than the more flattering present tense because the pattern’s own rule is that a schedule which cannot change anything should be switched off, and honouring that rule is not a result to be hidden. The claim this pattern supports is therefore that the loop can run unattended end to end and has, not that it is doing so today.

If an instrument issues a verdict from evidence it also produces or stages (a calibrator over its own predictions, a gate over its own outputs). However on first contact with reality every layer tries to certify itself, and each attempt looks rigorous — the forward model scores its own constants (“prior $=$ value”), the evidence reader eats its own staging files — and vigilance cannot catch these, because an instrument’s first catches are always about itself. Then require that a verdict move only on evidence its maker did not manufacture: tag every evidence record at birth with properties the apparatus cannot fake (:independent?, :measured vs :target-absent-fallback, :settled vs :transient) and count only records whose tags clear — untagged never counts. Because circularity is invisible from inside the loop (every internal reading is consistent with every other); only a referent the maker had no hand in breaks it, and structure (“the tag is absent, so it does not count”) survives where vigilance fails. Revised against the record: the rule reached one layer further than first written — :review-execution-evidence-missing, twice in the first cohort: a review is itself a verdict-producing act, and a reviewer’s claim that a review ran is exactly the kind of self-manufactured evidence the pattern bars. The landed revision corroborates review execution from the job-event stream the reviewer does not control, before any review counts.

If you want decisions to depend on tractable hypotheses (progress, blockers, pattern fit, uncertainty) rather than raw conversation history. However if the belief state is just the conversation, the agent cannot cleanly update, compare, or falsify its own assumptions. Then represent the belief state as a map of operational hypotheses

(:goal, :subgoals, :blockers, :pattern-fit, :expected-next-observation, :uncertainty)

updated each step using observation and outcomes. Because a compact belief state makes predict $\to$ observe $\to$ update implementable and testable.

If you want the agent’s observation to be comparable across steps so scoring and learning do not collapse into prose interpretation. However tool output and user feedback arrive as heterogeneous artifacts (JSON, logs, diffs, snippets, natural language) that are hard to compare or weight consistently. Then maintain an explicit observation record as a typed, normalized feature map derived from session state (test status, compile status, diff size, failing-spec count, user-stated constraints, time since last anchor, contradiction flags). Because a stable observation vector is the prerequisite for meaningful precision control and policy scoring.

If you want belief updates to be principled, tunable (one learning rate; a separate trust setting per evidence channel), and operationally robust. However without an explicit rule the agent either slams its beliefs to each new observation (over-trusts) or never moves them (over-anchors), and an uncertainty estimate with no floor under it decays toward false certainty. Then move each belief toward what was actually observed, but only as far as the learning rate and the trust placed in that channel allow; and track how uncertain the belief is by keeping a running average of the size of recent misses, measured against the freshly-updated belief, never letting that uncertainty fall below a floor. It is the size of a miss that counts, not its direction — an overshoot and an undershoot are equally informative about how well the channel is understood — and the floor is a standing admission that no channel is a perfect instrument. Because moving in proportion to trusted error is what predictive coding means, and the floor keeps uncertainty in a range where the ambiguity half of the action score still says something. Invariant to preserve: the belief must be able to move, and its uncertainty must not be able to reach zero.

If you want the agent to discount low-trust evidence without discarding it, and to become stricter when outcomes are volatile. However without an explicit precision layer, evidence weighting becomes implicit prompt rhetoric and cannot be audited. Then keep a per-channel precision registry — one trust weight per kind of evidence — keyed to observation features, and apply it wherever prediction error, scoring, or gating occurs. Because making precision explicit turns trust into a tunable control surface rather than an undocumented bias.

If you want a single number, comparable across time, that says how badly the agent’s current belief explains what it just observed — for validation, diagnostics, and alarms. However without such a per-tick number the belief evolution is opaque (nothing to plot, no acceptance criterion, no alarm), and the action score is no substitute: action scores rank imagined futures, this one scores the fit of the present. Then compute it as a pure function of belief, observation, and precision — a trust-weighted average of how badly each channel missed — and emit it in the per-tick trace beside the belief state. It sits near zero when trusted channels match expectation and rises when trusted evidence disagrees with the model. Because this mismatch is the quantity active-inference agents work to minimise; making it observable every tick gives both a clean validation target (it should fall on average as the agent learns) and an operational signal (a sudden jump merits attention). Invariant to preserve: one number per tick, computed from nothing but belief, observation, and trust — so it cannot be quietly improved by anything else.

If you want the forward model’s predictions to match what the live dynamics actually do, with one set of rules to maintain. However two implementations of the same dynamics is two places for bugs to hide and two surfaces where prediction can silently diverge from the live step. Then factor the live step into a pure deterministic kernel (state, action, seed, opts) $\to$ next-state plus a thin wrapper that threads defaults; the predictive forward model calls the same kernel and adds principled uncertainty. Because one implementation of the dynamics is the only place the rules live — any update is reflected in both live and predicted behaviour.

If you want selection to balance canonical outcome risk and ambiguity with operational constraints. However calling every useful controller term “EFE” makes tuning indistinguishable from storytelling. Then compute and persist the canonical core separately — risk, how far the outcomes an action predicts sit from the outcomes the system prefers, plus ambiguity, how uninformative those outcomes are expected to be — and admit engineering terms only as a named augmentation, reported beside that core and never folded into it. Because the decomposition makes clear whether a recommendation moved because of active-inference quantities or because of an engineering control. Invariant to preserve: the two-term core is persisted apart from everything wrapped around it, so any reader can ask which one moved the pick.

If you want pattern choice to be legible and comparable, and to avoid collapse into one habitual pattern. However if the action space is any pattern at any time, evaluation becomes unstructured and selection is dominated by recency. Then define the action set as a constructed candidate set of pattern IDs produced by retrieval plus gating rules, of bounded size, with explicit reasons for inclusion and exclusion. Because constraining the action space makes downstream scoring meaningful rather than performative.

If you want exploration versus exploitation to depend on operational pressure (deadlines, repeated failures, instability), not on randomness alone. However without an explicit dial the agent either thrashes or tunnels, and there is nothing to turn. Then maintain a commitment temperature governing how decisively the best-scoring candidate wins: turned down, the system commits to its front-runner; turned up, it keeps the field open — and couple that dial to diagnostic signals (recent regressions, uncertainty in the belief state, contradiction rate, time pressure). Because a single commitment dial allows systematic control of stochasticity without changing the scoring model at all. Invariant to preserve: exploration is a dial, not a random number generator buried in the selector.

If you want collective action selection that respects budget constraints at every hierarchy level — never recommending allocations that exceed the aggregate per-tick budget, and factoring in downstream and coordination costs. However a naive union of independent selections leaves the budget invariant unenforced (over-subscription happens silently), while a single central coordinator throws away the value of local-agent factoring. Then resolve conflicts explicitly at each hierarchy level: local agents propose within their sub-budgets, and a coordinator arbitrates the shared consumable budget across them. Because budget is a shared consumable, and enforcing the invariant at every level is the only way to keep multi-agent selection both locally factored and globally feasible. This is the resource hierarchy — how a shared per-tick budget is split across competing selections — and it is orthogonal to the temporal / abstraction hierarchy of R13 (a strategic loop choosing the task, a tactical loop rolling out the pattern-cascade that enacts it); the two compose but are not the same pattern. Current evidence: the exact arbiter, mutually exclusive ranked-field adapter, over-subscription witnesses, and opt-in live selection boundary are tested together, including exact replay. In Campaign S it selected one proposal from each live ranked field on both ticks, using all 7 units of the shared budget without exceeding it; exact replay reproduced both selections.

If a fast tactical loop acts inside a slower strategic loop. However merely giving both levels a scalar score does not create a hierarchy. Then make the coupling explicit: strategic selection fixes the tactical target; witnessed tactical outcomes update the next strategic calibration state; and longer policies use a named temporal discount of their own rather than overloading the commitment dial. Because hierarchy is a relationship between levels and timescales, not a second use of the same score. Invariant to preserve: each level has its own quantities, and no quantity does duty at two levels at once. Current evidence: the opt-in two-tick campaign records both levels separately, rejects unwitnessed learning, folds a grounded fast outcome into a Beta update of the slow state, and uses that state to parameterise the next fast rollout. Campaign S supplied the live positive branch: Tick A’s independently approved and grounded outcome advanced the relevant slow posterior from Beta(1,1) to Beta(2,1), changed the slow mode from exploration to consolidation, and parameterised Tick B under that new state. This is evidence for the explicit coupling, not for a general nested generative model.

If you want the agent to plan — to score whole pattern cascades as policies, not single steps, and to prefer an action whose payoff is two or three ticks out over a greedy one-step win. However a rollout that looks one step ahead demonstrates the machinery but not depth; without a temporal hierarchy the horizon stays shallow. Then score the whole cascade over a horizon of more than one step, and introduce a two-timescale hierarchy: a slow (strategic) loop that updates priors and preferences, and a fast (tactical) loop that acts against them. Scoring a route means adding up the costs of its steps with the later ones discounted, so that a distant payoff can matter without swamping the immediate situation. Because active inference plans over a policy — here, the pattern cascade for the selected mission — not over the next action alone. Invariant to preserve: the thing being scored is the cascade, not its first move.

If you want a mission’s build phase (instantiate) to close only when its selected pattern cascade has actually been constructed — “a live instance”, not a rich prose section describing one. However the honest-looking witness is a tautology in disguise: re-run the same fold that proposed the wiring and check it reproduced itself (a mirror, R16), or — the failure we hit — execute the cascade as a strict linear pipeline through a fixed rule table, which silently abstains on every mission whose patterns that table does not already encode, so a genuinely well-posed cascade reads as unbuildable. Then take seriously that a cascade is a semilattice, not a chain — patterns compose both by sequence (one enables the next) and by overlap (one pattern belonging to several sub-constructions at once), and in practice the overlaps outnumber the sequences — and execute it by an independent rollout over that structure — give each pattern a move interface whose consumes are the salient tokens of its If/However clause and whose produces are the tokens of its Then; admit a move only when it chains onto the frontier the earlier moves have built; and read discharge as the fraction of the mission’s want-signature the assembled construction covers.The want-coverage used here is a token-level proxy for true discharge; training the move-prior on a structural-quality label (which cascades historically went well) is its natural strengthening, and turns the same rollout into a first estimate of the policy value R13 asks for. The executor is futon3a/holes/labs/M-memes-arrows/rollout_execute.py (over the cascade_rollout move interface); the witness it earns is read by futon3c/src/futon3c/logic/mission_clean.clj (instantiate-witness?). Mint the typed witness (<mission>.executed.edn) only when the construction both assembles (at least one box was built) and discharges (it covers some part of what the mission wanted), recording how much it covered as the realised signal; otherwise the phase re-opens. Because the rollout reconstructs the wiring from the patterns’ own text — a different computation from the phylogeny-edge fold that predicted it — so realised $\ne$ expected by construction: the witness is external to the predictor and cannot be farmed, which is precisely what R16 demands of a closed loop and what the strict-pipeline and re-run-the-fold alternatives both fail to give.

If predicted-versus-realised pairs are your evidence that the model is calibrated. However when the model’s own output composes the field it is scored against, the comparison is self-referential: it tests dynamics-consistency, not whether the model’s value is right — a model can pass forever while being worthless at predicting real outcomes. Then name and keep both layers explicitly: Layer 1 compares the model’s predictions against its own later scores — cheap, run every cycle, and permanently labelled never-value-evidence — while Layer 2 compares predictions against witnessed outcomes the model did not produce, which are scarce and therefore gated. Only Layer 2 clears value, and Layer 1’s cheap pass may never be reported as Layer 2 clearance. Because the only thing that escapes “prior $=$ value” is a referent the model had no hand in; Layer 1’s referent is its own output, so it can establish internal consistency and nothing more, while Layer 2’s is external — the one layer that can be wrong about value, which is exactly why it is the gate. Invariant to preserve: the two layers are never allowed to share a label. Current evidence: a deterministic report preserves the two records and their provenance under distinct fields and fails closed for a missing, failed, author-controlled, or self-witnessed Layer 2. Campaign S produced two successful live records: on both ticks Layer 1 matched proposal to realised action, while Layer 2 was supplied by independent review and grounded re-observation; both combined gates cleared without substituting the cheap layer for the external one.

If you want a genuinely closed action–perception loop: the agent acts, and the world it observes on the next tick is materially different because it acted. However this is seductively easy to fake — an enactor that re-runs its own construction and measures how faithfully it reproduced its own output produces a perfectly honest number over a quantity that cannot move (a mirror, not an act). Then close the loop only when the act writes a typed, ungameable witness to a substrate outside the model — an endpoint proven inhabited by a query derived from the authored bindings, not from builder claims — and that witness feeds the next belief. Because the point of a perception–action loop is that action changes the world and the changed world changes the next belief; if “realized” is coverage-over-reproduction, the world never changes and the belief never updates. Revised against the record: the witness demand has its own measured failure family — :artifact-binding-mismatch, four occurrences in the first cohort — in which an honest author has nothing bindable, either because the dispatched spec was too vague to act on or because the repair was data- or spec-shaped while the binding insisted on an in-attempt code commit; in the worst measured case the demand induced a fabricated code change that independent review then rejected. The revision is that the witness demand must be shape-aware (a deposit or a specification can be the typed, externally-checkable artifact), or the guard against fabrication becomes a generator of it.

If you want the agent to form concepts and reorganise its generative model --- merge look-alike states, prune redundant connections, generalise across contexts --- from accumulated experience but no new data, offline.The payoff is not merely fewer patterns; it is better search. If the system knows that several patterns form a useful constellation, it can propose richer candidate moves than a greedy one-pattern-at-a-time chooser. However simply accumulating experience cannot do this: piling up counts only sharpens the mappings that already exist, and never removes a connection or ties two states together. Then run Bayesian Model Reduction over the accumulated counts — ask whether the evidence already gathered is better accounted for under a simpler model’s assumptions, and accept the simplification only when the evidence favours it by roughly twenty to one. No new data is collected: the same counts are re-read under the simpler assumption, which is what makes the operation cheap enough to run offline over the whole catalogue. Because model evidence — not more data — is what reorganises concepts, and this is the closed-form, biologically-plausible (synaptic pruning during sleep) operator that scores a reduced model against its parent. Invariant to preserve: merging requires a stated evidence threshold, and looking alike is never sufficient. Current evidence: the offline envelope records the frozen parent, every proposed merge, the authoritative $\mathrm{\Delta }F$ threshold and decision, the reduced posterior, and either a structural change or a principled non-change; its canonical input replays to exact equality. Campaign S’s live inter-tick phase froze 26 capability–mission observations, evaluated all 21 pairwise proposals among seven capability concepts in 20 milliseconds, replayed exactly, and carried its result into Tick B’s proposal field. Its accepted reductions collapsed all seven concepts into one, so the mechanism is run-evidenced while the usefulness of this particular reduction remains an operator-facing question rather than an automatic deployment claim.

If you want unresolved structural hypotheses to remain eligible for exploration. However posterior standard deviation is uncertainty, not expected information gain: it contains no expectation over the observation and posterior update that a policy would induce. Then expose the spread under the honest name model-uncertainty bonus, keep it outside the risk-plus-ambiguity core, and reserve the words “information gain” for a calculation that actually earns them. Because an honest exploration heuristic is useful, while a falsely canonical one makes the controller impossible to audit. Invariant to preserve: a quantity is named for what it computes, not for the role you wish it played.

If you want to run structure learning (R17) — merging look-alike states, pruning redundant connections — but need a tractable set of candidate reductions to test, because the space of possible merges is far too large to enumerate. However the control loop (R1–R16) is no help here: it never needed to know which patterns are alike, and hand-picking the candidates by fiat smuggles in the very structure you are trying to learn. Then exploit the fact that design patterns are written as text — push the collection into a high-dimensional vector-space embedding and read off nearness, so that patterns sitting close become candidate merges; hand those to R17, which accepts only the mergers its evidence threshold clears, and let R17^′’s posterior spread rank which neighbourhoods to resolve first. Because the embedding is a cheap, model-free generator of structural hypotheses while the evidence test is the disposer: embeddings are inessential to the control loop but fundamental here, as its generator. Embedding proposes; free energy disposes. Invariant to preserve: whatever proposes the merges must not also be what accepts them.

If repeated, independently recorded episodes, failed retrievals, or fold policy-holes show that no existing pattern adequately expresses a recurring way of acting. However R6 can retrieve only the patterns already written down, R13 can compose only the moves already in the vocabulary, embedding nearness proposes similarity rather than a new action, and structure learning can reduce or compare the structures it has but cannot author a missing one. Then treat the gap as a proposal to enlarge the vocabulary: bundle the triggering circumstances and policy-hole, supporting and challenging memories, rejected near-matches, and a falsifiable predicted outcome into a candidate IF/HOWEVER/THEN/BECAUSE pattern; mint it as a new move at an explicitly unearned prior; make concrete, through a fold, what enacting it is expected to change; and admit cascades containing it to witnessed enactment. Only repeated R16-grounded outcomes and review can promote it; failures revise, merge, or prune it through the rest of R17. Because structure learning must sometimes enlarge the vocabulary in which policies can be expressed, not only rearrange or simplify an inherited vocabulary. Smith et al.’s active-inference model supplies the close theoretical precedent: insufficient state–outcome mappings motivate state-space expansion, after which reduction removes unnecessary structure (5). Our control-space move is an explicit extension of that precedent, not a claim that their model authors design patterns.

If you want the candidate cascades the agent proposes (R6) to improve with experience — to reach for the compositions that have actually gone well, not a retrieval ranking frozen at authoring time. However embedding-similarity retrieval is a prior, not a value: it ranks patterns that look relevant to the problem text, and on the historical corpus the patterns a successful mission actually used sit hundreds of places down that cosine ranking — similarity commits to nothing, so a proposal built from it alone cannot learn. Then train the proposal distribution from realised outcome: score a completed mission’s pattern-composition by the structural aliveness of what R16 witnessed was really built — Salingaros’s measure of a structure’s life, the product of its intensity and its internal coherence — credit that aliveness back to the patterns the mission used, and fit a sampler that generates compositions in proportion to that reward — a generative flow network over the cascade-construction semilattice, which samples the diversity of alive compositions rather than collapsing to the single modal one a greedy prior returns. Because the outcome of using the catalogue is the only signal that separates relevance-that-commits from relevance-that-merely-retrieves; feeding the realised aliveness of built cascades back into how they are proposed is what makes the catalogue a policy that learns which of its own compositions to reach for, not a static menu selected from by a fixed rule.This pattern is the one with the most measured history behind it, and the history is mixed. Credit trained on aliveness does separate the compositions that went well from those that did not, and survives a shuffled-label control. But in a preregistered head-to-head over forty externally adjudicated builds, the trained proposer did not beat the retrieval-prior incumbent on success rate, and a mission-conditioned variant made transfer to unseen missions worse rather than better. What it did win on decisively was diversity of proposals. The disposition we adopted is therefore the honest one: keep it as a diversity supplier, not as a better chooser, until the supply of adjudicated labels is wide enough to settle the question. The full protocol, metrics, and negative results are reported in the companion paper.

If the agent must choose among its own capability gaps — the proposer surfaces one “learn this action-class” candidate per class it cannot yet enact, and the loop must rank them. However gap classes carry no outcome statistics by definition: nothing about them has ever been enacted, so every honest posterior sits at its prior. This is measured, not hypothetical: on 2026-07-19, after a night of four consecutive externally-witnessed groundings, the leading five candidates were all learn-action-class entries at bit-identical scores (fourteen such candidates, every per-class posterior still sitting untouched at its prior, zero recorded updates), and the non-discrimination tripwire refused the pick — correctly, since preferring one never-observed option over another would be invented, not inferred. Then give the choice ground the agent already stands on: partition the same embedded landscape the stack renders as its mission field into action-class zones — a Voronoi tessellation over class seeds embedded in the same space — and value each gap by what its zone carries: structural load (enacted magnitude and summed turn-attestation of the features inside it), live demand (agent dwell-time in the zone, read from the running map), and posterior variance once months of repository history are described in capability terms and replayed into the per-class posteriors. Because capability in this stack is stigmergic — it lives in the built structure, not in agent biographies — the structure’s own load map is the only non-invented ground for preferences over learning; here the embedding stops being a generator of merge hypotheses and becomes the coordinate system in which the self-model has ground truth. The scope claim of R17^′′ therefore sharpens: embeddings remain inessential to acting (R1–R16) and are fundamental twice at the learning frontier --- learning what the model’s concepts are (R17), and learning what the agent’s capabilities are not (this pattern).Chartered, not yet built: futon0/holes/missions/M-capability-zones.md (2026-07-19), discharging the two stop-the-line obligations the measured refusal opened. Mechanism files: futon2/src/futon2/aif/action_proposer.clj (gap-actions), futon2/src/futon2/aif/intrinsic_values.clj (per-class Beta posteriors), futon3c/src/futon3c/live_efe_map.clj (the live coordinate field). A dimensional note with a principled core: the operative partition should live in a 3-D reduction of the embedding — not the print-flat 2-D projection (whose adjacency distortions would silently misfile boundary features) and not the raw high-dimensional space (where distance concentration leaves every nearest-seed margin uniformly thin and the partition uninspectable). Three dimensions keep Voronoi cells compact and the tessellation walkable — and the deeper reason is an acceptance invariant in the spirit of R9: the partition the operator visually accepts must be the same object the machine’s preferences run on, so the machine must operate in a space a human can actually inspect, with the high-dimensional nearest-seed reading retained only as a boundary-distortion diagnostic.

If the selector must rank capability gaps by earned evidence, while the non-discrimination gate rightly reads only the core of the score — risk and ambiguity, nothing else — so that a bolt-on credit can never hide a flat estimator. However feeding the posteriors is not enough — this is measured, not hypothetical: on 2026-07-21, with the per-class credits fully fed and visibly distinct in the ranked field, the core stayed bit-identical and the gate refused again, because by the score-provenance discipline that credit enters only the engineering augmentation — and each naive completion fails its own way: pushing structural uncertainty into the ambiguity leg alone makes every unexplored class uniformly repulsive (anti-epistemic); fabricating an information-gain term violates the honesty rule of R17^′; and re-pointing the gate at the augmented score guts the gate. Then make the core discriminate through both of its legs at once, in its native currency: per-class zone load — the structure’s earned mass — enters the preferences the risk leg scores against, so risk carries what the anthill wants; and each class’s own predicted-outcome uncertainty replaces the class-flat ambiguity placeholder, so ambiguity carries what the machine genuinely does not know about the outcome of learning that class. An unexplored-but-loaded zone then scores low risk and high ambiguity, and the selector’s trade-off between them is exploration-versus-exploitation expressed inside the canonical decomposition — no new term, the gate untouched, and at the empty store the behaviour degrades exactly to today’s honest refusal (uniform predictive variance, zero load shift). Because preferences are exactly where wanting lives in expected free energy and outcome ambiguity is exactly what the ambiguity leg measures; the R17^′ quarantine is a boundary, not a blanket — it bars structure-posterior spread from impersonating expected information gain, while the predictive variance of the scored action’s own outcome is the ambiguity leg’s proper content. That is the edge this pattern names: uncertainty about model structure stays outside the core as an honestly-labelled bonus (R17^′); uncertainty about an action’s outcome belongs inside it, as measurement (R12).Chartered as M-capability-zones slice 2; the two measured refusals it discharges are attempt-036 (prior-flat posteriors, 2026-07-19) and attempt-041 (credit-fed but core-flat, 2026-07-21) — the same tripwire correct both times, for different reasons.

If you have hardened the loop’s constructed core (R1–R16) and want the machinery itself to be observable while it runs live, because every pathology so far — wedges, livelocks, mixed code images, silently lost wakes — was discovered by post-hoc archaeology on a completed broken run. However the loop’s observation channel is task-level only: it observes the world it acts on (job outcomes, verdicts, witnesses, QA), while its own machinery is a hidden state with no likelihood mapping; and simulation tests of the known invariants pass by construction the moment the known bugs are fixed, so neither channel can notice the failure modes nobody has imagined yet. Then weave a supplementary harness of invariant tripwires around the live run at its phase boundaries: each wire is a near-infinite-precision prior over machine trajectories (turn conservation, ledger closure, review-commit provenance binding, append-only repair stores and their status lattice, wedge and livelock detectors, wall-clock overrides, loaded-code/file-code coherence, and an environment-alphabet wire on which any unknown job state trips rather than defaulting); a trip is surprisal that belief updating cannot explain away, and the mandated epistemic action is freeze, record, park, summon — write the frozen state as a durable report, open a typed stop-line through the loop’s own repair machinery, park an investigation join and summon the outer reviewer, on a fail-safe ladder that only ever degrades toward recording, never toward blocking the run. Calibrate before arming: the wires must retro-trip on the known incident corpus (a wire that does not fire on the known past is a dud laser), and every closed incident thereafter must deposit either a new wire or an entry on an explicit blind-spot map. Because this is interoception, not vision: like any sensorium it admits no completeness theorem — it gets identifiability checks, a measured coverage number, and a blind-spot map instead — but an organism with only a hand (R16) and a preference model (C) learns of poison from the stomach ache, and each hotfix repairs one meal; an organism with interoceptive nerves notices at the moment of violation, with the state still warm, and every incident leaves it permanently more observant. The trip stream is also precision evidence about the machine itself (R7): a wire whose trips keep being blessed as model revisions demotes itself down the action ladder, and a genuine trip should lower the system’s confidence in its own machinery until the finding is discharged — the noticing feeding the feeling.