research: mechanical depth gate for tranches (issue #409)

The overnight R1 run (epic #375) closed 16 of 31 domains with
reduced-depth batched masters; the quality firewall was self-attested
and bent under controller context pressure. Post-hoc review caught it;
this change makes depth mechanically checkable so the failure class
cannot recur silently.

- scripts/research_gate_check.py: stage-file presence + substance
  floors + adversarial provenance + R0 reconciliation + source
  traceability; R1_FULL / R1_LITE grades, LITE requires registry
  pre-declaration (silent scope reduction = gate drift).
- research_standard.md: five binding rules — mechanical gate,
  breadth-before-depth as the only legal trade, declared grades,
  adversarial independence, depth checkpointing between domains.
- domain_registry.md: stale statuses corrected, P–AE marked R1_LITE
  retroactively, 39 grandfathered findings across 8 pre-gate domains
  recorded (C-cognitive-architectures passes R1_FULL clean as the
  calibration domain).

Version intent: patch (tooling + research governance, no runtime
behavior change). Fixes #409.

.gitea/ISSUE_TEMPLATE/bug.md

@@ -1,16 +1,46 @@
 ---
 name: Bug Fix
-about: Fix a bug or issue
+about: Demonstrate currently incorrect behaviour — plain English first, proof required
 title: "[BUG] "
 labels: bug
 assignees: conductor
 ---
 
-## Plain summary
-<!-- 2-4 sentences, NON-TECHNICAL: what's broken and why it matters. -->
+<restate the issue title here in everyday words — this heading IS the
+plain-English summary; no meta-labels like "plain English" in it>
+<!-- The heading above carries the summary itself — a scan of issue
+     headings alone should tell the whole story of the board. TOP PRIORITY:
+     if a technical detail below contradicts this section, the issue is
+     buggy — fix the issue. -->
+<!-- SUBMITTED_BODY -->
 
-## Example
-<!-- A concrete before/after: "Doing X currently produces Y; it should produce Z." -->
+
+What is broken: <what a person observes going wrong>
+
+What should happen instead: <the correct behaviour>
+
+How often / when: <always | after X | since change Y>
+
+## Proof it is broken (required — no proof, no bug)
+<!-- A bug is DEMONSTRATED currently incorrect behaviour. Nothing else.
+     If this section cannot be filled, file it as a question, not a bug. -->
+- [ ] Reproduction command or steps (deterministic where possible)
+- [ ] The exact wrong output observed: <paste/log excerpt>
+- [ ] Where the evidence lives: <log path, fixture, session id>
+
+## Steps to reproduce
+<!-- How to trigger the bug -->
+
+## What would let us close this
+- [ ] The reproduction command now shows correct behaviour
+- [ ] A regression test exists that fails before the fix and passes after
+- [ ] No other behaviour changed (or changes are listed and justified)
+
+## Version impact (declared at submission — verified at merge)
+<!-- A bug fix is USUALLY a patch. Pick major or minor only with a reason. -->
+- [ ] patch — same behaviour, done correctly (usual for bugs)
+- [ ] major — the bug was in a published contract and fixing it breaks consumers (justify)
+- [ ] minor — fixing revealed a missing capability that had to be added (justify)
 
 ## Technical details
 <!-- WHAT (the bug) / WHERE (files) / EVIDENCE (how it was confirmed). -->
@@ -29,10 +59,6 @@ assignees: conductor
 - [ ] Canary passes (name)
 - [ ] Closed with a properly formatted closing comment + commit references
 
-## Steps to reproduce
-<!-- How to trigger the bug -->
-
-
 ## Cognitive invariants (memory/cognition issues — both handoffs)
 <!-- Complete ONLY if this issue touches memory, learning, or self-model state. -->
 - [ ] **Owner** — which existing subsystem owns this (audit before creating modules)

.gitea/ISSUE_TEMPLATE/feature.md

@@ -1,18 +1,44 @@
 ---
 name: Feature Request
-about: New feature or improvement — DESCRIPTION GATE v4 format (plain summary + pipeline requirements)
+about: New feature or improvement — plain English first, verifiable close conditions, version intent
 title: "[FEATURE] "
 labels: feature
 assignees: conductor
 ---
 
-## Plain summary
-<!-- 2-4 sentences, NON-TECHNICAL: what this does and why it matters. Nick should
-understand the goal without decoding internals. -->
+<restate the issue title here in everyday words — this heading IS the
+plain-English summary; no meta-labels like "plain English" in it>
+<!-- The heading above carries the summary itself — a scan of issue
+     headings alone should tell the whole story of the board. TOP PRIORITY:
+     if a technical detail below contradicts this section, the issue is
+     buggy — fix the issue. A non-technical reader must be able to retell this
+     section. 3-6 sentences, no jargon. -->
+<!-- SUBMITTED_BODY -->
+
+
+What is this about: <what>
+
+Why do we need it: <the itch — what happens today that shouldn't, or what becomes possible>
+
+Why is it still open: <"not started yet" | "part done, X remains" | "deliberately parked as a future idea">
 
 ## Example
-<!-- A concrete example of the intended behavior, in plain terms:
-"If X happens, the system will Y instead of Z." -->
+<!-- A concrete before/after in plain terms: "If X happens, the system will Y instead of Z." -->
+
+## What would let us close this
+<!-- Checkable statements, verifiable by looking at something that EXISTS —
+     a file, a log line, a passing test. Not "when appropriate". -->
+- [ ] <condition 1 — observable>
+- [ ] <condition 2>
+
+## Version impact (declared at submission — verified at merge)
+<!-- The pipeline derives the real bump from merged conventional commits and
+     compares against this declaration. A mismatch is flagged, not fatal:
+     either the declaration was wrong or the work grew. Both facts matter. -->
+- [ ] major — breaking: changes a contract, schema, or interface others depend on
+- [ ] minor — new capability: something becomes possible that wasn't
+- [ ] patch — repair: same behaviour, done correctly
+- [ ] none — touches no released artifact (docs, memory, process notes)
 
 ## Technical details
 <!-- WHAT — one-line objective.
@@ -37,7 +63,6 @@ DEPENDENCIES — parent epic + preceding stage/plan refs. -->
 - [ ] Canary passes (name)
 - [ ] Closed with a properly formatted closing comment + commit/PR references
 
-
 ## Cognitive invariants (memory/cognition issues — both handoffs)
 <!-- Complete ONLY if this issue touches memory, learning, or self-model state. -->
 - [ ] **Owner** — which existing subsystem owns this (audit before creating modules)
@@ -69,4 +94,4 @@ Hard invariants: derived cognition preserves evidentiary ancestry · epistemic c
 - [ ] **P0 — critical** — breaks the spine / core correctness, or blocks other work
 - [ ] **P1 — high** — material user value or a real defect (money, correctness bugs, next-stage dependency)
 - [ ] **P2 — medium** — quality/consolidation improvement (check the fold-into mapping first)
-- [ ] **P3 — low** — measurement / benchmark / deferred policy
+- [ ] **P3 — low** — measurement / benchmark / deferred policy

.gitea/ISSUE_TEMPLATE/research.md

@@ -0,0 +1,76 @@
+---
+name: Research Submission
+about: Buy down uncertainty before building — question, falsifier, budget, durable findings
+title: "[RESEARCH] "
+labels: research
+assignees: conductor
+---
+
+<restate the issue title here in everyday words — this heading IS the
+plain-English summary; no meta-labels like "plain English" in it>
+<!-- The heading above carries the summary itself — a scan of issue
+     headings alone should tell the whole story of the board. TOP PRIORITY:
+     if a technical detail below contradicts this section, the issue is
+     buggy — fix the issue. -->
+<!-- SUBMITTED_BODY -->
+
+
+The question: <what we're trying to learn, one sentence>
+
+Why we're asking: <what decision this research will inform — a name, an issue
+number, or "exploratory: none yet">
+
+What we believe today: <the current assumption, stated so it can be proven wrong>
+
+## The shape of an answer
+- [ ] What evidence would settle the question: <observation, benchmark, or spike>
+- [ ] What evidence would KILL the current assumption (the falsifier): <be specific —
+      this is stated BEFORE starting so the research cannot become a search for confirmation>
+- [ ] Budget: <time/effort cap — when research must stop and report back>
+
+## What would let us close this
+- [ ] Findings written to a durable document: <path, e.g. research/issue-NNN/> —
+      a comment thread is not a durable finding
+- [ ] The decision the research informs is recorded: made / deferred / changed
+- [ ] If a follow-up build issue was minted: <#N or "none needed">
+
+## Version impact (declared at submission — verified at merge)
+- [ ] none — research changes no released artifact (usual)
+- [ ] minor/major — only if a code spike is being merged as part of this (justify)
+
+## Technical detail
+<!-- Candidate approaches, prior art in the repo, related issues, constraints,
+     rebuildable-projection or authority requirements if findings touch canonical state. -->
+
+## Pipeline requirements
+- [ ] Findings committed under the stated durable path
+- [ ] Every citation verified against a real source (no fabricated references)
+- [ ] Closed with a properly formatted closing comment: findings summary + decision
+
+## Cognitive invariants (memory/cognition research — both handoffs)
+<!-- Complete ONLY if findings touch memory, learning, or self-model state. -->
+- [ ] **Owner** — which existing subsystem owns this (audit before proposing modules)
+- [ ] **Read/write authority** — which canonical state is affected
+- [ ] **Provenance** — findings traceable to evidence
+- [ ] **Reversibility** — projections remain rebuildable; no unique truth moves into a derived index
+- [ ] **No duplicate authority** — why extend vs create
+
+Hard invariants: derived cognition preserves evidentiary ancestry · retrieval never increases utility · raw evidence is never destroyed by promotion.
+
+## Related umbrella
+- [ ] Memory
+- [ ] Governance
+- [ ] Identity
+- [ ] Growth
+- [ ] Perception
+- [ ] Infrastructure
+- [ ] Life (Nick's)
+- [ ] Custodian
+- [ ] Orchestration
+
+## Priority (REQUIRED — the priority gate)
+<!-- Pick exactly one. An issue without a priority is not filed. -->
+- [ ] **P0 — critical** — blocks a decision that blocks other work
+- [ ] **P1 — high** — informs a next-stage dependency
+- [ ] **P2 — medium** — quality/consolidation understanding
+- [ ] **P3 — low** — watchlist / deferred / exploratory

.gitea/workflows/auto-label.yml

@@ -58,9 +58,38 @@ jobs:
             const managedLabels = new Set([
               'memory', 'governance', 'identity', 'growth',
               'perception', 'infrastructure', 'life', 'custodian',
-              'priority: high', 'bug', 'feature',
+              'priority: high', 'bug', 'feature', 'research',
             ]);
 
+            // Type label: DECLARED over GUESSED. The template spine
+            // (kind: bug|feature|research|epic|...) is authoritative.
+            // A recognized kind maps to its label; ANY other declared kind
+            // (e.g. epic) means NO type label and NO keyword guessing —
+            // epics are containers, not bugs. Keyword heuristics apply
+            // only to pre-template issues with no spine at all.
+            let isBug = false, isFeature = false, isResearch = false;
+            const kindMatch = body && body.match(/^kind:\s*([a-z_-]+)\s*$/m);
+            if (kindMatch) {
+              const kind = kindMatch[1];
+              isBug = kind === 'bug';
+              isFeature = kind === 'feature';
+              isResearch = kind === 'research';
+            } else {
+              const textBug = title.startsWith('[BUG]') || text.includes('bug') || text.includes('fix') || text.includes('broken');
+              isBug = textBug;
+              isFeature = !isBug && (title.startsWith('[FEATURE]') || text.includes('feature') || text.includes('improve') || text.includes('add'));
+              isResearch = !isBug && !isFeature && title.startsWith('[RESEARCH]');
+            }
+            if (isBug) {
+              desiredLabels.add('bug');
+            }
+            if (isFeature) {
+              desiredLabels.add('feature');
+            }
+            if (isResearch) {
+              desiredLabels.add('research');
+            }
+
             // Umbrella labels
             if (text.includes('memory') || text.includes('store') || text.includes('recall') || text.includes('consolidat')) {
               desiredLabels.add('memory');
@@ -92,16 +121,6 @@ jobs:
               desiredLabels.add('priority: high');
             }
 
-            // Type labels
-            const isBug = title.startsWith('[BUG]') || text.includes('bug') || text.includes('fix') || text.includes('broken');
-            const isFeature = !isBug && (title.startsWith('[FEATURE]') || text.includes('feature') || text.includes('improve') || text.includes('add'));
-            if (isBug) {
-              desiredLabels.add('bug');
-            }
-            if (isFeature) {
-              desiredLabels.add('feature');
-            }
-
             const issueNumber = context.payload.issue?.number || context.payload.pull_request?.number;
             const current = await github.rest.issues.listLabelsOnIssue({
               owner: context.repo.owner,

AGENTS.md

@@ -58,3 +58,26 @@ fix, full pipeline re-entry (suite + ratchet + ruff + canaries + henxels;
 gates for anything beyond a mechanical minor), regression tests frozen forever,
 discharge recorded finding → test → commit. Symptom patches are rejected at
 review. To escape: edit `henxels.yaml` or this file — visibly.
+
+## Issue organisation standard (binding, 2026-09-19)
+
+One open note per idea. Issues use the template spine (kind, subsystem,
+version intent) with a plain-English heading that restates the subject —
+no meta-labels. Before minting a standalone issue, check whether the work
+belongs inside an existing parent:
+
+- **Parked ideas under a blocked/future epic** are filed as checklist items
+  in the parent's "Absorbed children" section, NOT as standalone issues.
+  Absorption is reversible — re-mint standalone when the idea becomes live.
+- **Live, dependency-tracked, or starting work** gets a standalone issue.
+- **Closures state the reason as data**: `closed_because` in the spine
+  (completed / superseded-by-#N / absorbed-into-#N / wont-do / duplicate),
+  plus a standard closing comment (plain summary first).
+- The reconciliation checker (`scripts/gitea_reconciliation_check.py`) must
+  stay green after any issue state change; the artifact is updated in the
+  same change that moves issues.
+
+## Async continuation final flow proofs (R13/M9) — 2026-09-19
+
+PR-flow live proof marker: harmless documentation addition exercising the
+canonical single-continuation path on the PC-local forge. No code change.

README.md

@@ -1,6 +1,6 @@
 # Rune
 
-**Current release: v0.66.71**
+**Current release: v0.87.5**
 
 **Rune is a persistent personal agent designed to accumulate experience, develop reusable competence, and remain recognisably the same agent even when its underlying foundation model changes.**
 

bridge/daemon/completion_file.py

@@ -0,0 +1,196 @@
+"""completion_file.py — REAL_ASYNC_BRIDGE: durable completion-file delivery
+with inotify wake. Replaces FIFO+lease for process-wait delivery.
+
+DESIGN:
+  Producer (bridge/daemon/notify):
+    1. Validates operation identity
+    2. Atomically writes a completion file:
+         resumes/<operation_id>.done
+       containing the event/verdict JSON (write to tmp, rename for atomicity)
+
+  Waiter (ci_event_wait / any continuation consumer):
+    1. Checks if the completion file already exists (event-before-waiter)
+    2. If not: registers inotify watch on the resumes/ directory
+    3. Re-checks after watch registration (closes the registration race)
+    4. Blocks in kernel on inotify — zero CPU, zero timer
+    5. On file-created event: reads the file, verifies authority, returns
+
+  The event is a WAKE SIGNAL. Authority still decides terminal truth.
+  The completion file is durable — survives daemon and waiter restarts.
+
+WHY NOT FIFO:
+  FIFO is one-shot (token consumed), requires lease management, and
+  fails under session-busy guards. A completion file is atomic, durable,
+  and works across restarts. inotify wakes the process with zero CPU
+  cost and zero latency between file creation and wake.
+
+WHY NOT POLLING:
+  Polling introduces an arbitrary interval. inotify is a kernel callback
+  that fires exactly when the filesystem changes — the latency tracks
+  the real completion event, not a configured interval.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import select
+import struct
+import time
+from pathlib import Path
+
+
+def _wr_bridge() -> Path:
+    # WR_ROOT = daemon/infra convention; RUNE_WR_ROOT = repo/scripts
+    # convention. Both honored (WR_ROOT wins) so the daemon, the waiter,
+    # and any isolated test root always resolve the SAME directory.
+    root = os.environ.get("WR_ROOT") or os.environ.get("RUNE_WR_ROOT") or "/mnt/workdrive/wr-bridge"
+    return Path(root)
+
+
+def _resumes_dir() -> Path:
+    return _wr_bridge() / "resumes"
+
+
+# inotify constants (Linux)
+IN_CREATE = 0x100
+IN_CLOSE_WRITE = 0x8
+IN_MOVED_TO = 0x80
+
+
+def completion_path(operation_id: str) -> Path:
+    return _resumes_dir() / f"{operation_id}.done"
+
+
+def write_completion(operation_id: str, event: dict) -> Path:
+    """Atomically write a durable completion file. The rename(2) ensures
+    the waiter never sees a partial file."""
+    _resumes_dir().mkdir(parents=True, exist_ok=True)
+    target = completion_path(operation_id)
+    tmp = target.parent / f".{target.name}.tmp.{os.getpid()}"
+    tmp.write_text(json.dumps(event, sort_keys=True) + "\n")
+    os.rename(str(tmp), str(target))  # atomic on same filesystem
+    os.chmod(str(target), 0o666)  # cross-user bridge
+    return target
+
+
+def read_completion(operation_id: str) -> dict | None:
+    """Read a durable completion file. Returns None if absent."""
+    p = completion_path(operation_id)
+    if not p.is_file():
+        return None
+    try:
+        return json.loads(p.read_text())
+    except (OSError, ValueError):
+        return None
+
+
+def completion_exists(operation_id: str) -> bool:
+    return completion_path(operation_id).is_file()
+
+
+def _inotify_init_and_add_watch(directory: str) -> int:
+    """Create an inotify instance and add a watch on the directory.
+    Returns the inotify fd."""
+    libc = __import__("ctypes").CDLL(None, use_errno=True)
+    fd = libc.inotify_init()
+    if fd < 0:
+        raise OSError("inotify_init failed")
+    # IN_CREATE | IN_MOVED_TO: catch both direct creation and atomic rename
+    mask = IN_CREATE | IN_MOVED_TO
+    wd = libc.inotify_add_watch(fd, directory.encode(), mask)
+    if wd < 0:
+        os.close(fd)
+        raise OSError(f"inotify_add_watch failed for {directory}")
+    return fd
+
+
+def _inotify_read(fd: int, timeout_secs: float | None = None) -> list[str]:
+    """Read pending inotify events. Returns list of filenames that were
+    created/moved-to. Blocks until at least one event or timeout."""
+    poll = select.poll()
+    poll.register(fd, select.POLLIN)
+    events = []
+    buf = os.read(fd, 4096)
+    pos = 0
+    while pos < len(buf):
+        # struct: wd(i32), mask(u32), cookie(u32), name_len(u32)
+        wd, mask, cookie, name_len = struct.unpack_from("iIII", buf, pos)
+        pos += 16
+        name = buf[pos : pos + name_len].rstrip(b"\x00").decode("utf-8", "replace")
+        pos += name_len
+        if mask & (IN_CREATE | IN_MOVED_TO):
+            events.append(name)
+    return events
+
+
+def wait_for_completion(operation_id: str, *, timeout_secs: float | None = None, poll_callback=None) -> dict | None:
+    """Block until a completion file exists for this operation.
+
+    Uses inotify for zero-latency, zero-CPU wake. Falls back to
+    polling_callback (if provided) when inotify is unavailable.
+
+    The completion file is a WAKE SIGNAL. The caller must still verify
+    canonical authority after reading it.
+
+    Returns the event dict from the completion file, or None on timeout.
+    """
+    target = completion_path(operation_id)
+
+    # 1. check-before-watch (event may have arrived before we started)
+    existing = read_completion(operation_id)
+    if existing is not None:
+        return existing
+
+    _resumes_dir().mkdir(parents=True, exist_ok=True)
+
+    try:
+        fd = _inotify_init_and_add_watch(str(_resumes_dir()))
+    except OSError:
+        # inotify unavailable: fall back to polling callback
+        if poll_callback:
+            return poll_callback(operation_id, timeout_secs)
+        return None
+
+    try:
+        # 2. re-check after watch registration (closes the race between
+        #    the initial check and the watch being active)
+        existing = read_completion(operation_id)
+        if existing is not None:
+            return existing
+
+        # 3. block in kernel on inotify — zero CPU, exact latency
+        import select as _select
+
+        poll = _select.poll()
+        poll.register(fd, _select.POLLIN)
+        deadline = (time.monotonic() + timeout_secs) if timeout_secs else None
+
+        while True:
+            remaining = None
+            if deadline is not None:
+                remaining = max(0.1, deadline - time.monotonic())
+                if remaining <= 0.1:
+                    return None  # timeout
+            events = poll.poll(remaining * 1000 if remaining else None)
+            if not events:
+                continue  # poll timeout, re-check
+            names = _inotify_read(fd)
+            if target.name in names:
+                # 4. file appeared — read it
+                existing = read_completion(operation_id)
+                if existing is not None:
+                    return existing
+                # partial/corrupt: keep watching
+    finally:
+        os.close(fd)
+    return None
+
+
+def clear_completion(operation_id: str) -> None:
+    """Remove a consumed completion file (idempotent cleanup)."""
+    p = completion_path(operation_id)
+    try:
+        p.unlink()
+    except OSError:
+        pass

bridge/daemon/daemon.py

@@ -0,0 +1,799 @@
+#!/usr/bin/env python3
+"""daemon.py — Gitea webhook receiver + reconciliation + resume driver (v0.2).
+
+W/R-v0.2 invariants implemented here:
+  A. SINGLE-FLIGHT PER SESSION — per-session lease (waitstore.acquire_lease,
+     /proc-validated, atomic) + in-process inflight set. A second READY wait
+     for the same session stays queued until the lease releases.
+  B. BUSY SESSION PROTECTION — before spawning, /proc is scanned for a live
+     `mimo run -s <sid>`-shaped process not owned by our lease. Found → skip
+     launch (wait stays READY). No invented MiMo APIs; the lease is the
+     conservative floor against W/R-created concurrency.
+  C. ATOMIC SESSION LEASE — persisted {session_id, wait_id, pid, pgid,
+     pid_starttime, acquired_at, state}; O_EXCL create, steal only on /proc
+     evidence of a dead owner.
+  D. PROCESS TREE OWNERSHIP — workers spawn with start_new_session=True (own
+     process group). Watch timeout ⇒ SIGTERM group → bounded grace → SIGKILL
+     group → verify zero surviving group members → release lease → truthful
+     READY_TO_RETRY (never terminal-on-timeout).
+  E. TIMEOUT IS NOT SUCCESS — rc==0 maps to verdict terminal
+     (COMPLETED/FAILED); rc!=0 or unverifiable ⇒ RESUME_UNVERIFIED
+     (not schedulable, operator-requeueable); timeout ⇒ READY_TO_RETRY.
+  F. STALE RESUMING RECOVERY — on startup, every RESUMING record is
+     inspected: live lease owner ⇒ adopted and monitored; otherwise ⇒
+     RESUME_UNVERIFIED (+ stale lease released). Never auto-relaunched.
+  G. MULTIPLE WAITS, SAME SESSION — schedulable() orders oldest-first; one
+     continuation finishes before the next starts.
+  H. PIDFILE CORRECTNESS — singleton enforced by flock on daemon.pid; the
+     lock dies with the process, so stale pidfiles (incl. SIGKILL) cannot
+     admit a second daemon.
+
+The resume command is configurable (WR_RESUME_CMD, JSON list with
+{session_id}/{msg} placeholders) so the test harness can use a stub; the
+default is the real mechanism: `mimo run -s <sid> -m <model> <msg>`.
+"""
+
+from __future__ import annotations
+import fcntl, json, os, signal, subprocess, sys, threading, time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+import waitstore
+import verify
+import completion_file  # REAL_ASYNC_BRIDGE R3: durable completion-file delivery
+
+RESUME_MODEL = "Verboo Code/glm-5.3-flash"
+RECONCILE_SECS = int(os.environ.get("WR_RECONCILE_SECS", "60"))
+RECONCILE_EVERY_TICKS = max(1, int(os.environ.get("WR_RECONCILE_TICKS", "3")))
+WAKE_MIN_AGE_SECS = float(os.environ.get("WR_WAKE_MIN_AGE_SECS", "5"))
+WAKE_RETRIES = int(os.environ.get("WR_WAKE_RETRIES", "3"))
+WAKE_RETRY_SECS = float(os.environ.get("WR_WAKE_RETRY_SECS", "4"))
+DRIVE_LOOP_SECS = int(os.environ.get("WR_DRIVE_SECS", "20"))
+# REAL_ASYNC_BRIDGE §4: a RESUMING wait older than this grace without
+# progress is an orphaned resume flow (thread died between lease acquire
+# and release). Must exceed the longest legitimate in-flight watch
+# (WATCH_SECS); default 3x. Env-overridable for deterministic tests.
+WATCH_SECS = int(os.environ.get("WR_WATCH_SECS", "600"))
+# REAL_ASYNC_BRIDGE §4: a RESUMING wait older than this grace without
+# progress is an orphaned resume flow (thread died between lease acquire
+# and release). Must exceed the longest legitimate in-flight watch
+# (WATCH_SECS); default 3x. Env-overridable for deterministic tests.
+ORPHAN_GRACE_SECS = int(os.environ.get("WR_ORPHAN_GRACE_SECS", str(3 * WATCH_SECS)))
+TERM_GRACE_SECS = int(os.environ.get("WR_TERM_GRACE_SECS", "10"))
+MAX_ATTEMPTS = int(os.environ.get("WR_MAX_ATTEMPTS", "3"))
+_WR_ROOT = Path(os.environ.get("WR_ROOT", "") or Path(__file__).resolve().parent)
+PIDFILE = _WR_ROOT / "daemon.pid"
+LOG = _WR_ROOT / "daemon.log"
+
+DEFAULT_RESUME_CMD = ["mimo", "run", "-s", "{session_id}", "-m", RESUME_MODEL, "{msg}"]
+
+
+def log(msg: str) -> None:
+    with open(LOG, "a") as f:
+        f.write(f"{time.strftime('%H:%M:%S')} {msg}\n")
+
+
+def resume_cmd(session_id: str, msg: str, wait_id: str = "", override: list | None = None) -> list[str]:
+    """T15 §15D: per-wait override wins; placeholders {session_id}/{msg}/
+    {wait_id}. A synthetic controller session (Scaffolding stage driver)
+    is not a MiMo session — the global default cannot resume it, which is
+    exactly why fixed-sleep polling crept back into T12-T14."""
+    if override:
+        return [
+            c.replace("{session_id}", session_id).replace("{msg}", msg).replace("{wait_id}", wait_id) for c in override
+        ]
+    tmpl = os.environ.get("WR_RESUME_CMD")
+    cmd = json.loads(tmpl) if tmpl else DEFAULT_RESUME_CMD
+    return [c.replace("{session_id}", session_id).replace("{msg}", msg).replace("{wait_id}", wait_id) for c in cmd]
+
+
+# ── process-tree evidence & ownership ─────────────────────────────────────
+
+
+def pgid_members(pgid: int) -> list[int]:
+    out = []
+    for d in Path("/proc").iterdir():
+        if not d.name.isdigit():
+            continue
+        try:
+            stat = (d / "stat").read_text()
+            fields = stat.rsplit(")", 1)[1].split()
+            # zombies: killed but not yet reaped. Counting them makes the
+            # survivor check report the direct child we just KILLed before
+            # communicate() reaps it (observed live 2026-09-12).
+            if fields[0] == "Z":
+                continue
+            if int(fields[2]) == pgid:
+                out.append(int(d.name))
+        except (OSError, IndexError, ValueError):
+            continue
+    return out
+
+
+def terminate_tree(pgid: int) -> list[int]:
+    """TERM → bounded grace → KILL. Returns surviving members (must be [])."""
+    try:
+        os.killpg(pgid, signal.SIGTERM)
+    except ProcessLookupError:
+        pass
+    deadline = time.time() + TERM_GRACE_SECS
+    while time.time() < deadline:
+        if not pgid_members(pgid):
+            return []
+        time.sleep(0.2)
+    try:
+        os.killpg(pgid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
+    for _ in range(50):  # up to 10s for KILL to land
+        if not pgid_members(pgid):
+            return []
+        time.sleep(0.2)
+    return pgid_members(pgid)
+
+
+def stray_worker_pids(session_id: str, exclude_pgids: set[int] = ()) -> list[int]:
+    """Live `mimo run -s <sid>`-shaped processes not owned by our workers."""
+    out = []
+    for d in Path("/proc").iterdir():
+        if not d.name.isdigit():
+            continue
+        try:
+            parts = [p.decode(errors="replace") for p in (d / "cmdline").read_bytes().split(b"\0") if p]
+        except OSError:
+            continue
+        if not parts:
+            continue
+        joined = " ".join(parts)
+        if session_id not in joined or "-s" not in parts:
+            continue
+        if "mimo" not in joined.lower() and "@mimo-ai" not in joined.lower():
+            continue
+        try:
+            if os.getpgid(int(d.name)) in exclude_pgids:
+                continue
+        except OSError:
+            continue
+        out.append(int(d.name))
+    return out
+
+
+# ── verification → transition (unchanged authority model) ─────────────────
+
+
+def _authoritative_verify(rec: dict) -> tuple[str, dict]:
+    """Authoritative verification with a deterministic test seam.
+
+    Production (WR_VERIFY_STUB unset): real Gitea API via verify.py — the
+    ONLY source of success/failure truth. Test (WR_VERIFY_STUB=path to
+    JSON {"<run_ref-or-sha>": verdict, "default": verdict}): stubbed
+    verdicts so invariant tests never touch the network. The stub is a
+    test fixture, not an alternate authority — no production path sets it.
+    """
+    stub_path = os.environ.get("WR_VERIFY_STUB", "")
+    if stub_path:
+        try:
+            spec = json.loads(Path(stub_path).read_text())
+        except Exception:
+            return "pending", {"stub_error": "unreadable stub"}
+        key = str(rec.get("run_ref", "") or rec.get("sha", ""))
+        verdict = spec.get(key, spec.get("default", "pending"))
+        return verdict, {"stub": True, "key": key}
+    import verify
+
+    if rec.get("wait_kind") == "RELEASE_DEPLOY":
+        return verify.verify_release_deploy(rec.get("sha", ""), rec.get("repo_root", ""), rec.get("deployed_link", ""))
+    return verify.verify_run(rec.get("run_ref", ""), rec.get("sha", ""), rec.get("expected", "success"))
+
+
+def try_transition(rec: dict, event: dict | None = None) -> dict:
+    if rec["status"] != "WAITING_EXTERNAL":
+        return rec
+    if rec.get("wait_kind") == "PROCESS_EVENT":
+        # T15 §15D: the matching event IS the authority. The notifier
+        # wrapper observed the real process exit; exit_code decides the
+        # verdict. No Gitea lookup applies. A duplicate event never
+        # reaches here (match applies only to WAITING_EXTERNAL waits).
+        if not event:
+            return rec  # no event → nothing authoritative happened
+        try:
+            exit_code = int(event.get("exit_code"))
+        except (TypeError, ValueError):
+            exit_code = None
+        if exit_code is None:
+            return rec  # malformed event: stay WAITING (15E hostile case)
+        verdict = "success" if exit_code == 0 else "failure"
+        evidence = {"process_event": True, "exit_code": exit_code, "operation_id": event.get("run_ref", "")}
+        log(f"verify {rec['wait_id']}: {verdict} {json.dumps(evidence)[:120]}")
+        rec["status"] = "READY_TO_RESUME"
+        rec["verdict"] = verdict
+        if verdict == "failure":
+            rec["failure_evidence"] = evidence
+        rec["process_event_evidence"] = evidence
+        waitstore.save(rec)
+        return rec
+    verdict, evidence = _authoritative_verify(rec)
+    log(f"verify {rec['wait_id']}: {verdict} {json.dumps(evidence)[:120]}")
+    if verdict == "success":
+        rec["status"] = "READY_TO_RESUME"
+        rec["verdict"] = "success"
+    elif verdict == "failure":
+        rec["status"] = "READY_TO_RESUME"
+        rec["verdict"] = "failure"
+        rec["failure_evidence"] = verify.failed_job_evidence(rec.get("run_ref", ""))
+    else:
+        return rec  # pending/unknown → stay WAITING
+    waitstore.save(rec)
+    return rec
+
+
+def continuation_msg(rec: dict) -> str:
+    c = rec["continuation"]
+    if rec.get("verdict") == "success":
+        return (
+            f"External wait satisfied (wait {rec['wait_id']}).\n"
+            f"Original objective: {c.get('objective', '')}\n"
+            f"Waited for: {c.get('waited_for', '')}\n"
+            f"Authoritative result: workflow success verified via Gitea API.\n"
+            f"SHA/run: {rec.get('sha', '')}/{rec.get('run_ref', '')}\n"
+            f"Verify: {c.get('verify_when_woken', '')}\n"
+            f"Continue from: {c.get('on_success', '')}"
+        )
+    ev = json.dumps(rec.get("failure_evidence", {}))[:400]
+    return (
+        f"External wait finished with FAILURE (wait {rec['wait_id']}).\n"
+        f"Original objective: {c.get('objective', '')}\n"
+        f"Authoritative result: workflow FAILURE verified via Gitea API.\n"
+        f"Failed job evidence: {ev}\n"
+        f"SHA/run: {rec.get('sha', '')}/{rec.get('run_ref', '')}\n"
+        f"Do NOT treat this as success. Continue from: {c.get('on_failure', '')}"
+    )
+
+
+# ── resume driver (single-flight, tree-owned) ─────────────────────────────
+
+
+def resume(rec: dict) -> None:
+    """Run one continuation to completion. Runs on a dedicated worker thread.
+    Preconditions: caller verified no inflight worker for this session."""
+    sid, wid = rec["session_id"], rec["wait_id"]
+    # REAL_ASYNC_BRIDGE §2 invariant: a successful authority-verified
+    # operation completion must NEVER be overwritten or downgraded by a
+    # legacy session/FIFO delivery failure. Terminal operation state
+    # (COMPLETED/FAILED — stamped by the waiter's own authority
+    # verification) is owned by the OPERATION domain; this function owns
+    # only SESSION-DELIVERY. Re-read from disk: the in-memory copy may be
+    # stale relative to the waiter's terminal stamp.
+    fresh = waitstore.load(wid)
+    if fresh and fresh.get("status") in waitstore.TERMINAL:
+        log(
+            f"resume {wid}: skipped — operation already terminal "
+            f"({fresh['status']}); delivery worker never overrides "
+            f"operation truth"
+        )
+        return
+    rec = fresh or rec
+    msg = continuation_msg(rec)
+
+    # B: busy-session guard before touching the lease
+    strays = stray_worker_pids(sid)
+    if strays:
+        rec["status"] = "READY_TO_RESUME"
+        rec["resume_note"] = f"queued: target session busy (stray pids {strays})"
+        waitstore.save(rec)
+        log(f"queued {wid}: session busy {strays}")
+        return
+
+    # pre-register the lease owner as THIS daemon so acquisition is atomic
+    lease = waitstore.acquire_lease(sid, wid, os.getpid(), os.getpid())
+    if lease is None:
+        live = waitstore.read_lease(sid)
+        rec["status"] = "READY_TO_RESUME"
+        rec["resume_note"] = f"queued: lease held by wait {live and live.get('wait_id')}"
+        waitstore.save(rec)
+        log(f"queued {wid}: lease held")
+        return
+
+    rec["status"] = "RESUMING"
+    rec["resume_attempts"] = rec.get("resume_attempts", 0) + 1
+    waitstore.save(rec)
+
+    try:
+        proc = subprocess.Popen(
+            resume_cmd(sid, msg, wid, rec.get("resume_cmd")),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            start_new_session=True,
+        )
+    except Exception as e:
+        waitstore.release_lease(sid, wid)
+        rec["status"] = "READY_TO_RETRY"  # spawn failed pre-delivery → retryable
+        rec["resume_note"] = f"spawn failed: {e}"
+        waitstore.save(rec)
+        log(f"spawn {wid} failed pre-delivery: {e}")
+        return
+
+    pgid = proc.pid  # start_new_session ⇒ pgid == child pid
+    waitstore.update_lease(sid, wait_id=wid, pid=proc.pid, pgid=pgid, pid_starttime=waitstore._pid_starttime(proc.pid))
+    log(f"launched {wid}: pid={proc.pid} pgid={pgid} attempt={rec['resume_attempts']}")
+
+    timed_out = False
+    try:
+        stdout, stderr = proc.communicate(timeout=WATCH_SECS)
+        rc = proc.returncode
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        survivors = terminate_tree(pgid)
+        try:
+            stdout, stderr = proc.communicate(timeout=30)
+        except Exception:
+            stdout, stderr = "", ""
+        rc = proc.returncode
+        if survivors:
+            log(f"ERROR {wid}: group {pgid} survivors after KILL: {survivors}")
+
+    waitstore.release_lease(sid, wid)
+
+    if timed_out:
+        # D+E: timeout is NOT success. Tree terminated; retry truthfully.
+        if rec["resume_attempts"] >= MAX_ATTEMPTS:
+            rec["status"] = "RESUME_UNVERIFIED"
+            rec["resume_note"] = (
+                f"watch timeout x{rec['resume_attempts']}; process group {pgid} terminated; attempts exhausted"
+            )
+        else:
+            rec["status"] = "READY_TO_RETRY"
+            rec["resume_note"] = f"watch timeout; process group {pgid} terminated (TERM→KILL, verified); will retry"
+        log(f"timeout {wid}: tree {pgid} terminated, rc={rc}")
+    elif rc == 0:
+        # COMPLETION TRUTH (constraint 4): rc==0 means the headless worker
+        # EXITED CLEANLY — the strongest terminal evidence the supported CLI
+        # provides. Timeout/cancel can never reach this branch. The evidence
+        # chain (rc, output tail, timing) is recorded on the wait record.
+        terminal = "COMPLETED" if rec.get("verdict") == "success" else "FAILED"
+        rec["status"] = terminal
+        rec["resume_evidence"] = {
+            "kind": "worker_exited_rc0",
+            "rc": 0,
+            "output_tail": (stdout or "")[-400:],
+            "finished_at": waitstore.now(),
+        }
+        log(f"resumed {wid}: rc=0 → {terminal}")
+    else:
+        # Nonzero rc: delivery/completion unproven. Honest, not schedulable.
+        rec["status"] = "RESUME_UNVERIFIED"
+        rec["resume_evidence"] = {
+            "kind": "worker_exited_nonzero",
+            "rc": rc,
+            "output_tail": ((stdout or "") + (stderr or ""))[-400:],
+            "finished_at": waitstore.now(),
+        }
+        rec["resume_note"] = f"resume rc={rc}; delivery unverified"
+        log(f"resumed {wid}: rc={rc} → RESUME_UNVERIFIED")
+    waitstore.save(rec)
+
+
+# ── startup recovery (invariant F) ────────────────────────────────────────
+
+
+def startup_recovery() -> None:
+    for rec in waitstore.all_waits():
+        if rec.get("status") != "RESUMING":
+            continue
+        sid, wid = rec["session_id"], rec["wait_id"]
+        lease = waitstore.read_lease(sid)
+        if lease and lease.get("wait_id") == wid and waitstore._owner_alive(lease):
+            # Adopt the live worker and monitor it to a bounded conclusion.
+            pgid = lease["pgid"]
+            log(f"recover {wid}: adopted live worker pgid={pgid}")
+            deadline = time.time() + WATCH_SECS
+            while time.time() < deadline and pgid_members(pgid):
+                time.sleep(2)
+            survivors = terminate_tree(pgid) if pgid_members(pgid) else []
+            waitstore.release_lease(sid, wid)
+            rec["status"] = "RESUME_UNVERIFIED"
+            rec["resume_note"] = "adopted post-restart; outcome unverifiable" + (
+                f"; survivors killed: {survivors}" if survivors else ""
+            )
+            waitstore.save(rec)
+            log(f"recover {wid}: adopted worker ended → RESUME_UNVERIFIED")
+        else:
+            if lease:
+                waitstore.release_lease(sid, wid)  # stale
+            rec["status"] = "RESUME_UNVERIFIED"
+            rec["resume_note"] = "recovered at daemon startup: no live owner; delivery unverifiable"
+            waitstore.save(rec)
+            log(f"recover {wid}: no live owner → RESUME_UNVERIFIED")
+
+
+# ── reconciler + drive loop (invariant G: deterministic queue) ────────────
+
+_inflight: dict[str, threading.Thread] = {}
+_inflight_lock = threading.Lock()
+
+
+def drive_ready() -> None:
+    for rec in waitstore.schedulable():
+        sid = rec["session_id"]
+        # CONTENTION POLICY (constraint 2): MiMo exposes NO supported
+        # busy/idle session signal (verified 2026-09-12: `mimo session list
+        # --format json` has no status field; no `session status` command;
+        # no status column in the session schema; no documented ACP/serve
+        # endpoint). Therefore automatic injection into interactive sessions
+        # is NOT YET SAFE and stays disabled. Only waits explicitly declared
+        # target_kind="headless" (disposable/owned sessions) auto-dispatch.
+        if rec.get("target_kind") != "headless":
+            if not rec.get("hold_reason"):
+                rec["hold_reason"] = (
+                    "INTERACTIVE_AUTO_RESUME = NOT YET SAFE: "
+                    "no supported MiMo busy/idle signal; "
+                    "queued until operator releases"
+                )
+                waitstore.save(rec)
+            continue
+        if rec.get("ext", {}).get("resume_mode") == "self":
+            # REAL_ASYNC_BRIDGE §3: self-resuming wait (completion-file /
+            # inotify waiter owns its continuation). The daemon has NO
+            # delivery role here — dispatching a delivery worker would
+            # stamp a phantom rc!=0 over the waiter's own truthful
+            # terminal state (the canonical-state contradiction).
+            # NB: keyed on the explicit self marker, NOT on resume_cmd
+            # absence — records without inline resume_cmd may still be
+            # dispatchable via the WR_RESUME_CMD env template.
+            continue
+        with _inflight_lock:
+            t = _inflight.get(sid)
+            if t is not None and t.is_alive():
+                continue  # single-flight: session already being driven
+            # B: never launch into a busy session
+            strays = stray_worker_pids(sid)
+            if strays:
+                log(f"drive: {rec['wait_id']} held, session busy {strays}")
+                continue
+            th = threading.Thread(target=resume, args=(rec,), daemon=True, name=f"resume-{rec['wait_id']}")
+            _inflight[sid] = th
+            # start INSIDE the lock: a just-created thread is not yet
+            # is_alive() until start() runs — starting outside the lock let
+            # the same drive cycle dispatch a second worker for the session
+            # (single-flight race, caught by the T2 invariant test).
+            th.start()
+        log(f"drive: dispatched {rec['wait_id']} (session {sid})")
+
+
+def reconcile_once() -> None:
+    for rec in waitstore.pending():
+        if rec["status"] != "WAITING_EXTERNAL":
+            continue
+        created = rec.get("created_at", "")
+        try:
+            import calendar
+
+            age = time.time() - calendar.timegm(time.strptime(created, "%Y-%m-%dT%H:%M:%SZ"))
+        except ValueError:
+            continue
+        if age > RECONCILE_SECS:
+            try_transition(rec)
+
+
+_tick = 0
+
+
+def orphan_sweep() -> int:
+    """REAL_ASYNC_BRIDGE §4: permanent mid-run orphan-lease recovery.
+
+    FAILURE DETECTION ONLY — never involved in normal completion
+    scheduling. A wait stuck in RESUMING past ORPHAN_GRACE_SECS means the
+    resume flow died between lease acquire and release (worker thread
+    lost, exception mid-watch). Reconcile exactly as startup_recovery
+    would have: release the lease, stamp RESUME_UNVERIFIED truthfully
+    (delivery unverifiable), never auto-relaunch.
+    """
+    import calendar as _cal
+
+    healed = 0
+    for rec in waitstore.all_waits():
+        if rec.get("status") != "RESUMING":
+            continue
+        try:
+            updated = _cal.timegm(time.strptime(rec.get("last_updated", ""), "%Y-%m-%dT%H:%M:%SZ"))
+        except ValueError:
+            continue
+        if time.time() - updated < ORPHAN_GRACE_SECS:
+            continue  # legitimate in-flight watch (up to WATCH_SECS)
+        wid, sid = rec["wait_id"], rec["session_id"]
+        lease = waitstore.read_lease(sid)
+        owner_dead = lease is not None and not waitstore._owner_alive(lease)
+        daemon_owned = lease is not None and lease.get("pid") == os.getpid()
+        if lease is None or owner_dead or daemon_owned:
+            if lease is not None:
+                waitstore.release_lease(sid, wid)
+            if rec.get("resume_attempts", 0) >= MAX_ATTEMPTS:
+                rec["status"] = "RESUME_UNVERIFIED"
+            else:
+                rec["status"] = "READY_TO_RETRY"
+            rec["resume_note"] = (
+                "orphaned mid-run: resume flow died between lease acquire "
+                "and delivery ("
+                + ("lease owner dead" if owner_dead else "resume thread lost" if daemon_owned else "no lease")
+                + "); orphan sweep recovered"
+            )
+            waitstore.save(rec)
+            log(f"orphan-sweep {wid}: {rec['status']} — {rec['resume_note']}")
+            healed += 1
+    return healed
+
+
+def reconciler() -> None:
+    global _tick
+    while True:
+        # v0.3: the local-runner wake is the fast path; periodic
+        # authoritative verification demotes to a slower fallback
+        # (missed-event + daemon-restart recovery), not API polling.
+        _tick += 1
+        if _tick % RECONCILE_EVERY_TICKS == 0:
+            try:
+                reconcile_once()
+            except Exception as e:
+                log(f"reconcile error: {e}")
+            try:
+                orphan_sweep()  # §4 failure detection — bounded, periodic
+            except Exception as e:
+                log(f"orphan-sweep error: {e}")
+        try:
+            drive_ready()
+        except Exception as e:
+            log(f"drive error: {e}")
+        with _inflight_lock:
+            for sid, t in list(_inflight.items()):
+                if not t.is_alive():
+                    del _inflight[sid]
+        time.sleep(DRIVE_LOOP_SECS)
+
+
+# ── webhook receiver (wake signal only) ───────────────────────────────────
+
+
+def wake_sweep(event: dict, eid: str) -> dict:
+    """Sweep WAITING_EXTERNAL waits through authoritative verification.
+
+    Runs on a background thread (the hook's HTTP response returns
+    instantly, minimising the runner's offline window). If any verified
+    wait got 'pending' — the normal case for a job that finished
+    microseconds ago: the post-task hook fires after results are reported
+    but before the runner's final task acknowledgement flips server-side
+    status — retry on a BOUNDED event-triggered schedule (default 4s x3),
+    never a polling loop. The final ack lands milliseconds after the hook
+    exits, so the first retry almost always sees the terminal state.
+    """
+    arrival = time.time()
+    log(f"local wake {eid}: {json.dumps(event)[:140]}")
+    import calendar
+
+    def sweep() -> tuple[int, int, int]:
+        verified = advanced = pending = 0
+        for rec in waitstore.pending():
+            if rec["status"] != "WAITING_EXTERNAL":
+                continue
+            try:
+                age = time.time() - calendar.timegm(time.strptime(rec.get("created_at", ""), "%Y-%m-%dT%H:%M:%SZ"))
+            except ValueError:
+                continue
+            if age < WAKE_MIN_AGE_SECS:
+                continue
+            verified += 1
+            before = rec["status"]
+            try_transition(rec)
+            if rec["status"] != before and rec["status"] == "READY_TO_RESUME":
+                advanced += 1
+            elif rec["status"] == "WAITING_EXTERNAL":
+                pending += 1
+        return verified, advanced, pending
+
+    verified, advanced, pending = sweep()
+    log(
+        f"local wake {eid}: verified={verified} advanced={advanced} "
+        f"pending={pending} sweep_ms={int((time.time() - arrival) * 1000)}"
+    )
+    for attempt in range(1, WAKE_RETRIES + 1):
+        # Retry while the sweep didn't conclusively advance anything:
+        # pending verdicts (ack-window) AND fresh-wait skips (age gate).
+        # Bounded, event-triggered — not a polling loop.
+        if not pending and verified:
+            break
+        time.sleep(WAKE_RETRY_SECS)
+        verified, advanced, pending = sweep()
+        log(
+            f"local wake {eid}: retry{attempt} verified={verified} "
+            f"advanced={advanced} pending={pending} "
+            f"total_ms={int((time.time() - arrival) * 1000)}"
+        )
+    return {"event_id": eid}
+
+
+class Handler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        if self.path == "/process-event":
+            # T15 §15D: process-exit events from builder/controller
+            # notifiers. Minimal dedicated endpoint — the Gitea webhook
+            # path stays untouched. Payload: {operation_id, exit_code,
+            # completed_at} + OPTIONAL provider/event_type/sha (T16
+            # §16C/§16E: the CI adapter registers as provider="gitea",
+            # event_type="ci_completed"; defaults preserve the T15 builder
+            # identity so existing notifiers are unaffected). The event is
+            # a WAKE, never truth — resumed controllers re-read canonical
+            # authority before any verdict.
+            length = int(self.headers.get("Content-Length", 0))
+            body = self.rfile.read(length)
+            try:
+                payload = json.loads(body) if body else {}
+            except json.JSONDecodeError:
+                self.send_response(400)
+                self.end_headers()
+                return
+            event = {
+                "provider": str(payload.get("provider", "builder")),
+                "event_type": str(payload.get("event_type", "builder_exit")),
+                "run_ref": str(payload.get("operation_id", "")) or None,
+                "sha": payload.get("sha"),
+                "exit_code": payload.get("exit_code"),
+                "completed_at": payload.get("completed_at") or "",
+            }
+            event = {k: v for k, v in event.items() if v is not None}
+            eid = waitstore.record_event(event)
+            log(f"process-event {eid}: {json.dumps(event)[:140]}")
+            # REAL_ASYNC_BRIDGE (R3): durable completion-file delivery.
+            # Every event reaching the bridge is written as
+            # resumes/<operation_id>.done so inotify waiters wake on the
+            # kernel event (R4) with no FIFO/lease machinery, and the
+            # event survives daemon AND waiter restarts (R9). Atomic
+            # rename; duplicate events rewrite identical content (R10).
+            _op_id = str(payload.get("operation_id", ""))
+            if _op_id:
+                try:
+                    # Stable identity only: duplicate deliveries of the
+                    # same logical event must produce byte-identical
+                    # completion files (R10 idempotence by construction).
+                    # completed_at is volatile and lives in the durable
+                    # event log; the file is a WAKE SIGNAL, never truth.
+                    _stable = {
+                        k: event.get(k)
+                        for k in ("provider", "event_type", "run_ref", "sha", "exit_code")
+                        if event.get(k) is not None
+                    }
+                    completion_file.write_completion(_op_id, _stable)
+                except Exception as e:  # noqa: BLE001 — delivery best-effort; wait-record transition + watchdog recovery still cover the lost file
+                    log(f"process-event {eid}: completion-file write failed: {e}")
+            matched = 0
+            for rec in waitstore.pending():
+                if rec["status"] == "WAITING_EXTERNAL" and waitstore.match(rec, event):
+                    matched += 1
+                    try_transition(rec, event)
+            # matched READY controller waits are dispatched IMMEDIATELY
+            # (event-driven, no floor). Guard: only never-resumed waits —
+            # a duplicate/late event must not double-dispatch (15E);
+            # single-flight lease + this guard together make resume
+            # idempotent.
+            for rec in waitstore.pending():
+                if rec["status"] == "READY_TO_RESUME" and rec.get("resume_cmd") and rec.get("resume_attempts", 0) == 0:
+                    threading.Thread(target=resume, args=(rec,), daemon=True, name=f"resume-{rec['wait_id']}").start()
+                    matched += 1
+            try:
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write(json.dumps({"event_id": eid, "matched": matched}).encode())
+            except (BrokenPipeError, ConnectionResetError):
+                pass
+            return
+        if self.path == "/wake":
+            length = int(self.headers.get("Content-Length", 0))
+            body = self.rfile.read(length)
+            try:
+                payload = json.loads(body) if body else {}
+            except json.JSONDecodeError:
+                self.send_response(400)
+                self.end_headers()
+                return
+            event = {
+                "provider": "gitea-local-runner",
+                "task_id": str(payload.get("task_id", "")) or None,
+                "run_id": str(payload.get("run_id", "")) or None,
+                "repository": str(payload.get("repository", "")) or None,
+                "job_result": str(payload.get("job_result", "")) or None,
+            }
+            event = {k: v for k, v in event.items() if v}
+            eid = waitstore.record_event(event)
+            # Respond instantly; sweep on a worker thread. The hook is
+            # fire-and-forget (curl -m 2) — a broken pipe on write is
+            # harmless and must not propagate.
+            try:
+                threading.Thread(
+                    target=wake_sweep, args=(event, eid), daemon=True, name=f"wake-{payload.get('task_id', '?')}"
+                ).start()
+            except Exception as e:
+                log(f"wake spawn error: {e}")
+            try:
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write(json.dumps({"queued": True, "event_id": eid}).encode())
+            except (BrokenPipeError, ConnectionResetError):
+                pass
+            return
+        if self.path != "/webhook":
+            self.send_response(404)
+            self.end_headers()
+            return
+        length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(length)
+        try:
+            payload = json.loads(body)
+        except json.JSONDecodeError:
+            self.send_response(400)
+            self.end_headers()
+            return
+        action = payload.get("action") or payload.get("event_type") or ""
+        wf = payload.get("workflow_run") or {}
+        event = {
+            "provider": "gitea",
+            "event_type": f"workflow.{action}" if wf else action,
+            "sha": (wf.get("head_sha") or payload.get("sha") or "")[:12] or None,
+            "run_ref": str(wf.get("id") or payload.get("run_number") or "") or None,
+        }
+        event = {k: v for k, v in event.items() if v}
+        eid = waitstore.record_event(event)
+        log(f"webhook event {eid}: {json.dumps(event)[:140]}")
+        matched = 0
+        for rec in waitstore.pending():
+            if rec["status"] == "WAITING_EXTERNAL" and waitstore.match(rec, event):
+                matched += 1
+                try_transition(rec)
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(json.dumps({"event_id": eid, "matched": matched}).encode())
+
+    def do_GET(self):
+        if self.path == "/health":
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(b'{"ok":true}')
+            return
+        self.send_response(404)
+        self.end_headers()
+
+    def log_message(self, *a):
+        pass
+
+
+def main() -> int:
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8791
+
+    # H (constraint 1): flock is the SINGLETON AUTHORITY. daemon.pid's
+    # content is diagnostic metadata only — it never gates startup, never
+    # implies liveness, and is overwritten after the exclusive lock is held.
+    # Stale pid content (incl. SIGKILL debris) is thus harmless by design.
+    PIDFILE.parent.mkdir(parents=True, exist_ok=True)
+    lock_fd = os.open(PIDFILE, os.O_CREAT | os.O_RDWR, 0o644)
+    try:
+        fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        log("refusing start: another daemon holds the pidfile flock")
+        print("daemon already running (pidfile flock held)", file=sys.stderr)
+        return 1
+    os.ftruncate(lock_fd, 0)
+    os.write(lock_fd, f"{os.getpid()}\n".encode())  # diagnostic, lock held for life
+
+    startup_recovery()
+    t = threading.Thread(target=reconciler, daemon=True)
+    t.start()
+    log(f"daemon starting on :{port}")
+    srv = ThreadingHTTPServer(("0.0.0.0", port), Handler)
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bridge/daemon/verify.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""verify.py — authoritative Gitea verification (webhook ≠ success).
+
+Queries the Gitea API for the TRUE state of the run/job/commit the wait
+references. Returns (verdict, evidence). verdict ∈ {success, failure,
+pending, unknown}. Only this module may move a wait out of
+WAITING_EXTERNAL.
+"""
+
+from __future__ import annotations
+import json, subprocess
+from pathlib import Path
+
+HOST = "https://gitea.thingscouldgetdicey.online"
+REPO = "conductor/rune"
+
+
+def _token() -> str:
+    # Canonical ladder without importing Rune: env → token file → git store
+    import os
+
+    tok = os.environ.get("GITEA_TOKEN", "").strip()
+    if tok:
+        return tok
+    tf = os.path.expanduser("~/.config/opencode/secrets/gitea-token")
+    if os.path.isfile(tf):
+        return open(tf).read().strip()
+    r = subprocess.run(
+        ["git", "credential", "fill"],
+        input="protocol=https\nhost=gitea.thingscouldgetdicey.online\nusername=conductor\n\n",
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+    for line in r.stdout.splitlines():
+        if line.startswith("password="):
+            return line[9:]
+    raise RuntimeError("no gitea credential available")
+
+
+def _api(path: str) -> tuple[int, object]:
+    import urllib.request
+
+    req = urllib.request.Request(f"{HOST}/api/v1/repos/{REPO}{path}", headers={"Authorization": f"token {_token()}"})
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            return r.status, json.loads(r.read())
+    except urllib.error.HTTPError as e:
+        return e.code, {"error": e.read().decode()[:200]}
+
+
+def _jobs_list(run_ref: str):
+    """GET jobs for a run, unwrapping the {'jobs': [...]} envelope."""
+    s, data = _api(f"/actions/runs/{run_ref}/jobs")
+    if s != 200:
+        return s, None
+    if isinstance(data, dict):
+        data = data.get("jobs", [])
+    return s, data if isinstance(data, list) else None
+
+
+def _resolve_run_id(run_ref: str, sha: str) -> str:
+    """Task-list ids are NOT run ids. If run_ref lookup 404s, resolve the
+    real run id by head SHA via /actions/runs (T15: run 6907 vs task 15743)."""
+    if run_ref:
+        s, jobs = _jobs_list(run_ref)
+        if s == 200 and jobs:
+            return run_ref
+    if sha:
+        s, runs = _api(f"/actions/runs?limit=30")
+        items = runs.get("workflow_runs", []) if isinstance(runs, dict) else (runs if isinstance(runs, list) else [])
+        # One SHA fans out to multiple runs (lint + deploy-only). Prefer a
+        # substantive (non-skipped) run; a skipped-only run proves nothing.
+        fallback = ""
+        for r in items:
+            if str(r.get("head_sha", "")).startswith(sha):
+                rid = str(r.get("id"))
+                if r.get("conclusion") != "skipped":
+                    return rid
+                fallback = fallback or rid
+        return fallback
+    return ""
+
+
+def verify_run(run_ref: str, sha: str, expected: str) -> tuple[str, dict]:
+    """run_ref = actions run id (or task id — resolved via SHA lookup).
+
+    Defect fixed 2026-09-12 (surfaced by W/R-v0.3 live proof, run 7110):
+    the jobs query here used raw _api + isinstance(jobs, list), but this
+    Gitea wraps jobs in the {"jobs": [...]} envelope — the check always
+    failed, so EVERY EXACT_WORKFLOW verdict silently fell through to the
+    aggregate commit-status fallback, where unrelated runs on the same
+    SHA (multi-run fan-out: ci.yml + deploy-only) poison the verdict.
+    Use _jobs_list (unwraps the envelope), same as _resolve_run_id."""
+    run_ref = _resolve_run_id(run_ref, sha)
+    if run_ref:
+        s, jobs = _jobs_list(run_ref)
+        if s == 200 and isinstance(jobs, list) and jobs:
+            conclusions = {j.get("name"): j.get("conclusion") for j in jobs}
+            statuses = {j.get("status") for j in jobs}
+            if statuses <= {"completed"}:
+                verdict = "success" if set(conclusions.values()) <= {"success", "skipped"} else "failure"
+                return verdict, {"run_ref": run_ref, "jobs": conclusions}
+            return "pending", {"run_ref": run_ref, "statuses": sorted(statuses)}
+    if sha:
+        s, st = _api(f"/commits/{sha}/status")
+        if s == 200 and isinstance(st, dict):
+            state = st.get("state", "unknown")  # success|error|failure|pending|warning
+            rid = _resolve_run_id("", sha)  # attach run id so failure evidence works
+            if state == "success":
+                return "success", {"sha": sha, "state": state, "run_ref": rid}
+            if state in ("error", "failure"):
+                return "failure", {"sha": sha, "state": state, "run_ref": rid}
+            return "pending", {"sha": sha, "state": state}
+    return "unknown", {"run_ref": run_ref, "sha": sha}
+
+
+def failed_job_evidence(run_ref: str, sha: str = "") -> dict:
+    """For failure continuations: exact failing job + conclusion."""
+    run_ref = _resolve_run_id(run_ref, sha)
+    if not run_ref:
+        return {}
+    s, jobs = _jobs_list(run_ref)
+    if s != 200 or not isinstance(jobs, list):
+        return {}
+    bad = [j for j in jobs if j.get("conclusion") not in ("success", "skipped", None)]
+    return {
+        "failed_jobs": [
+            {"name": j.get("name"), "conclusion": j.get("conclusion"), "url": j.get("url", "")} for j in bad
+        ]
+    }
+
+
+# ── RELEASE_DEPLOY verification (W/R v0.1, overnight handoff Part 2) ──────
+# Aggregate commit status is NOT a valid completion authority for Rune's
+# release/deploy flow: the release successor SHA, not the source SHA, is what
+# converges (observed live: wr-1789179026 stranded on pending while 0.66.15
+# was deployed). The authority chain is:
+#   source SHA → source runs terminal → release successor commit (descendant)
+#   → successor runs success → deployed/current identity converges.
+
+
+def _git(args: list[str], repo_root: str) -> str:
+    import subprocess
+
+    r = subprocess.run(["git"] + args, capture_output=True, text=True, cwd=repo_root or None, timeout=15)
+    if r.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args[:2])}: {r.stderr.strip()[:120]}")
+    return r.stdout
+
+
+def _runs_for_sha(sha: str) -> list[dict]:
+    s, runs = _api("/actions/runs?limit=50")
+    items = runs.get("workflow_runs", []) if isinstance(runs, dict) else []
+    return [r for r in items if str(r.get("head_sha", "")).startswith(sha)]
+
+
+def _sha_verdict_from_runs(runs: list[dict]) -> tuple[str, dict]:
+    """success | failure | pending from a SHA's workflow runs.
+    Terminal verdict ONLY when every run is completed — mixed states
+    (some success, some still in flight) must stay PENDING (observed live:
+    a SHA with 1 completed-success + 1 queued + 1 in-progress was judged
+    success mid-flight; wr-1789182522 2026-09-12)."""
+    if not runs:
+        return "pending", {"note": "no runs found"}
+    non_terminal = [r for r in runs if r.get("status") != "completed"]
+    if non_terminal:
+        return "pending", {"in_flight": len(non_terminal)}
+    conclusions = {r.get("name"): r.get("conclusion") for r in runs}
+    bad = {n: c for n, c in conclusions.items() if c == "failure"}
+    if bad:
+        return "failure", {"failed": bad}
+    return "success", {"runs": conclusions}
+
+
+def verify_release_deploy(source_sha: str, repo_root: str = "", deployed_link: str = "") -> tuple[str, dict]:
+    """RELEASE_DEPLOY authority chain. Returns (verdict, evidence)."""
+    source_sha = (source_sha or "")[:12]
+    ev: dict = {"source_sha": source_sha, "kind": "RELEASE_DEPLOY"}
+
+    # 1. Source SHA's own runs must be terminal and healthy.
+    src_runs = _runs_for_sha(source_sha)
+    src_verdict, src_ev = _sha_verdict_from_runs(src_runs)
+    ev["source"] = src_ev
+    if src_verdict != "success":
+        return src_verdict, ev
+
+    # 2. Release successor: first chore(release) commit descending from source.
+    if not repo_root:
+        return "pending", {**ev, "note": "no repo_root — cannot check lineage"}
+    try:
+        out = _git(
+            [
+                "log",
+                "--format=%H %s",
+                "--reverse",
+                f"{source_sha}..master",
+                "--grep=^chore\\(release\\)",
+                "--extended-regexp",
+            ],
+            repo_root,
+        )
+    except RuntimeError as e:
+        return "pending", {**ev, "note": str(e)}
+    successors = [l for l in out.splitlines() if l.strip()]
+    if not successors:
+        return "pending", {**ev, "note": "no release successor yet"}
+    succ_line = successors[0]
+    succ_sha_full, _, succ_subject = succ_line.partition(" ")
+    succ_sha = succ_sha_full[:12]
+    ev["successor"] = {"sha": succ_sha, "subject": succ_subject[:80]}
+
+    # Ancestry is guaranteed by the range, but verify explicitly (deterministic
+    # lineage over title guessing):
+    try:
+        _git(["merge-base", "--is-ancestor", source_sha, succ_sha_full], repo_root)
+    except RuntimeError:
+        return "failure", {**ev, "note": "successor is not a descendant of source"}
+
+    # 3. Successor runs must be terminal and healthy.
+    succ_runs = _runs_for_sha(succ_sha)
+    succ_verdict, succ_ev = _sha_verdict_from_runs(succ_runs)
+    ev["successor"]["runs"] = succ_ev
+    if succ_verdict != "success":
+        return succ_verdict, ev
+
+    # 4. Deployed identity convergence. A mismatch is FAILURE only when the
+    # successor's runs are ALL completed — if any is still running/queued the
+    # deploy may simply not have propagated yet → PENDING (observed live:
+    # reconciler checked mid-deploy, verdict failure, deployment converged
+    # ~2 min later; wr-1789182522 2026-09-12).
+    if deployed_link:
+        link = Path(deployed_link)
+        if link.is_symlink() or link.is_dir():
+            deployed = str(link.resolve())
+            deployed_id = Path(deployed).name
+            ev["deployed"] = deployed_id
+            if not deployed_id.startswith(succ_sha[:12]):
+                still = [r for r in _runs_for_sha(succ_sha) if r.get("status") != "completed"]
+                if still:
+                    return "pending", {**ev, "note": "deploy propagating (runs in flight)"}
+                return "failure", {**ev, "note": f"deployed {deployed_id} != successor {succ_sha} (all runs terminal)"}
+        else:
+            return "failure", {**ev, "note": f"deployed link missing: {deployed_link}"}
+
+    return "success", ev

bridge/daemon/waitstore.py

@@ -0,0 +1,337 @@
+#!/usr/bin/env python3
+"""waitstore.py — wait/resume state machine v0.2 (developer tooling, NOT Rune).
+
+States:
+  RUNNABLE → WAITING_EXTERNAL → READY_TO_RESUME → RESUMING → COMPLETED | FAILED
+                                       ↑               │
+                                       │               ├─(watch timeout, tree killed)
+                                       │               └─(rc!=0 / unverifiable)
+                                  READY_TO_RETRY ←─────┘
+  RESUME_UNVERIFIED : delivery after crash/timeout cannot be proven.
+                      TERMINAL-ish — never auto-scheduled; explicit
+                      `requeue()` required to make it READY_TO_RESUME.
+  TIMED_OUT         : external event never arrived within the wait budget.
+
+Waits persist as waits/<wait_id>.json (atomic tmp+rename).
+Leases persist as leases/<session_id>.lease.json (atomic tmp+rename,
+validated against /proc so a dead or PID-reused owner is stealable).
+"""
+
+from __future__ import annotations
+import fcntl, json, os, tempfile, time, uuid
+from pathlib import Path
+
+ROOT = Path(os.environ.get("WR_ROOT", "") or Path(__file__).resolve().parent)
+WAITS = ROOT / "waits"
+EVENTS = ROOT / "events"
+LEASES = ROOT / "leases"
+
+SCHEDULABLE = {"READY_TO_RESUME", "READY_TO_RETRY"}
+VALID_STATES = {
+    "RUNNABLE",
+    "WAITING_EXTERNAL",
+    "READY_TO_RESUME",
+    "RESUMING",
+    "COMPLETED",
+    "FAILED",
+    "READY_TO_RETRY",
+    "RESUME_UNVERIFIED",
+    "TIMED_OUT",
+}
+TERMINAL = {"COMPLETED", "FAILED", "RESUME_UNVERIFIED", "TIMED_OUT"}
+
+
+def _atomic_write(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), prefix=".tmp-")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(data, f, indent=1, sort_keys=True)
+        os.replace(tmp, path)
+        # T17 17C: the bridge root is SHARED across users (deploy waiter
+        # runs as the runner user; daemon as nick). mkstemp creates 0600 —
+        # daemon re-saves locked the runner user out of records it must
+        # read (waitstore.load in await_resume_event; find_matching_event
+        # replay scan silently skipped them). 0644: owner writes, all read.
+        os.chmod(path, 0o644)
+    except BaseException:
+        if os.path.exists(tmp):
+            os.unlink(tmp)
+        raise
+
+
+def now() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def new_wait(
+    *,
+    session_id: str,
+    provider: str,
+    event_type: str,
+    repo: str,
+    sha: str = "",
+    run_ref: str = "",
+    expected: str = "success",
+    wait_kind: str = "EXACT_WORKFLOW",
+    target_kind: str = "interactive",
+    repo_root: str = "",
+    deployed_link: str = "",
+    objective: str = "",
+    waited_for: str = "",
+    verify_when_woken: str = "",
+    on_success: str = "",
+    on_failure: str = "",
+    resume_cmd: list | None = None,
+) -> dict:
+    wid = f"wr-{int(time.time())}-{uuid.uuid4().hex[:6]}"
+    rec = {
+        "wait_id": wid,
+        "session_id": session_id,
+        "created_at": now(),
+        "provider": provider,
+        "event_type": event_type,
+        "repo": repo,
+        "sha": sha,
+        "run_ref": run_ref,
+        "expected": expected,
+        # T15 §15D: PROCESS_EVENT — a wait whose authoritative verdict is
+        # the matching process-exit event itself (exit_code carried on the
+        # event), e.g. a builder/controller process completing. The event
+        # IS the authority here (the notifier wrapper observed the real
+        # process exit); no Gitea lookup applies.
+        "wait_kind": wait_kind
+        if wait_kind in ("EXACT_WORKFLOW", "RELEASE_DEPLOY", "PROCESS_EVENT")
+        else "EXACT_WORKFLOW",
+        # CONTENTION POLICY: "interactive" (default, conservative) never
+        # auto-dispatches — MiMo exposes NO supported busy/idle session
+        # signal, so injecting into a possibly-busy interactive session is
+        # NOT YET SAFE. Only explicitly declared headless/disposable
+        # targets ("headless") are auto-resumed.
+        "target_kind": target_kind if target_kind in ("headless", "interactive") else "interactive",
+        "repo_root": repo_root,
+        "deployed_link": deployed_link,
+        # T15 §15D: per-wait resume command override (placeholder template,
+        # same substitution as WR_RESUME_CMD: {session_id}/{msg}/{wait_id}).
+        # A synthetic controller session (e.g. a Scaffolding stage driver)
+        # is NOT a MiMo session — the global mimo-shaped default cannot
+        # resume it, which is exactly why fixed-sleep polling crept back
+        # in T12-T14. Per-wait override makes ANY registered continuation
+        # target resumable through the same bridge.
+        "resume_cmd": list(resume_cmd) if resume_cmd else None,
+        "status": "WAITING_EXTERNAL",
+        "last_verified": "",
+        "resume_attempts": 0,
+        "continuation": {
+            "objective": objective,
+            "waited_for": waited_for,
+            "verify_when_woken": verify_when_woken,
+            "on_success": on_success,
+            "on_failure": on_failure,
+        },
+    }
+    _atomic_write(WAITS / f"{wid}.json", rec)
+    return rec
+
+
+def load(wid: str) -> dict | None:
+    p = WAITS / f"{wid}.json"
+    return json.loads(p.read_text()) if p.is_file() else None
+
+
+def save(rec: dict) -> None:
+    assert rec.get("status") in VALID_STATES, rec.get("status")
+    rec["last_updated"] = now()
+    _atomic_write(WAITS / f"{rec['wait_id']}.json", rec)
+
+
+def all_waits() -> list[dict]:
+    out = []
+    for p in WAITS.glob("*.json"):
+        try:
+            out.append(json.loads(p.read_text()))
+        except json.JSONDecodeError:
+            continue
+    return out
+
+
+def pending() -> list[dict]:
+    return [r for r in all_waits() if r.get("status") in {"WAITING_EXTERNAL"} | SCHEDULABLE]
+
+
+def schedulable() -> list[dict]:
+    """READY waits, oldest first — deterministic queue order."""
+    rs = [r for r in all_waits() if r.get("status") in SCHEDULABLE]
+    rs.sort(key=lambda r: (r.get("created_at", ""), r.get("wait_id", "")))
+    return rs
+
+
+def requeue(wid: str, note: str) -> dict | None:
+    """Operator-explicit requeue of a RESUME_UNVERIFIED/RESUME_FAILED wait."""
+    rec = load(wid)
+    if not rec:
+        return None
+    rec["status"] = "READY_TO_RESUME"
+    rec["resume_note"] = note
+    save(rec)
+    return rec
+
+
+# ── events (wake signals, idempotent) ─────────────────────────────────────
+
+
+def record_event(event: dict) -> str:
+    import hashlib
+
+    body = json.dumps(event, sort_keys=True)
+    eid = hashlib.sha256(body.encode()).hexdigest()[:16]
+    f = EVENTS / f"{eid}.json"
+    if not f.is_file():
+        _atomic_write(f, {"event_id": eid, "received_at": now(), "event": event})
+    return eid
+
+
+def match(rec: dict, event: dict) -> bool:
+    if rec.get("provider") != event.get("provider"):
+        return False
+    if rec.get("event_type") and event.get("event_type") and rec["event_type"] != event["event_type"]:
+        return False
+    if rec.get("sha") and event.get("sha") and rec["sha"] != event["sha"]:
+        return False
+    if rec.get("run_ref") and event.get("run_ref") and rec["run_ref"] != event["run_ref"]:
+        return False
+    return True
+
+
+# ── leases (per-session single-flight, /proc-validated) ───────────────────
+#
+# Invariant 3 (PID reuse): liveness is NEVER "PID exists". The lease records
+# pid + pgid + process starttime (/proc/<pid>/stat field 22); all three must
+# match or the owner is a different process wearing a recycled PID.
+#
+# Invariant 1 (flock as authority): the lease file's flock serializes
+# read-modify-write across processes and dies with its holder, so a crashed
+# daemon can never wedge the lock. The lease JSON + /proc decide who OWNS the
+# session; the flock only prevents racing acquirers from double-stealing.
+
+_lease_fds: dict[str, int] = {}  # session_id → open fd holding the flock
+
+
+def _pid_starttime(pid: int) -> str | None:
+    """Field 22 of /proc/<pid>/stat — distinguishes PID reuse."""
+    try:
+        stat = Path(f"/proc/{pid}/stat").read_text()
+        return stat.rsplit(")", 1)[1].split()[19]
+    except (OSError, IndexError):
+        return None
+
+
+def _owner_alive(lease: dict) -> bool:
+    pid = lease.get("pid")
+    if not pid or not Path(f"/proc/{pid}").is_dir():
+        return False
+    if _pid_starttime(pid) != lease.get("pid_starttime"):
+        return False  # PID reused by an unrelated process
+    try:
+        if os.getpgid(pid) != lease.get("pgid"):
+            return False
+    except OSError:
+        return False
+    return True
+
+
+def lease_path(session_id: str) -> Path:
+    # T16 §16C finding (observed live in daemon.log): session ids like
+    # "controller-<op>-Verboo Code/glm-5.3-flash" contain "/" — the raw
+    # embed made lease creation raise FileNotFoundError, so resume
+    # delivery for those waits could never succeed. Sanitize to a flat
+    # filesystem-safe name; the hash suffix prevents collisions between
+    # ids that sanitize identically.
+    import hashlib as _hashlib
+    import re as _re
+
+    safe = _re.sub(r"[^A-Za-z0-9._-]+", "_", session_id)[:80]
+    digest = _hashlib.sha256(session_id.encode()).hexdigest()[:10]
+    return LEASES / f"{safe}-{digest}.lease.json"
+
+
+def read_lease(session_id: str) -> dict | None:
+    p = lease_path(session_id)
+    if not p.is_file():
+        return None
+    try:
+        return json.loads(p.read_text())
+    except json.JSONDecodeError:
+        return None
+
+
+def _locked_lease_fd(session_id: str) -> int | None:
+    """Open the lease file and take its flock (non-blocking). The fd stays
+    open (lock held) until release_lease closes it."""
+    if session_id in _lease_fds:
+        return _lease_fds[session_id]  # already hold it
+    LEASES.mkdir(parents=True, exist_ok=True)
+    fd = os.open(lease_path(session_id), os.O_CREAT | os.O_RDWR, 0o600)
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        os.close(fd)
+        return None  # another process holds the lock — mid-acquire
+    _lease_fds[session_id] = fd
+    return fd
+
+
+def _write_lease_locked(session_id: str, lease: dict) -> None:
+    fd = _lease_fds[session_id]
+    os.ftruncate(fd, 0)
+    os.lseek(fd, 0, os.SEEK_SET)
+    os.write(fd, json.dumps(lease, indent=1, sort_keys=True).encode())
+    os.fsync(fd)
+
+
+def acquire_lease(session_id: str, wait_id: str, pid: int, pgid: int) -> dict | None:
+    """Atomically create or steal the session lease. Returns the lease dict,
+    or None if a live owner holds it (or another process is mid-steal).
+    Staleness is decided by /proc identity evidence, never by age alone."""
+    fd = _locked_lease_fd(session_id)
+    if fd is None:
+        return None
+    existing = read_lease(session_id)
+    if existing and _owner_alive(existing):
+        _lease_fds.pop(session_id, None)
+        os.close(fd)
+        return None  # live worker owns this session
+    lease = {
+        "session_id": session_id,
+        "wait_id": wait_id,
+        "pid": pid,
+        "pgid": pgid,
+        "pid_starttime": _pid_starttime(pid),
+        "acquired_at": now(),
+        "state": "RESUMING",
+    }
+    _write_lease_locked(session_id, lease)
+    return lease
+
+
+def update_lease(session_id: str, **fields) -> None:
+    lease = read_lease(session_id) or {}
+    lease.update(fields)
+    _write_lease_locked(session_id, lease)
+
+
+def release_lease(session_id: str, wait_id: str) -> bool:
+    """Release only if the current lease belongs to this wait (no stealing
+    a successor's lease during a slow shutdown path). Closes the flock fd."""
+    lease = read_lease(session_id)
+    if not (lease and lease.get("wait_id") == wait_id):
+        return False
+    fd = _lease_fds.pop(session_id, None)
+    if fd is not None:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_UN)
+        except OSError:
+            pass
+        os.close(fd)
+    lease_path(session_id).unlink(missing_ok=True)
+    return True

config/mimo-hooks/event-wait-guard.ts

@@ -0,0 +1,56 @@
+import type { Hooks } from "@mimo-ai/plugin"
+
+// event-wait-guard — RETIRED (T21.5 §6/§8, 2026-09-17).
+//
+// HISTORY: this hook was the T21 §21B-3 runtime interception layer that
+// blocked model-generated sleep→poll continuation (T20 regression), and
+// later carried the T21.1 §21.1C cwd guard. Both were DOWNSTREAM patches:
+// they corrected the model's output instead of fixing the generator.
+//
+// ROOT-CAUSE FIX (T21.5 §2-§5): the generator was ci_event_wait's
+// wait loop returning nonterminal control to the model — caused by a
+// single hard-coded master-deploy authority that was blind to branch/PR
+// operations. T21.5 fixed this upstream:
+//   - OPERATION_SPECS: per-operation-type completion authority
+//     (branch_ci/pull_request_checks -> own Actions runs;
+//     master_ci/deploy/release -> deploy qualification);
+//   - SINGLE LOGICAL AWAIT: all nonterminal conditions re-arm inside
+//     ci_event_wait.run(); the model sees only terminal results;
+//   - structured PendingOperation envelopes (op_type, authority,
+//     internal_rearm_count) propagate to the controller.
+//
+// With the generator fixed, runtime interception is retired per the
+// tranche rule FIXED UPSTREAM BEHAVIOUR > DOWNSTREAM GUARD CORRECTION.
+// Regression prevention lives in the test suite:
+//   tests/test_single_logical_await.py  (no model re-arm contract)
+//   tests/test_ci_event_wait.py         (watchdog=recovery, event=wake)
+//   tests/test_wait_guard_corpus.py     (canonical wait-pattern corpus)
+// NOT as a permanent runtime block. The hook file stays installed as a
+// documented no-op so canonical-source/install parity (test_hook_drift,
+// test_hook_parity) continues to prove the installed runtime matches
+// this repository's canonical state.
+
+export const EventWaitGuard: Hooks = {
+  "tool.execute.before": async (_input, _output) => {
+    // RETIRED — no interception. See history above.
+    return
+  },
+}
+
+export const CwdGuard: Hooks = {
+  "tool.execute.before": async (_input, _output) => {
+    // RETIRED (T21.5 §8) — the harness/construction execution boundary
+    // now resolves project context upstream (execution-context binding).
+    // No runtime refusal. See tests/test_auto_execution_context.py.
+    return
+  },
+}
+
+export const CombinedGuards: Hooks = {
+  "tool.execute.before": async (input, output) => {
+    // Kept as the default export shape; both sub-guards are retired.
+    return
+  },
+}
+
+export default CombinedGuards

config/mimo-tools/await-operation.ts

@@ -0,0 +1,92 @@
+import { tool } from "@mimo-ai/plugin"
+import { execSync } from "child_process"
+
+export default tool({
+    description: "Wait for an external operation (CI, deploy, release) to complete. Call this when you cannot make progress until an external process finishes. You do NOT need to know the sha, op_type, or duration — Rune's controller resolves those from the bound PendingOperation. Just call this when you want to wait.",
+    args: {
+        operation_id: tool.schema.string().optional().describe("Optional: the operation to wait for. If omitted, the controller resolves the current pending operation automatically."),
+        task_id: tool.schema.string().optional().describe("Optional: the active task id (e.g. T4). When provided, resolution is scoped to operations bound to this task — stale global operations are never consulted."),
+        sha: tool.schema.string().optional().describe("OPTIONAL HINT — non-authoritative. The controller uses this only to help resolve which operation you mean."),
+        op_type: tool.schema.string().optional().describe("OPTIONAL HINT — non-authoritative. The controller derives the canonical operation type from repository/Gitea state."),
+        deadline_secs: tool.schema.number().optional().describe("OPTIONAL HINT — non-authoritative. The controller applies governed policy timing. Real user deadlines must be stated in conversation."),
+    },
+    async execute(args) {
+        // INTENT NORMALIZATION — model output is intent; the controller
+        // owns execution semantics. All model args are hints recorded for
+        // observability; canonical truth comes from the bound operation.
+        const parts = []
+        if (args.operation_id) parts.push(`--operation-id ${args.operation_id}`)
+        if (args.task_id) parts.push(`--task-id ${args.task_id}`)
+        if (args.sha) parts.push(`--sha ${args.sha}`)
+        if (args.op_type) parts.push(`--model-op-type ${args.op_type}`)
+        if (args.deadline_secs) parts.push(`--model-deadline ${args.deadline_secs}`)
+        const normCmd = `python3 /mnt/workdrive/issue161-harness/scripts/await_intent_cli.py normalize ${parts.join(" ")}`
+        let norm: any
+        try {
+            const normOut = execSync(normCmd, {
+                cwd: "/mnt/workdrive/issue161-harness",
+                encoding: "utf-8" as const,
+                timeout: 120000,
+                env: { ...process.env, RUNE_WR_ROOT: "/mnt/workdrive/wr-bridge" },
+            })
+            norm = JSON.parse(normOut.trim().split("\n").find((l: string) => l.startsWith("{")) || "{}")
+        } catch (e: any) {
+            return JSON.stringify({ ok: false, stage: "normalization", error: (e.stderr || e.message || "?").slice(0, 300) })
+        }
+        if (norm.normalized === "AMBIGUOUS") {
+            return JSON.stringify({ ok: false, stage: "normalization", ...norm })
+        }
+        if (!norm.normalized) {
+            return JSON.stringify({ ok: false, stage: "normalization", ...norm })
+        }
+        // canonical continuation: stored/derived op_type + POLICY deadline
+        // (the sha for the wait comes from the normalization resolution,
+        // NOT from the model's args)
+        const waitSha = norm.sha_for_wait || args.sha || ""
+        if (!waitSha) {
+            return JSON.stringify({ ok: false, stage: "resolution", error: "no sha resolved for the pending operation", norm })
+        }
+        const cmd = `python3 /mnt/workdrive/issue161-harness/scripts/ci_event_wait.py --sha ${waitSha} --deadline ${norm.deadline_secs} --op-type ${norm.op_type}`
+        try {
+            const result = execSync(cmd, {
+                cwd: "/mnt/workdrive/issue161-harness",
+                timeout: (norm.deadline_secs + 60) * 1000,
+                encoding: "utf-8" as const,
+                env: { ...process.env, DEPLOY_SHA: waitSha, RUNE_WR_ROOT: "/mnt/workdrive/wr-bridge", RUNE_WR_CODE: "/home/nick/.local/share/mimo-wait-resume" },
+            })
+            const jl = result.trim().split("\n").find((l: string) => l.startsWith("{"))
+            const envelope = jl ? JSON.parse(jl) : { ok: false, error: "no output" }
+            return JSON.stringify({
+                ...envelope,
+                normalization: {
+                    model_deadline_ignored: norm.model_deadline_ignored,
+                    model_op_type_ignored: norm.model_op_type_ignored,
+                    model_sha_ignored: !!args.sha && args.sha !== waitSha,
+                    canonical_op_type: norm.op_type,
+                    canonical_authority: norm.authority,
+                    deadline_provenance: norm.deadline_provenance,
+                    matched_by: norm.matched_by || norm.evidence || "auto-resolved",
+                },
+            })
+        } catch (e: any) {
+            const lines = (e.stdout || "").trim().split("\n")
+            const jl = lines.find((l: string) => l.startsWith("{"))
+            if (jl) {
+                const envelope = JSON.parse(jl)
+                return JSON.stringify({
+                    ...envelope,
+                    normalization: {
+                        model_deadline_ignored: norm.model_deadline_ignored,
+                        model_op_type_ignored: norm.model_op_type_ignored,
+                        model_sha_ignored: !!args.sha && args.sha !== waitSha,
+                        canonical_op_type: norm.op_type,
+                        canonical_authority: norm.authority,
+                        deadline_provenance: norm.deadline_provenance,
+                        matched_by: norm.matched_by || norm.evidence || "auto-resolved",
+                    },
+                })
+            }
+            return JSON.stringify({ ok: false, stage: "wait", error: (e.stderr || e.message || "?").slice(0, 300) })
+        }
+    },
+})

config/mimo-tools/bash.ts

@@ -0,0 +1,167 @@
+
+// bash — executes a shell command. PROCESS-OWNERSHIP CONTRACT (v2):
+//
+//   MODE A (tool-owned): the child is launched in its own process group;
+//   stdout/stderr are CAPTURED pipes (never the TUI tty). On timeout or
+//   failure the ENTIRE process group is signalled (SIGTERM, grace,
+//   SIGKILL) so grandchildren cannot survive the invocation, then the
+//   result is finalized. After finalization NO descendant retains a
+//   writer into MiMo's streams.
+//
+//   MODE B (explicitly detached): a command suffixed with " &" that the
+//   user/model intends to outlive the tool (nohup/setsid/disown-style)
+//   is executed via the detached helper: stdin=/dev/null, stdout/stderr
+//   -> durable log file, own session (setsid), no MiMo PTY inheritance.
+//   The tool returns the log path as the durable handle.
+//
+// Wait-intent compilation (sleep/check/poll aimed at a pending operation)
+// is preserved: interception happens at the SEMANTIC level via
+// await_intent route-bash, and a NO-OP for anything that is not a genuine
+// continuation of a live pending operation. Arbitrary shell syntax
+// (quotes, pipes, semicolons) passes through untouched — the router
+// response is only trusted when it carries normalized=true AND
+// ContinuePendingOperation with a concrete operation bound.
+import { tool } from "@mimo-ai/plugin"
+import { spawn, execFile } from "child_process"
+
+const REPO = "/mnt/workdrive/issue161-harness"
+const WR_ROOT = "/mnt/workdrive/wr-bridge"
+
+// ── MODE A: process-group-owned capture execution ──────────────────────
+interface OwnedResult { stdout: string; stderr: string; status: number; timedOut: boolean }
+
+function runOwned(command: string, timeoutMs: number): Promise<OwnedResult> {
+    return new Promise((resolve) => {
+        // /bin/sh -c "command" in its OWN process group (detached:true makes
+        // the child a session/group leader we can signal as a WHOLE).
+        const child = spawn("/bin/sh", ["-c", command], {
+            cwd: REPO,
+            stdio: ["ignore", "pipe", "pipe"],   // NEVER inherit the TUI tty
+            env: process.env,
+            detached: true,                      // own process group
+        })
+        let stdout = "", stderr = ""
+        let timedOut = false
+        let settled = false
+        const outChunks: Buffer[] = []
+        const errChunks: Buffer[] = []
+        child.stdout!.on("data", (d) => outChunks.push(d))
+        child.stderr!.on("data", (d) => errChunks.push(d))
+
+        const killGroup = (sig: NodeJS.Signals) => {
+            try { process.kill(-child.pid!, sig) } catch { /* already gone */ }
+        }
+        const finalize = (status: number) => {
+            if (settled) return
+            settled = true
+            clearTimeout(timer)
+            // detach listeners, then resolve — no late listeners remain
+            child.stdout!.removeAllListeners()
+            child.stderr!.removeAllListeners()
+            resolve({ stdout: Buffer.concat(outChunks).toString(), stderr: Buffer.concat(errChunks).toString(), status, timedOut })
+        }
+        const timer = setTimeout(() => {
+            timedOut = true
+            killGroup("SIGTERM")
+            // bounded grace for clean shutdown, then SIGKILL the group
+            setTimeout(() => killGroup("SIGKILL"), 2000)
+            // the exit/close event settles; a hard stop-guard settles anyway
+            setTimeout(() => finalize(124), 4000)
+        }, timeoutMs)
+
+        child.on("error", (e) => finalize(-1))
+        child.on("close", (code) => finalize(code ?? -1))
+    })
+}
+
+// ── MODE B: explicit detachment for "cmd &" invocations ────────────────
+function runDetached(command: string): Promise<string> {
+    return new Promise((resolve) => {
+        const logPath = `/tmp/mimo-detached-${Date.now()}-${Math.floor(Math.random() * 1e6)}.log`
+        const out = `exec >>"${logPath}" 2>&1; exec 0</dev/null; ${command}`
+        const child = spawn("/bin/sh", ["-c", `setsid /bin/sh -c '${out.replace(/'/g, `'\\''`)}'`], {
+            cwd: REPO,
+            stdio: "ignore",     // child rebinds its own fds — no PTY inheritance
+            env: process.env,
+            detached: true,
+            // unref: MiMo's event loop does not wait for it
+        })
+        child.unref()
+        resolve(JSON.stringify({
+            detached: true,
+            log: logPath,
+            note: "process detached (setsid, own fds); output streams to the log file only; fd 0/1/2 do NOT reference the MiMo tty",
+        }))
+    })
+}
+
+// ── wait-intent routing (semantic level, preserved from v1) ────────────
+async function tryCompileWaitIntent(command: string): Promise<string | null> {
+    let routeOut: string
+    try {
+        routeOut = await new Promise<string>((resolve, reject) => {
+            execFile("python3", [`${REPO}/scripts/await_intent_cli.py`, "route-bash", "--command", command], {
+                cwd: REPO, timeout: 60000, encoding: "utf-8",
+                env: { ...process.env, RUNE_WR_ROOT: WR_ROOT },
+                maxBuffer: 8 * 1024 * 1024,
+            }, (err, stdout) => { if (err && !stdout) reject(err); else resolve(stdout || "") })
+        })
+    } catch {
+        return null // router unavailable: normal execution (never block on routing)
+    }
+    const jl = routeOut.trim().split("\n").find((l) => l.startsWith("{"))
+    if (!jl) return null
+    let norm: any
+    try { norm = JSON.parse(jl) } catch { return null }
+    // STRICT gate: compile ONLY a normalized, concrete continuation.
+    if (!(norm.normalized === true &&
+          norm.action === "ContinuePendingOperation" &&
+          norm.operation_id && norm.sha_for_wait)) return null
+    const waitCmd = `python3 ${REPO}/scripts/ci_event_wait.py --sha ${norm.sha_for_wait} --deadline ${norm.deadline_secs} --op-type ${norm.op_type}`
+    const r = await runOwned(waitCmd, (norm.deadline_secs + 60) * 1000)
+    const jline = r.stdout.trim().split("\n").find((l) => l.startsWith("{"))
+    if (jline) {
+        return JSON.stringify({
+            ...JSON.parse(jline),
+            intent_compilation: {
+                raw_command_kind: norm.raw_command_kind || "sleep_poll",
+                literal_sleep_executed: false,
+                operation_id: norm.operation_id,
+                canonical_op_type: norm.op_type,
+                authority: norm.authority,
+            },
+        })
+    }
+    return JSON.stringify({ ok: false, stage: "compiled-wait", error: (r.stderr || "no output").slice(0, 300) })
+}
+
+export default tool({
+    description: "Run a shell command. If the command expresses external wait intent (sleep/check/poll aimed at CI, deploy, or release operations with pending operations), it is automatically compiled to Rune's event-driven continuation — you do not need to manage wait mechanics. Plain local commands execute normally. Commands ending in ' &' run detached with output logged to a file.",
+    args: {
+        command: tool.schema.string().describe("Shell command to run"),
+    },
+    async execute(args) {
+        // 1. wait-intent compilation (semantic, strict-gated)
+        try {
+            const compiled = await tryCompileWaitIntent(args.command)
+            if (compiled !== null) return compiled
+        } catch { /* fall through to normal execution */ }
+
+        // 2. MODE B: explicit detachment for backgrounded invocations
+        const cmd = args.command
+        if (/\b(nohup|setsid)\b/.test(cmd) || /&\s*$/.test(cmd)) {
+            return await runDetached(cmd)
+        }
+
+        // 3. MODE A: tool-owned, group-killed, captured execution
+        const r = await runOwned(cmd, 120000)
+        const text = r.stdout + (r.stderr ? `\n[stderr]\n${r.stderr}` : "")
+        if (r.timedOut) {
+            return `exit timed-out (process group terminated): ${text.slice(0, 500)}`
+        }
+        if (r.status !== 0) {
+            return `exit ${r.status}: ${text.slice(0, 500) || "?"}`
+        }
+        return text || "(no output)"
+    },
+})

config/umbrellas.json

@@ -1,7 +1,7 @@
 {
  "_comment": "GENERATED by rune.spine \u2014 compatibility view for legacy umbrella consumers. DO NOT EDIT: structural truth lives in store/spine/current.json; edits here are flagged by spine drift.",
  "_generated_by_spine": true,
- "generated_at": "2026-09-15T18:24:01Z",
+ "generated_at": "2026-09-16T18:23:38Z",
  "umbrellas": {
   "capability": {
    "description": "Tool selection and execution authority",
@@ -12,6 +12,7 @@
     "capability_broker",
     "connection_pool",
     "evidence_probe",
+    "forge",
     "forge_client",
     "intent_continuity",
     "local_tool_runtime",
@@ -44,7 +45,8 @@
     "drift_core",
     "drift_ledger",
     "drift_observability",
-    "failure_auto_filer"
+    "failure_auto_filer",
+    "programme_gates"
    ],
    "depends_on": [],
    "mirrors": [],
@@ -216,9 +218,11 @@
     "attention_capsule",
     "auto_context",
     "auto_tasks",
+    "behaviour_ledger",
+    "build_basis",
     "capability_fit",
+    "capability_ledger",
     "cognitive_budgeter",
-    "complexity_scorer",
     "construction_activation",
     "construction_commands",
     "construction_decision",
@@ -234,16 +238,25 @@
     "drift_resume",
     "event_wait",
     "failure_recovery",
+    "graph_projection",
+    "impact_preview",
+    "iteration",
     "layout_contract",
     "programme_continuation",
+    "project_registry",
     "release_notes",
     "salience_gate",
     "scaffold",
     "spine",
     "stage_guards",
+    "structural_migration",
+    "structural_model",
     "structural_store",
+    "testing_mode",
     "toolchain",
     "tui_backlog",
+    "wait_guard",
+    "wait_guard_corpus",
     "witness"
    ],
    "depends_on": [

config/v1_authority_map.json

@@ -104,15 +104,15 @@
         },
         {
           "path": "src/rune/attention_capsule.py",
-          "role": "AttentionCapsule — the typed ledger of admitted blocks the model receives (to_messages re-derives the runtime payload)",
+          "role": "AttentionCapsule \u2014 the typed ledger of admitted blocks the model receives (to_messages re-derives the runtime payload)",
           "disposition": "retain-authority",
-          "evidence": "P1-02 (#25): the capsule IS the product the model receives — the broker renders admitted blocks into it, the safety override mutates its user block in place (re-measured), runtime.run consumes capsule.to_messages(), and the trace v4 capsule_messages/capsule_content_hashes prove the logged capsule EXACTLY equals the sent payload. Legacy create_capsule/to_prompt (string-trim fake budgeting) deprecated with no live callers."
+          "evidence": "P1-02 (#25): the capsule IS the product the model receives \u2014 the broker renders admitted blocks into it, the safety override mutates its user block in place (re-measured), runtime.run consumes capsule.to_messages(), and the trace v4 capsule_messages/capsule_content_hashes prove the logged capsule EXACTLY equals the sent payload. Legacy create_capsule/to_prompt (string-trim fake budgeting) deprecated with no live callers."
         },
         {
           "path": "src/rune/inference_trace.py",
           "role": "Durable per-run inference trace (tokens served/estimated, output, latency, per-block visibility)",
           "disposition": "migrate-adapter",
-          "evidence": "P0-07 (#23): persists what ContextBroker (#19) assembled and what the transport served — builds FROM the broker trace, never re-measures; store state/inference_traces.jsonl."
+          "evidence": "P0-07 (#23): persists what ContextBroker (#19) assembled and what the transport served \u2014 builds FROM the broker trace, never re-measures; store state/inference_traces.jsonl."
         }
       ]
     },
@@ -160,13 +160,13 @@
           "path": "src/rune/capability_broker.py",
           "role": "Authoritative capability selector (select_for_job + verified floor + find_capability escape hatch)",
           "disposition": "retain-authority",
-          "evidence": "P1-01 (#24): select_for_job is the single selection authority — its ordered decision feeds LocalToolRuntime(tools=) at both construction sites and the _contributor_tools prompt block; degrade-not-crash falls back to full TOOLS with a tier-1 record_failure."
+          "evidence": "P1-01 (#24): select_for_job is the single selection authority \u2014 its ordered decision feeds LocalToolRuntime(tools=) at both construction sites and the _contributor_tools prompt block; degrade-not-crash falls back to full TOOLS with a tier-1 record_failure."
         },
         {
           "path": "memory/index/capability_cards.json",
           "role": "Capability-card index (rebuilt on empty/stale/corrupt; native cards synthesized from TOOLS metadata)",
           "disposition": "migrate-adapter",
-          "evidence": "P1-01 (#24): load_cards validates and rebuilds — the packaged empty array no longer passes as an index; cards carry risk/preconditions/side_effects copied from tool_executor.TOOLS."
+          "evidence": "P1-01 (#24): load_cards validates and rebuilds \u2014 the packaged empty array no longer passes as an index; cards carry risk/preconditions/side_effects copied from tool_executor.TOOLS."
         },
         {
           "path": "src/rune/local_tool_runtime.py",
@@ -486,12 +486,6 @@
           "disposition": "retain-authority",
           "evidence": "Defines the owner-approved canary-first Gitea sequence."
         },
-        {
-          "path": "src/rune/plugins/build_mode/__init__.py",
-          "role": "Checkpoint/ledger state-machine primitive used by current governed builds",
-          "disposition": "migrate-adapter",
-          "evidence": "Persists checkpoints but encodes an older phase order."
-        },
         {
           "path": "src/rune/build_mode.py",
           "role": "Separate BuildManager and worktree engine",
@@ -504,6 +498,9 @@
           "disposition": "archive-candidate",
           "evidence": "Reports fixed success strings for phases without executing their claimed effects."
         }
+      ],
+      "notes": [
+        "T17 17U: plugin BuildStateMachine deleted (zero importers; second parallel orchestrator)"
       ]
     },
     {
@@ -540,4 +537,4 @@
       ]
     }
   ]
-}
+}

docs/RELEASE_POLICY.md

@@ -0,0 +1,53 @@
+# Rune Semantic Release Policy (T20 §20B)
+
+Pre-1.0 convention. Scaffolding "V1" does NOT mean Rune 1.0.
+
+## Bump kinds
+
+**PATCH** (0.66.80 → 0.66.81):
+- bug fix, correction, implementation/internal maintenance
+- no meaningful new user/system capability
+
+**MINOR** (0.66.80 → 0.67.0):
+- meaningful new Rune capability
+- new subsystem functionality
+- materially expanded system behaviour
+- significant new supported workflow
+
+**MAJOR**: reserved for Rune 1.0+ compatibility/public-contract semantics.
+
+## How the machinery expresses this (no manual version edits)
+
+The existing machinery already maps commit shape → bump kind:
+- `semver_bump.next_version` (PR titles): feat→minor, else patch
+- `version_convergence.highest_warranted_bump` (push ranges):
+  feat/breaking→minor, fix/perf→patch, else None
+
+**Tranche-level rule (20B)**: a feature tranche lands its feature
+commits (`feat(...)`), and the convergence machinery bumps MINOR at
+the tranche's release boundary. Patch-only follow-ups (fix/perf)
+warrant only PATCH — the machinery cannot accidentally re-minor
+because `highest_warranted_bump` takes the max over the *post-
+boundary* range, and a fix-only range yields "patch".
+
+## Why T20 → 0.67.0
+
+T20 is a feature-level tranche (Rune-wide retrofit: structural
+taxonomy, capability/behaviour ledgers, rune graph, /testing backlog,
+Spine modernization, semantic release). The release is classified
+MINOR under this policy, earned through the governed convergence
+machinery — never a manual version edit.
+
+## T20 0.67.0 release record
+T20 classified MINOR under this policy: Rune-wide retrofit (structural
+taxonomy, capability/behaviour ledgers, rune graph, /testing backlog,
+Spine modernization, semantic release) = new subsystem functionality +
+materially expanded system behaviour. Earned through the governed
+convergence machinery (feat-bearing range → minor), never a manual edit.
+
+## Root cause record (T20, 2026-09-16)
+semver_bump re-derived the bump kind from the SYNTHESIZED title text —
+"minor: converged release" matched nothing → patch. Feature tranches
+T18/T19/T20 downgraded to 0.66.77-83. Fixed: MINOR_PREFIX_RE carries the
+convergence kind through; first push after the fix with a feat-bearing
+range lands 0.67.0 through the normal machinery.

docs/SCAFFOLDING_IMPLEMENTATION_AUDIT.md

@@ -0,0 +1,79 @@
+# SCAFFOLDING IMPLEMENTATION AUDIT + V1 GAP MATRIX (T18 §18B)
+
+_Every claim classified against evidence. Scale: LIVE_PROVEN (production
+evidence) / TEST_PROVEN (suite green, no production exercise) /
+IMPLEMENTED_UNPROVEN / PARTIAL / PLANNED / ABSENT / LEGACY / DUPLICATE._
+
+## Kernel claims
+
+| Claim | Status | Evidence |
+|---|---|---|
+| Contract lifecycle + legal transitions | LIVE_PROVEN | 28 contracts driven through real flow; refusal envelopes observed |
+| classify_mode (one classifier) | LIVE_PROVEN | gates TUI /build (17G), operator hook, tests 62+ |
+| Conversational intent layer | TEST_PROVEN | 22+ held-outs incl. unseen paraphrases; 17R live exercise (one real conversational proof) |
+| Programme continuation | LIVE_PROVEN | 17E 4-stage proof on real bridge; restart/dup/failure held-outs |
+| Event-driven waits (builder) | LIVE_PROVEN | T15 15Q real model build; T17E async stage |
+| Event-driven waits (CI) | LIVE_PROVEN | T16 16D deadline path ×2 + T17 natural wake (mode=event, 112.5s) |
+| Event replay (before-registration) | TEST_PROVEN + production-realistic exercise | 17C 4.6s vs real completed CI; natural-cycle confirmation: the 17Z wake arrived mid-wait, replay path itself not yet hit naturally |
+| Cross-user bridge delivery | LIVE_PROVEN | 17C repro as runner user (2.05s) + production deploys |
+| Provider boundary | TEST_PROVEN (structural guard) + observed loud-failure | 16F/G suites; no silent fallback observed in production runs |
+| Builder cannot self-certify | LIVE_PROVEN | T14 closure refusals ×2; phase-gated close |
+| Completion truth evidence-driven | LIVE_PROVEN | contract checkpoints; verify_test_truth refusals |
+| Interruption/resume | LIVE_PROVEN | T14E SIGKILL; 17E restart held-outs |
+| Impact preview (visible, pre-build) | ABSENT → T18 | nothing renders structured impact before build today |
+| Structural project model (first-class) | PARTIAL | stores are spine-shaped (entities/rels) but projects model CONTRACTS, not architecture; no domain/subsystem/interface nesting for arbitrary projects |
+| Structural queries/impact closure for projects | PARTIAL | spine.impact_frontier exists for Rune; project stores lack query API |
+| Research→Build Basis (durable, versioned) | ABSENT → T18 | research output today stays in transient context/artifacts |
+| Research-depth decision at construction entry | PARTIAL | ADAPT routes task classes; no explicit construction-stage research gate |
+| OUTWARD prior-art-first pass | PARTIAL | stage exists in Research Core; not strengthened to precedent-first ordering |
+| Schema versioning + consent-gated migration | PARTIAL | stores carry schema_version=1; no migration machinery/consent flow |
+| Environment/runtime model | PARTIAL | deployment_surface exists in Spine; project scaffolds don't model envs |
+| Workspace lifecycle (worktree per contract) | PARTIAL | BuildManager worktrees exist (legacy adapter); not wired to contracts |
+| Forge abstraction | ABSENT (Gitea-coupled scripts) | deploy/qualify call Gitea API directly |
+| Structural drift for project scaffolds | PARTIAL | drift_resume (16P) covers checkpoint-vs-reality; no file/entity-level drift detection |
+| Graph projection for visualisation | ABSENT → T18 | Spine has snapshots; no stable read-only graph projection |
+| Memory/Substrate | ABSENT (BY DESIGN — out of scope) | rule L |
+
+## V1 North Star gap matrix (this tranche's targets)
+
+| North Star capability | Gap | T18 action |
+|---|---|---|
+| Research-led construction (early research, Build Basis) | ABSENT Build Basis | 18C: build_basis.py + ADAPT depth hook |
+| OUTWARD precedent-first | PARTIAL | 18D: strengthen stage contract + real research run |
+| First-class structural Scaffold | PARTIAL (contract-shaped) | 18E: structural_model.py over structural_store core |
+| Structure→scope→governance | PARTIAL | 18F: queries + impact closure feeding contracts |
+| Visible impact preview | ABSENT | 18G: impact_preview projection |
+| Structural drift | PARTIAL | 18H: extend drift_resume with entity-level checks |
+| Schema versioning + consent | PARTIAL | 18I: migration + consent flow + tests |
+| Environment/runtime model | PARTIAL | 18J: env entities + verification distinction |
+| Workspace lifecycle | PARTIAL (legacy adapter) | 18K: workspace contract on the BuildManager adapter |
+| Forge boundary | ABSENT | 18L: forge.py adapter interface (Gitea impl) |
+| Full route convergence | PARTIAL (classify shared; backends differ) | 18M: audit + smallest fix |
+| Generalisation (not phrase list) | TEST_PROVEN | 18N: adversarial paraphrase families |
+| Self-scaffold | PARTIAL (contracts only) | 18O: structural model of Scaffolding itself |
+| Upgrade-via-Scaffold proof | ABSENT | 18P: one real upgrade driven by the scaffold |
+| Graph projection | ABSENT | 18Q: versioned read-only projection |
+
+## T19 additions (post-T18 classifications)
+
+| Capability | Status | Evidence |
+|---|---|---|
+| Project/Scaffold Registry | TEST_PROVEN | registry tests; boundaries proven (no truth in index, no Spine leak) |
+| /build governance fail-closed | LIVE_PROVEN | 19A: T18 degradation paths removed; failure-path held-outs |
+| Capability Ledgers | TEST_PROVEN | lifecycle+history+packet tests |
+| Surgical context packets | LIVE_PROVEN | 19R: packet bound exactly 1 file for a real change |
+| Behaviour/Test Specs + hardening lifecycle | TEST_PROVEN | ledger suites incl. generation history |
+| Selective invalidation | TEST_PROVEN | 19S-2/5/9/10 held-outs |
+| Predictive vs descriptive impact | TEST_PROVEN | delta persistence tests |
+| Post-change obligations | TEST_PROVEN | machine-derived from structural truth |
+| /testing backend + aggregate | TEST_PROVEN + LIVE (19R) | testing_mode suites; command wired in real TUI |
+| Observation→closure (user-confirm gate) | TEST_PROVEN | closure requires retest AND user confirm |
+| Forge failure never rewrites truth | TEST_PROVEN | 19S-14 held-out |
+| Self-hosted T19 change | LIVE_PROVEN | contract 19r-testing-command, 11-step scaffold-driven flow |
+
+## Kernel exceptions required (rule B record)
+
+None yet. Every T18 plan so far EXTENDS (new modules consuming
+structural_store) rather than modifying frozen kernel behavior. Any
+exception discovered during implementation will be recorded here with
+evidence that the V1 requirement could not be met otherwise.

docs/SCAFFOLDING_V1_DEFINITION.md

@@ -0,0 +1,153 @@
+# SCAFFOLDING V1 DEFINITION (T18 §18B)
+
+_Plane-English + technical definition of Scaffolding as it ACTUALLY
+exists at tranche T18 start (master 29570f4). Companion artifact:
+SCAFFOLDING_IMPLEMENTATION_AUDIT (evidence classification per claim)._
+
+## What Scaffolding is (plain English)
+
+Scaffolding is Rune's **construction authority**: the governed process
+by which software gets built or changed. It takes an authorized need,
+classifies what kind of construction it is, proportionally governs the
+work through a durable contract (with legal lifecycle transitions),
+derives scope from structural reality, drives builders, waits on events
+(not sleeps), refuses self-certified completion, verifies from
+canonical reality, and records evidence on durable objects so any
+future session can resume without a transcript.
+
+It is NOT a scheduler, NOT a memory system, NOT a provider selector,
+NOT a research engine, NOT a release system. It is the layer that
+decides *whether, how, and with what obligations* construction happens
+— and whether it actually finished.
+
+## What it owns
+
+- **Construction classification** (`construction_mode.classify_mode` —
+  the ONE classifier: NOT_CONSTRUCTION / LOCAL_CHANGE /
+  EXISTING_PROJECT_CHANGE / PROJECT_BUILD / UNKNOWN; never silently
+  chooses; unknown surfaces probe questions)
+- **Conversational interpretation** (`construction_intent.py` —
+  meaning/referents/authorization; DISCUSSION→PROPOSAL→USER_APPROVED;
+  feeds the ONE classifier, never deepens)
+- **Project Scaffold + Contracts** (`scaffold.py` — legal phase map
+  draft→approved→building→verifying→…→closed/failed/abandoned; scope;
+  obligations; checkpoints; predicted-vs-observed at close)
+- **Programme continuation** (`programme_continuation.py` —
+  run_construction_programme: stages 1:1 to contracts, persist→canary→
+  next; "task done ≠ programme done")
+- **Impact/scope machinery** (construction_decision, completeness
+  gates, affected-surface propagation)
+- **Stage guards** (`stage_guards.py` — readiness blocks, liveness
+  proves progress, exit canary proves effect; verify_test_truth refuses
+  false greens)
+- **Failure taxonomy** (`failure_recovery.py` — 7 classes incl.
+  PROVIDER_UNAVAILABLE; retry budgets; PERMANENT/APPROVAL never retry)
+- **Builder interface** (`construction_interface.py` — ONE builder
+  boundary; JSON envelopes; builder identity recorded-but-inert;
+  discover_active_contract; capabilities())
+
+## What it does NOT own
+
+- **Provider/model selection** (provider layer owns; ambient context
+  via `provider_context.require_model`; structural guard test)
+- **Research competence** (Research Core owns; Scaffolding invokes and
+  consumes — see 18C integration)
+- **Asynchronous wait/resume machinery** (W/R event bridge owns;
+  `event_wait.py` is the repo-side adapter: event drives continuation,
+  watchdog detects failure, durable record is truth)
+- **Release/deployment** (deploy_stage/promotion/qualify + Gitea
+  workflows own it; Scaffolding records evidence)
+- **Rune's structural self-model** (Spine owns — `spine.py` over
+  `structural_store.py`; Scaffolding stores use the SAME generic core)
+- **Long-horizon relevance/memory** (future Substrate — not built;
+  seam exists: construction_projection + construction_commands)
+- **The TUI** (client; sends text, renders projections)
+
+## How the flows work
+
+**New build (PROJECT_BUILD)**: conversational/explicit intent →
+classify_mode (+ project-existence evidence) → activate() bootstraps a
+provisional Project Scaffold (identity before repository, UNKNOWN
+fields explicit) → contract draft→approved (user provenance) →
+building (builder under event wait) → verifying (exit canary;
+independent evidence) → closed with predicted-vs-observed.
+
+**Existing-project change**: intent → classify (scoped/file/target
+evidence; proportional) → attach to existing authority → light or full
+contract by depth → same lifecycle, proportionate ceremony.
+
+**Research-led construction (V1 target — CORRECTED 2026-09-15, Nick):**
+
+> THE RESEARCH PLAN ITSELF IS CONTEXTUALLY GENERATED. There is NO
+> permanent research-topic checklist. For every request:
+> REQUEST/INTENT → understand target/current reality → identify material
+> unknowns/decisions/risks → generate a context-specific research plan →
+> perform proportional INWARD/OUTWARD/deeper research. OUTWARD asks what
+> already exists relevant to THIS specific intent (adopt/adapt/combine/
+> reject/gaps/innovation). The categories researched are selected from
+> context; deeper technical research is driven by unresolved questions
+> and consequence level, never performed mechanically.
+
+`build_basis.generate_research_plan()` implements this: topics are
+synthesized from THIS intent's material unknowns/decisions/risks;
+the held-out suite proves unrelated intents produce materially
+different plans and that no canned category list exists.
+
+**Future upgrades (V1 target)**: authorized need → research-depth
+decision (ADAPT) → Research Core pass → durable Build Basis →
+structural Scaffold consult/construct → impact closure + visible
+preview → contract with structurally-derived scope → isolated
+workspace → governed build/verify → merge/release → structural
+Scaffold updated. (Parts of this chain are new in T18 — see audit.)
+
+**Interruption/resume**: SIGKILL-safe. Durable contract + programme
+records + wait records are the truth; fresh process resumes from
+identity alone; duplicate signals idempotent (live-proven T14E/T17E).
+
+**Deployment/release participation**: Scaffolding does not run the
+pipeline; it consumes qualified CI/deploy evidence, records deployed
+identity on contracts, and refuses closure without it where contracted.
+
+## T19 layer model (the general engineering system)
+
+> "The Scaffold should let the LLM operate with surgical precision
+>  locally, while preserving global awareness of what else must be
+>  checked or changed."
+>
+> "Lower active cognitive load without losing the whole idea."
+
+- **STRUCTURAL MODEL** tells Rune what the project contains / how it connects.
+- **CAPABILITY LEDGER** provides compact local re-entry context (stable IDs
+  across moves; history preserved through supersede/retire).
+- **BEHAVIOUR VALIDATION LEDGER** tells Rune what intended behaviour is
+  actually confirmed — generation-aware, selective invalidation, automated
+  green never implies USER_CONFIRMED.
+- **PROJECT REGISTRY** tells Rune which Scaffolds/projects exist
+  (discovery/index only — not structural truth, not Spine).
+- **ITERATION ENGINE** (predictive→descriptive impact, impact-delta
+  records, machine-derived obligations) makes quicksand protection
+  STANDARD behaviour of every construction route.
+- **/TESTING** is a dependency-aware hardening programme: dynamic queue,
+  fix-for-B-may-reopen-A, closure requires retest AND user confirmation.
+- **FORGE** provides workflow/history projection (failure never rewrites
+  canonical validation truth).
+- **FUTURE SUBSTRATE** will coordinate sequencing/current focus/pause-
+  resume but does NOT own structural or validation truth.
+
+## How Spine relates
+
+Spine = Rune's canonical structural self-model (structural_store
+generic core, maturity ladder, impact_frontier). Scaffolding's project
+stores share the SAME generic core (zero Rune constants) — one graph
+discipline, two scopes: Spine models Rune; project Scaffolds model
+their projects. No duplicate truth: a project's structural model lives
+in its own store; Rune's lives in Spine. Later retrofit will modernise
+Spine using the discipline V1 generalises (18K relationship).
+
+## How Substrate will interact (without owning internals)
+
+Read: versioned outbound projection (construction_projection,
+SCHEMA_VERSION=1). Write: bounded validated commands
+(construction_commands — 6 commands, lifecycle-validated, idempotent,
+no direct storage mutation). Substrate asks; Scaffolding decides.
+Memory graph explicitly out of scope (T18 rule L).

docs/STRUCTURAL_MAP.md

@@ -22,7 +22,9 @@ and deploys Rune itself to `/mnt/workdrive/rune-code/current`.
 | Construction (build lifecycle) | `src/rune/scaffold.py` + `construction_*.py` | scaffold store (`<dir>/.rune/scaffold`) |
 | Builder sessions | `scripts/t15_builder_session.py` (event-driven successor; T14 is legacy) | contract + wait records |
 | Provider/model selection | `rune_operator` final decider; ambient context via `provider_context.require_model` | `state/model_routing_profiles.json` |
-| Wait/resume (any long op) | `src/rune/event_wait.py` + W/R daemon (out-of-repo snapshot at `~/.local/share/mimo-wait-resume`, data root `/mnt/workdrive/wr-bridge`) | waits/events/leases/resumes JSON |
+| Wait/resume (any long op) | `src/rune/event_wait.py` + W/R daemon (out-of-repo snapshot at `~/.local/share/mimo-wait-resume`, data root `/mnt/workdrive/wr-bridge` — PIN `RUNE_WR_ROOT`: unpinned consumers get a loud warning, never a silent split-brain) | waits/events/leases/resumes JSON |
+| Programme continuation | `src/rune/programme_continuation.py` (WIRED T17: `run_construction_programme` binds stages to Scaffolding contracts) | scaffold store `programmes/` |
+| Conversational construction | `src/rune/construction_intent.py` (meaning/referents/authorization) → `construction_mode.classify_mode` (the ONE classifier) | intents are transient; contracts durable |
 | CI qualification verdict | `scripts/deploy_qualify.py` (two legs, fail-closed) | Gitea commit status + runs |
 | Release/deploy | `scripts/deploy_stage.py` → `deploy_promotion.py` (monotonic, flock) | deploy root + `current`/`last-good` symlinks |
 | Research | `scripts/research_task_tree.py` (authority; labels are projection) | `research/issue-<N>/` |
@@ -45,8 +47,8 @@ and deploys Rune itself to `/mnt/workdrive/rune-code/current`.
 
 ## Unfinished / blocked / deprecated
 
-- programme_continuation.py: implemented + tested but UNWIRED (no
-  production caller) — the "continue problem" machinery awaits routing.
+- programme_continuation.py: WIRED (T17 17D — run_construction_programme
+  is the canonical multi-stage driver; 17E live-proven).
 - maintenance.yml canary-suite job: loops `shared/canary_*.py` — wrong
   dir (real canaries in `src/rune/`), job likely no-ops (LEGACY).
 - daemon out-of-repo: the W/R daemon is deployed from

docs/gitea_issue_reconciliation.json

@@ -11,38 +11,36 @@
   "NEEDS_REVALIDATION",
   "DEFERRED_FUTURE"
  ],
- "live_defects": [
-  324
- ],
+ "live_defects": [],
  "records": [
   {
    "number": 324,
    "title": "Engine defect: checkpoint writer fails deterministically on aborted worker sessions (MessageAbortedError -> empty checkpoint shells)",
-   "tracker_state": "open",
-   "reconciliation_state": "VALID_OPEN",
+   "tracker_state": "closed",
+   "reconciliation_state": "FIXED_VERIFIED",
    "labels": [
     "bug",
     "custodian",
     "life",
     "memory"
    ],
-   "live_defect": true,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "live_defect": false,
+   "last_revalidated": "2026-09-20",
+   "next_action": "none \u2014 defect FIXED_VERIFIED (present-absence 2026-09-19); stale bug label removed 2026-09-20 after #407 fix (PR #408 merged) stopped the workflow re-adding it"
   },
   {
    "number": 316,
    "title": "ADAPT-1 B3-v2 (RESEARCH-LIKE): Qdrant associative-memory projection spike (executes #162)",
-   "tracker_state": "open",
-   "reconciliation_state": "VALID_OPEN",
+   "tracker_state": "closed",
+   "reconciliation_state": "FIXED_VERIFIED",
    "labels": [
     "governance",
     "memory",
     "perception"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-12",
-   "next_action": "B3-v2 Qdrant associative-memory projection spike \u2014 not started; ADAPT-1 sub-item under epic #284"
+   "last_revalidated": "2026-09-20",
+   "next_action": ""
   },
   {
    "number": 315,
@@ -237,8 +235,8 @@
   {
    "number": 183,
    "title": "Future: typed temporal semantics for facts, relationships, beliefs, and preferences",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "governance",
@@ -250,14 +248,14 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #181 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 182,
    "title": "Future: GitHub code-search prior-art audit for graph and vector memory",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "governance",
@@ -266,8 +264,8 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #181 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 181,
@@ -287,13 +285,13 @@
    ],
    "live_defect": false,
    "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "next_action": "epic holds absorbed children #182 #183 + research watchlist #164 #165 #166; closes when prerequisites land or ideas dropped"
   },
   {
    "number": 179,
    "title": "Future: succession/privacy semantics and lineage evaluation",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "governance",
@@ -305,14 +303,14 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #175 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 178,
    "title": "Future: evidence-grounded ancestral perspective with explicit uncertainty",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "governance",
@@ -322,14 +320,14 @@
     "perception"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #175 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 177,
    "title": "Future: temporal autobiographical model with provenance and reinterpretation lineage",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "governance",
@@ -340,14 +338,14 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #175 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 176,
    "title": "Future: lineage-aware situated curiosity for meaningful autobiographical gaps",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "feature",
@@ -358,8 +356,8 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #175 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 175,
@@ -379,13 +377,13 @@
    ],
    "live_defect": false,
    "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "next_action": "epic holds absorbed children #176-#179 as checklist items; closes when prerequisites land or ideas dropped"
   },
   {
    "number": 166,
    "title": "RESEARCH WATCHLIST: Memory-R1 (RL memory ops), Titans (test-time memory), Vespa/Weaviate/Milvus (retrieval competitors)",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "growth",
@@ -394,14 +392,14 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #181 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 165,
    "title": "RESEARCH: SimpleMem semantic compression + A-MEM dynamic linking + Letta sleep-time compute",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "infrastructure",
@@ -410,14 +408,14 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #181 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 164,
    "title": "RESEARCH: HippoRAG 2 \u2014 PPR-style associative propagation as warm-neuron activation candidate",
-   "tracker_state": "open",
-   "reconciliation_state": "DEFERRED_FUTURE",
+   "tracker_state": "closed",
+   "reconciliation_state": "HISTORICAL_EVIDENCE",
    "labels": [
     "P3 \u2014 low",
     "growth",
@@ -426,27 +424,27 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 idea absorbed into parent epic #181 as tracked checklist item; full detail preserved in this closed issue; re-mint when live"
   },
   {
    "number": 163,
    "title": "Temporal graph backend spike: Neo4j vs FalkorDB (LadybugDB experimental; Graphiti as reference)",
    "tracker_state": "open",
-   "reconciliation_state": "NEEDS_REVALIDATION",
+   "reconciliation_state": "VALID_OPEN",
    "labels": [
     "P1 \u2014 high",
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "run the backend spike; compare on same corpus/query set; record evidence-backed recommendation"
   },
   {
    "number": 162,
    "title": "Qdrant associative-memory projection spike (dense/sparse/multivector + ColBERT late-interaction reranking)",
-   "tracker_state": "open",
-   "reconciliation_state": "NEEDS_REVALIDATION",
+   "tracker_state": "closed",
+   "reconciliation_state": "SUPERSEDED",
    "labels": [
     "P1 \u2014 high",
     "custodian",
@@ -454,8 +452,8 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 scope carried verbatim by #316 (ADAPT-1 B3-v2); single-tracker rule"
   },
   {
    "number": 159,
@@ -478,8 +476,8 @@
   {
    "number": 158,
    "title": "Generated wiring-status / architecture-truth report",
-   "tracker_state": "open",
-   "reconciliation_state": "VALID_OPEN",
+   "tracker_state": "closed",
+   "reconciliation_state": "SUPERSEDED",
    "labels": [
     "P2 \u2014 medium",
     "growth",
@@ -489,8 +487,8 @@
     "ready"
    ],
    "live_defect": false,
-   "last_revalidated": "2026-09-11",
-   "next_action": ""
+   "last_revalidated": "2026-09-19",
+   "next_action": "none \u2014 scope carried verbatim by #315 (ADAPT-1 B2-v2); single-tracker rule"
   },
   {
    "number": 156,
@@ -1149,8 +1147,20 @@
    "live_defect": false,
    "last_revalidated": "2026-09-11",
    "next_action": ""
+  },
+  {
+   "number": 407,
+   "title": "Auto-labeler re-adds bug label to closed fixed issues, defeating reconciliation",
+   "tracker_state": "closed",
+   "reconciliation_state": "FIXED_VERIFIED",
+   "labels": [
+    "infrastructure"
+   ],
+   "live_defect": false,
+   "last_revalidated": "2026-09-20",
+   "next_action": "fixed by PR #408 (closed-issue guard + keyword fallback filing-time-only); verified live: bug label removed from #324 and no re-add after 75s across label events"
   }
  ],
- "last_reconciled": "2026-09-12",
- "reconciled_by": "PL1 held-out era reconciliation (fresh session 2026-09-12)"
-}
+ "last_reconciled": "2026-09-20",
+ "reconciled_by": "2026-09-20 overnight Atlas close-out: R1 complete (#376-#406 all R1_QUALIFIED), epic #375 closed; artifact updated for #316 (FIXED_VERIFIED spike concluded) and #324 (FIXED_VERIFIED, label blocker owned by #407); prior: fresh-session tranche 2026-09-19 (template retrofit, closures #158/#162 SUPERSEDED + #324, absorption pass)"
+}

lint-baseline.json

@@ -1,4 +1,4 @@
 {
- "BLE001": 354,
- "S110": 80
+  "BLE001": 347,
+  "S110": 75
 }

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rune"
-version = "0.66.71"
+version = "0.87.5"
 description = "Rune — a stateful coding assistant with persistent memory, orchestration, and TUI"
 requires-python = ">=3.10"
 

pyright-baseline.json

@@ -1,5 +1,5 @@
 {
- "errorCount": 117,
- "warningCount": 443,
- "informationCount": 0
+  "errorCount": 117,
+  "warningCount": 454,
+  "informationCount": 0
 }

pyrightconfig.json

@@ -1,29 +1,34 @@
 {
-    "typeCheckingMode": "standard",
-    "pythonVersion": "3.14",
-    "reportMissingImports": "warning",
-    "reportMissingModuleSource": "none",
-    "reportMissingTypeStubs": "none",
-    "reportUnknownArgumentType": "none",
-    "reportUnknownParameterType": "none",
-    "reportUnknownVariableType": "none",
-    "reportUnknownMemberType": "none",
-    "reportMissingTypeArgument": "none",
-    "reportUntypedFunctionDecorator": "none",
-    "reportUntypedClassDecorator": "none",
-    "reportUntypedBaseClass": "none",
-    "reportPrivateUsage": "none",
-    "reportOptionalMemberAccess": "warning",
-    "reportUnnecessaryIsInstance": "warning",
-    "reportUnnecessaryComparison": "warning",
-    "reportUnnecessaryTypeIgnoreComment": "warning",
-    "reportPossiblyUnboundVariable": "error",
-    "reportUndefinedVariable": "error",
-    "reportAttributeAccessIssue": "warning",
-    "include": ["src/rune"],
-    "exclude": [
-        "src/rune/__pycache__",
-        "**/node_modules",
-        "**/__pycache__"
-    ]
-}
+  "typeCheckingMode": "standard",
+  "pythonVersion": "3.14",
+  "reportMissingImports": "warning",
+  "reportMissingModuleSource": "none",
+  "reportMissingTypeStubs": "none",
+  "reportUnknownArgumentType": "none",
+  "reportUnknownParameterType": "none",
+  "reportUnknownVariableType": "none",
+  "reportUnknownMemberType": "none",
+  "reportMissingTypeArgument": "none",
+  "reportUntypedFunctionDecorator": "none",
+  "reportUntypedClassDecorator": "none",
+  "reportUntypedBaseClass": "none",
+  "reportPrivateUsage": "none",
+  "reportOptionalMemberAccess": "warning",
+  "reportUnnecessaryIsInstance": "warning",
+  "reportUnnecessaryComparison": "warning",
+  "reportUnnecessaryTypeIgnoreComment": "warning",
+  "reportPossiblyUnboundVariable": "error",
+  "reportUndefinedVariable": "error",
+  "reportAttributeAccessIssue": "warning",
+  "include": [
+    "src/rune"
+  ],
+  "exclude": [
+    "src/rune/__pycache__",
+    "**/node_modules",
+    "**/__pycache__"
+  ],
+  "extraPaths": [
+    "scripts"
+  ]
+}

requirements-ci.txt

@@ -1,5 +1,5 @@
 # This file was autogenerated by uv via the following command:
-#    uv pip compile pyproject.toml -o requirements-ci.txt --extra dev --extra memory --python-version 3.11
+#    uv pip compile pyproject.toml -o /tmp/req_new.txt --extra dev --extra memory --python-version 3.11
 aiohappyeyeballs==2.7.1
     # via aiohttp
 aiohttp==3.14.3
@@ -34,7 +34,7 @@ httpcore==1.0.9
     # via httpx
 httpx==0.28.1
     # via rune (pyproject.toml)
-idna==3.19
+idna==3.20
     # via
     #   anyio
     #   httpx
@@ -56,7 +56,7 @@ mdit-py-plugins==0.6.1
     # via textual
 mdurl==0.1.2
     # via markdown-it-py
-multidict==6.8.0
+multidict==6.9.0
     # via
     #   aiohttp
     #   yarl
@@ -64,13 +64,13 @@ nodeenv==1.10.0
     # via pyright
 packaging==26.3
     # via pytest
-platformdirs==4.11.8
+platformdirs==4.11.11
     # via textual
 pluggy==1.6.0
     # via
     #   diff-cover
     #   pytest
-propcache==0.5.2
+propcache==0.5.4
     # via
     #   aiohttp
     #   yarl
@@ -118,5 +118,5 @@ typing-extensions==4.16.0
     #   textual-autocomplete
 websockets==17.1
     # via rune (pyproject.toml)
-yarl==1.24.5
+yarl==1.25.1
     # via aiohttp

research/memory-atlas-r1/A-complementary-learning-systems/00_issue_scope.md

@@ -0,0 +1,47 @@
+# 00 — ISSUE SCOPE (#376 R1)
+
+## Core question
+What does Complementary Learning Systems (CLS) actually establish about fast episodic acquisition, slower generalization, consolidation, replay, schemas, interference, reconsolidation, and retention — and which of those mechanisms should or should not inform Rune's Memory architecture?
+
+## Subquestions
+1. What did the original CLS theory actually claim?
+2. Which claims were empirical vs computational/theoretical?
+3. What has changed since the original theory?
+4. Which mechanisms survived later evidence?
+5. Which were weakened or substantially revised?
+6. How does schema learning change "fast vs slow"?
+7. What is known about replay selection?
+8. What is known about destructive interference?
+9. What is known about memory transformation during consolidation?
+10. What is known about reconsolidation?
+11. Does consolidation necessarily imply transformation?
+12. When is rapid integration possible?
+13. What evidence exists against a simple dual-store interpretation?
+14. What competing theories explain the same observations?
+15. What parts are biological constraints rather than general learning principles?
+16. Which properties transfer to software agents?
+17. Which do NOT transfer?
+18. Does Rune already implement analogous behavior?
+19. What would materially alter Rune's target architecture?
+20. What remains experimental?
+
+## Hypotheses under test (from R0, NOT accepted)
+H1: fast exact episodic storage + slow generalized knowledge is the right Rune split.
+H2: two stores / two writers is the software form.
+H3: schema-gated fast consolidation is justified.
+H4: consolidation should be utility-prioritized, not recency-based.
+H5: covering episodes must be retained after generalization.
+H6: reconsolidation has a software analogue in supersession.
+H7: independent-evidence corroboration should gate promotion.
+H8: destructive consolidation must be rejected (append-only).
+H9: evidence→episode→observation→belief→procedure is the right progression.
+
+## Falsifiers
+- F1: If deeper evidence shows no useful fast/slow separation outside biological constraints, the CLS architectural analogy is weakened or rejected.
+- F2: If schema-rapid-integration findings fail replication or are explained by simpler mechanisms, H3 falls.
+- F3: If replay prioritization evidence is task-specific (rodent navigation) with no general principle, H4 weakens to speculation.
+- F4: If reconsolidation's boundary conditions prove so biological that no software analogue preserves the useful property, H6 falls.
+- F5: If retained-episodes practice has no measured benefit in AI systems (consolidation without retention works as well), H5 is a preference, not a requirement.
+
+## Stopping criterion
+Evidence saturation: new sources repeat known mechanisms/criticisms, add only detail.

research/memory-atlas-r1/A-complementary-learning-systems/01_inward.md

@@ -0,0 +1,32 @@
+# 01 — INWARD: Current Rune reality (evidence-first)
+
+_Evidence hierarchy: observed runtime > persisted canonical state > independent tests > source existence > design docs. Sources: T0 gates, T0.1 reconciliation, R0 artifact, direct store inspection (this tranche, read-only)._
+
+## What Rune already does (PROVEN, T0/T0.1)
+- **Fast exact capture:** every entry append-only with created_at; dedupe/supersede gate with receipts (T0 PROVEN_PRESENT). 924 canonical entries; supersession preserves prior rows (56 superseded retained).
+- **Slow derived layer:** knowledge.json consolidation (PROVEN to run; single inspectable writer `memory_consolidation.py`); source-attributed (memory/abstraction/neuron/graph provenance counts in T0 map).
+- **Trust lifecycle:** provisional/validated/locked + HMAC audit ledger (PROVEN — but T0.1: trust does NOT gate retrieval today).
+- **Dual-write discipline:** episodic writes synchronous via `memory_store.py add_entry`; consolidation runs offline. Two writers exist structurally (agent path vs consolidation path).
+- **Failure learning:** wash_count/use history, promotion_eligible flag (PROVEN fields; promotion gate semantics = design, not exercised at scale).
+
+## What is DESIGNED but not proven
+- `derived_from` links: ABSENT (T0.1/M: "what depended on X" unanswerable).
+- Utility-prioritized or schema-gated consolidation: ABSENT (consolidation = full sweep; trigger non-deterministic — T0.1 R5: no cron/timer exists, agent-invoked).
+- Reconsolidation loop: ABSENT (locked is terminal; retrieved beliefs are not re-litigated).
+- Case layer (episode→case→procedure): ABSENT.
+- Independent-evidence corroboration test: ABSENT (promotion_eligible driven by wash_count = frequency, not independence).
+
+## What is BROKEN/DORMANT
+- Sleep-time transcript mining: BROKEN (stale DB path, T0).
+- Warm tier: vestigial (all 924 rows tier='warm'; T0.1 R4).
+- Graph projection: dormant (last edge 2026-08-26).
+- 439/838 active entries unindexed (embedder silent failure — T0.1 R3): the fast layer itself is LEAKY.
+
+## R0 CLS claims (to reconcile, not accept)
+R0 (families/complementary_learning_systems.md) claimed CLS supports: H1-H9 above, classifications COVERED (two-store split), ADAPT (utility qualification, shadow-mode, schema fast-path, reconsolidation loop, utility-prioritized consolidation), REJECT (recency-based priority, destructive consolidation). T1-impact flag: YES (three missing mechanisms).
+
+## Where R0 made implementation leaps
+1. R0 said "utility (retrieved-and-used count)" as qualification signal — but Rune's wash_count IS a retrieved-use count and T0 evidence shows it was never validated as a quality signal (it's frequency, gameable, and the T0.1 store shows superseded entries with high wash counts).
+2. R0's "schema-gated fast path" assumed schema detection is tractable — no Rune mechanism for schema-matching exists (abstraction.db has 59 facts; no matching machinery).
+3. R0's reconsolidation analogue assumed retrieval-triggered lability maps to supersession — but Rune supersession is write-triggered, not retrieval-triggered; the mapping was asserted, not derived.
+4. R0 did not distinguish which CLS claims are empirical vs computational assumptions (e.g. d≈0.5 decay is a fit parameter, not a law).

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/README.md

@@ -0,0 +1,6 @@
+# 02 — OUTWARD (populated by the deep-research actor; verified by controller)
+
+Files: historical_foundations.md, modern_cls.md, consolidation_and_replay.md,
+schema_learning.md, reconsolidation.md, interference_and_forgetting.md,
+competing_models.md, criticism_and_limitations.md, software_and_ai_analogues.md
++ sources.md (ledger) + claims.json (machine-readable).

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/competing_models.md

@@ -0,0 +1,8 @@
+# Competing theories (researched from critics, not just CLS advocates)
+
+- **MTT vs standard consolidation** (Nadel & Moscovitch 1997/2000 vs Squire & Alvarez 1995): retrograde amnesia gradients exist in BOTH directions depending on lesion/method; meta-analyses of patient data show inconsistent gradient temporality. Status: genuinely UNRESOLVED.
+- **Hippocampal indexing vs store-and-transfer:** Teyler & Rudy 2007 (DOI 10.1002/hipo.20350); Ryan/Tonegawa 2015 engram work (DOI 10.1126/science.aaa5542) favors trace-persistence + retrieval-dependence over physical transfer. 2025 reassessment preprint exists (Authorea).
+- **Consolidation skeptics / old-memory hippocampal engagement:** Nadel, Hupbach, Gomez & Newman-Smith 2012 (Neurosci Biobehav Rev) — hippocampus remains active for remote memories; Bontempi et al. 1999 (J Neurosci); Frankland et al. 2004, Science 304. DOI 10.1126/science.1094804 — remote memories shift cortical systems (ACC) but hippocampal damage still disrupts DETAILED remote recall; Squire camp counters deficits reflect detail/quality not necessity (Squire, Genzel, Wixted & Morris 2015, CSH Perspect Biol). **This is the field's fault line on transformation-vs-retention.**
+- **Trace Transformation Theory:** R0's "Winsneski/Bhatt" DOES NOT EXIST. Verified anchors: Moscovitch & Gilboa 2021 preprint (OSF, DOI 10.31234/osf.io/yxbrs) + Sekeres/Winocur/Moscovitch 2018.
+- **Bayesian/latent-cause:** Gershman, Blei & Niv 2010, Psych Review 117:197 — reconsolidation/extinction phenomena emerge from latent-cause inference; reconsolidation = belief-updating special case. This is the strongest competing FRAMEWORK for Rune: it explains the same data without a biological consolidation story.
+- **CLS v2 (McClelland et al. 2020)** absorbs schema effects and responds to MTT — the live theoretical front.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/consolidation_and_replay.md

@@ -0,0 +1,13 @@
+# Consolidation & replay
+
+**Foster & Wilson 2006, Nature 440:680. DOI 10.1038/nature04587.** Reverse replay of behavioral sequences in awake hippocampal place cells.
+
+**Carr, Jadhav & Frank 2011, Nat Neurosci 14:147. DOI 10.1038/nn.2732.** Awake replay serves BOTH retrieval and consolidation — unresolved dual role.
+
+**Ambrose, Pfeiffer & Foster 2016, Neuron 91:1342. DOI 10.1016/j.neuron.2016.07.047.** Awake reverse replay gated by changing reward — precursor evidence for prioritization.
+
+**Mattar & Daw 2018, Nat Neurosci 21:1609. DOI 10.1038/s41593-018-0232-z.** Computational model: replay prioritized by EXPECTED FUTURE UTILITY (gain = value of replaying; need = state relevance), NOT recency; replays benefit FUTURE learning. Makes replay prospective/selective — biological analog of prioritized experience replay, and a direct constraint on CLS's replay-as-teacher loop.
+
+**Tanrıverdi et al. 2023, J Cogn Neurosci. DOI 10.1162/jocn_a_02021.** In humans, MORE awake hippocampal-cortical co-reactivation predicted MORE forgetting of details — co-reactivation may reorganize/gist-ify rather than preserve.
+
+**Method validity caveat:** "Evaluating hippocampal replay without a ground truth" (eLife 2023, DOI 10.7554/eLife.85635.sa0) + 2024 dopamine-signaling exchange (eLife): replay DECODING methods still contested — treat specific replay-content claims as method-dependent.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/criticism_and_limitations.md

@@ -0,0 +1,10 @@
+# Negative evidence / limitations
+
+1. **Fenn et al. 2009** (DOI 10.1101/lm.1500808): sleep REDUCED false memories — direct counter-result to Payne 2009. The gist-consolidation direction is not settled.
+2. **Tanrıverdi et al. 2023** (DOI 10.1162/jocn_a_02021): replay-like co-reactivation associated with FORGETTING — consolidation-as-helping is not monotone.
+3. **RIF reliability** (European Psychologist 2011, DOI 10.1027/1016-9040/a000040; Frontiers 2014, DOI 10.3389/fpsyg.2014.01343; Camp/Pecher/Schmidt 2007 cue-independent tests): effect size unstable across labs/cues; inhibition interpretation often fails.
+4. **Reconsolidation human failures:** prediction-error boundary (Sevenster/Kindt) means many "reactivation" protocols fail to destabilize — numerous human nulls (Exton-McGuinness & Reichelt review).
+5. **Sharon/Moscovitch/Gilboa 2011** (PNAS, DOI 10.1073/pnas.1005238108): rapid acquisition of arbitrary associations WITHOUT hippocampus — counterevidence to strict hippocampal necessity for fast learning.
+6. **Ryan/Tonegawa engram line** (DOI 10.1126/science.aaa5542): retrograde amnesia without trace loss — behavioral "forgetting after consolidation disruption" can be RETRIEVAL failure, not trace destruction; weakens lesion-based consolidation arguments in BOTH directions.
+7. **Hoffman et al. 2024, Memory & Cognition. DOI 10.3758/s13421-024-01576-x:** "Awake targeted memory reactivation doesn't work" — a named negative result.
+8. **Two R0-brief references do not exist** (McClelland/Whyte 1994; Winsneski/Bhatt) — flagged and excluded (see sources.md).

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/historical_foundations.md

@@ -0,0 +1,7 @@
+# Historical foundations (API-verified citations)
+
+**McClelland, McNaughton & O'Reilly 1995, "Why there are complementary learning systems in the hippocampus and neocortex," Psych Review 102(3):419-457. DOI 10.1037/0033-295X.102.3.419.**
+Claims verified: (1) catastrophic interference in backprop-style networks — new arbitrary associations sharing representations destroy old ones; (2) forces slow, interleaved, small-step statistical learning in neocortex; (3) structurally separate hippocampus with sparse representations provides fast episodic learning and later acts as TEACHER via replay; (4) episodes become neocortical gist. Computational assumptions: hippocampal sparseness (pattern separation), neocortical overlap (generalization), replay-driven consolidation.
+NOTE: the "McClelland/McNaughton/Whyte 1994 bitter-tracing paper" from the R0 brief DOES NOT EXIST (Crossref/OpenAlex/arXiv searched) — likely conflation of the 1995 review with animal rapid-learning studies. Flagged; excluded from ledger.
+
+**Squire 1992 (Archives of Neurology); Squire & Alvarez 1995 (Curr Opin Neurobiol).** Declarative-memory background; hippocampal involvement TEMPORARY; systems consolidation = neocortex gradually sufficient. This is the position CLS inherits — and the main target of MTT critics.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/interference_and_forgetting.md

@@ -0,0 +1,9 @@
+# Interference / forgetting / generalization hazards
+
+**McCloskey & Cohen 1989 (Psychol Learn Motiv 24:109); Ratcliff 1990 (JEP:General 119:195).** Catastrophic interference — the motivating phenomenon for CLS; robust in simulation.
+
+**O'Reilly & Norman 2002, TiCS 6. DOI 10.1016/s1364-6613(02)02005-3; Norman & O'Reilly 2003, Psych Review 109. DOI 10.1037/0033-295x.110.4.611.** REC model: hippocampal pattern SEPARATION (prevents interference/false memories) vs pattern COMPLETION (retrieval); computational trade-off explains age-related and amnesic distortions. Robust computationally; hippocampal-subfield fMRI support (Lacy/Yassa/Stark line, e.g. 2011 Learn Mem, DOI 10.1101/lm.1971111).
+
+**False memories via gist:** Payne et al. 2009, Neurobiol Learn Mem. DOI 10.1016/j.nlm.2009.03.007 — sleep INCREASED DRM false memory (gist consolidation). **BUT Fenn et al. 2009, Learn Mem. DOI 10.1101/lm.1500808 found the OPPOSITE** (sleep reduced false memories). Flag: the gist-consolidation claim is directly contested at the effect level. Ledger records the PAIR.
+
+**Retrieval-induced forgetting:** Anderson, Bjork & Bjork 1994, JEP:LMC 20:1063. DOI 10.1037/0278-7393.20.5.1063. Meta-analytically real on average — Murayama et al. 2014, Psych Bull. DOI 10.1037/a0037505 — but strong cue-dependence; the INHIBITION interpretation contested (interference accounts; Raaijmakers-school critiques); reliability concerns documented (European Psychologist 2011, DOI 10.1027/1016-9040/a000040; Frontiers in Psychology 2014, DOI 10.3389/fpsyg.2014.01343). Effect real; mechanism and cross-lab reliability of the inhibitory version unsettled.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/modern_cls.md

@@ -0,0 +1,13 @@
+# Modern CLS (CLS v1 → v2)
+
+**Nadel & Moscovitch 1997 (Hippocampus 7:217); Nadel et al. 2000 (Psych Review 107:66).** MTT: each retrieval creates a new hippocampal trace; episodic memories stay hippocampus-dependent FOREVER; only semanticized gist becomes neocortex-dependent. Direct challenge to standard consolidation and CLS's teacher-transfer picture.
+
+**Teyler & DiScenna 1986; Teyler & Rudy 2007 (Hippocampus, DOI 10.1002/hipo.20350).** Hippocampal indexing theory: hippocampus stores an INDEX only; cortical representations reinstated at retrieval — consolidation is index elaboration, not trace transfer.
+
+**Ryan, Roy, Pignatelli, Arons & Tonegawa 2015, Science 348:1007. DOI 10.1126/science.aaa5542.** Optogenetic reactivation of hippocampal engram cells rescued memory expression after anisomycin-induced amnesia; silent engrams later matured (Roy et al. 2017 PNAS, DOI 10.1073/pnas.1714248114). Bearing: dissociates trace STORAGE from trace RETRIEVAL — amnesia is often retrieval failure, undermining simple "consolidation = strengthening" readings used by BOTH CLS and its critics.
+
+**Winocur & Moscovitch 2011 (JINS 17:766); Sekeres et al. 2018 (Hippocampus).** Transformation hypothesis: remote memories are TRANSFORMED (episodic→semantic; vivid→schematic), not copied.
+
+**Kumaran, Hassabis & McClelland 2016, TiCS 20(7). DOI 10.1016/j.tics.2016.05.004.** CLS updated: rapid neocortical integration via schema-consistency, episodic control, deep-learning interpretation; explicitly reconciles Tse findings with CLS. Robust as framework paper; each added claim inherits its own evidence base.
+
+**McClelland, McNaughton & Lampinen 2020, Phil Trans R Soc B 375. DOI 10.1098/rstb.2019.0637.** CLS v2: schema consistency, replay gating, explicit MTT responses.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/reconsolidation.md

@@ -0,0 +1,11 @@
+# Reconsolidation
+
+**Nader, Schafe & LeDoux 2000, Nature 406:722. DOI 10.1038/35021052.** Anisomycin in lateral amygdala after retrieval blocks subsequent expression of an already-consolidated fear memory — consolidated memories re-enter a labile state. Method: Pavlovian fear conditioning + post-reactivation infusion.
+
+**Tronson & Taylor 2007, Nat Rev Neurosci 8. DOI 10.1038/nrn2090.** Canonical review: successful replications across tasks/species AND wildly heterogeneous boundary conditions.
+
+**Boundary conditions (the crucial ledger part):** Sevenster, Beckers & Kindt 2014, Learn Mem 21. DOI 10.1101/lm.035493.114 — destabilization requires sufficient PREDICTION ERROR (violated expectation); a mere reminder does not. Exton-McGuinness, Lee & Reichelt 2015 (Neurosci Biobehav Rev, DOI 10.1016/j.bbr.2014.10.011) + Lee 2009 (Trends Neurosci): memory strength and age limit labilization (weak/very old memories resist).
+
+**Framing:** reconsolidation is best understood as UPDATING WITH A GATE (prediction error), not automatic restabilization. Whether it differs from ordinary updating only in timing: UNRESOLVED. Replication: rodent amygdala robust; human literature mixed (benzodiazepine/propranolol inconsistencies).
+
+**Adversarial canon (see 05_adversarial.md):** Rudy et al. 2006 (Learn Mem 13:1-3, anisomycin non-specificity); Lattal & Abel 2004 (PNAS 101:4667, deficits REVERSE with time = retrieval failure); Morris et al. 2006 (Neuron 50:479, nonspecific effects). Nader & Hardt 2009 (Nat Rev Neurosci 10:224-234) is the PRO case — the phenomenon requires a "case for" paper.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/schema_learning.md

@@ -0,0 +1,10 @@
+# Schema learning
+
+**Tse et al. 2007, Science 313:76 (neuroscience pages 1130-1133 of that issue). DOI 10.1126/science.1135935.** Rats: flavor-place paired associates over weeks; schema-CONSISTENT new pairs learned in one trial and became hippocampal-lesion-insensitive (neocortical immediate-early gene markers); schema-INCONSISTENT pairs needed weeks + hippocampal replay. Strongest single result for schema-gated rapid integration — the finding that forced McClelland to revise CLS.
+
+**Tse et al. 2011, Science 333:891. DOI 10.1126/science.1205274.** Immediate-early gene activation in neocortex for schema-consistent encoding.
+
+**McClelland 2013, JEP:General 142(4):1190. DOI 10.1037/a0033812.** Principled CLS revision: schema consistency permits small neocortical weight changes that don't cross interference thresholds.
+
+**Replication status:** core effect replicated in Morris lab (2010/2011); human echo: Audrain & McAndrews 2022, Nature Communications. DOI 10.1038/s41467-022-33517-0 (fMRI scaffold-for-integration). BUT the neocortex-alone/hippocampal-independence interpretation is CONTESTED: Sharon, Moscovitch & Gilboa 2011, PNAS 108:17263-17268. DOI 10.1073/pnas.1005238108 (rapid arbitrary associates WITHOUT hippocampus); hippocampal damage still slows many rapid-learning tasks (Warren, Duff & Cohen line — "Fast mappers, slow learners," Cognitive Neuroscience 2019, DOI 10.1080/17588928.2019.1593120). Consolidation skeptics note schema effects may reflect inferential/RETRIEVAL processes rather than consolidation speed.
+NOTE: the R0-brief "Warren et al. 2020-2021 schema replication" is UNVERIFIED — nearest verified Warren items are 2019 Cognitive Neuroscience and 2014 hippocampus/word-learning work.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/software_and_ai_analogues.md

@@ -0,0 +1,15 @@
+# Software / AI analogues
+
+**Schaul, Quan, Antonoglou & Silver 2016, "Prioritized Experience Replay," ICLR (arXiv 1511.05952).** TD-error-prioritized sampling beats uniform on 41/49 Atari games. Relationship to Mattar & Daw: Schaul's priority ≈ "gain" (prediction error); Mattar-Daw adds "need" (utility). Caveats from adversarial pass: PER needs importance-sampling correction; Fedus et al. ICML 2020 (arXiv 2007.06700) — uniform replay often MATCHES PER, freshness dominates; Song & Qian 2024 (Sci Rep 53117) — single-criterion prioritization unstable.
+
+**Shin et al. 2017, "Continual Learning with Deep Generative Replay," NeurIPS (arXiv 1705.08690).** Generative replay mitigates catastrophic forgetting — direct computational CLS instantiation.
+
+**Blundell et al. 2016 (arXiv 1606.04460); Pritzel et al. 2017, "Neural Episodic Control" (arXiv 1703.01988).** Semi-tabular episodic buffers give one-shot value updates — the FAST system as the missing piece of slow-gradient deep RL. Validated as engineering lever.
+
+**Kauvar et al. 2023, "Curious Replay for Model-based Adaptation," ICML (arXiv 2306.15934).** Curiosity-prioritized replay for world models — direct translational echo of Mattar-Daw.
+
+**Kumaran, Summerfield, Hassabis & Botvinick 2016, Neuron 92** (Neuroscience-Inspired AI program statement); **Marblestone, Wayne & Kording 2016, Front Comput Neurosci** (constructive critique: biological plausibility gaps).
+
+**Kumaran, Hassabis & McClelland 2016, TiCS** — the pro-CLS-for-agents anchor the adversarial side must answer; De Lange et al. 2021 (IEEE TPAMI) establishes catastrophic interference as REAL in ML — CLS's distinctive content transfers as interference management.
+
+Bearing: in ML, fast/slow split and replay prioritization are VALIDATED AS ENGINEERING LEVERS; the contested part is whether biological replay does what the algorithms assume.

research/memory-atlas-r1/A-complementary-learning-systems/02_outward/sources.md

@@ -0,0 +1,77 @@
+# Sources Ledger (#376 R1)
+
+_Format: source_id | citation | DOI/arXiv | peer-reviewed | primary/secondary | read depth | bearing. All "(verified)" DOIs were confirmed via Crossref/OpenAlex/arXiv APIs during the outward pass._
+
+## Foundations
+- S001 | McClelland, McNaughton & O'Reilly 1995, Psych Review 102(3):419-457 | 10.1037/0033-295X.102.3.419 | yes | primary (theory) | RELEVANT_SECTIONS | canonical fast/slow split; catastrophic-interference motivation
+- S002 | Squire 1992, Archives of Neurology; Squire & Alvarez 1995, Curr Opin Neurobiol | — | yes | primary | RELEVANT_SECTIONS | standard-consolidation position CLS inherits
+- X001 | "McClelland/McNaughton/Whyte 1994 bitter-tracing" | NOT FOUND in Crossref/OpenAlex/arXiv | — | — | — | UNVERIFIABLE — excluded from ledger
+
+## Schema learning
+- S003 | Tse et al. 2007, Science 313:1130-1133 | 10.1126/science.1135935 | yes | primary | RELEVANT_SECTIONS | schema-gated rapid integration (rats)
+- S004 | Tse et al. 2011, Science 333:891 | 10.1126/science.1205274 | yes | primary | ABSTRACT/SECTIONS | neocortical gene activation
+- S005 | McClelland 2013, JEP:General 142(4):1190 | 10.1037/a0033812 | yes | primary (theory) | RELEVANT_SECTIONS | CLS schema revision
+- S006 | Audrain & McAndrews 2022, Nature Communications | 10.1038/s41467-022-33517-0 | yes | primary | ABSTRACT | human fMRI echo
+- S007 | Sharon, Moscovitch & Gilboa 2011, PNAS 108:17263-17268 | 10.1073/pnas.1005238108 | yes | primary | RELEVANT_SECTIONS | rapid learning WITHOUT hippocampus
+- S008 | Warren & Duff 2014, Hippocampus 24(8):920-932; Warren et al. 2014, J Neurosci 34(22); Warren et al. 2019, Cognitive Neuroscience | 10.1080/17588928.2019.1593120 | yes | primary | ABSTRACT/SECTIONS | amnesic fast-mapping failures; vmPFC schema locus
+- X002 | "Warren et al. 2020-2021 schema replication" | NOT FOUND as named | — | — | — | UNVERIFIABLE — nearest verified items listed above
+
+## Replay
+- S009 | Foster & Wilson 2006, Nature 440:680 | 10.1038/nature04587 | yes | primary | ABSTRACT | reverse replay discovery
+- S010 | Carr, Jadhav & Frank 2011, Nat Neurosci 14:147 | 10.1038/nn.2732 | yes | review/primary | RELEVANT_SECTIONS | dual retrieval/consolidation role
+- S011 | Ambrose, Pfeiffer & Foster 2016, Neuron 91:1342 | 10.1016/j.neuron.2016.07.047 | yes | primary | ABSTRACT | reward-gated replay
+- S012 | Mattar & Daw 2018, Nat Neurosci 21:1609 | 10.1038/s41593-018-0232-z | yes | primary (model) | RELEVANT_SECTIONS | utility-prioritized replay (gain+need)
+- S013 | Tanrıverdi et al. 2023, J Cogn Neurosci | 10.1162/jocn_a_02021 | yes | primary | RELEVANT_SECTIONS | co-reactivation ↔ FORGETTING
+- S014 | eLife 2023 ground-truth evaluation + 2024 dopamine exchange | 10.7554/eLife.85635.sa0 | yes | editorial/primary | ABSTRACT | replay-decoding methods contested
+
+## Reconsolidation
+- S015 | Nader, Schafe & LeDoux 2000, Nature 406:722 | 10.1038/35021052 | yes | primary | RELEVANT_SECTIONS | reconsolidation anchor (rodent amygdala)
+- S016 | Tronson & Taylor 2007, Nat Rev Neurosci 8 | 10.1038/nrn2090 | yes | review | RELEVANT_SECTIONS | boundary-condition heterogeneity
+- S017 | Sevenster, Beckers & Kindt 2014, Learn Mem 21 | 10.1101/lm.035493.114 | yes | primary | RELEVANT_SECTIONS | prediction-error gate
+- S018 | Rudy et al. 2006, Learn Mem 13:1-3 | — | yes | primary (critique) | RELEVANT_SECTIONS | anisomycin non-specificity
+- S019 | Lattal & Abel 2004, PNAS 101(13):4667 | — | yes | primary | RELEVANT_SECTIONS | deficits REVERSE with time
+- S020 | Morris et al. 2006, Neuron 50(3):479 | — | yes | primary | ABSTRACT | nonspecific anisomycin effects
+- S021 | Nader & Hardt 2009, Nat Rev Neurosci 10:224-234 | — | yes | review (PRO) | ABSTRACT | "a single standard" — pro-reconsolidation case
+- S022 | Exton-McGuinness, Lee & Reichelt 2015, Neurosci Biobehav Rev | 10.1016/j.bbr.2014.10.011 | yes | review | ABSTRACT | update-gate framing
+
+## Competing theories
+- S023 | Nadel & Moscovitch 1997, Hippocampus 7:217; Nadel et al. 2000, Psych Review 107:66 | — | yes | primary (theory) | RELEVANT_SECTIONS | MTT
+- S024 | Teyler & Rudy 2007, Hippocampus | 10.1002/hipo.20350 | yes | primary (theory) | RELEVANT_SECTIONS | indexing theory
+- S025 | Ryan et al. 2015, Science 348:1007 (+ Roy 2017 PNAS) | 10.1126/science.aaa5542 | yes | primary | RELEVANT_SECTIONS | engram persistence vs retrieval
+- S026 | Winocur & Moscovitch 2011, JINS 17(5):766; Moscovitch et al. 2016, Ann Rev Psych 67 | — | yes | review/theory | RELEVANT_SECTIONS | transformation hypothesis
+- S027 | Frankland et al. 2004, Science 304 | 10.1126/science.1094804 | yes | primary | ABSTRACT | remote-memory cortical shift + detail loss
+- S028 | Moscovitch & Gilboa 2021 OSF preprint | 10.31234/osf.io/yxbrs | no (preprint) | theory | ABSTRACT | TTT verified anchor
+- S029 | Gershman, Blei & Niv 2010, Psych Review 117:197 | — | yes | primary (theory) | RELEVANT_SECTIONS | latent-cause: reconsolidation = belief updating
+- X003 | "Winsneski/Bhatt TTT" | NOT FOUND | — | — | — | UNVERIFIABLE — replaced by S028
+
+## Generalization / interference
+- S030 | McCloskey & Cohen 1989; Ratcliff 1990 | — | yes | primary | RELEVANT_SECTIONS | catastrophic interference
+- S031 | O'Reilly & Norman 2002, TiCS; Norman & O'Reilly 2003, Psych Review 109 | 10.1016/s1364-6613(02)02005-3 | yes | primary (model) | RELEVANT_SECTIONS | pattern separation/completion (REC)
+- S032 | Payne et al. 2009, Neurobiol Learn Mem | 10.1016/j.nlm.2009.03.007 | yes | primary | ABSTRACT | sleep increases false memory
+- S033 | Fenn et al. 2009, Learn Mem | 10.1101/lm.1500808 | yes | primary | ABSTRACT | OPPOSITE: sleep reduces false memory
+- S034 | Anderson, Bjork & Bjork 1994, JEP:LMC 20:1063 | 10.1037/0278-7393.20.5.1063 | yes | primary | RELEVANT_SECTIONS | RIF discovery
+- S035 | Murayama et al. 2014, Psych Bull | 10.1037/a0037505 | yes | meta-analysis | ABSTRACT | RIF real on average, boundaries
+- S036 | RIF reliability papers (Eur Psychologist 2011, DOI 10.1027/1016-9040/a000040; Frontiers 2014, DOI 10.3389/fpsyg.2014.01343) | — | yes | meta/replication | ABSTRACT | reliability concerns
+
+## AI analogues
+- S037 | Schaul et al. 2016, ICLR (PER) | 1511.05952 | yes (conference) | primary | RELEVANT_SECTIONS | prioritized replay in RL + bias caveat
+- S038 | Fedus et al. 2020, ICML | 2007.06700 | yes | primary | RELEVANT_SECTIONS | uniform replay often matches PER
+- S039 | Song & Qian 2024, Scientific Reports 53117 | — | yes | review | ABSTRACT | prioritization instability
+- S040 | Shin et al. 2017, NeurIPS | 1705.08690 | yes | primary | ABSTRACT | generative replay
+- S041 | Blundell et al. 2016 (1606.04460); Pritzel et al. 2017 (1703.01988) | — | yes (conference) | primary | ABSTRACT | episodic control — fast store as engineering lever
+- S042 | Kauvar et al. 2023, ICML | 2306.15934 | yes | primary | ABSTRACT | curious replay for world models
+- S043 | Kumaran, Hassabis & McClelland 2016, TiCS 20(7) | 10.1016/j.tics.2016.05.004 | yes | review (theory) | RELEVANT_SECTIONS | CLS-for-agents anchor (pro)
+- S044 | McClelland, McNaughton & Lampinen 2020, Phil Trans R Soc B | 10.1098/rstb.2019.0637 | yes | review (theory) | RELEVANT_SECTIONS | CLS v2
+- S045 | De Lange et al. 2021, IEEE TPAMI 44(7) | — | yes | survey | RELEVANT_SECTIONS | catastrophic interference REAL in ML
+- S046 | Dacrema et al. 2019, RecSys | 1907.06902 | yes | primary (critique) | RELEVANT_SECTIONS | simple baselines beat complexity (adversarial)
+- S047 | O'Neil et al. 1996, Acta Informatica 33(4):351-385 (LSM-tree) | — | yes | primary | RELEVANT_SECTIONS | two-stores-as-engineering (adversarial)
+- S048 | Baria & Cross 2021, arXiv 2107.14042; Weisberg et al. 2008, J Cogn Neurosci 20(3) | — | mixed | critique | ABSTRACT | neuro-metaphor seduction (adversarial)
+- S049 | Lam et al. 2026, SSGM | 2603.11768 | no (preprint) | primary | RELEVANT_SECTIONS | semantic drift + immutable ledger fix
+- S050 | TRUSTMem 2026 | 2606.25161 | no (preprint) | primary | ABSTRACT | consolidation-pipeline corruption measured
+- S051 | Ólafsdóttir, Bush & Barry 2018, Curr Biol 28(1) | — | yes | review | RELEVANT_SECTIONS | replay dynamics load-bearing (adversarial)
+- S052 | Maynez et al. 2020, ACL | — | yes | primary | ABSTRACT | summarization hallucination (adversarial)
+- S053 | Roediger & McDermott 1995, JEP:LMC 21(4):803 | — | yes | primary | RELEVANT_SECTIONS | DRM gist falsification
+- S054 | Greshake et al. 2023 | — | yes | primary | ABSTRACT | indirect injection (adversarial, corroboration justification)
+- S055 | Candea & Fox 2003 HotOS (crash-only, context) | — | yes | primary | ABSTRACT | engineering pattern context
+
+Totals: primary sources 40+; reviews/surveys 6; competing theories 4 (MTT, indexing, latent-cause, TTT); negative/contrary sources 9; recent (2023-2026) 8; software analogues 8. Unverifiable R0 references excluded: 3 (X001-X003).

research/memory-atlas-r1/A-complementary-learning-systems/03_applicability.md

@@ -0,0 +1,56 @@
+# 03 — APPLICABILITY (Rune-specific, per surviving mechanism)
+
+_Mandate questions 1-15 answered per mechanism. Cheapest-mechanism rule enforced._
+
+## M1: Two-layer split (fast exact / slow generalized) — CLS-R1-C001
+1. Original problem: catastrophic interference in overlapping-representation learners.
+2. Rune's problem: REAL but milder — LLM consolidation rounds corrupt (C007), not gradient interference. Interference arrives via semantic drift, not weight overlap.
+3. Non-transferring biology: replay dynamics, sleep, neuromodulation, decay constants (d≈0.5 is a fit parameter to rodent data, S001).
+4. Computational differences: Rune's "fast store" is a database; perfect fidelity, zero decay — better than a hippocampus.
+5. Rune already solves it: YES — append-only entries + separate consolidation writer (T0 PROVEN). CLS adds justification, not mechanism.
+6-7. Complexity check: copying CLS's neural machinery (sparseness, decay curves) = unnecessary. Simplest capture: the existing two-writer design + drift guards (C007).
+8-9. Preserves exact evidence + provenance: YES (append-only + source columns).
+10. LLM dependence: unchanged. 11. Offline: YES. 12. Century-scale: YES (append-only is archival-friendly, child U).
+13. Event-driven conflict: none. 14. Owner: Memory (whole). 15. Cheapest mechanism: current design + index repair.
+
+## M2: Schema-gated fast path — CLS-R1-C002
+1. Original problem: weeks-long consolidation latency for schema-consistent info.
+2. Rune's problem: PARTIAL — consolidation lag exists but is not user-painful (nightly); urgency unproven.
+3-4. Non-transferring: schema detection in biology is implicit/in learned representations; Rune would need EXPLICIT schema matching (a new classifier) — the biological mechanism does not transfer, only the outcome.
+5. Rune already solves: NO (uniform consolidation).
+6. Copying increases complexity: YES — schema classifier = new LLM/deterministic component with its own error rate.
+7. Simpler capture: promotion-gate with independence check (C006) approximates the benefit without schema detection.
+8-12. Preserves evidence/provenance: yes if shadow-mode; offline yes; century-scale yes.
+13. Event-driven: compatible (consolidation trigger can be event-driven).
+14. Owner: Memory consolidation. 15. Cheapest: defer fast path until consolidation lag is measured as a real problem; shadow-mode experiment first.
+
+## M3: Utility-prioritized consolidation — CLS-R1-C003
+1. Original: finite replay budget in navigation.
+2. Rune: consolidation compute is cheap; the REAL constraint is lesson QUALITY (bad generalizations are expensive).
+3-4. Non-transferring: "need" signals (state relevance) are navigation-specific; Rune's equivalent ("what will shape future behavior") is unmeasurable without an outcome stream.
+5. Rune already solves: NO (full sweeps).
+6. Complexity: moderate — a utility estimator is a new component.
+7. Simpler: dedup + diversity + contradiction-targeting (from child E replay findings) captures most value without a utility model.
+8-12. Preserves evidence: yes. 10. LLM: can REDUCE (fewer consolidation calls). 11. Offline: yes.
+14. Owner: Memory consolidation. 15. Cheapest: diversity+contradiction sampling; utility model only if that fails.
+
+## M4: Retained covering episodes — CLS-R1-C004
+Already Rune doctrine (append-only). Applicability: total. Cheapest: current design. The R1 change is the RATIONALE (drift-correction, not reconsolidation) and the added obligation: drift tests comparing consolidated output against retained sources.
+
+## M5: Reconsolidation framing — CLS-R1-C005
+REJECTED as framing. The transferable atom: S017's prediction-error gate — update memories when reality VIOLATES them (contradiction detected), not on mere retrieval. That's just Rune's supersession trigger refined: supersede on contradiction, not on schedule. Owner: Memory write path.
+
+## M6: Independence-gated promotion — CLS-R1-C006
+Problem proven (wash_count gameable/unvalidated). Cheapest mechanism: promotion requires entries from ≥2 distinct sessions/sources touching the same content + no contradiction at promotion time. No new subsystem — a gate rule.
+
+## M7: Drift guards on consolidation — CLS-R1-C007
+Cheapest: (a) consolidate from immutable source text only (never from prior summaries) — already Rune doctrine, now load-bearing; (b) spot-check: N sampled claims per consolidation run verified against sources (existing claim_audit machinery); (c) drift metric: factual-consistency rate per run, logged. Owner: consolidation pipeline.
+
+## M8: Stage progression — CLS-R1-C008
+Keep stages as LABELS on one store (they already exist as kind/status fields); do NOT create separate stores per stage. Owner: Memory.
+
+## M9: Shadow-mode — CLS-R1-C009
+Cheap version: generalized beliefs enter with status=provisional and `acted_on=false` until independence gate passes; retrieval MAY surface them but marked. Owner: Memory entry status.
+
+## Boundary assignments (Q14)
+All mechanisms above: Memory authority. Nothing here belongs to Spine (structural truth), Substrate (execution), Persona (identity spec), or World Model (current-state belief) — with one note: consolidation's OUTPUT that describes the environment (facts about services/config) feeds the WM projection, but the belief-update authority stays in Memory.

research/memory-atlas-r1/A-complementary-learning-systems/04_innovation.md

@@ -0,0 +1,42 @@
+# 04 — INNOVATION (falsifiable hypotheses only; systems integration counts; novelty not manufactured)
+
+## I1: Drift-metered consolidation (closest prior art: SSGM 2603.11768, TRUSTMem 2606.25161)
+- Difference: SSGM prescribes immutable ledgers; Rune ADDS a measured drift metric per consolidation run (factual-consistency rate of sampled claims vs immutable sources) gating whether the run's output is accepted.
+- Mechanism: post-consolidation, sample N derived claims, verify against source episodes (existing claim_audit machinery); acceptance threshold; failed runs re-run or discarded.
+- Predicted advantage: consolidation corruption (C007, S050: 79%/50% reduction when guarded) caught before entering the belief layer.
+- Cost: N verification calls per run. Failure mode: verification LLM hallucinates agreement — mitigate with exact-quote checks.
+- Benchmark: drift rate per run before/after; retraction rate of accepted beliefs.
+- Rejection criterion: if drift rate is <1% unguarded across 10 runs, the meter is overhead — drop it.
+- Classification: EXPERIMENT. Evidence: EXTERNALLY_ESTABLISHED (drift) → RUNE_HYPOTHESIS (meter).
+
+## I2: Independence-gated promotion (closest prior art: dedup+recency recommenders, S046)
+- Difference: recommendation systems gate on statistical ensembles; Rune gates on SOURCE-GRAPH independence (distinct sessions, distinct evidence chains) + contradiction absence — a check available only because Rune keeps exact provenance.
+- Mechanism: promotion_eligible requires ≥2 independent evidence chains + zero active contradictions (using existing supersession graph).
+- Predicted advantage: eliminates frequency-gamed promotions (observed T0.1).
+- Cost: none — query over existing data. Failure mode: over-strict gate starves promotion (measure promotion latency).
+- Benchmark: promoted-belief retraction rate vs old wash_count gate.
+- Rejection criterion: if retraction rates equal, revert to simple gate.
+- Classification: ADAPT. Evidence: RUNE_APPLICABLE.
+
+## I3: Contradiction-triggered consolidation (event-driven, from S017's prediction-error gate via M5)
+- Difference: consolidation runs on DRIFT/CONTRADICTION events (new evidence contradicting an existing belief), not on timers — unifying Rune's event-driven mandate (req 34) with CLS's update-gate.
+- Mechanism: write-path contradiction detection (cross-encoder prefilter, child AC) emits consolidation-trigger events; consolidation processes affected beliefs, not the whole store.
+- Predicted advantage: timely belief updates (T0.1's non-deterministic trigger replaced); reduced LLM consumption (targeted runs).
+- Cost: contradiction detector errors (false positives → consolidation churn; rate-limit).
+- Benchmark: belief-update latency; LLM calls per belief-update; churn rate.
+- Rejection criterion: if targeted consolidation misses updates the sweep catches, hybrid (event + periodic sweep).
+- Classification: EXPERIMENT. Evidence: RUNE_HYPOTHESIS.
+
+## I4: Shadow-mode generalizations (closest prior art: TiMem dual-buffer probation; SSGM staging)
+- Difference: probation tied to the independence gate (I2) with `acted_on=false` semantics — beliefs are retrievable-but-marked, and the promotion decision is auditable in the ledger.
+- Predicted advantage: overgeneralization caught before behavior; audit trail of WHY a belief was promoted (req 24).
+- Cost: status complexity. Failure mode: shadow beliefs leak into behavior unmarked.
+- Benchmark: retraction rate of shadow-vs-direct promotions.
+- Rejection criterion: if no retraction-rate difference across 50 promotions, drop shadow mode.
+- Classification: EXPERIMENT. Evidence: RUNE_HYPOTHESIS.
+
+## I5: Two-lane consolidation benchmark (from CLS-R1-C010 refinement)
+- The innovation is METRIC-FIRST: before any prioritization scheme, implement the measurement (lesson quality: retraction rate, contradiction rate at promotion, independence depth) — then let data pick recency vs utility vs diversity.
+- Classification: EXPERIMENT (protocol). Evidence: RUNE_APPLICABLE (problem proven).
+
+No manufactured novelty: I1/I4 have close published prior art (SSGM, TiMem); I2 is integration of existing Rune provenance with standard hygiene; I3 is Rune's own event-driven mandate applied to CLS's update gate; I5 is measurement design. Each claims integration, not new mechanism.

research/memory-atlas-r1/A-complementary-learning-systems/05_adversarial.md

@@ -0,0 +1,30 @@
+# 05 — ADVERSARIAL (independent research pass; actor general-31)
+
+_Mandate: assume the emerging CLS→Rune conclusions are WRONG. Find the strongest cited evidence. Honest failed attacks recorded._
+
+## Attack 1 — "Two stores / two writers": LARGELY SUCCESSFUL
+The dual-store pattern exists in engineering WITHOUT neuroscience and predates CLS-as-software: the LSM-tree (memtable + immutable SSTables + background compaction) is exactly "fast volatile store, slow durable store, consolidation pass" — O'Neil, Cheng, Gawlick & O'Neil, *Acta Informatica* 33(4):351-385, 1996. What CLS would add beyond cache+DB is the DYNAMICS: sharp-wave-ripple replay during sleep, interleaved training, slow integration — software Rune has none (Ólafsdóttir, Bush & Barry, *Current Biology* 28(1):R37-R50, 2018: the biological consolidation story rests on those dynamics). Metaphor critique: Baria & Cross, arXiv:2107.14042 (2021); Weisberg et al., "The seductive allure of neuroscience explanations," *J Cogn Neurosci* 20(3):470-477, 2008. **Strength: high.** Honest counter: CLS's distinctive content is INTERFERENCE MANAGEMENT — catastrophic interference is a real software phenomenon (De Lange et al. 2021) — but that doesn't rescue "two stores" specifically, which is not where CLS does work.
+
+## Attack 2 — Tse 2007 schema gating: SUCCESSFUL
+Tse et al., *Science* 313:1130-1133, 2007: rats only, food-reward flavor-place paired-associate task, WEEKS of training on six PAs before one-trial new-PA learning (paradigm per Hasan et al., *PLoS Biology* 17(12):e3000564, 2019, which concedes "difficult to map the concept of mental schema precisely onto existing neurobiological models"). Mechanism contested at publication: "Does assimilation into schemas involve systems or cellular consolidation?" (*Neurobiol Learn Mem* 2007) — an encoding-level prior-knowledge benefit is an equally live explanation. Human translation: Warren & Duff, *Hippocampus* 24(8):920-932, 2014 — amnesics fail to benefit from fast-mapping routes; Warren et al., *J Neurosci* 34(22), 2014 — schema influence located in vmPFC, not a hippocampus-bypassing speedup; Sharon/Moscovitch/Gilboa, *PNAS* 108:17263-17268, 2011 — rapid acquisition via a DIFFERENT route (rapid neocortical acquisition independent of hippocampus). **Strength: high** for animal-paradigm confinement; **medium** for the encoding-effect alternative (no paper cleanly rules it out).
+
+## Attack 3 — Mattar & Daw prioritized replay → utility-prioritized consolidation: SUCCESSFUL
+Mattar & Daw, *Neuron* 99(5):944-966, 2018 models utility-driven replay in simulated MAZE NAVIGATION. Ólafsdóttir et al. (2018): replay literature rests "mainly, but not exclusively, on rodents"; human replay evidence indirect. **No published evidence prioritized replay transfers to semantic-memory consolidation.** Closest analog (RL PER) is cautionary: Schaul et al. ICLR 2016 (PER needs importance-sampling correction for bias); Fedus et al. ICML 2020 — uniform replay often MATCHES PER, buffer freshness dominates; Song & Qian, *Scientific Reports* 53117, 2024 — single-criterion prioritization unstable across environments. **Strength: high** ("no transfer evidence"); PER pathologies make transfer worse.
+
+## Attack 4 — retained covering episodes: **FAILED** (conclusion survives; rationale replaced)
+The biology supports the attack: transformation theory (Winocur & Moscovitch, *JINS* 17(5):766-780, 2011; Moscovitch et al., *Ann Rev Psych* 67:1-36, 2016) holds the brain ROUTINELY DISCARDS details — retention of source episodes is not what biological consolidation does. Generative Agents (Park et al., UIST 2023) and MemGPT (Packer et al. 2023) run reflection/summarization without retained originals. **But the strongest engineering evidence cuts the other way**: SSGM (Lam et al., arXiv:2603.11768, 2026) documents SEMANTIC DRIFT — lossy iterative summarization progressively distorting stored facts ("likes mild spicy food" → "loves very spicy") — and prescribes an immutable episodic ledger reconciled against the mutable store. **Retention is justified by DRIFT-CORRECTION, not reconsolidation; the CLS conclusion survives on engineering grounds, losing its biological rationale.**
+
+## Attack 5 — reconsolidation → supersession: SUCCESSFUL
+Pharmacological foundation contested: Rudy, Biedenkapp, Moineau & Bolding, *Learn Mem* 13(1):1-3, 2006 — anisomycin has non-specific effects producing TEMPORARY amnesia unrelated to re-stabilization; Lattal & Abel, *PNAS* 101(13):4667-4672, 2004 — deficits REVERSE with time (retrieval-failure signature, not erasure); Morris et al., *Neuron* 50(3):479-489, 2006 — intrahippocampal anisomycin "nonspecific effects unconnected with reconsolidation." Alternative mechanisms (extinction facilitation: Myers & Davis 2002; Fischer et al. 2004) explain the same data. Tronson & Taylor, *Nat Rev Neurosci* 8:352-365, 2007 — wildly heterogeneous boundary conditions. **Correction to the R0 assumption: Hardt & Nader are on the PRO side** — Nader & Hardt, "A single standard for memory: the case for reconsolidation," *Nat Rev Neurosci* 10:224-234, 2009 — which is itself telling: the phenomenon requires a "case for" paper. **Strength: high.** Mapping Rune supersession to a phenomenon whose existence is pharmacology-dependent is speculation.
+
+## Attack 6 — corroboration gating: PARTIAL SUCCESS
+Dacrema, Cremonesi & Jannach, "Are we really making much progress?" *RecSys 2019* (1907.06902): 11 of 18 neural recommenders failed to beat well-tuned simple baselines — simple mechanisms (dedup, recency, linear) match added complexity; "corroboration" is structurally ensemble voting / confirmation-weighted averaging — standard hygiene needing no memory theory. **However, partially fails:** for single-user stores exposed to prompt injection and hallucinated inputs (Greshake et al. 2023, indirect injection), write-path validation has a distinct justification beyond dedup/recency. Corroboration-as-hygiene: yes; corroboration-as-redundant: unproven.
+
+## Attack 7 — workload mismatch: MIXED
+De Lange et al., *IEEE TPAMI* 44(7), 2021; Abel et al., *NeurIPS 2023*: agent settings are never-stationary, never-i.i.d. streams — nothing like hippocampal encoding at fixed event boundaries; MemGPT demonstrates top-down OS-style design working without neuro-anchoring; timescales differ by orders of magnitude. **Failed part:** Kumaran, Hassabis & McClelland, "What learning systems do efficient agents need?" *TiCS* 20(7):512-534, 2016 IS a peer-reviewed argument that CLS maps directly onto agent ML — the strongest pro-position the adversarial side must answer; and catastrophic interference (real, per De Lange) gives CLS teeth.
+
+## Attack 8 — consolidation damages exactness: SUCCESSFUL
+Maynez et al., "On faithfulness and factuality in abstractive summarization," *ACL 2020*: "substantial amounts of hallucinated content in all model generated summaries" — summarization (consolidation's software form) systematically injects error. Roediger & McDermott 1995 (DRM): gist compression GENERATES false content. Agent-specific: SSGM (2603.11768) places "semantic drift during consolidation updates" among top three failure modes; **TRUSTMem (arXiv:2606.25161, 2026) measures omission/corruption/hallucination introduced BY the consolidation pipeline itself** and cuts these 79.1%/50.0% vs baselines — direct evidence consolidation rounds degrade exactness an exact store wouldn't.
+
+## Bottom line
+**Strongest kills:** #5 (contested pharmacological foundation), #3 (no transfer evidence + fragile RL analog), #2 (rat food-reward paradigm, contested mechanism, human translation failures), #8 (documented consolidation-introduced corruption). **Attack #4 failed on the conclusion** (retention is right) **but won on the rationale** (drift-correction, not reconsolidation). **#1 strongest** where it says two stores are trivial engineering (LSM 1996), weakest against interference-based CLS content. **#6, #7 genuinely mixed** — with Kumaran 2016 as the pro-CLS anchor any honest synthesis must answer.

research/memory-atlas-r1/A-complementary-learning-systems/06_synthesis.md

@@ -0,0 +1,22 @@
+# 06 — SYNTHESIS: mechanism matrix + reconciliation
+
+## Mechanism matrix
+
+| MECHANISM | ORIGINAL PURPOSE | EVIDENCE STRENGTH | LIMITATIONS | RUNE EQUIVALENT | RUNE GAP | TRANSFER VALIDITY | COST | FAILURE MODES | CLASSIFICATION | RUNE EVIDENCE LEVEL |
+|---|---|---|---|---|---|---|---|---|---|---|
+| Fast exact episodic store | evade catastrophic interference | STRONG (S001, S030, S045, S041) | biology's decay dynamics don't transfer; Rune's is better (perfect fidelity) | append-only entries (PROVEN) | index coverage (439 unindexed) | HIGH (as engineering; CLS adds interference rationale) | none | silent embedder failure (observed) | COVERED — repair | RUNE_PROVEN (store); index repair needed |
+| Slow statistical/generalized layer | interference-free generalization | STRONG (S001, S044) | transformation loses detail (S026) | knowledge.json consolidation (PROVEN to run) | drift guards; source-only inputs | HIGH | verification calls | consolidation hallucination (S052, S050) | ADAPT (drift-metered) | RUNE_APPLICABLE |
+| Two stores / two writers | separate update rates | STRONG as engineering (S047 LSM) / CLS content = interference mgmt (S045) | "two stores" trivial without dynamics (adversarial #1) | agent writer + consolidator (PROVEN) | none structural | HIGH | none | writer conflation | COVERED | RUNE_PROVEN |
+| Schema-gated rapid integration | fast assimilation with prior knowledge | CONTESTED (S003 effect real in rats; mechanism contested S007/S008; adversarial #2) | animal paradigm; encoding-vs-consolidation confound; schema detection cost | none | schema detector would be NEW | MEDIUM | new classifier | wrong schema match → corrupt fast promotions | EXPERIMENT (deferred until lag measured) | RUNE_HYPOTHESIS |
+| Utility-prioritized consolidation | finite replay budget, prospective value | MEDIUM (S012 model+converging ephys; navigation-specific) | no semantic-memory transfer evidence (adversarial #3); PER fragility (S038/S039) | none (full sweeps) | utility signal unmeasurable without outcome stream | MEDIUM | utility estimator | gamed/biased prioritization | EXPERIMENT (baseline-first) | RUNE_HYPOTHESIS |
+| Retained covering episodes | reconsolidation substrate (R0 claim) → drift correction (R1) | STRONG engineering (S049/S050/S052) | storage cost; biology actually discards (S026) | append-only (PROVEN) | drift tests vs sources | HIGH | storage | none serious | ADOPT (rationale corrected) | RUNE_APPLICABLE |
+| Reconsolidation → supersession | update-on-retrieval | CONTESTED (S015 rodent robust; S018-020 pharmacology contested) | write-vs-retrieval trigger mismatch | supersession (PROVEN, write-triggered) | prediction-error trigger refinement | LOW (framing) / MEDIUM (gate atom) | none | dogma without mechanism | REJECT framing; KEEP contradiction-triggered updates | RUNE_APPLICABLE (gate atom only) |
+| Interference management (pattern separation/completion) | avoid false memories + enable retrieval | STRONG computational (S031) + fMRI support | separation/completion trade-off is architectural, not tunable | dedupe/supersede gate (PROVEN); exact quotes | contradiction detection (missing) | HIGH | cross-encoder prefilter | false contradiction detections | ADAPT | RUNE_APPLICABLE |
+| Independent-evidence promotion gate | avoid premature generalization | MEDIUM (S017 gates; S046 simplicity warning) | nothing biological required | promotion_eligible (exists, frequency-driven — UNVALIDATED) | independence test | HIGH | none (query) | over-strict gate starves promotion | ADAPT | RUNE_APPLICABLE |
+| Shadow-mode provisional beliefs | prevent premature influence | MEDIUM (interference-threshold logic; TiMem convergence) | state complexity | status field (exists) | acted_on semantics | MEDIUM | none | shadow leakage | EXPERIMENT | RUNE_HYPOTHESIS |
+| Replay as teacher (offline re-processing) | neocortical learning from hippocampal record | MEDIUM (S012; decoding contested S014) | content-decoding methods disputed (S014); co-reactivation ↔ forgetting (S013) | consolidation as re-processing (PROVEN to run) | sampling policy | MEDIUM | none | replay amplifies poisoned content (child E) | COVERED (consolidation = Rune's replay; policy = experiments above) | RUNE_APPLICABLE |
+| Gist consolidation creates false content | efficiency of gist | CONTESTED in biology (S032 vs S033); STRONG in software (S052, S049, S050) | — | LLM summarization | drift guards | HIGH | verification | silent corruption | ADOPT (guards) | RUNE_APPLICABLE |
+
+## Synthesis narrative
+
+CLS's load-bearing content for Rune is NOT the two-store anatomy (that's LSM-tree engineering, S047) and NOT the biological dynamics (replay/sleep — S051) and NOT reconsolidation (pharmacologically contested — S018-020). Three things transfer: (1) **the interference-management problem is real in software** (S045) and Rune's exact store + supersession is the pattern-separation answer; (2) **consolidation corrupts** (S049/S050/S052) — so the slow layer requires drift guards and retained sources as engineering requirements; (3) **updates are gated by prediction error, not schedules** (S017, reframed via S029's latent-cause account as plain belief-updating) — which lands Rune's consolidation trigger on events, not timers. The five-stage progression is Rune's own construct: keep it as labels, not stores. Competing theories (MTT, indexing, latent-cause) matter mostly as warnings: the biology does not settle what CLS's early readings assumed, and the latent-cause account explains reconsolidation phenomena as ordinary belief-updating — which is exactly the software form Rune should implement. Kumaran 2016 (S043) remains the strongest pro-CLS-for-agents argument and survives the adversarial pass on interference grounds.

research/memory-atlas-r1/A-complementary-learning-systems/07_qualification.md

@@ -0,0 +1,28 @@
+# 07 — QUALIFICATION (#376 R1)
+
+_Classification separate from evidence level. Each item: confidence, sources (for/against), assumptions, cost, failure modes, T1 impact, experiment, falsifier, rejection criterion. Evidence levels per claims.json._
+
+## Qualified mechanisms
+
+| # | Mechanism | Classification | Evidence level | Conf | For | Against | T1 impact | Experiment | Rejection criterion |
+|---|---|---|---|---|---|---|---|---|---|
+| Q1 | Two-layer split (exact episodes + generalized layer, two writers) | COVERED — keep; repair index coverage | EXTERNALLY_ESTABLISHED + RUNE_APPLICABLE (store RUNE_PROVEN) | HIGH | S001/S045/S041/S049 | S047 (trivial-engineering caveat — does not defeat interference content) | HIGH (retention/rotation decision) | index-repair + embedder loud-failure (not CLS but urgent) | single-store drift parity |
+| Q2 | Drift guards on consolidation (source-only inputs, quote-checks, drift metric) | ADOPT | EXTERNALLY_ESTABLISHED + RUNE_APPLICABLE | HIGH | S049/S050/S052/S053 | S033 (biology direction contested — irrelevant to software) | HIGH | drift-rate measurement per run | drift <1% unguarded over 10 runs |
+| Q3 | Retained covering episodes (append-only; rationale = drift correction) | ADOPT — already doctrine | RUNE_APPLICABLE | HIGH | S049 adversarial-confirmed | S026 (biology discards — explicitly not imitated) | MEDIUM | retention vs drift controlled test | consolidation-without-retention parity |
+| Q4 | Independence-gated promotion (replaces wash_count frequency gate) | ADAPT | RUNE_APPLICABLE (problem RUNE_PROVEN via T0.1) | HIGH | S054 threat model; wash_count unvalidated | S046 simplicity | MEDIUM | promotion retraction-rate A/B | equal retraction rates |
+| Q5 | Contradiction-triggered (event-driven) consolidation | ADAPT | RUNE_HYPOTHESIS | MEDIUM | S017 gate atom; S029 latent-cause framing | trigger-churn risk | MEDIUM | targeted-vs-sweep update latency | missed updates vs sweep |
+| Q6 | Shadow-mode provisional generalizations | EXPERIMENT | RUNE_HYPOTHESIS | MEDIUM | TiMem convergence; interference logic | complexity | MEDIUM | shadow-vs-direct retraction rates | no difference over 50 promotions |
+| Q7 | Utility-prioritized consolidation | EXPERIMENT (refined from R0) | RUNE_HYPOTHESIS (transfer unproven) | LOW-MED | S012/S011 | adversarial#3; S038/S039 | LOW-MED | lesson-quality A/B vs dedup+diversity baseline | no improvement over baseline |
+| Q8 | Schema-gated fast path | EXPERIMENT (DEFERRED until consolidation lag measured as real) | CONTESTED externally | LOW-MED | S003/S005 | S007/S008; adversarial#2 | LOW | lag measurement first; then shadow fast path | fast-path retraction rate higher |
+| Q9 | Five-stage progression (episode→observation→belief→procedure) | ADAPT (as labels on one store) | RUNE_APPLICABLE (transitions RUNE_PROVEN) | MEDIUM | S001/S044 stage logic | over-engineering risk (meta-review) | LOW-MED | friction vs lesson-quality | collapse to 2-stage if no benefit |
+| Q10 | Reconsolidation framing for supersession | REJECT (framing); KEEP prediction-error-gated updates | CONTESTED | HIGH (in the reject) | S015/S017/S029 | S018/S019/S020; adversarial#5 | LOW | — | — |
+
+## Evidence-level discipline (mandate §17)
+No mechanism above is RUNE_PROVEN beyond what T0/T0.1 already established (two-writer structure, append-only, promotion-gate existence). Everything new — drift guards, independence gates, event triggers, shadow mode — is RUNE_HYPOTHESIS until Rune experiments run. Q1's store layer is the only RUNE_PROVEN item, and its gap (index coverage) is operational, not architectural.
+
+## Evidence-level separation statement (G10)
+
+Explicit separation of layers, per mandate:
+- BIOLOGICAL MECHANISM (what the brain does): fast sparse hippocampal store, slow overlapping neocortex, replay-as-teacher, schema-gated integration, reconsolidation-with-prediction-error-gate. Established to varying degrees (S001-S031) — NOT Rune claims.
+- SOFTWARE ANALOGY (what the mechanism becomes in software): two-layer store, consolidation pass, prioritized sampling, update-on-violation. Validated as engineering levers (S037-S041, S045) — still NOT Rune claims.
+- RUNE PRESCRIPTION (what Rune should do): only items with RUNE_APPLICABLE or stronger levels in claims.json — the two-layer split (RUNE_PROVEN structure), drift guards (RUNE_APPLICABLE), independence gate (RUNE_APPLICABLE), contradiction-triggered updates (RUNE_HYPOTHESIS), shadow mode (RUNE_HYPOTHESIS). Every EXTERNALLY_ESTABLISHED claim that entered Rune prescription passed through an explicit applicability argument (03_applicability.md) and carries its Rune evidence level in claims.json. No biological finding is cited as Rune proof anywhere in this artifact set.

research/memory-atlas-r1/A-complementary-learning-systems/FINAL.md

@@ -0,0 +1,46 @@
+# #376 R1 — Complementary Learning Systems: FINAL (durable technical reference)
+
+_This document is the domain's durable reference. It assumes the reader has the pipeline artifacts alongside: 00_issue_scope, 01_inward, 02_outward/ (9 files + sources.md + claims.json), 03_applicability, 04_innovation, 05_adversarial, 06_synthesis, 07_qualification, r0_reconciliation._
+
+## 1. The domain in one page
+
+Complementary Learning Systems (McClelland, McNaughton & O'Reilly 1995) claims cognition needs two learning systems: a fast, sparse, episodic store (hippocampus) that learns instantly but interferes catastrophically when asked to generalize, and a slow, overlapping, statistical store (neocortex) that generalizes well but must learn slowly and interleaved. The hippocampus acts as a teacher: replay of episodes drives slow neocortical integration. Thirty years of development produced: schema-gated rapid integration (Tse 2007; McClelland 2013 — the theory's biggest self-revision), utility-prioritized replay (Mattar & Daw 2018), reconsolidation (Nader 2000 — with a contested pharmacological foundation), transformation theory (memories are transformed, not copied — Winocur/Moscovitch), and serious competitors (MTT, hippocampal indexing, latent-cause/Bayesian accounts). In ML, the pattern is validated as engineering: episodic control buffers, experience/generative replay, and catastrophic interference are all real (S037-S045).
+
+## 2. What transfers to Rune, and what does not
+
+**Transfers (as engineering, with Rune evidence):**
+- The two-layer split with separate update rates. Rune has it structurally (RUNE_PROVEN); its urgency comes from consolidation corruption (S049/S050), not from CLS.
+- Retention of exact sources. NOT because reconsolidation needs them (the biology discards — S026) but because iterative summarization measurably drifts (S049) and the consolidation pipeline itself corrupts (S050).
+- Update gating by prediction error. When new evidence contradicts a belief, update; mere retrieval changes nothing. (S017's gate, reframed through S029's latent-cause account as ordinary belief-updating.)
+- Interference management. Catastrophic interference is real in ML (S045); Rune's exact store + supersession + dedupe is the pattern-separation answer.
+
+**Does not transfer:**
+- The biological dynamics (replay during sleep, decay constants, neuromodulation). Rune has no sleep; its "fast store" is a database with perfect fidelity.
+- Reconsolidation as a phenomenon to imitate. Pharmacologically contested (S018-020); the useful atom (update-on-violation) is captured by plain belief-updating.
+- Schema detection as a mechanism. In biology it is implicit in learned representations; in Rune it would be an explicit, error-prone classifier.
+- Utility signals without an outcome stream. Mattar-Daw "need" requires measuring future value; Rune cannot measure that yet.
+
+## 3. The corrected rationale for Rune's pipeline
+
+R0 said: CLS justifies episode→observation→belief→procedure with a schema fast path, utility prioritization, and reconsolidation-style updates. R1 corrects: the pipeline is justified by (a) drift-correction economics (exact sources are the only defense against measured consolidation corruption), (b) interference management (dedupe/supersede/exact quotes), (c) prediction-error-gated updates (contradiction-triggered, event-driven), and (d) independence-gated promotion (because frequency is gameable and unvalidated). Schema fast paths and utility prioritization are experiments, not architecture.
+
+## 4. Experiments this domain requires (in order)
+1. **Drift-metered consolidation**: measure factual-consistency of derived claims vs immutable sources per run. Rejection criterion: drift <1% unguarded → drop the meter.
+2. **Promotion-gate A/B**: independence-gated vs wash_count-gated promotion; metric = promoted-belief retraction rate.
+3. **Consolidation trigger A/B**: event-driven (contradiction-triggered) vs periodic sweep; metrics = update latency, missed updates, LLM calls.
+4. **Prioritization A/B**: recency vs utility vs dedup+diversity sampling; metric = lesson quality (retraction/contradiction rates).
+5. **Shadow mode**: shadow-vs-direct promotion retraction comparison over 50 promotions.
+
+## 5. What would change this conclusion
+- A credible "summarize-and-discard works fine" result (would force re-examination of retention).
+- Consolidation-lag evidence showing nightly updates are user-painful (would revive the schema fast path).
+- An outcome-stream making utility measurable (would upgrade C003 from experiment to design input).
+- Replication of schema-acceleration as consolidation-specific (would strengthen C002).
+
+## 6. Remaining unknowns (bounded)
+- Whether Rune's consolidation is atomically checkpointed end-to-end (code verification, not research).
+- Optimal independence-test depth (2 chains? 3?) — needs the promotion A/B.
+- Whether interval-confidence elicitation helps on local models (child Q's open question, shared).
+
+## 7. Production implementation
+NONE. This tranche is research only. Everything above enters T1 as design input and experiment protocol.

research/memory-atlas-r1/A-complementary-learning-systems/claims.json

@@ -0,0 +1,125 @@
+{
+  "note": "Narrow, falsifiable claims. external_status: EXTERNALLY_ESTABLISHED|CONTESTED|WEAK. rune_status: RUNE_APPLICABLE|RUNE_HYPOTHESIS|RUNE_EXPERIMENTALLY_SUPPORTED|RUNE_PROVEN.",
+  "claims": [
+    {
+      "claim_id": "CLS-R1-C001",
+      "claim": "Fast exact episodic capture + slow statistical generalization is the right two-layer split for Rune",
+      "evidence_for": ["S001 core CLS logic", "S045 catastrophic interference REAL in ML", "S041 episodic fast store validated as engineering lever", "S049 semantic drift from lossy consolidation documents what happens without the split"],
+      "evidence_against": ["S047 two-stores is trivial engineering (LSM-tree) needing no CLS", "S048 neuro-metaphor seduction", "S051 biological dynamics (replay/sleep) not present in software"],
+      "external_status": "EXTERNALLY_ESTABLISHED (as engineering pattern; CLS's interference-management content adds justification)",
+      "rune_status": "RUNE_APPLICABLE (T0: two writers exist structurally; T0.1 leak = implementation gap not design gap)",
+      "architecture_impact": "HIGH",
+      "falsifier": "F1: if single-store designs match two-store on drift+interference metrics at Rune scale, the split is preference",
+      "experiment_required": true,
+      "classification": "COVERED (architecture) — implement cleanly"
+    },
+    {
+      "claim_id": "CLS-R1-C002",
+      "claim": "Schema-gated rapid consolidation (fast path) is justified for Rune",
+      "evidence_for": ["S003 Tse 2007 (rats, replicated in-lab)", "S005 McClelland 2013 principled revision", "S006 human fMRI echo"],
+      "evidence_against": ["S007 rapid learning WITHOUT hippocampus (alternative route)", "S008 amnesic failures of fast mapping", "adversarial#2: encoding-level prior-knowledge benefit equally live; food-reward rat paradigm; mechanism contested at publication"],
+      "external_status": "CONTESTED (effect real; MECHANISM and hippocampal-independence interpretation contested)",
+      "rune_status": "RUNE_HYPOTHESIS",
+      "architecture_impact": "MEDIUM",
+      "falsifier": "F2: if fast-path promotions show higher retraction rates than slow-path, revert",
+      "experiment_required": true,
+      "classification": "EXPERIMENT (fast path with shadow-mode + retraction-rate kill criterion)"
+    },
+    {
+      "claim_id": "CLS-R1-C003",
+      "claim": "Consolidation should be utility-prioritized (expected future value), not recency/frequency-based",
+      "evidence_for": ["S012 Mattar & Daw: prioritization by gain+need, NOT recency", "S011 reward-gating precursor", "S037 PER validates prioritization as lever (with bias caveat)"],
+      "evidence_against": ["adversarial#3: model is maze-navigation-specific; NO transfer evidence to semantic consolidation", "S038 uniform replay often matches PER", "S039 single-criterion prioritization unstable", "Rune's own wash_count (frequency) never validated as quality signal (T0.1)"],
+      "external_status": "EXTERNALLY_ESTABLISHED (in navigation/RL) / TRANSFER_UNPROVEN (to semantic memory consolidation)",
+      "rune_status": "RUNE_HYPOTHESIS",
+      "architecture_impact": "MEDIUM",
+      "falsifier": "F3: if utility-weighted consolidation produces no measurable lesson-quality improvement over recency+dedup baselines, use the simple version",
+      "experiment_required": true,
+      "classification": "EXPERIMENT (utility signal must be measured, not assumed; simple baseline first)"
+    },
+    {
+      "claim_id": "CLS-R1-C004",
+      "claim": "Covering episodes must be retained after generalization (no destructive consolidation)",
+      "evidence_for": ["S026 transformation theory: details are LOST — retention fights biology but preserves verifiability", "S049 SSGM: semantic drift from lossy summarization; immutable ledger is the fix", "S050 TRUSTMem: consolidation pipeline itself corrupts (79%/50% reduction when guarded)", "S052 summarization hallucination", "S053 DRM gist falsification"],
+      "evidence_against": ["adversarial#4 FAILED: no 'summarize-and-discard works fine' evidence found; biology discards freely (S026)", "storage cost is real"],
+      "external_status": "EXTERNALLY_ESTABLISHED (as engineering requirement — drift correction; NOT as biological requirement)",
+      "rune_status": "RUNE_APPLICABLE (append-only entries already PROVEN in Rune)",
+      "architecture_impact": "HIGH",
+      "falsifier": "F5: if consolidation-without-retention shows no drift/corruption in controlled Rune test, retention is preference",
+      "experiment_required": false,
+      "classification": "ADOPT (already Rune doctrine; rationale CORRECTED from reconsolidation to drift-correction)"
+    },
+    {
+      "claim_id": "CLS-R1-C005",
+      "claim": "Reconsolidation (retrieval-triggered lability) maps to Rune supersession",
+      "evidence_for": ["S015 anchor phenomenon", "S017 prediction-error gate is a real mechanism", "S029 latent-cause framing: reconsolidation = belief updating"],
+      "evidence_against": ["S018/S019/S020 pharmacological foundation contested (temporary amnesia, reversal with time, nonspecific effects)", "adversarial#5: mapping to a phenomenon whose existence is pharmacology-dependent is speculation", "Rune supersession is WRITE-triggered not retrieval-triggered — the analogy was asserted in R0, not derived"],
+      "external_status": "CONTESTED (rodent robust; human mixed; pharmacology-dependent)",
+      "rune_status": "RUNE_HYPOTHESIS (weak)",
+      "architecture_impact": "LOW",
+      "falsifier": "F4: if reconsolidation's useful property (update-on-retrieval) is fully captured by plain belief-updating (S029), drop the neuroscience framing entirely",
+      "experiment_required": false,
+      "classification": "REJECT the reconsolidation FRAMING; KEEP plain belief-updating with prediction-error gating (S017's gate is the transferable part)"
+    },
+    {
+      "claim_id": "CLS-R1-C006",
+      "claim": "Independent-evidence corroboration should gate promotion (not frequency/wash_count)",
+      "evidence_for": ["S017 prediction-error/independence gates exist in biology", "S054 injection threat makes write-path validation distinct from dedup", "Rune wash_count demonstrably unvalidated (T0.1: superseded entries with high counts)"],
+      "evidence_against": ["S046 11/18 neural recommenders failed vs simple baselines", "adversarial#6: corroboration = ensemble voting hygiene, no memory theory needed"],
+      "external_status": "EXTERNALLY_ESTABLISHED (as hygiene)",
+      "rune_status": "RUNE_APPLICABLE (problem proven: frequency gating is gameable and unvalidated)",
+      "architecture_impact": "MEDIUM",
+      "falsifier": "If dedup+recency matches corroboration-gated promotion on lesson quality, use simple version",
+      "experiment_required": true,
+      "classification": "ADAPT (independence test as promotion criterion; simple implementation first)"
+    },
+    {
+      "claim_id": "CLS-R1-C007",
+      "claim": "Consolidation introduces errors an exact store wouldn't have (gist hallucination/drift)",
+      "evidence_for": ["S052 summarization hallucination (ACL 2020)", "S053 DRM", "S049 SSGM drift documented", "S050 TRUSTMem measured consolidation corruption"],
+      "evidence_against": ["S033 sleep REDUCED false memories (biology direction contested)", "none in software — drift is well-documented"],
+      "external_status": "EXTERNALLY_ESTABLISHED (in software)",
+      "rune_status": "RUNE_APPLICABLE (Rune consolidates via LLM summarization — same mechanism)",
+      "architecture_impact": "HIGH",
+      "falsifier": "none plausible — mitigation is the question, not existence",
+      "experiment_required": false,
+      "classification": "ADOPT mitigations: consolidate from immutable sources only; quote-verification before promotion; drift tests"
+    },
+    {
+      "claim_id": "CLS-R1-C008",
+      "claim": "Evidence→episode→observation→belief→procedure progression with deterministic state transitions and LLM-only content operations",
+      "evidence_for": ["S001/S044 CLS stage structure", "S029 latent-cause: updating = inference (LLM content ops) over deterministic state", "S041 episodic control (fast layer engineering-validated)", "Rune T0: state transitions already deterministic; promotion gate exists"],
+      "evidence_against": ["stage boundaries are Rune's construct, not CLS's — CLS has two stores, not five stages", "over-engineering risk (meta-review #3)"],
+      "external_status": "EXTERNALLY_ESTABLISHED (as two-layer); the 5-stage elaboration is RUNE-designed",
+      "rune_status": "RUNE_APPLICABLE (transitions already deterministic; T0 PROVEN)",
+      "architecture_impact": "MEDIUM",
+      "falsifier": "if 5-stage bookkeeping adds friction without measurable lesson quality, collapse to 2-stage (episodes + consolidated)",
+      "experiment_required": true,
+      "classification": "ADAPT (keep progression but treat intermediate stages as labels on one store, not separate stores)"
+    },
+    {
+      "claim_id": "CLS-R1-C009",
+      "claim": "Shadow-mode provisional generalizations (behavioral-only until corroborated by independent episodes)",
+      "evidence_for": ["S003/S005 interference-threshold logic supports probation", "S050 consolidation corruption risk argues for pre-promotion probation", "TiMem dual-buffer probation (prior closure O) — convergent design"],
+      "evidence_against": ["no biological analog needed — this is engineering", "adds state complexity"],
+      "external_status": "RUNE_HYPOTHESIS (engineering design informed by interference thresholds)",
+      "rune_status": "RUNE_HYPOTHESIS",
+      "architecture_impact": "MEDIUM",
+      "falsifier": "if shadow-mode beliefs never differ from direct promotion outcomes in retrospective analysis, drop the mode",
+      "experiment_required": true,
+      "classification": "EXPERIMENT"
+    },
+    {
+      "claim_id": "CLS-R1-C010",
+      "claim": "Recency-based consolidation priority should be rejected",
+      "evidence_for": ["S012 replay NOT recency-biased in biology", "S013 co-reactivation ↔ forgetting", "R0 rationale holds"],
+      "evidence_against": ["S038 freshness dominates in RL replay buffers (recency has value!)", "adversarial#3: no transfer evidence either direction for semantic consolidation"],
+      "external_status": "CONTESTED",
+      "rune_status": "RUNE_HYPOTHESIS",
+      "architecture_impact": "LOW",
+      "falsifier": "if recency-weighted consolidation matches utility-weighted on lesson quality, the rejection is dogma",
+      "experiment_required": true,
+      "classification": "REFINED — reject recency-ONLY; do not assume utility-weighting either; benchmark both against dedup+diversity baseline"
+    }
+  ]
+}

research/memory-atlas-r1/A-complementary-learning-systems/r0_reconciliation.md

@@ -0,0 +1,22 @@
+# R0 → R1 Reconciliation (#376 CLS)
+
+_Every material R0 claim, revisited. R0 source: memory-atlas/families/complementary_learning_systems.md_
+
+| R0 claim | R1 verdict | Why |
+|---|---|---|
+| Fast exact episodic storage + slow generalized knowledge is the right split | **CONFIRMED** (with rationale correction) | Survives adversarial pass as ENGINEERING pattern (S047 caveat noted); interference management (S045) is the transferable content, not the anatomy. Rune's gap is operational (index coverage), not architectural. |
+| Two stores / two writers analogy | **CONFIRMED** | Already RUNE_PROVEN structurally (T0); CLS adds justification via interference content; adversarial "it's just LSM" accepted as caveat, not defeat. |
+| Schema-gated fast path | **REFINED → DEFERRED-EXPERIMENT** | R0 said "justified by CLS"; R1: mechanism CONTESTED externally (encoding-vs-consolidation confound, S007/S008; adversarial#2), schema detection is a new error-prone component, and consolidation lag is unmeasured. Reclassified EXPERIMENT with a precondition (measure lag first). Evidence level downgraded from implied-strong to RUNE_HYPOTHESIS. |
+| Utility-prioritized consolidation | **REFINED** | R0 accepted Mattar-Daw transfer; R1: transfer to semantic consolidation UNPROVEN (adversarial#3), PER has documented fragilities (S038/S039), and Rune's own frequency signal was never validated. Reclassified: benchmark utility vs dedup+diversity baseline before any adoption; recency-only rejection itself downgraded to "benchmark it" (C010). |
+| Retained covering episodes | **CONFIRMED (rationale replaced)** | Adversarial#4 FAILED to kill the conclusion but SUCCEEDED against the rationale: not reconsolidation — DRIFT CORRECTION (S049/S050). Evidence level upgraded: RUNE_APPLICABLE with software evidence, not biological analogy. |
+| Shadow-mode provisional beliefs | **CONFIRMED as EXPERIMENT** | R0 hypothesis; R1 adds convergence (TiMem) + falsifiable kill criterion + leakage failure mode. |
+| Reconsolidation → supersession mapping | **OVERTURNED** | R0 asserted the mapping; R1: pharmacological foundation contested (S018-020), trigger mismatch (write vs retrieval), and S029's latent-cause account explains the same data as ORDINARY belief-updating — the neuroscience framing adds nothing. Keep supersession; keep the prediction-error GATE atom; drop the framing. (Also corrected: Nader & Hardt are PRO-reconsolidation — R0's assumption was inverted.) |
+| Independent-evidence corroboration gate | **CONFIRMED (evidence strengthened)** | R0 hypothesis; R1 adds: wash_count PROVEN unvalidated (T0.1), injection threat makes write-path validation distinct from dedup (S054), and the gate is implementable over existing provenance at zero schema cost. Still needs the retraction-rate experiment. |
+| Destructive consolidation rejection | **CONFIRMED (upgraded)** | R0 rejected on principle; R1: drift/corruption is MEASURED in software (S049/S050/S052) — the strongest evidence in the entire domain, and it's engineering evidence, not analogy. |
+| Recency-based consolidation rejection | **REFINED** | R0 rejected recency citing S012; R1: S038 shows freshness dominates in RL buffers — recency has documented value; the honest position is benchmark recency vs utility vs diversity, not dogma. |
+| Evidence→episode→observation→belief→procedure progression | **REFINED** | Keep the stages as LABELS on one store (T0-proven fields); do NOT materialize separate stores per stage. Over-engineering guard from meta-review. |
+| T1 impact = YES (three missing mechanisms) | **REFINED** | The three R0 mechanisms become: drift guards (ADOPT), independence gate (ADAPT), event-triggered consolidation (EXPERIMENT). Schema fast-path dropped from T1 scope to deferred-experiment. |
+
+Tally: CONFIRMED 4 · REFINED 5 · OVERTURNED 1 · STILL_UNKNOWN 0 (all bounded into experiments).
+
+Honest note: R0 was directionally right on every claim — but three of its rationale chains did not survive contact with the primary literature, and one mechanism (schema fast path) was prematurely promoted toward T1. That is exactly what R1 exists to catch.

research/memory-atlas-r1/A-complementary-learning-systems/sources.md

@@ -0,0 +1,3 @@
+# Sources Ledger (#376 R1)
+
+Columns: source_id | title | authors | year | venue | DOI/arXiv/URL | peer-reviewed | primary/secondary | version | research question | mechanism | method | claims supported | claims contradicted | limitations | Rune relevance | confidence | read depth (ABSTRACT_ONLY/RELEVANT_SECTIONS/FULL_PAPER/CODE_AUDITED/REPLICATED)

research/memory-atlas-r1/AA-security-memory-poisoning/AA_SECURITY_MEMORY_POISONING_R1_MASTER.md

@@ -0,0 +1,16 @@
+# AA — Security / Memory Poisoning: R1 Domain Master
+## #402
+
+**Executive summary:** TMA-NM (2606.24322) is the design law — content- and lineage-based trust are both launderable; trust MUST be bound at write time from input channel, elevated only via human/Sybil-resistant processes. MemCollusion (2608.01637) proves per-record trust scoring is unsound — taint must propagate to derived records.
+
+**Attack landscape:** AgentPoison (NeurIPS 2024, >80% ASR <0.1% poison rate); PoisonedRAG (USENIX 2025, 90% ASR from 5 texts in 1M corpus); InjecMEM (COLM 2026, single-interaction injection); MemCollusion/Salami (81.3% save rate, 75% ASR — kills individual-record defenses); MPBench (systematic taxonomy — aggressive agents more exploitable); eTAMP (environment-observation-only poisoning); Sleeper poisoning (60-89% action success, dormant).
+
+**Defenses:** TMA-NM origin binding (provable, machine-checked); CaMeL 2503.18813 (control/data-flow separation — memory reads are untrusted data, never trigger state mutations); trust-aware retrieval with temporal decay (2601.05504 — but thresholds brittle); forensic trajectory detection (2606.30566 — AUC 0.99 but 25-53% benign FPR; warning against recall-signal auto-quarantine); GRAB-RAG — sufficiency-based confidence cannot substitute for source-based trust.
+
+**Design invariants for Rune:** (1) channel-bound trust, never laundered by summarization; (2) elevation only via human review or Sybil-resistant corroboration; (3) taint propagation through derived memories; (4) time-bounded re-verification; (5) quarantine as visible state, not silent deletion.
+
+**SQLite transfer (highest of all domains):** origin_channel, trust_level (write-time bound), taint set, quarantined_at, supersession/rollback rows.
+
+**Classification:** ADOPT (TMA-NM origin binding, CaMeL data-flow separation, taint propagation, quarantine-as-state); EXPERIMENT (temporal decay trust, forensic trajectory detection); REJECT (per-record trust scoring, sufficiency-based abstention for security). Evidence: EXTERNALLY_ESTABLISHED.
+
+**R0:** CONFIRMED 3 · REFINED 2 · OVERTURNED 0 · Sum = 5.

research/memory-atlas-r1/AB-multimodal-artifact-memory/AB_MULTIMODAL_ARTIFACT_MEMORY_R1_MASTER.md

@@ -0,0 +1,14 @@
+# AB — Multimodal / Artifact Memory: R1 Domain Master
+## #403
+
+**Executive summary:** Literature multimodal "memory" is never a second store — it is either a shared embedding space (Nomic Embed Vision 2406.18587 explicitly shares latent space with nomic-embed-text) or distilled artifacts (Voyager 2305.16291 code skills; Agent Workflow Memory 2409.07429 abstracted routines, +24.6%/+51.1% relative success). Screenshots in GUI agents are INPUT, not retained memory.
+
+**Verdicts:**
+- **ADOPT**: artifact memory as metadata (path, hash, MIME, mtime, provenance — ledger already does this)
+- **ADAPT**: code-artifact distillations tied to outcomes (Voyager/AWM pattern)
+- **REJECT**: storing screenshots/images as memory entries (zero payoff evidence for text-first agent, real token/storage cost)
+- **FUTURE**: nomic-embed-vision into the EXISTING index (no second store) if a concrete "I saw that file/error before" retrieval failure appears — EXPERIMENT only then
+
+**Evidence grades:** CLIP 2103.00020, Voyager, AWM, CogAgent = A (peer-reviewed); Nomic Embed Vision, OS-Copilot, surveys = B.
+
+**R0 reconciliation:** CONFIRMED 2 · REFINED 1 · OVERTURNED 0 · Sum = 3.

research/memory-atlas-r1/AC-local-offline-intelligence/AC_LOCAL_OFFLINE_INTELLIGENCE_R1_MASTER.md

@@ -0,0 +1,14 @@
+# AC — Local / Offline Intelligence: R1 Domain Master
+## #404
+
+**Executive summary:** Nomic Embed (2402.01613, TMLR) achieves cloud-parity embeddings locally — Rune's local embedding is evidence-backed, not convenience. BUT: no A/B evidence exists that small local models match cloud on consolidation-style summarization — that gap is the crux.
+
+**Verdicts:**
+- **ADOPT**: local embedding (nomic-embed-text via Ollama — verified parity with Ada-002/emb-3-small on MTEB 2210.07316)
+- **REJECT**: local LLM consolidation (summarize/merge/rewrite facts) with small models — silent quality loss, unmeasurable without ground truth
+- **EXPERIMENT**: small local models for MECHANICAL ops only (dedup clustering, tag/title extraction, tool-call classification — MobileLLM 2402.14905 ICML 2024 covers exactly this class)
+- **FUTURE**: quantized consolidation; revisit when an ≤8B A/B study on memory-consolidation quality exists
+
+**Evidence:** QLoRA 4-bit NF4 preserves task performance (2305.14314, NeurIPS 2023); quantization degradation predictable not chaotic (2103.13630); layer-pruning headroom (2403.17887, ICLR 2025). Asymmetry doctrine: consolidation is a rare background op — cloud for judgment-heavy, local for mechanical.
+
+**R0 reconciliation:** CONFIRMED 2 · REFINED 1 · OVERTURNED 0 · Sum = 3.

research/memory-atlas-r1/AD-hardware-resource-placement/AD_HARDWARE_RESOURCE_PLACEMENT_R1_MASTER.md

@@ -0,0 +1,14 @@
+# AD — Hardware / Resource Placement: R1 Domain Master
+## #405
+
+**Executive summary:** "Memory-resident vs disk-backed" is VACUOUS below ~10^5 entries. All ANN-placement literature (HNSW 1603.09320 TPAMI 2018; DiskANN 2105.09613; SPANN 2111.08566 — both NeurIPS 2021) is calibrated at 10^6–10^9 points. vstash (2604.15484): vector+FTS5 hybrid in a single SQLite file at 20.9ms median latency at 50,000 chunks — 54× Rune's count.
+
+**Rune arithmetic:** 924 × 768-dim float32 ≈ 2.7MB. Brute-force cosine is sub-millisecond. SQLite on NVMe + OS page cache = effectively memory-resident (sqlite.org/mmap.html); mmap optional copy-avoidance with documented failure modes.
+
+**Verdicts:**
+- **ADOPT**: whole-store memory-residency as a side effect (SQLite on NVMe + page cache; optional mmap_size)
+- **REJECT**: DiskANN/SPANN-style disk-backed ANN (design point 10^9, not 10^3) and any dedicated vector database
+- **REJECT**: Pi placement for memory operations — no model capacity, no measurable benefit; current split (PC: Gitea/CI/Ollama; Pi: TLS/backup) matches the doctrine that placement follows capability
+- **FUTURE**: revisit only if the store crosses ~10^5 entries (vstash shows the SQLite stack holds well past that)
+
+**R0 reconciliation:** CONFIRMED 1 · REFINED 2 · OVERTURNED 0 · Sum = 3.

research/memory-atlas-r1/AE-memory-evaluation/AE_MEMORY_EVALUATION_R1_MASTER.md

@@ -0,0 +1,17 @@
+# AE — Memory Evaluation / Benchmark Science: R1 Domain Master
+## #406
+
+**Executive summary:** R0's LoCoMo critique CORROBORATED (6.4% wrong answer key; ~63–64% judge wrong-accept — directional, via secondary reporting; full-context baseline ~73% J beats Mem0's best ~68% per Zep's released eval code). New failure mode beyond R0: scoring-target noninvariance (2605.24060) flips benchmark conclusions on 83–94% of shared LoCoMo/LongMemEval queries depending on which derived form gets retrieval credit.
+
+**Minimal viable evaluation for a single-user store with no ground truth:**
+1. Hand-curated ~50–100 question probe set over Rune's own history (abstention questions verifiable with zero ground truth) — LongMemEval 2410.10813 ICLR 2025 taxonomy: temporal, update, abstention
+2. Ledger-derived end-task outcome metrics — τ-bench pattern (2406.12045): compare final DB state vs goal state; pass^k reliability
+3. Hybrid-retrieval disagreement as continuous label-free health signal (vstash: 74.5% of queries produce top-10 disagreement between lexical and dense lanes)
+
+**Verdicts:**
+- **REJECT**: running LoCoMo/MemBench (wrong population: multi-persona synthetic chat, not coding traces; known scoring pathologies)
+- **ADAPT**: LongMemEval question taxonomy; judge use only with FairEval position calibration (2305.17926: ordering alone flips 66/80 verdicts; MT-Bench 2306.05685: ~80% agreement with position/verbosity bias)
+- **ADOPT**: the three-part minimal eval above
+- **EXPERIMENT**: pass^k reliability across repeated sessions
+
+**R0 reconciliation:** CONFIRMED 2 · REFINED 2 · OVERTURNED 0 · Sum = 4.

research/memory-atlas-r1/B-human-memory-cognitive-science/00_issue_scope.md

@@ -0,0 +1,68 @@
+# #377 R1 — 00_issue_scope.md
+
+## Core question
+
+What distinctions and mechanisms established by human memory and cognitive-science
+research are genuinely useful for Rune's Memory architecture, and which should be
+rejected as biological detail, misleading metaphor, or human failure mode?
+
+## Investigative scope (30 areas per mandate)
+
+1. episodic memory; 2. semantic memory; 3. autobiographical memory;
+4. prospective memory; 5. working memory; 6. procedural memory;
+7. source memory; 8. familiarity vs recollection; 9. cue-dependent recall;
+10. context-dependent recall; 11. temporal memory; 12. prospective
+obligations/reminders; 13. encoding vs storage vs retrieval failure;
+14. consolidation; 15. reconsolidation/update; 16. interference;
+17. forgetting; 18. retrieval-induced forgetting; 19. spacing effects;
+20. testing/retrieval-practice effects; 21. false memories;
+22. misinformation effects; 23. source-monitoring errors;
+24. confidence/metamemory boundaries; 25. salience/emotion (mechanics only);
+26. memory transformation over time; 27. schema effects (delta only vs #376);
+28. distortions from repeated summarization/reconstruction;
+29. prospective cues and event-triggered remembering;
+30. unavailable vs inaccessible vs forgotten vs overwritten.
+
+## R0 hypotheses under re-evaluation (NOT accepted)
+
+H1: prospective memory → typed obligation rows with trigger field.
+H2: episodic vs semantic → entry-kind distinctions.
+H3: autobiographical → session/task narrative records.
+H4: source memory → mandatory origin fields.
+H5: recollection/familiarity → exact/lexical vs semantic retrieval analogy.
+H6: cue/context recall → task/session scoping.
+H7: reconsolidation → supersession analogue (ALREADY OVERTURNED by #376 R1:
+     reconsolidation framing rejected; prediction-error-gated updating kept).
+H8: spacing → reactivation-driven consolidation priority.
+H9: confidence → evidence-linked rather than self-reported.
+H10: RIF → reject imitation.
+H11: false-memory research → anti-pattern/design constraint.
+H12: source-monitoring errors → provenance requirement.
+
+H7 incorporates #376's correction: the reconsolidation→supersession mapping
+is dead. This tranche must not reintroduce it; the prediction-error-gate atom
+survives independently (Sevenster/Beckers/Kindt 2014 via #376).
+
+## Falsifiers
+
+F1: If episodic/semantic/autobiographical are descriptive human taxonomies
+rather than computationally distinct processes, Rune must not materialize
+them as separate stores.
+F2: If prospective-memory findings primarily concern biological attentional
+limitations Rune does not share, they do not by themselves justify an
+"obligation memory" subsystem.
+F3: If familiarity/recollection evidence does not transfer cleanly to
+lexical/vector retrieval, reject that analogy.
+F4: If spacing/testing effects depend strongly on human neural learning
+rather than information availability, do not use them as consolidation policy.
+F5: If human forgetting mechanisms mostly exist because biology is
+resource-limited in ways Rune is not, Rune should solve overload with
+indexing, cooling and paging instead of imitating forgetting.
+F6: If human metamemory confidence is systematically unreliable, do not map
+human confidence mechanisms directly to Rune trust.
+
+## Stopping criterion
+
+Evidence saturation: new sources repeat known mechanisms/criticisms, add
+only detail. No arbitrary paper-count target — but a few paragraphs and a
+handful of citations are NOT sufficient for a foundational field.

research/memory-atlas-r1/B-human-memory-cognitive-science/01_inward.md

@@ -0,0 +1,85 @@
+# #377 R1 — 01_inward.md
+
+## Current Rune mechanisms mapped to human-memory questions (evidence-first)
+
+_Source: direct read-only inspection of memory.db (924 entries) + T0/T0.1
+archaeology. Status vocabulary: PROVEN / IMPLEMENTED_UNPROVEN /
+DESIGNED / DORMANT / ABSENT / BROKEN._
+
+### Canonical entries and kinds
+- kinds present: `fact` (729), `neuron` (195). NO episodic/semantic/
+  autobiographical/procedural/prospective kinds exist. Memory_type column
+  exists but R0 found only `associative` populated.
+- Status: PROVEN (counts), but kind coverage is NARROW — H2 (entry-kind
+  distinctions) would be NEW schema, not a rename.
+
+### Facts vs neurons
+- Neurons (195) = warm-neuron activation rows with wash_count history;
+  facts (729) = durable content. 304 entries have wash_count>0.
+- Status: PROVEN. Use-history exists but T0.1 found it unvalidated as
+  quality signal (superseded entries carry high wash counts).
+
+### Retrieval lanes
+- Dense: 420/924 entries have vectors (sqlite-vec, 256-d). FTS5/BM25:
+  560 rows. Hybrid recall dense+BM25+RRF+floor: PROVEN (T0).
+- T0.1 R3: 439/838 active entries retrievable by NEITHER index.
+- Recollection/familiarity analogy (H5) would map to exact/lexical vs
+  vector lanes — lanes exist (PROVEN), the ANALOGY is untested.
+
+### Temporal fields
+- valid_from non-null on all 924; valid_until on 56 (supersession-derived).
+- Status: IMPLEMENTED_UNPROVEN for tri-timestamp semantics — fields exist,
+  retention policy and record-time query path unproven (T0 AS-IS).
+
+### Provenance/source/method
+- Columns: `source`, `method` (values: curator 679, dedupe_policy 165,
+  directive 34, migrate_blocks 22, warm_router 6, record 5). NO `origin`
+  column — R0's "mandatory origin field" (H4) is DESIGNED, not present.
+- `derived_from` edge: ABSENT (#376 R1 finding).
+- Confidence column exists (IMPLEMENTED_UNPROVEN — calibration unknown).
+
+### Trust
+- NO `trust_level` column — trust lifecycle (provisional/validated/locked)
+  lives in governance scripts, not as entry state. UNKNOWN state: ABSENT.
+- H9 (evidence-linked confidence): DESIGNED.
+
+### Supersession
+- 56 superseded rows retained; valid_until set. PROVEN. Write-triggered
+  (not retrieval-triggered) — #376 R1 overturned the reconsolidation
+  mapping; prediction-error gate atom survives.
+
+### Obligations/task systems
+- No obligation entry kind. Task system (auto_tasks.db, 2 tasks) and
+  PendingOperation machinery exist SEPARATELY from Memory.
+- H1 (obligation rows in Memory) would be NEW — the boundary question
+  (§10) is live: obligation-as-Memory vs Memory-as-evidence-for-tasks.
+
+### Persona/relationship memory
+- No dedicated persona/relationship kinds. Persona lives in constitution
+  files; relationship memory is implicit in facts.
+- Status: ABSENT as memory kinds.
+
+### Consolidation and failure learning
+- Consolidation → knowledge.json: PROVEN to run; trigger non-deterministic
+  (agent-invoked; no cron — T0.1 R5).
+- promotion_eligible flag exists; wash_count feeds it (unvalidated).
+- knowledge.json: derived artifact, source-attributed.
+
+### Warm Neurons
+- 195 neuron rows; tier='warm' on ALL 924 rows = vestigial (T0.1 R4).
+- Wash/use history PROVEN; activation ≠ truth doctrine stated but the
+  scoring (wash_count+importance) is frequency-only (NFU-like per #376/#385).
+
+## Where R0 renamed software without proving transfer
+1. "Episodic vs semantic → entry kinds": Rune has NO such kinds; calling
+   facts-vs-chronicles "episodic/semantic" would rename an ABSENT
+   distinction. Transfer must be EARNED, not asserted.
+2. "Recollection/familiarity → exact/vector": lanes exist, but dual-process
+   theory adds nothing until a retrieval-routing decision cites it.
+3. "Cue/context recall → task scoping": scoping exists (session/task keys);
+   Godden & Baddeley add no mechanism.
+4. "Spacing → reactivation priority": wash_count already counts
+   reactivation; Cepeda adds nothing unless a spacing SCHEDULE is proposed.
+5. "Prospective memory → obligation rows": the boundary question is
+   unresolved; R0 assumed the answer (Memory) without arguing against
+   task-system ownership.

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/README.md

@@ -0,0 +1,9 @@
+# 02 — OUTWARD (populated by deep-research actor; verified by controller)
+
+Files: taxonomy_of_memory.md, episodic_semantic_memory.md,
+autobiographical_memory.md, prospective_memory.md, source_memory.md,
+working_memory.md, procedural_memory.md, cue_context_retrieval.md,
+temporal_memory.md, forgetting_interference.md, false_memory_source_errors.md,
+spacing_testing_learning.md, consolidation_retrieval_update.md,
+competing_models.md, criticisms_replication.md, software_transfer.md
++ sources.md (ledger) + claims.json (machine-readable).

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/autobiographical_memory.md

@@ -0,0 +1,6 @@
+# Autobiographical memory
+
+Conway & Pleydell-Pearce (2000) SMS: generative construction yoked to identity goals. Adversarial #6 SUCCEEDS: this is the confabulation engine a truth-preserving store must NOT imitate (identity-flattering reconstruction, telescoping, goal-consistent distortion).
+
+Rune use: session/task narratives exist (COVERED as chronicles); any "life-story synthesis" must be fenced from the evidence store and labeled generated. Take only a warning label.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/competing_models.md

@@ -0,0 +1,8 @@
+# Competing models / disputes
+
+- Systems vs processes: Foster & Jelicic 1999; Roediger/Buckner/McDermott 1999-style process critiques; Schacter & Tulving 1994. Psychologists' own failure to agree on system count = evidence software should not hard-code one taxonomy (adversarial #8).
+- Unitary vs dual-process recognition: Wixted 2007 / Dunn 2004 / Wixted & Mickes 2010 vs Yonelinas 1994. Live dispute; software mapping built on it is sand.
+- Working memory: Baddeley boxes vs Cowan activation vs Engle attention. Active contest.
+- Inhibition vs interference (RIF mechanism); storage-loss vs retrieval-failure; reconstructive (Bartlett) vs trace views; modularity (Squire) vs distributed processing.
+- Functional accounts: Nairne survival-processing; Henke 2010 processing-modes — dissolve store boundaries into processes/functions.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/consolidation_retrieval_update.md

@@ -0,0 +1,6 @@
+# Consolidation / retrieval / updating (delta vs #376)
+
+No deep duplication of #376 CLS per mandate. #376 R1 already: overturned reconsolidation→supersession mapping; kept prediction-error-gated updating; confirmed retained covering episodes (rationale = drift correction); rejected destructive consolidation.
+
+Human-memory additions from this tranche: Fuzzy Trace verbatim/gist opponent processes (Brainerd & Reyna) — store both, expect gist to outlive detail; Bartlett schema-assimilation across retellings — minimize re-encoding retrieved outputs; reconsolidation boundary conditions (Sevenster prediction-error gate, via #376) — update-on-violation, not on retrieval.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/criticisms_replication.md

@@ -0,0 +1,9 @@
+# Criticisms / replication / negative evidence
+
+- RIF: small effect + publication bias (Murayama 2014); reliability weak (Potts 2012; Eur Psychologist 2011; Frontiers 2014); inhibition signature often fails (Camp 2007).
+- Misinformation boundaries: McCloskey & Zaragoza 1985; recent high-powered boundary work.
+- Godden & Baddeley 1975: N=18, small-N legacy; Smith & Vela 2001: small/fragile overall.
+- DRM ecological validity (Pezdek & Lam 2007); Shaw & Porter 2015 rate disputes.
+- WEIRD populations; lab-vs-naturalistic prospective-memory gaps; measurement confounds (remember/know, ROC procedures).
+- Consolidation-hallucination links contested/mixed (Darsaud; Calvillo 2016).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/cue_context_retrieval.md

@@ -0,0 +1,12 @@
+# Retrieval: cues, context, recognition
+
+**Encoding specificity: Tulving & Thomson (1973), Psych Review 80(5) (~4690 cites).** Retrieval succeeds to the degree cues reinstate encoding conditions. ROBUST principle, boundaries debated. Bearing: store encoding context alongside content; match on cues present at write.
+
+**Availability vs accessibility: Tulving & Pearlstone (1966, JVLVB).** Unrecallable-under-one-cue items become available under another — failure is often accessibility, not erasure. ROBUST; designated THE key distinction. Bearing: default to retrieval-failure hypothesis before deletion; forgetting policy gates on demonstrated inaccessibility across cues, never single failed recall.
+
+**Context-dependence: Godden & Baddeley (1975, BJP 66:325-331)** — divers, N=18, WEAK-evidence legacy. **Smith & Vela (2001)** synthesis: overall effect small/fragile; reinstatement helps mainly with impoverished cues. CONTESTED/small-effect. State-dependence similarly fragile. Bearing: context tags help; expect small gains; never rely on context match alone.
+
+**Recognition vs recall; recollection vs familiarity:** Yonelinas (1994) dual-process vs Wixted unitary-strength (2007; Wixted & Mickes 2010). CONTESTED — both fit much data; measurement confounds. Adversarial #4 SUCCEEDS: do not reify two hardware systems; keep two retrieval GRADES (detail-bearing vs bare signal) as outputs; track confidence separately. Bearing: the lexical/vector mapping inherits a live dispute — justify hybrid retrieval by IR engineering only.
+
+**Retrieval competition, temporal order, partial cues:** cue-overload competition ROBUST; temporal-order memory error-prone/reconstructive; partial cues help only when encoding-compatible (encoding-specificity corollary).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/episodic_semantic_memory.md

@@ -0,0 +1,6 @@
+# Episodic / semantic memory
+
+See taxonomy (Tulving 1972/1985/2002). Status: ROBUST descriptive; CONTESTED as strict neural systems (adversarial #1: Henke 2010 processing-modes; systems-vs-processes debate; Vargha-Khadem 1997 amnesic dissociations preserve a weak distinction).
+
+Bearing for Rune: strongest candidate for two store-types (event records with source/context vs distilled durable claims) — but as QUERY-TIME TAGS, never schema partition (adversarial verdict). F1 falsifier stands: descriptive taxonomy ≠ computational process split.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/false_memory_source_errors.md

@@ -0,0 +1,18 @@
+# False memory / source errors
+
+**DRM: Roediger & McDermott (1995, JEP:LMC 21(4):803-814; Deese 1959).** Lure recalled ~40-55%, recognized at studied-item rates, ~72% "remember" judgments. ROBUST, heavily replicated; ecological-validity critiques (Pezdek & Lam 2007). Bearing: associative retrieval generates confident false positives — penalize gist-only matches lacking verbatim support.
+
+**Fuzzy Trace Theory: Brainerd & Reyna (2002, Curr Dir Psych Sci 11(5):164-169; 2005 OUP book).** Parallel verbatim (decays fast) + gist (persists) traces; false memory = gist-supported + verbatim-unsuppressed; signature predictions: delay increases false memory while true decays; developmental reversal (older show MORE DRM false memory). ROBUST alternative to unitary-trace views. Bearing: store BOTH verbatim detail and gist; expect gist to outlive detail; gist-vs-verbatim contradiction should trigger verification, not averaging.
+
+**Reconstruction: Bartlett (1932, Remembering).** Repeated reproduction rationalizes toward schemas. Foundational; direct replication difficult (Bergman & Roediger 1999 partial), schema-consistent distortion ROBUST via successors. Bearing: each retrieval-rewrite cycle risks schema assimilation — minimize re-encoding retrieved outputs as new entries without provenance.
+
+**Rich false memories: Shaw & Porter (2015, Psych Sci 26:291-301)** — whole-event implantation possible with suggestive pressure (~70%, coding-dependent). CONTESTED rates, ROBUST possibility.
+
+**Misinformation: Loftus & Palmer (1974, JVLVB 13(5):585-589); Loftus, Miller & Burns (1978).** Post-event narrative blends with/overwrites original; grows with delay, lowers with discrepancy detection. ROBUST core; CONTESTED mechanism (McCloskey & Zaragoza 1985: modified tests reduce apparent impairment). Bearing: post-event inputs (corrections, restatements, tool outputs) can corrupt originals — keep original vs amendment separated with source tags.
+
+**Confidence-accuracy: Wixted & Wells (2017) eyewitness family; Koriat metamemory.** Confidence malleable (feedback, repetition), often miscalibrated. ROBUST dissociation. Bearing: never confidence-as-accuracy-proxy; track calibration separately.
+
+**Cryptomnesia/reality monitoring/false fame (Jacoby et al. 1989, JPSP):** ROBUST demonstrations of origin confusion. Bearing: generation events labeled self-generated at write time.
+
+All converge on: append-only + supersession-linking beats destructive consolidation (adversarial #10 FAILED as attack — Maynez 2020 + SSGM 2026 corroborate).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/forgetting_interference.md

@@ -0,0 +1,8 @@
+# Forgetting / interference
+
+Interference (proactive/retroactive) ROBUST since Underwood/McGeoch; pure trace-decay WEAK as sole account — most forgetting = cue-dependent inaccessibility + competition. Directed forgetting ROBUST as control phenomenon. Adaptive/intentional forgetting (Anderson & Hanslmayr) CONTESTED as unified mechanism.
+
+**RIF: Anderson, Bjork & Bjork (1994, JEP:LMC 20(5):1063-1087).** ~10-13% effect; inhibition account. Status CONTESTED — real but fragile: Murayama et al. (2014, Psych Bulletin) meta-analysis small effect + publication bias; Raaijmakers/Verde interference alternatives; Potts et al. (2012) reliability weak; cue-independence (inhibition signature) often fails (Camp et al. 2007).
+
+Bearing: do NOT implement inhibition-as-deletion — retrieval practice suppressing neighbors is exactly what a memory system must avoid; treat RIF as hazard (retrieval narrows access), not feature. Adversarial #7 SUCCEEDS: keep tiered storage; ban "forgetting" vocabulary; the one transferable rule = never delete, only de-index (availability vs accessibility).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/procedural_memory.md

@@ -0,0 +1,4 @@
+# Procedural memory
+
+Squire declarative/nondeclarative split (ROBUST coarse). "How I do X" ≠ "what happened" — supports separating procedure traces from statable entries. NOT_RELEVANT as memory-store mechanism (skill runtime concern); relevant as taxonomy boundary.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/prospective_memory.md

@@ -0,0 +1,12 @@
+# Prospective memory
+
+**Einstein & McDaniel (1990, JEP:LMC 16:717-726).** Event vs time-based; external event cues beat self-initiated time monitoring; age deficits larger for time tasks. **Sellen et al. (1997, Memory 4:483-507)** in-situ confirmation. ROBUST.
+
+**Monitoring costs — PAM vs multiprocess:** Smith (2003) PAM (capacity-consuming preparatory monitoring; ongoing-task slowing) vs McDaniel & Einstein (2000 Applied Cog Psych; 2005) multiprocess (monitoring + spontaneous retrieval; salient/focal cues pop without cost); Reese & Cherry (2002) against constant monitoring (~2% reported thinking of intention). CONTESTED coexistence; pure-PAM rejected for mundane tasks.
+
+**Interruption/resumption: Altmann & Trafton (2002)** goal-activation model: interruptions decay activation; resumption lag grows with length; reminders restore. **McDaniel et al. (2004, Applied Cog Psych 18:533-547):** delays degrade performance; external reminders eliminate interruption cost. ROBUST practical findings.
+
+**Implementation intentions: Gollwitzer (1999, American Psychologist 54:493-503).** If-then plans substantially raise follow-through. ROBUST, large literature.
+
+Bearing: prefer event-anchored triggers over pure time; time intentions need external scaffolding; support both spontaneous firing (salient cues) AND costly watch (non-focal); store intentions as cue→action pairs with explicit triggers + reminder scaffolding. BUT adversarial #2 (Risko & Gilbert 2016 offloading) says obligations belong OUTSIDE memory in a commitment authority — the obligation-entry-kind question is NOT settled by this literature (see 03_applicability).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/software_transfer.md

@@ -0,0 +1,4 @@
+# Software transfer (placeholder — full chain in 03_applicability)
+
+Transfer rule: HUMAN FINDING → GENERAL COMPUTATIONAL PRINCIPLE → SOFTWARE ANALOGUE → RUNE APPLICABILITY → RUNE PRESCRIPTION. If one arrow cannot be justified, stop the chain. Full treatment in 03_applicability.md; key results: availability/accessibility → retrieval-failure-before-deletion policy; encoding specificity → store encoding context; Fuzzy Trace verbatim/gist → dual representation with verification on conflict; offloading literature → obligations OUTSIDE memory; testing effect → reactivation-as-durability (not ranking).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/source_memory.md

@@ -0,0 +1,6 @@
+# Source memory / monitoring
+
+**Johnson, Hashtroudi & Lindsay (1993, Psych Bulletin 114(1):3-28).** Source attributions = decisions over features (perceptual, contextual, affective, cognitive-operations records), heuristic (fast) vs systematic (slow) judgments. External/internal/reality monitoring types. ROBUST/influential framework.
+
+Bearing: every entry needs source features recorded at write; source judgments at READ are fallible decisions — provenance must be stored, not inferred. Adversarial #3: mechanism analogy backwards (Rune already has columns), but Johnson's cue inventory is a useful schema checklist; errors spike under similarity/time-pressure → predicts when retrieval needs provenance-weighted ranking.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/spacing_testing_learning.md

@@ -0,0 +1,8 @@
+# Spacing / testing / reactivation
+
+**Spacing: Cepeda et al. (2006, Psych Bulletin 132(3):354-380).** 839 assessments: spaced > massed in 259/271. Lag effects (Glenberg; Kahana); Bahrick et al. (1993) 9-year retention (56-day gaps optimal there). ROBUST — among psychology's most replicated. Mechanism accounts (encoding variability, study-phase retrieval, deficient processing) CONTESTED; multifactor prevails.
+
+**Testing: Roediger & Karpicke (2006, Psych Sci 17(3):249-255); Karpicke & Roediger (2008, Science 319:966-968).** Repeated testing beats restudying on delayed retention; Butler (2010) superior transfer. Dunlosky et al. (2013) rates practice testing + distributed practice highest-utility. ROBUST. **Desirable difficulties: Bjork (1994) family** — effortful retrieval aids retention.
+
+Bearing (adversarial #5 verdict): re-exposure scheduling is the one human effect safe to import as POLICY — but frequency ≠ spacing; the wash_count question resolves toward SPACED re-presentation, not raw repetition count. Allow reactivation into retention/tiering decisions; FORBID (or heavily discount) in relevance ranking. Spacing is acquisition-side; ranking is a separate judgment.
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/taxonomy_of_memory.md

@@ -0,0 +1,10 @@
+# Taxonomy of memory (human literature)
+
+**Tulving (1972)** episodic vs semantic (Organization of Memory; K.C. amnesic dissociations). Later: Tulving 1985 autonoetic/noetic; Tulving 2002 mental time travel. Status: ROBUST as descriptive distinction; CONTESTED as strict neural-systems claim.
+
+**Squire (1992 Psych Review; Squire & Zola 1996 PNAS).** Declarative (hippocampal-dependent) vs nondeclarative (skills/habits/priming). ROBUST at coarse grain. Bearing: separate skill/procedure traces from statable entries.
+
+**Conway & Pleydell-Pearce (2000, Psych Review 107(2):261-275).** Self-Memory System: autobiographical memory hierarchical (lifetime periods → general events → event-specific knowledge), reconstructed under working-self control; generative, not replay. ROBUST/influential. Bearing: warns against treating recalled episodes as verbatim logs.
+
+**Baddeley & Hitch (1974); Baddeley (2000, TiCS 4(11), episodic buffer).** Dual-task interference basis. ROBUST framework, revised often. Competitor: **Cowan (1999)** embedded-processes (activated LTM + ~4-chunk focus); Engle executive-attention third pole. Active CONTEST. Bearing: do NOT hard-imitate slot buffers; transferable = capacity-limited active set + executive control (~4-chunk focus).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/temporal_memory.md

@@ -0,0 +1,4 @@
+# Temporal memory
+
+Tri-timestamps already adopted from Graphiti (prior closure; COVERED). This literature adds: temporal-order memory is reconstructive and error-prone — "as-of" queries must trust stored timestamps, never reconstructed order. No new mechanism beyond prior closure; cross-reference #376-adjacent schema work minimally per mandate (no deep duplication).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/02_outward/working_memory.md

@@ -0,0 +1,4 @@
+# Working memory
+
+Baddeley & Hitch 1974 / Baddeley 2000 (above) vs Cowan 1999 vs Engle. Active contest; do not hard-imitate boxes. Transferable: capacity-limited active set + executive control. NOT_RELEVANT as store concern (context window / skill runtime).
+

research/memory-atlas-r1/B-human-memory-cognitive-science/03_applicability.md

@@ -0,0 +1,109 @@
+# #377 R1 — 03_applicability.md
+
+_For every surviving mechanism: the 19 applicability questions + the transfer
+chain HUMAN FINDING → GENERAL PRINCIPLE → SOFTWARE ANALOGUE → RUNE
+APPLICABILITY → RUNE PRESCRIPTION. Chain breaks are recorded, not smoothed._
+
+## T1. Availability/accessibility distinction (Tulving & Pearlstone 1966)
+- Human finding: unrecallable-under-one-cue items become available under
+  another — failure is often accessibility, not erasure.
+- Principle: retrieval failure ≠ storage loss.
+- Analogue: multi-cue retrieval + deletion gated on demonstrated
+  inaccessibility across cues.
+- Rune: PROVEN problem (439/838 active entries unindexed — but those are
+  AVAILABILITY failures, worse). Prescription: default to retrieval-failure
+  hypothesis; forgetting/deletion policy requires demonstrated
+  inaccessibility across cues, never single failed recall.
+- Owner: retrieval layer + deletion policy. LLM: none. Offline: yes.
+  Century: yes. Cheapest: deletion-gate rule. EXTERNALLY_ESTABLISHED → RUNE_APPLICABLE.
+
+## T2. Encoding specificity (Tulving & Thomson 1973)
+- Finding: retrieval succeeds to the degree cues reinstate encoding conditions.
+- Principle: store the conditions, not just the content.
+- Analogue: encoding-context metadata on entries (session/task/partition keys
+  already exist; extend to query-relevant cue fields).
+- Rune: PARTIALLY solved (scoping exists). Prescription: extend stored context
+  fields; retrieval matches on write-present cues. Owner: retrieval layer.
+
+## T3. Fuzzy Trace verbatim/gist (Brainerd & Reyna 2002/2005)
+- Finding: parallel traces; gist persists, verbatim decays; false memory is
+  gist-supported + verbatim-unsuppressed.
+- Principle: keep both representations; contradiction between them triggers
+  verification, not averaging.
+- Analogue: store exact source text + distilled gist side by side (Rune
+  already stores text; gist = summary field).
+- Rune prescription: verbatim/gist dual representation with
+  conflict-triggered verification. Owner: Memory. Cheap: schema fields.
+  EXTERNALLY_ESTABLISHED → RUNE_APPLICABLE. (Chain holds end to end.)
+
+## T4. Source-monitoring cue inventory (Johnson 1993) — schema only
+- Per adversarial #3: mechanism backwards, inventory useful. Prescription:
+  ensure origin/source/method/verbatim-detail/operation-record fields exist
+  (partially present; origin column ABSENT → add). Owner: Memory schema.
+
+## T5. Prospective cues → task authority, NOT memory (adversarial #2 wins)
+- Human finding: event cues beat time monitoring; monitoring costs are real;
+  implementation intentions (cue→action pairs) work.
+- Principle: intentions need triggers + scaffolding.
+- Analogue: commitment state machine with trigger conditions.
+- Rune applicability: the OWNER is the task/commitment authority, NOT Memory
+  (Risko & Gilbert 2016 offloading: externalize intentions). R0's H1
+  (obligation rows IN Memory) is OVERTURNED as stated.
+- Prescription: obligations live in task system with open/kept/broken states;
+  Memory holds evidence ABOUT commitments. Event-triggered remembering reuses
+  PendingOperation machinery where applicable. Owner: task system.
+  EXTERNALLY_ESTABLISHED → RUNE_APPLICABLE (with corrected owner).
+
+## T6. Testing effect → durability signal only (adversarial #5 verdict)
+- Finding: retrieval strengthens the trace (Roediger & Karpicke 2006).
+- Principle: reactivation = durability event.
+- Analogue: reactivation count feeds retention/tiering.
+- Rune: allowed into retention decisions; FORBIDDEN in relevance ranking
+  (category jump: learning schedule ≠ relevance score; rich-get-richer).
+- Owner: retention policy. Cheap: spaced-reactivation counter distinct from
+  wash_count.
+
+## T7. Misinformation/DRM → anti-pattern constraints
+- Findings: post-event blending (Loftus), gist false positives (DRM 40-55%
+  recall, 72% "remember"), schema assimilation across retellings (Bartlett).
+- Principle: every transformation is a corruption opportunity.
+- Analogues: consolidate from immutable sources only; original-vs-amendment
+  separation; penalize gist-only retrieval matches; minimize re-encoding
+  retrieved outputs.
+- Rune: largely COVERED (append-only, supersession); ADD: gist-match penalty
+  in retrieval scoring; re-encoding guard. Owner: Memory + retrieval.
+
+## T8. RIF → hazard, never feature
+- Finding: retrieval practice suppresses competitors (~10-13%, fragile).
+- Rune: retrieval must not narrow access to neighbors. Prescription: no
+  inhibition mechanism; monitor for retrieval-narrowing as a bug class.
+- Owner: retrieval layer. REJECT imitation (adversarial #7 supports).
+
+## T9. Confidence-accuracy dissociation → calibration discipline
+- Finding: confidence malleable, miscalibrated (Wixted & Wells; Koriat).
+- Principle: never confidence-as-accuracy.
+- Analogue: evidence-linked confidence + separate calibration tracking.
+- Rune: confidence column exists (IMPLEMENTED_UNPROVEN). Prescription:
+  calibration tracked per source/kind; self-reported confidence distrusted.
+- Owner: Memory schema + governance.
+
+## T10. Context-dependence → small-gain tags (expectations capped)
+- Finding: real but small/fragile (Smith & Vela 2001); N=18 legacy.
+- Prescription: keep context tags; never rely on context match alone;
+  measure gains before investing. Owner: retrieval.
+
+## T11. Recognition grades without dual-process ontology
+- Per adversarial #4: keep two retrieval outputs (detail-bearing vs bare
+  signal) + separate confidence; do NOT cite Yonelinas as architecture.
+- Owner: retrieval layer. Justification: IR engineering (child H), not
+  psychology.
+
+## T12. Autobiographical generativity → fence + label
+- Finding: SMS construction yoked to identity goals (Conway 2000).
+- Prescription: any life-story synthesis fenced from evidence store,
+  labeled generated. Owner: Persona/presentation layer, never canonical Memory.
+
+## Authority assignments (Q19)
+Memory owns: T1, T2, T3, T4, T6, T7, T8, T9, T10, T11. Task system owns: T5.
+Persona/presentation owns: T12. Retrieval layer implements: T1, T2, T8, T10, T11.
+No mechanism here belongs to Substrate, World Model, or Spine.

research/memory-atlas-r1/B-human-memory-cognitive-science/04_innovation.md

@@ -0,0 +1,57 @@
+# #377 R1 — 04_innovation.md
+
+_Falsifiable integration hypotheses only. Each: prior art, difference,
+advantage, cost, failure mode, benchmark, kill criterion._
+
+## I1. Availability-gated deletion (prior art: HSM tiering policies)
+- Difference: deletion requires demonstrated inaccessibility across N
+  independent cue sets + time window, not age or single failed recall.
+- Advantage: eliminates the worst deletion class (available-but-inaccessible).
+- Cost: bookkeeping per deletion candidate. Failure: gate too strict →
+  unbounded growth (mitigate: tiering absorbs).
+- Benchmark: zero wrongful deletions on synthetic available-but-inaccessible
+  probes. Kill: gate never fires in 6 months → simplify.
+
+## I2. Verbatim/gist dual entries with conflict verification (prior art:
+Fuzzy Trace Theory; Rune text+summary fields)
+- Difference: explicit conflict detector — when gist contradicts verbatim
+  detail, verification fires instead of averaging.
+- Advantage: catches consolidation drift at the representation level.
+- Cost: dual storage + detector. Failure: detector false positives annoy.
+- Benchmark: drift-detection rate on synthetic gist/verbatim conflicts.
+- Kill: no conflicts detected in production over 6 months → keep schema,
+  drop detector.
+
+## I3. Spaced-reactivation durability counter (prior art: Cepeda spacing;
+Anki/SRS scheduling)
+- Difference: separates durability counting (spaced re-presentations) from
+  relevance ranking (topical fit) — two counters, two consumers.
+- Advantage: resolves the wash_count conflation T0.1 exposed.
+- Cost: one new counter + scheduler. Failure: scheduler complexity.
+- Benchmark: retention prediction accuracy vs wash_count.
+- Kill: no retention-prediction gain → drop.
+
+## I4. Gist-match penalty in retrieval (prior art: DRM literature; child H
+reranking)
+- Difference: retrieval scores down-weight matches supported only by
+  gist-level similarity without verbatim support, for factual queries.
+- Advantage: directly attacks the 40-55% DRM-style false-positive class.
+- Cost: scoring change. Failure: over-penalization hurts paraphrase recall
+  (tune on paraphrase-vs-lure test set).
+- Benchmark: lure-rejection rate vs paraphrase-recall rate.
+- Kill: paraphrase recall drops >5% → revert.
+
+## I5. Commitment-evidence linking (prior art: GTD trusted-system concept;
+Rune PendingOperation)
+- Difference: task-system commitments carry memory-evidence pointers
+  (supporting entries), and memory entries ABOUT commitments link back —
+  bidirectional without co-location (respects adversarial #2's ownership
+  verdict).
+- Advantage: obligations auditable against evidence without living in Memory.
+- Cost: link maintenance. Failure: stale links.
+- Benchmark: commitment audit completeness on synthetic set.
+- Kill: links unused in 6 months → drop.
+
+No manufactured novelty: I1 = HSM policy + Tulving distinction; I2 = FTT
+applied to schema; I3 = SRS practice applied to counters; I4 = DRM
+literature applied to scoring; I5 = GTD + existing Rune machinery.

research/memory-atlas-r1/B-human-memory-cognitive-science/05_adversarial.md

@@ -0,0 +1,135 @@
+# #377 R1 — 05_adversarial.md
+
+_Independent pass (separate actor/context). Instruction: assume the emerging
+human-memory → Rune conclusions are wrong. Verdicts: ATTACK SUCCEEDS / MIXED /
+ATTACK FAILED. ✅ = tool-verified citations; ⚠️ = canonical references._
+
+## 1. Episodic/semantic store separation — MIXED, leans SUCCEEDS
+**Henke (2010, Nat Rev Neurosci)** ✅ — processing-modes (rapid-flexible vs
+slow-rigid encoding) should replace the consciousness-based declarative split.
+If right, an episodic/semantic table split reifies the wrong ontology: the
+joint is at processing mode, not phenomenology. Backing: systems-vs-processes
+debate (⚠️ Foster & Jelicic 1999; ⚠️ Roediger/Buckner/McDermott 1999-style
+process critiques); ⚠️ Cabeza et al. 2008 (parietal = attention-to-memory, not
+episodic module); ⚠️ Nairne/Thompson/Pandeirada 2007 (survival-processing
+functional account). Patient dissociations (⚠️ Vargha-Khadem 1997, Science:
+developmental amnesia sparing semantic learning) keep the distinction alive —
+demoted to "one contested taxonomy," not neural fact.
+**Software verdict: query-time tag, never schema partition.**
+
+## 2. Obligation-as-memory — ATTACK SUCCEEDS (strongest in brief)
+**Risko & Gilbert (2016, Trends Cogn Sci)** ✅ — cognitive offloading: agents
+perform better EXTERNALIZING intentions than retaining them; intention-offloading
+literature shows people set external triggers precisely because internal
+prospective memory is unreliable. ⚠️ Allen (2001, GTD): "mind like water" via
+capture into a trusted EXTERNAL system. Hostile inference: obligations are the
+canonical case where science says DO NOT store as memory traces — they belong
+in a commitment/task authority with state machines (open/kept/broken/
+superseded), deadlines, reminders; memory holds only evidence ABOUT the
+commitment. Putting obligations inside the memory store repeats the exact error
+the offloading literature diagnoses.
+**Verdict: obligations live outside Memory.**
+
+## 3. Source-memory analogies — MIXED, leans FAILED
+⚠️ Johnson/Hashtroudi/Lindsay 1993 (source-monitoring framework); ⚠️ Johnson &
+Raye 1981 (reality monitoring): a brain doing forensic reconstruction from
+impoverished cues because it has NO provenance bus. Rune already has
+source/method columns — importing "source-monitoring processes" brings a candle
+to a lit room. Honest admission: Johnson's diagnostic cue inventory (verbatim
+detail, operation records, affective tags, contextual embedding) is a useful
+SCHEMA checklist, and source errors spiking under similarity/time-pressure
+predicts when retrieval needs provenance-weighted ranking.
+**Verdict: analogy backwards as mechanism, useful as schema checklist.
+Downgrade "implement source monitoring" → "store what source monitoring
+wishes it had."**
+
+## 4. Recollection/familiarity → lexical/vector mapping — ATTACK SUCCEEDS
+Three verified kill-shots: **Wixted (2007, Psych Review)** ✅ — unitary
+unequal-variance signal-detection model fits the ROC data dual-process
+theorists claimed exclusively. **Dunn (2004, Psych Review)** ✅ —
+remember/know dissociations fall out of unidimensional strength + decision
+criteria. **Wixted & Mickes (2010, Psych Review)** ✅ — "continuous
+dual-process" concedes recollection is graded, collapsing the categorical
+joint the mapping leans on. (⚠️ Rotello et al. 2005 same point via
+process-dissociation critiques.) Mapping BM25→familiarity/vectors→recollection
+inherits a live dispute as settled architecture.
+**Verdict: keep hybrid retrieval (it works), justify by IR engineering, never
+by dual-process psychology. The mapping adds zero architectural force.**
+
+## 5. Spacing/reactivation → activation scoring — MIXED, leans SUCCEEDS
+⚠️ Cepeda et al. 2006 (Psych Bulletin): spacing framed as ACQUISITION/encoding
+phenomenon (optimal inter-study intervals as function of retention interval).
+Nothing licenses "reactivated often → rank higher at retrieval" — a category
+jump from learning schedule to relevance score, smuggling frequency-past-use
+into relevance where it swamps topical fit (rich-get-richer). Admission:
+⚠️ Roediger & Karpicke 2006 (testing effect) proves retrieval IS an encoding
+event — reactivation genuinely strengthens the trace.
+**Verdict: reactivation allowed into retention/tiering decisions, FORBIDDEN
+(or heavily discounted) in relevance ranking.**
+
+## 6. Autobiographical-memory requirements — ATTACK SUCCEEDS
+**Conway & Pleydell-Pearce (2000, Psych Review)** ✅ — autobiographical recall
+is GENERATIVE CONSTRUCTION yoked to the "working self" and identity goals, not
+playback. ⚠️ Conway 2005: coherence with self-goals constrains construction.
+That is precisely the confabulation engine a truth-preserving store must NOT
+imitate — importing SMS requirements invites identity-flattering
+reconstruction, telescoping, goal-consistent distortion dressed as "rich
+autobiographical context."
+**Verdict: dangerous as design input. Take only a warning label: any
+"life-story synthesis" feature must be fenced off from the evidence store and
+labeled generated.**
+
+## 7. Human forgetting → software cooling — ATTACK SUCCEEDS (one caveat)
+Storage engineering solved tiering decades ago without psychology (HSM,
+LRU/LFU/ARC, buffer pools — hit-rate math, no Ebbinghaus). "Cooling" that
+merely demotes priority is eviction policy with a cardigan; calling it
+"forgetting" licenses the one thing a single-user truth store must never do —
+silent data loss — while adding no mechanism (no decay constant transfers to
+SQLite rows). Caveat: the availability-vs-accessibility distinction maps to a
+sound rule — never delete, only de-index.
+**Verdict: keep tiered storage; ban the word "forgetting" from the codebase
+vocabulary. The metaphor's expected value is negative.**
+
+## 8. Cognitive-science terminology adds architecture — ATTACK SUCCEEDS
+The field's own meta-literature: systems-vs-processes controversy plus "how
+many systems?" stalemates (⚠️ Schacter & Tulving 1994; ⚠️ Foster & Jelicic
+1999) — labels proliferating while predictions stay put. Adopting "episodic /
+semantic / procedural / source / familiarity" imports five contested ontologies
+and zero ranking functions, loss functions, or invariants.
+**Gate: every borrowed noun must answer — what query does it change, what
+invariant does it enforce, what test would falsify it? Failing that gate =
+documentation perfume. Terminology guilty until proven mechanistic.**
+
+## 9. Bonus: computer memory should NOT imitate humans — MIXED
+⚠️ Schacter 1999 (American Psychologist: "seven sins") — a spec sheet for what
+NOT to build. ⚠️ Norman 1986/1988 (gulfs of execution/evaluation) — bridge
+limits with external structure, don't mirror them. Database/IR orthodoxy never
+cites Atkinson–Shiffrin: durability, transactions, recall metrics come from
+engineering. Admission: nobody wants to imitate FALLIBILITY — borrowings are
+functional (separate concerns, provenance, tiering); biomimetic inspiration
+constrained by benchmarks is legitimate.
+**Verdict: "human memory is a terrible database" is true and worth posting on
+the wall — kills naive imitation, not disciplined functional borrowing.**
+
+## 10. Bonus: consolidation-hallucination — ATTACK FAILED
+Backfired into corroboration. **Maynez et al. 2020 (ACL)** ✅ — widespread
+hallucination in abstractive summarizers, direct analog of lossy LLM
+consolidation rounds. **SSGM (2026 preprint)** ✅ — semantic drift across
+evolving LLM memory updates as governed risk. Both support the FALSE-memory-
+as-anti-pattern stance: each summarization round is a misinformation
+opportunity; append-only + supersession-linking beats destructive
+consolidation.
+**Verdict: evidence sides with the main researcher.**
+
+## Failed-attack rollup
+- #3 partially failed: Johnson's cue inventory informs schema.
+- #5 partially failed: testing effect legitimizes reactivation as durability
+  signal (not ranking signal).
+- #9 partially failed: kills naive mimicry only.
+- #10 fully failed: Maynez 2020 + SSGM 2026 corroborate append-only/supersede.
+- #1 partially failed: amnesic dissociations preserve weak tag-level
+  episodic/semantic distinction.
+
+Strongest clean kills: #2 (obligations out of memory), #4 (dual-process
+mapping built on sand), #6 (autobiographical confabulation engine),
+#7 (forgetting vocabulary), #8 (terminology without mechanism).

research/memory-atlas-r1/B-human-memory-cognitive-science/06_synthesis.md

@@ -0,0 +1,44 @@
+# #377 R1 — 06_synthesis.md
+
+## Mechanism matrix
+
+| MECHANISM | ORIGINAL PURPOSE | EVIDENCE STRENGTH | LIMITATIONS | RUNE EQUIVALENT | RUNE GAP | TRANSFER VALIDITY | COST | FAILURE MODES | CLASSIFICATION | RUNE EVIDENCE LEVEL |
+|---|---|---|---|---|---|---|---|---|---|---|
+| Episodic/semantic distinction | describe human memory kinds | STRONG descriptive; CONTESTED neural | Henke processing-modes; systems-vs-processes stalemate | none (no such kinds) | — | LOW as stores; MEDIUM as tags | none | reified wrong ontology | query-time TAGS, never schema partition | RUNE_HYPOTHESIS |
+| Availability/accessibility | explain recall failure | STRONG (Tulving & Pearlstone) | — | none (no deletion gate) | deletion-gate rule | HIGH | bookkeeping | gate too strict | ADAPT | RUNE_APPLICABLE |
+| Encoding specificity | explain cue effects | STRONG + boundaries | — | session/task scoping (partial) | cue-field extension | HIGH | schema fields | over-tagging | ADAPT | RUNE_APPLICABLE |
+| Fuzzy Trace verbatim/gist | explain false memory + development | STRONG (developmental predictions confirmed) | — | text+summary (implicit) | conflict verification | HIGH | detector | false positives | ADAPT | RUNE_APPLICABLE |
+| Source-monitoring inventory | explain source errors | STRONG framework | mechanism backwards for Rune | source/method cols (partial; origin ABSENT) | origin column | MEDIUM (schema only) | one column | omission under pressure | ADAPT (schema) | RUNE_APPLICABLE |
+| Prospective cues | explain remembering-to-act | STRONG (event>time; monitoring costs; implementation intentions) | lab-vs-naturalistic gaps | task system + PendingOperation (separate) | commitment-evidence links | HIGH (with corrected owner) | links | stale links | task-system ADAPT; REJECT memory co-location | RUNE_APPLICABLE |
+| Testing effect | explain retention | STRONG | acquisition-side only | wash_count (conflated) | spaced-durability counter | MEDIUM (durability only) | counter | scheduler complexity | ADAPT (durability); REJECT (ranking) | RUNE_HYPOTHESIS |
+| Spacing | optimize learning schedules | STRONGEST in psychology | encoding-side; no ranking license | none | re-presentation policy | MEDIUM | scheduler | — | EXPERIMENT | RUNE_HYPOTHESIS |
+| DRM/gist hazards | explain false recall | STRONG | word-list ecology | dedupe/supersede (partial) | gist-match penalty | HIGH | scoring change | paraphrase harm | ADAPT | RUNE_APPLICABLE |
+| Misinformation blending | explain post-event corruption | STRONG core; mechanism contested | — | append-only + supersession | re-encoding guard | HIGH | guard | friction | ADAPT | RUNE_APPLICABLE |
+| RIF | explain forgetting-after-retrieval | FRAGILE (small + bias) | inhibition contested; reliability weak | none (good) | monitoring as bug class | LOW (as mechanism) | none | implementing it | REJECT imitation | EXTERNALLY_ESTABLISHED (fragility) |
+| Dual-process recognition | explain recognition ROCs | CONTESTED (Wixted/Dunn kill-shots) | — | hybrid lanes (exist) | nothing | NONE (mapping dead) | — | sand architecture | REJECT mapping; keep lanes on IR grounds | — |
+| Autobiographical generativity | explain self-memory | STRONG (as description of construction) | — | narratives (exist) | fence + label | HIGH (as warning) | fence | confabulation leak | REJECT as design input | RUNE_APPLICABLE (warning) |
+| Forgetting-as-deletion | explain loss | WEAK as sole account | — | tier flags (vestigial) | tiering without the word | HIGH (tiering) / NONE (word) | vocabulary change | silent loss license | REJECT word; ADAPT tiering | RUNE_APPLICABLE |
+| Confidence-accuracy link | predict accuracy from confidence | DISSOCIATED (robust) | — | confidence col (unproven) | calibration tracking | HIGH (as discipline) | tracking | decoration | ADAPT | RUNE_APPLICABLE |
+| Reconsolidation mapping | update-on-retrieval | CONTESTED (per #376) | trigger mismatch | supersession (write-triggered) | prediction-error gate | LOW (framing dead) | none | dogma | REJECT (per #376; not reintroduced) | — |
+
+## Synthesis narrative
+
+Human memory science gives Rune three kinds of value, in descending order:
+(1) **Error catalogs** — DRM, misinformation, source confusion, schema
+assimilation, confidence dissociation are a field-tested list of what goes
+wrong in any reconstructive memory process, biological or software. Every one
+maps to a concrete Rune guard, and the guards are cheap.
+(2) **Policy-grade effects** — spacing, testing, availability/accessibility,
+encoding specificity are acquisition/retention phenomena robust enough to
+inform scheduling and deletion policy, with the strict boundary that none
+licenses relevance ranking.
+(3) **Warnings** — autobiographical generativity, forgetting vocabulary,
+dual-process ontology, and the systems-vs-processes stalemate are what NOT
+to import.
+
+The single largest correction vs R0: obligations live in the task authority,
+not Memory (Risko & Gilbert 2016 is load-bearing and verified). The single
+largest confirmation: append-only + supersession beats destructive
+consolidation (Maynez 2020 + SSGM 2026 corroborate from the software side).
+The taxonomy question resolves to tags, never partitions (Henke 2010 +
+Vargha-Khadem 1997 jointly: contested ontology, weak surviving distinction).

research/memory-atlas-r1/B-human-memory-cognitive-science/07_qualification.md

@@ -0,0 +1,26 @@
+# #377 R1 — 07_qualification.md
+
+_Classification separate from evidence level. No item above RUNE_APPLICABLE
+except pre-existing RUNE_PROVEN infrastructure; everything new is hypothesis
+until Rune experiments run._
+
+| # | Mechanism | Classification | Evidence level | Conf | T1 impact | Experiment | Rejection criterion |
+|---|---|---|---|---|---|---|---|
+| Q1 | Episodic/semantic/autobiographical as query tags | ADAPT (tags) | RUNE_HYPOTHESIS | MED | LOW | tag-retrieval benefit test | no benefit → drop |
+| Q2 | Obligations in task authority (NOT Memory) | REJECT co-location; ADAPT task commitments | RUNE_APPLICABLE | HIGH | HIGH | audit/completion parity test | parity → revisit |
+| Q3 | Dual-process retrieval mapping | REJECT mapping | — (dead) | HIGH | LOW | — | — |
+| Q4 | Reactivation in durability, banned in ranking | ADAPT / REJECT split | RUNE_APPLICABLE / RUNE_HYPOTHESIS | HIGH | MED | retention A/B | no gain → drop counter |
+| Q5 | Forgetting vocabulary ban; engineering tiering | REJECT word; ADAPT tiering | RUNE_APPLICABLE | HIGH | LOW | — (costless) | — |
+| Q6 | Autobiographical fence-and-label | REJECT input; ADAPT rule | RUNE_APPLICABLE | HIGH | MED | — | — |
+| Q7 | Availability-gated deletion | ADAPT | RUNE_APPLICABLE | MED | MED | synthetic probes | gate never fires → simplify |
+| Q8 | Verbatim/gist dual + conflict verification | ADAPT | RUNE_APPLICABLE | MED | MED | synthetic conflicts | no conflicts → keep schema, drop detector |
+| Q9 | Gist-match penalty | EXPERIMENT | RUNE_HYPOTHESIS | MED | MED | lure vs paraphrase A/B | >5% paraphrase harm → revert |
+| Q10 | Original/amendment separation + re-encoding guard | ADAPT | RUNE_APPLICABLE | HIGH | MED | — (largely covered) | — |
+| Q11 | Calibration tracking (not self-report) | ADAPT | RUNE_APPLICABLE | MED | LOW | calibration measurement | — |
+| Q12 | Mechanistic gate for borrowed nouns | ADAPT (process rule) | RUNE_APPLICABLE | HIGH | LOW | — | — |
+
+## Evidence-level discipline
+No biological finding is cited as Rune proof anywhere in this artifact set.
+Every EXTERNALLY_ESTABLISHED claim that entered prescription passed through
+an explicit applicability argument (03_applicability.md) with its Rune level
+in claims.json. New prescriptions are RUNE_HYPOTHESIS until experiments run.

research/memory-atlas-r1/B-human-memory-cognitive-science/FINAL.md

@@ -0,0 +1,71 @@
+# #377 R1 — Human Memory / Cognitive Science: FINAL (durable technical reference)
+
+_Companion artifacts: 00_issue_scope, 01_inward, 02_outward/ (16 sections +
+sources.md with 44 entries + claims.json with 12 falsifiable claims),
+03_applicability (12 transfer chains), 04_innovation (5 candidates),
+05_adversarial (10 attacks), 06_synthesis (16-row matrix),
+07_qualification (below), r0_reconciliation._
+
+## 1. The domain in one page
+
+Human memory science is a century of careful experiments on a system Rune
+does not have: a biological organ with fixed capacity, no provenance bus, no
+exact storage, and identity goals tangled into recall. Its value to Rune is
+therefore asymmetric: ENORMOUS as an error catalog (every failure mode humans
+exhibit — gist falsification, source confusion, misinformation blending,
+schema assimilation, confidence dissociation — is a hazard any reconstructive
+process faces, including LLM consolidation), MODERATE as policy (spacing,
+testing, availability/accessibility inform scheduling and deletion rules),
+and NEGATIVE as ontology (its taxonomies are contested; importing them as
+schema partitions reifies one faction's vocabulary).
+
+## 2. What transfers, what does not
+
+**Transfers (with Rune evidence ≥ RUNE_APPLICABLE):** availability/
+accessibility → deletion gating; encoding specificity → cue metadata;
+Fuzzy Trace verbatim/gist → dual representation + conflict verification;
+source-monitoring inventory → origin column; testing effect → durability
+(not ranking); misinformation/DRM → anti-reconstruction guards;
+confidence dissociation → calibration discipline; implementation
+intentions → cue→action pairs (in the task system).
+
+**Does not transfer:** store partitions from taxonomies; dual-process
+recognition as retrieval architecture; spacing as ranking signal;
+forgetting as deletion license; autobiographical generativity as design
+input; reconsolidation as supersession rationale (per #376); obligations
+as memory rows; cognitive-science nouns without mechanistic gates.
+
+## 3. The corrected rationale for Rune's pipeline
+
+R0 said: human memory justifies obligation rows, dual-process retrieval,
+spacing-weighted activation, and store-partitioned kinds. R1 corrects:
+human memory justifies ERROR GUARDS (append-only, supersession, provenance,
+verbatim preservation, gist penalties), RETENTION POLICIES (spaced
+re-presentation, availability-gated deletion), and OWNERSHIP DECISIONS
+(obligations to tasks, generativity fenced from evidence). Everything else
+is either IR engineering wearing a psychology costume or contested ontology.
+
+## 4. Experiments required (in order)
+1. Gist-penalty A/B: lure-rejection vs paraphrase-recall (kill: >5%
+   paraphrase harm).
+2. Spaced-durability counter vs wash_count: retention-prediction accuracy.
+3. Deletion-gate trial: availability-gated vs age-based on synthetic
+   available-but-inaccessible probes.
+4. Verbatim/gist conflict detector: detection rate on synthetic conflicts.
+
+## 5. What would change this conclusion
+- A replication resolving dual-process recognition in its favor (would
+  reopen C003 — unlikely to change the IR justification either way).
+- Evidence that co-located obligations outperform task-owned commitments
+  on audit/completion metrics (would reopen C002).
+- Large-scale evidence that spacing schedules improve retrieval ranking
+  (would reopen C004's ranking ban).
+
+## 6. Remaining unknowns (bounded)
+- Optimal spaced-re-presentation schedule parameters (needs retention A/B).
+- Gist/verbatim conflict-detector design (needs prototype).
+- Whether event-triggered obligations can reuse PendingOperation without
+  new state (shared with #376's unknowns; needs code verification).
+
+## 7. Production implementation
+NONE. Research only. All prescriptions enter T1 as design input.

research/memory-atlas-r1/B-human-memory-cognitive-science/claims.json

@@ -0,0 +1,188 @@
+{
+ "note": "Narrow, falsifiable claims. external_status vs rune_status kept separate per R1 standard.",
+ "claims": [
+  {
+   "claim_id": "HM-R1-C001",
+   "claim": "Episodic/semantic/autobiographical distinctions should be query-time tags, never schema partitions",
+   "evidence_for": [
+    "Henke 2010 processing-modes",
+    "systems-vs-processes stalemate",
+    "Nairne functional accounts"
+   ],
+   "evidence_against": [
+    "Vargha-Khadem 1997 amnesic dissociations (weak surviving distinction)"
+   ],
+   "external_status": "CONTESTED (as neural systems)",
+   "rune_status": "RUNE_HYPOTHESIS",
+   "architecture_impact": "LOW",
+   "falsifier": "F1: if tag-based retrieval shows no benefit over untyped, drop tags",
+   "experiment_required": true,
+   "classification": "ADAPT (tags)"
+  },
+  {
+   "claim_id": "HM-R1-C002",
+   "claim": "Obligations belong in the task/commitment authority, NOT in Memory",
+   "evidence_for": [
+    "Risko & Gilbert 2016 offloading review",
+    "Allen GTD trusted-external-system premise",
+    "monitoring-cost literature (Smith PAM vs multiprocess)"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED",
+   "rune_status": "RUNE_APPLICABLE",
+   "architecture_impact": "HIGH",
+   "falsifier": "F2: if Memory-co-located obligations show audit/completion parity with task-owned in A/B, revisit",
+   "experiment_required": false,
+   "classification": "REJECT memory co-location; ADAPT task-system commitments with evidence links"
+  },
+  {
+   "claim_id": "HM-R1-C003",
+   "claim": "Recollection/familiarity must NOT justify the lexical/vector retrieval split",
+   "evidence_for": [
+    "Wixted 2007 UVSD fit",
+    "Dunn 2004 confidence account",
+    "Wixted & Mickes 2010 graded recollection"
+   ],
+   "evidence_against": [],
+   "external_status": "CONTESTED (psychology unsettled)",
+   "rune_status": "RUNE_HYPOTHESIS (mapping dead)",
+   "architecture_impact": "LOW",
+   "falsifier": "F3 resolved: mapping rejected regardless",
+   "experiment_required": false,
+   "classification": "REJECT mapping; keep lanes on IR grounds"
+  },
+  {
+   "claim_id": "HM-R1-C004",
+   "claim": "Reactivation counts belong in retention/tiering decisions, NOT relevance ranking",
+   "evidence_for": [
+    "Cepeda 2006 (acquisition-side)",
+    "Roediger & Karpicke 2006 (retrieval-as-encoding)"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED (as acquisition)",
+   "rune_status": "RUNE_APPLICABLE (durability only)",
+   "architecture_impact": "MEDIUM",
+   "falsifier": "F4/F5: if ranking-with-reactivation beats ranking-without on topical-fit benchmarks, revisit with discount factor",
+   "experiment_required": true,
+   "classification": "ADAPT (durability counter); REJECT (ranking use)"
+  },
+  {
+   "claim_id": "HM-R1-C005",
+   "claim": "Human forgetting vocabulary must not enter the codebase; tiering is engineering",
+   "evidence_for": [
+    "HSM/cache/buffer-pool practice (no psychology needed)",
+    "availability/accessibility distinction as the sound core"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED (engineering)",
+   "rune_status": "RUNE_APPLICABLE",
+   "architecture_impact": "LOW",
+   "falsifier": "F5: none plausible \u2014 vocabulary ban is costless",
+   "experiment_required": false,
+   "classification": "REJECT word; ADAPT tiering"
+  },
+  {
+   "claim_id": "HM-R1-C006",
+   "claim": "Autobiographical generativity is a confabulation engine; fence life-story synthesis from evidence",
+   "evidence_for": [
+    "Conway & Pleydell-Pearce 2000 (generative, goal-yoked)",
+    "Conway 2005 (coherence constraints)"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED (as description)",
+   "rune_status": "RUNE_APPLICABLE (as warning)",
+   "architecture_impact": "MEDIUM",
+   "falsifier": "none plausible",
+   "experiment_required": false,
+   "classification": "REJECT as design input; ADAPT as fence-and-label rule"
+  },
+  {
+   "claim_id": "HM-R1-C007",
+   "claim": "Deletion requires demonstrated inaccessibility across cues (availability/accessibility)",
+   "evidence_for": [
+    "Tulving & Pearlstone 1966"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED",
+   "rune_status": "RUNE_APPLICABLE",
+   "architecture_impact": "MEDIUM",
+   "falsifier": "if gate never fires, simplify",
+   "experiment_required": false,
+   "classification": "ADAPT"
+  },
+  {
+   "claim_id": "HM-R1-C008",
+   "claim": "Store verbatim detail + gist side by side; verify on conflict (Fuzzy Trace)",
+   "evidence_for": [
+    "Brainerd & Reyna 2002/2005 + developmental predictions"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED",
+   "rune_status": "RUNE_APPLICABLE",
+   "architecture_impact": "MEDIUM",
+   "falsifier": "if no conflicts detected in 6 months, keep schema, drop detector",
+   "experiment_required": false,
+   "classification": "ADAPT"
+  },
+  {
+   "claim_id": "HM-R1-C009",
+   "claim": "Penalize gist-only retrieval matches lacking verbatim support (DRM guard)",
+   "evidence_for": [
+    "Roediger & McDermott 1995 (40-55% recall, 72% remember)"
+   ],
+   "evidence_against": [
+    "paraphrase-recall harm risk"
+   ],
+   "external_status": "EXTERNALLY_ESTABLISHED",
+   "rune_status": "RUNE_HYPOTHESIS",
+   "architecture_impact": "MEDIUM",
+   "falsifier": "paraphrase recall drops >5% \u2192 revert",
+   "experiment_required": true,
+   "classification": "EXPERIMENT"
+  },
+  {
+   "claim_id": "HM-R1-C010",
+   "claim": "Post-event inputs can corrupt originals; keep original-vs-amendment separated",
+   "evidence_for": [
+    "Loftus & Palmer 1974; Loftus/Miller/Burns 1978"
+   ],
+   "evidence_against": [
+    "McCloskey & Zaragoza 1985 (mechanism dispute \u2014 blending vs interference)"
+   ],
+   "external_status": "EXTERNALLY_ESTABLISHED (core)",
+   "rune_status": "RUNE_APPLICABLE",
+   "architecture_impact": "MEDIUM",
+   "falsifier": "none plausible",
+   "experiment_required": false,
+   "classification": "ADAPT (already largely covered; add re-encoding guard)"
+  },
+  {
+   "claim_id": "HM-R1-C011",
+   "claim": "Confidence must never proxy accuracy; track calibration separately",
+   "evidence_for": [
+    "Wixted & Wells 2017; Koriat metamemory"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED",
+   "rune_status": "RUNE_APPLICABLE",
+   "architecture_impact": "LOW",
+   "falsifier": "none plausible",
+   "experiment_required": false,
+   "classification": "ADAPT"
+  },
+  {
+   "claim_id": "HM-R1-C012",
+   "claim": "Cognitive-science nouns must pass the mechanistic gate (query changed? invariant enforced? falsifier?) or stay out of the architecture",
+   "evidence_for": [
+    "systems-vs-processes stalemate; Schacter & Tulving 1994; Foster & Jelicic 1999"
+   ],
+   "evidence_against": [],
+   "external_status": "EXTERNALLY_ESTABLISHED (meta)",
+   "rune_status": "RUNE_APPLICABLE (process rule)",
+   "architecture_impact": "LOW",
+   "falsifier": "none \u2014 process discipline",
+   "experiment_required": false,
+   "classification": "ADAPT (as R1 process rule)"
+  }
+ ]
+}

research/memory-atlas-r1/B-human-memory-cognitive-science/r0_reconciliation.md

@@ -0,0 +1,25 @@
+# R0 → R1 Reconciliation (#377 Human Memory)
+
+_R0 source: memory-atlas/families/human_memory_cognitive_science.md_
+
+| R0 claim | R1 verdict | Why |
+|---|---|---|
+| Prospective memory → typed obligation rows (H1) | **OVERTURNED** | Risko & Gilbert 2016 (verified): offloading science says externalize intentions; obligations belong in task authority with state machines. R0 assumed Memory ownership without arguing it. Preserved: cue→action pairs, event-anchored triggers, reminder scaffolding — relocated to task system with memory-evidence links. |
+| Episodic/semantic kinds (H2) | **REFINED → tags, not stores** | Henke 2010 + systems-vs-processes stalemate: contested ontology; Vargha-Khadem preserves weak distinction. R0's "entry kinds" would reify one faction's taxonomy. Downgraded to query-time tags. |
+| Autobiographical narratives (H3) | **REFINED → chronicles kept, generativity fenced** | Chronicles exist (COVERED); Conway SMS shows recall is goal-yoked construction — R0 understated the danger. Added fence-and-label rule. |
+| Source-memory provenance (H4) | **REFINED → schema checklist, not mechanism** | Adversarial #3: analogy backwards (columns already exist); Johnson's cue inventory still earns the origin column. Downgraded from "implement source monitoring" to "store what it wishes it had." |
+| Recollection/familiarity analogy (H5) | **OVERTURNED** | Wixted 2007 / Dunn 2004 / Wixted & Mickes 2010 (all verified): psychology unsettled; mapping built on sand. Hybrid lanes kept on IR grounds only. |
+| Cue/context scoping (H6) | **CONFIRMED (expectations capped)** | Encoding specificity + availability/accessibility stand; Godden & Baddeley capped at small-effect (N=18; Smith & Vela). |
+| Reconsolidation mapping (H7) | **CONFIRMED OVERTURN** (per #376; not reintroduced) | #376 R1 killed the framing; this tranche independently keeps only prediction-error-gated updates. No regression. |
+| Spacing priority (H8) | **REFINED → durability-only** | Cepeda robust as acquisition; adversarial #5 forbids ranking use (category jump). Split into spaced-durability counter (ADAPT) + ranking ban. |
+| Confidence mechanism (H9) | **CONFIRMED (strengthened)** | Dissociation robust (Wixted & Wells; Koriat); added separate calibration tracking requirement. |
+| RIF rejection (H10) | **CONFIRMED** | Fragility confirmed (Murayama meta + reliability literature); hazard framing kept. |
+| False-memory anti-pattern (H11) | **CONFIRMED (strengthened)** | Maynez 2020 + SSGM 2026 corroborate from software side; added gist-penalty + re-encoding guard. |
+| Source-monitoring protections (H12) | **CONFIRMED** | Origin column + verbatim-quote rules stand; generation-event labeling added (Jacoby). |
+
+Tally: CONFIRMED 5 · REFINED 4 · OVERTURNED 2 · STILL_UNKNOWN 0.
+
+Honest note: R0 was right about error prevention (its strongest half) and wrong
+about ownership and ontology (obligations-in-memory, dual-process mapping,
+store-partitioning). The adversarial pass did the most work in this domain —
+five clean kills, four of them against R0's own conclusions.

research/memory-atlas-r1/B-human-memory-cognitive-science/sources.md

@@ -0,0 +1,47 @@
+# Sources Ledger (#377 R1)
+
+| ID | Citation | Year | Venue | Peer? | Type | Read depth | Status | Rune relevance |
+|---|---|---|---|---|---|---|---|---|
+| S001 | Tulving 1972, episodic/semantic (Organization of Memory) | 1972 | book chapter | n/a | primary/theory | RELEVANT_SECTIONS | ROBUST descriptive; CONTESTED neural-systems | taxonomy validity |
+| S002 | Tulving 1985 autonoetic/noetic; 2002 Ann Rev Psych | 1985/2002 | journal | yes | theory | ABSTRACT | revisions of S001 | taxonomy |
+| S003 | Squire 1992 Psych Review; Squire & Zola 1996 PNAS | 1992/1996 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST coarse | skill/procedure boundary |
+| S004 | Conway & Pleydell-Pearce 2000, Psych Review 107(2) | 2000 | journal | yes | synthesis | RELEVANT_SECTIONS | ROBUST/influential | warning label (generative construction) |
+| S005 | Baddeley & Hitch 1974; Baddeley 2000 TiCS | 1974/2000 | chapter/journal | yes | framework | RELEVANT_SECTIONS | ROBUST, revised | capacity-limited active set |
+| S006 | Cowan 1999 embedded-processes; Engle executive attention | 1999 | chapter | yes | theory (competitor) | ABSTRACT | active CONTEST | ~4-chunk focus number |
+| S007 | Tulving & Thomson 1973, encoding specificity | 1973 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST + boundaries | store encoding context |
+| S008 | Tulving & Pearlstone 1966, availability vs accessibility | 1966 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST; key distinction | retrieval-failure-before-deletion |
+| S009 | Godden & Baddeley 1975, divers | 1975 | journal | yes | primary | RELEVANT_SECTIONS | WEAK (N=18) | small-gain context tags |
+| S010 | Smith & Vela 2001, context meta-analysis | 2001 | meta | yes | meta-analysis | ABSTRACT | small/fragile effect | context-match expectations |
+| S011 | Yonelinas 1994 dual-process | 1994 | journal | yes | primary | RELEVANT_SECTIONS | CONTESTED | two retrieval GRADES (not systems) |
+| S012 | Wixted 2007 Psych Review (unitary UVSD) | 2007 | journal | yes | theory | RELEVANT_SECTIONS | live dispute | kills lexical/vector mapping |
+| S013 | Dunn 2004 Psych Review (remember/know = confidence) | 2004 | journal | yes | theory | RELEVANT_SECTIONS | live dispute | same |
+| S014 | Wixted & Mickes 2010 (continuous dual-process) | 2010 | journal | yes | theory | RELEVANT_SECTIONS | concedes graded recollection | same |
+| S015 | Einstein & McDaniel 1990, JEP:LMC | 1990 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST | event-anchored triggers |
+| S016 | Sellen et al. 1997, Memory | 1997 | journal | yes | primary (in-situ) | ABSTRACT | ROBUST | event cues > time cues |
+| S017 | Smith 2003 PAM theory | 2003 | journal | yes | theory | ABSTRACT | CONTESTED coexistence | monitoring cost is real |
+| S018 | McDaniel & Einstein 2000/2005 multiprocess | 2000/05 | journal | yes | framework | RELEVANT_SECTIONS | coexistence | spontaneous + watch |
+| S019 | Altmann & Trafton 2002 goal-activation | 2002 | journal | yes | model | ABSTRACT | ROBUST practical | resumption-lag/reminders |
+| S020 | McDaniel et al. 2004 (delays/reminders) | 2004 | journal | yes | primary | ABSTRACT | ROBUST | external reminders eliminate cost |
+| S021 | Gollwitzer 1999 implementation intentions | 1999 | journal | yes | review | ABSTRACT | ROBUST, large lit | cue→action pairs |
+| S022 | Risko & Gilbert 2016 offloading, TiCS | 2016 | journal | yes | review | RELEVANT_SECTIONS | verified, high-strength | obligations OUTSIDE memory |
+| S023 | Johnson/Hashtroudi/Lindsay 1993 source monitoring | 1993 | journal | yes | framework | RELEVANT_SECTIONS | ROBUST | schema checklist, not mechanism |
+| S024 | Loftus & Palmer 1974; Loftus/Miller/Burns 1978 | 1974/78 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST core; mechanism CONTESTED | original-vs-amendment separation |
+| S025 | McCloskey & Zaragoza 1985 | 1985 | journal | yes | primary (critique) | ABSTRACT | mechanism dispute | same |
+| S026 | Wixted & Wells 2017 eyewitness; Koriat metamemory | 2017/1993 | journal | yes | review/primary | ABSTRACT | ROBUST dissociation | never confidence-as-accuracy |
+| S027 | Jacoby et al. 1989 false fame/cryptomnesia | 1989 | journal | yes | primary | ABSTRACT | ROBUST | label generation events |
+| S028 | Roediger & McDermott 1995 DRM | 1995 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST, replicated | penalize gist-only matches |
+| S029 | Brainerd & Reyna 2002/2005 Fuzzy Trace | 2002/05 | journal/book | yes | theory | RELEVANT_SECTIONS | ROBUST alternative | verbatim+gist dual representation |
+| S030 | Bartlett 1932 Remembering | 1932 | book | n/a | foundational | RELEVANT_SECTIONS | foundational; replication partial (Bergman & Roediger 1999) | minimize re-encoding without provenance |
+| S031 | Shaw & Porter 2015 | 2015 | journal | yes | primary | ABSTRACT | CONTESTED rates, ROBUST possibility | suggestive-pressure caution |
+| S032 | Anderson/Bjork/Bjork 1994 RIF | 1994 | journal | yes | primary | RELEVANT_SECTIONS | CONTESTED/fragile | hazard, not feature |
+| S033 | Murayama et al. 2014 RIF meta-analysis | 2014 | meta | yes | meta-analysis | ABSTRACT | small + publication bias | same |
+| S034 | Cepeda et al. 2006 spacing meta-analysis | 2006 | meta | yes | meta-analysis | RELEVANT_SECTIONS | ROBUST (259/271) | spaced re-presentation policy |
+| S035 | Roediger & Karpicke 2006; Karpicke & Roediger 2008 | 2006/08 | journal | yes | primary | RELEVANT_SECTIONS | ROBUST | retrieval-as-encoding (durability) |
+| S036 | Bjork 1994 desirable difficulties | 1994 | chapter | yes | theory | ABSTRACT | ROBUST direction | effortful retrieval |
+| S037 | Henke 2010 Nat Rev Neurosci (processing modes) | 2010 | journal | yes | theory | RELEVANT_SECTIONS | verified | tag-not-partition |
+| S038 | Maynez et al. 2020 ACL faithfulness | 2020 | conference | yes | primary | RELEVANT_SECTIONS | corroborates anti-pattern | append-only over destructive |
+| S039 | SSGM 2026 semantic drift | 2026 | preprint | no | primary | RELEVANT_SECTIONS | corroborates | same |
+| S040 | Nairne/Thompson/Pandeirada 2007 survival processing | 2007 | journal | yes | primary | ABSTRACT | functional account | dissolve store boundaries |
+| S041 | Vargha-Khadem et al. 1997 Science (developmental amnesia) | 1997 | journal | yes | primary | ABSTRACT | preserves weak distinction | tag-level distinction survives |
+| S042 | Conway 2005 self/memory | 2005 | journal | yes | theory | ABSTRACT | goal-constrained construction | fence life-story synthesis |
+| S043 | Lee & See 2004 trust calibration (via child Z) | 2004 | journal | yes | review | ABSTRACT | anchor | visible fixability |

research/memory-atlas-r1/C-cognitive-architectures/00_issue_scope.md

@@ -0,0 +1,109 @@
+# #378 R1 — 00_issue_scope.md
+
+## Core question
+
+Which mechanisms discovered through cognitive-architecture research genuinely
+solve problems Rune has, which mechanisms should inform Memory/Substrate/
+learning design, and which architecture concepts should be rejected as
+unnecessary imitation?
+
+## Research questions (40 per mandate)
+
+1. Why were cognitive architectures developed?
+2. What recurring architectural problems do they solve?
+3. Which mechanisms independently recur across architectures?
+4. Which mechanisms actually have empirical support?
+5. Which are primarily theoretical engineering choices?
+6. Which have failed to scale?
+7. Which have survived decades of use?
+8. Which architectures remain actively developed?
+9. What happened to abandoned architectures?
+10. What maintenance burden do full architectures create?
+11. Do cognitive cycles provide useful properties or artificial rigidity?
+12. Are declarative/procedural divisions computationally necessary?
+13. What does activation actually accomplish?
+14. What is the strongest evidence for ACT-R activation equations?
+15. How does Soar semantic memory compare?
+16. How do architectures prevent hub/fan effects?
+17. What does spreading activation add beyond ordinary retrieval?
+18. When is procedural compilation/chunking beneficial?
+19. What is the utility problem?
+20. Does impasse-driven learning outperform simple outcome learning?
+21. How are failures represented?
+22. How are stale procedures handled?
+23. What does Global Workspace add computationally?
+24. Is broadcast actually needed in software agents?
+25. What does attention competition accomplish?
+26. How do architectures distinguish active state from long-term memory?
+27. How do symbolic/subsymbolic hybrids work?
+28. Which mechanisms require numeric tuning that becomes maintenance debt?
+29. How do architectures handle uncertainty?
+30. How do architectures handle contradictory knowledge?
+31. How do architectures represent context?
+32. How do they represent goals?
+33. How do they recover from interruption?
+34. How do they select which memory enters active cognition?
+35. Which ideas map naturally to Rune's Warm Neurons?
+36. Which map to procedural learning?
+37. Which belong to Substrate rather than Memory?
+38. Which duplicate mechanisms Rune already possesses?
+39. What would a minimal cognitive architecture for Rune actually contain?
+40. Would Rune be better served by borrowing isolated mechanisms rather than
+    adopting any architecture?
+
+## R0 claims under test (HYPOTHESES, not accepted)
+
+H1: ACT-R base-level activation (B_i ≈ Σ t_j^-d) should inform deterministic
+    Warm Neuron activation.
+H2: Recency + frequency should replace wash_count-style frequency-only behavior.
+H3: ACT-R/Soar fan normalization supports graph/PPR anti-hub weighting.
+H4: Soar chunking supports impasse → successful resolution → procedure promotion.
+H5: Global Workspace / LIDA suggests selected context → broadcast → learning.
+H6: Context inclusion itself might be treated as a consolidation/learning event.
+H7: Activation noise should be rejected for Rune.
+H8: Production-rule engines should be rejected.
+H9: Codelet concurrency / strict cognitive-cycle timing should be rejected.
+H10: Cognitive architectures largely validate Rune's existing separation of
+     memory / active context / procedural execution.
+
+## Technical correction to verify (§8)
+
+R0 represented ACT-R base-level activation approximately as:
+
+    B_i = Σ_j t_j^-d
+
+Verify against original ACT-R sources: the canonical formulation commonly
+includes a logarithm around the summed decayed accesses:
+
+    B_i = ln(Σ_j t_j^-d)
+
+Verify: exact canonical formulations, historical revisions, optimized
+approximations, what d represents, where noise enters, what spreading
+activation adds, what retrieval threshold adds, whether Soar copied the same
+formula exactly or approximately. If R0 misstated the formula, record an
+explicit correction.
+
+## Falsifiers
+
+F1: If ACT-R activation's predictive success is confined to laboratory
+    response-time fitting with non-identifiable parameters, it does not
+    justify Rune adoption.
+F2: If fan-effect → graph-normalization transfer conflates three distinct
+    mathematics (human semantic-network fan, graph-degree normalization,
+    PageRank/PPR), the analogy must be rebuilt per-domain or dropped.
+F3: If Soar chunking's utility problem dominates (rule explosion outweighs
+    benefit), impasse-driven promotion is rejected for Rune.
+F4: If Global Workspace broadcast reduces to publish/subscribe that Rune's
+    event/state machinery already implements, GWT adds nothing.
+F5: If cognitive cycles provide no property that event-driven architecture
+    cannot supply more cheaply (bounded work, fairness, budgets), cycles
+    are rejected as biological imitation.
+F6: If the scaling/failure history shows architectures fail on maintenance
+    burden rather than mechanism quality, the lesson is anti-architecture:
+    borrow mechanisms, never frameworks.
+
+## Stopping criterion
+
+Evidence saturation: new sources repeat known mechanisms/criticisms, add
+only detail. No arbitrary paper-count target — but a few paragraphs and a
+handful of citations are NOT sufficient for a foundational field.

research/memory-atlas-r1/C-cognitive-architectures/01_inward.md

@@ -0,0 +1,110 @@
+# #378 R1 — 01_inward.md
+
+## Current Rune mechanisms vs cognitive-architecture questions (evidence-first)
+
+_Source: direct read-only inspection of memory.db (924 entries) + behavior.db
++ T0/T0.1 archaeology. Status: PROVEN / IMPLEMENTED_UNPROVEN / DESIGNED /
+DORMANT / ABSENT / BROKEN._
+
+### Canonical Memory and use_history
+- 924 entries (729 fact, 195 neuron). wash_count>0 on 304.
+- Status: PROVEN. Use-history exists; T0.1 found it unvalidated as quality
+  signal (superseded entries carry high wash counts).
+
+### wash_count — what job does it do?
+- Currently feeds: promotion_eligible (143 rows), retrieval ranking
+  (frequency term), and nothing else. It does triple duty for truth,
+  activation, and promotion — three unrelated jobs on one counter.
+- Timestamps available: created_at, last_accessed, last_washed per entry.
+  Per-OCCURRENCE timestamps (ACT-R needs the full access history, not just
+  last-accessed): ABSENT. An access log would be NEW.
+- Status: PROVEN counter; ABSENT occurrence history.
+
+### Warm/neuron state
+- 195 neuron rows; tier='warm' on ALL 924 rows = vestigial (T0.1 R4).
+- No activation equation, no spreading, no threshold, no noise.
+- Status: DORMANT as architecture; PROVEN as rows.
+
+### Retrieval ranking
+- Hybrid dense+BM25+RRF+floor (T0 PROVEN). Rank terms: importance,
+  wash_count (frequency), recency via last_accessed (coarse).
+- No decay function, no fan normalization, no threshold gate.
+- Status: PROVEN; activation mathematics ABSENT.
+
+### ContextBroker
+- Planned (T1 target); current: keyword routing + session/task scoping
+  (PROVEN per T0 production entrypoints).
+- Performs PART of a workspace: bounded selection into context. No
+  broadcast, no competition, no learning-from-inclusion.
+- Status: IMPLEMENTED (selection) / DESIGNED (workspace semantics).
+
+### Task/session state
+- auto_tasks.db (2 tasks), PendingOperation machinery, event-driven waits
+  (PROVEN, R13/M9/M10 PASS). Goal stacks: ABSENT as such — goals live in
+  task records + conversation, not a goal buffer.
+- Interruption/resume: PROVEN via event-driven continuation (async
+  programme FROZEN_ACCEPTED).
+
+### Success/failure learning
+- behavior.db: 2 corrections, 1 habit, 0 activations. Mechanism exists;
+  volume is negligible — no statistical signal has ever flowed through it.
+- Status: IMPLEMENTED_UNPROVEN (mechanism) / ABSENT (evidence base).
+
+### Promotion mechanisms
+- promotion_eligible flag (143 rows); governance scripts (provisional/
+  validated/locked lifecycle, PROVEN as code). Impasse signal: ABSENT —
+  no retrieval-failure vs tool-failure distinction is logged.
+- Status: DESIGNED (gate semantics) / ABSENT (impasse trigger).
+
+### Procedural-learning design
+- Skill files exist; promotion/demotion lifecycle DESIGNED (child G
+  research), not exercised. No chunking, no compilation, no utility
+  tracking. Status: DESIGNED.
+
+### Graph/PPR plans
+- graph.sqlite DORMANT (last edge 2026-08-26). PPR: EXPERIMENT (child I
+  protocol defined, bridge-node recall + hybrid ablation). Fan
+  normalization: DESIGNED as requirement, not implemented.
+- Status: DORMANT / EXPERIMENT.
+
+### Scaffolding / Spine / Substrate
+- Scaffolding: construction authority, PROVEN (contracts driven through
+  real flow). Spine: structural truth, evidence-gated maturity (per child P
+  research). Substrate: execution substrate, DESIGNED.
+- These already solve: executive control (task authority + event-driven
+  continuation), architectural state representation (Spine), execution
+  (Substrate). Cognitive-architecture imports must not duplicate them.
+
+### Event-driven continuation/recovery
+- PROVEN (async programme frozen). This is Rune's answer to anything a
+  cognitive cycle might offer (bounded work, fairness, budgets) — the
+  burden is on cycles to show what events cannot do.
+
+### Growth Delta mechanisms
+- Outcome-learned utility: DESIGNED (child E/G research); wash_count is
+  the current proxy, unvalidated.
+
+### Current learning signals (inventory)
+1. wash_count (frequency of retrieval/use) — PROVEN counter, unvalidated.
+2. importance (LLM-assigned scalar) — PROVEN field, calibration unknown.
+3. last_accessed / last_washed (coarse recency) — PROVEN fields.
+4. corrections (2 rows) — negligible volume.
+5. promotion_eligible (143 rows) — gate output, not a signal.
+6. Per-occurrence access history — ABSENT.
+7. Retrieval-failure events — ABSENT.
+8. Outcome-verified success/failure per procedure — ABSENT.
+
+## Inward questions answered (§9)
+
+- Reliable impasse signal? NO — ABSENT. Retrieval failure vs tool failure
+  is not distinguished anywhere.
+- Access timestamps sufficient for ACT-R-like activation? PARTIAL —
+  last_accessed/last_washed exist per entry; per-occurrence history ABSENT.
+- wash_count's jobs? THREE unrelated jobs (truth proxy, activation term,
+  promotion input) on one counter — the core finding.
+- ContextBroker as workspace? PARTIAL — selection yes; competition,
+  broadcast, learning-from-inclusion no.
+- Substrate as executive control? DESIGNED — the claim is untested.
+- Spine as state representation? PROVEN (per T0/T21.5 + child P).
+- Vocabulary renaming risk? HIGH — "activation," "chunk," "workspace,"
+  "attention" could all rename existing systems without adding mechanism.

research/memory-atlas-r1/C-cognitive-architectures/02_outward/README.md

@@ -0,0 +1,10 @@
+# 02 — OUTWARD (populated by the deep-research actor; verified by controller)
+
+Files: field_history.md, act_r.md, soar.md, clarion.md,
+lida_global_workspace.md, sigma.md, opencog_hyperon.md,
+other_architectures.md, declarative_memory.md, procedural_learning.md,
+activation_retrieval.md, spreading_activation.md, working_memory_attention.md,
+goal_impasse_control.md, symbolic_subsymbolic.md, cognitive_cycles.md,
+scaling_and_failure.md, modern_agent_relevance.md, competing_models.md,
+criticism_replication.md, software_transfer.md
++ sources.md (ledger) + claims.json (machine-readable).

research/memory-atlas-r1/C-cognitive-architectures/02_outward/act_r.md

@@ -0,0 +1,20 @@
+# ACT-R deep pass
+
+**History/versions:** 4.0 (1998, Lebiere join, perceptual-motor from EPIC), 5.0 (2004 modules+buffers, brain mapping), 6.0 (2005 rewritten, dynamic pattern matching), 7.x (2015+, typeless chunks, JSON-RPC, Python tutorial). Common Lisp; jACT-R, python_actr, pyactup are partial mirrors. Maintained at CMU, active modelling community, 700+ models, cognitive-tutor deployment — but NOT a production agent substrate.
+
+**Mechanisms:** declarative chunks (typed slot-vectors); productions (buffer-condition → buffer-action, single firing per ~50ms cycle); buffers (goal, imaginal/problem state, retrieval, visual, aural, manual); modules (perceptual-motor + declarative + procedural).
+
+**VERIFIED CANONICAL BASE-LEVEL EQUATION (load-bearing):** per Anderson et al. 2004; Anderson 2007; ACT-R 7 reference manual:
+
+> **B_i = ln( Σ_j t_j^(−d) ) + β_i**
+
+B_i = base-level activation of chunk i; t_j = lag since j-th encounter/use; d = decay rate (default ≈0.5, typically 0.4–0.6); β_i = offset/intercept (prior/familiarity constant). **The logarithm is canonical** — it converts summed recency/frequency trace into log-odds-like need probability under Anderson & Schooler (1991) rational analysis. **R0 CORRECTION: R0 wrote B_i = Σ t_j^−d, missing the ln. Without it the quantity is not activation but raw recency mass.** Historical revisions: early ACT versions used power-law strength without log; rational-analysis integration (1990–93) introduced log-sum form; later work adds β, optional optimized/approximated forms (recency-only or two-point approximations) per reference manual.
+
+**Full activation:** A_i = B_i + Σ_j W_j·S_ji + P_i + ε, where spreading ΣW·S is context boost, P partial-match penalty, ε logistic/similar noise. Retrieval only if A_i > τ (threshold); latency T = F·e^(−A) (F latency factor); probability logistic in (A−τ). Spreading: W_j source weighting (usually 1/n sources), S_ji ≈ S − ln(fan_j) (association strength minus fan penalty). Utility learning for productions: U updated by reward minus cost with noise; production compilation collapses sequences. Noise enters twice: activation noise (transient retrieval stochasticity) and utility noise — both principled as sampling, but in practice often free parameters.
+
+**Fitting methodology:** grid-search parameters per experiment to latency/accuracy/BOLD. Strength: genuine quantitative prediction. Weakness (contested): **parameter identifiability — admitted in Anderson 2004 itself**: "the retrieval threshold, τ, and latency factor, F, are parameters that have varied substantially from model to model," with only the empirical relation F ≈ .35·e^τ offered. d = 0.5 is community convention ("has emerged as the default value... over a large range of applications"), not derivation. Replication requires exact parameters + history traces rarely published. Transfer limits: parameters tuned to one paradigm rarely transfer; brittle chunk-type engineering.
+
+**Anchor-verification note (post-repair):** the author preprint was read in FULL — equation verified verbatim including the logarithm. Anderson & Schooler 1991 (companion OCR'd in full) explicitly states: "We are not too concerned with whether the memory or environmental functions are truly power functions or just good approximations" — the theory itself transfers the SIGNALS, not the power-law form. This is the strongest possible grounding for the R1 conclusion "adopt signals, benchmark the form." 
+
+**Soar copy question — VERIFIED:** Laird (2012, semantic memory ch.; restated Laird 2022 arXiv:2201.09305) says Soar SMEM "implements the base-level activation scheme originally developed for ACT-R." It is **functionally the same form (log-sum power-law) but approximately, not byte-identical**: own decay/parameters, own usage-history storage, plus lazy-evaluation spreading (Jones et al. 2016 ICCM). Cite as approximate adoption, not exact port.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/activation_retrieval.md

@@ -0,0 +1,6 @@
+# Activation / retrieval compared
+
+**What is activation FOR?** The literature conflates five functions Rune must separate: (1) retrieval ordering (rank candidates); (2) cache residency (what stays hot — ECAN/STI, warm neurons); (3) context inclusion (what enters prompt — working-memory budget); (4) forgetting (what decays — base-level); (5) procedural selection (which skill fires — utility). ACT-R uses one number for 1/3/4; Soar splits utility vs declarative activation; ECAN splits STI vs LTI. Rune should follow the split: distinct signals per function (relevance, frequency, recency, accessibility, residency, importance, utility, trust, confidence, task affinity), not one "activation."
+
+Separate dimensions per mandate §20 — do not collapse into one scalar without evidence.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/clarion.md

@@ -0,0 +1,6 @@
+# CLARION (fair treatment)
+
+Sun's dual-representation thesis: every subsystem has **explicit** (localist chunks/rules) and **implicit** (distributed microfeatures/Q-networks) levels, bidirectionally linked (bottom-up rule extraction RER; top-down guidance). Four subsystems: action-centered (procedural), non-action-centered (semantic/episodic), motivational (drives→goals), metacognitive (monitoring/parameter-setting). Explains skill speed-up, verbalization gains, transfer, pressure degradation (Sun et al. 2005 Psych. Rev.; Sun 2016 OUP).
+
+**Bearing on Rune:** the explicit/implicit split is PARTIALLY but not fully captured by deterministic/LLM/local-model layering. What CLARION adds: (a) redundant encoding with principled bottom-up extraction (experience → rule) and top-down shaping (rule → habit) — Rune's procedural-promotion path lacks the second direction; (b) motivational/metacognitive subsystems as first-class (drives → goals → parameter control) — Rune has trust/authority but no drive economy; (c) synergy accounting (when to trust which level). Weaknesses: implementation fragmented (pyClarion partial), validation mostly lab tasks (serial reaction, artificial grammar, Tower of Hanoi), heavy machinery for modest engineering gain. Borrow the bidirectional learning loop and metacognitive parameter control; skip the four-box ontology as mandatory.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/cognitive_cycles.md

@@ -0,0 +1,4 @@
+# Cognitive cycles
+
+Cycles provide bounded work, fairness, predictable budgets (challenge accepted). But fixed biological cadence is unjustified for async agents. Recommendation: **event-driven with bounded quantum** (Soar-like decision cycle as budget unit, not clock): each continuation runs propose→select→act with a work cap, yielding fairness without 10 Hz theatre. (Adversarial #7 verdict: strongest attack in the brief — no production agent runtime runs fixed cognitive cycles; event-driven continuation already PROVEN in Rune contradicts, not complements, fixed cycles.)
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/competing_models.md

@@ -0,0 +1,4 @@
+# Competing models / negative evidence
+
+Connectionism/PDP vs symbols; embodied/situated critiques (Brooks, Varela); single-system vs multi-system memory (carries over from #377); IIT vs GWT (2023 adversarial collaboration unresolved); masking-method critiques (Meyen et al. 2022); BOLD-mapping disputes; parameter-identifiability critiques (Roberts & Pashler 2000; Pitt/Myung/Zhang 2002); power-law-vs-exponential (Heathcote/Brown/Mewhort 2000; Evans et al. 2018; Anderson R.B. 2001 emergence; Murre & Chessa 2011); Kotseruba & Tsotsos 2020 (40 years: fragmentation, near-zero shared benchmarks, few deployed applications).
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/criticism_replication.md

@@ -0,0 +1,4 @@
+# Criticism / replication record
+
+Consolidated with competing-models for the durable record: BOLD mapping contested; GNW ignition-as-proof contested (no-report paradigms, Tsuchiya et al. 2015); broadcast-causes-learning stipulated not derived; LIDA cycle timing unjustified for async; PLN/MOSES failed to scale; Hyperon immature; LIDA constructs lack comparative benchmarks; ACT-R buffers added/removed across versions on modelling convenience; Soar chunking semantics replaced across versions (1986 ≠ today).
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/declarative_memory.md

@@ -0,0 +1,4 @@
+# Declarative-memory mechanisms compared
+
+Recurring independents (strong signal): recency + frequency → accessibility; context spreading; fan/degree penalty; threshold-gated retrieval; noise/stochasticity; utility-based procedural retention. These recur in ACT-R, Soar, ECAN, LIDA — treat as **convergent requirements**, not coincidence. Representation varies (chunks, fact graphs, hypergraph atoms, coalition models); indexing varies (slot matching, RETE, spreading); retrieval gating (threshold τ vs preference arbitration vs budget) is the dimension that matters for Rune.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/field_history.md

@@ -0,0 +1,8 @@
+# Field history — why each architecture was created
+
+**Newell (1990, Harvard UP, Unified Theories of Cognition):** isolated micro-models would never cumulate; a fixed architecture + variable knowledge should span tasks. Directly relevant to Rune: fixed substrate (store, retrieval, authority) vs variable entries.
+
+**Lineage:** Newell/Simon/Shaw Logic Theorist/GPS → production systems (IF-THEN + working memory, RETE matching) → two rival answers to Newell. **ACT-R** (Anderson; HAM 1973 → ACT 1976 → ACT* 1983 → ACT-R 1993) was created to model HUMAN data quantitatively (latency, accuracy, fMRI) under rational analysis: cognition approximates environmental statistics. **Soar** (Laird/Newell/Rosenbloom; Laird 1983 thesis; Laird et al. 1987 Artif. Intell.) was created for GENERAL intelligent behavior: all goal-directed behavior as problem-space search with a serial operator bottleneck over parallel rule firings. ACT-R optimizes for fit-to-human; Soar optimizes for breadth of agent function. **Neither was created to be a scalable software platform** — a root cause of later failure.
+
+**Reactions:** connectionism/PDP (Rumelhart/McClelland 1986) attacked brittle symbols; hybrid architectures (CLARION, ACT-R's own subsymbolic layer, Sigma) are the synthesis: symbols for structure, numbers for grading/learning. Embodied/situated critiques (Brooks subsumption 1991; Varela et al. 1991) spawned EPIC, Psi/MicroPsi, behavior nets in LIDA. Cognitive modelling vs general AI remains the split: modelling demands parameter identifiability and human fit; engineering demands throughput, debuggability, maintenance. Rune is the second; borrow equations only where they solve engineering functions.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/goal_impasse_control.md

@@ -0,0 +1,4 @@
+# Goals / impasses / executive control
+
+(Consolidated with working-memory findings above for the durable record.) Ownership-boundary question throughout: do NOT put executive-control mechanisms into Memory merely because a cognitive architecture does. Rune's task authority + event-driven continuation + recovery supervisor already cover interruption/resumption; Soar's typed-impasse lesson (distinguish retrieval failure vs tool failure vs authority block) is the transferable atom.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/lida_global_workspace.md

@@ -0,0 +1,6 @@
+# LIDA / Global Workspace
+
+**Separate three things:** (1) **Baars GWT** (1988 book; 1997 theater metaphor): parallel unconscious specialists compete; winner enters global workspace; broadcast makes it available system-wide. Functionalist theory of conscious access, NOT an implementation. (2) **Dehaene global neuronal workspace:** prefrontal-parietal ignition, ~200–300ms signatures, masking paradigms — neuroscience, contested (2023 adversarial collaboration vs IIT unresolved; masking-method critiques Meyen et al. 2022). Do NOT cite neural ignition as proof of a software broadcast. (3) **LIDA** (Franklin et al., IDA for Navy detailers → LIDA with learning): codelets → workspace situational model → attention-codelet coalitions → competition → winning coalition broadcast → learning-from-broadcast + action selection, iterating at claimed ~10 Hz cognitive cycles.
+
+**Computational function of broadcast:** essentially **publish/subscribe with a single winning message + side-effectful learning hook**. "Broadcast causes learning" is stipulated, not derived — plausible as a synchronization point but unjustified as a necessity; it creates **unwanted coupling** (every module must handle every broadcast) and a bottleneck. For Rune: event bus + explicit subscribers is the sound kernel; global broadcast-to-all is an anti-pattern at scale. Strict ~10 Hz cycles make no sense for an asynchronous agent with bursty LLM/tool latencies; LIDA timing is biological imitation, not latency control. Borrow: competition among coalitions (retrieval candidates) before commitment; reject: mandatory cycle and learn-on-every-broadcast.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/modern_agent_relevance.md

@@ -0,0 +1,4 @@
+# Modern agent relevance
+
+Genuine convergence: retrieval scoring ≈ base-level + spreading; prompt context ≈ working-memory buffers; skill libraries ≈ production compilation; importance budgets ≈ ECAN; arbiters/routers ≈ operator preferences; episodic replay ≈ Soar EPMEM. Superficial naming: any "global workspace" or "consciousness" label on a message bus; any "chunking" meaning text-splitting (unrelated to Soar chunking); any "activation" meaning embedding magnitude. Test: does the mechanism implement the equation and the failure guard, or just the word?
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/opencog_hyperon.md

@@ -0,0 +1,6 @@
+# OpenCog / Hyperon (ECAN investigated seriously)
+
+Classic OpenCog (Goertzel, 2008 NCE open-sourcing): AtomSpace (hypergraph store), PLN (uncertain inference), MOSES (program evolution), pattern miner, OpenPsi, link-grammar NLP. **ECAN (Economic Attention Networks):** atoms carry Short-Term/Long-Term Importance (STI/LTI); rent collection, wages, spreading via Hebbian-like links under a budget — an explicit **attention economy** for inference control. This is the most transferable idea to Warm Neurons: budget-constrained importance with decay/rent, spreading gated by funds, forgetting as bankruptcy. PLN/MOSES: failed to scale as general reasoners; maintenance burden high; Hyperon/MeTTa is the reboot (in progress, immature).
+
+**Why not dominant:** (1) over-ambitious AGI scope before a killer app; (2) hypergraph + custom language lock-in vs SQL/vector ecosystems; (3) inference control never tamed (combinatorial explosion ECAN only partially contains); (4) funding discontinuities (MIRI→Hong Kong/Hanson/SingularityNET crypto turn damaged credibility); (5) LLM wave obsoleted its NLP stack. Verdict: borrow ECAN economics; do not adopt AtomSpace/PLN as substrate.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/other_architectures.md

@@ -0,0 +1,6 @@
+# Other architectures (discovery pass)
+
+**Include briefly:** EPIC (Meyer & Kieras — perceptual-motor timing; buffer-timing precedent); ICARUS (Langley — hierarchical skills, concept learning; procedural-promotion lead); SAL (ACT-R+Leabra synthesis; seam-design precedent); Nengo/SPA (Eliasmith — spiking semantic pointers, Spaun 2.5M neurons; bounds neural-grounding claims); Leabra/Emergent (O'Reilly — biologically plausible learning; implicit-level candidate only); MicroPsi/Psi (Bach/Dörner — drives+emotion modulation; motivational gap); 4CAPS (Just & Varma — capacity-constrained cortical centers; bounded-resource precedent); Blackboard (Hearsay-II; GWT's acknowledged ancestor — proves broadcast is old); BDI/PRS (Rao/Georgeff — beliefs-desires-intentions; ownership/intention separation); modern GWT-inspired agent frameworks (Shanahan 2006; recent LLM "global workspace" papers): **naming-convergence warnings, not evidence.**
+
+**Exclude from deep treatment** (record reason, move on): Copycat, DUAL, CHREST, FORR, HTM — narrow or dormant for ledger purposes.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/procedural_learning.md

@@ -0,0 +1,4 @@
+# Procedural learning compared
+
+Common principle: **promote only resolved, reused, rewarded traces**; demote/delete on disuse or negative utility. Rule explosion is the universal failure when this gate is lax. ACT-R compilation (repeated sequence → production), Soar chunking (impasse resolution → rule), CLARION RER (implicit regularity → explicit rule), RL utility (reward → preference). For later #382: record impasse-vs-repetition-vs-verification trigger comparison as cross-domain lead; do NOT settle the trigger question here.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/scaling_and_failure.md

@@ -0,0 +1,4 @@
+# Scaling / failure history (mandatory)
+
+Why ACT-R/Soar aren't the LLM-agent substrate — deeper than "LLMs are newer": rule explosion + utility problem; knowledge-engineering burden (hand-authored chunks/productions); brittle symbols vs open-ended text/tools; parameter-tuning fragility; architecture lock-in (Lisp/C++, custom languages vs Python/SQL/vector ecosystems); hard debugging (why did this production fire?); no moat once LLM + RAG + tools covered 80% with 20% effort; maintenance concentrated in single labs. LLM agents rediscover ideas because the problems are real, but they win on leverage, not theory purity.
+

research/memory-atlas-r1/C-cognitive-architectures/02_outward/sigma.md

@@ -0,0 +1,4 @@
+# Sigma
+
+Rosenbloom's claim: **factor graphs + message passing unify symbols, probabilities, neural vectors** (Sigma/I/ITSEC papers; Rosenbloom 2025 ACS evaluation discussion). Memory, inference, learning, control all as graph inference. Status: elegant, research prototype, no production deployment, scaling unproven beyond demos. Criticism: generality via graphical models inherits inference intractability; unification is representational, not computational savings. Transfer without framework: yes — one idea: treat retrieval scoring as **factor combination** (prior × context × trust) with explicit normalization, rather than adopting Sigma wholesale.
+