taskops-cli 0.4.2__tar.gz → 0.5.1__tar.gz

{taskops_cli-0.4.2 → taskops_cli-0.5.1}/ARCHITECTURE.md

@@ -1012,7 +1012,8 @@ Both remaining items are done. The migration ran against all four v1 boards
 directory of board logs, so it is `pip install` into a venv and one pm2 entry
 (README, "Deployed"). **The box runs this tree** since 2026-08-09 (tk-df8e64,
 §17), so `https://taskops.bernardocastro.dev/<board>/ui/` answers `410` and one
-sentence, exactly as the trunk does (§16, §17). Re-derivable:
+sentence, exactly as the trunk does (§16, §17) — until a board with a declared
+forge gets its hosted window (§16, "The hosted window"). Re-derivable:
 `curl -s https://taskops.bernardocastro.dev/healthz` and
 `curl -w '%{http_code}' https://taskops.bernardocastro.dev/axion/ui/`
 — measured `{"boards": 4}` (after all four boards had been addressed through
@@ -1505,15 +1506,21 @@ construction and never sniffed per request** (`Mounts(repo=…)`,
 | `taskops serve` | a directory of boards, no checkout | **404 with the reason spelled out**, and nothing faked | **410 and one sentence** |
 
 The `/ui/` column arrived later, and it is the same `repo` deciding both — see
-"API ONLY is now literal" below.
+"API ONLY is now literal" below. Both cells of the `serve` row are narrowed a
+second time by "The hosted window" below: a board that DECLARED a forge may be
+answered from a bare read-only mirror of it, and only then. And the page's ADDRESS moved
+one notch after that: on a serve-mode host the last column is the board's own
+`/<board>/`, with `/<board>/ui/` kept as an alias — "The board's own address IS
+the page" at the end of this section.
 
 A viewer meets that gap whenever this clone cannot answer — a ref not fetched
 yet, a shallow checkout, a commit from before this repo had the branch — and
 there the UI's declared cascade takes over: numstat from the event → patch from
 /git → the forge link if a slug exists → one honest sentence. No dead anchor, no
 empty pane pretending. (The gap used to have a second, worse shape: a browser
-with no clone at all, pointed at the hosted page. There is no hosted page any
-more — see below.)
+with no clone at all, pointed at the hosted page. That page was withdrawn — see
+below — and comes back only standing on a real history: the forge mirror, in
+"The hosted window".)
 
 That cascade is ONE function — `ui/src/links.tsx::cascade`, beside the slug and
 the link templates it already owned — and `ui/src/components/card/Patch.tsx`
@@ -1595,9 +1602,11 @@ doubled separator and the directory itself, and never repairs one: a traversal
 normalised into something acceptable is the bug. Anything outside
 `.taskops/reports/` is a 400 that names the directory, and `tests/test_topology.py`
 walks every shape (a real secret one directory up included, asserting its
-contents appear nowhere in the answer). `taskops serve` still mounts no `/git`
-at all: the switch is `Mounts.repo`, decided once at construction, and a new
-question underneath it opens no door.
+contents appear nowhere in the answer). `taskops serve` mounts no `/git`
+from a checkout it does not have: the switch is `Mounts.repo`, decided once at
+construction, and a new question underneath it opens no door. The hosted-window
+amendment below changes what `repo` may point AT — a bare mirror of the
+declared forge — never the switch itself.
 
 ### The window: `taskops ui` serves locally even for a REMOTE board (2026-08-08)
 
@@ -1636,7 +1645,7 @@ The routes do not change, so the committed bundle is untouched by any of this:
 decision). The server used to serve the bundle too, from a `--ui` flag with a
 packaged default — so the box above answered `/ui/` with a real dashboard, and
 that dashboard could not draw a single patch, because the machine it was served
-from deliberately has no clone. It was a degraded window presented as *the*
+from deliberately had no clone. It was a degraded window presented as *the*
 window; the redirect above merely pointed people at it. **The binary serves the
 window; the server serves the truth.**
 
@@ -1644,7 +1653,9 @@ So: `Mounts.ui` is not a parameter, it is `repo`'s shadow — one construction-t
 switch mounts `/git` AND the bundle, and only a process standing in a checkout
 has either. `/ui/` on a board host answers `static.py::NO_UI` as plain text with
 **410 Gone**, not 404: 404 says "no idea, maybe later", and this page was
-withdrawn on purpose and is never coming back to a host with no clone. Plain
+withdrawn on purpose and is never coming back to a host with no clone — and a
+host holding the board's forge MIRROR is no longer that host ("The hosted
+window", below). Plain
 text and not the JSON envelope because the only reader who reaches that door is
 a human with a browser. The `--ui` flag is REMOVED, not deprecated: there is no
 command line that puts the decision back. The bundle still ships inside the
