@passioncode-ai/fabric-agent-adapter 0.31.1 → 0.32.1

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## 0.32.1 - 2026-10-14
+
+The `building-fabric-services` lifecycle reference is now the rule its readers follow (release iteration 1, N-12;
+operator decision O6). It used to link the organization's private lifecycle contract and say "the contract wins and
+this page is the defect", which left a public reader with a rule they could not open.
+
+### Changed
+
+- **`references/lifecycle.md` is normative.** A new *The rules* section states the lifecycle itself: the supervisor
+  owns the process (never kill a service; start, stop and restart only through launchd, systemd, the Task Scheduler
+  or the node; state is read from the supervisor; restart no sooner than 10 s; off stays off), the descriptor, and
+  readiness through the well-known document. A table states each lifecycle rule the kits serve (LC-01, -02, -03, -04,
+  -05, -09, -11, -12, -14, -15, -21, -22) in one sentence, with the section and the kit function that serve it. It
+  links only public sources: the Fabric Agent Contract's service specification, *Lifecycle*. The `LC-` ids remain
+  for provenance.
+- **`working-with-fabric` `references/project-board.md`** no longer says the private page "wins": it is the rule a
+  coding agent with this plugin follows, and cites the knowledge base for provenance.
+- The two kits' lifecycle comments (`fabric_service.py`, `fabric-service.mjs`) point at the reference and the
+  public specification instead of the private page.
+
+### Added
+
+- **`test/validate.py` refuses a skill page that defers to a private source**: a paragraph that names
+  `fabric-workspace` and says it "wins", "takes precedence", "prevails" or "is authoritative", or that this page "is
+  the defect". The validator's self-test plants one; `test/test_validate.py` covers the cases.
+
+## 0.32.0 - 2026-10-14
+
+The adapter is pinned at contract `1636fa9`. The board kits now read the operator's hold (DEC-0079) and the owner's
+settlement (DEC-0081) (FAA-42, contract CT-42). Before this, a Fabric serving either decision would have broken a
+responder at this pin:
+- a `held` refusal was read as a malformed answer, and the responder blocked;
+- a receipt carrying `settledBy`, a directory page carrying `held`, and a held refusal were all refused as shapes the
+  contract does not name.
+
+### Changed
+
+- **Repin** from `f00a768` to `1636fa9`. Every vendored vector is byte-identical except `comms-vectors.json`, which
+  gains 59 comms fixtures and one digest. `f00a768` stays a supported revision.
+
+### Added
+
+- **`held` (DEC-0079)** in `fabric_board.py` / `fabric-board.mjs`:
+  - `held` is a known refusal code and must be `retryable: true`.
+  - A slot that `com.status` names `held`, or whose `com.enroll`, `com.claim` or `com.responder_replace` is refused
+    `held`, pauses. It is asked again after 15 s, the wait doubling up to 15 minutes. One `board.slot.held` event per
+    capability is emitted, then `board.slot.released`; no `board.down`.
+  - Accepted work continues: `com.renew`, `com.progress` and `com.complete` are never held.
+  - `com.effect_begin` refused `held` waits and asks again with the same key. Nothing outside the service starts until
+    it is answered.
+  - A hold between the claim and the accept does nothing; the request waits on the board.
+  - Accepted work found at restart under a hold is kept for a transfer once the hold is lifted.
+  - `hold_refuses` / `holdRefuses`: the contract's matrix, held to its 114 cases (`comms-hold-vectors.json`, vendored
+    and re-answered by the contract's own function).
+- **`settledBy: "owner"` (DEC-0081)** read on a receipt's request (only `completed` or `failed_known`), and **`held`**
+  read on a directory page's capability and on `com.status` responders.
+- **Docs:**
+  - `references/board.md`: "When the operator holds work".
+  - `working-with-fabric`'s `references/project-board.md`:
+    - `held` means wait and retry with the same key, never route around the hold;
+    - a structured finding (DEC-0080), sent only where `com.submit` takes `finding`, with an idempotency key of at
+      least 128 random bits and `repeated: true` read as the standing finding;
+    - `settledBy` read as the owner's attestation.
+
+### Evidence
+
+- Two scenario evals (`board-responder-held`, `board-held-and-finding`) were written before the prose.
+- The fake board models holds from its own records.
+- 13 Python hold cases (`HoldShapeTests`, `HoldTests`, two in `RestartTests`) and 5 Node ones (`test/fabric-board.test.mjs`, the cases after "DEC-0079 and DEC-0081").
+- 30 planted defects (16 Python, 14 Node) were all caught, two of them only after a case was added for them.
+
 ## 0.31.1 - 2026-10-14
 
 ### Fixed

package/README.md

@@ -251,7 +251,7 @@ Scaffolding is non-destructive by default. It writes only the paths declared in
 The default pin for new bundles is [`fabric-contract.lock.json`](fabric-contract.lock.json):
 
 - version: `0.1.0`
-- commit: `f00a7685e3861c27f7899c033fb850a145a1708f`
+- commit: `1636fa97262f4a26e2086572d540c2ee701e0010`
 
 Every other mention of the default contract revision — this section, the skills' metadata, the
 skill card, `adapt_project.py` — must equal it; `python3 test/validate.py` fails a tree

package/package.json

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

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

@@ -5,9 +5,9 @@ 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.31.1"
+  version: "0.32.1"
   contract-version: "0.1.0"
-  contract-commit: "f00a7685e3861c27f7899c033fb850a145a1708f"
+  contract-commit: "1636fa97262f4a26e2086572d540c2ee701e0010"
 ---
 
 # Adapting projects to Fabric
@@ -70,7 +70,7 @@ Use exactly:
 
 - contract version `0.1.0`;
 - repository `https://github.com/passioncode-ai/fabric-agent-contract`;
-- commit `f00a7685e3861c27f7899c033fb850a145a1708f`.
+- commit `1636fa97262f4a26e2086572d540c2ee701e0010`.
 
 This is the default for new bundles. When checking an issued legacy bundle, preserve its
 explicit supported lock and use that exact clean checkout. Never silently upgrade or

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

@@ -21,10 +21,10 @@ import fabric_secrets as _secrets  # noqa: E402 - the contract's credential dete
 
 CONTRACT_VERSION = "0.1.0"
 CONTRACT_REPOSITORY = "https://github.com/passioncode-ai/fabric-agent-contract"
-CONTRACT_COMMIT = "f00a7685e3861c27f7899c033fb850a145a1708f"
+CONTRACT_COMMIT = "1636fa97262f4a26e2086572d540c2ee701e0010"
 # #region supported-contract-revisions — docs: README.md#contract-pin
 # Only this declaration may name a legacy revision in live files.
-SUPPORTED_CONTRACT_COMMITS = (CONTRACT_COMMIT, "a046f57cf46ea9e3da57ff8ce6a3ed4d26d8774b", "fe55fc67cba1a9e34a736da7d148d4fe2a8fbfa0", "b291bf09e0a9f9fd3c16cf540832cd021203b7d1", "0cacd08b0e95b6abf131eae1206b60792138bc3c", "2eb91c00e852d9c31d804310d38fad91589fcbac", "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5", "a83bec6b47776af688402c18efec507143061f68", "52da526d7cc1e063d74c5b520dbc03d0ace15246", "78b2da018d2c4bd9ac1bde1dc3b7f1a110a175f5", "623bf61358c339cb10297807b3f024b5d9f1f327", "23f9fda4c05f8a3852246ee98d4f2adf74ed0875", "9091d3d6606b0c4b5591a38c3674356a01fd7f55", "df55c8c54a23251342a7ee57ba95642b7eb39e61", "2ce392291c6668598d12cd38327e24696b5ca15c")
+SUPPORTED_CONTRACT_COMMITS = (CONTRACT_COMMIT, "f00a7685e3861c27f7899c033fb850a145a1708f", "a046f57cf46ea9e3da57ff8ce6a3ed4d26d8774b", "fe55fc67cba1a9e34a736da7d148d4fe2a8fbfa0", "b291bf09e0a9f9fd3c16cf540832cd021203b7d1", "0cacd08b0e95b6abf131eae1206b60792138bc3c", "2eb91c00e852d9c31d804310d38fad91589fcbac", "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5", "a83bec6b47776af688402c18efec507143061f68", "52da526d7cc1e063d74c5b520dbc03d0ace15246", "78b2da018d2c4bd9ac1bde1dc3b7f1a110a175f5", "623bf61358c339cb10297807b3f024b5d9f1f327", "23f9fda4c05f8a3852246ee98d4f2adf74ed0875", "9091d3d6606b0c4b5591a38c3674356a01fd7f55", "df55c8c54a23251342a7ee57ba95642b7eb39e61", "2ce392291c6668598d12cd38327e24696b5ca15c")
 # #endregion supported-contract-revisions
 INTEROP_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1"
 MCP_REVISION = "2026-07-28"

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

