Skip to main content

51  Procedural Memory and Cognitive Loop Closure

51.1 Chapter status

Field	Value
Chapter ID	procedural-memory-and-cognitive-loop-closure
Part	Part II - Planning, Memory, Reasoning, and Execution
Status	conceptual
Manuscript maturity	v0.3 claim-proof program
Last updated	2026-08-02
Primary source records	23 assigned records with 19 exact mappings, including governed compilation of recurring relational programs while retaining the slow path
Claim label	Design rationale
Evidence level	argument
Source loading state	source notes: cognitive_loop_closure, deterministic_capability_compilation, platonic_world_model, rmi, rgs, benchmaxxing, talos, moecot, project_theseus_whitepaper, theseus_self_evolution_system, theseus_operator_os, cca_project, moecot_manifest_project, beastbrain_project, corbens_trainer_project, ext_memgpt_2023, ext_toolformer_2023, ext_voyager_2023, ext_dreamcoder_2020, ext_mem0_2025, reflexive_router_whitepaper, kernel_english_residual_compiler, relational_dimension_compiler, capability_ratchet_whitepaper, regret_engine, ext_hermes_agent_2026, ext_openclaw_agent_runtime_2026; raw cache: cognitive_loop_closure, rmi, rgs, benchmaxxing, talos; connector/recovery: moecot
Test state	AsiStackProofs.ProceduralMemoryRefinement exposes an exact twenty-one-theorem surface over arbitrary finite event runs, including exact identity and nonauthority preservation, rejected-event noninterference, batch composition, and absorbing retirement. Its independent consumer recompiles that surface, preserves the exact three-valid/six-invalid loop and one-valid/ten-invalid trace-promotion suites, covers thirty-two routes across seven stages, and rejects 33/33 mutations. Thirty-five declarations remain live with fourteen retained legacy negative cases; five weak projections or fixture admissions were retired. No deployed procedure-foundry or support claim follows.

51.2 Drafting guardrail

Procedural memory is a governed promotion path from traces to reusable execution structure. All nineteen exact source mappings are bounded, and their reported results remain external context. The executable surface is two exact suites, an arbitrary finite-run lifecycle over seven reachable stages, thirty-two routes, 33 rejecting mutations, and thirty-five live declarations across the refinement and legacy modules. The exact twenty-one-theorem refinement surface preserves nine identity fields and zero support/effect authority, rejected events preserve complete state, event batches compose, and retirement absorbs every suffix. Five weak declarations were retired; fourteen legacy countermodels remain. None proves deployed trace mining, causal abstraction, parameter discovery, generated-tool correctness, natural usefulness, safe routing, recovery, or transfer.

Execution history becomes future execution capacity only after review. The loop-closure layer does not assume that every successful trace deserves automation; it asks which repeated, bounded, verified patterns are mature enough to become routable tools.

That makes procedural memory different from habit. A habit repeats because it worked before. Procedural memory repeats because the stack has preserved traces, extracted a stable invariant, named the parameters, checked failures, and attached regression and retirement rules. The difference matters because a self-improving system will otherwise turn yesterday’s lucky path into tomorrow’s default behavior.

51.3 Human Reading Path

Concrete lens. The repetition baseline compiles the most common action. The governed closure retains negative cases and quarantines the overbroad shortcut.

Repeated work creates a question the execution layer cannot avoid: what should the stack learn from traces that keep recurring? Procedural memory is the path from comparable traces to a reusable tool, checklist, workflow, or capability candidate, after the evidence and boundaries are mature enough.

Automation should be earned. A repeated reasoning loop should not be improvised forever, but it also should not become default behavior just because it worked once. Promotion gates let memory become capability without becoming unchecked habit. That is how self-improvement starts as operational memory rather than as a vague urge to automate everything.

Loop closure is progress only when the closed loop remains inspectable. A reusable procedure should make future work clearer, not merely easier to repeat. It should preserve promotion traces, limiting failures, regression checks, and retirement paths under changed conditions.

Memory becomes capability when reuse carries the reason it was allowed. The loop should close around evidence, not habit. Procedural memory turns repetition into a governed candidate for toolmaking, routing, or delegation while keeping residuals visible.

51.4 Problem

Repeated reasoning trajectories should not be improvised forever when they can become verified procedures or tools.

The execution layer produces traces. Cognitive loop closure asks which repeated traces should become procedural memory. The source’s key point is that repeated reasoning should not remain a bespoke conversation forever: the system should detect recurring trajectories, abstract invariant structure, discover parameters, synthesize tools, verify them, register them, monitor them, and retire or revise them when they fail.

Procedural memory closes Part II because it is the handoff to routing and readiness. Once a loop becomes a tool, the router can select it, readiness gates can govern it, and benchmark ratchets can preserve its floor.

The loop-closure question is therefore not “can this be automated?” but “what evidence would make this safe to reuse?” Some traces should remain examples. Some should become checklists. Some should become scripts or tools. Some should become warnings. The promotion path must keep those categories separate.

51.5 Why existing approaches are insufficient

Agents waste cognition and introduce inconsistency when recurring workflows are repeatedly reconstructed from scratch.

Repeated improvisation wastes tokens, time, and reviewer attention. It also creates drift: the same task is solved differently each time, with different hidden assumptions and different failure modes. But the opposite failure is premature toolification: turning one lucky trace into a routable tool before preconditions, parameters, risks, and regressions are known.

MemGPT (ext_memgpt_2023) supplies the closest external memory-management baseline: long-running agents need explicit memory tiers and control flow rather than unbounded context. Procedural memory applies that pressure to workflows instead of only facts. A recurring procedure should move from trace to tool card only after preconditions, authority, regression checks, and residual risks are recorded; the MemGPT reference is context for memory architecture, not proof that this loop-closure mechanism works.

The adjacent tool-learning literature sharpens the boundary. Toolformer (ext_toolformer_2023) shows a learned policy for deciding when and how to call simple external APIs. Voyager (ext_voyager_2023) shows an embodied agent pattern with an automatic curriculum, executable-code skill library, environment feedback, execution errors, and self-verification. DreamCoder (ext_dreamcoder_2020) shows program-synthesis library learning where solved tasks feed reusable abstractions. Those sources make the procedural-memory ambition less isolated, but they also clarify the missing ASI Stack evidence: this repo has not trained a tool-use policy, reproduced a skill library, learned program abstractions, run a deployed loop detector, or promoted a generated tool through regression and readiness gates.

The efficient stack needs three modes: interpretation for novel work, compiled-tool mode for verified recurring procedures, and failsafe/reflex mode for safety-critical responses. Moving between modes requires evidence.

Current agent systems often blur those modes. A workflow gets repeated because it is convenient, copied into a prompt because it seems useful, and later invoked as if it were validated procedure. The ASI Stack should make that transition explicit: comparable traces first, abstraction second, verification third, routable memory last.

51.6 Core Claim

[procedural-memory-and-cognitive-loop-closure.core, label: Design rationale, support: argument] Cognitive loop closure compiles repeated reasoning into verified parameterized tools and procedural memory.

Reader claim. Repetition becomes procedural memory only when the repeated reasoning can be parameterized, verified, challenged with negative examples, monitored, and retired as a tool.

Operational rule. Preserve source traces and failures, extract explicit parameters and preconditions, verify the generated tool against strong baselines and negative cases, and give it a readiness lease, fallback, monitor, residual owner, and retirement trigger. A failed regression quarantines it.

51.6.1 Worked loop closure: the shortcut fails outside its precondition

An agent repeatedly repairs broken chapter links by replacing an old filename with a new canonical slug. After several successful traces it proposes a reusable repair tool. Positive examples pass, but a negative case contains the old filename inside a quoted historical passage where replacement would corrupt the text. The first generated tool performs a global substitution and fails that regression, so it remains quarantined rather than becoming a routable reflex.

The repaired procedure parses links, restricts edits to link targets, records changed locations, preserves a dry-run diff, and falls back to review on ambiguous markup. Its source traces, parameters, closure artifact, verifier result, benchmark floor, readiness state, monitor, and retirement trigger remain linked. The finite route checks distinguish routable, quarantined, and retired procedural records; they do not establish that the extracted procedure is complete, useful on natural workloads, secure, or better than fresh reasoning.