@@ -1709,6 +1720,66 @@ move a branch under a worktree somebody is sitting in.
 
 A repo joined to nothing behaves exactly as it did.
 
+### The hosted window: the host may hold a MIRROR of the declared forge (decided 2026-08-30)
+
+The first amendment narrowed "no server reads a repo" to "a host that sits in a
+repo may read it". This one narrows the other clause — *the server deliberately
+has no clone* — and, as before, the change is recorded here rather than quietly
+made:
+
+> **A board host MAY hold a bare, READ-ONLY mirror of the board's DECLARED
+> forge — and only then does it answer `/git` and `/ui/`.** A board with no
+> declared forge is exactly what it was: 404 on `/git`, 410 on `/ui/`, each
+> refusal naming `taskops board forge <owner>/<repo>` as the door.
+
+Why this is not the degraded window "API ONLY" withdrew. That window's flaw was
+never that a server drew a dashboard — it was that the machine drawing it had
+NO git at all, so every diff fell through the whole cascade to a forge link or
+a sentence, a blank presented as *the* window. The mirror removes the flaw, not
+the caution: it is **the same history the forge already holds** — `git clone
+--mirror` of the repo the owner declared with `board forge`, refreshed by ONE
+bounded on-demand fetch when a requested ref is missing, then answered stale
+rather than blocking — so a diff served from it is the diff GitHub would show,
+read by the same `gitwork/diff.py` doors, behind the same visibility rules as
+`/rpc`. And the dev-side story does not move an inch: `taskops ui` still serves
+the window from the checkout it stands in, reading the dev's OWN clone,
+including refs the forge has never seen. The hosted window is for the reader
+who has no clone — the case the local window, by construction, cannot serve.
+
+**Where it lives**: `<root>/<board>/mirror.git`, a bare repo beside the board's
+`events.jsonl` — later cards follow this wording. It is DERIVED and disposable
+in exactly the sense `cache.sqlite` is: delete it and it re-clones from the
+declared forge; nothing in it is truth the forge does not hold. Its ONLY source
+is that forge. It takes no client pushes — the host still exposes no receive
+door of any kind — and it is not a second trunk: nothing lands there, nothing
+is read back into the log from it, and `taskops_merge` still happens in the
+dev's shared checkout.
+
+**The credential story** is §19's, unchanged in kind. A public repo needs no
+credential at all. A private repo is fetched with an **ssh deploy key on the
+host's filesystem** — read-only, minted and installed by the OWNER, revocable
+on the forge like any deploy key — which is the ONE new credential this chapter
+adds, and it is the owner's business exactly as `board forge` itself is. What
+remains banned is what §11 and §19 already ban: a stored GitHub token (the
+mirror's remote is an address, never a token), a write credential in any form,
+GitHub as a second identity system, and any dev credential travelling to the
+host — nobody's `gh auth token` is involved, because the owner already declared
+the repo and the mirror pulls from the outside like any anonymous (or
+deploy-keyed) clone.
+
+**Still banned, spelled out**: client pushes to the host and git replication
+between clones (the mirror replicates FROM the forge, one direction, and no
+clone ever pushes to it); a write credential on the host; a second trunk; a
+`--ui` flag or any per-request sniffing (whether the mirror exists is decided
+at mount time, the same `Mounts.repo` switch, now pointable at `mirror.git`);
+and anonymous writes — a public board's hosted window is a READ, and it leaves
+no `presence` row.
+
+So `static.py::NO_UI` and `gitdoor.py::NO_REPO` change meaning, not words of
+intent: each stops saying "this host never has a repo" and starts saying "this
+BOARD declared no forge, so this host holds no mirror to read from" — a state
+the owner ends with one `taskops board forge`. The refusal still names the door.
+
 ### A concept named by two cards is a seam — the fan-out rule, third notch
 
 `gitwork/remote.py` was born TWICE in one wave: two workers, each over the
@@ -1755,6 +1826,98 @@ starts from the server's real shape, and `null` (fewer than two ready cards,
 nothing to decide) is deliberately a different state from absent (a board older
 than the wave).
 
