@passioncode-ai/fabric-agent-adapter 0.39.1 → 0.41.0

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/delegation.md

@@ -30,7 +30,7 @@ the declaration (`auth.delegation-declared`) and that `/mcp` refuses the descrip
 
 ```python
 import fabric_delegation as fd, fabric_interop as fi
-keys = fd.JwksCache(well_known["auth"]["delegation"]["jwks"])          # https, loopback http, or a file
+keys = fd.JwksCache(well_known["auth"]["delegation"]["jwks"])          # https, loopback http, or a file; one 5 s deadline per fetch
 gate = fd.delegation_gate(audience="example-agent", jwks=keys, issuer=well_known["auth"]["delegation"]["issuer"],  # required
                           effects={"example.write": "draft", "example.publish": "publish"})   # each tool's manifest effect
 server = fi.McpToolServer("example-agent", VERSION, authorize=gate)    # pass the request headers to handle()
@@ -115,7 +115,8 @@ current verified revision as `estate=` / `{ estate }`, as a value or as a functi
 - A revision that cannot be read, is outside its window, is lower than the applied one or forks it is the trust
   source's fault: `issuer-unavailable`, detail `estate-unreadable`, `estate-outside-window`, `estate-rolled-back` or
   `estate-forked`.
-- Without `estate`, nothing changes.
+- Without `estate` (the option left out), nothing changes. An explicit `null` (Python `None`) for `estate`, its
+  applied mark or its revocations is an unreadable source, `estate-unreadable`, in both kits (FAA-78).
 - Every verifier refuses a clock that is not a number of seconds `unknown-state` `no-clock` before row 1: a NaN clock
   would make every time row false and pass an expired token.
 

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/estate-record.md

@@ -87,8 +87,8 @@ gate = fd.delegation_gate(audience=..., jwks=keys, issuer=..., effects=..., esta
   `estate-forked` (the applied number with another digest). A caller cannot cure these by minting again.
 - An unreadable clock (not a finite number of seconds a `Date` can hold) is refused `unknown-state` `no-clock`
   before row 1, in every verifier.
-- Only an absent `estate` skips the check. In the Node kit `null` is an unreadable source; in Python, where `None` is
-  the absent value, pass a function returning `None` for a source that has nothing.
+- Only an absent `estate` skips the check: an option left out. An explicit `null` (Python `None`) is an unreadable
+  source in both kits, and so is `applied: null`; an omitted `applied` means no revision applied yet (FAA-78).
 - **What you pass in.** Pass only a revision that `verify_estate_record` accepted and whose number is not lower than
   the highest the machine applied; a higher one only when you verified its chain from the applied revision.
 - `hub_key_certified(record, kid, x, at, applied, extra_revocations)` /
@@ -120,8 +120,9 @@ of `[A-Za-z0-9][A-Za-z0-9_-]{0,127}`. Absent is `personal`; `null` is not absent
   `publisherKeys` pins. A key no scope names keeps DEC-0051's meaning, trusted in any context.
 - **Update a copied kit before a revision carries `publisherScopes`.** A service runs the copy of the kit it was built
   with; a copy older than 0.39.0 does not read `publisherScopes`, so it trusts a partner's key in every context and
-  finds no rule broken. A service that applies the estate record updates its copy of `fabric_estate.py` /
-  `fabric-estate.mjs` to 0.39.0 or later first.
+  finds no rule broken. A service that applies the estate record updates its copy first:
+  `fabric_kit.py install <dir> --module fabric_estate` (or `--lang node --module fabric-estate`). Since 0.40.0 the
+  estate reader imports the kit's core modules, so the one file alone no longer loads ([kit modules](kit-modules.md)).
 
 Every rule is total on hostile JSON, as the contract's are: an `instancePath` names an item by its index as written (a
 non-object before it does not shift it), and a value whose own `toString` member is data is shown as its JSON. Both kits

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/interop.md

@@ -103,6 +103,11 @@ As a provider:
   caller only. A key that already names a job starts nothing; `jobs.repeat(caller, key, now)` answers `new`, `same`
   (answer with that job) or `run`: a `quota-exhausted` job runs again once its reset passed or you pass
   `limit_holds=False`, a `limit-reached` job once `approval_granted=True`, and an `outcome-unknown` job never.
+  A key admits only the intent it was first used for: the key file keeps a digest of the capability and its input,
+  and the same key with another intent is refused as `idempotency-conflict` (FAA-77). `repeat` takes the intent too
+  (`capability=`, `arguments=`; Node `{capability, input}`) and then answers `conflict` for another intent. A key file
+  written before 0.41.0 holds no intent: it is answered with its job, never a conflict, and its job runs again only
+  for the capability and input that job stored.
 - **Usage you did not measure is `null`, never 0,** but only toward a caller whose request `_meta.protocols` names
   `fabric-interop/0.2`: pass `request_meta` to `result_envelope` (`usage_toward`). Toward any other caller the kit
   writes the measured lower bound, as before. Either way, record that call's usage receipt with

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/kit-modules.md

@@ -0,0 +1,129 @@
+# The service kit: modules, layers and installing them
+
+Since 0.40.0 (FAA-65) the kit is a set of small modules in two languages, not two large files. `scripts/kit.json`
+lists every module in dependency order, per language, with the kit modules it imports and its sha256; `history` keeps
+the digests of every release since 0.8.0, so a copy in a service can be told apart. `scripts/fabric_kit.py` installs a
+module with exactly what it needs and reports a copy's state. Tests: `test/test_fabric_kit.py`,
+`test/test_kit_api.py`, `test/kit-api.test.mjs`.
+
+## Contents
+
+- [Install, status, build](#install-status-build)
+- [The layers](#the-layers)
+- [What 0.39 code keeps](#what-039-code-keeps)
+- [Dates and times](#dates-and-times)
+- [Adding or changing a module](#adding-or-changing-a-module)
+
+## Install, status, build
+
+```bash
+K=<adapter>/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts
+python3 $K/fabric_kit.py install <service-dir>                      # fabric_service and its closure (Python)
+python3 $K/fabric_kit.py install <service-dir> --module fabric_service --module fabric_interop --module fabric_board
+                                                                    # what sample_service.py imports
+python3 $K/fabric_kit.py install <service-dir> --lang node          # fabric-service.mjs and its closure
+python3 $K/fabric_kit.py install <service-dir> --module fabric_openrouter --module fabric_board
+python3 $K/fabric_kit.py install <service-dir> --all --dry-run      # every module, nothing written
+python3 $K/fabric_kit.py status <service-dir> [--json]              # current, older (the release), modified, missing
+python3 $K/fabric_kit.py build [--check]                            # maintainers: refresh kit.json from the sources
+```
+
+- `install` copies the closure of the named modules and nothing else. It refuses to overwrite a file it does not
+  recognise (`modified`: someone edited the copy) unless `--force`, and says which.
+- `status` names each kit file in the folder as `current`, `older` with the release it came from, or `modified`, and
+  prints `missing <file>, which <file> imports` for every module the folder lacks, read from what each copy itself
+  imports and followed through the modules it would install: that copy would fail when that code path runs. A folder
+  holding only the 0.40.0 `fabric_service.py` gets one line for each of the 16 modules it needs; a 0.39.1 copy is
+  asked only for what it imports (`test_an_older_copy_is_judged_by_its_own_imports`).
+- Exit codes: 0 done or every copy current, 1 a problem (a copy missing, `older` or `modified`, no kit module in the
+  folder at all, an install refused), 2 usage (an unknown `--module` included).
+- Every kit module puts its own folder on `sys.path` before it imports a sibling, so a service that loads a kit file
+  by its path from another working directory gets its siblings too (`test_every_module_loads_by_path_from_any_folder`).
+- `build --check` is what CI runs: `kit.json` must be what the sources say.
+
+## The layers
+
+A module imports only modules listed before it in `kit.json`, so the kit has no import cycle and no upward import
+(`test_the_order_is_a_layering`; a planted cycle is caught). Python name first, the Node twin is the same name with
+`-` for `_` and `.mjs`. No module is over 1000 lines (`test_no_module_over_the_line_ceiling`).
+
+| Layer | Module | What it holds |
+|---|---|---|
+| L0 | `fabric_jsvalue` | JavaScript's view of JSON values: numbers, strings, equality, `jcs`, `show`; defined once for the kit |
+| L0 | `fabric_time` | strict RFC 3339, UTC days, formatting, day windows, the clock ([dates](#dates-and-times)) |
+| L0 | `fabric_identifiers` | identifier equality by normal form (DEC-0076) |
+| L0 | `fabric_secrets` | the contract's one credential detector (DEC-0044) |
+| L1 | `fabric_crypto` | Ed25519 signing (a Montgomery ladder that does not branch on the key) and verification, P-256 verification, base64url, sha256 |
+| L2 | `fabric_estate` | `estate-record/1` revisions and their rules (DEC-0055) |
+| L2 | `fabric_delegation` | the callee's side of `fabric-delegation/0.1` (DEC-0039) |
+| L2 | `fabric_share` | share grants and registrations (DEC-0086) |
+| L2 | `fabric_ceremonies` | the headless join token (DEC-0084) |
+| L2 | `fabric_package` | `fabric-package/1`: pack, sign, verify (DEC-0050, DEC-0051) |
+| L3 | `fabric_base` | the protocol name, `ServiceError`, small shared helpers |
+| L3 | `fabric_platform` | Windows: named pipes, owner-only files (DEC-0032) |
+| L3 | `fabric_paths` | the services directory, a service's folders, atomic and private writes |
+| L3 | `fabric_protocols` | protocol revisions (DEC-0067) and feed data (DEC-0070) |
+| L3 | `fabric_lock` | the instance lock and the supervisor marker (LC-01, DEC-0057) |
+| L3 | `fabric_usage` | usage receipts, the ledger, the usage report, attribution, spending limits ([usage](usage.md)) |
+| L3 | `fabric_backups` | settings backups (DEC-0025) |
+| L3 | `fabric_descriptor` | the descriptor, peers, app descriptors, the well-known document |
+| L3 | `fabric_auth` | the token, the network guard, login codes |
+| L3 | `fabric_events` | events, paging, the JSONL event log (DEC-0029) |
+| L3 | `fabric_logs` | rotating logs, the stop signal and the drain (LC-12) |
+| L3 | `fabric_supervisors` | launchd, systemd user units, Task Scheduler (DEC-0032, LC-14) |
+| L3 | `fabric_service` | the facade: every name 0.39.1 exported, re-exported from the modules above |
+| L3 | `fabric_profiles` | runner and model profiles ([profiles](profiles.md)) |
+| L3 | `fabric_interop` | `fabric-interop/0.1`: jobs, envelopes, MCP tools ([interop](interop.md)) |
+| L4 | `fabric_hub` | the Fabric hub's door (`fabric-hub/0.1`) |
+| L4 | `fabric_board_shapes` | the project board's wire: constants, refusal codes, shapes |
+| L4 | `fabric_board_link` | the board's link: the MCP session over the hub, the fsynced checkpoint, a claimed request as data |
+| L4 | `fabric_board_session` | the board responder: the work context, the fenced request, transfer and recovery |
+| L4 | `fabric_board_fixture` | the scripted board the probe runs a responder against |
+| L4 | `fabric_board` | the facade of the board connector ([board](board.md)) |
+| L4 | `fabric_http` | outbound HTTP: deadline, bounded retries, `Retry-After`, size cap ([connectors](connectors.md)) |
+| L4 | `fabric_openrouter` | OpenRouter chat: own key, spend ceiling, receipts, fallback ([connectors](connectors.md)) |
+
+Beside the kit, not in `kit.json`: the probe (`check_service.py`, `check_service_rules.py`), the sample
+(`sample_service.py`, `sample-remote-service.mjs`), `fabric_kit.py` itself and the dashboard tools. Recipes built on
+the kit live in `../recipes/` ([the support agent](../recipes/support-agent/README.md)).
+
+## What 0.39 code keeps
+
+`import fabric_service as fs` and `import ... from './fabric-service.mjs'` keep working: the facades re-export every
+public name 0.39.1 had, in both languages (the snapshot is `test/fixtures/kit-api/kit-api-0.39.1.json`; a missing
+name fails `test_kit_api`), and the Python facade the private names other code reached through it (`_number`,
+`_DAY_MS`, `_utc_date_ms` from the core). `fabric_board` and `fabric-board.mjs` are
+facades the same way. What changed for a service that copies the kit: `fabric_service.py` alone is no longer enough;
+install with `fabric_kit.py install` and `status` names what is missing. A test or service that replaced a function
+by assigning it on the facade (`fabric_service.X = ...`) no longer changes what the kit does: the code reads its own
+module's name, so patch the module that defines it (`fabric_lock.X`, `fabric_session_env.X`). A service that imported a module-private
+helper (`_x`) of the Node twin should import it from its module now.
+
+## Dates and times
+
+`fabric_time` / `fabric-time.mjs` is the kit's one reading of dates, on the cases both twins test
+(`test/fixtures/kit-time-cases.json`). Anything unreadable is NaN, never an exception, so a check compares it and
+reports a finding.
+
+| Python | Node | What |
+|---|---|---|
+| `parse_rfc3339_ms(text)` | `parseRfc3339Ms(text)` | strict RFC 3339: a `T`, an offset and a day that exists; no space, no leap second; milliseconds or NaN |
+| `utc_date_ms(text)` | `utcDateMs(text)` | a `YYYY-MM-DD` that exists, as midnight UTC in milliseconds, or NaN |
+| `utc_day(ms)` | `utcDay(ms)` | the UTC calendar day of an instant (NaN or Infinity raise) |
+| `format_rfc3339(ms)` | `formatRfc3339(ms)` | `2026-10-21T09:00:00.000Z`, which parses back to the same value |
+| `day_window(today_ms, days)` | `dayWindow(todayMs, days)` | the last N UTC days ending with today's, oldest first (a usage report's 31) |
+| `clock_ms(at)` | `clockMs(at)` | a verifier's clock (an aware `datetime` / a `Date`, or epoch seconds) in milliseconds |
+| `now_ms(clock)` | `nowMs(clock)` | now in milliseconds; `clock` returns seconds in Python (`time.time`), milliseconds in Node (`Date.now`) |
+| `DAY_MS` | `DAY_MS` | 86 400 000 |
+
+`fabric_estate.estate_time` is `parse_rfc3339_ms` under its older name.
+
+## Adding or changing a module
+
+1. Put it in the lowest layer whose modules it needs; import only modules listed before it.
+2. Write the Node twin with the same public names in camelCase, and shared cases under `test/fixtures/` that both
+   test files read.
+3. Add it to `kit.json` (module, file, layer) and run `fabric_kit.py build`; add it to the table above
+   (`test_every_kit_module_is_documented`).
+4. A value or helper the core already has is imported, never redefined (`test_the_core_is_defined_once`).
+5. Stay under 1000 lines; split by responsibility, keeping a facade when callers already import the old name.

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/lifecycle.md

@@ -273,7 +273,9 @@ that still exits 75 stays down until the next logon.
 a named pipe on Windows (`lock_name` / `lockName`), each gone with the process. The Python kit
 holds the same name beside its file lock, so the two kits exclude each other everywhere, and
 `check_service.py` reports the lock held when either is. The probe only looks (`/proc/net/unix`,
-`WaitNamedPipeW`); it never takes the name, so it cannot make a service that is starting fail.
+`WaitNamedPipeW`); it never takes the name, so it cannot make a service that is starting fail. On Linux the Node kit's
+name needs Node 22 or later: Node 18 and early 20 collapse every abstract socket name into one, and later 20 pads it so
+no Python copy or probe sees it, so the Node kit refuses to start there with a sentence naming Node 22 (FAA-72).
 
 **Token files on Windows.** The privacy of `service.token` is its ACL (service.md *Windows
 token files*): the kits write a protected list: the user, SYSTEM and Administrators, set before the

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/package.md

@@ -50,7 +50,11 @@ copy. A member named twice in `fabric.package.json` is refused too.
 Then every problem is listed, each with its `rule`: `schema` (the contract's schema), `FAC-SEM-064` (whole: its own
 digest, each path once, every named file listed with the same SHA-256), `FAC-SEM-065` (no secret), `FAC-SEM-066`
 (`agentRef` derived), `FAC-SEM-102` (one role, one server) and `folder` (`file-missing`, `file-digest`, `file-unlisted`,
-`plugin-manifest`, `provider-manifest`). With a problem, `--apply` writes nothing. Repacking drops old signatures and
+`plugin-manifest`, `provider-manifest`) and `path` (a listed or folder path holding a control character, U+2028 or
+U+2029, a `..` segment, a backslash, `//` or a colon, refused by the kit itself whatever the schema's pattern lets
+through, FAA-78). A JSON document is read as strict UTF-8 and nested at most 256 levels; a folder entry the kit cannot
+read is refused as `Cannot read <path>`, and a link, FIFO or other non-regular file is never followed. With a problem,
+`--apply` writes nothing. Repacking drops old signatures and
 says so: a changed package is signed again.
 
 ## sign

