/usr/bin/bash: line 5: cd: .worktrees/ws272-w2: No such file or directory
=== tail of registry ===
[[requirements]]
id = "REQ-NOW-SIGNAL-SEAL-BRIEF"
title = "THE SEAL_BRIEF CATEGORY TEACHES SEALING IN AT MOST TWO SHORT SENTENCES, ONCE PER SESSION (releases#18, ruled by the operator at the access-control grill follow-up 2026-07-29; the two-sentence bound is the operator constraint verbatim and is not ours to relax). IT ANSWERS EXACTLY TWO THINGS, in that order: what sealing IS and its significance as a PROVEN USER DIRECTIVE, and how the agent EXECUTES the proof. THE COMMAND IT NAMES MUST BE THE REAL ONE -- a payload whose entire purpose is telling an agent how to act is the worst possible place for an invented verb, and the first draft of this text cited a `spt seal verify` that does not exist; the shipped surface is `spt api seal verify <token>` with the content on stdin, mint via the `;;text;;` shortform. THE TEXT IS A CONSTANT, so the wording has ONE home and the two-sentence bound is auditable at a glance rather than reconstructed from a formatter. ONCE PER SESSION on the standing delta discipline: an agent that has been told does not need telling again, and a brief repeating every turn is precisely the noise that discipline exists to prevent. The category is POST-v1, appended by operator ruling rather than by widening the ratified set."
required_stages = ["doc", "impl", "unit"]  # ACTIVATED in the delivering lane (todlando, NOW-SIGNAL W1 / releases#18, 2026-08-30).
[[requirements]]
id = "REQ-SHELL-HINTS"
title = "A SHELL ADAPTER'S [[hints]] ARE LIVE TEXT, READ THROUGH THE NOW-SIGNAL HINTS CATEGORY UNDER A PER-SOURCE CAP (releases#133, operator-authored and operator-GREENLIT into NOW-SIGNAL #23; the cap shape ruled by the gater 2026-08-30). THE SCHEMA WAS NEVER THE GAP: hints is a top-level manifest field with no kind gate, so a kind=shell manifest has always parsed, validated, registered and profile-merged its [[hints]] -- what was missing is a READER, because the only reader resolves the ENDPOINT-BOUND manifest and therefore never looked at any other adapter. THE ONE-HINT-PER-MESSAGE CLAUSE (CONTEXT.md keyword hints, ratified 2026-06-12) IS AMENDED BY REPLACEMENT TO A PER-SOURCE CAP: the harness contributes at most one line and EACH shell adapter contributes at most one line, each still once per session. The authority chain is explicit: the clause was ratified when exactly ONE manifest could speak, its ground was flood protection from a single adapter's chatter, and #133 cannot be delivered under a global cap at all -- so the amendment implements the newer operator decision while preserving the original ground per source, where a global cap would convert every second adapter into a structurally mute one that the ground never asked for. TWO ARMS, DECIDED BY INSTANTIATION AND NEVER BY LINK STATE: an adapter this owner holds an instance of surfaces the FULL hint text regardless of whether that instance is online or offline, and an adapter with no instance surfaces only a teaser naming the trigger keyword and the command that shows the text. THE TEASER'S COMMAND MUST EXIST AT THE HEAD THAT SHIPS IT -- the same class as the SEAL_BRIEF phantom verb, and the shipped surface is spt adapter hints <adapter[:profile]>, verified against the built binary rather than remembered. THE SEEN-SET KEY GAINS ADAPTER IDENTITY, because the existing key hashes only keywords, text and the regex flag, so two adapters shipping identical hint text would otherwise share one entry and the first to fire would silence the other invisibly for the session. THE HARNESS KEY SPELLING IS UNCHANGED: qualification is additive and shell-side only, so no session's seen-set forgets what it has already been told when this lands. The shell key also carries its ARM, so a shell that is instantiated after its teaser fired still delivers the full text once -- a teaser tells the agent the hint exists and acting on it must not be punished by silence. ABSENCE IS SILENCE: no shells, no matching keyword, an unreadable or deregistered adapter, or an endpoint bound to no harness manifest at all each contribute NOTHING, and in particular the shell arm is NOT gated on the harness manifest being present, because an endpoint with no bound manifest can still own shells. THE DOC STAGE LANDS WHERE A SHELL-ADAPTER AUTHOR LOOKS (docs-site shells) rather than only in the ratification text, because a manifest section no author can find is a section that reads as absent."
required_stages = ["doc", "impl", "unit", "int"]  # ACTIVATED in the delivering lane (todlando, NOW-SIGNAL W3 / releases#133, 2026-08-30).
[[requirements]]
id = "REQ-NOW-SIGNAL-EDGE-SUBJECT-NAMING"
title = "THE EDGE_TRANSITIONS SUBNET-JOIN LINE NAMES ITS SUBJECT AS A NODE AND LABELS ITS FALLBACK AS A PUBKEY (releases#11b render rider, ruled 2026-08-30). The join arm reads `RosterEntry`, which is a NODE record (node pubkey, subnet, and a `label` that is the member's OS hostname) -- so the arm is NODE-LEVEL ONLY: there is no endpoint-level join here to distinguish, and a node does not join a subnet FROM another node. THE TICKET'S `z joined <subnet> from <node>` WORDING NAMES AN UNBUILT DATA SOURCE, NOT A MIS-RENDER, and the from-node half went back to the board as its own request rather than being invented here or silently dropped -- that distinction is the whole reason this requirement exists, because the next reader of the ticket would otherwise re-derive it. WHAT IS FIXABLE IN THE RENDER, AND IS FIXED: the line says `node <label> joined subnet <x>` so it states what its subject is, and the unlabeled fallback renders as `pubkey <12hex>...` rather than as a bare hex prefix standing where a name goes, because a bare prefix reads as an endpoint id to every reader who has not opened the function."
required_stages = ["impl", "unit"]  # ACTIVATED in the delivering lane (todlando, NOW-SIGNAL W1 / releases#11b rider, 2026-08-30). No doc stage: this is a render precision fix inside a category the docs already list, not a new surface.
[[requirements]]
id = "REQ-NOW-SIGNAL-DEFERRED-CATEGORIES"
title = "PROJECTS (spt-bs-releases#16) AND FILE_ACCESS_HELPER (#17) ARE MINTED AS DEFERRED NOW-SIGNAL CATEGORIES SO THEY ARE NOT LOST (ratified 2026-07-29). They are NAMED, NOT BUILT: v1 ships without them deliberately, and this requirement exists so that the decision is on the record as a deferral with an issue behind it rather than as an omission a later reader mistakes for an oversight. Activating this requirement is what the lane that builds them does; until then it carries no stages and fails nothing."
required_stages = []  # DEFERRED by ratification (#16, #17). Activate in the lane that builds them — not before.
[[requirements]]
id = "REQ-IO-EVENT-ADAPTER-LOG"
title = "ADAPTER-CONSUMABLE IO EVENTS LAND IN A PER-ENDPOINT APPEND-ONLY LOG REGISTERED AS A THIRD BUS SINK (releases#234, operator ruling 2). The funnel's claim was that a second reader costs a REGISTRATION and never a rework, and on the sink side that holds exactly as claimed — this consumer is one `bus.register` line in `default_bus`. THE READER IS FREE, THE STORE IS NOT, and this requirement is the honest half of that claim: neither existing sink writes a per-endpoint, ordered, cursorable surface — the shell-link sink spools per linked shell and the last-msg sink keeps two overwritten slots — so a delta-cursored poll needs a NEW DURABLE STORE, and that store is what this covers. EVERY ROW CARRIES ITS OWN MONOTONIC seq AS THE LINE'S KEY RATHER THAN AS A JSON FIELD: a row is `<seq>` TAB `<json>`, so a cursor scan parses an integer prefix and never the body, and the ordering key cannot become an accident of serialization field order. THE LOG'S seq AND THE DIGEST seq ARE DIFFERENT NUMBERS AND ARE SPELLED DIFFERENTLY (`seq` versus `digest_seq`), because the digest remains the content surface that a truncated payload points at and one name for two counters is a consumer following the wrong one. THE LOG IS BOUNDED PER ENDPOINT AND TRIMMED OLDEST-FIRST so that an adapter which stops polling cannot grow it without limit; the bound is a STATED CHOICE derived from a measured event rate rather than a guessed number, and the trim is amortized against a slack so an ordinary append is not a whole-file rewrite. APPENDS ARE SERIALIZED under an exclusive advisory lock on a stable sentinel, because the daemon publishes from several edges and two racing appends must not mint a colliding seq. A SINK FAILURE IS STILL ONLY A REPORT: this store may not become the first sink whose bad day reaches the operation it observes."
required_stages = ["doc", "impl", "unit"]  # ACTIVATED in the delivering lane (todlando, CONDUIT W3, 2026-08-28).