The claim remains at argument support. Cognitive Loop Closure supplies trajectory logging, loop detection, abstraction, parameter discovery, tool synthesis, verification, registry, routing, monitoring, and retirement vocabulary. RMI, RGS, and Benchmaxxing supply ratchet and regression pressure. Talos supplies execution traces and audit discipline. Project Theseus sources supply implementation-lineage pressure, not local proof of unattended self-evolution. The complete authenticated moecot connector text is passage-reviewed; its runtime artifacts remain unimported and unreproduced.

51.6.2 Claim-source mapping status

Appendix C now maps this procedural-memory claim to all assigned source notes and records passage-reviewed support for eight mappings. The mappings support loop closure as a governed promotion path from repeated traces into verified parameterized tools, not a working loop detector, tool synthesizer, or autonomous self-improvement result.

Source	Review state	What it supports	Limit
cognitive_loop_closure	passage-reviewed local raw cache	Trajectory logging, loop detection, abstraction, active parameter discovery, tool synthesis, verification, registry, routing, monitoring, revision/retirement, three execution modes, and tool-card governance.	No local loop-detection system, tool-synthesis run, verification harness, routing monitor, or retirement automation has been executed.
rmi	passage-reviewed local raw cache	Benchmark pressure, routed specialist attempts, logs, loop closure, residual escrow, regression preservation, arm/router lifecycle, and interpreter/compiled-tool/reflex modes.	Conceptual architecture source only; no independent reproduction, benchmark run, prototype inspection, or ASI behavior is proven.
rgs	passage-reviewed local raw cache	Verified tool promotion, residual preservation, regression suites, and ledgers for benchmarks, models, tools, residuals, calibration, safety, routing, and interventions.	No local benchmark runs, tool-promotion traces, regression data, or implemented ratchet are present.
benchmaxxing	passage-reviewed local raw cache	Benchmark lifecycle, wall diagnosis, ledgers, anti-Goodhart safeguards, residual accounting, and architecture-change discipline.	No benchmark harness, mutation, holdout, empirical run, or model/prototype result was produced here.
talos	passage-reviewed local raw cache	Job lifecycles, adjudication, delivery, feedback/autopoiesis, audit logs, replay, tests, residuals, and regression coverage.	No Talos loop-closure pipeline, scheduler, replay log, or benchmark result has been reproduced.
moecot	authenticated connector text passage-reviewed	Specialist lanes, readiness gates, ledgers, replay, handoff, promotion blockers, residual tracking, and limitation reporting.	MoECOT runtime artifacts, code, logs, readiness records, and benchmark results have not been imported or reproduced.
project_theseus_whitepaper	passage-reviewed local public-project source	Report-first loop closure into verified tools after parameters, preconditions, postconditions, verification, risk, and retirement criteria are recorded.	Current Theseus reports, ledgers, code paths, and command outputs were not rerun from this repo.
theseus_self_evolution_system	passage-reviewed local public-project source	Evidence-gated improvement through intervention ladders, local verified tools, outcome ledgers, lifecycle-governed cells, branch isolation, checks, and trace ledgers.	No Theseus scripts, ATTD reports, branch flow, teacher runner, outcome ledger, or dashboard endpoint was executed here.
theseus_operator_os	passage-reviewed local public-project source	Durable work-board state, goals with budgets/judges/steps/stop conditions/dependencies/events, skill registry, tool hooks, feedback routing, and safety-visible operator surfaces.	No Hive board, node registry, command channel, database, or dashboard was run from this repository.
cca_project	passage-reviewed pinned local project	Compiled-procedure lineage, durable trace identity, and the distinction between semantic knowledge and reusable execution structure.	No CCA procedure-mining run or historical runtime behavior is reproduced.
moecot_manifest_project	passage-reviewed pinned local project	Manifest-bound procedure identity, source/effect receipts, gates, rollback, and registry lifecycle discipline.	No MoECOT Manifest compiler or runtime is executed here.
beastbrain_project	passage-reviewed pinned local project	Durable semantic-memory pressure, procedure/tool separation, failure retention, and lifecycle state.	No BeastBrain memory or tool-promotion behavior is reproduced.
corbens_trainer_project	passage-reviewed pinned local project	Regression evidence, failed-attempt retention, checkpoint/effect acknowledgement, quarantine, and revocable promotion.	No training run, regression-quality result, or capability claim is reproduced.

51.6.3 Strongest objection

Trace promotion can formalize superstition. Four records may share a digest and carry receipts while still encoding a coincidental shortcut, a correlated failure, or an evaluator blind spot. The historical-project fixture therefore establishes record discipline only: it can require failure retention, regression evidence, rollback, and retirement, but it cannot establish that the abstracted procedure is useful, causal, safe, or general.

51.7 Mechanism

Loop closure begins after the execution layer has left enough trace to learn from. Artifact graphs supply source traces, job paths, adapter effects, failures, residuals, and replay limits. Cognitive Loop Closure turns that material into a governed promotion path: detect recurring trajectories, abstract invariant structure, discover parameters, synthesize a candidate tool, verify it, register it, route future matching work through it, monitor it, and retire it when it decays.

This is the proceduralization and skill-composition owner inside the Developmental Intelligence Loop. World models supply defeasible prediction and causal residuals, durable memory supplies qualified semantic objects, and training may supply a candidate policy or module; this chapter may turn repeated traces into a candidate procedure, but Readiness alone decides whether that procedure becomes ordinarily routable and System Boundaries still decides whether it may cause an effect.

RMI and RGS connect this path to the broader ratchet: benchmark pressure creates traces, traces expose repeated structure, verified structure becomes tools, residuals remain visible, and regressions protect the floor. Benchmaxxing keeps promotion tied to evaluation rather than enthusiasm. Theseus adds the report-first implementation boundary: a tool is not routable just because a trace looked useful; it needs a card, checks, ledgers, and retirement criteria.

51.7.1 Forward transfer is the admission test for reusable knowledge

From Compression to Forward Transfer adds a missing causal boundary to this lifecycle. A compact description of old traces can be valuable as analysis without helping on the next task. A stored procedure can be retrieved without being invoked, invoked without contributing to a verified solution, and contribute without being necessary. Even an operationally necessary abstraction can fail to improve the outcome once its mining, retrieval, search, and verification burden is counted.

The procedure record therefore carries a reuse state rather than a single reused flag. The proposed ladder runs from stored (R0), exposed or retrieved (R1), invoked (R2), present in a verified solution (R3), semantically contributory (R4), operationally essential under removal (R5), positive on a frozen future-task distribution (R6), and positive across a distinct task family (R7). Each transition needs its own evidence. Frequency can prioritize a candidate for testing; it cannot skip the ladder.

Admission also crosses a version boundary. Extraction and independent validation occur on development material. The knowledge state, search procedure, verifier, task lineage, and budgets are then frozen before the test intervention. Accepted candidates enter a later library version rather than the version being evaluated. This blocks a successful test task from teaching the artifact that is credited with solving that same task.

The decisive comparison is a matched intervention: candidate present versus absent, irrelevant or duplicate placebos, removal for necessity, and a library-by-search factorial when both changed. Outcomes remain verified, refuted, unknown, timeout, or invalid; cost and complete denominators stay visible. The source proposes this design and concrete program-synthesis protocols but reports no run, so this chapter gains an admission criterion, not evidence that any current procedure transfers.

The operational lifecycle has eighteen stages:

1. Freeze the task family, consumers, authority, risk, horizon, success criteria, and non-claims before mining traces.
2. Inventory the complete eligible trace universe with stable run, task, artifact, context, model, tool, effect, evaluator, and outcome identities.
3. Separate semantic facts, episodic observations, procedural traces, policies, skills, tools, and model-weight learning.
4. Verify source and effect receipts against artifact and runtime reality before a trace becomes eligible.
5. Define comparability prospectively and cluster by task semantics, pre-state, authority, environment, route, effect class, and outcome.
6. Preserve successes, failures, near misses, abstentions, interventions, repairs, and missing or censored outcomes.
7. Infer a candidate invariant with counterexamples, alternative explanations, causal dependencies, and a non-applicability envelope.
8. Discover typed parameters, latent dependencies, defaults, ranges, units, interactions, and unresolved confounders.
9. Specify preconditions, postconditions, authority and rights, side effects, resources, failure semantics, and residual owners.
10. Synthesize a candidate procedure, checklist, workflow, program, or tool card with lineage, environment lock, reproducible build, and rollback handle.
11. Run appropriate static, dynamic, adversarial, mutation, property, negative-control, and independent result checks.
12. Compare manual or interpreter execution, retrieval-only memory, prompt or checklist reuse, scripts, workflows, learned tool use, skill libraries, program-library learning, and the governed procedure under matched resources.
13. Run preregistered regressions, hidden holdouts, shifts, counterfactuals, and transfer tests with every attempt retained.
14. Measure useful success, wrong or unsafe reuse, false refusal, latency, tokens, compute, human effort, privacy, recovery, and residuals jointly.
15. Qualify explicit trace, cluster, candidate, verified, routable, quarantined, revised, deprecated, and retired lifecycle states.
16. Expose a qualified procedure to Routing only through a scoped fresh lease whose preconditions and authority are rechecked at invocation.
17. Monitor route drift, precondition decay, dependency change, regressions, incidents, evaluator drift, and delayed harm.
18. Quarantine, roll back or compensate effects, revise or retire, preserve failure lessons, and invalidate affected descendants when qualification fails.

flowchart LR
  A["Candidate traces"] --> B["Loop cluster"]
  B --> C["Invariant abstraction"]
  C --> D["Parameter discovery"]
  D --> E["Tool candidate"]
  E --> F["Verification + negative examples"]
  F --> G{"Qualified reuse?"}
  G -- "yes" --> H["Routable tool card"]
  G -- "no" --> I["Quarantine / residual / retire"]
  H --> J["SCF, benchmark floor, monitoring"]
  I --> J
  J --> K["Retirement or requalification trigger"]

Reading the loop closure path: The loop-closure path turns repeated traces into a candidate procedure only after invariant abstraction, parameter discovery, verification, and negative examples. Qualified reuse creates a routable tool card; failed qualification preserves quarantine, residual, retirement, and requalification routes.

The loop-closure path starts with safe traces that preserve provenance, failures, residuals, and replay limits. Comparable traces justify detection; detection leads to invariant abstraction, parameter discovery, preconditions, postconditions, and then candidate synthesis. Verification, regressions, monitoring, and retirement criteria decide whether the candidate becomes routable, remains in quarantine, returns to revision, or is retired.

The state machine should be explicit enough for a future implementation to refuse reuse. A trace starts as a candidate_trace, becomes a loop_cluster only when there are comparable cases, becomes a tool_candidate only after the invariant and parameters are named, becomes verified_reuse only after checks and negative examples bound the envelope, becomes routable only through an SCF/readiness gate, and can later be quarantined or retired. The existing public fixture validates the smaller procedural_tool_record shape; these states define the fuller procedure-qualification discipline the next harness should implement.

A tool card should name source traces, invariant structure, parameters, preconditions, postconditions, verification result, risk tier, runtime tier, monitoring plan, residuals, regressions, lifecycle state, and retirement criteria.

Negative examples are part of the memory, not clutter. A loop detector that only sees successes will overgeneralize; a tool card without failed cases cannot say where the procedure stops. The procedure card preserves near misses, rejected traces, and residuals so the future router knows when not to use the tool.

51.7.2 Active parameter discovery attacks accidental invariants

Repeated traces reveal only the variation that happened to occur. Three runs using npm, USD, one schema, one jurisdiction, or one output format do not make those values invariant. Before synthesis, the abstraction proposal therefore faces six kinds of probe:

1. historical variance across the complete eligible trace set;
2. counterfactual replay with controlled substitutions in a sandbox;
3. synthetic cases that add missing fields, alternative environments, boundary values, and unobserved but plausible structures;
4. adversarial cases with ambiguity, partial data, malformed inputs, drift, conflicts, stale dependencies, and unsafe edge conditions;
5. environment interrogation of configuration, versions, units, permissions, schemas, dependencies, and platform immediately before use; and
6. a named human or supervisory question when a dependency cannot be inferred safely.

Each candidate variable remains one of four epistemic states: invariant, parameter, precondition, or unknown_assumption. A parameter needs a type, unit, range, validation rule, source, interaction set, and evidence that changing it affects execution or checking without unexpectedly destroying the procedure. A suspected dependency that cannot be represented safely becomes a precondition, clarification/abstention trigger, or residual—not a hidden default.

Active probing carries authority and safety obligations of its own. A counterfactual is cheap only in a faithful sandbox; an environment query can disclose sensitive state; a physical perturbation can cause an irreversible effect. The probe record binds environment, permitted mutations, stop rule, observations, evaluator, cost, and affected residuals. “Discover the boundary” never grants permission to cross it.

Loop closure is reasoning compression. It turns many successful trajectories into one parameterized procedure, but only when the verification burden has been paid.

Semantic facts and procedural traces remain separate memory domains. A fact can justify a precondition or policy, but it is not evidence that a procedure ran; a trace can show an observed route and effect, but it does not become a timeless semantic fact. Promotion binds every candidate trace to both a source receipt and an effect receipt, retains failed attempts as negative examples, and requires a passing regression suite plus a rehearsed rollback route.

51.7.3 Governed trace-to-reflex compilation

The Reflexive Router makes the loop-closure product broader than a tool card. A verified recurring trace may compile into a deterministic rule, query, semantic-cache plan, workflow, program, solver template, or bounded specialist policy. Representation is chosen only after the invariant, parameters, preconditions, effect class, verifier, latency/cost target, and failure semantics are explicit; compilation is not synonymous with distillation into weights.

Eligibility requires complete comparable traces rather than repeated fluent success. The compiler retains negative examples, near misses, abstentions, human interventions, partial effects, rollbacks, delayed failures, and censored outcomes. It then synthesizes the negative space: guards for contexts in which the candidate must not run, including ambiguity, stale evidence, OOD inputs, authority mismatch, temporal conflict, risky effects, verifier absence, and known rare exceptions. Positive traces alone underdetermine those guards.

Promotion proceeds through static analysis, property and mutation checks, replay, differential comparison with the deliberative parent, adversarial and shifted holdouts, shadow execution, canary use, qualification, signed promotion, and monitored leases. The compiled reflex preserves source-trace, field, schema, policy, evaluator, authority, and environment dependencies. Material change triggers quarantine, fallback to the full deliberative path, and descendant invalidation.

Decompilation is a first-class recovery path. It disables the rule or policy, invalidates aliases, caches, routes, workflows, and descendants, restores the deliberative route, preserves affected effects and residuals, and records why the optimization failed. A reflex that cannot expire, quarantine, roll back, or decompile is not governed procedural memory.

The paper offers this lifecycle and falsification program, not an implemented compiler or measured efficiency gain. Existing synthetic qualification records do not establish trace mining or safe compilation, so the core remains at argument.

Assurance-Shift Learning (assurance_shift_learning) narrows what can be compiled from a failure family. The compiler consumes admitted Boundary Evidence Bundles rather than outcome labels: preserved prefixes and protected positives define what must survive, repair counterexamples define negative space, causal uncertainty limits generalization, and recurrence plus transfer justify amortizing a test, guard, procedure, tool, or recovery routine. A severe but unresolved bundle remains evidence for investigation, not a reflex.

Once a mature family becomes a cheap deterministic check or procedure, direct gradient pressure can retire while the bundle, regression, expiry, and reactivation trigger remain. Model, evaluator, region, or repair changes can reopen it. This is the procedural meaning of learner-relative negative half-life: attention follows unresolved risk and repair state, not archival age. No compiler or recurrence reduction has been demonstrated.

51.7.4 Compile relational programs without deleting the slow path

The Relational Dimension Compiler generalizes a repeated trace into a relation-construction program. The slow path may propose entities and role bindings, choose an operator, run counterfactual and invariance checks, admit a relation, and decide whether a subcomplex can be contracted. When that path repeats successfully, procedural memory may compile it into a classifier, index, exact rule, low-rank kernel, planner operator, cached macro-object, or specialist model.

