{
  "summary": "Finding: “elevated endpoint” is not an endpoint state in spt-core. There is no elevation bit in `InfoJson`, the local listener registry, the subnet `Instance`, the spool, WAN message records, or RC/session resolution. The only implemented elevated-agent topology is an externally/harness-hosted elevated process. Its `api listen` child inherits that process context, binds a loopback TCP relay, stamps `controllable = Some(false)`, and can receive messages through the same TCP→relay/stdout or spool→relay/hook paths as any ordinary harness-hosted endpoint. `docs/DEFERRED.md:27` states this explicitly: harness-hosted-elevated “works: TCP listeners + talk-down pipes.” By contrast, `spt rc` attaches only to broker-owned PTY sessions. A harness-hosted endpoint—elevated or not—has no broker session and is intentionally advertised as `harness_only`; RC therefore fails with “no live session” even while messaging remains valid. Spt-hosted endpoints have broker sessions and support RC, but are unelevated by construction because the daemon/broker is forcibly de-elevated (KNOWN-HAZARDS 5.7). Therefore the observed RC failure is explained by hosting topology, not elevated-message incapability. There is no code-grounded evidence that elevation alone blocks message receipt. For a message failure tied to a hyphenated/shortform invocation, the leading explanation is parser/target conflation before routing; the deterministic discriminator is to hold one hyphenated harness-hosted listener constant and compare a direct `spt_msg::deliver::send_windowed` call, canonical `spt send <target>`, and the shortform invocation. Direct+canonical success with shortform failure proves parser conflation; failure of direct delivery proves listener/state/transport instead. No files, endpoints, daemon state, or live `hertz` process were mutated, and no tests were run because this assignment was explicitly read-only.",
  "files": [
    {
      "path": "CONTEXT.md",
      "description": "Canonical topology and lifecycle model. Lines 29-39 define daemon/broker/brain and the harness-hosted in-session relay; lines 180-183 define `api bind`, long-running `api listen`, and short-lived `api poll`; lines 232-236 define ReadyAgent/LiveAgent; lines 663-665 define Unbound as broker-session-live but not message-addressable; line 767 mentions an elevated endpoint as a privileged agent process, not as registry state."
    },
    {
      "path": "docs/DEFERRED.md",
      "description": "Decisive elevation statement at row 27: spt-hosted children are unelevated by construction; an admin-capable agent is harness-hosted-elevated today and “works: TCP listeners + talk-down pipes”; true elevated spt-hosting requires a future consented PTY-host satellite."
    },
    {
      "path": "docs/KNOWN-HAZARDS.md",
      "description": "KH 2.1/2.5 separate harness-owned PID liveness from daemon-hosted status liveness; KH 4.3 requires stale listener cleanup before address lookup; KH 5.7 requires the daemon always run unelevated in the invoking user universe. This rules out treating an elevated external harness and an elevated daemon/broker as the same thing."
    },
    {
      "path": "docs/adr/0021-harness-hosted-adapter-agnostic-seed-and-bind-time-resolution.md",
      "description": "Exact harness-hosted attachment design: SessionStart writes an adapter-agnostic seed keyed by parent PID; `api listen` consumes it and resolves adapter/profile at bind time from the parent executable/registry."
    },
    {
      "path": "docs/adr/0022-spt-hosted-idle-delivery-translation-binary.md",
      "description": "Topology split for receive: harness-hosted uses relay-poll; spt-hosted uses a broker-owned translation binary/PTY channel. Also states a poll listener, if present, wins over PTY injection."
    },
    {
      "path": "docs/adr/0027-unbound-endpoint-state-and-attach-on-session.md",
      "description": "Load-bearing RC invariant: attach is gated on a live broker session, not on perch online/bind state. Unbound is attachable but not message-addressable. This does not make harness-hosted perches attachable because they never have broker sessions."
    },
    {
      "path": "docs/adr/0028-activity-gated-delivery-and-send-modifier-axes.md",
      "description": "Defines message window/channel/persistence axes. Important alternate explanation: `active_only` deliberately avoids the listener wake path, while `force_native` deliberately rejects harness-hosted endpoints because they have no translation-binary PTY channel."
    },
    {
      "path": "crates/spt/src/api/startup.rs",
      "description": "Exact bind/listen symbols. `bind_from_seed` calls private `establish_perch(..., \"live_agent\", Some(false), ...)` for harness-hosted endpoints. `establish_perch` writes `InfoJson`, `ready`, session ledger, adapter/cwd/read-env, token—but no elevation metadata. `cmd_listen` resolves the adapter, binds `Relay`, optionally stamps daemon status online, emits `BOUND`/`READY`, drains backlog, and streams events to stdout. `cmd_bind` is the spt-hosted counterpart and stamps `controllable = Some(true)` for live agents."
    },
    {
      "path": "crates/spt-store/src/info.rs",
      "description": "`InfoJson` authoritative endpoint record. It contains PID/session/type/status/home/adapter/controller/rest/`controllable` and fault fields, but no privilege/elevation/integrity field. `controllable` explicitly means broker-PTY hosting topology: true=spt-hosted, false=harness-hosted."
    },
    {
      "path": "crates/spt-msg/src/listener.rs",
      "description": "`PollListener`: binds `127.0.0.1:0`, registers `{id,address,pid}` in the local SQLite registry, reads framed `(from,body)`, and unregisters on close/drop. No elevation check, token check, adapter check, or broker dependency is present."
    },
    {
      "path": "crates/spt-store/src/registry.rs",
      "description": "Local listener registry schema is exactly `agents(id,address,pid,started)`. `register_address`, `resolve_address`, `clean_stale_entries`, and `unregister_address` carry no elevation dimension. Resolution stale-cleans then returns the loopback address."
    },
    {
      "path": "crates/spt-daemon/src/relay.rs",
      "description": "Harness-hosted receive owner. `Relay::bind` owns a `PollListener`; `drain_backlog` claims non-deferred spool rows; `pump_once` accepts one live TCP message then drains backlog; `run` repeats. It is stateless and respawn-safe."
    },
    {
      "path": "crates/spt-msg/src/deliver.rs",
      "description": "Local delivery core. `deliver_tcp` resolves the local listener address and counts only a completed framed TCP write as live success. `send_windowed` performs TCP-first except for `active_only`, then durably spools. No elevation branch exists."
    },
    {
      "path": "crates/spt/src/cli.rs",
      "description": "`Cmd::Send` has a positional `target`; `cmd_send` first tries only the spt-hosted inject leg, then falls back to `deliver::send_windowed`, and finally WAN only on `NoPerch`. A harness-hosted target returns `None` from the inject predicate and therefore proceeds normally to TCP. `--force-native` is the intentional exception: it rejects a harness-hosted/non-controllable endpoint rather than falling back."
    },
    {
      "path": "crates/spt-daemon/src/inject.rs",
      "description": "`is_spt_hosted_no_relay` is the shared topology discriminator: online, no local relay address, and `InfoJson.controllable == Some(true)`. Unit coverage explicitly proves `Some(false)` harness-hosted endpoints are excluded from PTY injection—not excluded from TCP relay delivery."
    },
    {
      "path": "crates/spt-store/src/spool.rs",
      "description": "Durable fallback and drain truth. Rows carry `(from,body,window,channel,ephemeral,delivered)` and WAN op dedup. Normal messages use `WINDOW_DEFAULT`; active-only mirrors to `deferred=1`; relay drains non-deferred; hook poll can include deferred; taken rows are marked delivered rather than deleted. No elevation metadata or privilege-conditioned query exists."
    },
    {
      "path": "crates/spt/src/api/delivery.rs",
      "description": "Short-lived receive path. `cmd_poll` resolves Hook eligibility and emits whole `<EVENT>` envelopes; `poll_drain` claims the active-window rows. This is the fallback/active hook consumer independent of the long-running listener and independent of elevation."
    },
    {
      "path": "crates/spt-daemon/src/registryhost.rs",
      "description": "`RegistryHost::advertise_local` converts perches to subnet `Instance` rows. It derives `bound` from liveness and `harness_only` from `state == live_agent && controllable != Some(true)`. It advertises status/type/adapter/project/controller facts, but not elevation."
    },
    {
      "path": "crates/spt-net/src/net/registry.rs",
      "description": "Subnet `Instance` schema carries node/status/epoch/resource/recency/type/bound/controller/`harness_only`/adapter/projects. There is no elevation bit. `harness_only` is explicitly the remote display datum for an online LiveAgent without a broker PTY seat."
    },
    {
      "path": "crates/spt/src/wansend.rs",
      "description": "Remote route: `wan_send_with` parses the canonical address, resolves a visible `Instance`, refuses own-node stale hits, dials the selected node, sends `WanMessage`, and waits for a receiver acknowledgement. RC uses sibling `resolve_and_dial_owner`, but routing to a node does not create a broker session there."
    },
    {
      "path": "crates/spt-daemon/src/wan.rs",
      "description": "Remote receive: `receive_wan` applies access and op-id gates, then tries the same local `deliver_tcp` relay path, then spt-hosted translation injection, then an atomic spool+dedup transaction. No elevation condition occurs anywhere in the funnel."
    },
    {
      "path": "crates/spt/src/rc.rs",
      "description": "Exact RC production path. `run_attach_inner` rejects only explicit offline status, then `establish_attach` connects to the existing broker, calls `resolve_session` against the broker session table, and only on local miss resolves/dials a remote owner. A local registry row owned by this node but absent from the broker session table degrades to `OwnerDial::NotFound`; result is “No live session.” This is expected for every harness-hosted endpoint."
    },
    {
      "path": "crates/spt-daemon/src/harnesshost.rs",
      "description": "Spt-hosted ownership path: daemon prepares and asks the broker to spawn the adapter’s session command into a broker-held PTY. This is what creates the session RC can attach to. Since the daemon/broker identity is unelevated, these children are unelevated."
    },
    {
      "path": "crates/spt-daemon/src/deelevate.rs",
      "description": "Daemon privilege invariant and pure seam. `plan_spawn` chooses de-elevation when possible; module docs explicitly say elevated one-shot clients talking downward to an unelevated daemon are valid, while the daemon itself must not inherit elevation."
    },
    {
      "path": "crates/spt-store/src/liveness.rs",
      "description": "Single liveness resolver. `STATUS_UNBOUND` is broker-attachable but not message-addressable; online daemon-hosted liveness is status-authoritative; external/status-less liveness is PID-based. No elevation dimension."
    },
    {
      "path": "crates/spt/tests/contract_e2e.rs",
      "description": "Best existing adapter/listener seam. `seed_then_listen_binds_and_relays` already drives real binary `api seed → api listen`, verifies a spooled message reaches stdout, and verifies the bound session/type. It should be extended or mirrored for the isolated discriminator rather than inventing a new harness."
    },
    {
      "path": "crates/spt/tests/quickstart_e2e.rs",
      "description": "Best existing live-routing seam. Starts a real `spt ready`, invokes canonical `spt send`, asserts `SENT`, and reads the exact `<EVENT>` from receiver stdout; then proves offline spool and restart drain. Missing dimensions are a hyphenated target and privilege/topology comparison."
    },
    {
      "path": "crates/spt-proto/src/id.rs",
      "description": "Endpoint IDs explicitly permit internal ASCII `-`; tests accept `kebab-case`, `doyle-psyche`, and mixed IDs. Thus a correctly passed hyphenated ID is valid downstream. A failure limited to invocation parsing occurs before this lifecycle."
    },
    {
      "path": "crates/spt-proto/src/addr.rs",
      "description": "Canonical `[subnet:]id[@node]` parser validates each component through `validate_endpoint_id`; internal hyphens remain legal and unambiguous."
    }
  ],
  "architecture": "## 1. Production ownership and receive flow\n\n```mermaid\nflowchart LR\n  EH[Externally launched harness<br/>possibly elevated] -->|SessionStart hook| Seed[api seed<br/>daemon SeedRegistry keyed by parent_pid]\n  EH -->|starts child| Listen[api listen]\n  Seed --> Listen\n  Listen --> Establish[bind_from_seed → establish_perch]\n  Establish --> Info[info.json + ready + token<br/>controllable=false<br/>NO elevation field]\n  Listen --> Relay[Relay::bind]\n  Relay --> PL[PollListener<br/>127.0.0.1:ephemeral]\n  PL --> LR[(local .registry<br/>id,address,pid,started)]\n\n  Send[canonical send / WAN receive] --> Resolve[registry::resolve_address]\n  Resolve --> TCP[deliver_tcp framed write]\n  TCP --> Relay\n  Relay --> Emit[emit canonical EVENT to stdout]\n  Emit --> EH\n  TCP -->|miss/refusal| Spool[(perch spool.db)]\n  Spool -->|relay backlog| Relay\n  Spool -->|api poll hook| Poll[cmd_poll/poll_drain]\n  Poll --> EH\n\n  RC[spt rc] --> Sessions[broker sessions map]\n  Sessions -->|harness-hosted: no row| NoSession[No live session]\n```\n\n### Elevation passage\n\nThere is intentionally no “elevate endpoint” transition through these stores. Elevation remains an OS property of the externally launched harness/listener process. `establish_perch` serializes topology and identity, not OS privilege. `PollListener` uses loopback TCP and the shared local registry. The daemon is separately forced into the unelevated user universe. Therefore:\n\n- **Harness-hosted, ordinary:** external harness owns terminal; listener child; `controllable=false`; messages via TCP/relay or spool/hook; RC unavailable.\n- **Harness-hosted, elevated:** same persisted/runtime topology as above; the listener inherits the elevated harness context; messages use the identical TCP/relay or spool/hook path; RC unavailable.\n- **Spt-hosted, ordinary:** broker owns PTY/session; `controllable=true`; messages prefer relay if one exists, otherwise translation-binary injection/spool; RC available.\n- **Spt-hosted, elevated:** not implemented. The daemon/broker de-elevation invariant makes its children unelevated. A future consented elevation satellite is explicitly deferred.\n\nThis also explains an easy observational trap: comparing an ordinary **spt-hosted** endpoint with an elevated **harness-hosted** endpoint changes two variables at once. RC differs because hosting topology differs, not because privilege differs.\n\n## 2. Exact call chains\n\n### Harness attachment/listener ownership\n\n1. Adapter SessionStart invokes `api seed`; daemon holds a `Seed` keyed by stable `parent_pid`.\n2. Adapter launches `api listen <id>` under the harness.\n3. `startup::cmd_listen` resolves adapter/profile and calls `bind_from_seed` (or the explicit-session fallback).\n4. `bind_from_seed → bind_taken_seed → establish_perch(..., \"live_agent\", Some(false), ...)`.\n5. `establish_perch` writes `InfoJson { pid = listener process, parent_pid = harness, session_id, state, adapter, controllable=false, ... }`, `ready`, ledger, and capability token. No privilege field is read or written.\n6. `cmd_listen → Relay::bind → PollListener::bind_blocking` binds `127.0.0.1:0` and calls `registry::register_address(id, addr, current_pid, owlery)`.\n7. `Relay::run` owns the listener until killed/orphan-watch exit; startup and each cycle drain durable non-deferred backlog.\n8. `startup::emit` formats delivered `(from,body)` into canonical EVENT lines and flushes stdout into the owning harness session.\n\n### Local send\n\n1. Clap `Cmd::Send.target: String` is handed to `cli::cmd_send`.\n2. For non-force-native sends, `cmd_send` may attempt `try_spt_hosted_inject`; a harness-hosted record (`controllable=false`) returns `None`, which is a normal fallthrough, not failure.\n3. `spt_msg::deliver::send_windowed` checks existing/online perch.\n4. Unless `active_only`, it calls `deliver_tcp`.\n5. `deliver_tcp → registry::resolve_address` stale-cleans `.registry`, connects to the registered loopback port, and writes the structural frame. Completed write yields `SENT`.\n6. A TCP miss writes the message to the per-perch spool with its window/channel/persistence tags and yields `QUEUED`.\n7. Relay startup/cycles call `drain_non_deferred_audited_at`; hook consumers call `api::delivery::poll_drain`. Thus losing/restarting the listener changes immediate-vs-queued, not deliverability.\n\n### WAN send/receive\n\n1. Sender `wansend::wan_send_with` parses canonical `Address`, resolves a visible subnet `Instance`, dials its node, writes `WanMessage`, and waits for receiver acknowledgement.\n2. Receiver dispatcher calls `wan::receive_wan` with the QUIC-proven origin node.\n3. `receive_wan` applies access, perch-existence, op-id dedup, and user-message restamping.\n4. It calls the same `deliver_tcp` local relay leg first.\n5. Only if TCP misses does it try `inject::try_spt_hosted_inject`.\n6. Any remaining miss atomically commits WAN op-id + spool row. Elevation never participates.\n\n### RC\n\n1. `rc::run_attach → run_attach_inner → establish_attach` connects to an already-running broker.\n2. `resolve_session` queries the broker’s endpoint-labeled sessions.\n3. An spt-hosted endpoint has a broker session; local loopback attach proceeds.\n4. A harness-hosted endpoint has no broker session. If its subnet registry row resolves back to the same node, `wansend::resolve_and_dial_owner` intentionally returns `NotFound` because local session lookup already missed. Remote routing reaches the owner node but server-side endpoint→session resolution still misses and refuses.\n5. Result: no live session. This is correct for both ordinary and elevated harness-hosted endpoints and says nothing about TCP listener delivery.\n\n## 3. Invariants another agent can test directly\n\n1. **No privilege state:** `InfoJson`, local `.registry`, subnet `Instance`, `WanMessage`, and spool schemas have no elevation/integrity field.\n2. **Topology is explicit:** `controllable == Some(true)` means broker-owned PTY/spt-hosted; `Some(false)` means harness-hosted/no broker PTY. `RegistryHost` publishes the latter as `Instance.harness_only=true`.\n3. **RC source of truth:** attachability is broker-session existence. Neither `ready`, local listener registration, registry `Active`, nor privilege grants attachability.\n4. **Live-message success:** a completed framed TCP write is the only relay live-success criterion; privilege is not inspected.\n5. **Durability:** a TCP miss spools; relay backlog or hook poll claims it later. The listener holds no in-memory message state.\n6. **Window exception:** `active_only` intentionally does not touch TCP/relay and waits for hook poll. A test using it is not testing ordinary receive.\n7. **Channel exception:** `force_native` intentionally excludes harness-hosted endpoints; its `leg=cli-gate-not-hosted` is topology truth, not an elevation failure.\n8. **Spt-hosted elevation is impossible today:** daemon and broker run unelevated; a broker-spawned child inherits that identity.\n9. **Hyphens are valid downstream:** `validate_endpoint_id` permits `-`, and `Address::parse` preserves an internal hyphen. If the target string reaches these layers correctly, no lifecycle branch rejects it for containing a hyphen.\n\n## 4. Ranked falsifiable mechanisms\n\n### 1 — RC failure is expected harness-hosted topology, mislabelled as elevation (very high confidence)\n\n**Mechanism:** elevated agents are currently externally/harness-hosted. They have `controllable=false` and no broker session, so RC cannot attach.\n\n**Falsifier:** show the affected endpoint in `Brain::sessions()` / broker `SessionsReply` under its endpoint ID. If it has a real broker session yet RC says no session, investigate RC resolution/stream lifecycle. An `info.json` with `controllable=false` plus no broker session confirms this hypothesis.\n\n**Distinguishing evidence:** ordinary harness-hosted endpoint should fail RC identically; ordinary spt-hosted endpoint should attach. Message delivery may succeed in both.\n\n### 2 — Shortform/target parsing never passes the intended ID to canonical send (high for failures limited to a particular spelling; outside this lane’s grammar scope)\n\n**Mechanism:** parser conflation occurs before `cmd_send`, so registry/spool/routing never sees the intended target.\n\n**Falsifier:** invoke canonical `spt send <exact-id>` or call `send_windowed(<exact-id>,...)` against the same live listener. If both fail, grammar alone is false. If direct/canonical succeeds and shortform fails, grammar is proven.\n\n**Distinguishing evidence:** no new spool audit row for the intended perch and no listener frame after shortform, while direct/canonical produces one. Downstream ID validation already accepts internal hyphens.\n\n### 3 — Listener never attached or lost ownership (medium)\n\n**Mechanism:** `api listen` failed before/at bind (`ADAPTER_UNRESOLVED`, `NO_SEED`, `HOME_REFUSED`, conflict), or its parent-watch exited. Without a live local registry row, normal sends queue rather than emit immediately.\n\n**Falsifier:** observe `BOUND:<id>` and `READY:<id>`, `InfoJson.session_id` and `controllable=false`, a current `.registry` row whose PID is alive, plus a successful direct `TcpStream`/`deliver_tcp` write. These establish the complete receive attachment.\n\n**Distinguishing evidence:** listener failure affects ordinary and elevated harness-hosted endpoints under the same adapter/bind conditions; elevation is only correlated if it changes parent PID, adapter resolution, or state universe.\n\n### 4 — Elevated process and ordinary clients resolve different SPT homes/user universes (medium-low but important on sudo/alternate-admin shapes)\n\n**Mechanism:** the endpoint binds under one `$SPT_HOME`/profile while sender and daemon inspect another. On Unix, an independently sudo-launched harness can inherit root’s HOME unless explicitly anchored; on Windows, over-the-shoulder credentials can mean a different user profile. This creates two registries/perch trees, not an elevation-sensitive route.\n\n**Falsifier:** compare canonical resolved `spt_home`, owlery path, node identity, `.registry` path, and endpoint `info.json` path from listener and sender. Exact path equality falsifies this.\n\n**Distinguishing evidence:** ordinary/elevated records appear in different roots or node IDs. If roots are identical, this mechanism is gone.\n\n### 5 — Send modifiers intentionally choose a non-listener channel (medium if modifiers were present, otherwise low)\n\n**Mechanism:** `active_only` spools for hook poll and never wakes relay; `force_native` refuses harness-hosted because there is no translation-binary PTY channel.\n\n**Falsifier:** repeat with default canonical send. Default success and modifier failure is expected contract behavior.\n\n### 6 — Legacy/stale elevated daemon blocks ordinary IPC (low for current code, recognizable fleet-state issue)\n\n**Mechanism:** pre-KH-5.7 elevated daemon/named-pipe ownership can deny unelevated clients. This would impair seed/broker commands broadly, not one endpoint’s relay TCP route.\n\n**Falsifier:** ordinary endpoints and daemon status/seed/broker IPC all work from the same unelevated client; current daemon PID/token is unelevated.\n\n### 7 — OS integrity boundary blocks loopback TCP from ordinary sender to elevated listener (very low)\n\n**Mechanism:** hypothetical platform restriction on connecting upward.\n\n**Evidence against:** delivery is plain `127.0.0.1` TCP with no integrity/elevation gate, and the accepted deferral explicitly says elevated harness-hosted TCP listeners/talk-down pipes work.\n\n**Falsifier/proof:** an elevated listener plus de-elevated sender on the same `SPT_HOME` completes `deliver_tcp` and receives the frame. This is the only rung that directly tests OS token behavior rather than source equivalence.\n\n## 5. Minimal deterministic isolated discriminator\n\nUse the existing `contract_e2e::seed_then_listen_binds_and_relays` and `quickstart_e2e` patterns; do not touch a live endpoint.\n\n### Platform-independent core integration test\n\n1. Create a temporary `SPT_HOME`.\n2. Use a valid hyphenated ID such as `elevated-probe`.\n3. Start the existing in-process seed daemon fixture.\n4. Seed a live anchor PID and spawn real binary `spt api --adapter mock listen elevated-probe --parent-pid <anchor>` persistently (not `--once`), or use the explicit `--session-id` fallback.\n5. Wait for `BOUND:elevated-probe` and `READY:elevated-probe`.\n6. Assert the written record has the intended ID/session and `controllable == Some(false)`; assert local registry address and owning listener PID exist.\n7. **Routing baseline:** call `spt_msg::deliver::send_windowed(\"elevated-probe\", \"probe\", \"direct\", owlery, WINDOW_DEFAULT, false)` from the test. Assert `SendOutcome::Sent` and read the exact EVENT from listener stdout.\n8. **Canonical CLI:** pipe `canonical` to `spt send elevated-probe --from probe`; assert exit 0, `SENT:elevated-probe`, and the second exact EVENT.\n9. **Shortform candidate:** run the disputed shortform against the still-running same listener and same payload shape. Assert the third EVENT.\n10. Inspect `spool::audit_rows_at` only if a route queued: it identifies whether the intended perch was reached and which carrier claimed it.\n11. Separately assert the endpoint has no broker session / is `harness_only`. An RC no-session result alongside successful messages is the expected topology, not a contradiction.\n\n**Interpretation matrix:**\n\n| Direct core | Canonical CLI | Shortform | Conclusion |\n|---|---|---|---|\n| pass | pass | fail | Parser/shortform conflation proven; routing and receive lifecycle healthy |\n| pass | fail | fail | Canonical Clap/CLI target plumbing issue before delivery |\n| fail | fail | fail | Listener registry, state universe, liveness, permissions, or transport issue |\n| queued then backlog emits | queued then backlog emits | varies | Listener was absent/raced, but durable delivery lifecycle works |\n| messages pass; RC fails | messages pass | any | Harness-hosted topology exactly; elevation not a message blocker |\n\nThis is deterministic and hermetic because it never needs UAC/sudo: elevation is deliberately absent from core routing, so the test fixes topology and lexical target independently. It is the minimum test that separates parser from routing without conflating RC.\n\n### Optional real-token boundary rung (Windows/Linux acceptance, not ordinary CI)\n\nTo directly establish the OS claim, run only in an isolated temp home on a pre-elevated fixture runner:\n\n- listener child inherits the elevated test token and binds `elevated-probe`;\n- sender child is launched under the unelevated linked token / selected sudo invoker against the exact same explicit `SPT_HOME`;\n- sender uses canonical `spt send`, listener writes the received EVENT to a test-owned file/stdout;\n- repeat with both children at the same privilege as the control.\n\nFour factual observations must be recorded: actual listener and sender token/euid, identical resolved `SPT_HOME`, registered loopback address/PID, and received EVENT. This rung distinguishes a genuine OS integrity/ACL effect from source-level equivalence. It must not be simulated with an environment flag because production has no elevation flag to simulate.\n\n## 6. Bottom line\n\n- A blanket statement “elevated endpoints cannot receive messages” is unsupported by the implementation and contradicted by the accepted architecture note.\n- `spt rc` failure is expected for the only currently supported elevated-agent topology: harness-hosted.\n- The code intentionally models **hosting ownership**, not elevation. Compare like-for-like harness-hosted endpoints before attributing any difference to privilege.\n- A canonical/direct send to the same hyphenated listener is the decisive non-mutating design seam. If it succeeds while shortform fails, no spool/routing/adapter work is warranted; fix the parser path only.\n- Actual live elevated-token behavior was not exercised in this read-only investigation, so the runtime statement beyond the accepted doc/source equivalence remains `[INFERENCE]` until the optional isolated token rung is run."
}