Beagle SCM

URI-014 HIGH: hunk links/banners/status-bar must use word URI shape — get the verb/view OUT of the scheme slot

Hunk-carried URIs jam the VERB/VIEW word into the URI SCHEME slot — diff://name/path, status://name, commit://name?sha, log://name?ref, cat://name/path#L<n>. Per "views are verbs, not schemes" (Nav, DIS-060) the verb belongs in the HEAD/word slot; the scheme addresses TRANSPORT only (ssh:/https:/be:/file:). The overload "worked" only because these URIs never carry a real transport scheme (the trick), but it is structurally wrong and blocks composition like diff https://host/x?a..b (a lens over a remote). Convert EVERY hunk-carried URI — embedded U-tag click-target LINKS, the hunk BANNER/record URI, AND the re-typeable STATUS-BAR address — to the word URI (verb-space-URI) form, the SAME module(args) shape ulogs, hunks, the CLI, and the address bar already use. HARD CUTOVER, JS-only (beagle-ext); the C weave/graf bakers are a linked follow-up. Completes the URI-012 (resolution) + URI-013 (composition) arc with SHAPE. Method Issues.

Input

Context

• Today JS projectors bake U-tag click-targets + banners with the verb in the scheme slot: navUri("diff", path) → diff://name/path, status://name, commit://name?sha, log://name?ref, cat://name/path#L<n>, tree://name/segs?rev. The pager (_uriAt/_resolveSpell) then parses them as SCHEMED URIs.
• The "trick" worked because a hunk link NEVER carries a real transport scheme (ssh:/https:/be:/file:), so overloading scheme with the verb didn't collide — but it forbids diff https://host/x?a..b (verb diff over a REMOTE), the very composition Nav frees by emptying the scheme slot.
• The record ALREADY carries the verb SEPARATELY — ulog rows {ts, verb, uri}, hunk records {uri, verb, ts} — so the word is DUPLICATED (record verb field AND the uri's scheme). word URI single-sources it.
• Design already says so: Nav "Click-targets are spells: a hunk's U-tag carries a verb args spell" and "Views are verbs, not schemes." This ticket makes the IMPLEMENTATION match the spec.
• Follows URI-012 (a relative link inherits the context authority) + URI-013 (all URI compose/parse through the URI class); this is the third axis — link SHAPE.

Goals

• Every hunk-carried URI uses word URI (verb SPACE uri): U-tag click LINKS, the hunk BANNER/record URI, and the pager STATUS-BAR re-typeable address.
• The word is the verb/view (diff/cat/commit/log/tree/status/grep/spot/ls/…); the URI part carries ONLY addressing (//authority/path?ref#frag) and a REAL scheme ONLY for a transport (diff https://host/x).
• The pager dispatches a link/banner as a module(args) SPELL (verb head + URI arg) via the SHARED spell machinery — never a <scheme>: parse.
• The scheme slot in these URIs is FREE for transports: diff https://host/x?a..b composes and clicks through.

Constraints

• JS-only (beagle-ext): the JS projectors that bake U-targets+banners (status/diff/cat/blob/sha1/tree/size/type/log/commit/spot/ls/lsr/refs/grep/regex) and the pager (views/bro/pager.js) that parses them. The C weave/graf bakers (beagle) that emit some diff:/cat: targets are OUT OF SCOPE → a linked follow-up; note the JS/C boundary (URI-012 navAuthorize was the C-baked-target compat shim).
• Reuse the SHARED word(context_uri, …rest) composer/parser (shared/spell.js) — the SAME one the CLI + address bar use (Nav, ONE resolver). Do NOT fork a hunk-only link parser.
• Compose the URI PART via the URI class (URI-013) — URI.make/navUri, authority-scoped; the word is prepended as <verb> , NEVER folded into a scheme.
• NOT byte-parity: the on-wire link/banner TEXT changes shape by design. The nav/click/pager tests that assert link text MUST be updated to the new shape (user-approved test edits, Issues).
• Repro-first: a baked link asserts diff //name/path (not diff://name/path) AND clicking it dispatches verb diff with arg //name/path.

WIP

Design decisions

• The record verb field is the SINGLE source of the word; the uri field drops the verb-scheme and carries scheme-less addressing (real scheme only for a transport). The U-tag click-target BYTES become the <verb> <uri> spell string (a space in the hidden bytes — Nav click-targets are spells, already a verb args string).
• A link composer emits <verb> <scheme-less //name/path?ref#frag> — the URI part through URI.make/navUri (authority-scoped, URI-013); navUri's <verb>:-scheme form is RETIRED for links (its query/frag params stay for the addressing part).
• Pager: _uriAt/_followRow/_runSpell treat the target as a spell and drive via driveSpell/spellCall (already handle verb args); the <scheme>:-for-verb branch in _resolveSpell is dropped for links (hard cutover) and falls to the bareword-verb + relative-URI path (URI-012).
• Status-bar: the re-typeable address becomes <verb> <uri> (diff //name/path#L<n>) — exactly what the user would type back.

API (concrete, URI-014)

• navLink(verb, path, query, fragment) (shared/nav.js) → `<verb> <scheme-

  less authority-scoped uri>: addressing via URI.make (authority INJECTED, rooted path), the verb prepended with a SPACE. No authority ⇒ <verb> path?q#f; empty addressing ⇒ the bare <verb>. Sibling to navUri`.

• Every projector swaps navUri("<verb>",…) → navLink("<verb>",…) for BOTH

  its U-tag click-targets AND its banner/record uri; navUri (scheme form) survives ONLY for a real transport, retired for links.

• The hunk record's uri field carries the WHOLE <verb> <uri> spell string

  (the word single-sourced as the LEADING token); the record verb slot stays "" — hunksFromLog can't decode the RON60 verb slot to text, and the C plain/color banner reads [<verb> ]<uri>, so an empty slot + a word-carrying uri render identically on BOTH the pager AND the plain/color edge.

• Banner-open: a projector that opened a hunk via a scheme-prefixed raw()

  (status:…) switches to the explicit out.open(navLink(...)) (hunkrows has open; status.js's local sinkOut gains a one-line open).

• Pager parse: _resolveSpell/_runSpell recognise a <verb> <rest> target

  (leading bareword + SPACE) as a COMPLETE absolute spell → driveSpell (spellCall→argline already splits verb arg), NO URI-relative mangling; _verbUri/_viewPath SPLIT the spell on the first space (drop scheme-decode).

• C-bridge: the <scheme>:-URI branch in _resolveSpell STAYS as a compat

  shim for C-baked diff:/cat: residue (out of scope) till the C follow-up; diff/cat U-targets are FINALISED in JS (diffOut.feed / cat) so the JS SUT converts them — native be output stays scheme-form till the C fix.

• Scope: the banner converts on ALL edges incl. the PLAIN columnar path, so

  jab status --plain's banner diverges from native be --plain (status: → status //name) until the C follow-up — INTENDED (not byte-parity); the plain-parity + links tests amend to the word shape (user-approved, Issues).

TODOs

• Repro: a baked status/log/diff link asserts the word URI shape and click-dispatches verb+uri (status/links, log/subnav, diff/links, uri011).
• Link composer: ONE shared helper navLink(verb,path,query,frag) (shared/nav.js) → <verb> <scheme-less authority-scoped URI>; navRelink for the C-bridge; navUri("<verb>",…) retired for LINKS.
• Convert every JS projector's U-tag click-targets to word-space form (status/log/commit/tree/cat/ls/spot/diff).
• Convert hunk BANNER/record URIs to the <verb> <uri> word spell (the word rides as the leading token; record verb slot left "" — hunksFromLog can't decode the RON60 slot).
• Convert the pager STATUS-BAR re-typeable address to <verb> <uri> (_verbUri/_splitSpell).
• Pager parse: drive links/banners as module(args) spells (SHARED spell machinery); a <verb>: scheme parse KEPT as the C-bridge only.
• Update nav/click/pager tests to the new shape (17 test files, user-approved).
• Grep-prove no JS baker emits a <verb>: scheme link (all 13 views on navLink/navRelink; grep clean).
• C follow-up: the weave/graf diff:/cat: bakers + the C HUNK hunk_uri_is_diff render gate — so jab diff --plain/--color + native be emit the word shape (JS keeps diff plain/color scheme-form until then).

Blockers and bummers

• C weave/graf still bakes some diff:/cat: scheme-form targets (out of scope) — the JS diff --plain/--color record uri STAYS scheme-form because the C HUNK hunk_uri_is_diff render gate keys off the diff: scheme (only --tlv/pager cuts over); filed as the C follow-up TODO above.
• Tests assert link TEXT → they changed shape (not byte-parity); user OK'd the amend (all-edges + amend, Issues).
• test/spot/submount FAILS — a PRE-EXISTING spot sub-recursion gap (the chsub/s.c sub-hit is dropped; verified identical on the unconverted tree), ORTHOGONAL to URI-014; candidate for its own SPOT ticket.

Outcome

• DONE (pending merge) — 2026-07-04, in worktree $SRC_ROOT/URI-014 (store-backed, beagle-ext). 16 source files (shared/nav.js navLink/navRelink, views/bro/pager.js _splitSpell/_verbUri/_resolveSpell/_runSpell/_viewPath, core/emit.js open, + all 13 projectors) + 17 test files; 93 tests green, 1 pre-existing fail (spot/submount). Links, banners, and the status-bar address are word URI spells — the verb out of the scheme slot, the scheme freed for real transports. Third axis of the link-correctness arc after URI-012 (resolution) and URI-013 (composition): SHAPE. NOT yet staged/committed — awaiting the user's explicit merge order.