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

package/CHANGELOG.md

@@ -1,5 +1,261 @@
 # 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
+skipped. 0.79.1 is 0.79.0 with these fixes, and is the release that ships it. Kit modules change: `fabric-peer-owner.mjs`,
+`fabric_supervisors` and `fabric-supervisors.mjs`, `fabric_board_session`, `fabric_board_slots` and their Node twins.
+
+### Fixed
+
+- **A checked connection to `localhost` reaches a listener on 127.0.0.1 under Node 18** (the `floors` job). Node 18
+  connects to the first address only, and `localhost` resolves to `::1` first on Linux, so `checkedSocket` (and every
+  loopback read made through it: `wellKnownOf`, the key set, the OpenRouter connector) found nothing where Python and
+  Node 20 and later try every address. It now passes `autoSelectFamily: true`. Reproduced on Node 22 with
+  `--no-network-family-autoselection`: the test fails without the change and passes with it.
+- **The Windows job runs what passes there** (the `windows` job). 0.79.0 ran the whole of
+  `test_fabric_session_dispatch.py` on Windows for the first time (FAA-236): the parsing, `gate-id` and damaged-folder
+  tests pass, and twelve `Hooks` tests fail (the dispatch record's holder and `/clear` across processes). The job runs
+  the whole file again: the twelve were ten tests of the POSIX `/clear` take-over, which `dispatch_holder` turns off on
+  Windows by design (now skipped there with the reason), one file read with the code page (now UTF-8), and one real
+  defect: when `os.fdopen` raised, the descriptor stayed open, Windows refused to remove the empty record, and the
+  run was told it was nested and never did its request. The descriptor is closed first (FAA-302).
+- **`foreign-user` no longer drops a lost call's record** (the 0.79.0 seam reading): 0.79.0's new board code
+  (FAA-252) reached two places that keep a lost call's state and read it as a refusal. The reply probe
+  (`_replied_before`, `repliedBefore`) and a lost enroll's asking record (`_replay`, `replay`) now stay, as for
+  `unreachable`, so a reply is never sent twice. Both twins, a test in each.
+- **A loopback origin with no port, or `:80`, is read on a checked connection** in both twins: Node's `new URL`
+  drops the default port and read `http://127.0.0.1:80` unchecked; Python read a portless origin unchecked.
+- `references/delegation.md` says what a restricted socket table does to a loopback key set and the way round.
+
+### Changed
+
+- 0.79.0's FAA-293 line is narrower than it read: the inode check closes the race between two copies starting at once.
+  A folder swapped under a copy already running is not caught yet (FAA-303).
+
+### Upgrading
+
+- `fabric_delegation` (and `fabric-delegation.mjs`) imports `fabric_peer_owner` since 0.79.0: update with
+  `fabric_kit.py install`, which brings it along, never a hand copy of the one file.
+
+## 0.79.0 (2026-11-12)
+
+The first release of the backlog sweep of 2026-11-12 (plan and inventory of the 134 open rows:
+`docs/evidence/specs/2026-11-12-backlog-waves-plan.md`). The contract pin stays `18f8d487`. Kit modules change:
+`fabric_lock`, `fabric_base`, `fabric_delegation`, `fabric_descriptor`, `fabric_supervisors`, `fabric_board_link`,
+`fabric_board_slots`, `fabric_board_session`, `fabric_openrouter`, the facade `fabric_service`, their Node twins, and
+`fabric-secrets.mjs`. The dashboard kit moves to 1.1.6.
+
+### Added
+
+- **creating and adapting: an organization's catalogue first** (the project board's request `2718ece8`). One neutral
+  line at step 0 of creating-fabric-agents and before scaffolding in adapting-projects-to-fabric: a private catalogue
+  of agent templates with an architect is asked first for the template, version, variant and known traps; the skill
+  runs after it. Scenario `ask-the-organization-catalogue-first` in both skills.
+
+### Changed
+
+- **working-with-fabric reads against Fabric v0.3.19.** The session-start preamble, the README and SKILL.md say both
+  cases: before Fabric 0.3.17 a dispatched run declines a request no session can take and the asker resends; from
+  0.3.17 the session's own Project is granted `board.respond` at `com.enroll` (CO-506) (FAA-221). The exit contract's
+  decline names the refusal's reason, takes over an `in_progress` request an earlier run left, and reads board ids
+  from the dispatch line first; the Observatory packet's board refs are the fallback (FAA-215, FAA-295).
+  `references/on-demand-session.md` and `board.md` name the Fabric releases as they are (FAA-246, FAA-216), and a
+  helper a run starts itself uses the runner's bypass flag with the task's limits set at launch (FAA-274).
+- **"When nobody answers"** runs only on a machine whose trust is `mine` (ADR-0176), and the asker cancels its own
+  request after adapting (FAA-220). One phrase for a never-held slot, and a gate question is moot once its request is
+  answered or taken (FAA-222, FAA-248).
+- **creating-fabric-agents: completion lines for an agent that answers people**, one per checklist item (a file and a
+  test, or `NOT_RUN`), the first reply measured from the person's message (FAA-180).
+- **One rule for a secret in a child's environment**: the agent's own process may hold its key from its supervisor or
+  a vault runner; a child it starts never gets it (FAA-281).
+- **Operator channel through the estate's gateway**: where the estate runs a messaging gateway the operator chose, the
+  channel sends through it; a polling token has one poller across machines (`poller-elsewhere`); the contract's
+  own-bot form (DEC-0034) is unchanged (FAA-282).
+- **README quick start picks a free port**; `where-agents-run.md` adds one computer with a personal and an
+  organization account and a member's virtual machine (DEC-0154) (FAA-283).
+- **The dashboard link gate is agent-side**, and a generated project pins a negative fixture in its own test (FAA-129).
+- **The shipped-file check follows npm** (`test/validate.py`): a `files` entry with a glob, one naming nothing, or no
+  `files` at all is a finding; README and LICENSE are read because npm ships them regardless; a line with no scheme
+  says so. Tests pin `__pycache__`, the wiring into `validate_repo`, and the kit's `older` and `modified` verdicts
+  without release tags (FAA-212).
+
+### Fixed
+
+- **The instance lock never holds a file that is no longer at its path** (FAA-293, a board finding of 2026-11-10).
+  After `flock` (Python) or the `O_EXLOCK` open (Node on macOS), and again after the pid is written, `acquire`
+  compares the locked inode with the file at the path; on a mismatch it re-opens up to
+  `InstanceLock.INODE_RETRIES` (3) times, then fails with an error naming the path. A data import that swapped the
+  data folder no longer lets two copies start.
+- **The dashboard kit's resize observers write in the next frame** (dashboard kit 1.1.6, a board finding of
+  2026-11-12): the nav's observer laid the bar out inside its callback and the chrome's wrote `--fd-chrome-h` and
+  `--fd-chrome-top` there, so WebKit raised "ResizeObserver loop completed with undelivered notifications" at 390 px.
+  Both schedule their work with `requestAnimationFrame` (cancelling the previous frame), the nav refits only when its
+  width changed, the chrome writes a property only when its value changed; a WebKit test pins that no callback writes.
+- **Another OS account's listener is never read as ours**: the delegation verifier reads a loopback key set only from
+  this account's listener (FAA-255); the OpenRouter connector stops at once on a loopback base URL another account
+  holds, without trying the fallback model (FAA-257); a board session maps a hub port another account holds to
+  `foreign-user`, never `unreachable` (FAA-252); Python's `well_known_of` and `job_well_known_of` tell down from
+  `foreign-user` as Node's `wellKnownOf` does, and an origin spelled `localhost`, another 127/8 address or `[::1]` is
+  read on a checked connection (FAA-259, FAA-257); a hub pid another account's process holds is "not verified",
+  never running (FAA-254).
+- **The reserved capability `project.work`** is refused by both kits in `surfaces.mcp.capabilities`, as an action's
+  tool and by the board responder (DEC-0140 PR-1) (FAA-244).
+- The provider entry's URI check uses the RFC 3986 class the descriptor check uses: a byte-order mark, a zero-width
+  space, a non-ASCII path and an IDN host are refused (FAA-127).
+- The dispatch record survives a hooks folder damaged by hand: `RecursionError` reads as unreadable, a `dispatch`
+  file is a folder that cannot be written, prune ages a record by its own `lstat` (FAA-208).
+- `test/validate.py` reads board rows cell by cell as the workspace aggregator does: code spans and escaped pipes
+  (FAA-214). The Node credential detector and the dashboard kit's button append values in place, linear like the
+  Python twin (FAA-245). The source check's linear-time tests measure a ratio, not the wall clock (FAA-209).
+- The board kit sends the operator to Fabric's Settings → Agent access (FAA-223); `vendor_vectors.mjs` names the
+  command that works, the contract's `tsx` at the pin (FAA-242).
+- Step 6's `fabric_task_create` example carries the required `origin` (FAA-154).
+- A dispatched Claude Code run that sees only `fabric_whoami` is named as Fabric's CO-563 (fixed in the Fabric release
+  after v0.3.19) and says so in its exit report instead of claiming the board was read (FAA-296).
+- `fabric_session.py --help` and the README list `gate-id`, and the Windows job runs the dispatch tests (FAA-236).
+- `provider-entry.md` and the provider writer's message name Fabric v0.3.16 for CO-479 (FAA-216).
+
+### Upgrading
+
+- A service that vendors the kit updates its copies with `fabric_kit.py install` (the changed modules are named
+  above); a dashboard that vendors the dashboard kit takes 1.1.6. `launchd_install` takes injected readers
+  (`fetch_well_known=`, `fetch_job_well_known=`) as Node's `launchdInstall` takes `fetchWellKnown`.
+
 ## 0.78.0 (2026-11-12)
 
 The contract pin stays `18f8d487`. Kit modules change: a new `fabric_tailnet` and `fabric-tailnet.mjs` (layer L0); `fabric_supervisors` and `fabric-supervisors.mjs`, and the facades