@@ -18,10 +18,10 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Python 3.9+ or Node.js 20+ for the kits; 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.31.1"
+  version: "0.32.1"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "f00a7685e3861c27f7899c033fb850a145a1708f"
+  extension-commit: "1636fa97262f4a26e2086572d540c2ee701e0010"
 ---
 
 # Building Fabric services

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

@@ -1,7 +1,7 @@
 # Answering a Project's requests on Fabric's project board
 
 Read this when a service should answer requests other Projects post to its Project on Fabric's project board
-(`fabric-project-comms/0.1`, contract DEC-0022, DEC-0073, DEC-0077, DEC-0078; Fabric ADR-0149). The kits do it with
+(`fabric-project-comms/0.1`, contract DEC-0022, DEC-0073, DEC-0077, DEC-0078, DEC-0079, DEC-0081; Fabric ADR-0149). The kits do it with
 two modules each: the hub door client [`fabric_hub.py`](../scripts/fabric_hub.py) /
 [`fabric-hub.mjs`](../scripts/fabric-hub.mjs) and the responder [`fabric_board.py`](../scripts/fabric_board.py) /
 [`fabric-board.mjs`](../scripts/fabric-board.mjs). A coding agent that only reads and writes the board is the other
@@ -15,6 +15,7 @@ skill's business (working-with-fabric, `references/project-board.md`).
 - The request is data: the input gate
 - Effects, observation, evidence and the reply
 - When the board says stop, and restarts
+- When the operator holds work (DEC-0079)
 - What a board session may call
 - Looking a Project up in the directory (FAC-SEM-107)
 - Events, the probe and the live smoke