+### A bare `Bearer` is NO credential, not an unknown one (2026-08-31)
+
+The hosted window shipped on 2026-08-30 and was unusable the next morning for
+the exact reader it was built for: a PUBLIC board, opened from its own hosted
+page, answered *"unknown credential — run: taskops join"*. Nothing about
+visibility was wrong. The page simply had no token, so the browser sent
+`Authorization: Bearer ` with an empty value; `auth.token_in`'s `removeprefix`
+did not match the header without its space-and-value, and it returned the
+literal string `Bearer` as if that were somebody's token. `creds.check` then did
+its job perfectly on a token nobody ever minted.
+
+So the fault was never in the visibility rule and never in the client. It was in
+the one place that decides what a header MEANS:
+
+> **An `Authorization` header that carries no value is the ABSENCE of a
+> credential, identical to sending no header at all. A header that carries a
+> value is a claim, and a claim that does not check out is refused with the
+> sentence it has always used.**
+
+Both halves are load-bearing, and the second is why this is not the tempting
+one-line generalisation. "Treat anything unparseable as anonymous" would make a
+typo'd token read a private board as far as its visibility allows and, worse,
+would turn an expired credential into a silent downgrade instead of the loud
+`unknown credential` it has always been. Empty is not wrong; wrong is wrong —
+and the two refusals stay different sentences: a caller who presented NOTHING to
+a private board is told how to join, a caller who presented something unknown is
+told it is unknown.
+
+It lives in ONE extractor (`http/auth.py::token_in`) because every door — `rpc`,
+`feed`, `git`, the static page — asks that function and nothing else. A second
+door with its own opinion about a header is how the fleet ends up with two
+credential rules, which is the failure mode §19 exists to prevent. `taskops
+ui`'s window never saw this: it mints a token before it opens a tab, so the only
+client that sends an empty bearer is the hosted page, and the hosted page is
+younger than the extractor.
+
+The lesson generalises past auth: **anonymous worked only because no client
+existed**. Every test that pinned "no header reads a public board" sent no
+header, because the only readers were `curl` and the MCP client. A browser
+cannot express "no header" through a fetch wrapper that always sets one — so a
+contract that is only ever exercised by hand-written clients is not pinned,
+it is merely unvisited. `tests/test_topology.py` now sends the bare header
+alongside the absent one, on a public board AND a private one, which is the pair
+that says which of the two rules above is being tested.
+
+### The board's own address IS the page (2026-08-31)
+
+The same report carried a second complaint, and it is a design one: the page was
+at `/<board>/ui/`. A board host serves exactly one thing to a human, and it had
+been given a sub-path — so the URL a person pastes says `ui` twice over (once in
+the product's name for the thing, once in the path) and the shortest address on
+the host, `/<board>/`, answered 404. Whatever a host serves to people belongs at
+its own address; a prefix is for the doors people never type.
+
+> **A board's page is served at `/<board>/` (and `/<board>`, bare). The MACHINE
+> doors move under `/<board>/api/…` — `rpc`, `git/…`, `feed`, `invite/redeem`.**
+
+Two facts make that router unambiguous rather than a guess per request. The
+prefix is stripped ONCE, in `http/routes.py::split`, shared by GET and POST, so
+`/<board>/api/rpc` IS `/<board>/rpc` — same handler, same credential, same
+words, and no door can drift from the other spelling. And the page's own
+relative links (`./app.js`, `./style.css` off `index.html`) now arrive as board
+tails, which the router separates from doors by a CLOSED SET: `static.py::asset`
+asks the packaged bundle what files it actually ships, flat, with a suffix in
+`TYPES`. None is named `rpc`, `git`, `feed`, `ui` or `api`, so an asset can
+never shadow a door and a door never shadows an asset — and a bundle that grows
+a font ships without a router edit. The host's own one-segment doors (`/login`,
+`/rpc`, `/healthz`) are untouched, because the strip lives in the TAIL and never
+sees them; a board literally named `api` still answers at `/api/…`.
+
+**The 0.5.0 spellings are kept, not deprecated** — `/<board>/ui/`,
+`/<board>/rpc`, `/<board>/git/…`, `/<board>/feed` all answer, unprefixed and
+without a redirect. Not out of politeness: links to them were pasted the day
+they existed, `.mcp.json` files and agents are configured against them, four
+legacy-bearer production boards speak them, and `taskops ui`'s upstream forward
+builds them. A redirect would have been the tidier story and would have broken
+every POST that follows one badly. So the rule this chapter adds about old
+addresses is the one it also obeys: **an address that ever worked keeps
+answering, and the new one is where the page POINTS people.** `ui/src/client.ts`
+derives its base from the page's own location (`baseOf`) precisely so the page
+never hardcodes which of the two it was loaded from.
+
+**Both faults are pinned live, not only in the suite.** `smoke.sh` at the repo
+root is the re-runnable list — every assertion in it is one of these two reports
+or something 0.5.0 already promised, read-only, and it exits on the first
+failure:
+
+```sh
+sh smoke.sh                                   # taskops.bernardocastro.dev, taskops-v2
+sh smoke.sh <host> <board> <private-board>
+```
+
 ---
 
 ## 17. Deployed — taskops.bernardocastro.dev is v2 (2026-08-08)
