docs(architecture): refine CBAR-SUBSTRATE — pin trait to shipped types, add engram-analyzer worked example, codex derive-macro gate

[joelteply]

What

Four structural refinements to `docs/architecture/CBAR-SUBSTRATE-ARCHITECTURE.md`. Doc-only PR, no code touched.

Previously parked on `joel/docs-cbar-substrate-refine` waiting on the precommit-gate fix (now landed via #1319) and on incorporating codex's derive-macro review from #cambriantech.

Why

This document is the substrate contract — what every Rust concern in continuum-core inherits. The earlier draft was already directionally right (RTOS / CBAR pattern) but had three load-bearing weaknesses that this refresh fixes:

1. The `RuntimeModule` trait sketch named types (`ArtifactSelector`, `CadencePolicy`, `RuntimeFrame`, `ModuleResult`) as if they shipped — they don't. A reader couldn't tell what was real and what was proposed.
2. The "for free" framing was stated without showing how a new module actually inherits concurrency / memory pressure / device pressure / telemetry. The engram-analyzer worked example, asked for explicitly by Joel ("need a new engram analyzer? works in its own thread with zero effort..."), now demonstrates this concretely.
3. No acceptance gate on the derive-macro layer. Codex correctly flagged on #cambriantech that the derive macro is the load-bearing piece — if it ships sloppy, every module that uses it inherits the sloppiness invisibly.

Changes

1. Continuum Translation — anchor the trait sketch in shipped types

The section now first shows the actually-shipped `ServiceModule` + `ModuleConfig` from `src/workers/continuum-core/src/runtime/service_module.rs` with the real field set, then shows the proposed `RuntimeModule: ServiceModule` extension trait that adds typed `ArtifactSelector` / `CadencePolicy` / `RuntimeFrame` / `ModuleResult`. Each new type is labelled as a Lane D deliverable. A side-by-side table makes the today-vs-after-Lane-D delta explicit.

2. New section "The 'For Free' Triplet" + engram-analyzer worked example

Names the three things that have to ship together: base trait, `#[derive(RuntimeModule)]` macro, `just scaffold-module` generator. The engram-analyzer worked example shows the literal Rust source the developer writes (four config attributes + a handler body) and a per-concern inheritance table tracing what they get for free: registration, tokio/dedicated-thread choice, memory + CPU + device pressure response, concurrency cap, coalescing, spans / timing / VDD emission, typed failure path, replay test fixture, ts-rs exposure, lifecycle.

3. Substrate Gap Analysis cross-linked to ALPHA-GAP lanes

The previous "six numbered missing pieces" list now sits in a table that assigns each piece to its lane (A–G) and adds two pieces the earlier list omitted: piece 3 (the for-free triplet companion to the typed contract), and piece 8 (deletion of pre-broker concurrency hacks with the concrete `inference-grpc/main.rs::get_num_workers()` example calling out the `INFERENCE_WORKERS=` config.env read + system-memory heuristic as a Lane E deletion target).

4. Derive-macro acceptance gate (codex review)

Five gates the `#[derive(RuntimeModule)]` macro must clear before landing:

1. Thin — generated code is what a careful human would write; a reviewer can read a small module's expansion in one screen.
2. Contract-preserving — emits exactly the trait the hand-written version would; no smuggled behavior.
3. Inspectable — `cargo expand` output is auditable in 30 seconds, not identifier soup.
4. Tested — golden-file or trybuild tests over every supported attribute permutation, including failure modes with useful errors.
5. No hidden behavior — resource leases, scheduling decisions, and fallback/degradation paths remain visible in the macro output. The macro saves typing, not auditability.

Also

• Replaces the two-section "Extension Bar" + "Test Contract" pair with a single "Acceptance Criteria For Substrate-Done" section organized by what the substrate proves.
• "See Also" footer names ALPHA-GAP as the planning document and reasserts the precedence rule (CBAR-SUBSTRATE wins on substrate contract).

Validation

• Local precommit passed cleanly on the rebased branch (the precommit-gate fix from fix(precommit): probe continuum-core IPC, not just jtag-client surface #1319 correctly skipped browser tests when core was down).
• Cross-links resolved.

Companion PRs (canary doc track)

• docs(alpha): refresh ALPHA-GAP against 2026-05-16 canary; restructure document map; lane status truth-up #1316 — ALPHA-GAP refresh (open)
• docs(architecture): refresh CONTINUUM-ARCHITECTURE @ 2026-05-16 — substrate contract cross-link, lane-shaped roadmap, per-engine status notes #1317 — CONTINUUM-ARCHITECTURE refresh + codex persona-cognition asks (open, follow-up commit just pushed)
• docs(vision): refresh CONTINUUM-VISION — label TS sketches, pin concept→Rust map, cross-link truth docs #1320 — CONTINUUM-VISION refresh (open)
• airc#642 — manager-role + lane substrate design proposal (open)

This PR closes the parked block on CBAR-SUBSTRATE. The four-doc set (this one + #1316 + #1317 + #1320) now cross-reference each other consistently, with this doc named as the precedence-winner on substrate-shape questions.