[[requirements]]
id = "REQ-HAZARD-IOLOG-SEQ-MONOTONIC"
title = "IO event log appends mint strictly above the global sequence maximum; a tail window beginning inside a UTF-8 codepoint never produces a false zero. Reset-damaged history is renumbered above its prior maximum in file order under the exclusive lock, and retention keeps the newest rows by position (releases#277)."
required_stages = ["impl", "unit"]

[[requirements]]
id = "REQ-IO-EVENT-POLL-VERB"
title = "spt api io-events IS THE DELTA-CURSORED POLL A HARNESS ADAPTER READS IO EVENTS THROUGH (releases#234; the operator DELEGATED the mechanics and CHOSE POLL over push). It answers with the rows the caller has not yet been shown and with nothing else. TWO CURSOR MODES OVER ONE ORDERING: `--session-id <sid>` keeps a per-session cursor exactly as `api now-signal` keeps per-session seen-sets, and `--after <seq>` lets a caller carry its own cursor exactly as `endpoint digest --after` already does; naming both is what keeps a stateless adapter and a session-keyed hook off two different verbs. THE CURSOR KEY IS THE AUTH SESSION ID AND NOT A SECOND FLAG BESIDE IT: the harness session is ONE identity, and a `--session` for the cursor sitting one character from a `--session-id` for the gate would be two ways to be wrong about it on a verb an adapter wires once; a token-authenticated caller has no session identity and uses `--after`. A POLL WITH NEITHER CURSOR IS REFUSED BY NAME (`IO_EVENTS_NO_CURSOR`, exit 2) RATHER THAN ANSWERED WITH SILENCE, because a caller who asked an unanswerable question must not read the answer as nothing having happened. A NEW SESSION'S FIRST POLL SEES NOTHING AND SEEDS ITS CURSOR SILENTLY — history is the digest's job, and replaying an unbounded backlog into a turn-boundary hook is the exact cost the now-signal's delta discipline exists to avoid, with EDGE_TRANSITIONS the standing precedent for seeding silently for that reason. PROVING THIS NEEDS THE SEEDED-EMPTY FIRST POLL ASSERTED BESIDE A NON-EMPTY SECOND ONE, because an assertion that the first poll is empty passes just as well against a verb that emits nothing ever. ALL SIX EMITTED KINDS ARE VISIBLE — USER_INPUT, AGENT_OUTPUT, MSG_IN, MSG_OUT, COMMUNE, COMMUNE_FAIL — and AN UNKNOWN KIND IS IGNORED RATHER THAN REFUSED, the same posture the now-signal category vocabulary takes toward a name it does not know. TOOL_USE STAYS UNEMITTED AND THIS VERB DOES NOT CHANGE THAT: measurement says the harness adapter is its natural emitter, which is a question back to deployah and then the operator and must not ride in on this verb. THE PAYLOAD BOUND IS THE 16KB CLASS WITH A truncated FLAG AND THE DIGEST POINTER, MATCHING THE SHELL FRAME AS A CHOICE AND NOT AS AN INHERITANCE — `IoEvent.payload` is deliberately unbounded at the bus layer and the cap belongs to the frame — so that one event reads identically through either transport and a consumer needing the whole body follows the pointer into the digest. THE POLL IS AUTHENTICATED THE WAY `api poll` IS, AND FOR THE SAME REASON: it hands back the session's VERBATIM user input and agent output, which is the payload class addressed to the endpoint's occupant rather than to whoever asks. This is a DELIBERATE DEPARTURE from its sibling reader `api now-signal`, which is ungated because it renders DERIVED summaries — a ten-word excerpt, a category count — and never a raw payload; the gate follows the content, not the verb family. Proof is the `--session-id` an adapter already passes to `api state`, or a capability token, so the gate costs a compliant adapter nothing."
required_stages = ["doc", "impl", "unit", "int"]  # ACTIVATED in the delivering lane (todlando, CONDUIT W3, 2026-08-28). int = the e2e proving the seeded-empty first poll beside a non-empty second poll.
[[requirements]]
id = "REQ-EMIT-SINGLE-WRITE"
title = "A machine-parsed diagnostic emission is handed to the OS as exactly ONE write of the complete rendered text including its terminating newline."
required_stages = ["impl", "unit"]  # ACTIVATED at W1 START (todlando 2026-08-29), minted with no stages minutes earlier per doyle rider 3. impl = spt-proto emit.rs compose_line/compose_block/write_line/write_block/write_composed + the emit_line!/emit_block! macros. unit = one-write-of-the-whole-line (interpolated AND static literal), caller terminator absorbed not doubled, interior newline ESCAPED with the spelling pinned, bare CR escaped, the debug_assert arm firing under debug_assertions, has_interior_break pinned on its own, block arm keeping interior newlines and terminating exactly once, the RED-FIRST arm proving a plain write_fmt still fragments (measured 5 writes against 1 for a static literal), and the SHORT-WRITE arm proving complete text in order without asserting a count. MINTED releases#236 follow-on (todlando 2026-08-29, doyle-ruled shape); stages ACTIVATED at W1 start, not at mint. RATIONALE, which deliberately does NOT live in the title: the property is DETERMINISTIC and belongs to the EMITTER — it counts the writes WE issue and makes NO ATOMICITY CLAIM ON ANY OS. POSIX gives pipe writes at or below PIPE_BUF atomicity, Windows gives no such guarantee, and a file append and a console differ again; we promise the thing we control and refuse to promise the thing we do not. MEASURED PREMISE (std sources, stable 1.96): io::Stderr is unbuffered, and Write::write_fmt single-writes only a statically known str — otherwise default_write_fmt drives an adapter that write_all's PER FORMAT FRAGMENT, the trailing newline included, so an interpolated eprintln reaches an inherited handle in pieces that another process can interleave. TWO NAMED ARMS: emit_line refuses an interior newline (escaping it in release, debug_assert in debug, so the tolerant branch PRESERVES the invariant rather than abandoning it in the one build no test watches) and emit_block is the explicit opt-in for a composed multi-line block, still one write. Population at v0.65.0: 487 TOKEN-shaped sites, 444 interpolated, 200 calls spanning multiple lines. SHORT-WRITE NUANCE (doyle 2026-08-29): the emission is ISSUED AS ONE CALL and retried only on an OS short write, which preserves COMPLETENESS at the cost of a rare late tail — write_all and not a bare write, because a bare write under the same short write DROPS THE TAIL, loses the terminator, and glues the next emission onto the partial, manufacturing the very torn-token signature this requirement retires. The unit shape follows: a non-short-writing counter asserts EXACTLY ONE call and the full rendered newline-terminated buffer, a SEPARATE short-writing arm asserts complete text in order ending with the newline and deliberately does NOT assert the count, and the red-first arm asserts the plain write_fmt path still fragments. ONE SEAM, ONE OWNER: this emitter is the only helper; consumers convert onto it rather than minting a second dialect.