The compiled artifact inherits no unrestricted truth or applicability. Its card must retain the relation schema and role semantics, branch and time policy, candidate information, qualification envelope, known counterexamples, calibration, contraction error if any, distribution-shift triggers, expiry, monitoring, and a pointer to the exact slower route that can recheck it. Shadow and canary stages compare the fast path with that parent rather than merely checking task output.

This yields a stronger decompilation rule: disabling a compiled relational path must also invalidate its cached relations, macro-objects, downstream routes, and descendants whose support depends on it. Historical versions remain resolvable, and unresolved effects remain in the ledger. A fast recognizer that cannot reopen its source structure or route disputed cases through the qualified slow path is cache optimization, not governed loop closure.

The paper makes this a falsifiable program. Compilation has value only when measured savings exceed monitoring, requalification, invalidation, and rollback cost while role binding, calibration, branch separation, and shifted holdouts stay inside the declared envelope. No such result is imported here.

51.7.5 Kernel macros are instruction-set changes, not tokenizer trivia

KERC identifies two reusable structures that may emerge from repeated work: local residual entries that predict a stable realization, and repeated Kernel sequences that behave like typed procedures. The first may become a scoped dictionary or terminology rule; the second may become a grammar macro, local instruction, tool template, or globally trained token. Frequency is proposal evidence only. The candidate must still name the expanded sequence, typed signature, semantic identity, applicable domains, protected boundaries, authority effects, expected savings, negative cases, and slower expansion route.

A local macro can live inside one packet or interaction and expand completely for verification. Promotion to a shared registry requires representative corpora, paraphrase and minimal-contrast tests, rare-role and scope cases, embedding trainability, migration tests, ambiguity and injection review, versioned deployment, monitoring, and rollback. A frequent fusion is rejected when it hides negation, quantification, provenance, quotation, values, entity identity, or authority, or when a plain expanded Kernel sequence transfers better.

Residual promotion is narrower but still stateful. The compiler compares the definition cost and state-management burden with predicted future reference savings, includes privacy and misapplication risk, and selects the smallest scope that can earn the benefit. An automatically inferred term for one legal document does not become a global user preference. User correction, version change, drift, state desynchronization, or a changed concept definition can demote the entry back to explicit local residue.

Decompilation removes the macro token or dictionary shortcut while preserving the stable concept, expanded instruction, source traces, historical packet versions, and affected descendants. Stored memories and packets using the old code remain migratable or fault explicitly. The source describes a governed instruction-set optimization loop; it provides no trained macro, transfer gain, safe promotion result, or evidence that shorter internal traces preserve reasoning.

51.7.6 Campaign 5: consolidation must be versioned, quiescent, and reversible

Campaign 5 supplies a bounded synthetic test of the consolidation boundary. In ten governed environment/seed runs, the agent consolidated candidate sensor rules, semantic state beliefs, intervention-response rules, and procedures only at declared 20-episode quiescent boundaries. Each consolidation named supporting episodes, preserved a contradiction field, superseded the previous version after version one, and bound a rollback snapshot.

The governed arm produced a mean of six versions per workshop run and four per service-mesh run, with zero detached abstractions, exception-field losses, lineage breaks, or silent rewrites. Serialized replacement was exact in 10/10 governed runs and rollback to the selected snapshot was exact in 10/10. The no-quiescence ablation rewrote rules silently 34 times in the workshop and 44 times in the service mesh. The no-consolidation ablation reset its predictive tables at the frozen boundaries and lost 0.0367 and 0.0700 held-out accuracy.

This result sharpens the mechanism: consolidation is not a summary-writing event. It is a candidate state transition with evidence references, contradictions, lineage, a quiescence condition, replacement conformance, and a rehearsed rollback target. The narrow non-core transition is synthetic-test-backed; the procedural-memory core stays at argument. Count tables in authored simulators do not establish neural memory consolidation, semantic abstraction quality, catastrophic-forgetting resistance, durable deployed memory, open-ended procedure discovery, or transfer.

51.7.7 Reification closes learned improvement back into explicit memory

Deterministic Capability Compilation names the missing closure operation: reification. When a learned expert or environmental residual consistently outperforms its scaffold, a disagreement tribunal first classifies the event as student defect, specification defect, novelty, valid optimization, reward exploit, or unresolved. Accepted behavior is then compiled back into an explicit contract, test, counterexample, field, route rule, or tool. The weights remain lineage evidence, but they are not the only surviving copy of the discovery.

Reification prevents procedural memory from becoming unreviewable behavioral drift. It also creates a cycle rather than a one-way distillation pipeline: explicit scaffold -> learned candidate -> environmental disagreement -> governed discovery -> revised explicit artifact. False reification is a first- class failure mode and must preserve the original disagreement, evaluator, authority, rollback, and dissent.

The Regret Engine source (regret_engine) supplies a more selective trigger for this path. Repeated failures become a repair cluster only when their decision-time capsules, admitted comparators, causal features, and uncertainty regimes are meaningfully comparable. A high-confidence cluster should preserve a contrastive repair pair: the inferior trajectory, an admissible better trajectory, the smallest behavior difference, and the assumptions that make the comparison usable. If that pair cannot be supported, the episode remains uncertainty or data-acquisition material rather than becoming a rule.

Its proposed regret debt is a procedural backlog, not a reward: expected recurrence multiplied by preventable burden, uncovered mitigation, and transfer value. The compiler spends that debt by choosing the least invasive durable artifact that can prevent recurrence: test, monitor, checklist, guard, route, retrieval trigger, skill, policy patch, or architecture change. Every repair keeps scope predicates, protected counterexamples, exceptions, false-positive cost, expiry, rollback, and a receipt showing whether recurrence actually fell. Useful exploration and rare competence are retained as counterfactual-surplus cases so the system cannot improve its failure ledger by forgetting what worked.

This sharpens loop closure without validating autonomous rule discovery, causal clustering, transfer, or recurrence reduction. Those remain empirical and formal work.

The Platonic World Model contributes a smaller runtime residue before full reification. Each task can retain the concepts and versions used, new entities, propositions accepted or rejected, proof handles, world branch, unresolved ambiguity, proposed semantic changes, and packet dependencies. This semantic residue supports long-horizon memory without preserving every token, but it is not automatically a canonical Form, fact, policy, or skill. Promotion still passes the appropriate epistemic, semantic, and procedural gates.

51.7.8 “Verified tool” is a vector, not one maturity badge

Cognitive Loop Closure separates several properties that tool registries often collapse. A candidate can be deterministic yet untested, widely tested yet nondeterministic, sandboxed but semantically wrong, fast but overprivileged, or safe for an assisted workflow but unsafe for automatic routing.

Axis	Example states	Governing question
Internal generation	deterministic; bounded nondeterministic; model-assisted	What output variation and retry/selection lineage remain?
Verification evidence	unverified; replay; held-out; synthetic; adversarial; runtime-monitored; scoped human approval; domain certification	Which exact behavior, environment, threat, and consumer did the evidence cover?
Runtime assurance	template; assisted workflow; typed function; sandbox; memory-safe system; real-time controller	What can the executing artifact access, mutate, and recover from?
Latency	nonurgent; interactive; operational; real-time; safety reflex	What deadline and tail/jitter bound must the complete trigger-to-effect path meet?
Consequence	low; medium; high; critical	What happens when the tool or its monitor is wrong?
Lifecycle	candidate; proposed; probed; tested; probationary; active; monitored; revised; quarantined; retired	Is this version currently eligible for the requested route?

A semi-deterministic tool binds its internal model, prompt or policy, context sources, decoding, retry budget, candidate denominator, selector, verifier, fallback, and observed variance. Wrapping a model call in a function does not make it deterministic. Replay success does not imply held-out generalization; synthetic and adversarial coverage inherits generator blind spots; runtime monitoring observes only specified properties; human approval is scoped; and a “certified” label names a domain, version, authority, and expiry.

