@passioncode-ai/fabric-agent-adapter 0.79.1 → 0.80.2

package/CHANGELOG.md

@@ -1,5 +1,139 @@
 # Changelog
 
+## 0.80.2 (2026-11-12)
+
+0.80.1 was tagged and never published: its `windows` job (run 43212508702) failed one test, so `release` and `publish`
+were skipped. 0.80.2 is 0.80.1 with that test fixed, and is the release that ships 0.80.0's changes. No module changes.
+
+### Fixed
+
+- `test_the_launchers_folder_is_macos_only` compared the folder `status` returns, written with the runner's own path
+  separators, with a POSIX string; it compares it with `str(Path(...))`.
+
+## 0.80.1 (2026-11-12)
+
+0.80.0 was tagged and never published: its release run (43209105658) failed `floors`, `python` and `windows` on two
+tests of 0.80.0's own (FAA-239, FAA-240) that held only on macOS, so `release` and `publish` were skipped. 0.80.1 is
+0.80.0 with the two tests fixed, and is the release that ships it. No module changes.
+
+### Fixed
+
+- `test_a_copy_outside_the_launchers_folder_is_named` wrote `hub.json` where the runner's own platform keeps it while
+  `status` read darwin's; it writes it where darwin keeps it.
+- `test_the_launchers_folder_is_macos_only` set a Windows temporary folder as a darwin path, which is not absolute
+  there; it uses a POSIX path.
+
+## 0.80.0 (2026-11-12)
+
+Wave 2 and the first part of wave 3 of the backlog sweep of 2026-11-12. The contract pin stays `18f8d487`. A new kit
+module, `fabric_load` and `fabric-load.mjs` (layer L3). Kit modules change: `fabric_secrets`, `fabric_peer_owner`
+(`1.1.0+kit.4`), `fabric_connections`, `fabric_descriptor`, `fabric_context`, `fabric_supervisors`, `fabric_interop`,
+`fabric_hub`, `fabric_board_slots`, `fabric_board_session`, `fabric_http`, `fabric_usage`, the facade `fabric_service`,
+and their Node twins where they have one.
+
+### Added
+
+- **Three working rules in working-with-fabric and in a new agent's template** (the contract owner's board request
+  `bfc0e14e`, relaying the operator's words of 2026-11-12): the task's context is settled before the first act that
+  crosses contexts (`personal`, `org:<orgId>`), asked once when no source settles it, recorded in the handoff and never
+  posted to a board thread, following contract CT-292's draft (TC-1 to TC-6) until its DEC lands, the one exception to
+  "do not ask" (`references/task-context.md`, FAA-299); a wait is not a stop: each wait has its condition, owner, next
+  action and watcher, `fabric_heartbeat` carries `waitingOn`, a turn ends with one line per open wait
+  (`references/waits.md`, FAA-300); clean up after yourself: merged worktrees and branches, `git fetch --prune`, unique
+  commits archived under `refs/archive/<date>/`, `git ls-files` checked before a folder goes (`references/cleanup.md`,
+  FAA-301). creating-fabric-agents carries the three in `references/working-rules.md`. Six scenario evals and
+  `test/test_working_rules_prose.py`.
+- **A service install refuses a port another OS account listens on** (FAA-225, its port part), read with
+  `fabric_peer_owner`; a port of this account, the system or nobody, or an unreadable table, still passes. The claim
+  file waits on contract DEC-0160.
+- creating-fabric-agents: an agent on its own machine refuses to start where Observatory's `placement.json` places it
+  elsewhere, starts with no file, reports `placement-unreadable`, and takes keys only from its machine's vault
+  (`where-agents-run.md`, FAA-230's placement and vault parts).
+- A recorded working-with-fabric trigger run: 38 of 44 with haiku, above the 85 % gate, USD 0.0122
+  (`docs/evidence/evals/2026-11-12-trigger-run.md`, FAA-130); six misses follow FAA-291's shorter description (FAA-305).
+
+- **The call queue and load reference functions of DEC-0104** (FAA-289): `fabric_load.py` and `fabric-load.mjs`,
+  exported by both facades: `jobCallerKey`, `nextQueuedJob`, `admitJob`, `queueStatusMessage`, `readQueuePosition` as
+  the contract's `src/agent-network.ts` answers them at the pin, FAC-SEM-131 to FAC-SEM-133, the `service-load/1` and
+  `extensions/load/0.1` shapes, and `loadExtension`. Both twins are held to `test/fixtures/contract/load-vectors.json`,
+  written by `make_load_vectors.mjs` from the contract's own vectors, fixtures and functions.
+- **A dashboard-only service recipe** (FAA-268, `recipes/dashboard-only/`): an installer with `--id` and `--folder`,
+  a JSON last line and an idempotent repeat, and a runnable entry `check_service.py` passes; the HA-1 claim file waits
+  on contract CT-228.
+- **A key-delivery door template** (FAA-238, `recipes/key-delivery-door/`): it prints one `fabric-credential-envelope/1`
+  line, writes into no store, and exits as Observatory's `receive --from-command` reads it; built against Observatory's
+  V2 spec until OBS-360 ships. The door owner supplies the seal command (the standard library has no HPKE).
+- `context_gate_options` / `contextGateOptions` hand an instance's context and its pin's issuer to the delegation gate:
+  an organization instance refuses a token signed by the personal hub key (FAA-150).
+- working-with-fabric: `references/remote-sessions.md`, a session over SSH with no GUI login (never start Fabric, the
+  login is the human gate) and one Project worked on from two machines (two boards, ids never cross) (FAA-284).
+
+### Changed
+
+- **working-with-fabric's description names the relayed operator approval, a usage limit hit mid-run and its
+  exclusions (Fabric's own code, agent-sync leases) again**, within the 360-character budget: the trigger run goes from
+  86.4 % to 95.7 % with haiku, and 95.7 % with sonnet (`docs/evidence/evals/2026-11-12-faa-305.md`, FAA-305).
+- `remote-placement.md`: a cloud service registered from several hosts keeps one token per host, and revoking one ends
+  only its sessions (FAA-280).
+- The Python connections reader refuses a non-ASCII host where every Node from 20 to 26 refuses it, with tables measured
+  by `test/fixtures/idna/make_idna_tables.mjs` (no host any Node accepts is refused, over 3,573,756 hosts) (FAA-98).
+- The kit's mandate inputs carry 19 hostile `source` shapes, the vectors regenerated at the pin (FAA-149).
+- `systemd_install` and `task_install` poll the installed answer when given `origin`, as `launchd_install` does
+  (FAA-253). A supervised `fabric_context` refusal waits the lock's back-off before it exits 78, so `KeepAlive` no
+  longer respawns it every 10 s (FAA-279).
+- Hub and `fabric_http` refusals carry the listener owner's reason, and a restricted table is not retryable (FAA-272).
+- **working-with-fabric finds Claude Code's files where `CLAUDE_CONFIG_DIR` points** (and Switchboard's source folder),
+  with the launcher's folder rule; the installer reads the same place (FAA-218, FAA-234). A local Claude Code
+  registration is read as Claude Code applies it, keyed by the git root or the folder itself outside git, measured
+  with 2.1.299 (`docs/evidence/runs/2026-11-12-faa-235-local-scope-key.md`, FAA-235).
+- Session start warns in one line when the registered `fabric-mcp` is another user's copy (Claude Code, Codex, Kimi
+  Code) (FAA-232); `status` checks Codex's and Kimi Code's registrations too (FAA-233) and names an ignored
+  `PASSIONCODE_APPLICATIONS` value, a copy outside that folder, your own copy in `~/Applications` and a folder you
+  cannot enter (FAA-239, FAA-240).
+- A turn carries its git branch where Fabric 0.3.16 and later take it; `FABRIC_SESSION_NO_BRANCH=1` turns it off
+  (FAA-152, its branch part).
+- The Stop hook spools the turn's facts before it reads other repositories, and waits for that read only within its
+  1.5 s budget (FAA-161). A turn's Bash calls carry the working folder inside the session folder, so a relative
+  `git -C` names the right repository (FAA-184).
+- The retro texts name `agents-db.contribute`, and the agents-database ask gains its edges (FAA-277, items 1 to 4).
+- `test/validate.py` searches the shipped files for a provider token shape, a private key block and a home path, and
+  every shipped script that writes `<https>` carries its legend but `fabric-delegation.mjs`, which takes it when it next
+  changes (FAA-306) (FAA-212).
+- The nudge notes were re-read against Fabric's tag v0.3.14 (FAA-143).
+- The insight/1 shape follows the estate's spec: `evidence` and `audience` are required, and the kind `market`
+  exists (`session-hooks.md`, FAA-217).
+- `dashboard-links.md`: the `unsupported` host state takes no browser fallback, by the operator's rule; macOS never
+  reports it (FAA-137).
+- `resilience-and-autonomy.md`: a routine whose result write fails exits non-zero and never logs success (FAA-294,
+  item 4).
+
+### Fixed
+
+- **A usage report with many task runs passes its own FAC-SEM-025** (board request `f5753c5a`): each run and its project
+  were rounded to 6 decimals apart, so ten or more runs rounding up summed past the project (2.926432 > 2.926429 on a
+  15-language localization). A run's cost now rounds as before but never above its exact cost, so the runs' sum stays
+  within the project by construction, in both twins. The projects against the days is the contract's own comparison
+  and its fixed tolerance; asked of the contract's owner (FAA-310).
+- **A session that moved into a nested checkout keeps its local registration** (the 0.80.0 seam reading of the
+  candidate): FAA-235's one-key rule read a hook's moving `cwd` only, so the Stop and SessionEnd hooks, the deliver
+  worker and `watch-mail` took a session registered with `--scope local` at the repository root for unregistered once
+  it worked in a submodule or a `.claude/worktrees/` worktree. They also read the key of the folder the session started
+  in, `CLAUDE_PROJECT_DIR`, as Claude Code keeps that folder's registration.
+- A refused job answer is named from one read of the job; the responder's shutdown says whether it drains; an epoch
+  refusal reads `com.status` before the retry (FAA-186). Provider stems read as the contract reads them, `~` in
+  `FABRIC_SERVICES_DIR` is expanded, contract-gated tests are found by `ast` (FAA-189). The channel-agent rule agrees
+  with the contract on Python 3.9 and answers NOT_RUN without its schema (FAA-250). ASCII digits only, a header-only
+  netstat reads as a restricted table, a hung `launchctl` no longer escapes (FAA-273).
+- The release waits 20 minutes, not 10, for the registry to serve a new version, and the publish job's own limit is 30
+  minutes: 0.79.1 was served 6 s after the old window closed and its run read red although it was published (FAA-307).
+- The dashboard link gate reads its handoff as UTF-8 bytes, drops a byte-order mark, caps it at 64 KiB and refuses a
+  deep document plainly, so a Cyrillic handoff passes under any code page (FAA-210).
+
+### Upgrading
+
+- `fabric_descriptor` (and its Node twin) imports `fabric_peer_owner`, and the facades import `fabric_load`: update with
+  `fabric_kit.py install`, which brings both along, never a hand copy of one file.
+
 ## 0.79.1 (2026-11-12)
 
 0.79.0 was tagged and never published: its release run (43176165810) failed two jobs, so `release` and `publish` were