package/plugins/fabric-agent-adapter/skills/building-fabric-services/references/usage.md

@@ -29,6 +29,8 @@ ledger.record(receipt)                     # fs.JsonlUsageLedger(data / "usage.j
 ledger.record(k.makeUsageReceipt('openrouter', model, { inputTokens, outputTokens, costUsd: usage.cost ?? null }));
 ```
 
+- **OpenRouter through the kit.** `fabric_openrouter.Client` records these receipts itself, one per answered call,
+  and checks a spend ceiling before every attempt ([connectors](connectors.md)).
 - **The provider's own numbers.** Take tokens from the response's usage block, not from a local
   estimate. The cost is `provider` when the provider reported the charge (OpenRouter `usage.cost`,
   a billing API) and `price-list` when you computed it from a published price list.

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/check_dashboard_layout.mjs

@@ -22,6 +22,13 @@ import { pathToFileURL } from 'node:url';
 
 const EXTENSION_KEY = 'https://fabric.passioncode.ai/agent-contract/extensions/dashboard/0.1';
 const RULES = ['ED-1', 'ED-2', 'ED-3', 'ED-4', 'ED-5'];
+// The most elements ED-4 and ED-5 walk on one page; past it they say how much they did not see.
+const ELEMENT_CAP = 6000;
+
+// A one-time login code is a credential: no report, error or evidence line carries one.
+export function scrub(text) {
+  return String(text).replace(/([?&#;]code=)[^&#\s"']*/gi, '$1<redacted>');
+}
 
 function usage(message) {
   if (message) process.stderr.write(message + '\n');
@@ -103,7 +110,7 @@ async function serviceTarget(spec, dir) {
 }
 
 // Runs inside the page. Everything it reports is measured from the rendered layout.
-function measure(floor) {
+function measure([floor, cap]) {
   const de = document.documentElement;
   const vw = de.clientWidth;
   const vh = window.innerHeight;
@@ -111,6 +118,9 @@ function measure(floor) {
   const cs = (el) => getComputedStyle(el);
   const scrollsX = (el) => /(auto|scroll)/.test(cs(el).overflowX);
   const clipsX = (el) => cs(el).overflowX !== 'visible';
+  // Vertically a scroll box (auto, scroll) still lets the reader reach what it holds; hidden and clip do not.
+  const clipsY = (el) => /(hidden|clip)/.test(cs(el).overflowY);
+  const pinned = (el) => { for (let a = el; a && a !== de; a = a.parentElement) if (cs(a).position === 'fixed') return true; return false; };
   const label = (el) => {
     const id = el.id ? '#' + el.id : '';
     const cls = typeof el.className === 'string' && el.className.trim() ? '.' + el.className.trim().split(/\s+/).join('.') : '';
@@ -118,16 +128,22 @@ function measure(floor) {
   };
   const visible = (el) => { const r = el.getBoundingClientRect(); return r.width > 0 && r.height > 0 && cs(el).visibility !== 'hidden'; };
 
-  // ED-3: a link is reachable when it is fully inside the viewport and not clipped by an ancestor,
-  // or when it sits in a closed <details> whose summary is reachable, or in a menu a visible
+  // ED-3: a link is reachable when it is fully inside the viewport's width, inside the page's height
+  // (the viewport's, for something fixed to it) and not clipped by an ancestor on either axis, or
+  // when it sits in a closed <details> whose summary is reachable, or in a menu a visible
   // aria-controls button opens.
   const inViewport = (el) => {
     const r = el.getBoundingClientRect();
     if (r.width <= 0 || r.height <= 0 || r.left < -1 || r.right > vw + 1) return false;
+    const [top, bottom] = pinned(el) ? [0, vh] : [-window.scrollY, de.scrollHeight - window.scrollY];
+    if (r.top < top - 1 || r.bottom > bottom + 1) return false;
     for (let a = el.parentElement; a && a !== de; a = a.parentElement) {
-      if (!clipsX(a)) continue;
+      const x = clipsX(a);
+      const y = clipsY(a);
+      if (!x && !y) continue;
       const ar = a.getBoundingClientRect();
-      if (r.left < ar.left - 1 || r.right > ar.right + 1) return false;
+      if (x && (r.left < ar.left - 1 || r.right > ar.right + 1)) return false;
+      if (y && (r.top < ar.top - 1 || r.bottom > ar.bottom + 1)) return false;
     }
     return true;
   };
@@ -155,9 +171,11 @@ function measure(floor) {
   // unless it is inside a scroll box or clipped by an ancestor that is itself inside the viewport.
   const all = document.body ? document.body.querySelectorAll('*') : [];
   const FOCUSABLE = 'a[href], button, input, select, textarea, [tabindex]';
+  out.elements = all.length;
+  out.measured = Math.min(all.length, cap);
   let n = 0;
   for (const el of all) {
-    if (++n > 6000) break;
+    if (++n > cap) break;
     if (!visible(el)) continue;
     if (scrollsX(el) && el.scrollWidth > el.clientWidth + 1) {
       const keyboard = el.tabIndex >= 0 || !!el.querySelector(FOCUSABLE);
@@ -214,21 +232,28 @@ export function verdicts(width, floor, m) {
   else add('ED-3', m.nav.unreachable.length ? 'FAIL' : 'PASS',
     m.nav.unreachable.length ? `${m.nav.unreachable.length} of ${m.nav.total} links unreachable: ${m.nav.unreachable.slice(0, 6).join(', ')}` : `${m.nav.total} links reachable`);
   const badBoxes = m.boxes.filter((b) => !b.keyboard || !b.named);
+  // A page larger than the walk: what the walk saw can fail, but it cannot pass for the whole page.
+  const capped = m.elements > m.measured ? `only the first ${m.measured} of ${m.elements} elements measured` : '';
   const problems = [];
   if (m.past.length) problems.push(`past the viewport, not in a scroll box: ${m.past.slice(0, 4).join(', ')}`);
   if (badBoxes.length) problems.push(`scroll box without keyboard access or a name: ${badBoxes.slice(0, 4).map((b) => b.el).join(', ')}`);
-  add('ED-4', problems.length ? 'FAIL' : 'PASS', problems.join('; ') || `${m.boxes.length} overflowing box(es), each keyboard-reachable; edge shades not measured`);
+  if (problems.length) add('ED-4', 'FAIL', problems.join('; ') + (capped ? `; ${capped}` : ''));
+  else if (capped) add('ED-4', 'NOT_RUN', `${capped}: ${m.boxes.length} overflowing box(es) keyboard-reachable among them, the rest not seen`);
+  else add('ED-4', 'PASS', `${m.boxes.length} overflowing box(es), each keyboard-reachable; edge shades not measured`);
   const limit = Math.min(120, m.vh / 4);
   const ed5 = [];
   if (m.chrome > limit) ed5.push(`sticky chrome ${m.chrome} px > ${Math.round(limit)} px`);
   if (m.nested.length) ed5.push(`nested full-height scroller: ${m.nested.slice(0, 3).join(', ')}`);
   if (m.anchor && m.anchor.top < m.chrome - 1) ed5.push(`anchor ${m.anchor.el} lands at ${m.anchor.top} px, under the ${m.chrome} px chrome`);
   add('ED-5', ed5.length ? 'FAIL' : 'PASS', ed5.join('; ') ||
-    `sticky chrome ${m.chrome} px ≤ ${Math.round(limit)} px` + (m.anchor ? `; anchor lands at ${m.anchor.top} px` : '; no in-page anchor to jump to') + '; refresh keeps scroll: not measured');
+    `sticky chrome ${m.chrome} px ≤ ${Math.round(limit)} px` + (m.anchor ? `; anchor lands at ${m.anchor.top} px` : '; no in-page anchor to jump to') + '; refresh keeps scroll: not measured' +
+    (capped ? `; nested scrollers: ${capped}` : ''));
   return rows;
 }
 
 function report(rows, opts, target) {
+  rows = rows.map((r) => ({ ...r, evidence: scrub(r.evidence) }));
+  target = scrub(target);
   const failed = rows.filter((r) => r.verdict === 'FAIL').length;
   if (opts.json) {
     process.stdout.write(JSON.stringify({ target, browser: opts.browser, results: rows, failed }, null, 2) + '\n');
@@ -241,27 +266,31 @@ function report(rows, opts, target) {
 
 async function main(argv) {
   const opts = parseArgs(argv);
+  // What the report names: the service, never the login URL its one-time code is in.
+  const shown = opts.service || opts.url;
   let target = opts.url;
   let floor = opts.floor;
-  const notRun = (why) => report(RULES.map((rule) => ({ rule, width: 0, verdict: 'NOT_RUN', evidence: why })), opts, target || opts.service);
+  const notRun = (why) => report(RULES.map((rule) => ({ rule, width: 0, verdict: 'NOT_RUN', evidence: why })), opts, shown);
+  // The browser first: a run that cannot measure must not spend a one-time code.
+  const pw = await loadPlaywright(opts.playwright);
+  if (!pw) return notRun('Playwright is not installed here: npm i -D playwright && npx playwright install webkit (or pass --playwright DIR)');
+  let browser;
+  try {
+    browser = await pw[opts.browser].launch();
+  } catch (err) {
+    return notRun(`the ${opts.browser} browser does not start: ${String(err.message).split('\n')[0]} (npx playwright install ${opts.browser})`);
+  }
   if (opts.service) {
     try {
       const t = await serviceTarget(opts.service, opts.servicesDir);
       target = t.url;
       if (floor === undefined && Number.isInteger(t.declared?.minWidth)) floor = t.declared.minWidth;
     } catch (err) {
+      await browser.close();
       return notRun(`could not open the service's dashboard: ${err.message}`);
     }
   }
   floor = floor ?? 360;