The route lease consumes the whole vector. It rechecks task and parameter match, preconditions, environment, freshness, risk, authority, side effects, verification coverage, runtime, latency, monitor, and fallback. For hard real-time or safety-reflex classes, fresh language-model reasoning is not an admissible fallback merely because the compiled path failed. The fallback must already meet the deadline and physical or operational containment contract.

51.7.9 Tool maturity, confidence decay, and revalidation

VIEA prevents the jump from “this pattern recurred” to “the system may execute it.” A compiled procedure moves through candidate, draft, shadow, assisted, active, certified, and retired states. Promotion requires repeated success across more than one context, declared preconditions and postconditions, verification, absence or disposition of critical failures, total-cost review, fallback, and a named retirement policy. The exact threshold is task- and risk-dependent; the example counts in the source are design defaults rather than universal laws.

Trust then decays with time since valid use, dependency and runtime changes, environment shift, low or changed usage, failed executions, unresolved residuals, and changes to the verification suite or consequence tier. Those events can force shadow, assisted use, requalification, or retirement. Robotics, fabrication, deployment, finance, and security procedures require runtime monitoring and failsafe behavior even after certification. A tool is procedural memory only while its applicability and evidence remain current; otherwise it is a historical artifact with a stale execution hypothesis.

51.7.10 Evidence-bound skill mutation in live agent systems

ext_hermes_agent_2026 and ext_openclaw_agent_runtime_2026 make the abstract trace-to-procedure loop concrete. Hermes can create, patch, rewrite, and delete skills, and can stage those writes for durable diff approval. OpenClaw’s experience review receives a bounded trajectory, may author at most one pending proposal, binds a patch to the exact live skill, and routes application through security scanning, stale-target rejection, rollback metadata, and lifecycle aging. Both systems distinguish short always-present memory from longer load-on-demand procedures.

The comparison also identifies the remaining promotion gap. A trajectory can support a proposal without evidence that its causal lesson is correct, its procedure generalizes, or a new default route is safe. The book’s qualified path therefore adds held-out replay, adversarial and negative controls, authority checks, independent result adjudication, scoped readiness, canary routing, monitoring, and retirement. The official project documentation was reviewed at pinned revisions; no learned skill, regression campaign, rollback, or utility result was reproduced here.

51.8 Interfaces

Reusable cognition becomes operational through twelve explicit owner interfaces around the Procedural Tool Record:

1. Artifact Graphs, Audit Logs, and Replay owns trace identity, lineage, observed receipts, replay grade, and impact closure.
2. Virtual Context ABI and Context Transactions owns semantic, episodic, and working-memory state; this layer owns reusable execution structure.
3. Claim Ledgers and Belief Revision owns propositional support and contradiction; a successful procedure cannot become a true fact by reuse.
4. Cognitive Compilation and Semantic IR owns executable representation and semantic lowering; this layer owns promotion from repeated traces.
5. Routing Heads and Specialist Cores owns selection and fallback; this layer supplies applicability and lifecycle records.
6. Runtime Adapters owns authority-bound effects and observation; procedural memory cannot grant itself permission.
7. Verification Bandwidth, Spinoza, and Evidence Engineering owns verification obligations, proof artifacts, evidence, and support.
8. Benchmark Ratchets owns benchmark floors, anti-Goodhart controls, holdouts, and regression pressure.
9. Stable Capability Fields, Replacement, and Readiness owns capability identity, promotion, quarantine, rollback, and release gates.
10. Security, Privacy, Rights, and Legal owners constrain trace admission, authority, disclosure, retention, deletion, and remedy.
11. Labor OS and Human Collaboration owns work roles, intervention, review, appeal, and visible organizational learning.
12. Data Engines, Continual Learning, and Unlearning owns dataset and model- state updates; procedure reuse is not weight learning or erasure.

A fuller Procedure Qualification Packet should sit around the record when the tool is being promoted. It should include the candidate trace set, rejected traces, near misses, abstraction rationale, parameter-discovery notes, precondition and postcondition evidence, SCF target, benchmark floor, risk tier, authority requirement, monitoring signal, retirement trigger, and explicit non-claims. The packet is not a success badge; it is the material a gate needs in order to say yes, no, quarantine, or retire.

Minimum fields:

• tool_id
• source_traces
• eligible_trace_universe
• rejected_and_negative_traces
• invariant_structure
• parameters
• unknown_assumptions
• active_probe_refs
• preconditions
• postconditions
• generation_determinism
• model_and_selection_lineage
• verification_result
• verification_scope_and_expiry
• risk_tier
• runtime_tier
• latency_class
• authority_and_permissions
• allowed_side_effects
• fallback_mode
• monitoring_plan
• dependency_versions
• effect_receipts
• residuals
• regressions
• lifecycle_state
• retirement_criteria

Artifact graphs supply traces. Routing selects verified tools. Evidence tests utility and regressions. Readiness gates decide promotion, quarantine, revision, or retirement.

SCFs give the generated tool a capability boundary; benchmark ratchets give it a floor to preserve; artifact graphs give it lineage; readiness gates decide whether it can be selected. Without those interfaces, procedural memory becomes a private shortcut instead of a governed stack layer.

51.9 Invariants

1. Every procedure retains stable identity for its eligible universe, included cluster, excluded traces, and sampling rule.
2. Semantic facts, episodes, traces, policies, tools, and model learning remain distinct memory domains.
3. Declared sources, intended actions, and success labels never substitute for independently observed source and effect receipts.
4. Comparability is fixed before outcome inspection or every post-hoc change is recorded and re-evaluated.
5. Failures, near misses, abstentions, interventions, repairs, missing outcomes, and censored traces stay in the record and denominator.
6. Every inferred invariant carries counterexamples, alternatives, assumptions, causal dependencies, and a non-applicability envelope.
7. Parameters carry type, unit, range, default, provenance, interactions, and unknown dependencies.
8. Preconditions, postconditions, authority, rights, side effects, resources, failures, and residual owners are machine-checkable.
9. Synthesis is reproducible from bound traces and cannot silently widen task, authority, effect, data, or consumer scope.
10. Verification, regression, usefulness, safety, privacy, support, readiness, and release remain separate decisions.
11. Matched baselines receive equivalent tasks, information, models, tools, authority, resources, human help, retries, and time.
12. Denominators include every eligible, attempted, failed, refused, repaired, rolled-back, disputed, and delayed-outcome case.
13. Routable state requires current regressions, hidden holdouts, negative controls, capability identity, rehearsed rollback, monitoring, and custody.
14. Routing rechecks task match, preconditions, authority, rights, freshness, risk, and resource ceiling for every invocation.
15. Dependency, policy, evaluator, environment, model, tool, source, or benchmark changes invalidate or requalify affected descendants.
16. Quarantine, revision, deprecation, and retirement remain reachable and block ordinary routing while active.
17. Rollback inventories and observes effects, copies, descendants, costs, disclosures, and delayed obligations, not only the procedure card.
18. Evidence language stays inside the exercised task, trace, model, tool, effect, environment, threat, population, organization, and time envelope.

The promotion invariant is simple: only verified loops become routable tools. A failed regression does not become “future work” hidden inside a successful tool card; it blocks promotion or remains residual.

Scope fidelity is the tool-memory invariant. The generated tool may be narrower than the traces that inspired it, but it should not be broader unless new evidence justifies the expansion. Tool cards should prefer small verified envelopes over broad automation that is hard to falsify.

51.10 Failure modes