@@ -1803,7 +1966,9 @@ request (`http/mounts.py::stores`), so a just-restarted process says `1`, not
 
 **That md5-of-the-served-bundle check is history, not the procedure any more.**
 Since §16's "API ONLY" amendment the host serves no bundle: `/<board>/ui/`
-answers `410` and one sentence, so there is nothing at the domain to md5. The
+answers `410` and one sentence (until the hosted-window chapter deploys a board
+whose forge is declared — §16, "The hosted window"), so there is nothing at the
+domain to md5. The
 wheel is still checked for its markers *before* it ships — it is the same wheel
 teammates install to get `taskops ui` — and the domain is verified by DATA,
 through `/rpc`.

{taskops_cli-0.4.2 → taskops_cli-0.5.1}/CHANGELOG.md

@@ -3,6 +3,83 @@
 The source of truth for release notes — GitHub Releases are extracted from
 here, never written twice.
 
+## 0.5.1 — the hosted window, actually usable
+
+0.5.0 shipped a window nobody could use. Both faults were reported the next
+morning against the live host, and both were contract-level: the URL people
+paste, and the credential rule every door shares.
+
+- **A public board was unreadable from its own hosted page.** The client sends
+  `Authorization: "Bearer " + token()`; with no token that header arrives as
+  `Bearer`, and `auth.token_in`'s `removeprefix("Bearer ")` did not match — so
+  the literal string `"Bearer"` came back AS the token and the reader was told
+  "unknown credential — run: taskops join". Anonymous reads worked only when NO
+  Authorization header was sent at all, which no browser client does: the
+  anonymous path was only ever green because nothing but curl had walked it.
+  Scheme and value are now parsed as separate fields, the scheme
+  case-insensitive per RFC 7235, and a bearer scheme with no value is the
+  ABSENCE of a credential. Deliberately narrow: a header carrying any actual
+  value — wrong, expired, or under a scheme this server never spoke — is a
+  credential that WAS presented and still refuses exactly as before.
+  "Unparseable" is not "anonymous".
+- **The board's own address IS the page.** `https://<host>/<board>/` (and
+  `/<board>`) serves the dashboard, with `app.js` and `style.css` beside it; the
+  machine doors also answer under `/<board>/api/{rpc,git,feed}`, stripped once
+  in `http/routes.py::split` so no door can drift from another. A sub-path was
+  wrong for the primary thing a board host serves.
+- **Nothing that worked in 0.5.0 stopped working.** `/<board>/ui/`,
+  `/<board>/rpc`, `/<board>/git/…` and `/<board>/feed` all still answer — agents,
+  the MCP client, `taskops ui`'s forward and the legacy production boards speak
+  them, and a link somebody already pasted is a contract, not a legacy.
+- **`smoke.sh`** — the live, read-only smoke for a board host: the page at the
+  board root, a bare `Bearer` reading a public board, a private board still
+  refusing, a card branch's diff rendered from the forge mirror. Every line is
+  there because it failed once in production, and each says which report it
+  came from.
+
+## 0.5.0 — the hosted window
+
+- **A board can be READ without a clone.** Until now the dashboard was only ever
+  served by `taskops ui`, a binary standing in a checkout: a host running
+  `taskops serve` answered `/git` with a 404 and `/ui/` with a 410, because a
+  dashboard draws DIFFS and the host deliberately had no repository to read them
+  from. Serving a page that could not draw a single patch was a degraded window
+  presented as *the* window, so it was withdrawn. That reasoning had one
+  unexamined premise — that the host can never have git — and this release
+  removes it, argued in ARCHITECTURE §16 ("The hosted window") before a line of
+  code moved.
+- **The host may hold a bare, READ-ONLY mirror of the board's DECLARED forge**,
+  at `<root>/<board>/mirror.git`, and only then does it answer `/git` and
+  `/ui/`. The mirror is derived and disposable in exactly the sense
+  `cache.sqlite` is: delete it and it re-clones; nothing in it is truth the
+  forge does not already hold. Its ONLY source is the repo the owner declared
+  with `taskops board forge` — it takes no client pushes, it is not a second
+  trunk, and nothing is ever read back into the log from it.
+- **A board that declared no forge is exactly what it was**: 404 on `/git`,
+  410 on `/ui/`, and each refusal now names the door — `taskops board forge
+  <owner>/<repo>` — instead of stranding the reader in a sentence about a host
+  they cannot change.
+- **No new credential type.** A public repo is mirrored anonymously; a private
+  one is fetched with an ssh deploy key on the host's filesystem, installed by
+  the OWNER, revocable on the forge — the one new credential this chapter adds,
+  and it is the owner's business exactly as `board forge` itself is. No stored
+  GitHub token, no dev credential travelling, no second identity system.
+- **The page opens on the FACT, never on a clone.** `/ui/` is granted by the
+  declared forge alone: the bundle's bytes come from the installed package, so
+  putting a network clone in front of `index.html` would take a static page down
+  whenever the forge is unreachable. The mirror resolves lazily the moment a
+  diff is actually read — which is where a failure belongs, in the diff pane, in
+  the door's own words.
+- **A missing ref buys exactly ONE bounded fetch**, then answers stale rather
+  than blocking a page on a forge that is down — and only on a mirror. A
+  window's own clone still fetches nothing on the reader's behalf: a background
+  fetch inside a read-only door would move a branch under a worktree somebody is
+  sitting in.
+- **Reads stay reads.** `/ui/` sits behind the credential `/rpc` asks for —
+  a `public` board serves the page to an anonymous reader, a private one refuses
+  with the same join sentence — and an anonymous page load writes nothing at
+  all, not even the invisible write: no presence row.
+
 ## 0.4.2 — the filter that filtered nothing, and the window that stopped signing in
 
 - **"All chapters" is an ARGUMENT now, and it really shows every chapter.** The

