Prepare for Lerna 8 upgrade - #16
Closed
joelteply wants to merge 4 commits into
Closed
Conversation
- Update Node.js engine requirement to 18+ - Update CI workflow to use Node.js 18+ - Create update script for Lerna 8 - Update postinstall script for compatibility - Add documentation for the upgrade process 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
- Add robust error handling to visualize-config.js - Create simplified version that doesn't depend on yaml module - Add package.json for examples directory - Update CI workflow to better handle example validation 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
joelteply
enabled auto-merge
April 9, 2025 03:16
auto-merge was automatically disabled
April 9, 2025 03:28
Pull request was closed
joelteply
added a commit
that referenced
this pull request
Jul 3, 2026
…osterSlotView both rails read (#8/#13) (#1748) * feat(positron): converge roster projection — one neutral RoomMember→RosterSlotView both rails read (#8/#13) The persona's room-presence grounding (Rail A, RoomRosterSource) and the WS widget roster (Rail B, ChatProjection) independently projected the SAME airc `RoomMember` and dropped DIFFERENT fields: Rail A kept availability + last_seen_ms; Rail B silently dropped them. Two projections of one truth — the compression violation task #8/#13 targets. Converge on ONE neutral superset projection, keeping positron generic: - continuum-positron (the public, framework-neutral package): extend the neutral `RosterSlotView` with `availability: Option<String>` (airc's stable snake_case label, transported VERBATIM — positron never enumerates availability states, same not-interpreted discipline as provenance.runtime / integrations) and `last_seen_ms: u64`. Additive + serde(default) → wire-safe. - continuum-core: one shared `roster_slot_from_member(&RoomMember) -> RosterSlotView` — the single place a slot is built. Both rails call it, so they can never drop different fields again. Delete the hand-copied `AircPresenceSlot` twin (RosterSlotView already derives Serialize/Deserialize, so the neutral view IS the wire shape) and the now-identity `roster_slots_from`. Collapses the two provisional-name fallbacks into one decision. - Rail A formats its grounding line from the shared slot (availability/recency now survive into the persona's prompt — the fields Rail B used to drop). Test drift-proofing: the projector tests hand-authored camelCase presence JSON — the exact "hand-copied JSON literal" the module doc forbids, which my type change exposed. Replace with shared `#[cfg(test)] test_presence_payload` / `test_roster_slot` that serialize the REAL AircPresenceUpdate, so a test's wire can never drift from the struct's field names again. Transcript/ChannelDigest path is intentionally untouched — display (flat ring) and cognition (consolidated digest) are legitimately different projections; sharing the ChannelElement upstream is a separate follow-up. Validated: continuum-positron 83+5 tests; continuum-core roster + positron projection modules 40 tests; ts-rs bindings regenerated + re-vendored to sdk/typescript; chat-view/web/sdk/tui typecheck + vitest all green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * test(persona): deterministic seam proof — present member → [Present in this room] via one projection Prove the personaRag consumer reads the converged roster projection end to end, through the exact code the live heartbeat loop runs — deterministically, without depending on airc presence (which is empty on this host: 0 healthy routes, the known event/presence-wake gap #16/#84, upstream of this convergence). - Extract `project_room_roster` (the room-roster delivery → grounding fold) out of `serve_persona_loop` into a pure `pub(crate)` fn beside its sibling `build_workspace_turns`. The loop now calls it; behavior-preserving (all service_loop projection tests stay green). One roster truth, and a testable seam instead of inline loop code. - Add `present_member_reaches_present_in_room_block_end_to_end`: a present airc RoomMember (self-reported Busy) flows RoomRosterSource.deliver (the ONE shared roster_slot_from_member projection both rails use) → project_room_roster (the live fold) → prompt_assembly, and lands `win-claude [claude] — busy` in the [Present in this room] block — availability carried as airc's neutral label, the field the widget rail dropped before the convergence (#8/#13). Connects the three separately-unit-tested halves via real code. Live core (rebooted onto this branch) confirmed the plumbing runs: persona reads the channel + takes turns, prompt assembly intact. The [Present in this room] block can't render live only because airc presence returns no member — a separate infra gap, not this change. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(persona): restore live — persona heartbeats for roster presence + drop generation-lane --embeddings Two regressions were keeping the live persona stack dark; found + fixed while proving the roster convergence end-to-end on a running core. 1. Generation lane ran with `--embeddings` (inference/llama_server.rs). On the current llama.cpp build that flag forces embedding (non-causal) mode, so EVERY generation request failed with `500 "Compute error."` — no persona could take a turn — and OAI `/v1/embeddings` still 400'd ("pooling type 'none'"), so it wasn't even serving embeddings. One server can't do both causal generation and non-causal embeddings. Dropped the flag from the generation lane; verified the base GGUF generates cleanly the instant it's gone (`200` "Hello!" vs `500`). llama-hosted embeddings need their own lane (follow-up); the live embedding path is the fastembed/ONNX provider. 2. Personas never emitted airc `Alive` heartbeats. airc `active_agents` (which backs `room_roster`) reduces heartbeat events, NOT `say()` messages, so co-resident personas were invisible to each other's roster — the `[room-roster]` grounding went dark and personas leaked raw peer UUIDs instead of names. The spawn contract was attach → join → subscribe → publish_identity but never started the heartbeat pump. Now bootstrap calls `start_agent_heartbeat("persona", …, DEFAULT_HEARTBEAT_INTERVAL)` and holds the `HeartbeatTask` for the persona's lifetime (drop on teardown ages it out of the roster — the honest "no longer here"). WARN-and-continue on failure, symmetric with publish_identity. Live proof (rebooted onto this branch): room_roster deliver `present=1` for both Asha and Solenne; Asha's live brain-assembled system prompt now carries `[room-roster]\nSolenne [persona]` (the converged roster_slot_from_member line), and she converses as a grounded citizen. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(boot): gate persona hosting on DECODE-verified serving readiness, not just fits_on_gpu The `--embeddings` outage was silent because persona-boot spawned citizens the moment the serving PLAN said `fits_on_gpu` — a pure VRAM/resource decision that says nothing about whether the lane can actually generate. So a lane that fit GPU but 500'd on every `llama_decode` (embedding/non-causal mode, a bad LoRA, a wedged Metal context — all while `/health` answers 200) got personas hosted onto it, and every turn failed silently. The decode-verified signal already existed and was correct: `ServingSnapshot.ready` is published ONLY on a serve/adopt outcome that passed the 1-token decode smoke-probe (`wait_ready` → `decode_smoke_ok`). Persona-boot just wasn't waiting on it. Now, after `fits_on_gpu`, the boot loop `await_ready_serving(120s)` — parks on the serving snapshot until the lane proves it can decode. Timeout → do NOT host (loud warn, retry on the next serving edge, self-healing), never spawn personas onto a can't-generate lane. Verified live: healthy lane → `citizen(s) hosted, attempts=1` (no deadlock); a can't-decode lane now warns loudly and holds off hosting instead of producing silent per-turn 500s. This is the startup/health guard that makes the `--embeddings`-class regression impossible to land silently again. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
joelteply
added a commit
that referenced
this pull request
Jul 4, 2026
…inal) + screenshot-per-surface proof (#1787) Dogfooding all three surfaces against the README hero made the gap concrete: the live app is a basic 3-panel chat (text + one ACT meter); the README is rich complex widgets (avatar video tiles, INT/NRG/ATN+GENOME cards, system-vitals sparkline, tab bar, call controls, brain-HUD). Rewrote Workstream C brick 4: grow the positron component library to that set, each widget with a PER-SURFACE renderer — full web, responsive mobile (390px clips today = real bug), ANSI terminal (apps/tui renders WHO/WHAT, proving the seam). Proof = a shot on EACH surface vs the README. Also: the terminal frame confirmed the #16 persona-echo/duplication is in the DATA, not a render bug — fix upstream first. Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
joelteply
added a commit
that referenced
this pull request
Jul 5, 2026
doubled-turns bug (#1808) The bug hurting every interface: personas' turns rendered TWICE (Asha-A, Solenne-B, Asha-A, Solenne-B) on web, terminal, and RAG. Root-caused empirically: the live persona conversation is airc-native (continuum main.db held only 4 human test messages), and the same logical block replays through the bus with a FRESH message_id each hop (#16 multi-hop). apply_message deduped only on message_id, so the fresh-id replay slipped through and double-appended. Fix: apply_message is now idempotent on message_id AND on (sender_id, content) — the same content identity the cognition admission dedup already uses (content_hash, cognition_io.rs). One (sender, content) is one message however many ids the bus mints for it; a genuinely new message still appends. Verified: 13/13 positron_source tests green incl. the new multi_hop_replay_with_fresh_id regression (3 fresh-id copies → 1 message; new content → 2). Live effect lands on next core boot — the projection collapses the replayed block. Fixes the visible duplication behind the desktop love-pass caveat. Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
joelteply
added a commit
that referenced
this pull request
Jul 30, 2026
…media-plane split (#2059) * fix(serving): eval-lane bring-up fails LOUD with the real cause, not a masked 240s /health timeout (#205 unmask) Glass-boxed 2026-07-27 running the live coding measurement (agent/solve): every `agent/solve` on this Mac failed with a bare "llama-server not ready after 240s (/health request failed)". The real cause was thrown away — `wait_ready` polled the health port for the WHOLE budget without ever checking whether the child it spawned had died, and never surfaced the child's stderr. ROOT CAUSE, proven this session: the ephemeral eval lane forges a SECOND Devstral-24B (~14 GB) while the live persona lane already holds ~26 GB. With only ~9.6 GB free, macOS jetsam SIGKILLs the second llama-server the instant it maps the model — before llama.cpp prints a single byte (reproduced by hand: exit 137, zero-byte log). It is an OS out-of-memory kill, NOT Metal-context contention and NOT a hang. The masking bug made it look like a mysterious timeout. Two unmask fixes in `wait_ready`, benefiting live AND ephemeral lanes: 1. **Fail loud the instant our child EXITS** — `child_exit_status()` (non-blocking `try_wait`) turns any crash-at-launch — including the jetsam SIGKILL/137 above — into an immediate `Spawn` error carrying the exit status + stderr tail, instead of polling a dead port for 240s. This is the arm that fires for the memory-wall failure. 2. **Fingerprint the empty stderr on the hang-timeout** — `tail_or_hang_marker` turns an empty log into a marker that, read with the exit status, names the two empty-log causes: an OOM/jetsam kill (SIGKILL/137, child exited) vs. a genuine early-init hang (no exit status). A crash from bad args / model-load fault prints its banner first, so a non-empty tail carries that directly. `tail_or_hang_marker` is a pure fn (unit-tested: empty→OOM/hang marker, non-empty→last 20 lines in order) so the load-bearing decision is tested without touching the real `~/.continuum/logs` path (#72 env-dependent-test lesson). This makes the failure DIAGNOSABLE; the underlying fix (don't forge a second 24B for eval while the live 24B is resident — reuse the live lane's weights or serialize via the governor, #59/#234) is a follow-up. Validated: continuum-core compiles (--features metal,accelerate, 0 errors); `tail_or_hang_marker_fingerprints_empty_and_tails_nonempty` green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(serving): eval-lane gate refuses on real free-RAM-vs-footprint, not just pressure LEVEL — kills the jetsam SIGKILL at the root (#205) The companion to the unmask commit: don't just REPORT the eval-lane OOM loudly, PREVENT it. The gate (`await_eval_lane_memory_headroom` → `refuse_eval_lane_under_memory_pressure`) vetoed only on macOS *pressure LEVEL* + the sustained-pressure gate. But on unified memory the level reads "Normal" while sitting atop only a few GB of real free RAM — it counts compressible/cached pages as available. So the gate green-lit standing up a SECOND llama-server of a known ~14 GB footprint into 9.6 GB of actual headroom, and the OS jetsam-SIGKILLed it (exit 137, zero-byte log — the exact failure this session reproduced by hand). Neither the pressure gate NOR the GPU/CPU placement lease caught it: on unified memory the weights need the RAM on *either* device, so "spill to CPU" doesn't save you. Fix — size against the honest free-bytes number: - `MemoryPressureMonitor` already reads `sysinfo::available_memory()` each poll; publish it to a new lock-free global `current_available_bytes()` alongside the pressure level (the level is a ratio and lies; the bytes don't). - `eval_lane_ram_veto(available, footprint, headroom)` — a PURE, unit-tested guard that refuses ONLY when a KNOWN footprint won't fit in the KNOWN free bytes (+2 GiB headroom), and NEVER when either number is unknown (an unread probe must not starve a node — the pressure gate + placement lease stay the backstops). The refusal names the OOM wall, so the detached ledger carries a real cause and `await_eval_lane_memory_headroom` retries it as deferrable load instead of crashing. - One footprint sizing (`eval_lane_footprint`) now shared by the gate and the placement decision (compression — was duplicated inline). - Both eval-lane spawn sites resolve `base` and size the lane BEFORE the gate, so the RAM check runs pre-cold-load. This is the reliability doctrine [[reliability-is-it-works-not-that-it-reports-failure-well]]: the prior commit made the failure legible; this makes the machine refuse cleanly instead of being OOM-killed. Sibling of the #175 GPU-OOM-poisons-the-backend class — the level-vs-real- bytes gap is the same shape. Validated: continuum-core compiles (--features metal,accelerate, 0 errors); new `eval_lane_ram_veto_refuses_only_a_known_oversize_lane` + existing pressure-veto test green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(deploy): install the continuum CLI as a real COPY on PATH, not a symlink into the ephemeral cargo target dir The flaky mess where `continuum` vanishes post-boot ([[deploy-cli-binary-deleted-from-target-dir-post-boot]]): `start-server.sh` symlinked ~/.local/bin/continuum → the cargo target-dir binary. But that dir is a BUILD artifact — cargo replaces the binary mid-rebuild, `cargo clean` and rust-analyzer's feature-mismatched rebuilds delete it — and the PATH symlink then dangles, so `continuum <cmd>` dies with "no such file or directory" (hit twice this session). Fix: COPY the binary to ~/.local/bin (atomic temp+mv so a concurrent `continuum` invocation never sees a half-written file), and `rm -f` any pre-existing entry first so a leftover symlink from an old install can't make `cp` follow it back into the target dir. The PATH binary is now decoupled from cargo's churn — it changes only on deploy. Same self- provisioning intent, minus the ephemeral-artifact coupling. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(benchmark): BenchmarkAdapter trait + registry — the grid-transparent, reusable, learn-from benchmark interface (rail 1 of #123) The goal (Joel): "have all these benchmarks IN OUR SYSTEM, AUTOMATED so we or others can REUSE them (just the optional download + the adapters). Run, TARGET and — more importantly — LEARN from these." And: "any command can run anywhere, so can benchmarks — a persona in any continuum can bench anywhere." That settles the architecture and this is rail 1 of it: - `BenchmarkAdapter` — ONE trait per benchmark: `dataset()` (OPTIONAL download spec, never bundled), `tasks()` (items in the canonical `EvalTask` shape so the SAME `agent/solve` path runs them — persona as a whole AGENT, not a bare LLM), `grade()` (defaults to the EvalTask's own test/expect verdict; real-repo benchmarks like SWE-bench override to grade the workspace after the agent acted), `resources()` (a hint for grid placement). - `DatasetSpec` / `DatasetKind` (HF / URL / Git) + `BenchResourceHint` (dataset bytes, needs_container, needs_network) so the runner fetches on demand and the governor can place the run on a capable node — the same demand-vs-resource negotiation serving/eval already do. - A process-global registry (`register`/`get`/`names`) — the single lookup seam the `benchmark/run` DynCommand resolves against; an unknown benchmark is a clean miss so the runner can fail loud with the known list, never a silent skip. - `TaskOutcome` / `BenchGrade` — the agent/solve artifacts (spoken + patch + workspace + harness verdict) handed to `grade`, and the per-task pass/score/reason that aggregates into the scorecard AND, on failure, feeds salience→curriculum→train (#116/#122) — benchmarks as CURRICULUM, not just a scoreboard. Why Rust-native (not the ad-hoc benchmarks/*.py): a DynCommand is the grid-transparent primitive — `Commands.execute("benchmark/run", …)` routes local-or-remote over airc; python can't route the mesh. Adapters shell to python/docker graders ON whatever node runs them. Outlier-validation order (next rails): OUTLIER A = HumanEval (tiny download, static, test- graded); OUTLIER B = the Terminal-Bench ContinuumAgent adapter (agentic meta-harness that unlocks TB's registry — docs/architecture/BENCHMARK-HARNESS-INTEGRATION.md). Then the `benchmark/run` DynCommand + grid dispatch + the learning tie-in. Validated: compiles (--features metal,accelerate); `registry_round_trips_and_reports_unknown` + `default_grade_delegates_to_harness_verdict` green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(benchmark): HumanEval-rs adapter — outlier A on the BenchmarkAdapter trait (rail 2 of #123) The quick-cognition smoke rung (a step above arithmetic, per Joel): 156 Rust-translated HumanEval tasks our EXISTING Rust grader runs directly. Deliberately the SIMPLEST possible adapter — tiny, RESIDENT (no download), static, test-graded — so pairing it with a maximally-different outlier B (the Terminal-Bench agentic meta-harness: big download, real-repo, container-graded) proves the interface across both extremes. Nearly free because the in-repo `docs/genome/humaneval-rs.jsonl` rows ARE serialized `EvalTask`s (`{id, prompt, test, lang}`) — the same shape `cognition::eval` already deserializes — so the adapter is a per-line `serde_json::from_str`. This also exercises the trait's NO-DOWNLOAD branch (`dataset() == None`): a benchmark small enough to bundle needs no fetch; only the big ones (SWE-bench) do. Pure `parse_humaneval_rs` (line-by-line deserialize, honors `limit`, skips blanks, FAILS LOUD with the offending line number rather than silently dropping a task and inflating the pass rate) is unit-tested without the filesystem. Validated: compiles (--features metal,accelerate); `parse_maps_rows_to_evaltasks_honors_limit_and_fails_loud` + `adapter_identity_and_no_download` green. Next rail: the `benchmark/run` DynCommand (resolve adapter → tasks → agent/solve → grade → scorecard, grid-transparent) so this scores a model on any node — incl. BigMama's live Kimi-Linear-48B CUDA lane on :58057. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(memory): MemoryRecord (origin_node, origin_seq) — the RAID replication-provenance seam for Persona-RAID (#2056, co-designed w/ BigMama) Two additive fields on MemoryRecord, the target BigMama's Persona-RAID slice-2 receiver stamps on replay: - `origin_node: Option<String>` — node that ORIGINALLY admitted the record (None = local/lived) - `origin_seq: Option<u64>` — monotonic per-(persona, origin_node) admit seq, the newest-wins replay key (None = pre-replication) The KEY invariant (my review edge, now the agreed shape): replication is an ORTHOGONAL axis, NOT a new experience kind. `memory_type` (lived vs `shared-by`) is untouched — a replicated record keeps its experience (a replayed lived memory stays lived; a shared-by lesson stays taught) and merely gains (origin_node, origin_seq) as auditable/replayable metadata. So recall needs zero changes and audit gets everything. Both `#[serde(default)]` = zero migration for existing rows; every current construction site is a local admit → (None, None), semantically exact. ts-rs regenerated: `MemoryRecord.ts` gains `origin_node?: string` + `origin_seq?: number` (number not bigint, per the #120 drift rule). Validated: continuum-core compiles (--features metal,accelerate); memory::types tests green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(benchmark): wire BenchmarkAdapter registry into benchmark/run — inventory self-registration, catalog-then-adapter resolution (#123) Converges the two benchmark systems instead of forking a third. The static known_benchmarks() catalog keeps its proven, DEPLOY-SAFE embedded-gym path for resident benchmarks (resolve_gym finds the gym even without a repo checkout). The BenchmarkAdapter trait becomes the EXTENSION seam for benchmarks the catalog can't express — downloadable / custom-graded ones (Terminal-Bench, SWE-bench) now land as pure adapters with zero change to benchmark/run. - benchmark/run resolves catalog FIRST (name it knows → embedded gym), else the adapter registry (benchmark::get), else fail loud listing BOTH sets. A downloadable adapter (dataset() = Some) fails loud 'download not wired yet' rather than silently scoring empty; resident adapters (dataset() = None, e.g. humaneval-rs) run today. Delegates to the ONE grader (cognition/eval) exactly as before — never reimplements grading. - Adapters self-register via inventory (the SAME mechanism commands use), so a builtin needs NO boot hook and NO central list (the dynamic-discovery contract). get()/names() fold the link-time inventory set in over runtime registrations. - HumanEvalRsAdapter submits itself; new test pins that benchmark::get('humaneval-rs') resolves with no boot hook. 19 benchmark tests green; 0 errors. This makes rail 1+2 of the adapter framework LIVE on the grid-transparent benchmark/run command, ready for the Terminal-Bench ContinuumAgent adapter (outlier B) to slot in. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(boot): macOS core boot — bash-3.2 manifest gate + rt_handle.spawn off-runtime panic (#194) TWO regressions that made the macOS core un-bootable since the last long-running core died (glass-boxed live 2026-07-28; nobody could reboot on macOS): 1) start-server.sh sourced generated/manifest.macos.sh (bash-4 `declare -A`) under `set -e`; macOS ships bash 3.2, so the source aborted the whole boot before cargo ran. Regression from #2046 'serve on Windows' regenerating the manifest with associative arrays. Fix: only source the bash-4 manifest on bash 4+ (it solely feeds the Windows/CUDA runtime-PATH augmentation, whose own guard already tolerates absence). 2) ipc/mod.rs:1704 used bare `tokio::spawn` in the SYNC boot region (after the rt_handle.enter() guard drops) → 'there is no reactor running' panic → the IPC listener thread died → socket never bound → whole core a zombie. Regression from #2051's AircInterceptor block; every other spawn in the fn already uses `rt_handle.spawn`. Only reached when airc deps are present, so it bricked boot on every airc-configured host. Fix: rt_handle.spawn, matching the siblings. Verified: core boots to socket-live + answering commands in 60s; personas resume from disk and respond in live chat (Anwen answered a direct question with memory recall). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(boot+ui): macOS core boots + ONE automatic door into the positron interface (#194/#29) Two boot regressions that made the macOS core un-bootable since the last long-running core died, plus the missing automatic entry into the interface (you can't ship a beta a user can't open). BOOT (both verified — core now reaches socket-live in ~60s, personas resume + answer live chat): 1. start-server.sh sourced the bash-4 `declare -A` manifest under `set -e` → macOS bash 3.2 aborted the whole boot before cargo ran (regression from #2046). Gate the source on bash 4+. 2. ipc/mod.rs:1704 bare `tokio::spawn` in the sync boot region (after rt_handle.enter() dropped) → 'no reactor running' panic killed the IPC listener → socket never bound → zombie core (regression from #2051). Use rt_handle.spawn like every sibling. UI DOOR (#29): nothing tied the built positron web client to the running core, so finding 'how do I open the interface' required archaeology — exactly how a user (and an agent) gets lost. - New tools/scripts/open-ui.sh + `npm run ui`: resolves the core WS (8974) + call/video WS (8790) + a stable identity, ALWAYS rebuilds apps/web from current source (a stale dist renders an old shell — the 'interface looks lost' trap, glass-boxed today: a Jul-18 dist showed a bare chat view, not the current positron HUD), serves it, opens the browser with everything pre-wired. Verified live in headless Chrome: the full positron HUD (SYSTEM CPU/MEM/GPU sparkline, NODES, genome-paging tiles per persona, Go-live, rooms, live persona cognition) renders against the live core. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(live): auto-start the LiveKit avatar rail with the core (server + bridge sidecar) The persona's talking avatar is Bevy-rendered and published to a LiveKit room via the livekit-bridge sidecar; the browser's 'Go live' subscribes to that room. But NEITHER the SFU nor the bridge was started by `continuum start` — glass-boxed 2026-07-28 by joining the call plane headless: LiveKit :7880 was DOWN → get_or_create_agent fails → no avatar video pump ever runs, and clients only ever saw the native call_server's test-pattern default. The avatar was un-launchable without manual, undocumented steps (start livekit-server, build + start the bridge) — a beta can't ship a 'Go live' button that needs hidden setup. start-server.sh now runs start_livekit_rail() before the core, idempotently + NON-FATALLY: 1. livekit-server --dev on :7880 (dev creds devkey/secret = the bridge defaults) if not already up; warn+skip if the binary isn't installed (core still boots, only live A/V off). 2. build (release, once — links webrtc-sys) + start the livekit-bridge sidecar on its unix socket BEFORE the core, so the core's bridge_client finds the socket at boot. A missing/failed rail never blocks the core (chat/cognition/serving unaffected). system-stop.sh gets symmetric teardown of the bridge (server teardown already existed). Verified: syntax clean; idempotent against an already-running rail (both start steps skip when :7880 is up + the bridge is running). The rail itself is proven live this session — livekit-server + bridge up, core connected, an STT participant joined the LiveKit room. Follow-up (functional, not automation): the per-persona avatar VIDEO agent (get_or_create_agent + spawn_avatar_video_pump) still doesn't publish — only the STT listener joins the room. Next. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(live): tee avatar frames into the native call plane — everyone sees the real face (#193/#172) The avatar published to LiveKit, the bridge received it (640x360), but the native call plane (call_server WS 8790) that BOTH the positron web client AND the glass-box harness read still emitted its own 160x120 SMPTE test pattern. The real avatar was stranded on a rail no native viewer subscribed to. Convergence (render once, two sinks): the single Bevy slot the avatar pump already allocates now feeds BOTH LiveKit and the native plane. Per frame the pump tees the same RGBA into CallManager::push_avatar_frame, encoded in the exact [VideoFrameHeader][pixels] contract native clients decode, labeled with the persona's uuid. No second Bevy slot, no parallel renderer. - call_server.rs: push_avatar_frame (new seam) + retire the auto-start test pattern to an opt-in debug affordance (CONTINUUM_CALL_TEST_PATTERN=1), honoring the TODO that sat on the auto-start block since real sources were 'not yet connected'. - video_pump.rs: tee each frame (stable source Handle + monotonic seq/clock) alongside the LiveKit publish. - modules/live.rs + ipc/mod.rs: thread the native CallManager through VoiceState to the register-session pump spawn. - example: standalone CallManager (tee is a no-op there). Live-verified on the native plane after deploy: 640x360 real avatar (Asha's VRM, not the test pattern), 13.5 fps wall / 13.3 median (tracking the 15fps Bevy target), inter-frame jitter min 56.8 / median 75.4 / max 86.4 ms, 0 dropped/out-of-order frames, sole sender = Asha's uuid. Random-frame spot-check shows her real face, live-animating. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(voice): one canonical model root — kill the CWD-relative path bug that silently broke every local TTS/STT (#195) Root cause (glass-boxed this session): the workers→core/tools restructure moved the runtime model download root to `tools/models/` (gitignored — see .gitignore's own note), but every audio adapter kept stale, CWD-relative `models/…` path constants. When the core runs from the repo root (its normal CWD), `models/piper/…` pointed at the *tracked* avatar dir, not the voice models in `tools/models/piper/…` — so Edge returned empty, and Piper / Kokoro / Moonshine / Whisper all reported 'model not found'. Every local voice model was silently dead. Kokoro even mutated the process CWD (`set_jtag_cwd`) to paper over it. Proper fix — single source of truth, absolute, CWD-independent: - New `live/audio/model_root.rs`: `voice_model_root()` / `voice_model_path()`. Resolves `CONTINUUM_MODELS_DIR` (config.env single-owner, then process-env boot injection), then `tools/models`/`models` CWD candidates, then `~/.continuum/models`. - Routed EVERY voice adapter through it — piper, kokoro (15 sites), orpheus, moonshine, whisper, pocket-tts, silero VAD, tts_service. No more scattered `models/…` literals, no per-adapter candidate ladders, no `set_current_dir`. - start-server.sh exports `CONTINUUM_MODELS_DIR=$REPO_ROOT/tools/models` before exec so the binary resolves models from any CWD. Live-verified after deploy: fresh core has CONTINUUM_MODELS_DIR injected, no symlink present, `voice/synthesize-handle --adapter piper` resolves the model and synthesizes (was 'model not found' before). (The short synth duration is a separate phonemizer/espeak-data issue, not this.) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(live): tee persona voice into the native call plane — client hears her, not hold music (#193 audio convergence) Sibling of the avatar-video tee. A persona speaks via LiveKit (speak_in_call → bridge), but native clients (positron web, glass-box harness) read the native mixer — which, with only a lone listener, plays HOLD MUSIC. So a native viewer SAW her avatar but HEARD hold music: her voice was stranded on the LiveKit rail. Render once, two sinks: speak_in_call now returns the synthesized PCM, and the voice/speak-in-call handler tees the SAME samples into the native plane via CallManager::push_persona_audio — which registers the persona as a virtual AI participant in the call's mixer (the mixer already has an AI ring buffer built for 'dump a whole TTS utterance, drain frame-by-frame') and her presence stops the lonely-listener hold-music fill. Self-heals across call recreation via a stable per-(call,persona) handle. Live-verified: with Asha registered + speaking (kokoro), a native-plane capture shows audio sender = her uuid (90e758b2) for 4.58s, matching the 4.55s utterance — was 100% 'hold-mus' before. Video (640x360 avatar) + audio (her voice) now both reach the client: e2e see+hear on the native plane. Also this session: espeak-ng installed so kokoro TTS produces real full-length speech (piper's Rust phonemizer truncates — kokoro is the good local path). Follow-ups: hold-music still fills her SILENCE between utterances (minor polish — suppress when a persona is present); STT/audio-in blocked on moonshine ONNX format mismatch; livekit-bridge needs supervision (dies on every core restart). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(positron): durable local state + self-healing feed — inherent to the SDK, adapter-driven (the Twitter model) Glass-boxed 2026-07-29: routine core reboots orphaned every open tab — the state feed died once, the shell silently degraded to the bare chat view, and four months of positron HUD looked 'lost' until a manual refresh. Per Joel: this is normal app craft (cache-first boot, live reconcile, visible reconnect) and it must be POSITRON architecture — from the thin-client SDK out, adapter-driven local state, never an app-level hack or a localStorage bodge. SDK (sdk/typescript — the contract every platform SDK mirrors): - StateStorage.ts: StateStorageAdapter — the ONE local-durability seam. The whole renderable state is latest-envelope-per-kind (each envelope is a full snapshot), so the cache is tiny + complete. Adapters: IndexedDbStateStorage (browser), MemoryStateStorage (tests/ephemeral + conformance reference); swift/kotlin/ flutter implement the same interface over native stores. Cache is an accelerant, never a dependency (storage failure -> live-only, logged once). - StateConnection: durability + resilience are now INHERENT — - hydrate-first connect(): cached envelopes paint before the network is touched (instant last-known UI, even against a dead core), status 'cached'; - write-through: every live envelope replaces its kind's row (fire-and-forget); - auto-reconnect (default ON): capped 1s->10s ladder using the wire's existing last_seen replay; a failed FIRST connect rides the same ladder (core booting); - onStatus surface (cached/connecting/live/reconnecting/closed): recovery is LOUD — reconnecting stays visible while the core is away, so self-heal can never mask a dead core; close() stops the ladder (intentional shutdown); - reconnect:false preserves the legacy one-shot fail-loud contract for probes. - Fail-loud config errors (no registered kinds) never enter the retry ladder. App (apps/web): shrinks to what an app should be — pass IndexedDbStateStorage, render envelopes + ONE status chip. Zero resilience logic app-side. Tests: 97/97 SDK suite green; 4 new pins (default-resolve+reconnecting status, hydrate-before-open, write-through, drop->reconnect->resubscribe w/ last_seen). Live-verified: rebuilt app renders the full positron HUD through the new feed. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(mobile): positron durable-state contract on Android + iOS — Dart mirror of the SDK, tested One Dart implementation (byte-identical on both OSes) mirroring sdk/typescript's inherent resilience contract, per [[positron-durable-state-is-sdk-inherent-adapter-driven]]: - lib/positron_state.dart: StateEnvelope + StateStorageAdapter (the ONE seam) with MemoryStateStorage (conformance reference) and FileStateStorage (dart:io JSON — durable on Android + iOS app dirs, ZERO plugin deps, corrupt-tolerant, cache is an accelerant never a dependency); StateConnection with hydrate-first connect, write-through, capped 1s->10s reconnect ladder w/ last_seen replay, loud status (cached/connecting/live/reconnecting/closed), reconnect:false one-shot fail-loud. Injectable StateSocketFactory — tests drive the lifecycle without a core. - lib/live.dart: LiveConnection now RIDES the contract (was a one-shot connect that died silently — the same disease the web had). App keeps only the ChatViewState->MobileScreen mapping + optional status/cacheDir wiring. - test/positron_state_test.dart: 5 pins mirroring the TS spec — hydrate-before- socket, write-through, drop->reconnect+last_seen, fail-loud vs self-heal, FileStateStorage conformance (round-trip, replace-by-kind, corrupt-tolerant). - ios/: runner scaffolded (flutter create --platforms=ios). Verified: flutter test 6/6 green, flutter analyze clean. Platform note: the Dart contract tests prove BOTH OSes (same code); Android SDK present for APK builds; iOS device/simulator builds need full Xcode on this machine (CLI tools only). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): tab strip renders from ONE open tab — the focused room IS a tab Glass-boxed live: the strip + CSS + nav plumbing all shipped (38b60caae), but the render gate was cells.length > 1 while the node's room-set fold knows exactly one room (cambriantech) — so the whole bar hid and the interface read as 'tabs don't exist'. One open activity is still an open tab; the strip now draws from 1 up, and fills out as the room set grows. Substrate follow-up (separate card): seed spawn_room_set_fold from airc's subscribed-room registry (durable membership), not just observed traffic — today a room with no traffic since core boot never becomes a tab. Verified live: playwright screenshot + widget-state dump (tabBarTabCount 1), web tests 21/21, typecheck clean. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(web): Discord shell geometry — full-height rails, center-scoped tabs/header/compose The reference is the Discord/VS Code shell: columns run window-top to window-bottom; no chrome bar spans the whole width. The left rail now opens with the continuon (the server-header slot), the tab strip sits centrally over the content column only, the room header/transcript/composer all live inside the center column, and the ROOM context rail runs full height. Mechanically: RenderTarget.workspace grows an optional WorkspaceChrome<Out> slot (patterns) — the compose bar stays HOST-owned (input state + send handler) but SHELL-placed (chrome.centerFooter), so the widget no longer appends full-width rows after the surface. litTarget nests tabs + header + what + footer in a .center flex column inside the same .panels grid the universe skins and mobile rules already key off. Also: /// <reference lib="dom" /> on sdk StateStorage.ts — the IndexedDB adapter's DOM types broke typecheck for non-browser consumers (tui) since e4fedac8f; scoped ambient types fix every consumer without forcing lib:dom. Verified live: playwright screenshot (full-height rails, central tab, center compose), web 21/21 + chat-view 56/56 + patterns 5/5, typecheck clean on web/patterns/tui. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(chat): beforeMessageId scroll-back cursor on chat/poll — history pages out of durable storage The Twitter endless-scroll's storage half: chat/poll gains the backward cursor. beforeMessageId resolves the anchor's stored timestamp (same lookup as afterMessageId, now ONE anchor_timestamp helper), filters $lt, queries DESC, and normalizes chronological — the limit messages immediately preceding the anchor, straight from the durable chat_messages store. The two cursors are mutually exclusive and reject loud BEFORE any storage round-trip; the result echoes the cursor so the caller's paging loop just keeps passing the oldest id it holds. Client loop (web/mobile/tui alike): render the live 50-row tail, then scroll-back = chat/poll {roomId, beforeMessageId: oldest-on-screen} — prepend, repeat until an empty page says history is exhausted. The render-side wiring is the follow-up slice; the trigger idiom stays per-target (IntersectionObserver on web, ScrollController on Flutter), the cursor mechanics live here, once. Tests: before-anchor $lt+DESC+chronological, both-cursors reject (pinned to fail before data/query), absent-not-null echo. 32/32 chat module green; ts-rs bindings regenerated. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(sdk): export the drifted wire types — 64 registered-command params/results never emitted ts-rs bindings The pre-existing drift that has blocked the TypeScript SDK re-emit (and forced nav/select onto the raw-wire path): TS-deriving wire types across commands/{benchmark,help,tool}, cognition, runtime, and modules lacked #[ts(export, export_to)] — the emit's vendoring walks the registry and fails loud on the first missing binding. Swept every one onto the same protocol/typescript/<module>/ convention its file siblings use. export_bindings: 1236 green (was 1160). Remaining emit blocker (separate card): bare #[ts(export)] types land in the crate-local bindings/ dir while the vendorer expects protocol root. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(web): Twitter endless scroll — scroll-back pages durable history into the transcript The render half of the beforeMessageId cursor (02d5c7701): - chat-view: historyRowsFromPoll — one chat/poll storage page (raw entities: {content:{text}, ISO timestamp, no sender name}) onto the SAME MessageRowVM rows the live tail renders; roster-resolved identity, short-id + metadata.source fallback, live-tail dedup, malformed-row skip. 3 specs. - widget: scroll-near-top pages one older window and prepends with the viewport anchored (scrollTop compensated); rows that slide OUT of the live 50-row window RETIRE onto the buffer so no gap opens; buffer clears on room switch; an empty page latches exhausted. - scroll-yank fix (reported live): pin-to-bottom now only fires when the reader was AT the live edge (_wasNearBottom, measured pre-render) — a scrolled-back reader is never forced down by a new message. - host: chat/poll over the same raw-wire seam as nav/select (the typed CommandMap re-emit is still blocked; path documented in-code). - sdk drift: corrected the swept export_to paths to the proven ../../../protocol/typescript/ convention (benchmark/help/tool/agent); strays under core/protocol removed; export_bindings 1172 green. Live activation needs the rebuilt core (beforeMessageId lands on the next core restart — held deliberately: a restart replays the room log until #242 consumer cursors land). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): transcript times in the VIEWER's timezone + genome panel goes two rows of four Time: formatTimeOfDay was hardcoded UTC ('4:36' at Joel's 11:36 PM — wrong for every human off-meridian). Now local getHours/getMinutes; determinism moves to the test scripts (TZ=UTC pinned in chat-view + web package.json) instead of being baked into the product. Genome: 8 slots in a 4×2 grid (was one row of 4) — the loadout is heading past four as skills go per-domain and expert granularity (#226) lands; slots stay honest-dark until genes page in, top-8 lit with overflow named in the tooltip. Tests 59+21 green, typecheck clean, rebuilt. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): genome-click anchor re-lands after layout settles — the card sticks at the pane top Verified with a headless click receipt: the genome block DOES open that citizen's persona-home tab anchored at the #genome card (element navigation, card 95844639), but the single scrollIntoView fired before avatar-image decode / meter layout settled — the card drifted ~400px down-pane, reading as 'nothing happened'. Two follow-up rAF re-lands pin it. Harness note: headless clicks were steering the LIVE view — the harness shared Joel's ?me= citizen (nav focus is per-citizen, server-side). Minted a dedicated harness citizen (~/.continuum/ui-test-id); future interaction tests use it, never the operator's scope. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(nav+web): persona selects OPEN durable tabs (never swap) + sender names link to profiles + history-trigger guards Three live reports from Joel, one slice: 1. ONE shape-shifting persona tab: the nav reader derived the persona tab from the single current focus — selecting a second persona REPLACED the first. NavFocus now keeps the citizen's open non-room activity SET (activity == room == tab: a persona select OPENS a durable tab, a second select adds a SECOND tab) + a close() for the future nav/close verb. Reader surfaces every open activity. 9 nav tests green. (Core-side — live at the next core restart.) 2. 'History load failed: chat/poll rejected: unknown error' on persona click: two stacked bugs — the persona home OPENS at scrollTop 0 which tripped the transcript's near-top history trigger (now guarded off all non-transcript faces), and the bare-wire success check treated every response as a rejection (no success field on the raw path — only an explicit false is an in-band rejection; failures reject the promise). 3. Sender names in the transcript now open that citizen's profile — the SAME composed roster LISTING_SELECT the tiles fire, one nav verb, no parallel route. Keyboard-accessible, element-link affordance. Web 21/21, typecheck clean, rebuilt. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(nav+airc): tab close wired end-to-end + consumer cursor kills the reboot replay (#242) Tab close (Joel: 'tab close not wired yet' + 'super small hitbox'): - core: nav/close verb — removes one open activity from the citizen's tab set (NavFocus::close), clears focus if it was current, publishes nav:changed. Registered + in NavModule::commands(). 12 nav tests green. - web: the × is LIVE on non-room tabs (rooms are membership, not tab state) — composed NAV_TAB_CLOSE → widget → injected nav/close over the raw-wire seam; substrate-truth removal, no optimistic local state. Hitbox grown to ~22px square (padding + negative margin — glyph stays compact, target meets the pointer minimum). Consumer cursor (#242 — 'chat still loading literally every message in existence when you reboot', bitten 3× today): the attach stream asked for AttachStart::FromTranscriptStart on EVERY attach. Now a per-channel IpcCursor watermark persists under ~/.continuum/state/; attach resumes AttachStart::After(cursor) (gap only, no seam duplicates), advances to the daemon's RoomTip after attach, and persists AttachCursorAdvanced frames. Only the first-ever attach (no watermark) seeds from transcript start — once per state dir, never per reboot. Documented trade-off: a hard crash loses a slice of LIVE perception, never storage — the durable transcript + scroll-back serve history; replaying the log into every persona's mind each reboot was the worse failure. Live at the next core restart (which will be the LAST replaying one). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(web): durable-store hydration + Activities rename + rooms-only facet default Post-cursor reality check (Joel: 'No messages yet — say hello' after the reboot): the live projection now honestly starts AFTER the consumer watermark, so a rebooted room painted empty — the data was never gone (the durable transcript held every message; chat/poll served it), the window just never pulled it. Fix: a sparse first snapshot (<10 rows) auto-pages the LATEST stored window via the anchor-less chat/poll and prepends — the Twitter model complete: durable tail + live wire, one transcript. Verified live: 51 rendered rows from 1 wire message. Also per Joel: - the left rail's Rooms widget is now titled ACTIVITIES (they are rooms; the widget lists activities) — title flows from the projection. - the facet defaults to [Rooms]: open persona/content tabs are real activities but reached via their own controls (roster tiles, the tab strip) — the 'rooms' facet now excludes persona/content groups, and All remains one click away. Web 21/21 + chat-view 59/59, typecheck clean, rebuilt. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): 'Send failed' on every SUCCESSFUL send — only explicit success:false is a rejection Same response-shape bug as the history handler, now on the send path: chat/send's success payload is {eventId, messageId} with NO success field, so `!result.success` threw 'chat/send rejected: unknown error' while the message actually landed on the wire (glass-boxed live — Joel's 'How are you, I am Joel' arrived as peer-a5ded599 despite the strip). Failures reject in the transport; in-band rejection = explicit false. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(positron): projection hydrates from the durable transcript — the SUBSTRATE owns room fullness, never the renderer Joel's charge, accepted: 'why was the room history cleared? that's invalid positron — are you coding just regular lit?' The old full-backlog attach was secretly the chat projection's ONLY hydration mechanism; killing the replay (#242) starved the accumulator, and I patched it in the WIDGET — app-level durable-state logic, the inverted shape. Correct shape, now built: positron_source::spawn takes a durable seed (executor + bootstrap room). Before folding live events the projector hydrates its accumulator with the room's stored tail (the same chat_messages query chat/poll serves), pushed through the SAME classify path as wire events — one message semantics, two sources. Data-module warm-up is retried; a seed that never comes degrades to wire-fed-only, logged loud. Every client gets a full room with zero client logic. Also: WebSocketTransport discriminates push frames from replies — the ingress fans state envelopes to command-only sockets, which spammed 'reply for unknown correlation id undefined' 22× in Joel's console while every command actually worked. id-less frames are pushes, ignored; the server-side fan-out fix is a follow-up card. positron_source 16/16, sdk + web green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * revert(airc): consumer cursor OFF until it ships as one unit with perception hydration (#249) The cursor (#242) starved MORE than the UI window: glass-boxed live — Asha's turn prompt was a system prompt + ONE EMPTY user message, and Benchy answered Joel's direct question with 'you haven't provided any context'. The perception substrate (channel digest) drinks from the same cursored bus, so personas were left conversationally blindfolded: minds intact (engrams verified — Asha 11,667 rows, Atlas 10,035, writes minutes old), sensory feed empty. The greeting loop was the honest response to an empty world. Rollback: attach returns to FromTranscriptStart (full replay — the known, working behavior), watermark files deleted. The projection's durable seed (44a8b2606) stays — it is correct independent of the cursor. The cursor relands ONLY together with #249 (perception-tail hydration from durable storage), tested against a live persona turn BEFORE deploy: the lesson is that the replay was load-bearing for TWO consumers, and I verified only one. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): auto-scroll tracks READER INTENT, not bottom-distance — the position heuristic silently killed pin-to-bottom Joel: 'you designed it dumb, we did this before — you have to keep track of whether they scrolled up themselves.' Correct. The _wasNearBottom threshold died the moment a tall message grew the bottom-distance past 150px — after which every new message grew it further and auto-scroll never returned. Replaced with intent: a USER scroll away from the bottom parks auto-scroll; returning to the bottom re-arms it; programmatic pin-to-bottom scrolls are guarded out (_autoScrolling) so they never read as intent. Stream deltas (_typing) now also pin, so the token rail stays in view. Web 21/21, typecheck clean, rebuilt — reload to pick up. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(web): code is SHOWN, not hidden — line-numbered open-by-default code cards + fence-aware digest Joel: 'the code should have line numbers and show where its placed into code context like you do… i feel like for BOTH persona and humans we show it unless its huge.' Three fixes, one policy (show the start, expand for the rest, same rule at every density): 1. Renderer (parts.ts): blocks ≤40 lines render fully open (the old n<=3 collapse hid a 4-line snippet behind a '▸ RUST' bar); bigger blocks show the first 25 lines with a '+K more lines' expander whose gutter numbering continues seamlessly. Every block gets a line-number gutter. Templates whitespace-TIGHT — the pretty-printed newlines inside the pre-wrap bubble were the giant-empty-padding bug. 2. Digest (messageDigest.ts): fence-aware. Flood bounds now count each fenced block as ONE projected line (the code card self-truncates, so code can't flood pixels), and the head cut treats fences as atomic — live bug: the digest cut Claude's wordstats reply MID-FENCE and the dangling ``` rendered as literal backtick noise. 3. Specs: 3 new regressions (never-split-a-fence, whole-fence-in-head, unterminated fence) — chat-view 62/62, web 21/21, verified live in cambriantech (Asha's 2-liner open+numbered; Claude's 16-line card). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): retire the typing bubble on the settled message, not only on the done delta The stream-end contract had ONE signal (delta.done) and no fallback: a dropped/raced done flag left the cursor blinking forever over a message that had already landed (live 2026-07-30: Atlas + Benchy both looked hung after their turns settled). The settled post IS the ground truth that the stream ended — willUpdate now diffs new-arrival senders on every state change and retires their bubbles. done still works for the common path; this makes the stale-cursor state unreachable. Act pauses mid-turn still show a cursor (real work, no visual vocabulary yet) — that rendering is #254/#253 core-side work. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(cognition): FAIL LOUD on a starved prompt — never deliberate on a blank mind The 2026-07-30 outage mechanism, made impossible to miss: when window arithmetic (reserve + tool schemas + framing) squeezed msg_budget to ~0, the fitter's last-resort arm emitted ONE EMPTY user message and every persona greeting-looped for an hour while looking alive. Two guards now: 1. Fitter (delib.prompt.empty): a trimmed tail that comes back EMPTY is refused with an error probe carrying the budget arithmetic — never an empty ChatMessage. 2. contribute() (delib.prompt.starved): a view whose conversation is all empty while the room HAS turns skips the turn with an error probe — the room's messages stay queued, the next tick re-perceives; blind deliberation is never an option. The two verdict tests that broke were silently EXERCISING the bug path — ctor-default window, framing starved msg_budget to 0, scripted adapter masked the blank prompt. They now run at a real 32k window and test what they claim. 21/21 llm_deliberation green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(vitals): cognition compass AFTERGLOW — 6/s decay so the mind's glow is visible between turns + lowercase brand title DOM probe (.gymtool/vitals.mts, the new TS hot-path instrument) caught the wiring working — Anwen mid-turn: Reason 19, Recall 80, Act 16 — for exactly ONE 2s radiator sample before the 40/s decay blacked it out. With turns minutes apart the compass read as permanently dead (Joel: 'cognition not wired into the diamond' — it WAS wired; it was invisible). Decay 40/s → 6/s: a full pulse now eases to dark over ~17s — a readable afterglow of what the mind just did, still honestly dark at rest well inside a minute. Decay test re-pinned to the new contract (82 at 3s, 0 by 20s). Also: brand is always lowercase — <title>continuum</title>. Findings logged, not changed here: QUE pegged at 100 on every row is HONEST — staged digest unread never drains (personas never advance bookmarks, #43's territory); genome slots dark = honestly no genes paged in. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(airc): RE-LAND consumer cursor on inbound attach — resume from watermark, never replay the whole transcript (#242, exonerated) Joel on tonight's boot storm: 'why would it replay the whole chat start to finish? its insane.' It replayed because the bus-fed transcript writer needed boot-time replay to fill the offline window — full replay was load-bearing by accident. The cursor (attach After(watermark), persisted per room) delivers exactly the missed window: no storm, no holes. This is a byte-identical re-land of d4dbc9982, which was reverted during the 2026-07-30 outage on the theory it starved persona perception. The deep trace EXONERATED it: perception pulls the daemon's durable tail every turn and never consumed the attach replay; the blank minds were the spawn-pinned window budget bug — since fixed (live-window reconcile) and guarded loud (delib.prompt.starved / delib.prompt.empty error probes). Verification protocol this time, per the incident doctrine: live persona capture non-empty + zero starved probes + quiet boot + transcript continuity, BEFORE calling it done. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(positron): renderer frames coalesce at 10Hz + 100-message window — bursts become beats, not storms Joel: 'if i were me, i would see like the last 100 messages, and scroll for more — positron ought to make this easy.' Two changes, one contract: 1. Subscribed renderers no longer forward EVERY revision (Unlimited). State kinds are latest-wins snapshots on a watch channel, so intermediate revisions are legally skippable — RENDERER_HZ=10 sends the first change instantly (lone message: zero added latency) and coalesces bursts to at-worst 100ms behind. The boot-replay load storm (thousands of folds → thousands of socket frames raining into the tab) becomes ≤10 latest-state frames/sec. Token streams ride the separate stream rail, untouched. 2. Snapshot window 50 → 100 (MAX_MESSAGES_PER_SNAPSHOT), seed query bound to the same constant — one source for the window size. Scroll-back keeps paging older history from the durable store. With the attach cursor (f8e4ae6cc) this closes the storm class: resume from watermark delivers only the missed window, and whatever bursts do occur render as a handful of coalesced frames. positron 105/105+5/5, core positron_source 16/16. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(live): turn-start beacon → 'responding…' under the last message + dynamic lowercase title + continuon favicon Joel, during the dead-looking-interface scare (four minds mid-turn, zero pixels moving): 'in other systems it says XYZ is responding — we could use that right below the last chat item.' Three pieces: 1. Core: the token forwarder emits ONE empty-token START BEACON the moment generation dispatches — before prefill, which on a cold lane runs minutes. No wire change: an entry with no text yet IS the signal. The done flush retires it even on a speechless settle. 2. Web: a typing entry with empty text renders 'responding…' instead of a bare cursor (the bare cursor was the hang-look); text flowing keeps the live tail + cursor. 3. Web: document.title mirrors the current activity — 'continuum — cambriantech' (the #252 short-title rule, brand always lowercase; the static <title> edit finally ships too — it was edited but never rebuilt into dist, my miss). Favicon: the continuon orb becomes the subject (it IS the fourth-wall being), ring as threshold. Web 21/21 + rebuilt; core cargo check clean. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(web): '(xyz, abc) is responding…' — ONE grey line between the last message and the compose box Joel's exact spec, third iteration tonight: not a transcript bubble — the Discord-convention grey status line pinned above the composer, one line max (nowrap + ellipsis), parenthesized dynamic name list that updates as turns start and settle. Driven by the stream map: the #254 start beacon adds a persona the moment their turn dispatches — minutes before the first token on a cold lane. Beacon-only entries (no text yet) no longer render an empty bubble; streams with real tokens keep the live bubble as before. Web 21/21, rebuilt — refresh to pick up. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): STOP KILLING LIVE STREAMS — retire a typing bubble only on ITS OWN settle, and never hide a consecutive speaker's stream The streaming regression Joel caught ('did you just totally remove it'): the stale-cursor fix retired a persona's bubble on ANY arrival from them. With settles landing minutes late and reboot-echo dups landing constantly, delayed OLD messages executed LIVE bubbles mid-stream — streaming was functionally deleted. Retire now requires the arrived content to CONTAIN the streamed tail (it IS the settle); beacon-only entries are never retired by arrivals. Also removed the last-sender bubble suppression — a persona speaking twice in a row is normal, and the skip hid exactly the streams being watched for. done-flag retirement unchanged. Web 21/21, rebuilt — ONE refresh. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): '(X) is responding…' clears when the answer lands — beacon-only entries retire on any arrival from their sender Joel, live: 'it didnt go away once responded.' Some settles never stream rail tokens, so the entry stayed beacon-only and its only exit was a done flush that never came. Beacon-only entries now retire on ANY arrival from the sender (a still-running turn's next token recreates the entry instantly — nothing lost); text-bearing entries keep the own-settle content match so delayed old messages can't kill live streams. Line lifetime == inference in flight: appears at generation dispatch, clears at settle. Web 21/21, rebuilt. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(web): responding line = the PROMISE phase only — a name drops the moment their words visibly stream Joel: 'if it is responding stop showing it, for that user — it's when we are sure they're gonna respond, then you can show it.' The grey line now lists only beacon-only entries (inference dispatched, nothing visible yet); once tokens stream into a persona's bubble their name leaves the line. Complete lifecycle: dispatch → '(X) is responding…' → words stream in the bubble → settle lands → everything clears. Web 21/21, rebuilt — refresh. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(web): dormant minds dim — roster rows recede when every cognition pulse is dark, brighten on any pulse/stream Joel: 'dim the entire row slightly in the user list.' A row with vitals wired but zero across focus/reason/recall/act/speaking is a resting mind: opacity 0.62 with a 0.9s ease, so waking is VISIBLE and the ~17s afterglow keeps recently-active minds bright — row brightness reads as recency of thought. Opacity-only (compositor-cheap); the dim treatment is the interim for #260's full presence lifecycle, where the universe/ theme layer owns the inactive look. Members without vitals (plain agents/humans) never dim on this signal. Web 21/21, rebuilt — refresh. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(tests): pin TZ=UTC in the four time-asserting specs — CI-deterministic on any runner PR #2057 review blocker: formatTimeOfDay became viewer-local (by design) but four specs still asserted fixed UTC HH:MM strings — red on any non-UTC runner. The formatter stays viewer-local; the specs pin process.env.TZ before imports. Proven under TZ=America/Chicago and TZ=Asia/Tokyo: chat-view 62/62, web 21/21. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * fix(airc): close #261's SKIP hole — attach never pre-persists the room tip; the daemon's cursor heartbeat is the sole watermark writer Both PR #2057 review findings on the cursor re-land, fixed as one mechanism with airc 9390c32e8 (feat/attach-cursor-advance-heartbeat): 1. SKIP hole: the attach-time room_tip probe persisted a cursor for events not yet processed — a daemon Error frame or transport read error mid-backlog resumed PAST the tip, permanently skipping the unprocessed remainder from live perception. The probe is deleted. 2. Whole-session redelivery: the daemon's AttachCursorAdvanced now rides live streaming (throttled 1/s), so the existing persist arm — previously fed only once at the coalesce seam — advances the watermark continuously. Every advance points at an ALREADY DELIVERED event: resume is always at-or-before what this consumer processed. No skip, and the reboot redelivery window shrinks from the whole session to ≤1s of events. inbound_attach 8/8. Deploys with the rebuilt airc daemon binary; verification protocol: reboot twice, zero duplicate persona messages, watermark file advancing during live traffic. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * chore(airc): airc.cursor.advanced probe — every watermark advance gets a receipt The #261 verification found a silently-stale watermark with no way to distinguish 'heartbeat frames never arrived' from 'persist failed quietly' — the arm logged failures only. Glass-box: success needs receipts too. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(cognition): predictive [settled] fact + room-speech ring — name the echo BEFORE it is born (#264) Glass-boxed live 2026-07-30: after the conway task completed, the room spent 40+ minutes in a full-room chorus — one sentence emitted verbatim by all three personas in sequence (specimen on #16/#259). The existing repetition facts are retroactive: they fire the turn AFTER the echo, one turn too late to prevent it, and closure statements re-trigger peers because a closure is still a new message. The room had no rest state. Two pieces, both precedented: 1. inbound_restates_fact — the PREDICTIVE member of the repetition family: fires when the NEWEST inbound peer message restates something already said (older visible turn, her own-speech ring, or the room ring), rendering "[settled] X's newest message restates what has already been said here … silence (PASS) is a normal response" BEFORE she replies. Same near_identical_substantial geometry as every other repetition axis (one definition), registered in the perception_facts registry (probe + A/B toggle for free). 2. record_room_speech / recent_room_speech — the room-side sibling of the #148 own-speech ring, and the same starvation fix: with live workspace windows of 2-6 turns, the older copy of every restatement had already scrolled out (verified: 0 fires across an entire live chorus until the ring landed). Recorded ONCE per message at the airc inbound-attach projection seam; the fact drops exactly one byte-exact copy so a message never matches its own record while a genuine re-send still fires. Live receipts post-deploy: perception.fact id=inbound_restates fired=true on all four room personas (one organic fire on their own chorus before the controlled probe ran); [settled] rendered in prompt captures; first fact-bearing tick redirected one persona from echo to a tool call. Behavioral compliance is partial by design — the fact names the fork, the mind chooses; sticky silence (the #264 scheduler half) is the follow-up. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(presence): durable room directory — grid citizens are grey when unreachable, never gone (#258/#262) Joel 2026-07-30: "Why won't bigmama's persona ever show up? Feels like you guys don't understand the goals." The goal is ONE directory per grid with cumulative citizens — a client that is a window into the whole grid. The implementation conflated membership with presence: the roster was rebuilt every 2s from a 120-second live window, so any citizen silent for 2 minutes ceased to EXIST. BigMama's citizens (Kimi, Sahar) were perpetually unborn on this node whenever their flaky relay dropped — existence gated on a live transport session. Fix — membership is durable, presence is live: - Per-room directory persisted at ~/.continuum/state/room-directory-<room>.json: every RosterSlotView ever projected, folded on each emit, seeded at boot by ONE deep transcript scan (14d/4000 events) so members whose last event predates the live window exist from the first publish. Steady-state daemon load unchanged (the 2s poll keeps the shallow window). - Published roster = live read ∪ remembered members as `active: false` ghosts with stale liveness signals (availability/vitals) cleared — the interface never lies about liveness (#260). Client renders ghosts dimmed via the existing `.member.idle` path: zero wire change, zero client change. - Identity adopted once: a real display name never regresses to the provisional peer label on a card-less sighting. - Persistence is the loop's concern, not emit_once's — tests stay disk-free (the #7 isolation lesson). Verified live post-deploy: presence.directory.seeded remembered=8 — ALL grid citizens recovered from the daemon transcript including Kimi (e2f0e022), Sahar (df72dbf2), and BigMama's agent (ce8b9074) while their node's inbound relay is down; web roster renders 8/8. Their names stay provisional until their card publish crosses (#262, their side) — and will be adopted permanently the first time it ever does. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LoTjvf5j3Ez13g6k8mRkFo * feat(identity): publish every persona's airc identity card at birth — no more info-devoid citizens (#262/#248) Joel 2026-07-30: "Neither my user, all her persona, and you have any bio info, which should come over airc… devoid of all info persona." He was right, and the miss was pure wiring: the card system existed COMPLETE on both sides for months — airc's set_local_identity_card persists + broadcasts to every subscribed room, whois renders name/pronouns/role/bio, role_template carries hand-authored bio_templates in each role's voice, and the durable PersonaCard at birth holds name/gender/pronouns/role — but not one continuum path ever called publish. Every persona attached as a bare display name. Fix, at the single birth path (birth_one, right where the durable card is already read for avatar/voice registration — wire identity coheres with presentation identity by construction): - name from the card; pronouns from her presentation spine (profile facet override wins); role tagged continuum-persona-<role>; bio from her role's authored bio_template ({name} substituted), profile "bio" facet overriding; cards minted before role threading get an honest generic bio instead of silence; continuum_persona_id in integrations for cross-system binding. - publish failure is a warn + next-boot retry, never a birth-killer; success fires persona.identity.published. Verified live: probes for all four personas; airc whois now returns identity: published with name + pronouns + role + bio fo…
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
🤖 Generated with Claude Code
Description
Please include a summary of the changes and which issue is fixed. Please also include relevant motivation and context.
Fixes # (issue)
Type of change
Please delete options that are not relevant.
How Has This Been Tested?
Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce.
Checklist: