taskops-cli 0.5.2__tar.gz → 0.5.3__tar.gz

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/ARCHITECTURE.md

@@ -1526,9 +1526,16 @@ below — and comes back only standing on a real history: the forge mirror, in
 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`
 only DRAWS the step it is handed, so no component holds a fallback order of its
-own. It feeds the dossier's **Files changed** (the card as a PR:
-`compare/ms/<slug>...tk-<id>`, the file list from `stat`, each file's patch on
-expand via `?path=`) and the fold on every commit row. Availability is
+own. It feeds the dossier's **Files changed** (the card as a PR, over the range
+the BOARD recorded rather than two branch names — `links.tsx::cardRange`: one
+recorded commit goes through `commit/<sha>`, which the door diffs against its
+first parent, and several become `compare/<first>^...<last>`, whose base is the
+oldest commit's PARENT so that commit's own changes are inside the range. Both
+ends are durable, which is what makes the pane render for a card whose `tk-*`
+and `ms/*` branches were pruned before this host became the remote — the head
+alone was not enough, 0.5.2 shipped that and the pane stayed empty. Then the
+file list from `stat`, each file's patch on expand via `?path=`) and the fold on
+every commit row. Availability is
 DISCOVERED, not configured: the first refusal whose words are
 `gitdoor.py::NO_REPO` flips a module-level flag for the session and nothing asks
 again — an unknown ref does not flip it, because that means "ask again for
@@ -1542,6 +1549,10 @@ effect firing, and that half is covered against a real server in
 chapter): `pages/WorktreeDiff.tsx`, the full-width page a Worktrees row opens,
 hands its whole range `<milestone branch>...tk-<id>` to the very same
 `FilesChanged` — plus a summary bar, which is a prop on it and not a second ask.
+Two live BRANCHES there, deliberately, where the dossier asks by sha: that page's
+subject is a working tree that exists on disk right now, so where its two tips
+stand IS the question. `FilesChanged` therefore takes a whole `GitTarget` rather
+than a base/head pair — a pair could only ever express the second question.
 Nothing else moved to do that: **no verb, no stored key, no change to the door**,
 and no component fetches a patch outside `cascade()`. The one seam this cost is
 `FileList` exported beside `FilesChanged` — the pure half, given a step — for

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/CHANGELOG.md

@@ -3,6 +3,32 @@
 The source of truth for release notes — GitHub Releases are extracted from
 here, never written twice.
 
+## 0.5.3 — the Files-changed pane renders for a landed card
+
+- **The pane asked for two branch names, and a landed card has neither.**
+  0.5.2 made the HEAD durable — the card's newest recorded sha instead of its
+  branch — and stopped there. The BASE stayed the chapter's branch name, and
+  for every card that landed before this host became the board's remote that
+  branch was pruned on the forge, so the compare refused and the pane was
+  empty while the commits sat in the trunk. Reported live on tk-bffa26.
+- **The range now comes from the card's own commits, both ends**
+  (`ui/src/links.tsx::cardRange`): one recorded commit goes through the commit
+  door, which already diffs a commit against its first parent; several become
+  `compare/<oldest>^...<newest>`. The base is the oldest commit's PARENT, not
+  the oldest commit — `git diff` is exclusive of its base, so `<oldest>...<newest>`
+  answers 200 with that commit's own changes silently missing, which is a pane
+  that looks complete and is not. No server change was needed: `<sha>^` already
+  passed the ref shape and resolves through `^{commit}`.
+- **Pinned where it broke.** The pane renders the route it asked for, and a
+  smoke section reads that route off the rendered component — the previous
+  attempt was pinned one layer below the call site, so a call-site mutation
+  went green while the pane stayed broken. `smoke.sh` now derives the same
+  route from the LIVE card payload and asserts the first commit's files are in
+  the answer.
+- **"so them was never pushed here"** — the host's missing-ref refusal had a
+  plural substitution in a subject slot. The number now runs through the whole
+  sentence, and both forms are pinned as bytes.
+
 ## 0.5.2 — the host holds the git; GitHub is the copy
 
 0.5.0 and 0.5.1 built the hosted window on a mirror the host PULLED from the

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: taskops-cli
-Version: 0.5.2
+Version: 0.5.3
 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

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/src/taskops/_version.py

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

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/src/taskops/http/stale.py

@@ -49,12 +49,12 @@ that reader and must not drift toward the host's."""
 HOSTED = (
     "{refs} not in this board's own repository on this host. Nothing was "
     "pruned to make that true — this host keeps every branch pushed to it "
-    "forever — so {them} was never pushed here: a card worked before this host "
-    "became the board's remote, or a worktree whose commits have not left it. "
+    "forever — so {subject} never pushed here: {cause}. "
     "A commit reaches this repository the moment it is made in a worktree "
     "joined to the board; the declared forge is a copy of what is here, never "
     "the other way round, so there is nowhere else this pane could look."
 )
+
 """The HOST's words — a reader with no clone, who can run nothing. No command
 is named because there is none they could run, and no forge is named because
 the forge is no longer a source: under the reversal it is a projection of this
@@ -62,6 +62,21 @@ repository, so "not here" is not "look over there". What replaced the mirror's
 "a pruned branch is normal" is the stronger fact — this host prunes nothing —
 and therefore a different diagnosis: the commits never arrived."""
 
+SINGLE = (
+    "a card worked before this host became the board's remote, or a "
+    "worktree whose commits have not left it"
+)
+SEVERAL = (
+    "cards worked before this host became the board's remote, or "
+    "worktrees whose commits have not left them"
+)
+"""The DIAGNOSIS, in the number of the refs it explains. It is an apposition
+to the missing refs themselves — "they were never pushed here: cards worked
+before …" — so it declines with them, subject and possessive both: one ref
+missing is one card or one worktree, several are cards or worktrees. 0.5.2
+shipped "so them was never pushed here" with this clause frozen singular; a
+sentence a reader is meant to trust cannot ask them to forgive its grammar."""
+
 SHA = "0123456789abcdef"
 
 
@@ -82,7 +97,11 @@ def sentence(*refs: str, hosted: bool = False) -> str:
     listed = f"{' and '.join(names)} {'are' if many else 'is'}"
     them = "them" if many else "it"
     if hosted:
-        return HOSTED.format(refs=listed, them=them)
+        return HOSTED.format(
+            refs=listed,
+            subject="they were" if many else "it was",
+            cause=SEVERAL if many else SINGLE,
+        )
     branches = [ref for ref in names if not _looks_like_a_sha(ref)]
     return STALE.format(
         refs=listed,

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/tests/test_topology.py

@@ -2101,6 +2101,105 @@ def test_the_hosts_missing_ref_sentence_says_what_a_host_that_prunes_nothing_can
     assert "Nothing was pruned" in message and "never pushed here" in message
 
 
+# ── the CARD'S OWN RANGE, asked by sha (ui/src/links.tsx::cardRange) ───────
+
+
+def test_a_landed_cards_own_commits_name_a_range_this_host_can_read(
+    server: BoardServer, tmp_path: Path
+) -> None:
+    """The reported failure, end to end and on the SERVER side of it.
+
+    A card's branches — its own and its chapter's — were pruned on the forge
+    before this host became the board's remote, so neither name resolves here
+    while both of the card's commits sit in the trunk that was pushed. The
+    dossier therefore asks by sha, and for a multi-commit card the base is the
+    FIRST commit's PARENT: `<sha>^`, a spelling `gitwork/diff.py` already
+    resolves (`SHAPE` admits `^`, `resolve()` peels `^{commit}`), which is why
+    this chapter added nothing to the door.
+
+    The last assertion is the one worth having: with the first SHA as the base
+    instead of its parent, the door still answers 200 and the pane still looks
+    complete — with that commit's file silently missing. That is the failure
+    mode the `^` exists to prevent, and it is pinned here as the difference
+    between the two ranges rather than described.
+    """
+    from urllib.parse import quote
+
+    from taskops.gitwork import bare
+    from tests.test_mirror import run, commit, forge_repo
+
+    src = forge_repo(tmp_path / "fixture")
+    run.must("switch", "-q", "-c", "tk-range", cwd=src)
+    first = commit(src, "one.py")
+    last = commit(src, "two.py")
+    run.must("switch", "-q", "main", cwd=src)
+    run.must("merge", "--no-ff", "-q", "-m", "land tk-range", "tk-range", cwd=src)
+    repo = bare.ensure(server.mounts.root / BOARD)
+    run.must("push", str(repo), "main:refs/heads/main", cwd=src)
+    token = _token(server, BERNA)
+
+    status, _ = _get(f"{url_of(server)}/git/commit/tk-range", token)
+    assert status == 404, "the branch must be absent, or this proves nothing"
+
+    # percent-encoded, as `links.tsx::gitRoute` sends it: `...` is the route's
+    # grammar and stays literal, everything else is one encoded ref.
+    base = quote(f"{first}^", safe="")
+    status, body = _get(f"{url_of(server)}/git/compare/{base}...{last}", token)
+    assert status == 200, body
+    assert set(body["data"]["stat"]) == {"one.py", "two.py"}
+
+    status, dropped = _get(f"{url_of(server)}/git/compare/{first}...{last}", token)
+    assert status == 200 and set(dropped["data"]["stat"]) == {"two.py"}
+def test_the_hosts_missing_ref_sentence_is_grammatical_for_one_ref(
+    server: BoardServer, tmp_path: Path
+) -> None:
+    """The SINGULAR half, whole. 0.5.2 served "so them was never pushed here"
+    on the live window: a plural substitution in a subject slot. The number
+    now runs through the whole sentence — subject, verb and the diagnosis it
+    introduces — so both halves are pinned as bytes, not as substrings."""
+    _own_git(server, tmp_path / "fixture")
+    status, body = _get(
+        f"{url_of(server)}/git/commit/tk-dfaff7", _token(server, BERNA)
+    )
+    assert status == 404
+    assert body["error"]["message"] == (
+        "tk-dfaff7 is not in this board's own repository on this host. "
+        "Nothing was pruned to make that true — this host keeps every branch "
+        "pushed to it forever — so it was never pushed here: a card worked "
+        "before this host became the board's remote, or a worktree whose "
+        "commits have not left it. A commit reaches this repository the moment "
+        "it is made in a worktree joined to the board; the declared forge is a "
+        "copy of what is here, never the other way round, so there is nowhere "
+        "else this pane could look."
+    )
+
+
+def test_the_hosts_missing_ref_sentence_is_grammatical_for_several_refs(
+    server: BoardServer, tmp_path: Path
+) -> None:
+    """The PLURAL half — the one that was wrong. A compare asks for two refs
+    at once, which is exactly how the live report arrived: base ms/… and head
+    tk-… both absent. "they were never pushed here: cards worked … or
+    worktrees whose commits have not left them" — read it aloud; that is the
+    contract."""
+    _own_git(server, tmp_path / "fixture")
+    status, body = _get(
+        f"{url_of(server)}/git/compare/ms/a-chapter...tk-bffa26",
+        _token(server, BERNA),
+    )
+    assert status == 404
+    assert body["error"]["message"] == (
+        "ms/a-chapter and tk-bffa26 are not in this board's own repository on "
+        "this host. Nothing was pruned to make that true — this host keeps "
+        "every branch pushed to it forever — so they were never pushed here: "
+        "cards worked before this host became the board's remote, or "
+        "worktrees whose commits have not left them. A commit reaches this "
+        "repository the moment it is made in a worktree joined to the board; "
+        "the declared forge is a copy of what is here, never the other way "
+        "round, so there is nowhere else this pane could look."
+    )
+
+
 # ── the HOSTED window: /ui on a serve-mode host, per repo and visibility ───
 
 

taskops_cli-0.5.3/ui/smoke/sections/card-diff-range.tsx

@@ -0,0 +1,119 @@
+/* The card's Files-changed pane asks for a range that survives its chapter
+ * landing — BOTH ends of it, and pinned where the pane itself chooses it.
+ *
+ * WHAT WENT WRONG TWICE. First version: base = the chapter's branch, head = the
+ * card's branch — and for a landed card both were pruned on the forge before
+ * this host became the board's remote, so the compare refused and the pane was
+ * empty. Second version made only the HEAD a recorded sha; the base stayed a
+ * branch name and the pane stayed empty. Reported live on tk-bffa26 both times.
+ *
+ * WHY THIS FILE INSISTS ON THE CALL SITE. The previous section pinned the
+ * decision as a pure function and said so honestly: `FilesChanged` fetches
+ * through a `useEffect`, `react-dom/server` fires none, and a mutation at the
+ * dossier's call site was measured to be INVISIBLE here. So the fix that
+ * shipped was pinned everywhere except in the one component that was broken.
+ * `FilesChanged` now renders the route it asked for as `data-range` on its
+ * wrapper, which is a fact about the pane and not a test hook, and every claim
+ * below reads it off a rendered `<Body>` — the real component, the real
+ * payload. Mutate the call site and this section goes red.
+ *
+ * The one-commit dossier is the fixture's own card (`tests/test_ui.py`), so the
+ * shape asserted is the shape the SERVER sends on `CardPayload.commits`. The
+ * multi-commit one is that card with a second commit appended, which is the
+ * shape tk-bffa26's live payload has: two bodies, oldest first, both with a
+ * `branch` the host no longer carries.
+ */
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { Body } from "../../src/components/card/Sections";
+import { cardRange, gitForge, gitRoute } from "../../src/links";
+import type { CardPayload } from "../../src/types";
+import type { Check, Fixture, Harness } from "./section";
+
+/** The pane's own `data-range`, off a rendered dossier body. */
+function asked(dossier: CardPayload, now: number): string {
+  const markup = renderToStaticMarkup(<Body dossier={dossier} now={now} repo={null} reader={null} />);
+  return /data-range="([^"]*)"/.exec(markup)?.[1] ?? "";
+}
+
+export async function run(fixture: Fixture, check: Check, h: Harness): Promise<void> {
+  const { now, REPO } = h;
+  const one = fixture.card;
+  const commits = one.commits;
+
+  check(
+    "the dossier payload carries a per-card sha at all",
+    commits.length > 0 && typeof commits[0]?.sha === "string",
+    JSON.stringify(commits.map((c) => c.sha)),
+  );
+
+  /* ── one recorded commit: the commit door, which diffs against parent #1 ── */
+  const single: CardPayload = { ...one, commits: [commits[0]!] };
+  const first = commits[0]!.sha;
+  check(
+    "a one-commit card asks the COMMIT door for its own sha",
+    asked(single, now) === `git/commit/${encodeURIComponent(first)}`,
+    asked(single, now),
+  );
+  check(
+    "and never a branch name on either side",
+    !asked(single, now).includes(one.branch) && !asked(single, now).includes("ms/"),
+    asked(single, now),
+  );
+
+  /* ── several: the whole span, based on the FIRST commit's PARENT ────────── */
+  const last = "f".repeat(40);
+  const landed: CardPayload = {
+    ...one,
+    commits: [commits[0]!, { ...commits[0]!, sha: last, subject: "the second half" }],
+  };
+  const span = asked(landed, now);
+  check(
+    "a multi-commit card asks compare(<first>^ ... <last>) — the parent, not the first commit",
+    span === `git/compare/${encodeURIComponent(`${first}^`)}...${encodeURIComponent(last)}`,
+    span,
+  );
+  check(
+    "so the oldest commit's own changes are INSIDE the range, not one off its edge",
+    span.includes(encodeURIComponent(`${first}^`)) && !span.includes(`git/compare/${encodeURIComponent(first)}...`),
+    span,
+  );
+  check(
+    "and the landed card's pane asks for no branch this host may have pruned",
+    !span.includes(one.branch) && !span.includes("ms"),
+    span,
+  );
+
+  /* ── the fallback, and the forge link beside the pane ───────────────────── */
+  check(
+    "a commit body with no sha falls to the two branch names",
+    JSON.stringify(cardRange([{}], "tk-dfaff7", "ms/x")) ===
+      JSON.stringify({ kind: "compare", base: "ms/x", head: "tk-dfaff7" }),
+  );
+  check(
+    "no commit bound at all is no section — the gate the pane always had",
+    cardRange([], "tk-dfaff7", "ms/x") === null && cardRange(undefined, "tk-x", "ms/x") === null,
+  );
+  check(
+    "so a dossier with no commits renders no Files-changed pane at all",
+    asked({ ...one, commits: [] }, now) === "",
+  );
+  const forgeOne = gitForge(REPO, cardRange([{ sha: first }], "tk-x", "ms/x")!);
+  const forgeMany = gitForge(REPO, cardRange([{ sha: first }, { sha: last }], "tk-x", "ms/x")!);
+  check(
+    "the forge link beside the pane still points at a real page for one commit",
+    forgeOne === `${REPO.url}/commit/${first}`,
+    String(forgeOne),
+  );
+  check(
+    "and at the same span for several",
+    forgeMany === `${REPO.url}/compare/${first}^...${last}`,
+    String(forgeMany),
+  );
+
+  /* The route builder is the door's grammar and nothing here re-spells it. */
+  check(
+    "the pane's data-range IS gitRoute of the target the call site chose",
+    asked(single, now) === gitRoute(cardRange(single.commits, single.branch, single.milestone?.branch ?? "")!),
+  );
+}

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/ui/smoke/sections/git-diff.tsx

@@ -190,7 +190,7 @@ export async function run(fixture: Fixture, check: Check, h: Harness): Promise<v
    * on a `taskops serve` host), which must still be a readable pane and never a
    * dead anchor. */
   const filesChanged = renderToStaticMarkup(
-    <FilesChanged reader={undefined} repo={REPO} base="ms/x" head="tk-a11111" />,
+    <FilesChanged reader={undefined} repo={REPO} target={{ kind: "compare", base: "ms/x", head: "tk-a11111" }} />,
   );
   check(
     "Files changed with no reader falls to the forge, not to nothing",

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/ui/src/components/card/Patch.tsx

@@ -24,7 +24,7 @@
  * pane scrolls on its own X axis (`overflow: auto` over `white-space: pre`) and
  * every grid cell above it is `minmax(0, …)`. Nothing here may widen the drawer:
  * a horizontal scrollbar on the page is the one failure mode this pane has. */
-import { Ext, Numstat, cascade, useGitDiff, type DiffStep, type GitReader, type GitTarget, type Repo } from "../../links";
+import { Ext, Numstat, cascade, gitRoute, useGitDiff, type DiffStep, type GitReader, type GitTarget, type Repo } from "../../links";
 import { Fragment, useState } from "react";
 import type { Counts } from "../../links";
 import { split, type Hunk, type Side } from "./split";
@@ -441,12 +441,22 @@ const summaryBar: React.CSSProperties = {
   borderBottom: "1px solid var(--hair)",
 };
 
-/** Files changed — the card AS A PULL REQUEST.
+/** Files changed — the card AS A PULL REQUEST, over a range its CALLER chose.
  *
- *  The target is `<milestone branch>...<card branch>`, both already on the
- *  dossier payload, so nothing is constructed and nothing is guessed — the same
- *  two facts the forge `compare` link is built from, asked of the local clone
- *  instead of of the network.
+ *  It takes a whole `GitTarget` and not a `base`/`head` pair, because the two
+ *  callers do not ask the same question: the dossier asks for the range the
+ *  board RECORDED (a commit, or `<first>^...<last>` — `links.tsx::cardRange`),
+ *  and the Worktrees diff page asks about two live branches on disk. A pair of
+ *  strings could only express the second, which is how the dossier's pane came
+ *  to hold a base no host had.
+ *
+ *  `data-range` is the route it asked for, on the wrapper. It is there so the
+ *  RANGE can be asserted where it is chosen: the fetch is a `useEffect` and
+ *  `react-dom/server` fires none, so without it a mutation at the dossier's
+ *  call site renders identically and goes green — which is exactly what
+ *  happened once already (`smoke/sections/card-diff-range.tsx` says so). It
+ *  states what this pane is showing, which is also the first thing to read when
+ *  a pane is empty and nobody knows what it asked for.
  *
  *  The list is the FIRST step of the cascade in its own right: `stat` is the
  *  numstat vocabulary, so a reader who never expands a file still gets +/− per
@@ -454,15 +464,13 @@ const summaryBar: React.CSSProperties = {
 export function FilesChanged({
   reader,
   repo,
-  base,
-  head,
+  target,
   summary = false,
   view = DRAWER_VIEW,
 }: {
   reader: GitReader | null | undefined;
   repo: Repo | null | undefined;
-  base: string;
-  head: string;
+  target: GitTarget;
   /** Draw the `N files changed  +a −d` bar above the list.
    *
    *  A PROP here rather than a computation at the call site, because the count
@@ -477,17 +485,18 @@ export function FilesChanged({
    *  the drawer's, so the dossier pane is byte-for-byte what it was. */
   view?: PatchView;
 }): React.JSX.Element {
-  const target: GitTarget = { kind: "compare", base, head };
   const state = useGitDiff(reader, target, true);
   return (
-    <FileList
-      reader={reader}
-      repo={repo}
-      target={target}
-      step={cascade(repo, target, state)}
-      summary={summary}
-      view={view}
-    />
+    <div data-range={gitRoute(target)} style={{ minWidth: 0 }}>
+      <FileList
+        reader={reader}
+        repo={repo}
+        target={target}
+        step={cascade(repo, target, state)}
+        summary={summary}
+        view={view}
+      />
+    </div>
   );
 }
 