{taskops_cli-0.4.2 → taskops_cli-0.5.1}/CLAUDE.md

@@ -228,6 +228,17 @@ what it exists to report, not a fault.
 - One card rebuilds the bundle at the end of a wave. N cards rebuilding it is
   N-1 conflicts by construction.
 
+**The hosted page is at the board's OWN address** — `https://<host>/<board>/`
+(and `/<board>`), its assets beside it, the machine doors under
+`/<board>/api/{rpc,git,feed}`. 0.5.0's spellings (`/<board>/ui/`,
+`/<board>/rpc`, `/<board>/git/…`, `/<board>/feed`) still answer and are a
+contract, not a legacy — ARCHITECTURE §16, "The board's own address IS the
+page". The page derives its base from its own location
+(`ui/src/client.ts::baseOf`) and hardcodes neither. `sh smoke.sh` re-derives all
+of it against the live host, plus the credential rule a browser exposed:
+**an `Authorization` header with no value is the ABSENCE of a credential, a
+header with a wrong value still refuses loudly** (`http/auth.py::token_in`).
+
 ## Never re-introduce
 
 Each has its line in ARCHITECTURE.md §11 saying what it cost and where it is

{taskops_cli-0.4.2 → taskops_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskops-cli
-Version: 0.4.2
+Version: 0.5.1
 Summary: A shared work board for teams of coding agents, with a human who decides.
 Project-URL: Repository, https://github.com/bernatch22/taskops
 License-Expression: MIT
@@ -70,7 +70,7 @@ importable leaves commits un-stamped, silently.
 taskops init                              a local board in this repo
 taskops join [<name>] [--invite <id>]     join a board, install the hooks
 taskops remote add <url>                  the host this checkout operates, like git's origin
-taskops serve                             host boards — an events API, no dashboard
+taskops serve                             host boards — the page and /git open per declared forge
 taskops server init                       bootstrap THIS host: its owner and their ssh key
 taskops board create|ls|push|pull|rm      the boards on a host
 taskops board visibility|forge            who may read one · which repo's team is enrolled
@@ -383,9 +383,31 @@ to bytes that are not in history yet is a pointer to nothing.
 ```
 
 Then `taskops ui` lists it under the chapter's **Reports** tab and renders it
-full width, read out of **your own clone** at that sha — the dashboard never
-asks the server for the bytes, and there is nothing to serve: a host running
-`taskops serve` answers `/git` with a 404, whole.
+full width, read out of **your own clone** at that sha — the local dashboard
+never asks the server for the bytes. A host running `taskops serve` answers
+`/git` too, from a bare read-only mirror of the board's DECLARED forge — the
+hosted window, for the reader with no clone. A board that never declared one
+refuses with a sentence naming `taskops board forge <owner>/<repo>`.
+
+**The hosted page is at the board's OWN address.** `https://<host>/<board>/`
+IS the dashboard — not a sub-path under it — and the machine doors sit under a
+prefix that can never collide with a page asset:
+
+```
+https://<host>/<board>/            the page          (also /<board>, no slash)
+https://<host>/<board>/app.js      its assets        style.css, index.html
+https://<host>/<board>/api/rpc     the verbs         also /<board>/rpc
+https://<host>/<board>/api/git/…   diffs from the mirror   also /<board>/git/…
+https://<host>/<board>/api/feed    the live feed     also /<board>/feed
+https://<host>/healthz             the host itself
+```
+
+The right-hand spellings are 0.5.0's and they keep answering, unprefixed and
+un-redirected — including `/<board>/ui/`, which was the page's address for one
+day. Links were pasted, agents and the MCP client are configured against them,
+and `taskops ui`'s upstream forward speaks them, so they are a contract now
+rather than a legacy. Re-derivable at any time with `sh smoke.sh <host>
+<board>`.
 
 **Reading one, from the other side.** Everything above is the author's half; a
 reader needs no ceremony at all. Three doors onto the same bytes:

{taskops_cli-0.4.2 → taskops_cli-0.5.1}/README.md

@@ -58,7 +58,7 @@ importable leaves commits un-stamped, silently.
 taskops init                              a local board in this repo
 taskops join [<name>] [--invite <id>]     join a board, install the hooks
 taskops remote add <url>                  the host this checkout operates, like git's origin
-taskops serve                             host boards — an events API, no dashboard
+taskops serve                             host boards — the page and /git open per declared forge
 taskops server init                       bootstrap THIS host: its owner and their ssh key
 taskops board create|ls|push|pull|rm      the boards on a host
 taskops board visibility|forge            who may read one · which repo's team is enrolled
@@ -371,9 +371,31 @@ to bytes that are not in history yet is a pointer to nothing.
 ```
 
 Then `taskops ui` lists it under the chapter's **Reports** tab and renders it
-full width, read out of **your own clone** at that sha — the dashboard never
-asks the server for the bytes, and there is nothing to serve: a host running
-`taskops serve` answers `/git` with a 404, whole.
+full width, read out of **your own clone** at that sha — the local dashboard
+never asks the server for the bytes. A host running `taskops serve` answers
+`/git` too, from a bare read-only mirror of the board's DECLARED forge — the
+hosted window, for the reader with no clone. A board that never declared one
+refuses with a sentence naming `taskops board forge <owner>/<repo>`.
+
+**The hosted page is at the board's OWN address.** `https://<host>/<board>/`
+IS the dashboard — not a sub-path under it — and the machine doors sit under a
+prefix that can never collide with a page asset:
+
+```
+https://<host>/<board>/            the page          (also /<board>, no slash)
+https://<host>/<board>/app.js      its assets        style.css, index.html
+https://<host>/<board>/api/rpc     the verbs         also /<board>/rpc
+https://<host>/<board>/api/git/…   diffs from the mirror   also /<board>/git/…
+https://<host>/<board>/api/feed    the live feed     also /<board>/feed
+https://<host>/healthz             the host itself
+```
+
+The right-hand spellings are 0.5.0's and they keep answering, unprefixed and
+un-redirected — including `/<board>/ui/`, which was the page's address for one
+day. Links were pasted, agents and the MCP client are configured against them,
+and `taskops ui`'s upstream forward speaks them, so they are a contract now
+rather than a legacy. Re-derivable at any time with `sh smoke.sh <host>
+<board>`.
 
 **Reading one, from the other side.** Everything above is the author's half; a
 reader needs no ceremony at all. Three doors onto the same bytes:

taskops_cli-0.5.1/smoke.sh

@@ -0,0 +1,164 @@
+#!/bin/sh
+# The live smoke for a taskops board HOST. Read-only, no credential, no state:
+# every request below is a GET or a `board` read, so it is safe to run against
+# production at any time, including from a laptop that never joined the board.
+#
+#   sh smoke.sh                                  # the author's host, defaults below
+#   sh smoke.sh <host> <public-board> <private-board> <card-branch>
+#
+# Every assertion is here because it FAILED once, in production, against a real
+# reader — the comment above each one says which report it comes from. Nothing
+# is asserted because it seemed prudent: a smoke list that grows by taste stops
+# being read, and a green line that never could have gone red is a lie about
+# coverage. It exits non-zero on the FIRST failure, so the first red line is the
+# whole diagnosis.
+#
+# `pass` prints what was actually observed, never just OK — a smoke you cannot
+# read the evidence out of is a smoke you end up re-running by hand anyway.
+
+set -eu
+
+HOST=${1:-taskops.bernardocastro.dev}
+BOARD=${2:-taskops-v2}
+PRIVATE=${3:-axion}
+BRANCH=${4:-tk-32d2ba}
+
+BASE="https://$HOST"
+C="curl -sS -m 15"
+
+fail() { printf '\nFAIL  %s\n      %s\n' "$1" "$2" >&2; exit 1; }
+pass() { printf 'ok    %s\n        %s\n' "$1" "$2"; }
+head_ln() { printf '\n-- %s\n' "$1"; }
+
+# ── (e) the host itself ───────────────────────────────────────────────────────
+# First, because every failure below is ambiguous until this one is green: a
+# 502 from the proxy and a broken board answer the same shape of nothing.
+head_ln "healthz — the host is up"
+body=$($C "$BASE/healthz") || fail "GET /healthz" "no answer from $BASE"
+case $body in
+  *'"ok": true'*|*'"ok":true'*) pass "GET /healthz" "$body" ;;
+  *) fail "GET /healthz" "$body" ;;
+esac
+
+# ── (a) the board's own address IS the page ───────────────────────────────────
+# Reported 2026-08-31: the page was at /<board>/ui/ and /<board>/ was a 404 —
+# the shortest address on the host, the one a person types, answered nothing.
+# Asserted on the BARE path too: /<board> without the trailing slash is what
+# gets pasted into Slack, and a router that only handles one of the two looks
+# fine in a browser (it follows the redirect) and breaks every copied link.
+head_ln "the page at the board's own address"
+for path in "/$BOARD/" "/$BOARD"; do
+  page=$($C "$BASE$path") || fail "GET $path" "no answer"
+  case $page in
+    *'app.js'*) pass "GET $path" "html referencing app.js ($(printf %s "$page" | wc -c | tr -d ' ') bytes)" ;;
+    *) fail "GET $path" "not the page: $(printf %s "$page" | head -c 200)" ;;
+  esac
+done
+# And its assets resolve from that address: the page's own links are relative
+# (./app.js off index.html), so they arrive as board TAILS and the router has to
+# tell them from the machine doors. If this 404s, the page loads unstyled and
+# blank with nothing in the server log to say why.
+for asset in app.js style.css; do
+  code=$($C -o /dev/null -w '%{http_code} %{content_type}' "$BASE/$BOARD/$asset") \
+    || fail "GET /$BOARD/$asset" "no answer"
+  case $code in
+    200*) pass "GET /$BOARD/$asset" "$code" ;;
+    *) fail "GET /$BOARD/$asset" "$code" ;;
+  esac
+done
+
+# ── (b) a bare `Bearer` reads a PUBLIC board ──────────────────────────────────
+# THE fault of this chapter, shipped in 0.5.0 and reported 2026-08-31: the page
+# sends `Authorization: "Bearer " + token()`, so with no token the header
+# arrives as `Bearer`, and the old extractor returned the literal string
+# "Bearer" as somebody's token — "unknown credential — run: taskops join" to a
+# reader who presented nothing. Anonymous reads worked only with NO header at
+# all, which no browser client can express. Both shapes are asserted: the
+# no-header stranger (what the suite always tested) and the bare bearer (what
+# every browser actually sends).
+head_ln "a bare Bearer is no credential — public board reads"
+rpc() { # rpc <path> [<authorization value>]
+  if [ $# -gt 1 ]; then
+    $C -o /dev/null -w '%{http_code}' -X POST "$BASE$1" \
+      -H 'Content-Type: application/json' -H "Authorization: $2" \
+      -d '{"verb": "board", "args": {}}'
+  else
+    $C -o /dev/null -w '%{http_code}' -X POST "$BASE$1" \
+      -H 'Content-Type: application/json' -d '{"verb": "board", "args": {}}'
+  fi
+}
+code=$(rpc "/$BOARD/api/rpc" "Bearer") || fail "POST /$BOARD/api/rpc (bare Bearer)" "no answer"
+[ "$code" = 200 ] || fail "POST /$BOARD/api/rpc (bare Bearer)" "HTTP $code — the 0.5.0 fault is back"
+pass "POST /$BOARD/api/rpc  Authorization: Bearer" "HTTP 200"
+code=$(rpc "/$BOARD/api/rpc") || fail "POST /$BOARD/api/rpc (no header)" "no answer"
+[ "$code" = 200 ] || fail "POST /$BOARD/api/rpc (no header)" "HTTP $code"
+pass "POST /$BOARD/api/rpc  no Authorization" "HTTP 200"
+# The other half of that fix, and the reason it is not a one-line
+# generalisation: a credential that WAS presented and does not check out still
+# refuses loudly. "Unparseable is anonymous" would turn an expired token into a
+# silent read-only downgrade instead of a sentence naming the way back in.
+body=$($C -X POST "$BASE/$BOARD/api/rpc" -H 'Content-Type: application/json' \
+  -H 'Authorization: Bearer not-a-token' -d '{"verb": "board", "args": {}}') \
+  || fail "POST with a wrong token" "no answer"
+case $body in
+  *'unknown credential'*) pass "POST /$BOARD/api/rpc  Bearer not-a-token" "refused: unknown credential" ;;
+  *) fail "POST with a wrong token" "$body" ;;
+esac
+
+# ── (c) a PRIVATE board still refuses ─────────────────────────────────────────
+# The wall moved for public boards; it must not have moved here. And the
+# SENTENCE matters as much as the status: somebody who presented nothing is told
+# how to join, which is a different answer from "unknown credential".
+head_ln "a private board still refuses the same stranger"
+body=$($C -X POST "$BASE/$PRIVATE/api/rpc" -H 'Content-Type: application/json' \
+  -H 'Authorization: Bearer' -d '{"verb": "board", "args": {}}') \
+  || fail "POST /$PRIVATE/api/rpc" "no answer"
+# Grepped for `no credential` and NOT for `taskops join`: both refusals name
+# that command, so the looser grep passes on the 0.5.0 fault itself — where a
+# private board answered `unknown credential` to a stranger who presented
+# nothing. The whole point is WHICH sentence comes back.
+case $body in
+  *'no credential'*) pass "POST /$PRIVATE/api/rpc  Authorization: Bearer" "refused: no credential — run: taskops join" ;;
+  *) fail "POST /$PRIVATE/api/rpc" "expected the no-credential refusal, got: $body" ;;
+esac
+
+# ── (d) a card branch renders a diff from the forge mirror ────────────────────
+# The hosted window's whole point: a reader with NO clone. Before the mirror,
+# every diff fell through the UI's cascade to a forge link — a blank presented
+# as the window. A tk-* branch on purpose: `master` is fetched by any clone, and
+# the failure this catches is a mirror whose on-demand fetch never ran, which
+# only shows on a ref the mirror did not have at clone time.
+head_ln "a card branch diffs from the mirror"
+body=$($C "$BASE/$BOARD/api/git/commit/$BRANCH") || fail "GET git/commit/$BRANCH" "no answer"
+case $body in
+  *'"patch"'*) pass "GET /$BOARD/api/git/commit/$BRANCH" "a diff ($(printf %s "$body" | wc -c | tr -d ' ') bytes)" ;;
+  *) fail "GET git/commit/$BRANCH" "no diff: $(printf %s "$body" | head -c 300)" ;;
+esac
+
+# ── (f) every 0.5.0 address still answers ─────────────────────────────────────
+# Links were pasted the day they existed, .mcp.json files are configured against
+# them, four legacy-bearer production boards speak them, and `taskops ui`'s
+# upstream forward builds them. An old address that 404s in silence is this
+# chapter's own rule broken.
+head_ln "the 0.5.0 addresses, unprefixed"
+code=$($C -o /dev/null -w '%{http_code}' "$BASE/$BOARD/ui/") || fail "GET /$BOARD/ui/" "no answer"
+[ "$code" = 200 ] || fail "GET /$BOARD/ui/" "HTTP $code"
+pass "GET /$BOARD/ui/" "HTTP 200"
+code=$(rpc "/$BOARD/rpc" "Bearer") || fail "POST /$BOARD/rpc" "no answer"
+[ "$code" = 200 ] || fail "POST /$BOARD/rpc" "HTTP $code"
+pass "POST /$BOARD/rpc" "HTTP 200"
+code=$($C -o /dev/null -w '%{http_code}' "$BASE/$BOARD/git/commit/$BRANCH") \
+  || fail "GET /$BOARD/git/commit/$BRANCH" "no answer"
+[ "$code" = 200 ] || fail "GET /$BOARD/git/commit/$BRANCH" "HTTP $code"
+pass "GET /$BOARD/git/commit/$BRANCH" "HTTP 200"
+# /feed is a stream that never ends by design, so this reads the HEADERS and
+# hangs up. curl's own timeout is therefore EXPECTED here and not a failure —
+# what is asserted is the content type, which is what tells an SSE client it may
+# start reading.
+headers=$(curl -sS -m 3 -D - -o /dev/null "$BASE/$BOARD/feed" 2>/dev/null || true)
+case $headers in
+  *event-stream*) pass "GET /$BOARD/feed" "text/event-stream" ;;
+  *) fail "GET /$BOARD/feed" "no event-stream header: $(printf %s "$headers" | tr '\r\n' '  ')" ;;
+esac
+
+printf '\nall green — %s, board %s\n' "$HOST" "$BOARD"

{taskops_cli-0.4.2 → taskops_cli-0.5.1}/src/taskops/_version.py

@@ -1,4 +1,4 @@
 from __future__ import annotations
 
 __title__ = "taskops"
-__version__ = "0.4.2"  # single source of truth; pyproject reads it dynamically
+__version__ = "0.5.1"  # single source of truth; pyproject reads it dynamically