[[requirements]]
id = "REQ-WEB-URL-NODE-PREFIX"
title = "EVERY SERVED URL IS NODE-PREFIXED, LOCAL RESOURCES INCLUDED (ADR-0056, WEBSERVE grill round 1+2, releases#272/#249). ONE GRAMMAR: the 5474 server answers `/<node-name>/...` for every facet, and a resource on this node is reached by the SAME path here and on every other subnet machine -- the local daemon resolves the prefix and proxies to the owner when it is elsewhere. WHY ONE GRAMMAR AND NOT TWO: un-prefixed-local plus prefixed-remote was rejected because a URL would then mean different things depending on which machine it was pasted into, and a URL that cannot be pasted between subnet machines is a path, not a link -- which is exactly what #147 message links and #17 FILE_ACCESS_HELPER need it to be. Bare `/` REDIRECTS (302) to `/<local-node>/`. The docs server's existing bare paths stay reachable as a COMPATIBILITY ALIAS under the local node prefix and must remain BYTE-TRUE -- REQ-DOCS-LOCAL-SERVER's surface contract is untouched by this change, and the alias is not a second grammar. SUB-NAMESPACE PER FACET so a path says what it is: `f/` registry files, `docs/` the docs site, `a/<adapter>/` adapter docs, `m/<short-id>` message views, `bin/` + `install` the bootstrap surface. ALL FIVE ARE RESERVED AT THE ROUTER IN W0 EVEN WHERE THE FACET IS NOT BUILT: an unbuilt facet answers 404 NAMING THE FACET and must never fall through to a registry lookup, because a reserved prefix that resolves as a served name is how two facets collide later. `/<node>/` itself renders the INDEX PAGE -- the serving registry, path to URL, HTML with a `?json` twin for agents -- which is the what-is-this-node-exposing audit in a browser. A request for `/<other-node>/...` answers 502-with-node until W1 builds the proxy. Scheme is plain http only; an spt:// scheme was rejected as needing a handler on every OS to buy nothing. Gate: doc -- the serving overview page carrying the grammar and the reserved list; impl -- the router's node-prefix resolution, the bare-root redirect, the reserved sub-namespaces, the index page and its json twin; unit -- the redirect, each reserved prefix 404ing by NAME rather than reaching the registry, the docs alias answering byte-identically to its pre-change path, and the index rendering an entry's path and URL; int -- a real server answering the grammar end to end."
required_stages = ["doc", "impl", "unit", "int"]  # ACTIVATED WEBSERVE W0 (todlando build 2026-09-06), releases#272/#249, greenlit by the operator after the two-round grill. doc = docs-site serving/overview.md URL-grammar section. impl = the 5474 router's node-prefix resolution, bare-root 302, reserved facet sub-namespaces, index page + ?json twin. unit = redirect, per-facet 404-by-name, docs alias byte-true, index render. int = the grammar answered end to end by a real server.