@@ -516,15 +525,19 @@ export function FileList({
   summary?: boolean;
   view?: PatchView;
 }): React.JSX.Element {
-  const { base, head } = target.kind === "compare" ? target : { base: "", head: target.ref };
   if (step.step !== "patch") return <DiffPane step={step} view={view} />;
 
   const stat: Counts = step.diff.stat;
   const paths = Object.keys(stat).sort();
   if (paths.length === 0) {
+    /* Named in the grammar of the range that was actually asked: a compare has
+       two ends and a commit has one, and "between <sha> and " was the sentence
+       a single-commit target used to produce. */
     return (
       <div data-testid="changed-none" style={note}>
-        no files differ between {base} and {head}
+        {target.kind === "compare"
+          ? `no files differ between ${target.base} and ${target.head}`
+          : `no files changed in ${target.ref}`}
       </div>
     );
   }

{taskops_cli-0.5.2 → taskops_cli-0.5.3}/ui/src/components/card/Sections.tsx

@@ -13,7 +13,7 @@
  * to agents. That is the hole `<Criteria>` closes, and the reason it is a section
  * of its own rather than a paragraph folded into the spec. */
 import { shortActor } from "../../format";
-import { Ext, Numstat, cardHead, commitUrl, type GitReader, type Repo } from "../../links";
+import { Ext, Numstat, cardRange, commitUrl, type GitReader, type Repo } from "../../links";
 import { TONE_FG } from "../board/CardTile";
 import { Markdown } from "../shared/Markdown";
 import { CommitPatch, FilesChanged } from "./Patch";
@@ -114,6 +114,7 @@ export function Body({
 }): React.JSX.Element {
   const { card } = dossier;
   const stood = dossier.standing;
+  const range = cardRange(dossier.commits, dossier.branch, dossier.milestone?.branch ?? "");
   return (
     <>
       {stood && stood.verdict === "changes" ? (
@@ -287,24 +288,21 @@ export function Body({
       ) : null}
 
       {/* The card AS A PULL REQUEST, read from the host's own git (or this
-          clone) instead of the forge — the card's HEAD against its chapter's
-          branch. The head is the recorded sha when the card has one and the
-          branch otherwise (`links.tsx::cardHead`): a branch is durable again
-          now that the host prunes nothing, but a card whose branch was pruned
-          on the forge before that host existed is only findable by sha. This used to be described as
-          "the same two branches the `compare ↗` link above is built from", and
-          that link is gone: the Worktree block now opens the tree in this
-          dashboard instead of sending the reader to somebody else's rendering
-          of a range. The two branches are unchanged; only the sentence was
-          borrowing them. No branch on either side, no section. */}
-      {dossier.commits.length > 0 && dossier.branch && dossier.milestone?.branch ? (
+          clone) instead of the forge — and over the range the BOARD recorded,
+          both ends of it. `links.tsx::cardRange` is the whole decision and
+          argues it: a lone recorded commit goes through the commit door, which
+          diffs it against its first parent; several become
+          `<first>^...<last>`, whose base is the oldest commit's PARENT so that
+          commit's own changes are in the pane rather than one off the edge of
+          it. Neither end is a branch name, which is what makes the pane render
+          for a card whose `tk-*` and `ms/*` branches were pruned before this
+          host became the board's remote — the reported failure. This used to be
+          described as "the same two branches the `compare ↗` link above is
+          built from", and that link is gone: the Worktree block opens the tree
+          in this dashboard instead. No range to ask for, no section. */}
+      {range !== null ? (
         <Section title="Files changed">
-          <FilesChanged
-            reader={reader}
-            repo={repo}
-            base={dossier.milestone.branch}
-            head={cardHead(dossier.commits, dossier.branch)}
-          />
+          <FilesChanged reader={reader} repo={repo} target={range} />
         </Section>
       ) : null}