chore(release): auto-bump version to 0.88.3 — earned by #412 (fix(scaffolding): T22 — connect the MiMo edge + apply the meaning gate on the na)

Promotion record: http://192.168.1.156:3000/conductor/rune/pulls/412
Merge pull request 'fix(scaffolding): T22 — connect the MiMo edge + apply the meaning gate on the native path' (#412 ) from t22-scaffolding-default-path into master
2026-09-23 18:16:42 +01:00 · 2026-09-23 18:16:35 +01:00 · 2026-09-23 18:10:07 +01:00 · 2026-09-23 18:09:26 +01:00 · 2026-09-23 18:09:26 +01:00 · 2026-09-20 11:17:13 +01:00
29 changed files with 1388 additions and 313 deletions
@@ -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)
@@ -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
@@ -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
@@ -11,7 +11,7 @@ jobs:
  # P0/P1/P2/P3. An issue that lands without one gets 'unprioritized' +
  # a demand comment — filing is not complete until prioritized.
  priority-gate:
-    if: github.event_name == 'issues' && github.event.action != 'labeled'
+    if: github.event_name == 'issues' && github.event.action != 'labeled' && github.event.issue.state == 'open'
    runs-on: rune-infra-pi
    steps:
      - name: Enforce priority label
@@ -50,6 +50,20 @@ jobs:
        uses: actions/github-script@v7
        with:
          script: |
+            // CLOSED-ISSUE GUARD (#407): labels are filing-time metadata.
+            // A closed issue's lifecycle has ended; re-running label
+            // inference on it re-adds stale type labels (bug = currently
+            // incorrect behavior — a closed fixed issue must not carry
+            // it) and makes any human label cleanup self-defeating,
+            // because every PUT fires a 'labeled' event that re-triggers
+            // this job. Post-close label curation belongs to humans and
+            // the conductor, not this workflow.
+            const issueState = context.payload.issue?.state;
+            if (issueState === 'closed') {
+              console.log(`Issue #${context.payload.issue?.number} is closed — auto-label skips (labels are curated post-close).`);
+              return;
+            }
+            const action = context.payload.action;
            const title = context.payload.issue?.title || context.payload.pull_request?.title || '';
            const body = context.payload.issue?.body || context.payload.pull_request?.body || '';
            const text = (title + ' ' + body).toLowerCase();
@@ -58,9 +72,43 @@ 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 if (action === 'opened') {
+              // KEYWORD FALLBACK (#407): pre-template issues only, and
+              // ONLY at filing time. Re-running keyword guesses on every
+              // edit/label event overrides human curation of spine-less
+              // issues (documented rule: keyword heuristics are the
+              // pre-template fallback, not a standing authority).
+              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 +140,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,
@@ -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.
@@ -1,6 +1,6 @@
 # Rune

-**Current release: v0.86.0**
+**Current release: v0.88.3**

 **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.**

@@ -0,0 +1,124 @@
+import { execFile } from "node:child_process"
+import { existsSync, appendFileSync } from "node:fs"
+
+// builder-bridge — Rune Core preflight for the MiMo builder (handoff
+// 2026-09-10 §3–§7, Option C bridge tranche). For each user turn, the hook
+// extracts the user's message from the outgoing LLM request, runs the Rune
+// Core builder-bridge preflight (deterministic: route classification +
+// memory selection + active-Scaffolding projection, ZERO model calls), and
+// appends a compact capsule to the final user message. Same Rune Core the
+// TUI/operator path uses — this file is a thin adapter with no cognition.
+//
+// CANONICAL SOURCE: config/mimo-hooks/builder-bridge.ts
+// Installed to ~/.mimocode/hooks/builder-bridge.ts by
+// `scripts/install_mimo_hook.py` (hash-verified, drift-detecting — the same
+// contract as event-wait-guard.ts). T22: this file was previously
+// UNVERSIONED and hardcoded an ephemeral interpreter path (/tmp/ci-venv),
+// which silently killed the whole edge; both defects are repaired here.
+//
+// Overhead contract (§7/§8): capsule ≤ ~300 tokens; a repeat/empty task
+// costs ~0ms (TTL cache); a fresh task ~150ms (bounded retrieval). The hook
+// degrades silently to no-injection on any failure — it must never block
+// the builder.
+//
+// Injection policy: only append when the capsule is non-empty. A plain
+// "hello" gets nothing (§5: if nothing relevant exists, inject nothing).
+
+const BRIDGE = "/mnt/workdrive/issue161-harness/src/rune/builder_bridge_cli.py"
+const MARKER_PREFIX = "/tmp/rune-bridge-"
+
+// Interpreter resolution (T22 repair): the previous hardcoded
+// "/tmp/ci-venv/bin/python" is an EPHEMERAL path that no longer exists, so
+// every bridge call failed and the hook silently degraded — the MiMo edge
+// received no Rune Core preflight at all (zero fire-log lines). Resolve
+// against durable candidates, first existing wins; env override wins over
+// all of them. If nothing exists the hook degrades as before.
+const PY_CANDIDATES = [
+  process.env.MIMO_BRIDGE_PY,
+  "/mnt/workdrive/issue161-harness/.test-venv/bin/python",
+  "/home/nick/.venvs/memory/bin/python3",
+  "/usr/bin/python3",
+].filter((p) => typeof p === "string" && p.length > 0)
+
+function resolvePy() {
+  for (const p of PY_CANDIDATES) {
+    try {
+      if (existsSync(p)) return p
+    } catch {}
+  }
+  return null
+}
+
+// Per-process dedupe: identical task text within the cache TTL does not need
+// a second bridge call — the CLI has its own TTL cache, but skipping the
+// process spawn entirely for the same message text within 10 minutes keeps
+// repeats at ~0ms.
+const lastText = new Map() // text -> timestamp
+const TTL = 600_000
+
+function extractUserText(messages) {
+  // messages: Array<{ info: Message, parts: Part[] }> — newest last.
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]
+    if (m?.info?.role !== "user") continue
+    const texts = []
+    for (const p of m.parts ?? []) {
+      if (p?.type === "text" && typeof p.text === "string") texts.push(p.text)
+    }
+    if (texts.length) return texts.join("\n").slice(0, 4000)
+  }
+  return ""
+}
+
+export default {
+  "experimental.chat.messages.transform": async (input, output) => {
+    try {
+      if (!Array.isArray(output.messages) || output.messages.length === 0) return
+      const userText = extractUserText(output.messages)
+      if (!userText || userText.length < 12) return // trivial/noise guard
+      // Harness-internal steps (checkpoint writer, compaction, system
+      // reminders) are not builder tasks — no capsule (measured: the fire
+      // log showed checkpoint-writer steps receiving capsules 2026-09-10).
+      if (/^(<system-reminder>|EXTRACTION REQUIRED)/.test(userText.trim())) return
+      const now = Date.now()
+      const prev = lastText.get(userText)
+      if (prev !== undefined && now - prev < TTL) return // dedupe repeats
+      lastText.set(userText, now)
+      if (lastText.size > 64) {
+        // evict oldest
+        let oldestKey = null, oldestVal = Infinity
+        for (const [k, v] of lastText) if (v < oldestVal) { oldestVal = v; oldestKey = k }
+        if (oldestKey) lastText.delete(oldestKey)
+      }
+
+      const py = resolvePy()
+      if (!py) return // no durable interpreter — degrade (never block)
+
+      const capsule = await new Promise((resolve) => {
+        execFile(py, [BRIDGE, userText], { timeout: 15_000 }, (err, stdout) => {
+          resolve(err ? "" : (stdout?.toString() ?? ""))
+        })
+      })
+      if (!capsule.trim()) return
+
+      // Durable fire-trace: one line per ACTUAL injection into an outgoing
+      // model request (handoff §1 proof requirement). Not a canary — this is
+      // standing observability for the bridge's consumer edge.
+      try {
+        appendFileSync("/tmp/rune-bridge-fire.log",
+          JSON.stringify({ ts: new Date().toISOString(), task: userText.slice(0, 80), capsule_tokens: Math.round(capsule.length / 4), py }) + "\n")
+      } catch {}
+
+      // Append the capsule to the LAST user message (the one being answered).
+      const last = output.messages[output.messages.length - 1]
+      if (last?.parts && Array.isArray(last.parts)) {
+        last.parts.push({
+          type: "text",
+          text: "\n\n<rune-preflight>\n" + capsule.trim() + "\n</rune-preflight>\n(Injected by Rune Core builder bridge — deterministic preflight, zero model calls. Relevant state above; ignore if not applicable to this task.)",
+        })
+      }
+    } catch {
+      // never block the builder on bridge failure
+    }
+  },
+}
@@ -11,24 +11,22 @@
  "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-19",