1. Anecdote closure promotes one elegant or lucky trace without a comparable cluster.
2. Similarity laundering clusters traces whose tasks, states, authority, environments, effects, or outcomes differ.
3. Memory-domain laundering turns facts, summaries, policies, outputs, or intended actions into observed procedural evidence.
4. Receipt laundering accepts declared inputs, tool returns, or intended effects without checking reality.
5. Success-only promotion removes failures, abstentions, interventions, repairs, missing outcomes, or negative examples.
6. Evaluator capture lets the same model, code, data, organization, or incentives generate and certify the procedure.
7. Hidden-parameter closure encodes latent context, defaults, units, or human knowledge as generality.
8. Correlation-to-causation closure compiles a shortcut or confounder instead of a mechanism that survives intervention.
9. Authority laundering gives a useful procedure standing permission beyond the invoking principal, task, rights, or effect lease.
10. Semantic drift or dependency decay leaves a procedure routable after sources, APIs, policies, models, tools, or environments change.
11. Benchmark or regression overfitting preserves a visible floor while failing hidden natural work, transfer, or delayed outcomes.
12. Prompt, trace, or supply-chain poisoning installs malicious examples, dependencies, code, tests, monitors, or retirement logic.
13. Tool bloat creates overlapping procedures whose lifecycle burden exceeds saved reasoning.
14. Automation complacency weakens human skill, review, exception handling, or responsibility while apparent throughput rises.
15. Route drift invokes a qualified procedure outside its task, authority, rights, risk, model, environment, or resource envelope.
16. Rollback theater restores a card while effects, copies, disclosures, costs, descendants, or obligations persist.
17. Immortal promotion makes quarantine, revision, deprecation, retirement, or descendant invalidation unreachable.
18. State-of-the-art theater treats schema conformance, fixtures, finite routes, code generation, or reuse frequency as general procedural learning.

Premature toolification creates brittle automation. Hidden assumptions make the tool fail outside its original context. Procedural memory poisoning occurs when bad traces become reusable machinery. Those memory failures keep the tool in draft, residual, quarantine, or retired state.

Tool immortality is the memory-layer failure. A procedure that was once verified can become stale when sources change, APIs shift, benchmarks saturate, or governance rules tighten. Retirement criteria and monitoring are therefore part of memory, not administrative cleanup.

51.11 Minimum Viable Implementation

The implemented minimum is exact: one public procedural-tool schema; three valid and six expected-invalid qualification packets; one bounded four-project trace-promotion record with ten rejecting mutations; and thirty-five live Lean declarations. Twenty-one belong to the arbitrary finite-run refinement and fourteen retained legacy declarations remain bounded negative cases; five weaker declarations were retired.

Procedural memory begins with a procedural_tool_record schema and fixture. It validates source traces, invariant structure, parameters, pre/postconditions, verification result, risk/runtime tiers, monitoring plan, residuals, regressions, lifecycle state, and retirement criteria.

The synthetic procedural-memory loop harness now adds a small procedure-qualification gate around that record shape. It checks three valid and six expected-invalid packets for comparable success traces, near misses or failures, preserved negative examples, explicit parameters/preconditions/postconditions, matching invariant structure, regression quarantine, retirement triggers, and source-trace mismatch.

The historical-project trace-promotion fixture adds a stricter closure record. python3 scripts/validate_procedural_trace_promotion.py accepts one bounded four-project promotion and rejects ten mutations covering memory-domain conflation, failure erasure, missing source/effect receipts, regression laundering, negative-example erasure, unrehearsed rollback, missing retirement, source substitution, and fixture support promotion.

AsiStackProofs.ProceduralMemoryRefinement connects those record gates into one authored transition system from clustering through abstraction, verification, qualification, routing, and receipt-bound retirement. Its exact twenty-one-theorem surface proves, for every finite event list, preservation of procedure, version, source-set, trace-cluster, abstraction, regression-suite, SCF, policy, and consumer identity plus zero support/effect authority. Rejected events preserve the complete state exactly, event-list execution composes, and retirement is absorbing. python3 scripts/validate_procedural_memory_refinement.py independently recompiles that exact surface, preserves both exact suites, covers all thirty-two routes, and rejects all 33 mutations. The older module retains fourteen useful negative cases; its two assumption projections and three fixture-admission theorems are retired.

The miniature trace set is still synthetic record-gate evidence. It shows how the book expects a procedure candidate to cite source traces, preserve failures, narrow scope, and deny routable promotion when regressions or retirement triggers fire.

This makes qualification record discipline executable, not procedural learning. No deployed trace miner, prospective comparability rule, clusterer, causal invariant learner, parameter-discovery system, tool synthesizer, independent generated-tool verifier, natural regression campaign, router, rollback execution, monitor, or retirement automation ran.

51.12 Mature Research Target

The mature operational contract is a procedure foundry tested on preregistered natural repeated work. It mines complete artifact and effect traces, separates memory domains, clusters comparable cases, preserves every failure and intervention, infers invariants with counterexamples and causal alternatives, discovers typed parameters, synthesizes reproducible candidates, and qualifies them through independent verification, matched baselines, hidden holdouts, adversarial tests, monitoring, rollback, quarantine, and retirement.

The campaign compares manual or interpreter execution, retrieval-only memory, prompt or checklist reuse, scripts, workflow engines, learned tool use, program-library learning, skill libraries, and the full foundry under matched tasks, information, models, tools, authority, resources, human help, retries, and time. Joint gates cover useful success, wrong or unsafe reuse, false refusal, generalization, transfer, route drift, authority, privacy, latency, token and compute cost, human effort, recovery, residuals, and total lifecycle burden. Every eligible, attempted, failed, refused, repaired, rolled-back, disputed, and delayed-outcome case stays in the denominator.

Causal signatures are specified before results. Removing prospective comparability should increase false clustering. Removing negative examples should widen reuse into known failures. Removing parameter discovery should increase context-sensitive errors. Removing independent verification should increase accepted wrong procedures. Removing hidden regressions should increase overfit qualification. Removing scoped routing should increase authority and route drift. Removing retirement should increase stale reuse. Effects that do not follow those signatures remain unexplained observations.

A separately implemented evaluator must reproduce the conclusions across models, tasks, tools, effect classes, environments, organizations, rights regimes, attacks, and time. Until that program passes, procedural memory remains argument; schemas, authored records, theorem routes, code generation, or reuse frequency do not establish useful causal general procedural learning.

51.13 Codex test plan

Test	Purpose	Status
Procedural tool fixture validation	Check that the procedural-tool fixture matches the public schema and declares source traces, invariant structure, parameters, pre/postconditions, verification result, risk/runtime tiers, monitoring, residuals, regressions, lifecycle, and retirement criteria.	implemented by protocol validation; validated locally
Loop detection test	Check that candidate tools reference repeated source traces rather than a single anecdote.	implemented for synthetic qualification packets by python3 scripts/validate_procedural_memory_loop.py; no deployed loop detector claim
Procedure qualification state test	Check that a trace cannot jump from candidate trace to routable tool without loop clustering, abstraction, parameter discovery, verification, and readiness review.	planned; not run
Negative-example preservation test	Check that near misses, rejected traces, and failures remain attached to the candidate and narrow its scope.	implemented for synthetic qualification packets by python3 scripts/validate_procedural_memory_loop.py; no deployed interpretation claim
Tool abstraction test	Check that parameters, assumptions, preconditions, and postconditions are explicit.	implemented for synthetic qualification packets by python3 scripts/validate_procedural_memory_loop.py; no generated-tool correctness claim
Verified tool regression test	Check that failed regression blocks routable promotion.	implemented for synthetic qualification packets by python3 scripts/validate_procedural_memory_loop.py; no deployed regression-quality or routing claim
Retirement trigger test	Check that stale preconditions, failed floors, or SCF retirement move a routable tool to quarantine or retired state.	implemented for synthetic qualification packets by python3 scripts/validate_procedural_memory_loop.py; no deployed retirement automation claim
Procedure lifecycle route proof	Check that modeled routable promotion requires comparable traces, negative examples, closure artifacts, verification, clean regressions, benchmark floor, active SCF target, retirement handling, monitoring, residuals, non-claims, and a verified/routable source state, with fixture-shaped bridge records for valid routable, quarantined, and retired scenarios.	implemented in AsiStackProofs.ProceduralMemory; checked by Lean build
Historical-project trace-promotion test	Check fact/trace separation, failure retention, source/effect receipts, regression-backed promotion, rollback, retirement, and no support promotion.	implemented by python3 scripts/validate_procedural_trace_promotion.py; bounded fixture only

Fixture-shape validation, thirty-five live Lean declarations over the arbitrary finite-run refinement and retained negative cases, and the synthetic procedure-qualification harness are implemented. Remaining tests need deployed repeated-trace mining, synthesized tool candidates, generated-tool correctness checks, regression-quality benchmarks, routing monitors, and retirement automation.