[[requirements]]
id = "REQ-WEB-SERVING-REGISTRY"
title = "THE SERVING REGISTRY IS THE PRIMITIVE AND SERVED NAMES ARE STABLE AND DISAMBIGUATED (ADR-0057, releases#272/#248). The registry is the node's single enumerable list of what it exposes, and exposure is a DELIBERATE ACT of adding an entry -- so what-is-this-node-serving has exactly one answer. A served root (a dir entry an adapter declares in its manifest) is NOT a second mechanism: it is a registry entry of kind dir, which is what keeps the audit to one command. A drop-folder primitive was rejected because exposure would become a property of where a file happens to sit. STORE: `$SPT_HOME/serve/registry`, spt-store owns the format and the read path, the DAEMON IS THE SINGLE WRITER. ENTRY: id, kind (file | dir | attachment), absolute source path (file/dir) or snapshot path (attachment), served name, registered-at, ttl (attachments only), origin (endpoint id). THE SERVED-NAME RULE, exactly as ADR-0057 and binding clause by clause: the first registrant keeps the bare `<stem>.<ext>`; a later entry whose bare name is taken is served as `<stem>~<n>.<ext>` with the suffix BEFORE the extension so the file still opens as its type; `n` increments per (stem, ext) and THAT COUNTER IS PERSISTED, which is the one piece of state the stability promise costs; the assignment is persisted on the entry so an entry's URL NEVER CHANGES for its life; A FREED NAME IS RE-TAKEN ONLY BY THE ABSOLUTE PATH AND KIND IT LAST NAMED (ADR-0057 Amendment 2, doyle-ruled 2026-09-06 off the W0 smoke: the history records name to last path, so an adapter alias survives deactivate/activate and adapter update), so a stale link answers not-found or the very resource it always named and can never silently open a different one; re-registering the SAME ABSOLUTE PATH returns the EXISTING entry rather than minting a new suffix; an explicit `--as <name>` is subject to the same rule. Disambiguation is PER NODE -- across nodes the node prefix (ADR-0056) already separates names. VERBS: `spt serve add <path> [--as <name>]`, `spt serve rm <name|id>`, `spt serve list [--json]` rendering path to URL. MANIFEST: `web_short_path` is a dir entry registered at adapter activation and removed at deactivation. REFERENCE-SERVED (file/dir) RESOLVES AT REQUEST TIME: an edit is visible and a deleted source answers 404, which is the property that distinguishes a plainly registered file from an attachment snapshot (ADR-0058). Gate: doc -- the serving overview page's registry and served-name sections; impl -- the spt-store registry format and read path, the daemon writer, the three verbs, the manifest-declared served root; unit -- EVERY CLAUSE OF THE SERVED-NAME RULE AS ITS OWN CELL (bare to first, suffix after, counter per (stem,ext) and persisted, freed name re-taken only by its last path and kind while a different path or a changed kind takes the next suffix, same absolute path returns the same entry, --as under the same rule), plus the reference-served resolve-at-request-time behaviour; int -- add, list, fetch and rm through the real server."
required_stages = ["doc", "impl", "unit", "int"]  # ACTIVATED WEBSERVE W0 (todlando build 2026-09-06), releases#248. doc = serving/overview.md registry + served-name sections. impl = spt-store serve/registry format and read path, daemon single-writer, spt serve add|rm|list, manifest web_short_path served root. unit = one cell per served-name clause (ADR-0057 is clause-by-clause binding) + reference-served resolve-at-request-time. int = add/list/fetch/rm through the real server.