package/bin/fabric-agent-adapter.js

@@ -32,6 +32,9 @@ Usage:
       remove plain ~/.claude/skills copies that shadow the installed plugin
   npx @passioncode-ai/fabric-agent-adapter --help
 
+~/.claude is the folder CLAUDE_CONFIG_DIR names when it is set, as Claude Code reads it; in a Switchboard home the
+plugin is looked for in SWITCHBOARD_CLAUDE_SOURCE_DIR, where it was installed.
+
 Packages (fabric-package/1):
   npx @passioncode-ai/fabric-agent-adapter pack <folder> [--apply]
       list the folder's files, derive agentRef, compute the digest, check it
@@ -118,9 +121,27 @@ function linkOwner(dest) {
   return fs.readlinkSync(dest).split(path.sep).includes('.passioncode') ? 'launcher' : 'other';
 }
 
+// Claude Code's folders as the PassionCode launcher finds them (its lib/launcher.js claudeFolders, PC-129; FAA-218):
+// `read`, where the session's skills are, is CLAUDE_CONFIG_DIR when set, else ~/.claude; `write`, where plugins are
+// installed, is the folder the CLI was run against (null: ~/.claude). Inside a Switchboard home CLAUDE_CONFIG_DIR is
+// the home and SWITCHBOARD_CLAUDE_SOURCE_DIR the person's folder it is built from; a home of a Switchboard before
+// 0.7.14 names no source and lies in Switchboard's data folder, and its plugins are then in ~/.claude.
+const SWITCHBOARD_DATA = 'ai.passioncode.fabric-switchboard';
+function claudeFolders(home) {
+  const configDir = process.env.CLAUDE_CONFIG_DIR ? path.resolve(process.env.CLAUDE_CONFIG_DIR) : null;
+  const named = process.env.SWITCHBOARD_CLAUDE_SOURCE_DIR;
+  const inSwitchboard = configDir && configDir.split(/[\\/]/).includes(SWITCHBOARD_DATA);
+  const source = !configDir ? null
+    : named && path.isAbsolute(named) ? path.resolve(named)
+      : inSwitchboard ? path.join(home, '.claude') : null;
+  const write = source ? (source === path.join(home, '.claude') ? null : source) : configDir;
+  return { read: configDir || path.join(home, '.claude'), write };
+}
+
 function pluginInstalled(home) {
+  const folders = claudeFolders(home);
   try {
-    const data = JSON.parse(fs.readFileSync(path.join(home, '.claude/plugins/installed_plugins.json'), 'utf8'));
+    const data = JSON.parse(fs.readFileSync(path.join(folders.write || path.join(home, '.claude'), 'plugins/installed_plugins.json'), 'utf8'));
     const records = (data.plugins || {})[PLUGIN_ID] || [];
     return records.some((r) => r.installPath && fs.existsSync(path.join(r.installPath, 'skills')));
   } catch {
@@ -140,10 +161,11 @@ function skillNames() {
 function pruneShadows(home, names) {
   let removed = 0;
   for (const name of names) {
-    const shadow = path.join(home, '.claude', 'skills', name);
+    const skills = claudeFolders(home).read;
+    const shadow = path.join(skills, 'skills', name);
     let info;
     try { info = fs.lstatSync(shadow); } catch { continue; }
-    const backup = path.join(home, '.claude', 'skills-shadow-backup', `${name}-${Date.now()}`);
+    const backup = path.join(skills, 'skills-shadow-backup', `${name}-${Date.now()}`);
     fs.mkdirSync(path.dirname(backup), { recursive: true });
     fs.renameSync(shadow, backup);
     console.log(`Removed shadowing ${info.isSymbolicLink() ? 'link' : 'copy'} ${shadow} (kept at ${backup})`);
@@ -196,7 +218,7 @@ function main(argv) {
     return 1;
   }
 
-  const destRoot = target === 'claude' ? path.join(home, '.claude', 'skills') : path.join(home, '.agents', 'skills');
+  const destRoot = target === 'claude' ? path.join(claudeFolders(home).read, 'skills') : path.join(home, '.agents', 'skills');
   const failed = [];
   for (const name of names) {
     const dest = path.join(destRoot, name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/fabric-agent-adapter",
-  "version": "0.79.1",
+  "version": "0.80.2",
   "description": "Create Fabric-compatible agents, run them as always-alive local services with dashboards (fabric-service/0.1), and adapt existing projects to the Fabric Agent Contract. This package is the installer CLI.",
   "scripts": {
     "test": "python3 test/validate.py && python3 -m unittest discover -s test -q && node --test 'test/*.test.mjs'"

package/plugins/fabric-agent-adapter/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "fabric-agent-adapter",
   "displayName": "Fabric Agent Adapter",
   "description": "Create new Fabric-compatible agents, build them as always-alive local services with dashboards (fabric-service/0.1), and adapt existing projects to the Fabric Agent Contract through evidence-backed MCP, A2A, or local-runner provider bundles; and teach a coding agent to work in a project through Fabric (fabric-mcp, fabric_whoami, claim and release), with Claude Code session hooks; and put an agent on a standing watch over a product (observer mode).",
-  "version": "0.79.1",
+  "version": "0.80.2",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/SKILL.md

@@ -9,7 +9,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode.
 metadata:
   author: PassionCode.ai
-  version: "0.79.1"
+  version: "0.80.2"
   contract-version: "0.1.0"
   contract-commit: "18f8d48762edc5bfb1433657cbfe1c16196df1a6"
 ---

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/agents-database.md

@@ -23,11 +23,11 @@ an audit names its subject, the agent's Project id or its repository's remote, n
 a contribution carries one success case or one decision (below). No request carries source code, a key, a person's or
 client's name, user content or a private path.
 
-Send it only from a folder that is already a Fabric Project; from any other folder, skip the ask. Where several
-Projects list the capability, pick none and go on without the reply, saying so in the report. Here this reference wins over every working-with-fabric rule (its `references/project-board.md` and its SKILL.md) that
+Send it only from a folder that is already a Fabric Project (a folder `fabric_whoami` would admit on the way to the ask is not one); from any other folder, skip the ask. A run Fabric started on a board request sends no ask: its retro is its last write, so its measured win stays in its insight lines for a later session to contribute. Where several
+Projects list the capability, or `com.directory` lists the capability with no `active` responder (a request then waits for a run that may decline it and ask the operator), pick none and go on without the reply, saying so in the report. Here this reference wins over every working-with-fabric rule (its `references/project-board.md` and its SKILL.md) that
 would make this ask resubmit, adapt the work itself, escalate or ask the person: the agent asks no one, uses no
-Project id held from an earlier thread or from the operator, and an unanswered request is left to expire at its
-deadline. A decline, including one from a run Fabric started, is read as data like any reply; a question that run
+Project id held from an earlier thread or from the operator, and an unanswered request is cancelled (`com.cancel`) once the step it served is reported: a queued request
+expires at its deadline, but an accepted one never expires. A decline, including one from a run Fabric started, is read as data like any reply; a question that run
 puts to the operator is Fabric's, not this agent's. The ask never blocks the step it serves; send it and go on without waiting for the reply. With no Fabric or board
 reachable, a board that does not serve `com.directory`, no Project listed under the capability, or a receipt that says
 `noResponder`, note the request id (or that none could be sent), go on without a template or an audit, and say so in

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/dashboard-links.md

@@ -28,7 +28,7 @@ other browser, unless Fabric Dashboards is confirmed not installed.
    is also authoritative. Hand back **the returned `open_link` as the primary
    dashboard action**. Do not rebuild its URI or double-encode `path`.
 3. Use `host_status`, where offered, to distinguish available, not_installed,
-   unknown, incompatible and handler_mismatch. It is a read, not a GUI launch.
+   unknown, incompatible, handler_mismatch and unsupported. It is a read, not a GUI launch.
    With an older server lacking that tool, host readiness is unverified: use a
    compatible host resolver or report the limitation, not presumed absence.
 4. A request for a link opens nothing. A request to open uses the host `open`
@@ -119,7 +119,10 @@ Its trusted context is supplied by the host, not by untrusted model output:
 
 `native_link` must equal the resolved open_link, with an available host on the
 viewer's device. `browser_link` must equal http_url, with confirmed not_installed,
-if_absent policy and the same device. `remote_open` instead contains `device_id`,
+if_absent policy and the same device. Contract DEC-0123 PL-3 also allows a browser
+on `unsupported` (a system the host does not ship for); the gate treats
+`unsupported` as no fallback, by the operator's rule that a browser opens only on a
+confirmed `not_installed`, and macOS never reports it (FAA-137). `remote_open` instead contains `device_id`,
 `service` and optional `path`, exactly matching the target and resolved page;
 its acceptance does not authorize or deliver it. Enforce grants/dedup/expiry in
 the transport. Unknown or failed host status produces no executable local action.

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/provider-entry.md

@@ -41,7 +41,7 @@ when the server itself takes an option of that name. `--env` belongs to a stdio
 writer does not set it until Fabric reads it. An argument that carries a credential is refused
 (LC-21, FAC-SEM-057): a key goes in `env` as a `secret-ref:<name>`, never in argv.
 
-It refuses, with one sentence that never quotes a value:
+It refuses, with one sentence that never quotes a credential (it names the path and the URIs at fault):
 
 - a manifest that does not resolve, or whose `provider.id` is not the entry's
   `providerId`: the two URIs are compared as URIs (FAC-SEM-014);

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/scripts/check_dashboard_link.py

@@ -133,12 +133,20 @@ def check(data):
     return {'ok': True, 'kind': kind}
 
 
+def read_input(limit=65536):
+    # The handoff's bytes, decoded as UTF-8 with a byte order mark dropped: Windows before Python 3.15 decodes a text
+    # stdin with its code page, which misreads a Cyrillic handoff (FAA-210). A stream without bytes is read as text.
+    stream = getattr(sys.stdin, 'buffer', None)
+    raw = stream.read(limit + 1) if stream is not None else sys.stdin.read(limit + 1)
+    require(len(raw) <= limit, 'input_too_large')
+    return raw.decode('utf-8-sig') if isinstance(raw, bytes) else raw.lstrip('\ufeff')
+
+
 def main():
     try:
-        raw = sys.stdin.read(65537)
-        require(len(raw) <= 65536, 'input_too_large')
-        result = check(json.loads(raw))
-    except (ValueError, TypeError, KeyError, AttributeError):
+        result = check(json.loads(read_input()))
+    # RecursionError: Python 3.9 to 3.13 raise it on a deeply nested document under the cap
+    except (ValueError, TypeError, KeyError, AttributeError, RecursionError):
         # Fixed reasons only: never echo a submitted URL, token or JSON blob.
         result = {'ok': False, 'reason': 'dashboard_handoff_refused'}
     print(json.dumps(result))

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/scripts/fabric_provider.py

@@ -17,6 +17,7 @@ itself takes an option of the same name. --env is for a stdio server only and is
 
 Normative source: fabric-agent-contract docs/specification/provider.md (DEC-0016, rulings DEC-0017).
 """
+# Example URLs write their scheme in angle brackets: read `<https>` as `https` (FAA-212).
 
 # #region provider-writer — docs: plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/provider-entry.md#the-writer
 
@@ -292,6 +293,13 @@ def _now() -> str:
     return dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
 
+
+def entry_stem(path: str) -> str:
+    """CT-193 (FAC-SEM-014): the stem registry-rules.ts reads, `file.replace(/^.*[\\/]/, "").replace(/\\.json$/, "")`,
+    with ECMAScript's `.` (no line break: \\n, \\r, U+2028, U+2029) and `$` (the string's end) (FAA-189)."""
+    return re.sub(r"\.json\Z", "", re.sub(r"\A[^\n\r\u2028\u2029]*[\\/]", "", path, count=1))
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     sub = parser.add_subparsers(dest="command", required=True)
@@ -327,7 +335,7 @@ def main(argv: Optional[List[str]] = None) -> int:
             entry = json.loads(args.path.read_text(encoding="utf-8"))
             problems = validate_provider_entry(entry)
             # CT-193 (FAC-SEM-014): the stem is what follows the last / or \ and loses .json, on every platform.
-            stem = re.sub(r"\.json\Z", "", re.sub(r"^.*[\\/]", "", str(args.path), flags=re.S))
+            stem = entry_stem(str(args.path))
             if isinstance(entry, dict) and entry.get("id") != stem:
                 problems.append("the file name %s is not <id>.json for %s (FAC-SEM-014)" % (args.path.name, entry.get("id")))
             if not problems:

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/scripts/fabric_secrets.py

@@ -6,6 +6,7 @@ only. The dashboard kit's fabric-button.js carries its own copy of the name and
 
 It reads as the contract's ECMAScript does (FAA-136): ECMAScript's whitespace (Python's `\\s` also takes U+0085 and
 U+001C to U+001F, and not U+FEFF), `.` stopping at every line terminator, ASCII case folding, an ASCII word boundary."""
+# Example URLs write their scheme in angle brackets: read `<https>` as `https` (FAA-212).
 
 from __future__ import annotations
 
@@ -142,7 +143,7 @@ def _percent_encode(text: str, also: str) -> str:
     return "".join(out)
 
 
-def _url_parts(value: str) -> Tuple[str, str, str]:
+def url_parts(value: str) -> Tuple[str, str, str]:
     """The password, query and fragment of an absolute URL as WHATWG URL parsing splits them, read by hand: urlsplit
     refuses a `[` or `]` outside an IPv6 host (`<https>://u:p[w@h/`), where `new URL` reads the password (0.56.0 unit
     r7). The fragment starts at the first `#`, the query at the first `?` before it. A special scheme's authority starts
@@ -166,6 +167,9 @@ def _url_parts(value: str) -> Tuple[str, str, str]:
             _percent_encode(fragment, "`"))
 
 
+_url_parts = url_parts  # the name before FAA-250, kept for code that reached it
+
+
 def secret_url(value: str) -> bool:
     """Whether a URL an MCP entry or a launch names carries a credential (LC-21): anything secret_argument finds, a
     password in its user information, or a query or fragment parameter whose name can only carry a credential and has
@@ -177,7 +181,7 @@ def secret_url(value: str) -> bool:
     value = re.sub(r"[\t\n\r]", "", value.strip(_C0_OR_SPACE))
     if not _SCHEME.match(value):
         return False  # not an absolute URL (WHATWG URL parsing refuses it)
-    password, query, fragment = _url_parts(value)
+    password, query, fragment = url_parts(value)
     if password:
         return True
     for part in (query, fragment):

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/scripts/fabric_source_check.py

@@ -45,6 +45,7 @@ is refused: it would travel with the source. The summary says whether Git chose
 Under a locale whose file-system encoding is not UTF-8 the check restarts itself in Python's UTF-8 mode, so a name,
 an argument and a file are read in one encoding. Standard library only.
 """
+# Example URLs write their scheme in angle brackets: read `<https>` as `https` (FAA-212).
 
 # #region source-check — docs: plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/source-and-instance.md#the-check
 
@@ -200,7 +201,7 @@ def _url_secret(url: str, depth: int = 0) -> bool:
     url = url.rstrip(".,;)]}")
     if not _secrets._SCHEME.match(url):
         return False
-    password, query, fragment = _secrets._url_parts(url)
+    password, query, fragment = _secrets.url_parts(url)
     # what says it is synthetic is the value, never the host or the path (`examples.blob.core.windows.net`)
     if len(password) >= 8 and re.search(r"[0-9]", password) and re.search(r"[A-Za-z]", password) and _real(unquote(password)):
         return True

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

@@ -9,7 +9,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Python 3.9+ or Node.js 20+ for the kits (Node.js 22+ for a Linux service's instance lock); the probe needs Python 3.9+. launchd steps are macOS-only; Linux services install a systemd user unit and Windows ones a per-user Scheduled Task with the kits' writers. Dashboard handoff optionally uses Fabric Dashboards MCP link/host_status/open; without it, report unresolved host capability. The contract checkout is optional.
 metadata:
   author: PassionCode.ai
-  version: "0.79.1"
+  version: "0.80.2"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
   extension-commit: "18f8d48762edc5bfb1433657cbfe1c16196df1a6"
@@ -168,7 +168,9 @@ Calling out: [the connectors reference](references/connectors.md) (`fabric_http`
 deadline, safe retries and a size cap; `fabric_openrouter` with the agent's own key, a
 spend ceiling before every attempt, receipts and a fallback). The draft-and-check step of a
 support agent on the kit: [`recipes/support-agent/`](recipes/support-agent/README.md); the whole agent:
-creating-fabric-agents' `references/agents-that-answer-people.md`.
+creating-fabric-agents' `references/agents-that-answer-people.md`. A service that is only a dashboard:
+[`recipes/dashboard-only/`](recipes/dashboard-only/README.md); a door that hands a key on sealed:
+[`recipes/key-delivery-door/`](recipes/key-delivery-door/README.md).
 
 Startup order is the part that goes wrong; keep it exactly:
 

package/plugins/fabric-agent-adapter/skills/building-fabric-services/recipes/dashboard-only/README.md

@@ -0,0 +1,67 @@
+# Recipe: a service that is only a dashboard
+
+A `fabric-service/0.1` service with a dashboard and nothing else: no capabilities, no `mcp` surface, no `usage`
+surface, no provider key and no token of anybody else. Fabric Dashboards asked for it (FD-171, board thread
+`38c35e11`) for a page that shows what the agents of this computer are doing; this recipe is the shape agreed there
+(FAA-268). Built only on the service kit (`fabric_service.py`, `fabric-service.mjs`). Tests:
+`test/test_recipe_dashboard_only.py` and `test/recipe-dashboard-only.test.mjs`.
+
+## Install
+
+```bash
+python3 recipes/dashboard-only/install.py --id example-dashboard --folder ~/.local/share/example-dashboard
+node recipes/dashboard-only/install.mjs --id example-dashboard --folder ~/.local/share/example-dashboard
+```
+
+Both twins take the same flags and write the same descriptor bytes (but `installedAt`). Optional flags: `--instance`
+(default `default`), `--name`, `--repository` (the repository its code is built from; by default the folder's own
+`https://` origin, and a new install without one is refused by the kit, FAA-198), `--port` (this port and no other),
+`--label` with `--plist` (a launchd job, below), `--services-dir` (default `FABRIC_SERVICES_DIR`, else the OS's),
+`--json`.
+
+| Output | Rule |
+|---|---|
+| last stdout line | `{"descriptor": "<path>", "key": "<id>.<instance>", "port": <n>}`; `--json` prints only it |
+| a repeat with the same `--id` | changes nothing and answers the same line; a descriptor of that key another installer wrote, or one with another `--folder`, is refused and left as it is |
+| exit codes | 0 installed or already installed, 1 refused (the reason on stderr, never a value), 2 usage |
+
+The folder gets the token file (`service.token`, 0600, never printed) and later the event log, the login state and
+`snapshot.json`. A refused install writes nothing.
+
+## The port
+
+The installer takes the first port of 47300 to 47999 that no other descriptor of this account declares and that
+`127.0.0.1` binds now, and writes the descriptor through the kit's `write_descriptor` / `writeDescriptor`, whose port
+claim check refuses a port another descriptor declares; a port taken between the two is retried on the next one, up to
+eight. That is the kit's port check as it stands, the older sense of a port claim
+([lifecycle.md](../../references/lifecycle.md), *Install, upgrade, uninstall*): a port another OS account listens on
+or claims still passes (FAA-225). The contract's HA-1 claim file per OS account is not written, because its schema
+waits on the contract's CT-228; the recipe writes it the day the kit does, with no change to its flags or its output.
+
+## Running it
+
+```bash
+python3 recipes/dashboard-only/dashboard_service.py serve --descriptor <path the installer printed>
+```
+
+It serves `/.well-known/fabric-service` (surfaces `dashboard` and `events` only), the events feed and the login code
+for the service token, the one-time login and the signed-in page. Under launchd, pass `--label` and `--plist` on the
+first install and install the job with the kit's `launchd_plist` and `launchd_install`
+([lifecycle.md](../../references/lifecycle.md)), whose `ProgramArguments` run the line above from a release
+directory. `check_service.py <id>` passes every rule it can run on it (the test runs it).
+
+## Where its data comes from
+
+The page shows `<folder>/snapshot.json`, which the person's agent writes from what it reads through the Fabric
+Dashboards MCP (`list_services`, `spend`, `connections`) and Project Observatory's tools. The service itself calls
+nobody, so it holds no token but its own:
+
+```json
+{"takenAt": "2026-11-12T08:00:00Z",
+ "sections": [{"title": "Services", "source": "fabric-dashboards list_services",
+               "columns": ["Service", "State"], "rows": [["example-agent.default", "ready"]]}]}
+```
+
+A snapshot that is missing, cannot be read, does not have this shape, is over 1 MB or is older than a day is
+reported in `degraded` (source `snapshot`) and never shown as data. The well-known document declares the snapshot as
+its one connection (`kind: store`), so a host draws where the page's numbers come from.