First launch on an alt profile SETS ITSELF UP: a launch whose account root is MISSING runs the one-shot `alt init` itself and proceeds, and the account name defaults to "alt" — the user is never asked to run a binary command. Request BigscreenVR/claude-spt-bs#15 (requester discord:reavo, 2026-08-22): v0.29.0 shipped `claude-spt alt init <account>` as a user-facing setup step, but a user launching the shipped `claude-spt:alt` profile has no straightforward path to the `claude-spt` binary (it lives in the adapter dir, not on PATH), so asking them to run it is unacceptable — setup must happen automatically on the first launch of an endpoint via the alt profile. THE FAST PATH IS PRESERVED, which is what keeps this compatible with the ADR-0010 rejection of per-launch maintenance (the ccs cost this feature exists to remove): init runs at launch in EXACTLY ONE case, Preflight::MissingRoot — every launch after the first pays only the preflight stat it already paid. A FAILED auto-init fails the launch loudly and names `claude-spt alt init <account>` as the manual repair (the observation is reported, not a diagnosis); a successful one falls through to the normal credential preflight, so the first launch ends at Claude Code's own login prompt exactly as v0.29.0 documented. The default account name "alt" is a shared constant with the shipped profile's literal `--account alt`, so `alt init` bare and the profile agree by construction. The manifest is UNCHANGED — the shipped profile already bakes `--account alt` into every role's command; what this removes is the human step, not a profile knob.
       Every /clear boundary on an spt-hosted endpoint RE-ASSERTS the session display name (the boundary rename): CC drops the `-n "<id> @ <node> (<project>/)"` display name when a clear rotates the session, leaving the operator no rendered TUI anchor. The launch shim exports the computed display name as SPT_SESSION_NAME into the spawned CC env (single computation site — the same string that feeds `-n`, parity by construction); the SessionStart hook, on a `clear` boundary, self-sends {"rename":"v1","name":"<display name>"} --force-native BEFORE the {"checkpoint_fire":"v1"} signal; the translation binary STASHES the name on the rename delivery (answering the mandatory bare {commit}) and emits the rename keystrokes as the FIRST HALF of the fire's ONE COMBINED post-clear sequence (ctrl+s . 50 . `/rename <name>` . 50 . enter . 150ms enter->ctrl+s bridge . ctrl+s . 50 . wake . 50 . enter . commit) — REVISED v0.15.1: the original design emitted rename and wake as two back-to-back inject sequences, which RACED at the just-rebuilt post-clear boundary (CC input processing lags the PTY stream; the rename's enter registered as a soft newline, the next sequence's ctrl+s failed to stash the residue, and the wake text submitted INSIDE the /rename argument — flynn 2026-07-06, session titled with the wake, NO wake turn, agent dormant ~9.5h, ~33% observed rate). The single sequence removes the inter-sequence race BY CONSTRUCTION; the stash NEVER touches pending wake. Ordering: rename submits before any armed wake fires (/rename is a local no-turn CC command — empirically confirmed 2026-07-05: inline rest-of-line arg, renames the CURRENT session, no agent turn). Missing SPT_SESSION_NAME (pre-0.14.1 spawn, non-shim spawn) => the hook SKIPS the rename send with a loud RENAME_SKIP:no-name log line, never silently; heals on respawn. /compact RETAINS the name (empirically confirmed 2026-07-05) so the compact boundary sends nothing — the existing no-send invariant stands. A rename envelope with a blank/absent name answers a bare {commit} (REQ-HAZARD-EMPTY-RESPONSE-COMMIT discipline), never a stray `/rename ` submit.
       Perched sessions are steered to BACKGROUND long-running work so the perch stays reachable — the spt reachability notice, ported from legacy owl's <owl_reachability_notice> (sibling claude_skill_owl hook_prompt.rs + hook_check.rs) and renamed to spt semantics (<spt_reachability_notice>, 'active spt perch'). Two injection sites, both perch-gated (a plain CC session is never told it has a perch): (1) UserPromptSubmit — EVERY perched turn's additionalContext closes with the general notice ('when spawning subagents or running long tasks, use run_in_background: true so you stay reachable for incoming messages'), appended AFTER any skill injection + drained messages (a notice never displaces a delivery); (2) PreToolUse — when the tool about to run is a subagent spawn (tool_name Agent, or its older payload name Task — matched both ways so a CC rename in either direction keeps the nudge alive), the targeted launch-this-in-background nudge rides the same emit, messages first, nudge last, and emits EVEN when the drain is empty (the point is catching the foreground spawn before it happens); and (3) PreToolUse — when the tool is `Bash`, `run_in_background` is not true, and the call is LONG-RUNNING by its own declaration (an explicit `timeout` of 60s or more) or by command shape (cargo, npm/pnpm/yarn, gh, pytest/jest, make, cmake, docker, sleep, `find`, `rg`, recursive `grep`), the same nudge rides the emit with a Bash-specific body — CAPPED AT THREE PER TURN (operator's number), the counter reset by each UserPromptSubmit, so the steering is early enough to shape the turn without becoming wallpaper. and (4) PreToolUse — when the tool is a BLOCKING read of a background task's output (`TaskOutput`, its spaced display spelling `Task Output`, or the `BashOutput` sibling — matched all three ways, the same defence against a CC rename the spawn matcher makes), the same nudge rides the emit with a task-output body: backgrounding a task is HOW a perch stays reachable, and then blocking on that task's result spends exactly the reachability the backgrounding bought, while the poll is also unnecessary (completed background work re-invokes the agent on its own). The task-output arm DRAWS ON THE SAME per-turn budget as the Bash arm — ONE shared cap across every capped nudge kind, because the wallpaper the cap prevents is a property of how much a turn says in total, not of any one kind; a polling loop is the exact shape this steers, so a per-kind budget would have leaked the most noise precisely here. The uncapped spawn nudge does not draw on it. Tools that are neither a spawn, nor long-running Bash, nor a blocking task-output read stay silent with an empty drain. Both ride the existing once-capped emit (spill guard unchanged). ADVISORY ONLY, deliberately: PreToolUse returns `additionalContext` and the tool runs anyway, so a nudge cannot convert the call it fires on — only the next one. Deny-and-steer (PreToolUse denying the call so the agent re-issues it backgrounded) is the only lever that would convert the current call and was RULED OUT by the operator 2026-08-04. This buys coverage, not enforcement. WHY (field, 2026-07-07 operator): every claude-spt agent ran subagents/long tasks in the FOREGROUND, going unreachable for the task's whole duration — the legacy-owl notice was the missing steering pressure. WHY THE BASH ARM (2026-08-04 grill): both legacy-owl legs were already ported and shipped, so the honest finding was not 'the feature is missing' but 'the feature does not cover the common case' — long foreground Bash (cargo, gh, test suites, recursive greps) is the ordinary way a perch goes unreachable and fired NOTHING. Observed in the grill session itself: a foreground `grep` blocked 120s and the harness backgrounded it, with the general notice already in context and no targeted nudge existing for that call.
       Subagent working perches follow the WORKER-TRUTH wave-1 contract (spt-core v0.27.0, doyle freeze 2026-07-06) and NEVER leak silently. SubagentStart (parent context) calls `api worker-start <parent> --session-id <parent sid> --agent-id <cc agent id> --agent-type <type>` — NO worker-id positional (core hard-mints `{parent}-w{N}`), NO token (operator ruling: sid-symmetric auth, registration stores the sid, stop accepts stored OR parent-current sid — /clear rotation covered from both ends). The MINTED id is read from worker-start's BARE STDOUT (machine-readable result; empty/refused = LOUD log, never silent) and persisted in adapter-owned state keyed by the CC agent_id (state/worker/<agent_id>.wid — the SubagentStop payload carries only the CC agent_id, so the mapping is the adapter's to hold; same contract-clean carrier as the F-024 sid proof). SubagentStop looks up the minted id and calls `api worker-stop <minted-id> --session-id <parent sid>` STRICTLY: a refusal is LOUD (stderr reason surfaced — the pre-0.27.0 silent-swallow leaked 100% of workers, the 2026-07-06 six-worker leak), a missing mapping is LOUD (WORKER_STOP_SKIP breadcrumb), and the state row is cleared on success. Missing agent_id on either hook = LOUD skip, never a silent no-op. Floor: min_spt_core 0.27.0 (older cores clap-reject the id-less worker-start — the doyle-accepted skew; core's registration-time floor enforcement guards the reverse direction).
       The session carrier (state/session/<eid>.sid) never advances past a FAILED strict registration. Pre-fix, handle_session_start persisted the current sid on EVERY SessionStart even when the bind/boundary spt_strict call was refused (error only logged) — which (a) poisons the NEXT rotation's auth proof (the perch still records the PRIOR sid, so the next boundary presents a sid the perch never accepted → AUTH_REFUSED → stranded perch, the F-024 class reached via carrier skew) and (b) would let the verified-identity fast path (REQ-UPS-IDENTITY-FASTPATH) trust a session the perch never bound. INVARIANT: carrier(eid, sid) is authoritative only when written immediately after a SUCCESSFUL strict bind/boundary registration this SessionStart; on failure the carrier keeps the prior sid (still the true proof for the retry). The seed leg (no endpoint id) never writes. 2026-07-10 UPS-timeout RCA prerequisite (hertz), converged 2026-07-15.
       The drop detector examines each drop AT MOST ONCE PER IDENTITY and arms at most once: state/commune-seen/<eid>.stamp records the LAST EXAMINED identity (<mtime_ms>:<len>), an unchanged identity is a no-op that does NOT read the file, a changed or missing stamp triggers read-scan-arm-and-restamp, and drop absence clears the stamp. HAZARD INTRODUCED BY REQ-COMMUNE-DROP-DETECT, and it is a shape change rather than a detail: the old trigger was an EVENT (one Write tool call, observed once by construction), the new one is a STATE (a file that persists until core ingests it, >15s and many tool calls later), and every state-shaped trigger re-fires unless something remembers. Without the stamp the detector arms on EVERY hook for the whole ingest window - a second wake-arm self-send, a rewritten clearing latch, and ultimately two post-clear sequences, which BLEND rather than fail loudly (the v0.14.1 boundary-rename scar: never emit two post-clear sequences). The stamp records EXAMINED rather than ARMED deliberately: a commune with no wake marker is the common case, and recording only arms would re-READ a 20-100KB file on every tool call for 15 seconds while never arming. Both halves are load-bearing and both get a test - an arms-exactly-once test and a stat-not-read test asserting the cost model, since a detector that is correct but re-reads is a regression nobody would notice. EXTENDED 2026-09-06 (v0.38.0) TO A SECOND SOURCE: with REQ-COMMUNE-FRAME-BACKSTOP the same drop can be seen TWICE - once on disk before ingest, once as a COMMUNE frame after - so the frame leg stands down whenever a clearing latch is already armed. One drop, one boundary, whichever leg saw it first.
       The digest extractor's projects-root chain is SESSION-AWARE and never silent: it walks the precedence rungs (--config-dir capture → $CLAUDE_CONFIG_DIR env → legacy --in → ~/.claude/projects) and uses the first rung that actually CONTAINS the requested session's transcript — a rung that resolves to a real directory without the session must NOT end the search. When no rung holds it, the extractor says so on stderr (roots tried + session id) instead of exiting 0 with empty stdout. Rationale (field 2026-07-25, perri): the perch's bind-time {CLAUDE_CONFIG_DIR} capture is STALE the moment a later session boots under a different config root (a ccs-captured `~/.ccs/instances/<acct>` perch re-bound by a plain `~/.claude` session). The old first-rung-wins chain pointed the locator at the ccs tree, found no <sid>.jsonl, and returned empty-and-quiet — so the endpoint's digest carried spt-injected Context rows ONLY, its newest Agent entry frozen at the pre-reboot session, with no error anywhere on either side. Every digest consumer goes blind together: peers reading the endpoint, the Psyche's context sync, and any tool whose control channel is the digest (rebound's `!!done!!`/`!!wait=m!!` codes were unreachable for the whole session).
       The psyche host's resident loop is PACED and TERMINAL on persistent instant cycles: a healthy iteration blocks (perch poll or a real claude turn); when iterations complete sub-2s repeatedly (claude dying at spawn — the F-h untrusted-cwd trust prompt — or a thrashing poll), the host backs off exponentially (500ms doubling, 5s cap) and after 8 consecutive instant cycles exits LOUD + NONZERO (PSYCHE_HOST_GIVE_UP stderr, exit 3) so the wrapper DEATH becomes visible to spt-core's psyche_host_error/residency machinery — a silent internal loop is invisible to it (field: ~3 boots/sec for 30min, ordinal 5358, F-h). Threshold coupling (doyle-ruled): core's C3(b) backstop trips at >=10 ledger boundaries/60s; for the pure instant-death class this guard fires FIRST (<=8 boundaries, <60s wall clock); failure modes that dodge the streak (just-over-threshold cycles resetting it) legitimately reach the core backstop — a core trip on a guarded wrapper is correct backstop behavior, not a bug.
       A session-limit 429 must not leave an spt-hosted endpoint stuck ACTIVE with the limit banner read as agent activity. When a turn ends on the account session limit, CC files a SYNTHETIC assistant message (model `<synthetic>`, `isApiErrorMessage: true`, `error: rate_limit`, text `You've hit your session limit · resets <time>`) into the transcript; the digest extractor renders it as an ordinary `agent` record, so the endpoint's digest shows an `Agent` entry on the latest turn. The interrupt watcher (REQ-HAZARD-INTERRUPT-STUCK-BUSY fix 3) reads any `Agent` entry as THE AGENT PRODUCING OUTPUT → 'genuinely resumed' → re-arm, never heal. StopFailure DOES fire and heal on the first limit hits, but each drained delivery re-marks busy and re-429s, and once CC stops attempting API calls for the limited session it fires NO further hook — the last delivery leaves the endpoint ACTIVE with the limit banner as its newest digest turn, and the watcher's misread makes the black hole PERMANENT: messages arriving after the limit resets can never wake it (field lia 2026-07-28, ~4h dark; the operator woke her by hand). FIX (watcher-side, the hook-independent layer): a digest turn carrying an `Agent` entry whose text STARTS WITH `You've hit your session limit` is a STUCK MARKER, not activity — (1) such a turn is never read as a resume, whatever else it carries (a real pre-limit `Agent`/`ToolSprint` entry on the same turn must not defeat the heal — the same misread class as the lia echo_mirror RCA); (2) a limit marker anywhere in the scan window with no real agent activity on the latest turn heals exactly once (mark idle via the carrier sid), sharing the interrupt marker's heal-once latch and re-arm rules. Prefix-match on the entry text START only — an agent merely quoting the phrase mid-text must not read as stuck (the false-positive direction is one idempotent idle mark, self-corrected at the next busy transition, but a start-anchored match keeps even that rare).
       Every additionalContext spill gets its OWN file — a spill NEVER overwrites an earlier one, and a new spill's pointer NAMES any earlier spills of the same session so an unread one becomes visible instead of vanishing. The spill path used to be fixed per session (one `sptc-drain-<sid>.txt`), so the second oversized delivery of a session destroyed the first: field 2026-07-25 (lia) — a SessionStart brief spilled, then a peer broadcast spilled over it before the agent read it, and the agent's identity/role/live-context/resume tail were gone UNREAD. Silent by construction: no error, no marker, nothing tells the agent it ever had a brief, so the loss is indistinguishable from an agent that was never briefed — the one failure mode nobody catches. Blast radius is wider than one message: any agent collecting field evidence through spills has that evidence silently degraded (flynn had to retract the strength of an observation given to spt-core for exactly this reason).
       The spill POINTER can never itself be the thing that goes missing: an oversized delivery is surfaced by a notice that always reaches the agent, always names a file that actually exists, and always fits under CC's additionalContext limit. Three routes make a taken message read as a non-delivery even with REQ-HAZARD-SPILL-CLOBBER's unique paths in place — (a) a FAILED spill write emits a pointer naming nothing readable while the park is committed anyway, so the body exists nowhere; (b) only the UserPromptSubmit path names earlier spills, so an unread spill is never resurfaced by the PreToolUse mid-turn drain, the highest-volume spill path there is; (c) the pointer's earlier-spills list is unbounded, so a long session's own notice grows past CC's ~2KB limit and CC silently truncates the very notice whose job is to prevent silent truncation.
       An API-error turn-end must not leave an spt-hosted endpoint stuck ACTIVE/undrainable. CC fires NO `Stop` when a turn ends with an API error (matcher error types: rate_limit, authentication_failed, billing_error, invalid_request, server_error, max_output_tokens, unknown) — it fires `StopFailure` instead. The adapter marked idle ONLY on `Stop`, so an errored turn-end never got its idle mark and the daemon spooled every inbound without draining (same black-hole class as REQ-HAZARD-STUCK-ACTIVE-NO-IDLE, reached via API error instead of a never-completed first turn). FIX: wire `StopFailure` → `handle_stop_failure` → `state idle` (self_id-resolved, sid-scoped — mirrors the `Stop` idle mark); the error_type is logged (rare event; permanent observability + Step-0 coverage instrument).
       RETIRED 2026-08-29 by REQ-IO-COMPLIANCE-DECLARED (Release B): this adapter no longer parses or dispatches shortform - spt-core does, off the ingest payloads we report, and per-target outcomes surface through the now-signal DISPATCH_RESULTS category, which core documents as the only channel by design. The evidence this requirement described has been DELETED, not merely left untagged, so the stages are cleared rather than the requirement removed: what it protected is kept here as the reasoning that has to outlive the code. ORIGINAL: A shortform peer message (`@<targets body @>`) whose BODY contains code formatting still sends, and sends verbatim. The quotation guard is POSITIONAL — it decides whether the OPENER is quoted — and must never be implemented by splitting the text on code delimiters and scanning the pieces: that put an opener and its close in different pieces, so any tag whose body quoted a command was dropped whole, with no send and no error. Corollaries the tests pin: a `@>` inside code is quoted punctuation and not a terminator (an opener whose only close is inside code still does not fire); an UNTERMINATED backtick is literal text, not an open code span (one stray tick used to swallow the rest of the message); a fenced block inside a body survives intact. Field 2026-07-25: perri's request to doyle for a ledger item — a body full of backticked commands — was never delivered, and the silence read as an unresponsive peer rather than a lost message.
       A shortform peer message emitted on a pass where the tag-scan CURSOR IS ABSENT is still dispatched. The first run for an endpoint reads the whole transcript, so pre-existing history must not be re-dispatched — but the turn being written RIGHT NOW is not history, and the pass used to return before scanning anything, swallowing any tag in it whole: no send, no confirm, no error, and an agent with every reason to believe it had been delivered. The resolution is a NARROWING, not a widening: on the initializing pass only the FINAL assistant message (this turn's own output) is eligible, everything before it stays the history it is, and the cursor still jumps to EOF so the unscanned history can never be dispatched later. Cursor-absence is not exotic: a brand-new endpoint, a deleted state file, or an adapter re-registration that moves `source_dir` — which relocates EVERY endpoint’s cursor at once, exposing the whole fleet's next tag-bearing turn simultaneously.
       The [history] transcript-access seam (the echo-commune's feeder — 'stays opaque + single-session and feeds the echo-commune verbatim', published contract) is declared strategy="fetcher": `claude-spt history --session {session_id} --config-dir {CLAUDE_CONFIG_DIR}` locates the CC JSONL transcript with the SAME locate/precedence machinery as the [digest] fetcher (--config-dir read-var fill -> $CLAUDE_CONFIG_DIR env -> ~/.claude/projects; depth-1 then bounded-recursive slug sweep) and streams the file to stdout VERBATIM — opaque bytes, core never parses them, only the adapter's own echo_commune summarizer reads them. A literally-unsubstituted `{CLAUDE_CONFIG_DIR}` argv value is treated as absent (F-013 literal-brace guard class). Missing transcript / missing --session = LOUD stderr (HISTORY_FAIL:) + exit 1, never silent-empty stdout (an empty history would silently produce a vacuous echo-commune).
       The UserPromptSubmit hook must declare its own deadline, and a hook killed at that deadline must leave evidence that it ran. TWO DEFECTS, ONE ROOT, BOTH CLOSED HERE. (1) NO DEADLINE WAS DECLARED: plugin/sptc/hooks/hooks.json set no `timeout` on any event, so Claude Code's 5s UserPromptSubmit budget applied by default - and the hook's own measured p99 is 4835ms (n=795 traces / 30.14h / 9 endpoints, HFENDULEAM archive 2026-09-10), so the adapter shipped sitting ON the line. The declared value is 20s, above the 11715ms worst total observed, on the reachability adapter's own trade: losing the inbox drain is worse than making the operator wait, and the drain is the reason the hook exists. (2) THE INSTRUMENT COULD NOT SEE ITS OWN SUBJECT: StageTrace::finish() is an explicit end-of-hook call, not a Drop guard, and an external kill runs neither - so the trace built by the 2026-07-10 UPS-timeout RCA precisely so that 'a hook approaching the external deadline names the guilty stage instead of leaving a silent timeout' emitted NOTHING for every hook that actually timed out. FIELD-CONFIRMED, not reasoned: doyle's session reported a 5s timeout while doyle's slowest surviving row anywhere in the live log was 3885ms; the timing-out invocation wrote no line at all. THE CONSEQUENCE IS A BIASED MEASUREMENT, WHICH IS THE REAL HARM: every distribution computed from these traces covers COMPLETED hooks only, so the timeout rate reads as near-zero for the same reason a wiped log reads as 'never emitted' - the same class as REQ-HOOK-TRACE-RETENTION and VALIDATE THE INSTRUMENT BEFORE TRUSTING A ZERO HIT. THE FIX IS A PAIRABLE START MARKER, NOT A DROP GUARD: a Drop impl is defeated by the same kill, so the hook logs a short BEGIN line at entry, and because each hook invocation is its own process an unpaired BEGIN pid (no TRACE line from that pid) IS a deadline kill, observable no matter how the process dies. Scoped to UserPromptSubmit: it is the only event that traces today, which keeps the pairing exact and the added volume near 60B per invocation against REQ-HOOK-TRACE-RETENTION's 512KB roll. PRIVACY IS UNCHANGED AND BINDING: the BEGIN line carries the hook name and the endpoint id only - never prompt text, never a message body - the same rule REQ-HOOK-STAGE-TIMING states for the TRACE line. NOT IN SCOPE, DELIBERATELY: cutting the three serial `spt` subprocess calls (busy/poll/now-signal, together 99.4% of the hook's wall time). That decision waits on the rate this requirement makes measurable, because deciding it on the survivor distribution would be deciding it on the biased number this requirement exists to correct. NO MESSAGE LOSS IS IMPLIED BY EITHER DEFECT: REQ-HAZARD-PARK-DRAIN-DEADLINE's transactional custody stages the drain and commits only after emit, so a kill before emit redelivers - the user-visible loss is this turn's additionalContext injection and the error line, not mail.
       claude-spt REPORTS the turn's closing output on its end-of-turn idle call, so spt-core's IO funnel publishes an AGENT_OUTPUT event for this adapter's turns. Enabling half of BigscreenVR/spt-pacer-tool#14 (requester discord:reavo), which retires pacer's bespoke agent-output detection in favour of the AGENT_OUTPUT io kind; the operator ruled the sequencing on 2026-08-28 (claude-spt first, verify a frame actually lands, then pacer). WHY IT WAS NEEDED: the io funnel shipped in core 0.64.0 and AGENT_OUTPUT rides the activity report an adapter already makes (`spt api state idle <id> --payload-stdin`), but claude-spt passed no payload at any of its eight `state idle` call sites — validated scan, 197 files, 0 payload call sites against 151 control hits — so no AGENT_OUTPUT had ever been published for a Claude Code session and any consumer of the kind was structurally deaf on this adapter. TWO CONTRACT QUESTIONS WERE PUT TO CORE BEFORE BUILDING, either of which would have invalidated the release, both answered by doyle 2026-08-28 against shipped 0.64.0: (1) a fetcher-pulled digest entry emits NO io event by itself — the emission population is exactly payload-carrying `api state` calls, the MSG_IN/MSG_OUT delivery edges, and COMMUNE/COMMUNE_FAIL — so our `[digest] strategy = "fetcher"` does not create the second event the frames page warns about (that warning targets an adapter double-REPORTING the same turn text through payload-carrying calls); (2) riding `api state idle` is transport reuse, not coupled semantics — emission is per payload-carrying call, not per transition, and payload reporting leaves activity behaviour untouched. ONCE-PER-TURN IS THE ADAPTER'S DISCIPLINE AND IT IS KEPT AS A CALL-SITE RULE: core does not deduplicate, so exactly ONE `state idle` in the adapter carries a payload — the Stop end-of-turn mark. The other seven (receive-heal, Notification(idle_prompt), bringup bind, compact/clear) are healers and lifecycle marks, not turn ends, and a payload on any of them publishes a phantom AGENT_OUTPUT for a turn that never happened. WE DO NOT TRUNCATE, deliberately: bodies cap at 16 KB and core cuts a longer one on a character boundary and stamps `truncated="1"`, which is the entire mechanism by which a consumer learns to follow `seq` to the digest for the remainder. Cutting adapter-side to stay under the cap would deliver the same bytes with the truncation flag ABSENT — a silent loss wearing the shape of a complete payload, the same lossy-copy-invisible-at-the-far-end class as the dropped envelope attributes (REQ-EVENT-ATTR-PASSTHROUGH-RENDER). Core's cut is announced; ours would not be. ACCEPTED GAP, recorded not worked around: the across-clear quiet window returns before the idle mark, so a commune-across turn publishes no AGENT_OUTPUT — that turn ends in a `/clear` and is rebuilt from the commune. OUT OF SCOPE, deliberately: the USER_INPUT payload on `state busy` (nothing consumes it yet, and a second payload seam is a second once-per-turn discipline to keep), and `[io] compliance = true`, which declares this adapter's own tag parser deleted so core may parse our ingest for shortform — tag_scan.rs is live and shipping, and the published rule is to declare compliance in the release that removes the local parser, never before. FORWARD FLAG (releases#238, operator-ruled backlog): core will add framed emission of mid-turn digest entries with inline payloads and will respecify the dedup discipline and amend frames.md/patterns.md in the same change. A release built to today's contract stays correct; the design consequence taken NOW is that nothing here assumes one AGENT_OUTPUT per turn.
       The access-control surfaces we TEACH carry spt-core's current directionality vocabulary and the reply exemption: the two knock `[[hints]]` and the `/sptc:knock` operative body. Operator ask (discord:reavo, 2026-08-21): an agent must learn (a) that a knock REQUIRES choosing between `--send-only` and `--send-receive` and what each means, and (b) that `--send-only` does NOT silence the far side — it bars unsolicited sends, not answers. (b) IS THE GENERAL ACCESS CONTRACT, RULED BY doyle 2026-08-21 and not inferred by us: a reply correlated to the endpoint's own outbound is admitted with no rule of its own — REQ-SEC-1's own title clause (stateful-firewall, reply/outbound exempt; ADR-0009 family), and the exemption precedes rules, modes AND the rule store, surviving a degraded store by ratified design (ADR-0053). The ENGINE ROOM is the strictest CONSUMER of that rule, not its owner, which is why the published docs stated it only as an engine-room instance — a REAL docs gap, now closed at source at the consumption point (docs-site networking/knocking.md, section 'Two-way reach is offered, never imposed', passage 'What --send-only does not bar: replies'), doc stage activated on REQ-SEC-1, publishing with the next core cut. PHRASING IS PART OF THE REQUIREMENT (doyle): teach it as 'they can answer what you send', NEVER as 'messaging someone once opens a permanent back-channel' — the correlation bound is real and its width is implementation detail, so no number is quoted for it. Also taught: `new-code --subnet` seals a code (comma list or repeated flag; OMITTING it seals to every subnet the minter belongs to, and a redeemer must share a sealed subnet to read the code's route at all), a capability that landed after the 0.54.0 amendment the body was last written against. WHY A GUARD AND NOT JUST TEXT: 0.54.0 retired the old flags with no aliases, so text teaching the old spelling hands the agent a hard parse error rather than a deprecation warning — the body was amended once already and nothing stopped a later edit from undoing it.
       A session-limited endpoint's idle mark lands ~1 minute AFTER the limit resets, not while the session is still limited (operator-directed 2026-07-28, refining REQ-HAZARD-RATE-LIMIT-STUCK-BUSY). The banner carries the reset time (`You've hit your session limit · resets 7:50pm (America/Los_Angeles)`); marking idle IMMEDIATELY drains the spool into a session that cannot act — each delivery re-marks busy, re-429s, and burns a spooled message into CC's uncertain input queue (field lia 2026-07-28: 30+ StopFailure heal/drain cycles, messages effectively lost). DEFERRED HEAL, two legs: (1) WATCHER — parse the banner's wall-clock reset (H[:MM]am|pm), compute the deadline (first of today's/tomorrow's local occurrence still ahead of now, +60s) via the machine's current UTC offset (one shelled probe per process: unix `date +%z`, windows PowerShell `[DateTimeOffset]::Now.Offset.TotalSeconds`; the banner tz is ASSUMED to equal the machine tz — same account), and HOLD the heal (no idle mark, latch untouched) until the deadline passes, then heal once via the existing latch. A parse failure, missing offset, or implausible delay (> 5h30m — tz-mismatch distrust) falls back to the immediate heal (0.25.25 behavior): the fallback direction is ALWAYS heal-now, never hold-forever. Real agent activity on the latest turn cancels the hold (re-arm, operator woke it early). (2) HOOK — a `StopFailure` on an spt-hosted session whose transcript tail carries the SYNTHETIC banner record (`isApiErrorMessage: true` + content text start-anchored on the banner — an agent QUOTING the phrase must not match) SKIPS the immediate idle mark (loud log; the watcher owns the deadline), so deliveries stay in the durable spool instead of churning into the limited session. The banner is the WHOLE discriminator — `error_type` is deliberately not consulted: CC fires StopFailure with error_type="" even on a session-limit 429 (field lia 2026-07-28 21:53, the v0.25.26 residual — an etype==rate_limit gate never matched and the immediate heal defeated the watcher's hold). Non-hosted sessions (no $SPT_ENDPOINT_ID → no resident watcher) keep the immediate heal — hold-without-a-watcher would re-create the permanent black hole. (3) ACTIVE HOLD (v0.25.27, operator-directed): while the hold is live the watcher RE-ASSERTS `state busy` every tick — other idle sources (a hook miss, an idle_prompt Notification on the limited session sitting at its prompt) mark idle underneath a passive hold and the daemon drains deliveries into the dead session; the busy re-assert corrects any stray idle within ≤15s for the whole limited window. Idempotent; runs only while a hold is live (rare, bounded ~5h), inside the watcher cost discipline. (4) EVERY ADAPTER IDLE SOURCE YIELDS INSIDE THE WINDOW (v0.25.28): the bringup idle assert (a daemon restart resuming a session mid-window instantly drained the spool ahead of the 15s busy re-assert — field lia 2026-07-29 23:12, 2 spooled messages spent) and the idle_prompt Notification heal both SKIP (loudly) when the transcript shows a LIVE limit. The transcript test is keyed on the NEWEST assistant record — a recovered session's stale banner reads as history, so the STUCK-ACTIVE-NO-IDLE protections stand unweakened for every healthy endpoint; no transcript_path reads not-limited (fallback is always heal-now).
       The context-reset-that-keeps-you-live is called RECHARGE everywhere an agent or a user is taught it, and the flag that requests it is `--recharge`. `commune across` / `across-commune` / `--across` remain SILENTLY ACCEPTED - understood wherever they are written, refused nowhere - because durable context is the thing being renamed and peers carry the old spelling in briefs and communes that no release can reach. STAGED RETIREMENT, NOT A HARD CUT (operator ruling 2026-09-09), for the reason the knock rename paid for the opposite way: spt-core 0.54.0 renamed the knock directionality flags with no aliases, and text teaching the old spelling stopped being merely stale and became a hard parse error. The staging is the whole ruling, so BOTH halves are guarded: every taught surface must name `recharge` as the current word, AND no taught surface may present the old spelling as current usage - an occurrence is legal only on a line that marks it as also-accepted or legacy, exactly the shape REQ-KNOCK-DIRECTIONALITY-TAUGHT guards. HISTORY IS LEFT ALONE, DELIBERATELY: shipped CHANGELOG sections, docs/adr/, docs/plans/ and the root JIT plans describe what shipped under the name it shipped under, and rewriting them would make the release notes lie about their own releases. REQUIREMENT IDS ARE NOT RENAMED - an id is identity, so renaming one is a delete plus an add that orphans every tag pointing at it; the ids keep their COMMUNE spelling and this requirement is the single authoritative statement that the taught name has moved. ADR-0011 records the ruling (the plan called for ADR-0010; that number was already taken by the account-roots decision). Retiring the old spelling is a LATER stage, once peers' durable context has rotated; the wake rename took three stages and shipped its retirement forty releases late, and the lesson recorded there is to grep ci/ and tests/ for a wire token before retiring it, not just src/.