[[requirements]]
id = "REQ-WEB-ACCESS-SURFACE"
title = "WEB SERVING GETS ITS OWN ACCESS SURFACE AND IT IS MINTED BEFORE ANYTHING DIALS IT (ADR-0060, releases#272/#249/#246). Mint the `WEB` row in the OPEN surface vocabulary -- one row, no schema change, the FORK precedent -- gating every served resource reached ACROSS THE SUBNET, checked by the OWNING node under the handshake-proven origin. DEFAULT-ON WITHIN THE SUBNET, the DISCOVER shape: content in the serving registry is there by a deliberate act (ADR-0057), so the deny lever is for lockdown and not the default; deny-by-default was rejected because a second gate at every read would make the registry a list of things nobody can fetch. NON-ATTRIBUTABLE for now, and that is stated rather than implied: there is no daemon-stamped sender identity yet (the REQ-ACL-SUBJECT-CHAIN tier-1 inertness), so WEB inherits the note that it is the surface expected next to grow a sender stamp, which moves here from the retiring XFER. IN W0 THE ROW EXISTS AND IS RULE-ADDRESSABLE AND NOTHING DIALS IT -- the gate itself is W1's cross-node stream family. This ordering is deliberate: a surface minted with its first consumer would make the vocabulary change and the enforcement change one diff, and the surface table is the thing every rule and knock code is written against. The `--help` Control surfaces section grows the row BY EXISTING (the table is composed, never hand-listed), which is what keeps the published vocabulary from drifting from the table. XFER's retirement is a SEPARATE close rider on #246 (REQ-XFER-RETIRED) and is NOT part of this requirement. Gate: doc -- the access-surface docs page and CONTEXT.md's surface entry carrying WEB; impl -- the row in the surface vocabulary table and its composition into --help; unit -- the row is present, canonicalizes, is addressable by a rule, and defaults on within a subnet, with a guard that NO call site dials it in W0 so the guard reds on purpose when W1 threads the gate in."
required_stages = ["doc", "impl", "unit", "int"]  # ACTIVATED WEBSERVE W0 (todlando build 2026-09-06), releases#249/#246. doc = the access-surface page + CONTEXT.md surface entry carrying WEB. impl = the WEB row in the surface vocabulary and its composition into --help. unit = presence, canonicalization, rule-addressability, default-on-within-subnet, plus the no-call-site-dials-it guard that reds on purpose when W1 threads the gate. int ACTIVATED WEBSERVE W1 (todlando build 2026-09-07, releases#249): the cross-node proxy dials the row, so the mechanized two-daemon deny cell (a WEB deny rule on the owner turns the fetch into 403 naming the surface) is the first evidence that the gate is REACHED, not merely minted.