+   "next_action": "none \u2014 defect no longer reproduces: zero MessageAbortedError in current logs (incl. active worker), six most recent session checkpoints full documents (111-396 lines); verified by present-absence 2026-09-19"
  },
  {
   "number": 316,
@@ -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,
@@ -1151,6 +1149,6 @@
   "next_action": ""
  }
 ],
- "last_reconciled": "2026-09-12",
- "reconciled_by": "PL1 held-out era reconciliation (fresh session 2026-09-12)"
-}
+ "last_reconciled": "2026-09-19",
+ "reconciled_by": "fresh-session tranche 2026-09-19: template retrofit (spine+plain-English on all open issues), closures #158/#162 (SUPERSEDED) and #324 (FIXED_VERIFIED), research labels applied to #163/#164/#165/#166/#182/#316, stale bug labels removed from #163-#166; 2026-09-19 absorption pass: parked children absorbed into parents (#175<-#176..#179; #181<-#182,#183,#164..#166) per one-open-note-per-idea standard"
+}
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "rune"
-version = "0.86.0"
+version = "0.88.3"
 description = "Rune — a stateful coding assistant with persistent memory, orchestration, and TUI"
 requires-python = ">=3.10"

@@ -1,5 +1,5 @@
 # This file was autogenerated by uv via the following command:
-#    uv pip compile pyproject.toml -o /tmp/req_new.txt --extra dev --extra memory --python-version 3.11
+#    uv pip compile pyproject.toml -o requirements-ci.txt --extra dev --extra memory --python-version 3.11
 aiohappyeyeballs==2.7.1
    # via aiohttp
 aiohttp==3.14.3
@@ -20,7 +20,7 @@ chardet==7.6.0
    # via diff-cover
 coverage==7.16.1
    # via rune (pyproject.toml)
-diff-cover==10.5.1
+diff-cover==10.6.0
    # via rune (pyproject.toml)
 frozenlist==1.8.0
    # via
@@ -56,7 +56,7 @@ mdit-py-plugins==0.6.1
    # via textual
 mdurl==0.1.2
    # via markdown-it-py
-multidict==6.9.0
+multidict==6.9.1
    # via
    #   aiohttp
    #   yarl
@@ -64,7 +64,7 @@ nodeenv==1.10.0
    # via pyright
 packaging==26.3
    # via pytest
-platformdirs==4.11.11
+platformdirs==4.11.12
    # via textual
 pluggy==1.6.0
    # via
@@ -148,9 +148,18 @@ def sha_branch(sha: str) -> str:


 def sha_on_master(sha: str) -> bool:
-    out = _git("branch", "--contains", sha)
-    return any(l.strip().endswith("master") or l.strip() == "master"
-               for l in out.splitlines())
+    """SHA is an ancestor of master (local or remote-tracking refs).
+
+    M10 correction (2026-09-19): --all so a freshly fetched master
+    (refs/remotes/gitea/master) counts; local branches alone go stale
+    between fetches. derive_op_type refreshes refs before calling this.
+    """
+    out = _git("branch", "--all", "--contains", sha)
+    for l in out.splitlines():
+        s = l.strip().removeprefix("remotes/").removesuffix(" *")
+        if s == "master" or s.endswith("/master"):
+            return True
+    return False


 def open_pr_for_sha(sha: str) -> int | None:
@@ -184,6 +193,11 @@ def derive_op_type(sha: str) -> tuple[str, str]:
         were created from model-supplied defaults and cannot be trusted.
    Never trusts model input.
    """
+    # 0. M10 correction (2026-09-19): refresh remote-tracking refs before
+    #    inference. A just-merged master commit is invisible to
+    #    branch --contains until refs are fetched; stale local git state
+    #    must never outrank repo truth. Bounded by GIT_TIMEOUT, fail-open.
+    _git("fetch", "--quiet", "gitea", "+refs/heads/*:refs/remotes/gitea/*")
    for rec in _load_wait_records():
        if _rec_sha(rec) != sha:
            continue
@@ -86,9 +86,12 @@ def main() -> int:
        if live_state == "open" and rec["tracker_state"] == "closed" and rec["reconciliation_state"] in TERMINAL_STATES:
            drift.append(f"#{num}: live state open but artifact says closed/{rec['reconciliation_state']}")
        live_bug = "bug" in [l["name"] for l in li.get("labels", [])]
-        if live_bug and not rec.get("live_defect"):
+        # Same open-only exemption as the artifact-records block above: a
+        # closed issue's labels are historical record; FIXED_VERIFIED issues
+        # legitimately keep the bug label after closure.
+        if live_bug and rec.get("tracker_state") == "open" and not rec.get("live_defect"):
            drift.append(f"#{num}: live bug label present but artifact records no live defect")
-        if not live_bug and rec.get("live_defect"):
+        if not live_bug and rec.get("live_defect") and rec.get("tracker_state") == "open":
            drift.append(f"#{num}: artifact records live defect but live bug label absent")

    # Live defects in the artifact must all be OPEN in the tracker
@@ -1,43 +1,71 @@
 #!/usr/bin/env python3
-"""install_mimo_hook.py — T21.2 §21.2D: canonical MiMo hook installer.
+"""install_mimo_hook.py — T21.2 §21.2D (T22: multi-hook): canonical MiMo
+hook installer.

-Canonical source: config/mimo-hooks/event-wait-guard.ts
-Target: ~/.mimocode/hooks/event-wait-guard.ts
-Verifies hash after install. Detects drift in both directions."""
+Canonical sources: config/mimo-hooks/*.ts
+Targets:          ~/.mimocode/hooks/<same-name>.ts
+
+Every hook is hash-verified after install; drift is detected in both
+directions. T22 added builder-bridge.ts to the managed set — it was
+previously installed by hand, unversioned, which is how it silently rotted
+(hardcoded ephemeral interpreter). A hook that reaches the builder must be
+version-controlled and drift-checked like any other authority.
+
+Usage:
+    python3 scripts/install_mimo_hook.py            # sync all managed hooks
+    python3 scripts/install_mimo_hook.py --check    # verify only, install nothing
+"""
 import hashlib
 import shutil
 import sys
 from pathlib import Path

-CANONICAL = Path(__file__).resolve().parent.parent / "config" / "mimo-hooks" / "event-wait-guard.ts"
-TARGET = Path.home() / ".mimocode" / "hooks" / "event-wait-guard.ts"
+REPO = Path(__file__).resolve().parent.parent
+CANONICAL_DIR = REPO / "config" / "mimo-hooks"
+TARGET_DIR = Path.home() / ".mimocode" / "hooks"
+
+# The managed set. Adding a file here is what makes a hook version-controlled.
+MANAGED = ["event-wait-guard.ts", "builder-bridge.ts"]


 def sha256(p: Path) -> str:
    return hashlib.sha256(p.read_bytes()).hexdigest()


-def main() -> int:
-    if not CANONICAL.is_file():
-        print(f"canonical source missing: {CANONICAL}")
-        return 1
-    canon_hash = sha256(CANONICAL)
-    if TARGET.is_file():
-        target_hash = sha256(TARGET)
-        if target_hash == canon_hash:
-            print(f"in-sync: {target_hash[:12]}")
-            return 0
-        print(f"DRIFT: canonical={canon_hash[:12]} installed={target_hash[:12]}")
+def sync_one(name: str, check_only: bool) -> bool:
+    canonical = CANONICAL_DIR / name
+    target = TARGET_DIR / name
+    if not canonical.is_file():
+        print(f"canonical source missing: {canonical}")
+        return False
+    canon_hash = sha256(canonical)
+    if target.is_file() and sha256(target) == canon_hash:
+        print(f"in-sync: {name} {canon_hash[:12]}")
+        return True
+    if check_only:
+        state = "DRIFT" if target.is_file() else "MISSING"
+        inst = sha256(target)[:12] if target.is_file() else "-"
+        print(f"{state}: {name} canonical={canon_hash[:12]} installed={inst}")
+        return False
+    if target.is_file():
+        print(f"DRIFT: {name} canonical={canon_hash[:12]} installed={sha256(target)[:12]}")
    else:
-        print(f"hook missing at {TARGET}")
-    TARGET.parent.mkdir(parents=True, exist_ok=True)
-    shutil.copy2(CANONICAL, TARGET)
-    installed_hash = sha256(TARGET)
-    if installed_hash != canon_hash:
-        print(f"INSTALL FAILED: hash mismatch after copy")
-        return 1
-    print(f"installed: {installed_hash[:12]}")
-    return 0
+        print(f"hook missing at {target}")
+    TARGET_DIR.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(canonical, target)
+    if sha256(target) != canon_hash:
+        print(f"INSTALL FAILED: {name} hash mismatch after copy")
+        return False
+    print(f"installed: {name} {canon_hash[:12]}")
+    return True
+
+
+def main() -> int:
+    check_only = "--check" in sys.argv
+    ok = True
+    for name in MANAGED:
+        ok = sync_one(name, check_only) and ok
+    return 0 if ok else 1


 if __name__ == "__main__":
@@ -33,7 +33,7 @@ SCRIPTS_DIR = os.path.expanduser("~/.config/opencode/scripts")
 SHARED_DIR = os.path.expanduser("~/.config/opencode/shared")
 CUSTODIAN_STATE_FILE = os.path.expanduser("~/.config/opencode/memory/custodian_state.json")

-GITEA_URL = os.environ.get("GITEA_URL", "https://gitea.thingscouldgetdicey.online")
+GITEA_URL = os.environ.get("GITEA_URL", "http://127.0.0.1:3000")  # gitea.internal (PC); external = https://gitea.thingscouldgetdicey.online via Pi Caddy
 GITEA_TOKEN = load_gitea_token()
 REPO = "conductor/rune"
 TUI_DIR = "/mnt/workdrive/rune"
@@ -54,6 +54,15 @@ UMBRELLA_TAGS = {
 }


+# Issue template directory — canonical copies live beside this script
+# (mirrored to .gitea/ISSUE_TEMPLATE/ for the web-UI submission path).
+ISSUE_TEMPLATE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "issue_templates")
+
+# kind -> Gitea label that MUST be present on the issue
+KIND_LABEL = {"feature": "feature", "bug": "bug", "research": "research"}
+VERSION_INTENTS = ("major", "minor", "patch", "none")
+
+
 class Custodian:
    """The Custodian agent for Gitea-based self-improvement."""

@@ -105,23 +114,90 @@ class Custodian:
        except Exception as e:
            return {"error": str(e)[:200]}

-    def create_issue(self, title: str, body: str, labels: List[str] = None) -> dict:
-        """Create a Gitea issue with plain-language description.
+    def _ensure_label(self, name: str, description: str = "", color: str = "#6f42c1") -> bool:
+        """Make sure a label exists on the repo; return its id or None."""
+        labels = self._gitea_api("labels")
+        if isinstance(labels, list):
+            for l in labels:
+                if l["name"] == name:
+                    return l["id"]
+        data = {"name": name, "description": description or name, "color": color}
+        created = self._gitea_api("labels", method="POST", data=data)
+        return created.get("id") if isinstance(created, dict) else None

-        Labels should be umbrella names (memory, governance, etc).
-        They get converted to IDs automatically.
+    def _load_issue_template(self, kind: str) -> str:
+        """Load the canonical issue template for a kind, WITHOUT the web-UI
+        frontmatter (name/about/title/labels — that metadata belongs to the
+        submission form, not the issue body). Empty string if absent."""
+        path = os.path.join(ISSUE_TEMPLATE_DIR, f"{kind}.md")
+        try:
+            with open(path) as f:
+                text = f.read()
+        except FileNotFoundError:
+            return ""
+        if text.startswith("---"):
+            end = text.find("\n---", 3)
+            if end != -1:
+                text = text[end + 4:]
+        return text.lstrip("\n")
+
+    def create_issue(
+        self,
+        title: str,
+        body: str,
+        labels: List[str] = None,
+        kind: str = "feature",
+        version_intent: Optional[str] = None,
+    ) -> dict:
+        """Create a Gitea issue assembled from the canonical template.
+
+        kind: feature | bug | research — selects the template and forces the
+              matching label (the research label is auto-created if missing).
+        version_intent: major | minor | patch | none — pre-ticks the matching
+              box in the template's Version impact section. The pipeline
+              verifies the real bump at merge and flags mismatches.
+        labels: umbrella names (memory, governance, ...); converted to IDs.
+
+        The caller's body replaces the SUBMITTED_BODY marker inside the
+        template's Plain English section — plain terms first, always.
+
+        ORGANISATION STANDARD (one open note per idea, 2026-09-19): before
+        minting a standalone issue, check whether the work belongs inside an
+        existing parent. Ideas parked under a blocked/future epic are filed
+        as checklist items in the parent's "Absorbed children" section, NOT
+        as standalone issues — the board stays uncluttered and every idea
+        has exactly one home. Mint a standalone issue only when the work is
+        live, dependency-tracked, or about to start. Absorbed ideas are
+        reversible: re-mint standalone when they become live.
        """
-        # Convert label names to IDs
+        # 1. assemble body from template (graceful: unformatted if template missing)
+        template = self._load_issue_template(kind)
+        text = body.strip()
+        if template and "<!-- SUBMITTED_BODY -->" in template:
+            text = template.replace("<!-- SUBMITTED_BODY -->", text, 1)
+        if version_intent in VERSION_INTENTS:
+            text = text.replace(f"- [ ] {version_intent} ", f"- [x] {version_intent} ", 1)
+
+        # 2. labels: umbrella names + mandatory kind label
+        labels = list(labels or [])
+        kind_label = KIND_LABEL.get(kind)
+        if kind_label and kind_label not in labels:
+            labels.append(kind_label)
+
+        all_labels = self._gitea_api("labels")
+        label_map = {l["name"]: l["id"] for l in all_labels} if isinstance(all_labels, list) else {}
        label_ids = []
-        if labels:
-            all_labels = self._gitea_api("labels")
-            if isinstance(all_labels, list):
-                label_map = {l["name"]: l["id"] for l in all_labels}
-                label_ids = [label_map[l] for l in labels if l in label_map]
+        for l in labels:
+            if l in label_map:
+                label_ids.append(label_map[l])
+            else:
+                lid = self._ensure_label(l)
+                if lid:
+                    label_ids.append(lid)

        data = {
            "title": title,
-            "body": body,
+            "body": text,
            "labels": label_ids,
        }
        result = self._gitea_api("issues", method="POST", data=data)
@@ -0,0 +1,91 @@
+---
+name: Bug Fix
+about: Demonstrate currently incorrect behaviour — plain English first, proof required
+title: "[BUG] "
+labels: bug
+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 -->
+
+
+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). -->
+
+**WHAT (bug):**
+**WHERE:**
+**EVIDENCE:**
+
+## Pipeline requirements
+<!-- Every fix must clear these before the issue closes. -->
+- [ ] TDD: regression test written first, red → green
+- [ ] `ruff check` and `ruff format --check` clean
+- [ ] Spec-compliance review gate: PASS
+- [ ] Code-quality review gate: Approved
+- [ ] Full orchestration suite regression green (suite total)
+- [ ] Canary passes (name)
+- [ ] Closed with a properly formatted closing comment + commit 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)
+- [ ] **Trigger** — what event activates it
+- [ ] **Read/write authority** — which canonical state it reads/changes
+- [ ] **Provenance** — derived state traceable to evidence
+- [ ] **Verification** — how we know the change helped
+- [ ] **Failure visibility** — how failure surfaces
+- [ ] **Reversibility** — bad learned state can be superseded/replayed/rolled back
+- [ ] **Dormant cost** — what it costs when irrelevant
+- [ ] **Benchmark + ablation** — what measurable behaviour improves; what happens when disabled
+- [ ] **No duplicate authority** — why extend vs create
+
+Hard invariants: derived cognition preserves evidentiary ancestry · epistemic confidence ≠ attentional utility ≠ current applicability · retrieval never increases utility · self-model-induced behaviour is not independent evidence · historical truth survives present-state change · raw evidence is never destroyed by promotion.
+
+## Related umbrella
+- [ ] Memory
+- [ ] Governance
+- [ ] Identity
+- [ ] Growth
+- [ ] Perception
+- [ ] Infrastructure
+- [ ] Orchestration
+
+## Priority (REQUIRED — the priority gate)
+<!-- Pick exactly one. An issue without a priority is not filed. -->
+- [ ] **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
@@ -0,0 +1,97 @@
+---
+name: Feature Request
+about: New feature or improvement — plain English first, verifiable close conditions, version intent
+title: "[FEATURE] "
+labels: feature
+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. 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 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.
+WHY — design-spec reference (S#) or reason.
+FILES — affected components.
+ACCEPTANCE — frozen-test file + test count + canary name.
+DEPENDENCIES — parent epic + preceding stage/plan refs. -->
+
+**WHAT:**
+**WHY:**
+**FILES:**
+**ACCEPTANCE:**
+**DEPENDENCIES:**
+
+## Pipeline requirements
+<!-- Every stage must clear these before the issue closes. -->
+- [ ] TDD: frozen tests written first, red → green (N passed)
+- [ ] `ruff check` and `ruff format --check` clean
+- [ ] Spec-compliance review gate: PASS
+- [ ] Code-quality review gate: Approved
+- [ ] Full orchestration suite regression green (suite total)
+- [ ] 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)
+- [ ] **Trigger** — what event activates it
+- [ ] **Read/write authority** — which canonical state it reads/changes
+- [ ] **Provenance** — derived state traceable to evidence
+- [ ] **Verification** — how we know the change helped
+- [ ] **Failure visibility** — how failure surfaces
+- [ ] **Reversibility** — bad learned state can be superseded/replayed/rolled back
+- [ ] **Dormant cost** — what it costs when irrelevant
+- [ ] **Benchmark + ablation** — what measurable behaviour improves; what happens when disabled
+- [ ] **No duplicate authority** — why extend vs create
+
+Hard invariants: derived cognition preserves evidentiary ancestry · epistemic confidence ≠ attentional utility ≠ current applicability · retrieval never increases utility · self-model-induced behaviour is not independent evidence · historical truth survives present-state change · 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** — 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
@@ -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
@@ -6,7 +6,7 @@ This is the main entry point for the Rune program.
 import json
 from pathlib import Path

-__version__ = "0.86.0"
+__version__ = "0.88.3"

 # One build identity (handoff 2026-09-10 §4): the semantic version above is
 # the repo-level truth (auto-bumped at merge); the DEPLOYED revision (exact
@@ -64,6 +64,7 @@ class BuilderCapsule:
    memory_lines: list = field(default_factory=list)
    lesson_lines: list = field(default_factory=list)
    constraints: list = field(default_factory=list)
+    construction_lines: list = field(default_factory=list)
    generated_at: str = ""
    core_version: str = "rune-core/operator-path"

@@ -75,6 +76,7 @@ class BuilderCapsule:
            "memory_lines": self.memory_lines[:MAX_MEMORY_LINES],
            "lesson_lines": self.lesson_lines[:MAX_LESSON_LINES],
            "constraints": self.constraints,
+            "construction_lines": self.construction_lines,
            "generated_at": self.generated_at,
            "core_version": self.core_version,
        }
@@ -87,10 +89,14 @@ class BuilderCapsule:
            and not d["lesson_lines"]
            and not d["unknowns"]
            and not d["constraints"]
+            and not d["construction_lines"]
            and d["task_route"] in ("LOCAL_FIX", "STANDARD_CHANGE")
        ):
            return ""  # nothing useful — inject nothing (handoff §5)
        lines = [f"### Rune Core preflight ({d['task_route']})"]
+        if d["construction_lines"]:
+            lines.append("**Active Scaffolding construction (read-only projection):**")
+            lines += [f"- {c}" for c in d["construction_lines"]]
        if d["memory_lines"]:
            lines.append("**Relevant Rune memory:**")
            lines += [f"- {m}" for m in d["memory_lines"]]
@@ -107,6 +113,56 @@ class BuilderCapsule:
        return "\n".join(lines)


+def _construction_store() -> str:
+    """The SAME construction store the operator path uses (env override
+    honoured; default derives from the repo root, never a bare relative
+    path). Kept identical to rune_operator._construction_store."""
+    import os as _os
+    env = _os.environ.get("RUNE_CONSTRUCTION_STORE")
+    if env:
+        return env
+    from pathlib import Path as _P
+    return str(_P(__file__).resolve().parent.parent.parent / "store" / "scaffold")
+
+
+def _active_construction_lines() -> list:
+    """Read-only projection of the ACTIVE Scaffolding construction into
+    builder-consumable lines. This is the MiMo edge of the shared
+    Construction Context (§15) — it surfaces canonical state; it is NOT a
+    second construction authority and never mutates. Degrade-safe: any
+    failure returns [] (the bridge must never block the builder)."""
+    try:
+        from .construction_interface import ConstructionInterface
+        env = ConstructionInterface(builder="mimo-bridge",
+                                    project_store=_construction_store(),
+                                    project_id="issue161-harness"
+                                    ).construction_context()
+        st = env.get("state") or {}
+        if not st.get("active"):
+            return []
+        out = [f"contract {st.get('contract_id')} · phase {st.get('phase')}"
+               f" · status {st.get('status')}"
+               f" · mode {st.get('construction_mode')}"]
+        if st.get("project"):
+            out.append(f"project: {st['project']}")
+        if st.get("need"):
+            out.append(f"need: {st['need']}")
+        scope = st.get("scope") or []
+        if scope:
+            out.append("scope: " + ", ".join(str(x) for x in scope[:8]))
+        obl = st.get("obligations") or []
+        if obl:
+            out.append(f"outstanding obligations: {len(obl)}")
+            for o in obl[:3]:
+                txt = o.get("obligation") or o.get("kind") or o
+                out.append(f"  - {str(txt)[:120]}")
+        if st.get("next_action"):
+            out.append(f"next action: {st['next_action']}")
+        return out
+    except Exception:  # noqa: BLE001 — projection only; never block the builder
+        return []
+
+
 def _default_selector():
    """The SAME MemorySelector the operator path uses (lazy, degrade-safe)."""
    try:
@@ -166,6 +222,11 @@ def preflight(task_text: str, memory_selector=None) -> BuilderCapsule:
    # design (handoff §9: raw SEED records are outcome telemetry, not lessons).
    capsule.lesson_lines = _validated_lessons_for(task_text or "")

+    # Active Scaffolding construction state (read-only projection of the
+    # shared Construction Context). Empty when no contract is active, so
+    # the inject-nothing policy is preserved for ordinary turns.
+    capsule.construction_lines = _active_construction_lines()
+
    return capsule


@@ -231,7 +231,7 @@ def main() -> int:
    )
    check(
        "Rune minor version advertises provisioning and restore verification",
-        '__version__ = "0.86.0"' in rune_version,
+        '__version__ = "0.88.3"' in rune_version,
        failures,
    )
    # #169 policy update: auto-bump on merge is sanctioned (Nick directive:
@@ -181,9 +181,16 @@ class ConstructionInterface:
        if contract_id:
            target = self.scaffold.contract(doc, contract_id)
        else:
-            # most recent non-closed contract = the active construction
+            # Most recent ACTIVE contract = status open AND phase non-terminal.
+            # T22 repair: a contract whose phase is terminal (abandoned/closed
+            # — see scaffold.TERMINAL_PHASES) is NOT active construction, even
+            # if its status field was left "open". Without the phase test the
+            # projection reported stale abandoned contracts as the active
+            # construction (8 such records observed in the live store).
+            from .scaffold import TERMINAL_PHASES
            open_contracts = [e for e in contracts
-                              if e.get("status") == "open"]
+                              if e.get("status") == "open"
+                              and e.get("phase") not in TERMINAL_PHASES]
            target = (sorted(open_contracts,
                             key=lambda e: e.get("observed_at", ""))[-1]
                      if open_contracts else None)
@@ -805,13 +805,22 @@ class RuneOperator:
        except Exception:  # noqa: S110 — notes are best-effort by design
            pass

-    def _construction_activation(self, description: str, task_id: str) -> None:
+    def _construction_activation(self, description: str, task_id: str,
+                                 channel: str = OPERATOR_CHANNEL) -> None:
        """SCAFFOLD-TRANCHE-0011/0012 §11: contextual construction
        classification + activation on the NORMAL input path. Deterministic;
        the mode lands in the durable scaffold store where the shared
        Construction Context (and the future TUI) reads it. Delegates all
        lifecycle decisions to construction_mode/construction_activation —
-        NO duplicate intelligence here."""
+        NO duplicate intelligence here.
+
+        §17J criterion 1 (T22 wiring): the canonical intent layer
+        (construction_intent) resolves MEANING before the ONE
+        classifier decides mode — the boundary the intent module
+        documents ("the intent layer resolves MEANING; classify_mode
+        decides mode"). A turn the intent layer resolves as
+        DISCUSSION is not a construction demand, so no construction
+        state is recorded for it."""
        from .construction_mode import classify_mode, _STANDALONE_WORDS
        from .construction_activation import activate
        # §15J case F: manual override feeds the SAME decision path — a
@@ -849,6 +858,56 @@ class RuneOperator:
        from .scaffold import Scaffold
        s = Scaffold(self._construction_store(), "issue161-harness")
        doc = s.load()
+        # §17J criterion 1: meaning gate BEFORE the classifier.
+        # Context = the operator's own canonical conversation window
+        # (no new state store); the current message is excluded so it
+        # is not double-recorded as its own referent.
+        try:
+            from .construction_intent import (
+                ConversationContext, resolve_construction_intent)
+            ctx = ConversationContext()
+            for _m in self.conversation_window(channel, n=8):
+                _txt = str(_m.get("content", ""))
+                if _txt and _txt != description:
+                    ctx.record_turn(str(_m.get("role", "user")), _txt)
+            _intent = resolve_construction_intent(description, ctx)
+        except Exception as exc:  # noqa: BLE001 — intent layer
+            # unavailable: PRESERVE the pre-existing behaviour exactly
+            # (classify+activate) rather than silently changing
+            # governance in an unproven direction. The note is appended to
+            # THIS doc (not via _construction_note, which does its own
+            # load/save) because the normal path saves `doc` afterwards —
+            # a separate write would be clobbered (lost update).
+            _intent = None
+            doc.setdefault("observations", []).append({
+                "kind": "construction_note",
+                "text": (f"intent layer unavailable ({exc}); "
+                         f"classifier path unchanged")[:300],
+                "observed_at": __import__("datetime").datetime.utcnow()
+                .strftime("%Y-%m-%dT%H:%M:%SZ")})
+        # An explicit user override is USER AUTHORITY and outranks the
+        # meaning gate (§15J case F: the override is already carried with
+        # user provenance into the SAME classify_mode call).
+        if (override is None and _intent is not None
+                and _intent.action_intent == "DISCUSSION"):
+            # The intent layer resolved this turn as DISCUSSION: it is not a
+            # construction demand, so no construction state is created. The
+            # record keeps the SAME canonical observation kind/shape every
+            # other input produces (mode vocabulary unchanged — DISCUSSION
+            # maps to NOT_CONSTRUCTION, "no construction state"), with the
+            # intent evidence retained so the verdict is auditable.
+            doc.setdefault("observations", []).append({
+                "kind": "construction_activated",
+                "task": task_id,
+                "mode": "NOT_CONSTRUCTION",
+                "activated": False,
+                "lifecycle": "",
+                "classification_evidence": _intent.classification_evidence[:3],
+                "intent_layer": "DISCUSSION",
+                "observed_at": __import__("datetime").datetime.utcnow()
+                .strftime("%Y-%m-%dT%H:%M:%SZ")})
+            s.save(doc)
+            return
        rec = activate(mode_decision, need=type("N", (), {
            "objective": description,
            "project": "rune",
@@ -929,7 +988,8 @@ class RuneOperator:
        # failure NEVER blocks the ordinary task path (same lifecycle
        # guarantee as the route above).
        try:
-            self._construction_activation(description, state_task.task_id)
+            self._construction_activation(description, state_task.task_id,
+                                          channel=channel)
        except Exception as exc:  # noqa: BLE001 — construction must not break tasks
            try:
                self._task_state.transition(
@@ -8,7 +8,7 @@ mode system, subject header, shared memory and identity.

 This is not an interface. This is how I see, speak, and interact with the world.

-Version: v0.86.0
+Version: v0.88.3
 Features: 41 (24 original + 17 new native commands)

 Usage:
@@ -1885,7 +1885,7 @@ class RuneApp(App):
        # Show version info
        self.chat_channel.add_message(
            "system",
-            f"[dim]Rune v0.86.0 | Textual TUI | {len(loaded)} native modules[/dim]",
+            f"[dim]Rune v0.88.3 | Textual TUI | {len(loaded)} native modules[/dim]",
        )

        # Auto-show night mode suggestion if evening/night hours
@@ -57,7 +57,7 @@ from rune.structural_store import (  # shared generic core — no Rune constants
    task_entities,
 )

-__all__ = ["Scaffold", "PHASES", "LEGAL_TRANSITIONS", "REPO_PLACEMENTS", "REPO_SECRET_FIELDS"]
+__all__ = ["Scaffold", "PHASES", "LEGAL_TRANSITIONS", "TERMINAL_PHASES", "REPO_PLACEMENTS", "REPO_SECRET_FIELDS"]

 # ── constants ─────────────────────────────────────────────────────────────

@@ -73,6 +73,10 @@ LEGAL_TRANSITIONS = {
    "failed": {"building", "abandoned"},  # retry path
    "abandoned": set(),
 }
+# Terminal phases are DERIVED from the canonical transition table: a
+# phase with no legal successor ends the contract. One authority —
+# consumers must not re-declare their own terminal list.
+TERMINAL_PHASES = frozenset(p for p, nxt in LEGAL_TRANSITIONS.items() if not nxt)
 STATUSES = {"open", "closed", "failed", "abandoned"}
 REPO_PLACEMENTS = {"RUNE_REPO", "EXISTING_PROJECT_REPO", "NEW_MANAGED_REPO"}
 REPO_SECRET_FIELDS = {"token", "api_key", "password", "secret", "auth_header", "credential", "api_token"}
@@ -23,6 +23,83 @@ from rune.builder_bridge import (  # noqa: E402
 )


+class ConstructionProjectionActive(unittest.TestCase):
+    """T22: with a LIVE contract the projection surfaces canonical state
+    (contract/phase/scope/obligations/next-action) and renders it in the
+    capsule markdown; the read-only projection never mutates the store."""
+
+    def _active_store(self, td):
+        from pathlib import Path
+        from rune.scaffold import Scaffold
+        store = Path(td) / "scaffold"
+        sc = Scaffold(store, "fixture-proj")
+        sc.init(purpose="fixture")
+        doc = sc.load()
+        sc.new_contract(doc, contract_id="c-t22", need="add the retry backoff",
+                        origin="user", scope=["src/rune/retry.py"],
+                        requirement="prove the projection")
+        sc.save(doc)
+        return str(store)
+
+    def test_active_contract_projects_and_renders(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            store = self._active_store(td)
+            old = os.environ.get("RUNE_CONSTRUCTION_STORE")
+            os.environ["RUNE_CONSTRUCTION_STORE"] = store
+            try:
+                lines = builder_bridge._active_construction_lines()
+                self.assertTrue(lines, "an open non-terminal contract must project")
+                self.assertIn("c-t22", lines[0])
+                self.assertTrue(any("scope" in ln for ln in lines), lines)
+                cap = builder_bridge.preflight("add the retry backoff")
+                self.assertTrue(cap.construction_lines)
+                md = cap.to_markdown()
+                self.assertIn("Active Scaffolding construction", md)
+                # read-only: the store is unchanged by projection
+                before = (Path(store) / "current.json").read_text()
+                builder_bridge._active_construction_lines()
+                self.assertEqual(before, (Path(store) / "current.json").read_text())
+            finally:
+                if old is None:
+                    os.environ.pop("RUNE_CONSTRUCTION_STORE", None)
+                else:
+                    os.environ["RUNE_CONSTRUCTION_STORE"] = old
+
+    def test_store_resolution_honours_env_override(self):
+        self.assertEqual(builder_bridge._construction_store(),
+                         os.environ.get("RUNE_CONSTRUCTION_STORE"))
+
+
+class ConstructionProjection(unittest.TestCase):
+    """T22: the bridge surfaces the ACTIVE Scaffolding construction (the
+    shared Construction Context) to the builder — read-only projection,
+    inject-nothing preserved when no contract is active."""
+
+    def test_no_active_contract_projects_nothing(self):
+        import tempfile
+        from pathlib import Path
+        with tempfile.TemporaryDirectory() as td:
+            old = os.environ.get("RUNE_CONSTRUCTION_STORE")
+            os.environ["RUNE_CONSTRUCTION_STORE"] = str(Path(td) / "scaffold")
+            try:
+                self.assertEqual(builder_bridge._active_construction_lines(), [])
+            finally:
+                if old is None:
+                    os.environ.pop("RUNE_CONSTRUCTION_STORE", None)
+                else:
+                    os.environ["RUNE_CONSTRUCTION_STORE"] = old
+
+    def test_terminal_phase_is_not_active_construction(self):
+        """A contract left status='open' with a TERMINAL phase must not be
+        reported as active (live store had 8 such records)."""
+        from rune.scaffold import TERMINAL_PHASES
+        self.assertIn("abandoned", TERMINAL_PHASES)
+        self.assertIn("closed", TERMINAL_PHASES)
+        self.assertNotIn("building", TERMINAL_PHASES)
+
+
 class BridgeContract(unittest.TestCase):
    def test_preflight_local_task_is_cheap_and_bounded(self):
        cap = preflight("Fix the telemetry summary log level constant in stage_telemetry.py")
@@ -34,6 +34,16 @@ def test_artifact_exists_and_parses():


 def test_single_live_defect():
-    """The bug audit converged on exactly one live defect: #324."""
+    """Live-defect record is pinned: no unverified defect may appear silently.
+
+    History: the T15 bug audit converged on exactly one live defect (#324,
+    checkpoint writer empty husks). 2026-09-19 fresh-session verification
+    retired it — zero MessageAbortedError occurrences across all current
+    logs, full checkpoints in the six most recent sessions, nine days
+    without recurrence of a defect that previously fired at every
+    threshold. Verified by present-absence (09-10 logs rotated). #324 is
+    closed FIXED_VERIFIED and the record is now empty. A new live defect
+    must be re-audited and this pin updated deliberately.
+    """
    data = __import__("json").loads(grc.ARTIFACT.read_text())
-    assert data["live_defects"] == [324]
+    assert data["live_defects"] == []
@@ -4,14 +4,17 @@ from __future__ import annotations
 import hashlib
 from pathlib import Path
 REPO = Path(__file__).resolve().parent.parent
-CANONICAL = REPO / "config" / "mimo-hooks" / "event-wait-guard.ts"
+CANONICAL_DIR = REPO / "config" / "mimo-hooks"
+# T22: the managed set is the installer's authority — a hook that reaches the
+# builder must be version-controlled and drift-checked like any other.
+MANAGED = ["event-wait-guard.ts", "builder-bridge.ts"]
 # T21.3: the hook lives at the ACTUAL controller user's home, not the
 # test runner's. Use an env override or skip when unavailable.
 import os as _os
-INSTALLED = Path(_os.environ.get(
-    "MIMOCODE_HOOK_TARGET",
+HOOK_DIR = Path(_os.environ.get(
+    "MIMOCODE_HOOK_DIR",
    str(Path(_os.environ.get("RUNE_HOOK_TARGET_HOME", "/home/nick"))
-        / ".mimocode" / "hooks" / "event-wait-guard.ts")))
+        / ".mimocode" / "hooks")))


 def _sha(p: Path) -> str:
@@ -19,15 +22,19 @@ def _sha(p: Path) -> str:


 def test_213c_canonical_exists():
-    assert CANONICAL.is_file()
+    for name in MANAGED:
+        assert (CANONICAL_DIR / name).is_file(), f"canonical missing: {name}"


 def test_213c_installed_matches_canonical():
-    assert INSTALLED.is_file(), f"hook missing at {INSTALLED}"
-    assert _sha(CANONICAL) == _sha(INSTALLED), (
-        f"HOOK DRIFT: canonical={_sha(CANONICAL)[:12]} "
-        f"installed={_sha(INSTALLED)[:12]} — run "
-        f"python3 scripts/install_mimo_hook.py to sync")
+    for name in MANAGED:
+        canonical = CANONICAL_DIR / name
+        installed = HOOK_DIR / name
+        assert installed.is_file(), f"hook missing at {installed}"
+        assert _sha(canonical) == _sha(installed), (
+            f"HOOK DRIFT: {name} canonical={_sha(canonical)[:12]} "
+            f"installed={_sha(installed)[:12]} — run "
+            f"python3 scripts/install_mimo_hook.py to sync")


 def test_213c_installer_exists():
@@ -97,6 +97,61 @@ def test_15j_native_not_construction_touches_nothing(op):
    assert not projects.exists() or not any(projects.glob("*/current.json"))