package/README.md

@@ -24,7 +24,9 @@ The skills are `adapting-projects-to-fabric`, `creating-fabric-agents`,
 a terminal that works in a project through Fabric. It finds Fabric (`hub.json`, its `pid`), has the machine's
 lifecycle broker start it when it is down, registers `fabric-mcp` once with no secret, calls `fabric_whoami`
 first, reads the project board (`com.status`, `com.list`, `com.read_ack` only what was read), answers what waits on its
-Project in the same turn with its state (the result later; a request a responder should take stays queued), and asks other
+Project in the same turn with its state (the result later; a request its Project's service should take stays queued; before Fabric 0.3.17 a run Fabric starts
+declines a request no session can take and the asker resends, and from 0.3.17 the session's own Project is granted
+`board.respond` at `com.enroll`, CO-506), and asks other
 Projects only through `com.submit`, asks who is working on what and claims its task before it starts
 (`fabric_work_list`, `fabric_work_claim`, Fabric v0.3.5 and later), links tasks to backlog rows instead of copying them, and
 releases at the end (`fabric_work_release`). `scripts/fabric_session.py status` prints where Fabric stands and one
@@ -40,7 +42,7 @@ uses Fabric (one line pointing at `fabric_whoami` in a folder with no sign of it
 is down it adds one line (skip `fabric_whoami`, start Fabric through the broker if the task needs it), and only in a
 project that uses Fabric; in a session Fabric started on a board request (`FABRIC_DISPATCH_WORKFLOW` set) it prints the
 exit contract instead, on the condition that the session's own prompt starts with the dispatch line naming the same
-three, and UserPromptSubmit, which sees that line, confirms the run or says it is none (FAA-201); Stop records each turn's facts (HEAD, files changed, lines added and removed, never content)
+three (a `/clear` while another session holds the dispatch is told it is nested, FAA-208), and UserPromptSubmit, which sees that line, confirms the run or says it is none (FAA-201); Stop records each turn's facts (HEAD, files changed, lines added and removed, never content)
 and the board's unread count, and, once the running Fabric takes them (unless `FABRIC_SESSION_NO_REPOSITORIES=1`), the other repositories the turn touched (it then
 reads the last 512 KB of the session transcript (message text and tool output included, which can hold a secret the session displayed; read in memory only), uses only tool names and path arguments, and sends host/owner/name, never a
 local path or text); UserPromptSubmit adds one line only when that count rose, and each reminder Fabric gave on a turn once (a turn `watch-mail` delivered prints there instead); SessionEnd releases what the