[[requirements]]
id = "REQ-WEB-CROSS-NODE-PROXY"
title = "A NODE-PREFIXED URL FOR A SUBNET PEER IS SERVED BY THE OWNER THROUGH THE LOCAL DAEMON, WITHOUT A CACHE (ADR-0056, ADR-0060, WEBSERVE W1, releases#272/#249). A request on the loopback server for `/<peer>/...` where `<peer>` is a KNOWN subnet member opens ONE Iroh stream of a NEW TAGGED stream family (kind web -- the Knock shape: an N-1 owner has no arm, classifies it Unknown and drops it, so the requester answers 502 naming the node under a DEADLINE, never a hang) and relays the owner's answer back verbatim. THE OWNER DECIDES: it runs access_check on the WEB surface with the origin taken from the HANDSHAKE-PROVEN stream identity (the serve_xfer shape, REQ-HAZARD-WAN-ORIGIN-AUTH), the subject being the served entry's registering endpoint, and a refusal comes back as 403 whose body names the SURFACE and never a sender (WEB is non-attributable in W1). The owner resolves the served name through the SAME router the local facet uses, so an edit is visible on the next fetch, a deleted source is the owner's 404 carried back as 404, and the reserved facets stay router-first on the requester (`/<peer>/f/`, `m/`, `bin/`, `install` answer locally, no stream opened). NO CACHE: nothing is written under the requesting node's SPT_HOME; the body is STREAMED in bounded chunks, never buffered whole. HEAD, Range (forwarded verbatim; the owner's 206 with Content-Range comes back; unsatisfiable is 416) and Content-Type are the owner's. STATUS NAMING, ruled 2026-09-07: unreachable owner / dropped stream / deadline = 502 naming the NODE; owner deny = 403 naming the SURFACE; an UNKNOWN first segment is the docs compatibility 404 UNCHANGED (ADR-0056 Am.1 order), never a 502; a served-name miss is the owner's NOT_FOUND body at 404. Gate: doc -- the cross-node serving page (grammar, statuses, deadline, no-cache) and the access-viewing WEB row text; impl -- the tagged wire family, the dispatcher arm, the owner-side gate + serve, the requester-side resolve-to-proxy, the streaming body; unit -- the record family round-trips and an unknown kind is skipped, the tagged first line classifies as Web and never as a message, the census bijection, the Range grammar (single range, suffix, open-ended, unsatisfiable), the router's proxy-or-local decision per facet, the 502 shape naming the node and the 403 shape naming the surface; int -- two REAL daemons on one box: byte-equal fetch through the requester, a WEB deny rule on the owner answering 403 naming WEB, Range answering 206 with Content-Range, the owner stopped answering 502 naming the node within the deadline, an unknown label answering the docs 404, a reserved facet answered locally; plus the two-host cells on the real rig (fetch, deny, range) as their own #[test] fns."
required_stages = ["doc", "impl", "unit", "int"]  # ACTIVATED WEBSERVE W1 (todlando build 2026-09-07), releases#272/#249, doyle rulings 00:50Z (unknown label = docs 404 unchanged; 502 only for a KNOWN peer; no sender in the 403 body; twohost cells as separate fns). doc = docs-site serving/cross-node.md + networking/access-viewing.md WEB row. impl = spt-net webmsg.rs, dispatch Web arm, spt-daemon webproxy.rs (serve_web + fetch_via_peer), webserve resolve_path/known_subnet_node/apply_range, docshost proxy body. unit = webmsg round-trip, dispatch classify + census, apply_range cells, resolve_path decisions, 502/403 shapes. int = crates/spt/tests/webserve_cross_node_e2e.rs (mechanized two-daemon rig) + crates/spt-daemon/tests/twohost_web.rs (rig cells).


