@passioncode-ai/fabric-agent-adapter 0.58.0 → 0.60.0

package/CHANGELOG.md

@@ -1,5 +1,102 @@
 # Changelog
 
+## 0.60.0 (2026-11-03)
+
+The board responder is ready to find a slot the operator moves back to it, once Fabric offers the move (FAA-165), and four smaller fixes: working-with-fabric
+reads a filed row's answer (FAA-169) and says when an accepted request is left behind by a move (FAA-172), `pack`
+names why a provider manifest is refused (FAA-193), and Python's package kit refuses `NaN` and `Infinity` as Node's does.
+
+### Fixed
+
+- A slot the operator moved to another session and then back to this one (contract DEC-0140 PR-2, once Fabric offers
+  the move) would be held but never claimed or renewed: the responder skipped a `moved` slot until `take_back`, so its lease lapsed. Now, while a slot
+  is moved, the responder reads `com.status` once a renewal (20 s) and, when the slot's generation is past the recorded
+  move, sends one `com.claim` under a fresh key, as PR-2's "Learning the slot is its own" says. A claim that lands
+  holds the slot again (the record loses `moved`, the request it handed out is worked, or its own enroll renews the
+  lease at once; a later move is said again); `lease_expired` enrolls again; `held` asks at the next renewal;
+  `idempotency_window_expired` or `capacity_exceeded` asks again at the next renewal under a fresh key, recording
+  nothing; `fenced` or another refusal that is not the board session's records the new generation, so the same move is not asked about
+  twice. A recorded move drops the capability's claim key, so a claim answer lost before the move is never replayed, and a
+  lost answer to the move-back claim itself is asked again under its key, counting as a lease from its send meanwhile (while more than the 10 s margin of that lease is left)
+  (a replay from an older generation is dropped); `not_authorized` counts as another session's. It never enrolls or replaces a
+  slot another session holds, and waits while other work runs. Both kits (`fabric_board_slots.py`,
+  `fabric_board_session.py` and their Node twins). The `board.slot.moved` notice and references/board.md say so (FAA-165).
+- `pack`, `sign` and `verify` refused a provider manifest whose `costPresets` differ from the package's with only
+  `provider-manifest` as the message; the message now names both causes (the `problem` code is unchanged) (not a JSON object, or `costPresets` that differ). Both kits (FAA-193, found by the
+  FAA-124 pilot rehearsal). Python no longer refuses an empty provider manifest (`{}`), as Node never did (FAA-194 (1)).
+- Python's `pack`, `sign` and `verify` took `NaN`, `Infinity` and `-Infinity` in a plugin or provider manifest, a key file
+  or a trust file, which `JSON.parse` and the contract refuse, so a package the Node kit refused could pass Python's
+  `verify`. Python refuses them now too (older than 0.60.0, since 0.31.0; found by the 0.60.0 seam reading 11).
+
+### Changed
+
+- working-with-fabric Step 6 reads `fabric_task_create`'s answer as Step 4 item 2 does: while your single live claim is held, Fabric
+  0.3.14 links what is filed as spawned from it, so an unrelated row is filed after the release, or the person is told
+  it is linked (FAA-169). A scenario eval `a-backlog-row-filed-while-a-claim-is-held`.
+- working-with-fabric references/project-board.md, "When nobody answers": an `active` responder does not prove a request
+  is worked; one the old holder accepted before its slot moved stays `accepted` with nobody on it, and a requester
+  cannot see that (`com.get` shows no attempt), so it asks on the thread; with no answer it cancels the request while
+  its `effect` is `not_started` and goes on only once the cancel's receipt shows `cancelled`. An accepted request is
+  never adapted by hand and never expires (FAA-172; question to Fabric and the contract on board thread `ab12642e`). A
+  scenario eval `an-accepted-request-left-behind-by-a-move`.
+- building-fabric-services SKILL.md: a moved slot stays moved until `take_back` or a move back once Fabric offers one.
+- The reference service's take-back tool now reads "Take back a board slot moved to another session."; a manifest
+  registered before 0.60.0 keeps the old description until it is registered again.
+
+### Upgrading
+
+- No Fabric release offers the operator's move of a slot yet (Fabric 0.3.15 has none): today a moved slot is
+  another session's taking it, and take-back is the way back; the move-back check is ready for when Fabric ships it.
+- A kit service gets the move back once it installs the 0.60.0 kit modules (`fabric_board_slots.py`,
+  `fabric-board-slots.mjs` and their callers). Only the running session finds a move back: a slot moved back to a
+  session that has since ended needs take-back, since the session's end released the slot and the operator cannot move
+  a slot no session holds (a move is possible only once another session holds it). A kit older than 0.60.0 never finds
+  a move back: it needs take-back (any kit from 0.53.0), or, once Fabric offers the move, the 0.60.0 modules and then a move to the new session.
+
+## 0.59.0 (2026-11-03)
+
+Portable from day 0 (FAA-191, RM-36): on top of 0.58.0's source and instance, every new agent gets a data home, a
+data kind and an uptime category, and a new private agent a `LICENSE` naming its copyright holder, from its first commit, and runs the transfer
+audit at every release until the contract's export (CT-194) replaces it.
+
+### Added
+
+- creating-fabric-agents' intake grill asks three more rows: **Does it run around the clock?** (uptime category A, a
+  cloud host from the first release, Heroku unless a reason names another, from the cloud Fabric-server template once
+  its repository exists; or B, a local service only), **Whose data does it keep?** (kind U, data of people outside the
+  owner's team, never in the source, a copy or its tests; or O; in doubt U) and **Who holds the copyright?**
+- Step 2 gives the data a home of its own, `<agent>-data` (a folder beside the checkout or a private repository of
+  that name), and the README names the data kind and the uptime category; an agent someone builds for themselves gets
+  a `LICENSE` naming the holder (all rights reserved unless the owner gives other terms).
+- Step 5: every release runs `fabric_source_check.py check` as the transfer audit, in Git mode on the checkout and
+  with `--every-file` on a clean copy of what Git would commit (building-fabric-services' `references/package.md`).
+  references/source-and-instance.md adds why never the checkout (its ignored configuration and dependency folders
+  `--every-file` reads too), and that a `LICENSE` whose holder is on the owner's list is named in
+  `.fabric-source-ignore`, since authorship travels with the source.
+- references/source-and-instance.md (both skills): *The data home and its kind*; references/where-agents-run.md:
+  *Uptime: A or B* and a checklist line. building-fabric-services' Step 0 answers carry the same (data kind, data
+  home, uptime, holder, the audit per release).
+- Scenario evals `portable-from-day-zero` (creating-fabric-agents) and `new-service-names-data-and-uptime`
+  (building-fabric-services), a trigger, and `test/test_portable_from_day_zero_prose.py` pinning the prose to them.
+
+### Changed
+
+- The eval `own-agent-licence-is-the-owners-choice` expects a `LICENSE` naming the holder; still no AGPL or
+  commercial licence files unasked. The shared operator-channel reference and building-fabric-services say the same
+  for an agent built new, and that the kit files the adapter copies in keep their own licence
+  (`AGPL-3.0-only OR LicenseRef-PassionCode-Commercial`); adapting-projects-to-fabric leaves an existing agent's
+  licence as it is.
+- where-agents-run.md: Heroku is the default host of an A agent unless it runs in the person's or an organization's
+  PassionCode cloud or is sold; an A agent's data lives in a durable store, never the host's own folder (source-and-instance.md's
+  data home says the same for a host that does not keep its disk), and on a host with no Fabric hub it answers only
+  what reaches its own origin.
+- building-fabric-services' gotchas are shorter (the same rules); `test_fabric_kit` runs its by-path load with `-B`.
+
+### Upgrading
+
+- Nothing to change for an existing agent: an adapted project keeps its licence, data and release checks as they
+  are. A new one answers the three grill rows before its first commit.
+
 ## 0.58.0 (2026-11-03)
 
 Portable agents, part 1 (FAA-188, RM-36): an agent keeps its source apart from its instance from its first commit, and

package/README.md

@@ -72,7 +72,7 @@ requests other Projects post to its Project on Fabric's project board uses the b
 (`scripts/fabric_hub.py` and `scripts/fabric_board.py`, Node `fabric-hub.mjs` and `fabric-board.mjs`): the
 `board.respond` grant, enroll, claim, accept the exact digest, complete, a checkpoint before every step, and restarts
 that reconcile or take accepted work back by a transfer, unless the slot was moved to another session (until the
-operator's take-back) (the [board reference](plugins/fabric-agent-adapter/skills/building-fabric-services/references/board.md)):
+operator's take-back, or a move back once Fabric offers one) (the [board reference](plugins/fabric-agent-adapter/skills/building-fabric-services/references/board.md)):
 
 ```bash
 python3 plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/check_service.py example-agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/fabric-agent-adapter",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "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.",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

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

@@ -5,7 +5,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.58.0"
+  version: "0.60.0"
   contract-version: "0.1.0"
   contract-commit: "3830a3353923e20f826d466610e1c479f120bec0"
 ---
@@ -242,7 +242,8 @@ relayed, DEC-0121). An agent with neither stops nor notify events skips this ste
 repository standard (`knowledge/repository-standard.md`) from its first commit: the licence files,
 the README quick start verified with a real client, `AGENTS.md` and `CLAUDE.md`, listed in the
 shared reference above. An agent someone builds for themselves is not a PassionCode.ai repository:
-its licence is its owner's choice and none of those files is required of it.
+its licence is its owner's choice and none of those files is required of it (an agent built new with
+creating-fabric-agents carries a `LICENSE` naming its holder; an existing one keeps what it has).
 
 ## Completion format
 

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

@@ -63,4 +63,7 @@ the project).
 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
 choice, nothing about it is published or listed by the organization, and none of these files is
-required of it, though the verified MCP quick start is still how anyone learns to drive it.
+required of it, except that an agent built new carries a `LICENSE` naming the copyright holder (all rights reserved
+unless the owner gives other terms), as does a new private agent built for a client; files the adapter copies in (the service kit, the dashboard kit) keep their own
+licence, `AGPL-3.0-only OR LicenseRef-PassionCode-Commercial` ([COMMERCIAL-LICENSE.md](https://github.com/passioncode-ai/fabric-agent-adapter/blob/main/COMMERCIAL-LICENSE.md)).
+The verified MCP quick start is still how anyone learns to drive it.

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/source-and-instance.md

@@ -13,6 +13,7 @@ on it.
 ## Contents
 
 - [The layout](#the-layout)
+- [The data home and its kind](#the-data-home-and-its-kind)
 - [The check](#the-check)
 
 ## The layout
@@ -31,7 +32,7 @@ on it.
   (an organization's) is a sibling instance, `<id>.<instance>`, never a folder inside the personal one
   (`references/estate-record.md` of that skill).
 - **Ignore the instance in the source**: `.gitignore` names the real configuration (`config/*.json` with
-  `!config/*.example.json`), an instance folder that sits inside the checkout during development, and what running
+  `!config/*.example.json`), an instance folder an existing project still keeps inside the checkout, and what running
   the agent leaves (`__pycache__/`, `*.pyc`), which the check would otherwise report as binary in Git mode.
 - **State documents are instance data.** A handoff, a decision log or a backlog about this codebase is source
   documentation; a record of what this installation did (runs, conversations, the owner's notes, a journal) lives in
@@ -47,6 +48,27 @@ on it.
   keeps the scaffold's sentinel, and a person's name or account is never written there. The adapter moves both when the
   contract decides how an instance renames them (FAA-188 part 2).
 
+## The data home and its kind
+
+- **The data has a home of its own from the first commit: `<agent>-data`.** For an agent that is not a kit service it
+  is a folder beside the checkout, never inside it, and `<AGENT>_DATA_DIR` names it (its default is
+  `../<agent>-data`); a kit service keeps the kit's folders above. When the owner keeps the data in Git, it goes to a
+  separate private repository named `<agent>-data`, never to the source's repository. On a cloud host that does not
+  keep its disk across a restart (Heroku and the like, an uptime A agent's default), the data home is a durable store
+  the same variable names (a database, an object store, that private repository); the folder and the kit's folders
+  serve a machine whose disk persists. A copy of the agent starts with an empty home of its own and never connects
+  to the original's.
+- **The README names the kind of the data.** **U**: the agent keeps data of people outside the owner's team
+  (messages, support requests, reviews, customers' answers); it never enters the source, a copy or its tests, and the
+  source holds only the schema and synthetic fixtures (its real-trace corpus and replay samples live in the data
+  home). **O**: it keeps none (a tool or service for other agents, the
+  owner's reports, runs and media); its working data still goes to the data home. When in doubt, the kind is U.
+- **Every release runs the transfer audit.** `fabric_source_check.py check <project-root>` in Git mode, and
+  `check <clean-copy> --every-file` on a clean copy of what Git would commit (`git ls-files --cached --others
+  --exclude-standard`, as building-fabric-services' `references/package.md` makes it; never the checkout itself, whose ignored
+  configuration and dependency folders `--every-file` reads too), each exit 0, with the owner's list or its absence recorded, until the contract's export (CT-194)
+  replaces it.
+
 ## The check
 
 `fabric_source_check.py check` reads the files the source would carry (what Git would commit: tracked files and
@@ -124,7 +146,10 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/fabric_source_ch
   repository is not read; `--every-file` and a folder outside Git read its files, its `.git` left out. An exception line (`!`) is refused, since what it would
   bring back would go unread. Name the files, or a folder that holds
   only synthetic vectors, never a whole source folder (a nested repository checked in its own tree is the one
-  exception), and say why on the line above. A file `pack` refuses by its name cannot ship in a package: a public
+  exception), and say why on the line above. The `LICENSE` is the other: its copyright line names the holder, which is
+  authorship and travels with the source, so when the holder is on the owner's list the licence file is named in the ignore
+  file by its own path (`LICENSE`, `LICENSE.md`) with that reason (`# the copyright holder is authorship and travels with the source`); no other file of the
+  owner's is. A file `pack` refuses by its name cannot ship in a package: a public
   certificate is renamed `*.crt`; a project `.npmrc` that holds no credential may be named in the ignore file, with
   that reason, for the source check (the line then hides whatever is added to it later, so keep it credential-free),
   and `pack` still refuses it, so a package is made from a copy without it (its

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

@@ -14,7 +14,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.58.0"
+  version: "0.60.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
   extension-commit: "3830a3353923e20f826d466610e1c479f120bec0"
@@ -63,6 +63,7 @@ Answer before writing code, and record the answers in the project README:
 | Port | one number; run the claim check below before choosing it |
 | Who calls it | the named agents or people, and through which surface (Step 1) |
 | What it stores | the store, where it lives (Step 2, rule 5), and what survives uninstall |
+| Data and uptime | kind U or O, kit folders, a durable store or `<id>-data`, uptime A or B; a new agent's `LICENSE` holder, transfer audit per release (creating-fabric-agents) |
 | What it tells the operator | the events worth a notification (Step 5) |
 
 ## Step 1: choose the surfaces
@@ -102,9 +103,9 @@ When the service answers requests other Projects post to its Project on Fabric's
 responder in its own process: [`scripts/fabric_hub.py`](scripts/fabric_hub.py) finds the hub and joins,
 [`scripts/fabric_board.py`](scripts/fabric_board.py) enrolls, claims, accepts the exact digest, checkpoints before
 every step and stops on `fenced`, `lease_expired` or `authority_changed` (Node: `fabric-hub.mjs`, `fabric-board.mjs`).
-The request body is data behind the service's own input gate. From 0.53.0 a slot the operator moved to another
-session stays moved until `take_back` (`takeBack`): give it an operator action with its tool and gate `relayed`, or it
-stays moved for good (the operator reaches it through an agent that relays their decision in `_meta`, the service's
+The request body is data behind the service's own input gate. A slot moved to another
+session stays moved until `take_back` (`takeBack`) or a move back once Fabric offers one: give it an operator action with its tool and gate
+`relayed` (the operator reaches it through an agent that relays their decision in `_meta`, the service's
 page or its elicitation; Claude Code and Codex wait for CT-125's forwarding). Read [the board reference](references/board.md).
 
 ## Step 2: the non-negotiables
@@ -353,9 +354,9 @@ first commit:
 
 Whoever owns the repository, an agent with a page gets the dashboard rule block in its `AGENTS.md`
 (below). 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
-choice, nothing about it is published or listed by the organization, and none of these files is
-required of it, though the verified MCP quick start is still how anyone learns to drive it.
+someone builds for themselves is not a PassionCode.ai repository:** its licence is its owner's choice, the organization
+publishes and lists nothing about it, of these files one built new needs only a `LICENSE` naming its copyright holder (copied kit files keep
+theirs), and the verified MCP quick start teaches anyone to drive it.
 
 ## Online services: the remote placement
 
@@ -418,20 +419,16 @@ this estate needs.
 ## Gotchas
 
 - `lsof` shows `*:<port>` or `0.0.0.0` → the bind is wrong even if the Host check works.
-- A health probe that only checks HTTP 200 accepts any program on the port. Compare
-  `service.id` and `service.instance`: two services here once defaulted to ports
-  another service already held.
-- `launchctl bootstrap` right after `bootout` fails with I/O error 5 until the unload
-  finishes; wait, then retry.
+- A health probe that only checks HTTP 200 accepts any program on the port: compare
+  `service.id` and `service.instance`.
+- `launchctl bootstrap` right after `bootout` fails with I/O error 5: wait for the unload, then retry.
 - Under launchd `PATH` is bare. Pin the interpreter by absolute path; set `PATH`
   explicitly in the plist; never copy the whole shell environment into it.
-- A plist pointing at a worktree or a checkout breaks the day it moves. Point it at a
-  release.
-- `http.server.HTTPServer` asks the resolver for its FQDN between `bind()` and
-  `listen()`. With a slow resolver (a macOS CI runner, a Mac offline) the port is bound
-  but silent: connects time out instead of being refused. Use `fs.LoopbackHTTPServer`.
-- `logging.basicConfig` called twice: the second call is a no-op, so a server's own
-  log file stays empty. Configure logging once, in the entry point.
+- A plist pointing at a worktree or checkout breaks when it moves: point it at a release.
+- `http.server.HTTPServer` resolves its FQDN between `bind()` and `listen()`: with a slow
+  resolver (a macOS CI runner, a Mac offline) the port is bound but silent. Use `fs.LoopbackHTTPServer`.
+- `logging.basicConfig` called twice: the second is a no-op, the server's log file
+  stays empty. Configure logging once, in the entry point.
 - Hand-made `.plist.bak` files in `~/Library/LaunchAgents` are never cleaned up; keep
   backups elsewhere.
 

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

@@ -120,7 +120,7 @@ once the kit reads it (FAA-135).
 |---|---|
 | `fenced` | the attempt is another responder's: stop the handler, drop the entry (nothing outside had begun); accepted work on a slot this responder recorded holding stays as `lapsed`, and the next tick asks `com.status` whether the slot [moved](#when-the-operator-moves-a-slot-to-another-session-faa-155) |
 | `lease_expired` on accepted work | stop the handler; the board holds the request, and the kit takes it back with `com.responder_replace` and a transfer |
-| `authority_changed`, `not_authorized` | stop claiming; one `board.access.needed` event (notify) saying what to ask for |
+| `authority_changed`, `not_authorized` | stop claiming; one `board.access.needed` event (notify) saying what to ask for (except `not_authorized` on the move-back claim of a moved slot, read as another session's slot, [below](#when-the-operator-moves-a-slot-to-another-session-faa-155)) |
 | `fenced` on enroll or claim | another live holder: wait for it to lapse; never replace it on its own initiative. When this responder recorded holding the slot, it first reads `com.status`: a newer generation means the slot [moved](#when-the-operator-moves-a-slot-to-another-session-faa-155), and it is not taken again even after that holder lapses |
 | lost after an effect began | keep the entry as `unknown`; `observe(entry)` is asked to settle it with `com.reconcile` |
 | Fabric down, hub missing | bounded backoff (2 s doubling to 5 minutes, jittered), one `board.down` event, no spinning |
@@ -134,7 +134,7 @@ the target Project's participant reply answered it, DEC-0098 and DEC-0102; not s
 it, but no longer this responder's); `in_progress` and `outcome_unknown` are
 reconciled from what `observe(entry)` answers (observed only; with no observation they stay unknown and notify);
 accepted ones go back to this responder with `com.responder_replace {expectedGeneration, transfer}` (unless the slot
-moved to another session meanwhile: they stay `lapsed` until take-back, [below](#when-the-operator-moves-a-slot-to-another-session-faa-155)), whose receipt's
+moved to another session meanwhile: they stay `lapsed` until take-back or a move back to this session, [below](#when-the-operator-moves-a-slot-to-another-session-faa-155)), whose receipt's
 `transferred` (DEC-0078: `{request, revision, attempt}`) carries the new fence. **A Fabric that does not answer
 `transferred` yet leaves the request held** (`board.request.held`, notify): the kit never claims it back, because the
 contract has no `com.claim` read-back and `com.claim` never moves an accepted request. A known outcome is sent after the
@@ -181,7 +181,7 @@ contract's matrix, held to its vectors (`test/fixtures/contract/comms-hold-vecto
 | Refused `held` | What the kit does |
 |---|---|
 | `com.status` names the slot `held: true` at connect | the slot is not enrolled; it pauses |
-| `com.enroll`, `com.claim`, `com.responder_replace` | the slot pauses: asked again after 15 s, then 30 s, doubling to 15 minutes; one `board.slot.held` event per capability, and `board.slot.released` when an enroll succeeds again |
+| `com.enroll`, `com.claim`, `com.responder_replace` | the slot pauses: asked again after 15 s, then 30 s, doubling to 15 minutes; one `board.slot.held` event per capability, and `board.slot.released` when an enroll succeeds again (except the move-back claim of a moved slot, which asks again at the next renewal with no `board.slot.held`, [below](#when-the-operator-moves-a-slot-to-another-session-faa-155)) |
 | `com.accept` (the hold came after the claim) | nothing was done: the entry is dropped, the claim lapses and the request waits on the board (`board.request.waiting`); the slot pauses |
 | `com.effect_begin` | the effect has not begun: the handler waits (same idempotency key, the pause doubling) while the tick keeps renewing the lease, then begins once the hold is lifted; `ctx.stopped` ends the wait |
 | accepted work at restart under a hold | kept as `lapsed`, then taken back with `com.responder_replace` and a transfer once the hold is lifted, never claimed back |
@@ -194,7 +194,7 @@ whose responder was gone. Read it as the owner's attestation, not the responder'
 
 ## When the operator moves a slot to another session (FAA-155)
 
-The contract's DEC-0140 PR-2 (proposed, after this kit's pin; Fabric plans it for 0.3.15) lets the operator move a
+The contract's DEC-0140 PR-2 (accepted 2026-10-30, after this kit's pin) lets the operator move a
 (Project, capability) slot to another live session of the Project: one transition, as `com.responder_replace` would make
 it for the receiving session (generation up, `claimed` back to `queued`, `in_progress` to `outcome_unknown`, `accepted`
 held and not transferred). The responder keeps that move instead of undoing it:
@@ -228,17 +228,18 @@ held and not transferred). The responder keeps that move instead of undoing it:
   this service left unanswered, is a move, whatever made it: the operator, or another session that took the slot while
   this one was away or after it crashed. Before 0.53.0 a restarted responder took such a slot back by itself. So a
   second responder of the same capability is no longer a standby once the slot changed hands: after any change of
-  holder it waits for take-back, not for the other's lapse.
+  holder it waits for take-back or a move back to its session, not for the other's lapse.
 - A `fenced` refusal on accepted work while the slot did not move (the generation unchanged) keeps the entry
   `lapsed`; the next tick takes it back with a transfer and goes on (before 0.53.0 the entry was dropped and the
   request left accepted on the board).
 - Then the slot is `moved`: the running handler is told to stop (`ctx.stopped`); a `claimed` entry is dropped (the move
   returned it to the queue); accepted work stays as `lapsed` and work whose effect began as `unknown` (only the slot's
-  holder, or the estate owner, reconciles it now). No `com.claim`, `com.renew`, `com.complete`, `com.enroll` or
-  `com.responder_replace` is sent for that capability again: not at recovery after a restart, and not when the new
+  holder, or the estate owner, reconciles it now). While the slot is moved nothing but the move-back check
+  (`com.status` once a renewal, then one `com.claim`, below) is sent for that capability: no `com.renew`,
+  `com.complete`, `com.enroll` or `com.responder_replace`, not at recovery after a restart, and not when the new
   holder's lease lapses, nor when com.status later names no generation for the slot (a recorded move stays until
-  take-back). Accepted requests stay `accepted` on the board, unanswered, until the slot is taken back (CT-175
-  will hand them to the new holder). One `board.slot.moved` event (warning, notify) says so, once, also across restarts
+  take-back or a move back). Accepted requests stay `accepted` on the board, unanswered, until the slot is taken back
+  or moved back (CT-175 will hand them to the new holder). One `board.slot.moved` event (warning, notify) says so, once, also across restarts
   (the record keeps `moved`).
 - A responder that never held the slot (a first start: no record, or a record of another Project), or whose record
   equals the current generation, behaves as before: it enrolls, recovers and replaces its own lapsed work. A recorded or
@@ -248,7 +249,29 @@ held and not transferred). The responder keeps that move instead of undoing it:
   records its own generation. Only a replay the board refuses, or one that ran for the first time (`repeated: false`)
   after the slot had moved past the record, reads as a move: the safe side; a slot such a replay took is left to lapse
   unused. A generation written `2.0` is `2`.
-- Only the operator brings the slot back: `take_back(capability)` (`takeBack`) forgets the record, and wins over a move
+- The operator may move the slot back to this session in Fabric (DEC-0140 PR-2), which this client cannot hear. No
+  Fabric release offers the operator's move yet (Fabric 0.3.15 has none: the control is CT-174's in Fabric, its agent twin CT-181 in the contract, then CT-125),
+  so today every move is another session taking the slot and take-back is the route back; the check below is ready
+  for the move. While
+  a slot is moved the responder reads `com.status` once a renewal (20 s) and, when the slot's generation is past the
+  recorded move, sends one `com.claim` under a fresh key, as PR-2's "Learning the slot is its own" says (FAA-165,
+  0.60.0); the move itself drops the claim key of that capability, whose receipt the move made dead. A claim that
+  lands is the slot held again: the record loses `moved`, the request it handed out is worked (with none, its own
+  enroll renews the lease at once), accepted work left `lapsed` comes back with a transfer, and a later move is said
+  again. `lease_expired` (the move reached this session and its lease lapsed first) enrolls again. `held` asks again
+  at the next renewal. `idempotency_window_expired` or `capacity_exceeded` asks again at the next renewal under a
+  fresh key, recording nothing. `fenced`, or any other refusal that is not the board session's (`not_authorized` counted with them, since a
+  non-holder's claim may be refused so), is another session's slot:
+  recorded as `moved` at that generation, so it is not asked about twice. A claim whose answer was lost (`unreachable`) is asked again under the same key at the next renewal, so a claim that
+  landed is not stranded; until then it counts as at most a lease from that key's first send (a fresh key starts
+  its own, and it counts only while more than the 10 s margin of that lease is left, then no more, as a lapsed slot), so a second lost answer keeps
+  the session (finding 38). A replayed receipt from a generation older than `com.status` shows (a move away and back meanwhile) is
+  dead: its key is dropped and a fresh key asks at the next renewal. A take-back drops the capability's claim key too, so a request a move-back claim handed out while the take-back raced
+  it waits for its attempt's lease (60 s) before it is claimed again (a take-back that lands before the move-back check makes its claim key
+  leaves that key to the claim loop, which works the request at once). Nothing is asked while the responder stops. It is never an enroll or a replace on a slot another session holds, and it waits
+  while other work runs: a move back during a job longer than the lease (60 s) may lapse and be lost to another
+  session, after which take-back, or another move back to this session, brings it back.
+- Otherwise only the operator brings the slot back: `take_back(capability)` (`takeBack`) forgets the record, and wins over a move
   being read at the same time: the move is written under the responder's lock (Node: on the fence queue, after any fenced
   call in flight) and only while the record is unchanged (FAA-158). Never edit the
   checkpoint's `slots` record by hand to undo a move. In the same board
@@ -269,9 +292,8 @@ held and not transferred). The responder keeps that move instead of undoing it:
   tool](../SKILL.md), `fabric-actions/0.1`) with gate `relayed` (the operator's decision), never `none`, so a call
   without the operator's relayed decision is refused; on a server that reads mandates (`agent_id`) it also names its effect class, for example
   `change-policy` (DEC-0125); the operator reaches it through an agent that relays their decision in `_meta`, the
-  service's page or its elicitation (Claude Code and Codex, which cannot set `_meta`, wait for CT-125's forwarding), and the service names it in its docs; otherwise a moved slot stays moved. A move back to this service's own session is not
-  detected yet: the receiving side and the hand-over of accepted requests (contract CT-175) wait for Fabric's session
-  surface.
+  service's page or its elicitation (Claude Code and Codex, which cannot set `_meta`, wait for CT-125's forwarding), and the service names it in its docs; otherwise a moved slot stays moved for good today (no Fabric release offers the operator's move back, above). The
+  hand-over of accepted requests to another session (contract CT-175) waits for Fabric's session surface.
 
 ## What a board session may call
 

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

@@ -87,7 +87,7 @@ A module imports only modules listed before it in `kit.json`, so the kit has no
 | 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_slots` | the responder's slot records: the generation held, a move and its take-back, one capability's refusal retried alone (FAA-163) |
+| L4 | `fabric_board_slots` | the responder's slot records: the generation held, a move, its take-back and a move back (FAA-165), one capability's refusal retried alone (FAA-163) |
 | 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)) |

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

@@ -75,9 +75,14 @@ see a swap made and undone between two of those checks. Pack from a folder only
 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`) and `path` (a listed or folder path holding a control character, U+2028 or
+`plugin-manifest`, `provider-manifest`, whose message names its two possible causes: a provider manifest that is not a JSON object,
+or `costPresets` that differ from the package's, FAA-193) 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
+through, FAA-78). `fabric.package.json`, the trust file and a JWK key file take no `NaN` or `Infinity` token (a number too large for a double still reads as an infinity, in both kits as in `JSON.parse`), and the first two are read as strict UTF-8 and nested at most 256 levels; the plugin and
+provider manifests the folder check reads are strict UTF-8 too (the contract's `checkPackageFolder` decodes them with
+replacement characters, so an invalid byte inside a string value the check does not compare is no manifest here and is accepted there, FAA-194 (29)), take no `NaN` or `Infinity` token either, as `JSON.parse` takes none, and have no depth
+limit of their own, as the contract's reference has none (Python 3.9's own recursion limit reads one nested about 990
+levels deep as no manifest, FAA-194 (27)); 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.

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

@@ -88,6 +88,7 @@ export class Responder extends SlotKeeper {
     this.waitUntil = 0;
     this.stopping = false;
     this.claimKeys = {};
+    this.probing = new Set(); // moved slots whose move-back claim lost its answer: asked again under the same key
     this.said = {};
     this.rr = 0;
     this.reconcileAt = 0;
@@ -172,6 +173,7 @@ export class Responder extends SlotKeeper {
     this.state = 'connecting';
     this.slots = {}; // the previous session's slots are not this one's: a refusal now reconnects (FAA-163)
     this.confirmed = {}; // nor its confirmations: a slot may have moved between the two sessions
+    this.probing = new Set(); // nor its lost move-back claims
     const grant = await this.hub.joinBoard(this.project, this.credentialFile);
     const missing = this.capabilities.filter((c) => !grant.capabilities.includes(c));
     const session = this.sessionFactory(grant);
@@ -462,7 +464,9 @@ export class Responder extends SlotKeeper {
   /** Seconds this session's leases still run, by its own clock: the running attempt's, else the oldest held slot's. */
   leaseLeft() {
     const renewed = this.current ? [this.current.renewedAt ?? 0]
-      : Object.values(this.slots).filter((s) => s.state === 'held' && s.renewedAt !== -Infinity).map((s) => s.renewedAt ?? 0); // a lapsed slot holds no lease (FAA-163)
+      : [...Object.values(this.slots).filter((s) => s.state === 'held' && s.renewedAt !== -Infinity).map((s) => s.renewedAt ?? 0), // a lapsed slot holds no lease (FAA-163)
+        ...Object.entries(this.slots).filter(([c, s]) => this.probing.has(c) && 'probeAt' in s && this.now() - s.probeAt < LEASE_SECONDS - LEASE_MARGIN_SECONDS)
+          .map(([, s]) => s.probeAt)]; // a move-back claim whose answer was lost holds one from its send, while more than the 10 s margin of that lease is left (FAA-165)
     return renewed.length && this.session ? Math.min(...renewed) + LEASE_SECONDS - this.now() : 0;
   }
 
@@ -528,7 +532,10 @@ export class Responder extends SlotKeeper {
       this.suspect.delete(capability);
     }
     for (const [capability, slot] of Object.entries(this.slots)) {
-      if (slot.state === 'moved') continue; // never enrolled again on its own, even when the new holder's lease lapses (FAA-155)
+      if (slot.state === 'moved') { // never enrolled again on its own, even when the new holder lapses (FAA-155)
+        if (this.now() - (slot.renewedAt ?? 0) >= RENEW_SECONDS - 0.5) await this.movedBack(capability); // unless com.status shows a later generation it may hold (FAA-165)
+        continue;
+      }
       if (slot.state === 'paused') {
         // still held: a longer pause; lifted: the slot is ours again
         if (capability !== heldByWork && this.now() >= (slot.retryAt ?? 0) && !(await this.gone(capability))) await this.enroll(capability); // a move is read first

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

@@ -16,6 +16,8 @@ export const HOLD_RETRY_MAX_SECONDS = 900;
 export const SESSION_CODES = Object.freeze(new Set(['unreachable', 'session-ended', 'not_authorized', 'authority_changed', 'credential', 'no-epoch',
   'schema-unsupported', 'checkpoint', 'receipt-shape', 'idempotency_conflict', 'not-running', 'not-a-hub', 'hub-unavailable', 'protocol', 'not_available']));
 
+const sameRecord = (a, b) => JSON.stringify(a ?? {}) === JSON.stringify(b ?? {});
+
 /** The slot methods of Responder, which owns every field they read (checkpoint, slots, project, locked). */
 export class SlotKeeper {
   // -- a slot moved to another session (FAA-155, DEC-0140 PR-2) --
@@ -127,13 +129,88 @@ export class SlotKeeper {
     this.toResume = this.toResume.filter((r) => this.checkpoint.entries[r]?.capability !== capability);
     this.slots[capability] = { state: 'moved', generation: now, renewedAt: this.now() };
     delete this.confirmed[capability];
+    delete this.claimKeys[capability]; // the move returned that claim to the queue: its receipt is dead
     if (!('moved' in held)) { // once, even across restarts
-      this.emit('board.slot.moved', 'warning', `The ${capability} slot on this Project moved to another session. This service stopped answering it there and left its accepted work \`accepted\` (work begun is the new holder's to settle). Its take-back action brings the slot back once the other session lets it go, or at a later restart or reconnect while accepted work waits; a restart alone does not. Without it, ask its maintainer.`, { notify: true, episode: capability, capability, generation: now, held: held.generation });
+      this.emit('board.slot.moved', 'warning', `The ${capability} slot on this Project moved to another session. This service stopped answering it; accepted work stays \`accepted\` (work begun is the new holder's). The operator brings it back by take-back (once the other session lets it go, or at a restart with accepted work waiting; a restart alone does not) or, where Fabric offers it, a move back here. Else ask its maintainer.`, { notify: true, episode: capability, capability, generation: now, held: held.generation });
       this.note(capability, { ...held, moved: now }); // said again at the next start if it cannot be written
     }
     return true;
   }
 
+  /**
+   * A moved slot asked about once per later generation (FAA-165): the operator may move it back to this session
+   * (DEC-0140 PR-2), which this client cannot hear, so when com.status shows a generation past the recorded move, one
+   * com.claim asks whether the slot is its own. A claim that lands makes it held again and starts what it handed out; a
+   * lease_expired one (the move reached this session but its lease lapsed) enrolls again; a fenced one is another
+   * session's, recorded so the same generation is not asked about twice. Never an enroll or a replace on a slot another
+   * session holds: a slot moved off stays off unless it is handed back.
+   */
+  async movedBack(capability) {
+    if (this.current || this.stopping) return; // a claim now could hand out a second request, or start work while the responder stops
+    const held = this.checkpoint.slots[capability] ?? {};
+    if (held.project !== this.project || !isInt(held.moved, 1)) return;
+    if (this.slots[capability]) this.slots[capability].renewedAt = this.now();
+    const now = ((await this.status()).responders ?? []).find((r) => isObj(r) && r.capability === capability)?.generation;
+    if (!isInt(now, 1) || now <= held.moved) return;
+    if (!this.probing.has(capability) || !this.claimKeys[capability]) { // a fresh key: one from before the move may hold a dead receipt
+      this.claimKeys[capability] = this.key('claim');
+      if (this.slots[capability]) delete this.slots[capability].probeAt; // and a send time of its own
+    }
+    let answer;
+    const sent = this.now();
+    try {
+      answer = this.receipt('com.claim', await this.call('com.claim', { idempotency: this.idem(this.claimKeys[capability]), capability }));
+    } catch (e) {
+      if (!(e instanceof BoardError)) throw e; // not the board's answer
+      if (e.code === 'unreachable') { // the claim may have landed: asked again under this key, never left to the fault
+        this.probing.add(capability);
+        if (this.slots[capability] && !('probeAt' in this.slots[capability])) this.slots[capability].probeAt = sent; // its lease runs from the first send
+        return;
+      }
+      this.probing.delete(capability);
+      if (e.code === 'held') return; // the operator's hold: asked again at the next renewal
+      if (e.code === 'idempotency_window_expired' || e.code === 'capacity_exceeded') {
+        delete this.claimKeys[capability];
+        return;
+      }
+      if (e.code === 'lease_expired') {
+        delete this.claimKeys[capability]; // a dead attempt's receipt may sit under it
+        if (await this.back(capability, held, now)) {
+          this.slots[capability].renewedAt = -Infinity; // lapsed: the enroll below is recorded first
+          await this.enroll(capability);
+        }
+        return;
+      }
+      if (SESSION_CODES.has(e.code) && e.code !== 'not_authorized') throw e; // the board session's fault, not this slot's
+      // fenced, or another refusal of this claim: not this session's slot at this generation; a takeBack meanwhile wins (FAA-158)
+      await this.locked(() => { if (sameRecord(this.checkpoint.slots[capability], held)) this.note(capability, { ...held, moved: now }); });
+      return;
+    }
+    this.probing.delete(capability);
+    const generation = isObj(answer.attempt) && isInt(answer.attempt.generation, 1) ? answer.attempt.generation : now;
+    if (generation < now) { // a replay from before a later move: dead, asked again fresh
+      delete this.claimKeys[capability];
+      return;
+    }
+    if (!(await this.back(capability, held, generation))) return;
+    if ('request' in answer) {
+      delete this.claimKeys[capability];
+      this.slots[capability].renewedAt = this.now(); // the claim just landed: its lease runs (finding 38)
+      await this.start(capability, answer);
+    } else await this.enroll(capability); // renewed now: whether an empty com.claim renews the lease is not the contract's to say
+  }
+
+  /** The slot is this session's again at `generation`: held, its record rewritten without the move (FAA-165). */
+  back(capability, held, generation) {
+    return this.locked(() => {
+      if (!sameRecord(this.checkpoint.slots[capability], held)) return false; // a takeBack forgot it; its own next tick enrolls
+      this.slots[capability] = { state: 'held', generation, renewedAt: -Infinity }; // no lease yet
+      this.heldAt(capability, generation);
+      delete this.said['board.slot.moved']; // a later move is said again
+      return true;
+    });
+  }
+
   /**
    * The operator's act, never the kit's: forget that a capability's slot moved away. In the same board session the next
    * tick enrolls once the slot is free; a reconnect with held work takes it back at once by a transfer (FAA-155).
@@ -141,6 +218,8 @@ export class SlotKeeper {
   takeBack(capability) {
     if (!this.capabilities.includes(capability)) throw new BoardError('invalid_arguments', `This responder does not answer ${capability}.`);
     this.checkpoint.slot(capability, null);
+    delete this.claimKeys[capability]; // a receipt from before the take-back may be dead
+    this.probing.delete(capability);
     if (this.slots[capability]?.state === 'moved') this.slots[capability] = { state: 'contested', renewedAt: 0 };
     delete this.said['board.slot.moved'];
   }

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

@@ -504,12 +504,17 @@ export function compose(draft, files) {
   return { pkg, notes };
 }
 
+/** What a folder problem means, where its code alone does not say what to change (FAA-193). */
+const FOLDER_MESSAGES = {
+  'provider-manifest': 'provider-manifest: the provider manifest must be a JSON object, and when it carries costPresets fabric.package.json must carry the same costPresets (copy them; pack does not)',
+};
+
 function allProblems(pkg, files) {
   return [
     ...schemaProblems(pkg).map((p) => ({ ...p, rule: 'schema' })),
     ...pathProblems(pkg).map((p) => ({ ...p, rule: 'path' })),
     ...packageFindings(pkg).map((p) => ({ ...p, rule: p.code })),
-    ...checkPackageFolder(pkg, files).map((p) => ({ rule: 'folder', problem: p.problem, instancePath: p.path, message: p.problem })),
+    ...checkPackageFolder(pkg, files).map((p) => ({ rule: 'folder', problem: p.problem, instancePath: p.path, message: FOLDER_MESSAGES[p.problem] ?? p.problem })),
   ];
 }