51.13.1 Formalization hooks

Tag	Module	Target	Status
lean:procedural.loop_closure.operational_invariant	AsiStackProofs.ProceduralMemoryRefinement	Every finite procedure lifecycle run preserves exact procedure, source-set, trace-cluster, abstraction, regression-suite, SCF, policy, and consumer custody; rejected events preserve exact state, batches compose, retirement is absorbing, and support or external effects remain unassigned.	implemented
lean:procedural.loop_closure.failure_blocks_promotion	AsiStackProofs.ProceduralMemoryRefinement	Missing comparable traces, negative examples, source/effect receipts, abstraction contracts, verification, regression clearance, benchmark floor, active SCF, rehearsed rollback, monitoring, residuals, non-claims, acknowledgment, or retirement custody blocks lifecycle progress or routes to quarantine without mutating exact state.	implemented

These Lean hooks are implemented as finite-record predicates plus arbitrary-run identity and nonauthority invariants, exact rejection noninterference, batch composition, absorbing retirement, negative cases, and a closed lifecycle witness over generated-tool records, regression-promotion reviews, and modeled procedure transitions. The exact theorem set covers closure artifacts, failed-regression promotion blocking, routable-transition prerequisites, quarantine on regression failure, and receipt-bound retirement while treating every record field as authored input. The companion synthetic harness makes loop-qualification record discipline executable, but neither Lean nor the harness proves deployed loop detection, invariant abstraction quality, parameter-discovery quality, synthesized tool correctness, monitoring quality, regression quality, or retirement automation.

The exact refinement surface contains twenty-one declarations, and the retained legacy surface contains fourteen bounded negative cases. There are no deployed- system refinement theorems and no theorem establishes trace comparability, causal abstraction, parameter quality, generated-tool correctness, natural usefulness, safe authority, rollback completeness, generalization, or transfer.

51.14 From Repetition to Adjudicated Procedure

Repeated cognition is evidence for a possible reusable procedure, not automatic permission to create one. Before loop closure, the Adaptive Commit Boundary asks whether the pattern is a stable lesson, whether a procedure or tool is the least-commitment sufficient locus, which edge cases require a deliberative fallback, and who may authorize the new behavior.

The resulting procedure remains a realization under a qualification lease. A passed compilation test does not establish that it should become a default, and novelty or contradiction must still reach a maintained slower path. This keeps loop closure from turning local repetition into brittle global habit.

51.15 Source crosswalk

Source ID	Title	Layer	Planned use	Readiness
reflexive_router_whitepaper	The Reflexive Router	pre_deliberative_reflexive_routing_control_plane	Multiple reflex representations, complete trace eligibility, negative-space guard synthesis, differential/shadow qualification, signed promotion, monitored leases, quarantine, and decompilation.	source note available
cognitive_loop_closure	Cognitive Loop Closure	procedural_memory	Repeated cognition should become procedural memory / verified tools.	source note available; local raw cache available
rmi	Ratcheting Modular Intelligence	capability_ratchet	Benchmark pressure, residual escrow, verified modular capability, regression preservation.	source note available; local raw cache available
rgs	Ratcheting Generative Systems	compression_capability_growth	Bridge between active compression, procedural memory, benchmark frontiers, verified AI growth.	source note available; local raw cache available
benchmaxxing	Benchmaxxing: The Performance Ratchet	benchmarks_evidence	Benchmarks as pressure surfaces, saturation -> regression, harder frontier, anti-Goodhart safeguards.	source note available; local raw cache available
talos	Talos Protocol	labor_execution_os	AI labor OS. Deterministic cognitive manufacturing, typed jobs, control planes, auditability, tool isolation.	source note available; local raw cache available
moecot	MoECOT-Agent Architecture Whitepaper	implementation_reference	Concrete implementation evidence: governed low-parameter multi-core runtime, readiness gates, ledgers, replay.	source note available; connector or recovery required
project_theseus_whitepaper	Project Theseus Whitepaper	report_first_rmi_prototype	Local-first report-driven RMI implementation reference: SymLiquid, SparkStream, Octopus Router, residual escrow, self-evolution gates, Hive runtime, observability.	source note available
theseus_self_evolution_system	Theseus Self-Evolution System	recursive_self_improvement_governance	Evidence-first self-evolution lane with intervention ladder, ATTD repo-health gate, guarded teacher self-edit, architecture experiment governance, loop closure, and outcome ledger.	source note available
theseus_operator_os	Hive Operator OS and Work Board	labor_os_operator_surface	Shared command vocabulary, durable SQLite work board, node registry, background/watch/wake contracts, skill registry, tool hooks, feedback routing, and safety-visible operator surface.	source note available
cca_project	Compiled Cognitive Architecture project	compiled_cognitive_architecture	Procedure compilation, durable trace identity, and semantic/procedural memory separation.	source note available
moecot_manifest_project	MoECOT Manifest compiler-era project	compiler_first_ai_systems	Manifest-bound promotion, receipts, rollback, and lifecycle gates.	source note available
beastbrain_project	BeastBrain historical AI system project	durable_semantic_memory_and_system_architecture	Memory-domain boundaries, failed-attempt retention, and procedure lifecycle.	source note available
corbens_trainer_project	Corben’s Trainer epistemic training and evaluation control plane	epistemic_training_and_evaluation_control_plane	Regression evidence, quarantine, effect acknowledgement, and revocable promotion.	source note available
ext_memgpt_2023	MemGPT: Towards LLMs as Operating Systems	memory_management	External comparator for explicit memory tiers and controlled data movement while separating fact memory from procedure qualification.	source note available
ext_toolformer_2023	Toolformer: Language Models Can Teach Themselves to Use Tools	learned_tool_use	External comparator for learning when and how to call tools while separating skill from authority, replay, regression, and evidence.	source note available
ext_voyager_2023	Voyager: An Open-Ended Embodied Agent with Large Language Models	executable_skill_library	Full-paper-derived comparator for curriculum, executable skills, feedback, self-verification, ablations, transfer, costs, and failures.	source note available
ext_dreamcoder_2020	DreamCoder	program_library_learning	External comparator for synthesis, reusable library induction, interpretable abstraction, and later search reduction.	source note available
ext_mem0_2025	Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory	agent_long_term_memory	External comparator for extraction, consolidation, graph linkage, cross-session retrieval, latency, and token-cost pressure while distinguishing conversational memory from procedures.	source note available

The source set covers loop closure, memory tiers, learned tool use, skill and program libraries, ratchets, regressions, and operator-visible governance. All nineteen exact mappings cover the assigned sources at their recorded review depth; reported external performance and historical runtime behavior are not imported. No mapping establishes a working loop-closure pipeline.

51.15.1 Manifest source assignment reconciliation

These rows keep Procedural Memory and Cognitive Loop Closure’s manifest assignments visible at their recorded review boundary. Passage review does not establish local reproduction, performance, safety, deployment, or support-state movement.