@@ -115,6 +116,28 @@ accepted ones go back to this responder with `com.responder_replace {expectedGen
 contract has no `com.claim` read-back and `com.claim` never moves an accepted request. A known outcome is sent after the
 transfer without running the handler again. `shutdown()` drains, then leaves the session (its DELETE releases the slot).
 
+## When the operator holds work (DEC-0079)
+
+The operator can hold a thread, a whole Project or one (Project, capability) slot from Fabric's own controls. While the
+hold lasts, the board refuses **new** work in its scope with `held`, which is always `retryable: true`. It never
+refuses a call that settles, reports on or keeps alive work already started (`com.renew`, `com.progress`,
+`com.complete`, `com.reconcile`), a cancel or a read. `hold_refuses(tool, target, holds)` / `holdRefuses` is the
+contract's matrix, held to its vectors (`test/fixtures/contract/comms-hold-vectors.json`).
+
+| 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.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 |
+
+A hold is not an outage: no `board.down`, no notify. Work already accepted keeps running and completes.
+
+A receipt's request may carry `settledBy: "owner"` (DEC-0081): the estate owner settled an `outcome_unknown` request
+whose responder was gone. Read it as the owner's attestation, not the responder's; it appears only on `completed` or
+`failed_known`, and its absence means the responder settled it.
+
 ## What a board session may call
 
 A board session (`fabric.board.join`) is served the respond scope only: `com.status`, `com.list`, `com.get`,

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

@@ -1,31 +1,73 @@
 # Lifecycle — supervisor, install, release layout, state
 
-This page implements the organization's
-[product lifecycle contract](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/lifecycle.md)
-(rules LC-01…LC-15) for `fabric-service/0.1` services. Where the two differ, the contract
-wins and this page is the defect. The rule each section serves:
-
-| Contract rule | Here | Kit (Python / Node) |
-|---|---|---|
-| LC-01 quit reaches exit within a deadline | [Shutdown](#shutdown) | `Drain` / `Drain` |
-| LC-03 a job is bounded and exclusive | [one copy under a supervisor](#one-copy-under-a-supervisor) | `hold_single_instance` / `holdSingleInstance` |
-| LC-09 the footprint is declared | the descriptor and the plist, unit or task; the service's own `AGENTS.md` names its label (unit, task) and port | `write_descriptor`, `launchd_plist`, `systemd_unit` / `systemdUnit`, `task_xml` / `taskXml` |
-| LC-11 previous release kept, older pruned | [Install, upgrade, uninstall](#install-upgrade-uninstall) | `prune_releases` / `pruneReleases` |
-| LC-12 every file is bounded | [Logs](#logs) | `RotatingLog`, `cap_stdout_log` / `RotatingLog`, `capStdoutLog` |
-| LC-14 operator intent wins; uninstall is symmetric | [Install, upgrade, uninstall](#install-upgrade-uninstall), [Linux and Windows](#linux-and-windows) | `launchd_install` / `launchdInstall`, `launchd_uninstall` / `launchdUninstall`; `systemd_install` / `systemdInstall`, `task_install` / `taskInstall` and their uninstalls |
-| LC-15 builds clean up after themselves | release pruning runs inside the installer, not later | `prune_releases` / `pruneReleases` |
+**This page is the rule** for anyone who builds, installs or runs a `fabric-service/0.1` service with this
+skill. Everything you must follow is stated here or in the public Fabric Agent Contract's
+[service specification, *Lifecycle*](https://github.com/passioncode-ai/fabric-agent-contract/blob/main/docs/specification/service.md#lifecycle), which this page
+implements and links; where the two disagree, the specification is right and this page is the defect (report it in
+this repository). Inside
+PassionCode.ai the same rules make up the organization's product lifecycle contract, kept in its knowledge base. The
+`LC-` ids below are that contract's, given for provenance only: nothing behind them is needed to follow this page.
 
 ## Contents
 
-- [launchd plist](#launchd-plist-generate-it-with-launchd_plist)
+- [The rules](#the-rules)
+- [launchd plist](#launchd-plist-generate-it-with-launchd_plist-or-launchdplist-both-kits-write-the-same-bytes)
 - [Install, upgrade, uninstall](#install-upgrade-uninstall)
 - [One copy under a supervisor](#one-copy-under-a-supervisor)
+- [An app's own descriptor and the node](#an-apps-own-descriptor-and-the-node)
 - [Directories](#directories)
 - [Logs](#logs)
 - [Shutdown](#shutdown)
 - [Being managed by a host lifecycle broker](#being-managed-by-a-host-lifecycle-broker)
 - [Linux and Windows](#linux-and-windows)
 
+## The rules
+
+**The supervisor owns the process.** A local service runs under exactly one supervisor, named in its descriptor's
+`lifecycle.manager`: `launchd` (macOS), `systemd` (Linux), `task-scheduler` (Windows) or `node` (Project
+Observatory's node supervising its children). An app a person starts says `person` and has no supervisor; where a host
+runs a lifecycle broker, the broker is the one that quits it ([below](#being-managed-by-a-host-lifecycle-broker)).
+Starting, stopping and restarting go through the supervisor and nothing else:
+
+- **Never kill a service.** A host, an agent, an installer or the service's own CLI never starts a service process
+  directly and never kills or signals one. It asks the supervisor: on macOS `bootout` + `disable` to stop and keep
+  off, `enable` + `bootstrap` to start, `kickstart -k` to restart; [Linux and Windows](#linux-and-windows) have
+  their own verbs; a node's child is started, stopped and restarted only through the node.
+- **State comes from the supervisor**: `launchctl print`, `systemctl --user show`, the task's state and last run,
+  or the node's record. Compare the supervisor's pid with the well-known `process.pid` to see a second copy.
+- **Restart is the supervisor's.** A service that exits is started again, no sooner than 10 s after its last start
+  (`KeepAlive` with `ThrottleInterval` 10, `Restart=always` with `RestartSec=10`, the node likewise; a scheduled task
+  restarts on failure every minute). A restart onto new code shows as a new `service.build`.
+- **Off stays off.** The operator's off survives a login, an upgrade and a reinstall (LC-14).
+
+**The descriptor is the installation.** The installer writes one descriptor per instance (`<id>.<instance>.json`,
+atomic, mode 0600) and the uninstaller removes it; a running service never writes its own, except an app
+([below](#an-apps-own-descriptor-and-the-node)). It names the supervisor and its file (`label` and `plist`, `unit`,
+or `task`; none for `node` and `person`), the `origin` `http://127.0.0.1:<port>` (a port is a claim: an installer
+refuses a port another instance declares), the service's directories, and commands as argument arrays that never
+carry a credential. Only `doctor` and `update` are commands a host may run.
+
+**Started is not ready.** Readiness is the well-known document, `GET /.well-known/fabric-service`: answered without
+authentication, from memory, in under 100 ms, with `service.id` and `service.instance` equal to the descriptor's.
+`status` is `starting`, `ready`, `degraded` or `stopping`; `degraded` is always present, and an empty list asserts
+full health. A process that cannot serve does not answer, and a host derives `down`. An install or upgrade polls
+that document until `service.id` matches (at most 40 s) before it calls the service started.
+
+| Id | Rule | Here | Kit (Python / Node) |
+|---|---|---|---|
+| LC-01 | **Quit reaches exit within a deadline.** Every trigger (`SIGTERM`, `SIGINT`, logout, the app's own quit) ends the process: within 5 s idle, within 10 s with work in flight, then a hard exit. Nothing starts after quit begins | [Shutdown](#shutdown) | `Drain` / `Drain` |
+| LC-02 | **Every child has an owner, a deadline and a process group.** No subprocess without a timeout; on timeout or the parent's exit the whole group goes; no orphan survives. Locks and shared resources are released in `finally` | your own code | — |
+| LC-03 | **A job is bounded and exclusive.** One copy holds `service.lock`; a scheduled job has a watchdog shorter than its interval, shares its lock with every manual entry point, bounds every network call and records each run's outcome. Long work is journalled before it starts | [One copy under a supervisor](#one-copy-under-a-supervisor) | `hold_single_instance` / `holdSingleInstance` |
+| LC-04 | **Credentials are silent after setup.** No background prompt; a credential read that is denied or absent is cached and backs off until a person acts | [Directories](#directories) (secret files 0600) | — |
+| LC-05 | **Identity is stable across updates.** The supervisor runs a stable executable inside a release directory, never an interpreter by a versioned package-manager path; signed builds are pinned by team and identifier | [launchd plist](#launchd-plist-generate-it-with-launchd_plist-or-launchdplist-both-kits-write-the-same-bytes) | — |
+| LC-09 | **The footprint is declared.** The service's `AGENTS.md` names every resident process, its supervisor label, unit or task and its port, who starts each and who stops it | the descriptor and the supervisor file | `write_descriptor`, `launchd_plist`, `systemd_unit` / `systemdUnit`, `task_xml` / `taskXml` |
+| LC-11 | **An update is a lifecycle event.** An upgrade writes a new immutable release and restarts through the supervisor; the previous release is kept for rollback, older ones are pruned | [Install, upgrade, uninstall](#install-upgrade-uninstall) | `prune_releases` / `pruneReleases` |
+| LC-12 | **Every file is bounded.** Logs rotate by size (5 × 5 MB), mode 0600, never in `/tmp`; temporary leftovers are swept at start | [Logs](#logs) | `RotatingLog`, `cap_stdout_log` / `RotatingLog`, `capStdoutLog` |
+| LC-14 | **The operator's intent wins; uninstall is symmetric.** No install or upgrade re-enables what the operator turned off; uninstall removes what install added (supervisor file, override, descriptor), and data goes only on an explicit purge | [Install, upgrade, uninstall](#install-upgrade-uninstall), [Linux and Windows](#linux-and-windows) | `launchd_install` / `launchdInstall`, `launchd_uninstall` / `launchdUninstall`; `systemd_install` / `systemdInstall`, `task_install` / `taskInstall` and their uninstalls |
+| LC-15 | **Builds clean up after themselves.** At most the current release and the one before it remain; the prune runs inside the installer, not later | [Install, upgrade, uninstall](#install-upgrade-uninstall) | `prune_releases` / `pruneReleases` |
+| LC-21 | **A secret never travels in a command line.** Keys reach the process through its environment, a 0600 file or a vault, never argv; a supervisor file carries no secret | [launchd plist](#launchd-plist-generate-it-with-launchd_plist-or-launchdplist-both-kits-write-the-same-bytes), [Linux and Windows](#linux-and-windows) | the supervisor-file writers refuse a secret-shaped value |
+| LC-22 | **Work survives a restart.** Work started but not finished is journalled on disk, without secrets, before it starts; the restarted service takes it back or cleans it up | [Shutdown](#shutdown) | — (the service's own journal) |
+
 ## launchd plist (generate it with `launchd_plist` or `launchdPlist`; both kits write the same bytes)
 
 | Key | Value | Why |
@@ -168,7 +210,7 @@ has to survive being driven from outside:
 
 - **Quit reaches exit through both doors.** A broker asks the platform's own quit first — on
   macOS `NSRunningApplication.terminate()`, the path Cmd+Q and the Dock take — and `SIGTERM` a few
-  seconds later. Handle both and exit inside the deadline (fabric-workspace LC-01). A desktop app
+  seconds later. Handle both and exit inside the deadline (LC-01). A desktop app
   that answers `SIGTERM` by closing its window and staying alive is stopped late or not at all.
 - **A background launch stays in the background.** A broker opens the app non-activating
   (`NSWorkspace.OpenConfiguration.activates = false`); do not call `app.focus()`, `show()` on a

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

@@ -1,6 +1,6 @@
 # fabric-service/0.1 — wire reference
 
-Pinned to `fabric-agent-contract` commit `f00a7685e3861c27f7899c033fb850a145a1708f`
+Pinned to `fabric-agent-contract` commit `1636fa97262f4a26e2086572d540c2ee701e0010`
 (`docs/specification/service.md`, DEC-0015; the usage report DEC-0021; Windows and Linux supervision
 DEC-0032 and DEC-0033; the operator channel DEC-0034 and DEC-0035; the embedded dashboard DEC-0036;
 delegation and the operator session's lifetime DEC-0039; the meter's call window DEC-0041; session handoff DEC-0042;
@@ -8,7 +8,7 @@ canonical forms DEC-0043; `degraded[].setup` and `run.mcp.stdio.scope` DEC-0044;
 DEC-0045; runner and model profiles DEC-0046; the estate record DEC-0055; one copy under any supervisor and its marker,
 the Windows token-file reader DEC-0057; the hub key the estate certifies DEC-0060; signing credentials DEC-0063; the
 estate record's 60 s skew DEC-0066; an app's own descriptor DEC-0069; the descriptor for listings DEC-0061; identifier equality
-by normal form DEC-0076; the project board's directory page DEC-0077 and a replacement's transferred attempts DEC-0078). The contract's schemas are normative;
+by normal form DEC-0076; the project board's directory page DEC-0077 and a replacement's transferred attempts DEC-0078; an operator's hold DEC-0079, a structured finding DEC-0080 and the owner's settlement DEC-0081). The contract's schemas are normative;
 this page is the working summary. Extension key:
 `https://fabric.passioncode.ai/agent-contract/extensions/service/0.1`.
 

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

@@ -39,11 +39,20 @@ export const RESPOND_TOOLS = Object.freeze(new Set(['com.status', 'com.list', 'c
 export const REFUSAL_CODES = Object.freeze(new Set(['invalid_arguments', 'body_too_large', 'not_authorized', 'authority_changed',
   'unsupported_capability', 'unsupported_operation', 'not_available', 'idempotency_conflict', 'idempotency_window_expired',
   'capacity_exceeded', 'digest_conflict', 'revision_conflict', 'fenced', 'lease_expired', 'invalid_transition', 'reconcile_required',
-  'observation_required', 'cursor_reset_required', 'immutable_participants']));
+  'observation_required', 'cursor_reset_required', 'immutable_participants', 'held']));
 export const STOP_CODES = Object.freeze(new Set(['fenced', 'lease_expired', 'authority_changed']));
 const REQUEST_STATES = ['queued', 'claimed', 'accepted', 'in_progress', 'completed', 'failed_known', 'cancelled', 'expired', 'outcome_unknown'];
 const EFFECT_STATES = ['not_started', 'started', 'succeeded_observed', 'failed_observed', 'unknown'];
 const TERMINAL = new Set(['completed', 'failed_known', 'cancelled', 'expired']);
+/**
+ * DEC-0079: what an operator's hold may refuse, by the scopes that refuse it. A tool not named here is never refused
+ * `held`: it settles, reports on or keeps alive started work, cancels or reads. The contract's HOLD_SCOPES.
+ */
+export const HOLD_SCOPES = Object.freeze({ 'com.submit': ['thread'], 'com.reply': ['thread'], 'com.enroll': ['project', 'slot'],
+  'com.responder_replace': ['project', 'slot'], 'com.claim': ['thread', 'project', 'slot'], 'com.accept': ['thread', 'project', 'slot'],
+  'com.effect_begin': ['thread', 'project', 'slot'] });
+/** How long a held slot waits before it asks again: doubling from the poll interval, never past this. */
+export const HOLD_RETRY_MAX_SECONDS = 900;
 const OPAQUE = /^[A-Za-z0-9_-]{8,128}$/;
 const PROJECT = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,191}$/;
 const CAPABILITY = /^[a-z][a-z0-9._-]{1,127}$/;
@@ -138,11 +147,16 @@ export function receiptProblems(value, op) {
   if ('request' in value) {
     const r = value.request;
     const keys = ['id', 'state', 'effect', 'revision'];
-    if (closed(r, '/request', keys, keys, problems)) {
+    if (closed(r, '/request', keys, [...keys, 'settledBy'], problems)) {
       if (!str(r.id, OPAQUE)) problems.push('/request/id is a board id');
       if (!REQUEST_STATES.includes(r.state)) problems.push('/request/state is a request state');
       if (!EFFECT_STATES.includes(r.effect)) problems.push('/request/effect is an effect state');
       if (!isInt(r.revision, 1)) problems.push('/request/revision is an integer ≥ 1');
+      if ('settledBy' in r) {
+        // DEC-0081: present only when the estate owner settled it; absent, the responder did.
+        if (r.settledBy !== 'owner') problems.push('/request/settledBy is owner');
+        if (!['completed', 'failed_known'].includes(r.state)) problems.push('/request/settledBy names a settled request (completed or failed_known)');
+      }
     }
   }
   if ('slot' in value) {
@@ -187,6 +201,7 @@ export function refusalProblems(value) {
       if (!REFUSAL_CODES.has(e.code)) problems.push('/error/code is a refusal code the contract names');
       if (typeof e.message !== 'string' || e.message.length < 1 || e.message.length > 300) problems.push('/error/message is 1 to 300 characters');
       if (typeof e.retryable !== 'boolean') problems.push('/error/retryable is a boolean');
+      else if (e.code === 'held' && e.retryable !== true) problems.push('/error/retryable is true for held: the operator lifts a hold (DEC-0079)');
     }
   }
   return problems;
@@ -236,14 +251,40 @@ export function directoryProblems(page) {
     }
     project.capabilities.forEach((entry, c) => {
       const cat = `${at}/capabilities/${c}`;
-      if (!closed(entry, cat, ['capability', 'responder'], ['capability', 'responder'], problems)) return;
+      if (!closed(entry, cat, ['capability', 'responder'], ['capability', 'responder', 'held'], problems)) return;
       if (!str(entry.capability, CAPABILITY)) problems.push(`${cat}/capability is a capability name`);
       if (!['active', 'stale', 'absent'].includes(entry.responder)) problems.push(`${cat}/responder is active, stale or absent`);
+      if ('held' in entry && typeof entry.held !== 'boolean') problems.push(`${cat}/held is a boolean (DEC-0079)`);
     });
   });
   return [...problems, ...directoryFindings(page).map((f) => `${f.instancePath} ${f.message}`)];
 }
 
+/**
+ * DEC-0079, the contract's holdRefuses: true when a board refuses `tool` on `target` with `held` under `holds`. `target`
+ * is what the board resolved ({thread, project, capability, fenced, repeat}); `holds` is {threads, projects, slots:
+ * [{project, capability}]}. Ids compare as written; an inherited or mistyped member counts as absent; never throws.
+ */
+export function holdRefuses(tool, target, holds) {
+  const own = (value, key) => (isObj(value) && Object.hasOwn(value, key) ? value[key] : undefined);
+  const scopes = typeof tool === 'string' && Object.hasOwn(HOLD_SCOPES, tool) ? HOLD_SCOPES[tool] : undefined;
+  if (!scopes || !isObj(target)) return false;
+  if (own(target, 'repeat') === true) return false;
+  if (tool === 'com.reply' && own(target, 'fenced') === true) return false;
+  const text = (v) => (typeof v === 'string' ? v : undefined);
+  const strings = (v) => new Set(Array.isArray(v) ? v.filter((item) => typeof item === 'string') : []);
+  const thread = text(own(target, 'thread'));
+  const project = text(own(target, 'project'));
+  const capability = text(own(target, 'capability'));
+  if (scopes.includes('thread') && thread !== undefined && strings(own(holds, 'threads')).has(thread)) return true;
+  if (scopes.includes('project') && project !== undefined && strings(own(holds, 'projects')).has(project)) return true;
+  const slots = own(holds, 'slots');
+  if (scopes.includes('slot') && project !== undefined && capability !== undefined && Array.isArray(slots)) {
+    return slots.some((slot) => own(slot, 'project') === project && own(slot, 'capability') === capability);
+  }
+  return false;
+}
+
 /** Look a Project up in one com.directory page a Project session read; the page is checked first (FAC-SEM-107). */
 export function findProject(page, projectId, capability) {
   const problems = directoryProblems(page);
@@ -493,6 +534,9 @@ export class Responder {
     this.said = {};
     this.rr = 0;
     this.reconcileAt = 0;
+    /** The first pause under an operator's hold (DEC-0079); it doubles to HOLD_RETRY_MAX_SECONDS. */
+    this.holdDelay = POLL_SECONDS;
+    this.onHold = new Set();
   }
 
   // -- events --
@@ -568,6 +612,10 @@ export class Responder {
     try {
       receipt = this.receipt('com.enroll', await this.call('com.enroll', args));
     } catch (e) {
+      if (e.code === 'held') {
+        this.pause(capability);
+        return;
+      }
       if (e.code === 'fenced') {
         this.slots[capability] = { state: 'contested', renewedAt: this.now() };
         this.emit('board.slot.contested', 'warn', `Another responder holds the ${capability} slot on this Project; this service waits for it to lapse and never takes it over by itself.`, { notify: true, episode: capability, capability });
@@ -577,6 +625,27 @@ export class Responder {
     }
     this.slots[capability] = { state: 'held', generation: receipt.slot.generation, renewedAt: this.now() };
     delete this.said['board.slot.contested'];
+    this.lifted(capability);
+  }
+
+  /**
+   * The operator holds this slot or its Project (DEC-0079): ask again later, the pause doubling each time, and never act
+   * around the hold. Accepted work in progress continues; only new work waits.
+   */
+  pause(capability) {
+    const slot = this.slots[capability] ?? {};
+    const pauses = slot.state === 'paused' ? (slot.pauses ?? 0) + 1 : 1;
+    const wait = Math.min(HOLD_RETRY_MAX_SECONDS, this.holdDelay * 2 ** (pauses - 1));
+    this.slots[capability] = { state: 'paused', pauses, retryAt: this.now() + wait, renewedAt: this.now() };
+    if (!this.onHold.has(capability)) { // once per hold, per capability
+      this.onHold.add(capability);
+      this.emit('board.slot.held', 'info', `The operator holds new work for ${capability} on this Project; the service waits and asks again later. Work already accepted continues.`, { capability });
+    }
+  }
+
+  lifted(capability) {
+    if (!this.onHold.delete(capability)) return;
+    this.emit('board.slot.released', 'info', `The operator's hold on ${capability} was lifted; the service takes new work again.`, { capability });
   }
 
   // -- restart: reconcile and transfer --
@@ -607,9 +676,17 @@ export class Responder {
       else if (state === 'accepted') (transfer[entry.capability] ??= []).push(entry);
       else reconcile.push(entry);
     }
-    const generations = Object.fromEntries((status.responders ?? []).filter(isObj).map((r) => [r.capability, r.generation ?? 0]));
+    const responders = (status.responders ?? []).filter(isObj);
+    const generations = Object.fromEntries(responders.map((r) => [r.capability, r.generation ?? 0]));
+    const onHold = new Set(responders.filter((r) => r.held === true).map((r) => r.capability)); // DEC-0079
     for (const capability of capabilities) {
-      if (transfer[capability]?.length) await this.replace(capability, transfer[capability], generations[capability] ?? 0);
+      if (onHold.has(capability)) {
+        for (const entry of transfer[capability] ?? []) {
+          entry.step = 'lapsed'; // taken back by a transfer once the hold is lifted
+          this.checkpoint.put(entry);
+        }
+        this.pause(capability);
+      } else if (transfer[capability]?.length) await this.replace(capability, transfer[capability], generations[capability] ?? 0);
       else await this.enroll(capability);
     }
     for (const entry of reconcile) if (this.slots[entry.capability]?.state === 'held') await this.reconcile(entry);
@@ -618,8 +695,20 @@ export class Responder {
   async replace(capability, entries, generation) {
     const args = { idempotency: this.idem(this.key('replace')), capability, expectedGeneration: isInt(generation, 0) ? generation : 0,
       transfer: { requests: entries.map((e) => e.request).slice(0, 64), checkpoint: { summary: 'Resumed by the same service after a restart; no effect had begun.' } } };
-    const receipt = this.receipt('com.responder_replace', await this.call('com.responder_replace', args));
+    let receipt;
+    try {
+      receipt = this.receipt('com.responder_replace', await this.call('com.responder_replace', args));
+    } catch (e) {
+      if (e.code !== 'held') throw e;
+      for (const entry of entries) {
+        entry.step = 'lapsed'; // nothing moved: taken back by a transfer once the hold is lifted
+        this.checkpoint.put(entry);
+      }
+      this.pause(capability);
+      return;
+    }
     this.slots[capability] = { state: 'held', generation: receipt.slot.generation, renewedAt: this.now() };
+    this.lifted(capability);
     const moved = new Map((receipt.transferred ?? []).map((item) => [item.request, item]));
     for (const entry of entries) {
       const item = moved.get(entry.request);
@@ -697,6 +786,9 @@ export class Responder {
       this.state = 'not-authorized';
       await this.dropSession();
       this.emit('board.access.needed', 'warn', 'This service may not answer requests for this Project: the operator has to allow it in Fabric (Agents & access). Nothing is claimed until then.', { notify: true, episode: 'access', reason: code });
+    } else if (code === 'held') {
+      this.state = 'paused';
+      this.emit('board.held', 'info', 'The operator holds new work on this Project; the responder waits and asks again with a growing pause.', { episode: 'held', reason: code });
     } else if (['no-epoch', 'schema-unsupported', 'checkpoint', 'receipt-shape'].includes(code)) {
       this.state = 'down';
       await this.dropSession();
@@ -736,6 +828,11 @@ export class Responder {
     }
     const heldByWork = work && this.current ? work.entry.capability : null;
     for (const [capability, slot] of Object.entries(this.slots)) {
+      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.enroll(capability);
+        continue;
+      }
       if (capability !== heldByWork && this.now() - (slot.renewedAt ?? 0) >= RENEW_SECONDS - 0.5) await this.enroll(capability);
     }
     if (!this.current && !this.stopping) await this.continueLapsed();
@@ -790,6 +887,10 @@ export class Responder {
           this.slots[capability] = { state: 'contested', renewedAt: this.now() };
           continue;
         }
+        if (e.code === 'held') {
+          this.pause(capability);
+          continue;
+        }
         throw e;
       }
       if (!('request' in answer)) continue; // nothing claimable; the same key polls again
@@ -843,7 +944,17 @@ export class Responder {
     entry.keys.accept ??= this.key('accept');
     entry.step = 'accepting';
     this.checkpoint.put(entry);
-    const receipt = await this.fenced('com.accept', entry, { fence: this.fence(entry, entry.keys.accept) });
+    let receipt;
+    try {
+      receipt = await this.fenced('com.accept', entry, { fence: this.fence(entry, entry.keys.accept) });
+    } catch (e) {
+      if (e.code !== 'held') throw e;
+      // A hold came between the claim and the accept (DEC-0079): nothing was done, the claim lapses and the request waits.
+      this.checkpoint.drop(entry.request);
+      this.emit('board.request.waiting', 'info', 'A claimed request was not accepted: the operator holds it. Nothing was done; it waits on the board.', { request: entry.request, capability: entry.capability });
+      this.pause(entry.capability);
+      return false;
+    }
     if (!receipt) return false; // the claim was lost before it was accepted; nothing was done
     entry.revision = receipt.request.revision;
     entry.step = 'accepted';
@@ -916,20 +1027,42 @@ export class Responder {
     if (!(await this.fenced('com.progress', entry, args))) throw new Stopped();
   }
 
-  async effectBegin(entry, summary) {
+  async effectBegin(entry, summary, ctx) {
     entry.keys.effect_begin ??= this.key('effect');
     entry.step = 'effect-beginning';
     entry.effect = true; // from here a lost attempt is an unknown outcome, never "nothing happened"
     this.checkpoint.put(entry);
     const args = { fence: this.fence(entry, entry.keys.effect_begin), ...(summary ? { summary: clean(summary) } : {}) };
     let receipt = null;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
+    let lost = 0;
+    let delay = this.holdDelay;
+    for (;;) { // a lost answer: the same key again tells whether it was stored
       try {
         receipt = await this.fenced('com.effect_begin', entry, args);
         break;
       } catch (e) {
-        if (e.code !== 'unreachable' || attempt === 2) throw new Stopped();
-        await new Promise((resolve) => setTimeout(resolve, (attempt + 1) * 1000));
+        if (e.code === 'held') {
+          // The operator holds this work (DEC-0079): the effect has not begun. Wait, keep the lease (the tick renews it;
+          // com.renew is never held), and ask again with the same key.
+          entry.effect = false;
+          entry.step = 'effect-held';
+          this.checkpoint.put(entry);
+          this.emit('board.request.waiting', 'info', 'The operator holds this request before its effect: the service waits and does nothing outside it until the hold is lifted.', { episode: entry.request, request: entry.request, capability: entry.capability });
+          const until = Date.now() + delay * 1000;
+          while (Date.now() < until) {
+            if (ctx?.stopped) throw new Stopped();
+            await new Promise((resolve) => setTimeout(resolve, Math.min(250, Math.max(1, until - Date.now()))));
+          }
+          if (ctx?.stopped) throw new Stopped();
+          delay = Math.min(HOLD_RETRY_MAX_SECONDS, delay * 2);
+          entry.effect = true;
+          entry.step = 'effect-beginning';
+          this.checkpoint.put(entry);
+          continue;
+        }
+        if (e.code !== 'unreachable' || lost === 2) throw new Stopped();
+        lost += 1;
+        await new Promise((resolve) => setTimeout(resolve, lost * 1000));
       }
     }
     if (!receipt) throw new Stopped();

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

@@ -20,7 +20,8 @@ export const DASHBOARD_EXTENSION_KEY = 'https://fabric.passioncode.ai/agent-cont
 export const DASHBOARD_KIT = 'fabric-dashboard-kit@1.1.0';
 export const REFERENCE_THEMES = ['graphite', 'fabric', 'paper', 'forest', 'ocean', 'ember', 'contrast'];
 export const EXIT_ALREADY_RUNNING = 75;
-// Lifecycle contract (fabric-workspace knowledge/lifecycle.md), the same values as fabric_service.py.
+// Lifecycle rules: references/lifecycle.md (the rule for this kit's users; it implements the public
+// contract's service specification, Lifecycle), the same values as fabric_service.py.
 // A launchd-supervised copy that finds the lock held backs off in-process before its exit 75 (LC-03).
 export const SUPERVISOR_ENV = 'FABRIC_SERVICE_SUPERVISOR';
 export const LOCK_WAIT_SUPERVISED_SECONDS = 300;

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

@@ -60,13 +60,21 @@ REFUSAL_CODES = frozenset(["invalid_arguments", "body_too_large", "not_authorize
                            "unsupported_capability", "unsupported_operation", "not_available", "idempotency_conflict",
                            "idempotency_window_expired", "capacity_exceeded", "digest_conflict", "revision_conflict",
                            "fenced", "lease_expired", "invalid_transition", "reconcile_required", "observation_required",
-                           "cursor_reset_required", "immutable_participants"])
+                           "cursor_reset_required", "immutable_participants", "held"])
 #: On these the attempt is no longer ours: stop acting at once (C4).
 STOP_CODES = frozenset(["fenced", "lease_expired", "authority_changed"])
 REQUEST_STATES = ("queued", "claimed", "accepted", "in_progress", "completed", "failed_known", "cancelled", "expired",
                   "outcome_unknown")
 EFFECT_STATES = ("not_started", "started", "succeeded_observed", "failed_observed", "unknown")
 TERMINAL = frozenset(["completed", "failed_known", "cancelled", "expired"])
+#: DEC-0079: what an operator's hold may refuse, by the scopes that refuse it. A tool not named here is never refused
+#: `held` — it settles, reports on or keeps alive started work (com.renew, com.progress, com.complete, com.reconcile),
+#: cancels or reads. The contract's HOLD_SCOPES.
+HOLD_SCOPES = {"com.submit": ("thread",), "com.reply": ("thread",), "com.enroll": ("project", "slot"),
+               "com.responder_replace": ("project", "slot"), "com.claim": ("thread", "project", "slot"),
+               "com.accept": ("thread", "project", "slot"), "com.effect_begin": ("thread", "project", "slot")}
+#: How long a held slot waits before it asks again: doubling from the poll interval, never past this.
+HOLD_RETRY_MAX_SECONDS = 900.0
 
 _OPAQUE = re.compile(r"[A-Za-z0-9_-]{8,128}")
 _PROJECT = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{0,191}")
@@ -188,7 +196,7 @@ def receipt_problems(value: Any, op: Optional[str] = None) -> List[str]:
     if "request" in value:
         r = value["request"]
         keys = ("id", "state", "effect", "revision")
-        if _closed(r, "/request", keys, keys, problems):
+        if _closed(r, "/request", keys, keys + ("settledBy",), problems):
             if not (isinstance(r.get("id"), str) and _OPAQUE.fullmatch(r["id"])):
                 problems.append("/request/id is a board id")
             if r.get("state") not in REQUEST_STATES:
@@ -197,6 +205,12 @@ def receipt_problems(value: Any, op: Optional[str] = None) -> List[str]:
                 problems.append("/request/effect is an effect state")
             if not _is_int(r.get("revision"), 1):
                 problems.append("/request/revision is an integer ≥ 1")
+            if "settledBy" in r:
+                # DEC-0081: present only when the estate owner settled it; absent, the responder did.
+                if r["settledBy"] != "owner":
+                    problems.append("/request/settledBy is owner")
+                if r.get("state") not in ("completed", "failed_known"):
+                    problems.append("/request/settledBy names a settled request (completed or failed_known)")
     if "slot" in value:
         s = value["slot"]
         keys = ("project", "capability", "generation", "leaseExpiresAt")
@@ -248,6 +262,8 @@ def refusal_problems(value: Any) -> List[str]:
                 problems.append("/error/message is 1 to 300 characters")
             if not isinstance(e.get("retryable"), bool):
                 problems.append("/error/retryable is a boolean")
+            elif e.get("code") == "held" and e["retryable"] is not True:
+                problems.append("/error/retryable is true for held: the operator lifts a hold (DEC-0079)")
     return problems
 
 
@@ -312,14 +328,48 @@ def directory_problems(page: Any) -> List[str]:
             continue
         for c, entry in enumerate(caps):
             cat = "%s/capabilities/%d" % (at, c)
-            if _closed(entry, cat, ("capability", "responder"), ("capability", "responder"), problems):
+            if _closed(entry, cat, ("capability", "responder"), ("capability", "responder", "held"), problems):
                 if not (isinstance(entry.get("capability"), str) and _CAPABILITY.fullmatch(entry["capability"])):
                     problems.append("%s/capability is a capability name" % cat)
                 if entry.get("responder") not in ("active", "stale", "absent"):
                     problems.append("%s/responder is active, stale or absent" % cat)
+                if "held" in entry and not isinstance(entry["held"], bool):
+                    problems.append("%s/held is a boolean (DEC-0079)" % cat)
     return problems + ["%s %s" % (f["instancePath"], f["message"]) for f in directory_findings(page)]
 
 
+def hold_refuses(tool: Any, target: Any, holds: Any) -> bool:
+    """DEC-0079, the contract's ``holdRefuses``: True when a board refuses ``tool`` on ``target`` with ``held`` under
+    ``holds``. ``target`` is what the board resolved (``thread``, ``project``, ``capability``, ``fenced``, ``repeat``);
+    ``holds`` is ``{threads, projects, slots: [{project, capability}]}``. Ids compare as written. Malformed input never
+    raises: a member of the wrong type counts as absent, and an unknown tool is never refused ``held``."""
+    scopes = HOLD_SCOPES.get(tool) if isinstance(tool, str) else None
+    if not scopes or not isinstance(target, dict):
+        return False
+    if target.get("repeat") is True:
+        return False
+    if tool == "com.reply" and target.get("fenced") is True:
+        return False
+    holds = holds if isinstance(holds, dict) else {}
+
+    def text(value: Any) -> Optional[str]:
+        return value if isinstance(value, str) else None
+
+    def strings(value: Any) -> set:
+        return {item for item in value if isinstance(item, str)} if isinstance(value, list) else set()
+
+    thread, project, capability = text(target.get("thread")), text(target.get("project")), text(target.get("capability"))
+    if "thread" in scopes and thread is not None and thread in strings(holds.get("threads")):
+        return True
+    if "project" in scopes and project is not None and project in strings(holds.get("projects")):
+        return True
+    slots = holds.get("slots")
+    if "slot" in scopes and project is not None and capability is not None and isinstance(slots, list):
+        return any(isinstance(slot, dict) and slot.get("project") == project and slot.get("capability") == capability
+                   for slot in slots)
+    return False
+
+
 def find_project(page: Any, project_id: str, capability: Optional[str] = None) -> Optional[Dict[str, Any]]:
     """Look a Project up in one `com.directory` page (read by a Project session — a board session is not served the
     directory). The page is checked first: a page the contract would refuse, FAC-SEM-107 included, raises
@@ -630,6 +680,9 @@ class Responder:
         self.claim_keys: Dict[str, str] = {}
         self._said: Dict[str, str] = {}
         self._rr = 0
+        #: The first pause under an operator's hold (DEC-0079); it doubles to HOLD_RETRY_MAX_SECONDS.
+        self.hold_delay = POLL_SECONDS
+        self._on_hold: set = set()
 
     # -- events -------------------------------------------------------------------------------------------------
     def _emit(self, kind: str, level: str, text: str, notify: bool = False, episode: Optional[str] = None, **value: Any) -> None:
@@ -712,6 +765,9 @@ class Responder:
         try:
             receipt = self._receipt("com.enroll", self._call("com.enroll", args))
         except BoardError as exc:
+            if exc.code == "held":
+                self._pause(capability)
+                return
             if exc.code == "fenced":
                 self.slots[capability] = {"state": "contested", "renewed_at": self.now()}
                 self._emit("board.slot.contested", "warn", "Another responder holds the %s slot on this Project; this service "
@@ -721,6 +777,25 @@ class Responder:
             raise
         self.slots[capability] = {"state": "held", "generation": receipt["slot"]["generation"], "renewed_at": self.now()}
         self._said.pop("board.slot.contested", None)
+        self._lifted(capability)
+
+    def _pause(self, capability: str) -> None:
+        """The operator holds this slot or its Project (DEC-0079): ask again later, the pause doubling each time, and
+        never act around the hold. Accepted work in progress continues; only new work waits."""
+        slot = self.slots.get(capability) or {}
+        pauses = slot.get("pauses", 0) + 1 if slot.get("state") == "paused" else 1
+        wait = min(HOLD_RETRY_MAX_SECONDS, self.hold_delay * 2 ** (pauses - 1))
+        self.slots[capability] = {"state": "paused", "pauses": pauses, "retry_at": self.now() + wait, "renewed_at": self.now()}
+        if capability not in self._on_hold:  # once per hold, per capability
+            self._on_hold.add(capability)
+            self._emit("board.slot.held", "info", "The operator holds new work for %s on this Project; the service waits and "
+                       "asks again later. Work already accepted continues." % capability, capability=capability)
+
+    def _lifted(self, capability: str) -> None:
+        if capability in self._on_hold:
+            self._on_hold.discard(capability)
+            self._emit("board.slot.released", "info", "The operator's hold on %s was lifted; the service takes new work "
+                       "again." % capability, capability=capability)
 
     # -- restart: reconcile and transfer -------------------------------------------------------------------------
     def _read_state(self, entry: Dict[str, Any]) -> Optional[str]:
@@ -750,10 +825,17 @@ class Responder:
                 transfer.setdefault(entry["capability"], []).append(entry)
             else:  # in_progress (lost result once a new generation holds the slot) or outcome_unknown
                 reconcile.append(entry)
-        generations = {r.get("capability"): r.get("generation", 0) for r in status.get("responders") or [] if isinstance(r, dict)}
+        responders = [r for r in status.get("responders") or [] if isinstance(r, dict)]
+        generations = {r.get("capability"): r.get("generation", 0) for r in responders}
+        on_hold = {r.get("capability") for r in responders if r.get("held") is True}  # DEC-0079
         for capability in capabilities:
             held = transfer.get(capability)
-            if held:
+            if capability in on_hold:
+                for entry in held or []:
+                    entry["step"] = "lapsed"  # taken back by a transfer once the hold is lifted
+                    self.checkpoint.put(entry)
+                self._pause(capability)
+            elif held:
                 self._replace(capability, held, generations.get(capability, 0))
             else:
                 self._enroll(capability)
@@ -767,8 +849,18 @@ class Responder:
         args = {"idempotency": self._idem(self._key("replace")), "capability": capability, "expectedGeneration": generation,
                 "transfer": {"requests": [e["request"] for e in entries][:64],
                              "checkpoint": {"summary": "Resumed by the same service after a restart; no effect had begun."}}}
-        receipt = self._receipt("com.responder_replace", self._call("com.responder_replace", args))
+        try:
+            receipt = self._receipt("com.responder_replace", self._call("com.responder_replace", args))
+        except BoardError as exc:
+            if exc.code != "held":
+                raise
+            for entry in entries:
+                entry["step"] = "lapsed"  # nothing moved: taken back by a transfer once the hold is lifted
+                self.checkpoint.put(entry)
+            self._pause(capability)
+            return
         self.slots[capability] = {"state": "held", "generation": receipt["slot"]["generation"], "renewed_at": self.now()}
+        self._lifted(capability)
         moved = {item["request"]: item for item in receipt.get("transferred") or []}
         for entry in entries:
             item = moved.get(entry["request"])
@@ -848,6 +940,10 @@ class Responder:
             self._emit("board.access.needed", "warn", "This service may not answer requests for this Project: the operator "
                        "has to allow it in Fabric (Agents & access). Nothing is claimed until then.", notify=True,
                        episode="access", reason=code)
+        elif code == "held":
+            self.state = "paused"
+            self._emit("board.held", "info", "The operator holds new work on this Project; the responder waits and asks again "
+                       "with a growing pause.", episode="held", reason=code)
         elif code in ("no-epoch", "schema-unsupported", "checkpoint", "receipt-shape"):
             self.state = "down"
             self._drop_session()
@@ -887,6 +983,10 @@ class Responder:
                 self._renew(work)
         held_by_work = work.entry["capability"] if work is not None and self.current is not None else None
         for capability, slot in list(self.slots.items()):
+            if slot.get("state") == "paused":
+                if capability != held_by_work and self.now() >= slot.get("retry_at", 0.0):
+                    self._enroll(capability)  # still held: a longer pause; lifted: the slot is ours again
+                continue
             if capability != held_by_work and self.now() - slot.get("renewed_at", 0) >= RENEW_SECONDS - 0.5:
                 self._enroll(capability)  # the holder's enroll renews its lease (no event); a lapsed one re-enrolls
         if self.current is None and not self.stopping:
@@ -937,6 +1037,9 @@ class Responder:
                 if exc.code == "fenced":
                     self.slots[capability] = {"state": "contested", "renewed_at": self.now()}
                     continue
+                if exc.code == "held":
+                    self._pause(capability)
+                    continue
                 raise
             if "request" not in answer:
                 continue  # nothing claimable; the same key polls again
@@ -992,7 +1095,18 @@ class Responder:
         key = entry["keys"].get("accept") or self._key("accept")
         entry["keys"]["accept"], entry["step"] = key, "accepting"
         self.checkpoint.put(entry)
-        receipt = self._fenced("com.accept", entry, {"fence": self._fence(entry, key)})
+        try:
+            receipt = self._fenced("com.accept", entry, {"fence": self._fence(entry, key)})
+        except BoardError as exc:
+            if exc.code != "held":
+                raise
+            # A hold came between the claim and the accept (DEC-0079): nothing was done, the claim lapses and the request
+            # waits on the board for the hold to be lifted.
+            self.checkpoint.drop(entry["request"])
+            self._emit("board.request.waiting", "info", "A claimed request was not accepted: the operator holds it. Nothing "
+                       "was done; it waits on the board.", request=entry["request"], capability=entry["capability"])
+            self._pause(entry["capability"])
+            return False
         if receipt is None:
             return False  # the claim was lost before it was accepted; nothing was done
         entry["revision"], entry["step"] = receipt["request"]["revision"], "accepted"
@@ -1087,14 +1201,30 @@ class Responder:
         if summary:
             args["summary"] = " ".join(str(summary).split())[:SUMMARY_MAX]
         receipt = None
-        for attempt in range(3):  # a lost answer: the same key again tells whether it was stored
+        lost, delay = 0, self.hold_delay
+        while True:  # a lost answer: the same key again tells whether it was stored
             try:
                 receipt = self._fenced("com.effect_begin", entry, args)
                 break
             except BoardError as exc:
-                if exc.code != "unreachable" or attempt == 2:
+                if exc.code == "held":
+                    # The operator holds this work (DEC-0079): the effect has not begun. Wait, keep the lease (the tick
+                    # renews it; com.renew is never held), and ask again with the same key.
+                    entry["effect"], entry["step"] = False, "effect-held"
+                    self.checkpoint.put(entry)
+                    self._emit("board.request.waiting", "info", "The operator holds this request before its effect: the "
+                               "service waits and does nothing outside it until the hold is lifted.", episode=entry["request"],
+                               request=entry["request"], capability=entry["capability"])
+                    if ctx.stopped.wait(delay):
+                        raise Stopped() from None
+                    delay = min(HOLD_RETRY_MAX_SECONDS, delay * 2)
+                    entry["effect"], entry["step"] = True, "effect-beginning"
+                    self.checkpoint.put(entry)
+                    continue
+                if exc.code != "unreachable" or lost == 2:
                     raise Stopped() from None
-                time.sleep(attempt + 1)
+                lost += 1
+                time.sleep(lost)
         if receipt is None:
             raise Stopped()
         entry["revision"], entry["step"] = receipt["request"]["revision"], "in-progress"

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

@@ -49,9 +49,10 @@ DASHBOARD_EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensio
 DASHBOARD_KIT = "fabric-dashboard-kit@1.1.0"
 REFERENCE_THEMES = ("graphite", "fabric", "paper", "forest", "ocean", "ember", "contrast")
 EXIT_ALREADY_RUNNING = 75
-# Lifecycle contract (fabric-workspace knowledge/lifecycle.md). A launchd-supervised copy that finds
-# the lock held backs off in-process for this long before its exit 75 (LC-03, F8): under KeepAlive
-# with ThrottleInterval 10 that is a few starts an hour instead of one every 10 s.
+# Lifecycle rules: references/lifecycle.md, the rule for this kit's users, which implements the public
+# contract's service specification (Lifecycle). A launchd-supervised copy that finds the lock held backs
+# off in-process for this long before its exit 75 (LC-03, F8): under KeepAlive with ThrottleInterval 10
+# that is a few starts an hour instead of one every 10 s.
 SUPERVISOR_ENV = "FABRIC_SERVICE_SUPERVISOR"
 LOCK_WAIT_SUPERVISED_SECONDS = 300.0
 LOCK_BACKOFF_FIRST_SECONDS = 0.5

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/SKILL.md

@@ -5,9 +5,9 @@ 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. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.31.1"
+  version: "0.32.1"
   contract-version: "0.1.0"
-  contract-commit: "f00a7685e3861c27f7899c033fb850a145a1708f"
+  contract-commit: "1636fa97262f4a26e2086572d540c2ee701e0010"
 ---
 
 # Creating Fabric-compatible agents
@@ -123,7 +123,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py
 The effect class is declared, never defaulted: ask the author what the agent does outside itself when the request
 does not say. Cost presets are only for a run whose cost varies; their amounts come from the author or measured runs.
 
-Pin exactly contract `0.1.0` at commit `f00a7685e3861c27f7899c033fb850a145a1708f` and
+Pin exactly contract `0.1.0` at commit `1636fa97262f4a26e2086572d540c2ee701e0010` and
 read the pinned guide before implementing protocol details. If this skill is installed
 without its sibling, the scaffolder is absent: create the bundle by hand from the pinned
 contract's `docs/guides/connecting-compatible-agents.md` and mark the structural check

package/plugins/fabric-agent-adapter/skills/working-with-fabric/SKILL.md

@@ -19,7 +19,7 @@ compatibility: >-
   this plugin; Codex and Kimi Code get the session-start preamble hook on the person's consent.
 metadata:
   author: PassionCode.ai
-  version: "0.31.1"
+  version: "0.32.1"
 ---
 
 # Working with Fabric

package/plugins/fabric-agent-adapter/skills/working-with-fabric/references/project-board.md

@@ -1,9 +1,10 @@
 # The project board (`fabric-project-comms/0.1`, the `com.*` tools)
 
 Read this when the session starts in a project a Fabric hub serves, when the person asks about board mail, when you
-need something from another Project, or when you wait for an answer. The rule itself has one home: PassionCode's
-knowledge base, [agents-first.md, "The project board"](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/agents-first.md#the-project-board).
-This page is how a coding agent with this plugin follows it; where the two differ, that page wins.
+need something from another Project, or when you wait for an answer. This page is the rule a coding agent with this
+plugin follows. Inside PassionCode.ai it implements the knowledge base's
+[agents-first.md, "The project board"](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/agents-first.md#the-project-board)
+(private to the organization), and is kept in step with it; nothing behind that link is needed to follow this page.
 
 ## Contents
 
@@ -46,6 +47,26 @@ capability (a plain question may be `kind: "message"`), in a new thread whose pa
   SendMessage between sessions. agent-sync leases guard files; they carry no asks.
 
 A request the board stored has not been carried out. Only its state (`completed`, `failed_known`) says what happened.
+`settledBy: "owner"` on a request (DEC-0081) means the estate owner settled it after its responder was gone: read it as
+the owner's attestation, not the responder's.
+
+**`held` (DEC-0079).** The operator holds that thread, that Project or that capability, and the board refuses new
+work there with `held`, which is always retryable. Tell the person what is held. Retry later, the pause growing, with
+the **same idempotency key and arguments**. Never post the ask into another thread or to another Project to get around
+the hold. Reads, cancels and replies to work already started are never held.
+
+**A problem for another Project: a structured finding (DEC-0080).** Send one only when the running Fabric's
+`com.submit` input schema lists `finding`; otherwise send a plain message. A finding carries:
+
+- `severity`: `info`, `warning` or `blocking`;
+- `consequence`: one sentence on what it breaks;
+- `affects`: the backlog rows (`{repository, path, id}`) or host tasks it touches;
+- a `dedupeKey` that stays the same for the same problem.
+
+Its idempotency key is at least 128 random bits (for example 32 hex characters from a cryptographic generator), kept
+on every retry. A receipt with `repeated: true` and a fresh key means that finding already stands on the board: its
+thread may not be the one you named, and nothing new was posted. Never put a `{redacted: true}` item into a finding you
+send.
 
 ## The project directory
 

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session.py

@@ -60,7 +60,7 @@ WATCH_MAX_BACKOFF_S = 900
 SESSION_ID = re.compile(r"[A-Za-z0-9._:-]{1,128}")
 LOOPBACK_ORIGIN = re.compile(r"http://127\.0\.0\.1:(\d{1,5})")
 LOCAL_ORIGIN = re.compile(r'"origin": "http://(?:127\.0\.0\.1|localhost)')
-VERSION = "0.31.1"
+VERSION = "0.32.1"
 HOSTS = {"claude": "Claude Code", "codex": "Codex", "kimi": "Kimi Code"}
 # A session Fabric launched. FABRIC_LAUNCHED_SESSION=1 is the marker Fabric is asked to set (need D6); the others are
 # what Fabric already gives a launched session (fabric sessionBundle.ts): only their NAMES are looked at, never a value