@@ -49,7 +51,8 @@ line naming the retro (FAA-206; Fabric's `retro-after-work`, since Fabric 0.3.16
 advertises `session-hooks/1`; Stop and SessionEnd always prune their own stale spool folders. All are silent in a session Fabric launched (except the retro line after a release of finished work and, in one started on a board request, the exit contract and the prompt hook's verdict on its dispatch line, but no unread line or reminder), never block the session, read no Fabric token (an `origin` URL's embedded credential is dropped in memory, never
 kept or sent) and always
 exit 0 once `python3` starts (on Windows, Claude Code runs hooks in Git Bash, or PowerShell without it, where `python3`
-must name Python 3.9 or later; FAA-183). `fabric_session.py watch-mail` waits for board mail under a background watcher, and `install-host-hooks
+must name Python 3.9 or later; FAA-183). `fabric_session.py watch-mail` waits for board mail under a background watcher, `gate-id <request>` prints the
+`commandId` of a request's gate question (the one a dispatched run uses), and `install-host-hooks
 --host codex|kimi|hermes|opencode|openclaw|pi` installs each host's native context bridge (dry run unless `--apply`).
 Codex receives structured SessionStart JSON; Hermes, OpenCode, OpenClaw and Pi use native plugin APIs.
 See the [native host matrix](plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md)
@@ -204,18 +207,20 @@ With Python 3.9+ and the Claude Code CLI, in a throwaway directory and a tempora
 ```bash
 KIT=plugins/fabric-agent-adapter/skills/building-fabric-services/scripts   # or ~/.agents/skills/building-fabric-services/scripts
 DATA=$(mktemp -d); SERVICES=$(mktemp -d); WORK=$(mktemp -d)
-python3 "$KIT/sample_service.py" serve --port 47190 --data-dir "$DATA" &
-python3 "$KIT/sample_service.py" register --port 47190 --data-dir "$DATA" --services-dir "$SERVICES"
+# A free loopback port, so the sample never collides with a service already running here.
+PORT=$(python3 -c 'import socket;s=socket.socket();s.bind(("127.0.0.1",0));print(s.getsockname()[1])')
+python3 "$KIT/sample_service.py" serve --port "$PORT" --data-dir "$DATA" &
+python3 "$KIT/sample_service.py" register --port "$PORT" --data-dir "$DATA" --services-dir "$SERVICES"
 # The probe exits 0 (no FAIL); only then is the service registered for one client run (listener.owner proves the port
 # is this account's, and the client cannot check it). The token goes in a header, never in argv.
 # On macOS 27.2 run these with Apple's /usr/bin/python3: an ad-hoc-signed Python, such as Homebrew's, sees no other
 # process's sockets (FAA-272).
 python3 "$KIT/check_service.py" sample --services-dir "$SERVICES" && \
-python3 - "$DATA/service.token" "$WORK/mcp.json" <<'EOF'
+python3 - "$DATA/service.token" "$WORK/mcp.json" "$PORT" <<'EOF'
 import json, os, sys
 token = open(sys.argv[1]).read().strip()
 with os.fdopen(os.open(sys.argv[2], os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "w") as f:
-    json.dump({"mcpServers": {"sample": {"type": "http", "url": "http://127.0.0.1:47190/mcp",
+    json.dump({"mcpServers": {"sample": {"type": "http", "url": "http://127.0.0.1:%s/mcp" % sys.argv[3],
                "headers": {"Authorization": "Bearer " + token}}}}, f)
 EOF
 (cd "$WORK" && claude -p "Call the tool mcp__sample__sample_echo with text 'ping' and reply with only the text it returns." \
@@ -230,6 +235,8 @@ the CLI connected to the sample over streamable HTTP, called `sample.echo` and p
 ([record](docs/evidence/runs/2026-11-08-0.77.0-quick-start.md)). The probe prints one line per rule
 (`PASS`, `FAIL` or `NOT_RUN` with its evidence) and exits 1 on any `FAIL`; run it against your
 own service by its id once its installer has written the descriptor.
+The free-port line (FAA-283) was run again on 2026-11-12 from this repository's kit with Claude Code 2.1.299 and
+Apple's `/usr/bin/python3`: a port the system chose, 44 rules, 0 FAIL, `listener.owner` PASS, and `ping`.
 `FABRIC_REAL_CLIENT=1 python3 -m unittest discover -s test -p test_real_client.py` repeats the connection check
 (every sample tool listed, no model call) in the test suite.
 

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.78.0",
+  "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.78.0",
+  "version": "0.80.2",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

package/plugins/fabric-agent-adapter/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Two silent-unless-relevant hook sets. The dashboard-kit notice: one line at session start or /clear in a repository that owns a Fabric service whose dashboard has no kit or an older one (fabric-dashboard/0.1, DEC-0036), phrased as an upgrade the agent may make itself. The Fabric session hooks (working-with-fabric, COM-04, FAA-12a): at session start or /clear, the preamble when Claude Code has the MCP server `fabric` and Fabric runs (fabric_whoami, then the project board through com.status and com.list, claim and release); when Fabric is down, one line, only in a project that uses Fabric (a Fabric contract file, a project-bound registration or a service descriptor naming the repository); nothing on compact or resume; each turn's facts (HEAD, files changed, lines added and removed, never content), the board's unread count, and, once the running Fabric's fabric_session_observe takes them (unless FABRIC_SESSION_NO_REPOSITORIES=1), the other repositories the turn touched (the last 512 KB of the session transcript, message text and tool output included (a secret the session displayed can be there; read in memory only), is then read and only the current turn's tool names and path arguments are used; host/owner/name leave the machine, never a local path or text) and the session's end through Fabric, only when the running Fabric advertises session-hooks/1; at each prompt one line only when the unread count rose, then each nudge a turn's answer carried, once (watch-mail prints those of turns it delivered). The session hooks are all silent in a session Fabric launched but the exit contract and the prompt hook's verdict on it and the retro line below; the dashboard-kit notice is silent only in a session started on a board request. Every hook reads no Fabric token (a credential embedded in an origin URL is read by git config and dropped in memory, never spooled or sent), prints at most one block, always exits 0 once python3 starts (on Windows it must name Python in Git Bash, FAA-183), and hands any Fabric call to a detached worker with a 10 s deadline. In a session Fabric started on a board request (FABRIC_DISPATCH_WORKFLOW), session start prints the exit contract instead of the preamble on the condition that the session's own prompt starts with the dispatch line naming the same three, launched or not, and the prompt hook, which sees that line, confirms the run or says it is none, launched or not, with no unread line or nudge, and the dashboard-kit notice says nothing (FAA-201). After a call to Fabric's fabric_work_release or fabric_task_release that releases a claim as done, PostToolUse adds one line naming the retro (FAA-206); after any other call, or a release Fabric's answer refuses (released: false, already-released) or that released nothing, nothing.",
+  "description": "Two silent-unless-relevant hook sets. The dashboard-kit notice: one line at session start or /clear in a repository that owns a Fabric service whose dashboard has no kit or an older one (fabric-dashboard/0.1, DEC-0036), phrased as an upgrade the agent may make itself. The Fabric session hooks (working-with-fabric, COM-04, FAA-12a): at session start or /clear, the preamble when Claude Code has the MCP server `fabric` and Fabric runs (fabric_whoami, then the project board through com.status and com.list, claim and release); when Fabric is down, one line, only in a project that uses Fabric (a Fabric contract file, a project-bound registration or a service descriptor naming the repository); nothing on compact or resume; each turn's facts (HEAD, files changed, lines added and removed, never content), the board's unread count, and, once the running Fabric's fabric_session_observe takes them (unless FABRIC_SESSION_NO_REPOSITORIES=1), the other repositories the turn touched (the last 512 KB of the session transcript, message text and tool output included (a secret the session displayed can be there; read in memory only), is then read and only the current turn's tool names and path arguments are used; host/owner/name leave the machine, never a local path or text) and the session's end through Fabric, only when the running Fabric advertises session-hooks/1; at each prompt one line only when the unread count rose, then each nudge a turn's answer carried, once (watch-mail prints those of turns it delivered). The session hooks are all silent in a session Fabric launched but the exit contract and the prompt hook's verdict on it and the retro line below; the dashboard-kit notice is silent only in a session started on a board request. Every hook reads no Fabric token (a credential embedded in an origin URL is read by git config and dropped in memory, never spooled or sent), prints at most one block, always exits 0 once python3 starts (on Windows it must name Python in Git Bash, FAA-183), and hands any Fabric call to a detached worker with a 10 s deadline. In a session Fabric started on a board request (FABRIC_DISPATCH_WORKFLOW), session start prints the exit contract instead of the preamble on the condition that the session's own prompt starts with the dispatch line naming the same three, launched or not (a /clear while another session holds the dispatch is told it is nested, FAA-208), and the prompt hook, which sees that line, confirms the run or says it is none, launched or not, with no unread line or nudge, and the dashboard-kit notice says nothing (FAA-201). After a call to Fabric's fabric_work_release or fabric_task_release that releases a claim as done, PostToolUse adds one line naming the retro (FAA-206); after any other call, or a release Fabric's answer refuses (released: false, already-released) or that released nothing, nothing.",
   "hooks": {
     "SessionStart": [
       {

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.78.0"
+  version: "0.80.2"
   contract-version: "0.1.0"
   contract-commit: "18f8d48762edc5bfb1433657cbfe1c16196df1a6"
 ---
@@ -100,6 +100,7 @@ is unavailable, continue only through local structure and mark exact schema vali
 
 ### 3. Scaffold the provider bundle
 
+If your organization keeps a private catalogue of agent templates with an architect, ask it first: it names the template, version, variant and known traps; this skill runs after it.
 Before scaffolding, ask the [agents database](references/agents-database.md) for an audit of the project
 (`agents-db.audit`) and carry its `optimize` proposals into the completion report.
 Load [provider bundle](references/provider-bundle.md) before creating or mapping files.
@@ -290,9 +291,10 @@ host's `open` and `fallback=never`. Never `open <url>`, `open -a Safari`, `xdg-o
 `not_installed` host; an installed host that failed to open is reported, never replaced by HTTP.
 Links carry no token or login code.
 
-The agent's `AGENTS.md` carries this as its dashboard rule block, and its checks run the adapter's link gate
-(`scripts/check_dashboard_link.py` from this skill's own directory; it is not copied into the project) on every
-completion and notification action before delivery:
+The agent's `AGENTS.md` carries this as its dashboard rule block; the agent runs the adapter's link gate
+(`scripts/check_dashboard_link.py` from this skill's own directory, an agent-side gate never copied into the project or
+run by its CI) on every completion and notification action before delivery, and the project's own test pins the
+negative fixture:
 [dashboard links](references/dashboard-links.md) has the block, the gate's input and the remote case.
 Headless agents need no dashboard.
 

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,17 +119,52 @@ 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.
 A separately labelled copyable link for diagnosis is not an open action.
 
-Add this check to the generated project's dashboard completion/notification
-renderer before delivery. A raw-HTTP primary action with an available host is the
-negative fixture; a valid native action is the positive one. Keep diagnostics
-separate. This gate checks structured actions, not arbitrary prose: a CLI invocation
-or instructions alone do not prove all final answers from every agent are filtered.
+The gate is **agent-side**: the agent runs it from this skill's directory before it
+delivers an action. It is never copied into the generated project and never run by
+that project's CI: the adapter's versioned plugin folder has no stable path there, so
+its result in a project's pipeline would always be NOT_RUN. A raw-HTTP primary action
+with an available host is the gate's negative fixture; a valid native action is the
+positive one. Keep diagnostics separate. This gate checks structured actions, not
+arbitrary prose: a CLI invocation or instructions alone do not prove all final answers
+from every agent are filtered.
+
+The generated project pins the same negative fixture in its own test suite, without
+calling the gate: a test that renders its completion and notification output with an
+available host and fails when a raw loopback `http_url` or a legacy `open?service=`
+link appears in it. The snippet is self-contained; `render` stands for the project's
+own renderer:
+
+```python
+import re
+import unittest
+
+RAW_LOOPBACK = re.compile(r"https?://(?:127\.0\.0\.1|localhost|\[::1\])")
+LEGACY = "fabric-dashboards://open?service="
+RESOLVED = {"service": "example-agent.default",
+            "open_link": "fabric-dashboards://service/example-agent.default?path=%2Fdashboard",
+            "http_url": "http://127.0.0.1:47195/dashboard"}
+
+
+def render(resolved, host_state):  # replace with the project's completion/notification renderer
+    raise NotImplementedError
+
+
+class RenderedDashboardLinks(unittest.TestCase):
+    def test_rendered_output_has_no_raw_loopback_or_legacy_link(self):
+        out = render(RESOLVED, host_state="available")
+        self.assertIn(RESOLVED["open_link"], out)
+        self.assertIsNone(RAW_LOOPBACK.search(out), out)
+        self.assertNotIn(LEGACY, out)
+```
 
 ## Degradation
 

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/operator-channel-and-repository.md

@@ -25,6 +25,16 @@ unless addressed (`/command@ThisBot`, a reply to its own message or a press of i
 bare `/command` in a group is not addressed), and a channel nobody receives on is `degraded`
 (`receiver-missing`). Say so in the proposal when the operator means to bind a shared group.
 
+Where the estate runs a messaging gateway service the operator chose for sending (one service every
+agent sends through, holding its own grants and allowlist), the channel sends through that gateway
+and does not call the messenger itself; the agent's own bot above is the contract's form (DEC-0034,
+OC-11) and the form used where no such gateway runs. A bot token read by polling (Telegram
+`getUpdates`) has exactly one poller across every machine: a second poller on the same token gets
+`409 Conflict` and the two take each other's updates. Check placement before polling: the instance
+on the machine the estate's placement record names for the agent polls, an instance on any other
+machine does not poll and reports `degraded` with the reason (`poller-elsewhere`), and a test starts a
+second instance placed elsewhere and sees it stay off the token.
+
 Record the answer (`accepted`, `declined` or `later`) in the agent's state and in its conformance
 report, and do not ask again; an agent that serves `surfaces.operatorChannel` also shows it as
 `proposal` in its status document. Creating the bot and putting its token into the secret store
@@ -57,9 +67,9 @@ For a PassionCode.ai repository, the agent's repository follows the organization
   and a `CLAUDE.md` whose first line is `@AGENTS.md`.
 
 Whoever owns the repository, an agent with a page gets the dashboard rule block in its `AGENTS.md`
-(pages open only in Fabric Dashboards; the block is in `references/dashboard-links.md`), and its
-checks run the adapter's link gate (`scripts/check_dashboard_link.py` from the skill's own directory, not a copy in
-the project).
+(pages open only in Fabric Dashboards; the block is in `references/dashboard-links.md`); the agent runs the
+adapter's link gate (`scripts/check_dashboard_link.py` from the skill's own directory, agent-side, never a copy in the
+project or a step of its CI), and the project's own test pins the gate's negative fixture (the same reference).
 
 org-index `scripts/check_format.py` reports 0 findings for it before it is called done. An agent
 someone builds for themselves is not a PassionCode.ai repository: its licence is its owner's

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);
@@ -64,9 +64,9 @@ It refuses, with one sentence that never quotes a value:
 - a manifest whose name follows a backslash (`C:\Agents\example\fabric-agent.json`). The reader,
   `validate_provider_entry`, accepts it since DEC-0145 (`MANIFEST_PATTERN`, the schema's), but a reader that has not
   re-pinned to DEC-0145 refuses the entry, Fabric's registry among them (CT-192), so the writer does not emit it until
-  the oldest Fabric release in use reads it (the release after v0.3.15, CO-479). Write the path with `/` before the name. A manifest under the home folder
+  the oldest Fabric release in use reads it (Fabric v0.3.16, which shipped CO-479). Write the path with `/` before the name. A manifest under the home folder
   (`~/Agents/example/fabric-agent.json`) is read by every Fabric release; one with a drive letter
-  (`C:/Agents/example/fabric-agent.json`) only by Fabric after v0.3.15, whose registry took the repin (CO-479): v0.3.15
+  (`C:/Agents/example/fabric-agent.json`) only by Fabric v0.3.16 and later, whose registry took the repin (CO-479): v0.3.15
   and earlier read only a manifest under `~/` or `/`, so not `~\` either.
 
 `validate` also checks that the file is named `<id>.json` (FAC-SEM-014, slug half): the stem is what follows the last