Source	Intake role	Boundary
deterministic_capability_compilation	Passage-reviewed Corben architecture source: Deterministic Capability Compilation: A Capability-Preserving Ladder from Executable Scaffolds to Governed Adaptive Agents. Corben-authored July 2026 architecture and research program for compiling executable scaffolds into contract-bound experts and linked Neural Capability Objects while retaining semantic obligation mass balance, candidate-specific translation validation, fallback, residual escrow, authority ceilings, reification, and effect-complete recovery. Existing chapters are upgraded first; no foundry implementation, learned-capability result, preservation result, safety result, SOTA result, AGI, ASI, or support-state promotion is inferred.	No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
platonic_world_model	Metadata-first comparator: The Platonic World Model: A Semantic Constitution for Grounded, Proof-Carrying, Self-Editing Artificial Intelligence. Corben-authored July 2026 conceptual architecture and falsifiable research program for semantic continuity through stable Form lineages, immutable semantic versions, typed Essence Contracts, six mutually constraining planes, explicit proposition-attestation-commitment-proof separation, branch-protected world dynamics, qualified grounding, semantic transactions, runtime packet compilation, and federated mappings. Existing chapters are upgraded first; no implemented substrate, benchmark result, philosophical solution to grounding, safety result, SOTA result, AGI, ASI, or support-state promotion is inferred.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
kernel_english_residual_compiler	Metadata-first comparator: Kernel English with Hierarchical, Interaction-Amortized Residuals: A Dual-Vocabulary Cognitive Compiler for Efficient Language-Model Reasoning. Corben-authored July 2026 architecture proposal for KERC: protected-object capture, uncertainty-aware normalization, sense-aware Kernel IR, dual surface/core vocabularies, a four-level interaction-amortized residual ledger, exact object storage, grammar-aware macro fusion, structured answer packets, rendering, round-trip verification, versioned migration, and complete rate-compute-fidelity evaluation. Existing chapters are upgraded first; no implementation, benchmark, novelty, efficiency, fidelity, safety, transfer, SOTA, AGI, ASI, or support-state result is inferred.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.
relational_dimension_compiler	Passage-reviewed comparator: The Relational Dimension Compiler: Adaptive Polyadic Cognition with Bounded Computational Arity and Unbounded Semantic Structure. Adds a slow-path-to-specialist lifecycle in which repeatedly qualified relation programs become monitored recognizers, indexes, rules, kernels, macro-objects, or specialists while retaining scope, counterexamples, expiry, requalification, rollback, and the original slow route.	No relation program was compiled, no specialist equivalence or cost saving was measured, and no shift detector or rollback path was exercised. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
capability_ratchet_whitepaper	Passage-reviewed comparator: The Capability Ratchet. Full authenticated connector text section-audited. Synthesizes benchmark, procedural, and structural ratchets; benchmark and tool lifecycles; an intervention ladder; interpreter/compiled/reflex runtime modes; total-cost tool compilation; and anti-Goodhart controls. Same-author synthesis, not independent evidence for Benchmaxxing, Cognitive Loop Closure, RGS, or RMI.	No independent benchmark campaign, tool compiler, architecture-selection study, or measured capability improvement. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
regret_engine	Passage-reviewed Corben architecture source: The Regret Engine: Governed Counterfactual Learning Signals for Continual Adaptation, Prospective Risk Control, and Self-Correction in Artificial Agents. Corben-authored August 2026 conceptual architecture and research program for decision-time-fair Governed Counterfactual Regret, immutable Decision Capsules, admissible comparator contracts, sparse Regret Tensors, append-only Regret Packets, prospective regret control, regret-aware replay, regret-to-rule compilation, three update clocks, root-cause adjudication, and bounded update leases. Existing chapters are upgraded first; no implementation, experiment, reproduction, causal-identification result, formal proof, safety result, support transition, SOTA, AGI, or ASI is inferred.	The bibliography and Markdown figure companions were not supplied; the DOCX embeds its visual material. All propositions, algorithms, experiments, and architecture claims remain proposed rather than independently validated. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
ext_hermes_agent_2026	Passage-reviewed comparator: Hermes Agent: Learning, Memory, Tools, and Security Architecture. Supplies a current implementation comparator for progressive-disclosure skills, agent-managed create/patch/edit/delete operations, post-session review, and an optional durable write-approval queue that separates a proposed procedure mutation from its application.	Official software and documentation review only; no learned procedure was replayed, independently tested, promoted, rolled back, or measured for utility, safety, transfer, or regression. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
ext_openclaw_agent_runtime_2026	Passage-reviewed comparator: OpenClaw Gateway, Agent Runtime, ACP, and Self-Learning Architecture. Supplies a current implementation comparator for isolated trajectory review, bounded evidence exposure, one-mutation pending proposals, exact-target hash binding, stale-target rejection, security rescanning, rollback metadata, abstention, and skill lifecycle aging.	Official software and documentation review only; reviewer isolation and proposal controls do not establish procedure correctness, evaluator independence, held-out transfer, safe default routing, or beneficial recursive improvement, and no local result was reproduced. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
assurance_shift_learning	Passage-reviewed comparator: When Success Stops Teaching: Assurance-Shift Learning and Governed Residual Boundary Learning for Mature AI Systems. Adds a route for compiling mature exception families into tests, guards, procedures, tools, and recovery routines while preserving evidence, protected positives, expiry, and reactivation triggers.	No compiler, recurrence reduction, safe consolidation, or efficiency gain was implemented or measured. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
adjudicated_persistence	Passage-reviewed comparator: Adjudicated Persistence: Governing the Transition from Experience to Durable Structure in Adaptive Systems. Adds the prior adjudication step that determines whether a repeated cognitive pattern is eligible to become a procedure or tool.	Conceptual author framework and benchmark proposal; no local implementation, empirical result, independently checked proof, safety result, or support movement. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
forward_transfer_program_synthesis	Passage-reviewed comparator: From Compression to Forward Transfer: Evaluating Reusable Knowledge in Program Synthesis. Adds the verified forward-transfer intervention as the admission test for reusable procedures, with four-value separation, an R0-R7 reuse ladder, frozen knowledge versions, matched controls, and later-round admission.	Framework and experimental blueprint only; no candidate procedure, synthesis benchmark, forward-transfer effect, cost advantage, or support transition was produced. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.

51.16 Summary

Procedural Memory and Cognitive Loop Closure governs the transition from repeated traces to reusable execution structure. It separates memory domains, demands real source and effect receipts, preserves failures, tests comparability, parameters, causal alternatives, regressions, authority, routing, recovery, and retirement, and keeps support and release outside its authority. The current evidence remains one schema, twenty valid-or-mutated record cases across two harnesses, and thirty-five finite declarations—not a working procedure foundry.

The discipline is closure with evidence. A repeated pattern becomes procedural memory only when the stack can state what was learned, where it applies, how it was verified, and when it should stop being used. That is the hinge into Part III: once procedures and specialists exist, the next problem is routing them without hiding residuals or letting capability outrun readiness.

The same discipline returns in Part IV as benchmark ratchets. A procedure that becomes easier to run must also become easier to test, regress, retire, and explain. Otherwise memory increases capability faster than governance can remember why it trusted the capability in the first place.

51.17 Evidence reconciliation (2026-07-16)

The invariant protocol, field meanings, and inference limits are stated once in Living Book Methodology. This packet contains only the chapter-specific projection; its authoritative per-atom rows are the procedural-memory-and-cognitive-loop-closure slice of experiments/claim_family_terminal_coverage/results/result.json.

The core remains blocked after full attempt at argument support. The strongest family attempt was Situated world-model acquisition and consolidation campaign. Its exact boundary is: Bounded finite POMDP result only; no open-world truth, general memory transfer, deployment, or chapter-core promotion. Across 73 atoms, the terminal ledger records 73 blocked_after_full_attempt.

Chapter-specific field	Value
Family / atom denominator	CF-04 / 73 atoms
Terminal dispositions	73 blocked_after_full_attempt
Core	procedural-memory-and-cognitive-loop-closure.core: blocked_after_full_attempt at argument
Core attempted / missing lanes	source-synthesis / causal, empirical, executable, formal, normative, transfer
Attempted local lanes	source-synthesis
Missing or unproved lanes	causal, empirical, executable, formal, normative, transfer
Strongest family bundle	Situated world-model acquisition and consolidation campaign (natural_work_and_end_to_end): Two partially observed environments, 11,250 episodes, 6,000 held-out episodes, six directional ablation signatures, and governed replacement/rollback.
Negative controls	ten arms; six matched ablations; ten laundering mutations; replacement and rollback checks.
Accepted transitions	none
Maximum inference	Bounded finite POMDP result only; no open-world truth, general memory transfer, deployment, or chapter-core promotion.
Reproduction / next burden	Replay scripts/validate_p4_m8_world_model_campaign.py and scripts/validate_claim_family_terminal_program.py; fill the named atom-specific lanes under a new prospective protocol.

51.18 Handoff

Procedural memory completes the planning, memory, reasoning, and execution loop, but verified procedures are not useful by themselves unless the system can choose among them under bounded authority and readiness evidence. Routing Heads and Specialist Cores opens that next layer. It treats tools, procedures, and specialist workers as candidates for governed routing rather than as ambient capabilities available to every task.