[[requirements]]
id = "REQ-MANIFEST-UNKNOWN-KEY-WARN"
title = "AN UNKNOWN MANIFEST KEY IS NAMED ON STDERR AND REGISTRATION PROCEEDS (WEBSERVE W0 rider, doyle-ruled 2026-09-06 18:15Z from hertz W3 RED, releases#272/#265). manifest.rs carries NO deny_unknown_fields anywhere BY DESIGN (forward-compat for adapters built blind against a newer core), so refusal is out -- and that makes a misspelled OPTIONAL key visible only by its ABSENCE: web_short_pth registers with no alias and no error, docs_dir follows in W3. The tolerant branch that KEEPS the invariant: at adapter add (the register choke point, which adapter update also passes) every key not in its table's known set emits ONE stderr line `manifest: unknown key [<table>].<key> (ignored)` and registration PROCEEDS. Shape: a generic walk of the parsed toml::Value against the schemars-derived schema (the same derives the parser reads, so the known set cannot drift): $refs resolve through $defs, anyOf/oneOf/allOf branches union their properties, [[arrays]] descend through items, a map table (additionalProperties = a schema, e.g. [env.<VAR>]) admits every key and sweeps each value, a free-form table (additionalProperties true -- [profiles.*], [strings]) is the adapter's own vocabulary and is not judged, an unparseable document yields nothing because the parse error already speaks. Gate: doc -- one paragraph in harness-contract/manifest.md (unknown keys are ignored; the diagnostic names them); impl -- Manifest::unknown_keys + the register-site emission; unit -- a web_short_pth typo parses AND registers AND is named table-qualified, a known key emits nothing, the full fixtures sweep clean (no false positive across refs, options, maps, arrays), depth naming ([adaptor], [session].comune_dir, [env.HOME].direktion, [hints].keyword, a root scalar), free-form tables silent, unparseable silent."
required_stages = ["doc", "impl", "unit"]  # ACTIVATED WEBSERVE W0 rider (todlando 2026-09-06). doc = harness-contract/manifest.md Unknown keys paragraph. impl = spt-runtime manifest.rs unknown_keys walk + registry.rs register_with_core emission. unit = manifest.rs cells (typo named, known silent, fixtures clean, depth naming, free-form + unparseable silent) + registry.rs typo-still-registers.