-  const pw = await loadPlaywright(opts.playwright);
-  if (!pw) return notRun('Playwright is not installed here: npm i -D playwright && npx playwright install webkit (or pass --playwright DIR)');
-  let browser;
-  try {
-    browser = await pw[opts.browser].launch();
-  } catch (err) {
-    return notRun(`the ${opts.browser} browser does not start: ${String(err.message).split('\n')[0]} (npx playwright install ${opts.browser})`);
-  }
   const rows = [];
   try {
     const context = await browser.newContext({ viewport: { width: Math.max(...opts.widths), height: opts.height } });
@@ -279,7 +308,7 @@ async function main(argv) {
       await page.evaluate(() => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r))));
       await page.waitForTimeout(250);
       await page.evaluate(() => new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r))));
-      const m = await page.evaluate(measure, floor);
+      const m = await page.evaluate(measure, [floor, ELEMENT_CAP]);
       rows.push(...verdicts(width, floor, m));
     }
   } catch (err) {
@@ -287,7 +316,7 @@ async function main(argv) {
   } finally {
     await browser.close();
   }
-  return report(rows, opts, opts.service || target);
+  return report(rows, opts, shown);
 }
 
 if (import.meta.url === pathToFileURL(process.argv[1] || '').href) {

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/check_dashboard_link.py

@@ -7,7 +7,7 @@ This is an output correctness gate, not authentication, discovery, or a relay.
 import json
 import re
 import sys
-from urllib.parse import parse_qs, urlsplit
+from urllib.parse import parse_qs, parse_qsl, unquote, urlsplit
 
 
 def require(condition, reason):
@@ -15,6 +15,63 @@ def require(condition, reason):
         raise ValueError(reason)
 
 
+# Credential names and values: the same rules as fabric-button.js (credentialName, secretValue).
+CREDENTIAL_WORDS = {
+    'token', 'secret', 'password', 'passwd', 'pass', 'passphrase', 'credential', 'credentials', 'cookie',
+    'authorization', 'bearer', 'jwt', 'otp', 'apikey', 'signature', 'sig', 'accesstoken', 'idtoken', 'authtoken',
+    'refreshtoken', 'sessionid', 'sessiontoken', 'logincode', 'authcode', 'privatekey', 'clientsecret', 'secretkey',
+    'accesskey'}
+CREDENTIAL_PAIRS = {
+    'key': {'private', 'api', 'access', 'secret', 'session', 'auth', 'signing', 'encryption', 'master', 'client', 'login',
+            'refresh'},
+    'auth': {'token', 'code', 'header'},
+    'session': {'token', 'id'},
+    'code': {'login', 'auth', 'access', 'session'}}
+JWT_SHAPE = re.compile(r'eyJ[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]*')
+SECRET_VALUE = re.compile(r'(^bearer\s.+|sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[abposr]-[A-Za-z0-9-]{10,}'
+                          r'|AKIA[0-9A-Z]{16}|glpat-[A-Za-z0-9_-]{20,})', re.I | re.S)
+LONG_RUN = re.compile(r'[A-Za-z0-9+/=_-]{40,}')
+
+
+def name_words(name):
+    name = re.sub(r'([a-z0-9])([A-Z])', r'\1 \2', name)
+    name = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1 \2', name)
+    return [w.lower() for w in re.split(r'[\s._-]+', name) if w]
+
+
+def credential_name(name):
+    split = name_words(name)
+    words = set(split) | {w[:-1] for w in split if len(w) > 2 and w.endswith('s')}
+    if words & CREDENTIAL_WORDS:
+        return True
+    if len(split) == 1 and words & set(CREDENTIAL_PAIRS):
+        return True
+    return any(w in words and words & pairs for w, pairs in CREDENTIAL_PAIRS.items())
+
+
+def secret_value(value):
+    long_secret = any(re.search(r'[a-z]', run) and re.search(r'[A-Z]', run) and re.search(r'[0-9]', run)
+                      for run in LONG_RUN.findall(value))
+    return bool(JWT_SHAPE.search(value) or SECRET_VALUE.search(value) or long_secret)
+
+
+def carries_credential(text):
+    # A query or fragment whose names or values could be a credential: refused even with an empty value.
+    return (secret_value(text) or secret_value(unquote(text))
+            or any(credential_name(name) or secret_value(name) or secret_value(value)
+                   for name, value in parse_qsl(text, keep_blank_values=True)))
+
+
+def login_path(path):
+    # The path a server routes: refuse what normalises differently in different servers, then compare.
+    decoded = unquote(path)
+    require(not re.search(r'%2f|%5c', path, re.I) and '\\' not in decoded, 'encoded_separator')
+    segments = decoded.split('/')[1:]
+    require(not any(seg in ('.', '..') for seg in segments), 'dot_segment')
+    require(all(seg for seg in segments[:-1]), 'empty_segment')
+    return '/'.join([''] + [seg for seg in segments if seg]).lower() == '/fabric/v1/login'
+
+
 def safe_path(path):
     return (isinstance(path, str) and path.startswith('/') and not path.startswith('//')
             and len(path) <= 2048 and not re.search(r'[\\\x00-\x1f\x7f]', path))
@@ -42,10 +99,14 @@ def check(data):
             and not plain.username and not plain.password, 'invalid_http_fallback')
     http_page = plain.path + ('?' + plain.query if plain.query else '') + ('#' + plain.fragment if plain.fragment else '')
     require(safe_path(http_page) and http_page == (page or '/'), 'mismatched_page')
-    sensitive = {'token', 'access_token', 'refresh_token', 'password', 'secret', 'login_code'}
-    page_query = parse_qs(urlsplit(http_page).query)
-    require(not sensitive.intersection(k.lower() for k in page_query), 'credential_query')
-    require(urlsplit(http_page).path != '/fabric/v1/login', 'login_link_is_not_dashboard')
+    sensitive = {'token', 'access_token', 'refresh_token', 'password', 'secret', 'login_code', 'code', 'api_key',
+                 'apikey', 'key', 'auth'}
+    parts = urlsplit(http_page)
+    places = [parts.query, parts.fragment] + parts.fragment.split('?', 1)[1:]
+    require(not any(sensitive.intersection(k.lower() for k in parse_qs(p, keep_blank_values=True)) for p in places),
+            'credential_query')
+    require(not any(carries_credential(p) for p in places), 'credential_query')
+    require(not login_path(parts.path), 'login_link_is_not_dashboard')
     state = host.get('state')
     require(state in ('available', 'not_installed', 'unknown', 'incompatible', 'handler_mismatch', 'unsupported'), 'unknown_host_state')
     target, viewer = data.get('target_device'), data.get('viewer_device')