+def test_15j_intent_layer_unavailable_preserves_classifier_path(op, monkeypatch):
+    """If the meaning layer is unavailable the PRE-EXISTING behaviour is
+    preserved exactly (classify + activate) and the reason is recorded —
+    governance is never silently changed in an unproven direction."""
+    import rune.construction_intent as cint
+
+    def _boom(*a, **k):
+        raise RuntimeError("intent layer offline")
+
+    monkeypatch.setattr(cint, "resolve_construction_intent", _boom)
+    op, tmp = op
+    op.send_task("fix the broken retry handling in this project")
+    rec = _last_activation(tmp)
+    assert rec["mode"] == "EXISTING_PROJECT_CHANGE", rec
+    assert rec["activated"] is True
+    assert rec.get("intent_layer") is None
+    doc = json.loads((tmp / ".rune" / "scaffold" / "current.json").read_text())
+    notes = [o for o in doc.get("observations", [])
+             if o.get("kind") == "construction_note"]
+    assert any("intent layer unavailable" in str(n.get("text", "")) for n in notes), notes
+
+
+def test_15j_native_question_with_target_is_not_construction(op):
+    """§17J criterion 1 on the NORMAL path (T22 wiring repair).
+
+    A pure question that happens to carry a target reference
+    ("this module") must NOT record construction state. Before the
+    intent-layer gate this classified EXISTING_PROJECT_CHANGE (a target
+    reference was read as scope evidence) and recorded an activation for
+    a discussion turn. The canonical meaning layer resolves it as
+    DISCUSSION; the classifier is never reached.
+    """
+    op, tmp = op
+    op.send_task("explain how this module works")
+    rec = _last_activation(tmp)
+    assert rec is not None, "every input records its classification outcome"
+    assert rec["mode"] == "NOT_CONSTRUCTION", rec
+    assert rec["activated"] is False
+    assert rec.get("intent_layer") == "DISCUSSION", rec
+    # no project invention
+    projects = (tmp / ".rune" / "scaffold" / "projects")
+    assert not projects.exists() or not any(projects.glob("*/current.json"))
+
+
+def test_15j_native_real_construction_still_activates(op):
+    """The meaning gate must not suppress genuine construction demands —
+    the guard is a question/discussion gate, not an activation blocker."""
+    op, tmp = op
+    op.send_task("fix the broken retry handling in this project")
+    rec = _last_activation(tmp)
+    assert rec["mode"] == "EXISTING_PROJECT_CHANGE", rec
+    assert rec["activated"] is True
+    assert rec.get("intent_layer") is None, rec
+
+
 def test_15j_native_unknown_probes_without_invention(op):
    op, tmp = op
    op.send_task("Build something useful for this")