@passioncode-ai/fabric-agent-adapter 0.32.0 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # Changelog
 
+## 0.33.0 - 2026-10-15
+
+The adapter is pinned at contract `82e1636`. The estate kits now read contexts (DEC-0082; FAA-41, the RM-28 pilot): one
+agent placed on a machine for the person and for each organization it serves. Before this, at the old pin, a record
+placing one agent in two contexts was refused as a duplicate placement (FAC-SEM-074), and an organization's instance
+was checked against no share grant.
+
+### Changed
+
+- **Repin** from `1636fa9` to `82e1636`. Every vendored vector is byte-identical except `estate-vectors.json`.
+  `1636fa9` stays a supported revision.
+- **Placement and slot keys** in `fabric_estate.py` / `fabric-estate.mjs` carry the context: a placement is keyed by
+  agent and context (FAC-SEM-074), a secret slot by agent, slot and context (FAC-SEM-075). A secret fills a slot of an
+  agent placed in its own context. An absent `context` is `personal`; `null` is not absent.
+- **`placement_trust(record, machine, agentRef, context="personal")`** / `placementTrust(…, context)` answer for the
+  placement in that context. A caller that passes none gets the personal placement, as before.
+- **`estate-placement`** takes `{record, machine, package, context?}` and checks the placement in that context.
+
+### Added
+
+- **FAC-SEM-110**: a share grant (`principalKind: external`) is never in the `personal` context. Checked on each of an
+  estate record's `shareGrants[]`, and on a grant of its own with `grant_context_findings` / `grantContextFindings`.
+- **FAC-SEM-111**: an organization's placement names, in `grant`, a share grant of the record whose `context` is the
+  placement's, as written, and that the record does not revoke; a personal placement names none; a context that is not
+  `org:<orgId>` fails closed. Checked on a record and on an installation.
+- **An organization's slot is filled from its own machine**: an envelope names no context (FAC-SEM-075).
+- **`parse_context` / `parseContext`**: `personal`, `org:<orgId>` (`[A-Za-z0-9][A-Za-z0-9_-]{0,127}`), or nothing,
+  compared as written.
+
+### Fixed
+
+- **Every estate rule is total on hostile JSON**, as the contract's became in DEC-0082's fix rounds: an
+  `instancePath` names an item by its index as written (a non-object before it no longer shifts it), and a value whose
+  own `toString` member is data is shown as its JSON instead of throwing.
+- **A flaky board test** (FAA-43): the hold test of `com.effect_begin` lifted the hold on a 50 ms timer, so a slow runner
+  saw one begin instead of two. The fake board now lifts it right after the first held begin (`lift_holds_after`), in
+  the Python and the Node twin.
+
+### Evidence
+
+- Both kits answer 115 contract rule cases (19 hostile, built by `make_estate_vectors.mjs` from the contexts fixture),
+  28 grant-context cases and 19 `placementTrust` cases.
+- 28 planted defects, 14 per kit, all caught.
+- A new eval scenario, `estate-contexts`.
+## 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

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: `1636fa97262f4a26e2086572d540c2ee701e0010`
+- commit: `82e163665e156a08aa3b92e4711015582c06162c`
 
 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.32.0",
+  "version": "0.33.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.32.0",
+  "version": "0.33.0",
   "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.32.0"
+  version: "0.33.0"
   contract-version: "0.1.0"
-  contract-commit: "1636fa97262f4a26e2086572d540c2ee701e0010"
+  contract-commit: "82e163665e156a08aa3b92e4711015582c06162c"
 ---
 
 # 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 `1636fa97262f4a26e2086572d540c2ee701e0010`.
+- commit `82e163665e156a08aa3b92e4711015582c06162c`.
 
 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 = "1636fa97262f4a26e2086572d540c2ee701e0010"
+CONTRACT_COMMIT = "82e163665e156a08aa3b92e4711015582c06162c"
 # #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, "f00a7685e3861c27f7899c033fb850a145a1708f", "a046f57cf46ea9e3da57ff8ce6a3ed4d26d8774b", "fe55fc67cba1a9e34a736da7d148d4fe2a8fbfa0", "b291bf09e0a9f9fd3c16cf540832cd021203b7d1", "0cacd08b0e95b6abf131eae1206b60792138bc3c", "2eb91c00e852d9c31d804310d38fad91589fcbac", "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5", "a83bec6b47776af688402c18efec507143061f68", "52da526d7cc1e063d74c5b520dbc03d0ace15246", "78b2da018d2c4bd9ac1bde1dc3b7f1a110a175f5", "623bf61358c339cb10297807b3f024b5d9f1f327", "23f9fda4c05f8a3852246ee98d4f2adf74ed0875", "9091d3d6606b0c4b5591a38c3674356a01fd7f55", "df55c8c54a23251342a7ee57ba95642b7eb39e61", "2ce392291c6668598d12cd38327e24696b5ca15c")
+SUPPORTED_CONTRACT_COMMITS = (CONTRACT_COMMIT, "1636fa97262f4a26e2086572d540c2ee701e0010", "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.32.0"
+  version: "0.33.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "1636fa97262f4a26e2086572d540c2ee701e0010"
+  extension-commit: "82e163665e156a08aa3b92e4711015582c06162c"
 ---
 
 # Building Fabric services
@@ -86,7 +86,8 @@ are in [`scripts/fabric_interop.py`](scripts/fabric_interop.py) and
 service checks each call's delegation token (DEC-0039): read [the delegation reference](references/delegation.md);
 the verifier is [`scripts/fabric_delegation.py`](scripts/fabric_delegation.py) /
 [`scripts/fabric-delegation.mjs`](scripts/fabric-delegation.mjs). A service on the operator's machines that
-applies the estate record (DEC-0055) verifies each revision first and trusts only the keys it certifies: read
+applies the estate record (DEC-0055) verifies each revision first and trusts only the keys it certifies, and runs an
+agent once per context, the person's or an organization's (DEC-0082): read
 [the estate record reference](references/estate-record.md). When Fabric chooses the service's runner and models
 (DEC-0046), or a project routes its work through an ordered list of runners (DEC-0026: the doctor's closed probe
 results, the route checks FAC-SEM-028…034), read [the profiles reference](references/profiles.md).

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

@@ -1,10 +1,11 @@
 # The estate record — what the operator's machines are, signed by their passkey (DEC-0055)
 
 Fabric Agent Contract DEC-0055, `docs/specification/estate-record.md`, schema `schemas/estate-record.schema.json`,
-rules `FAC-SEM-072…076`. One revision of one person's estate lists:
+rules `FAC-SEM-072…076`, with contexts (DEC-0082, `docs/specification/contexts.md`, `FAC-SEM-110`, `FAC-SEM-111`).
+One revision of one person's estate lists:
 - the passkeys that sign it;
 - the machines, with their device keys and a certificate of each machine's hub key;
-- the packages placed on each machine;
+- the packages placed on each machine, each in a context: the person's own, or an organization's;
 - where each secret slot is filled from (by reference only);
 - share grants and revocations.
 
@@ -16,6 +17,7 @@ derived from its own digest. Python: [`scripts/fabric_estate.py`](../scripts/fab
 
 - Applying a revision
 - Trusting a delegation key
+- Contexts: one agent for you and for an organization
 - Checking a record you produce
 - What the kit does not do
 
@@ -51,7 +53,8 @@ It checks, in the order of the ER table:
    - The signature: ES256 or EdDSA, under a key validated first (a valid P-256 point; an Ed25519 key of full order).
 7. **The window.** At most 30 days. A revision may be issued up to 60 s ahead of the verifier's clock (DEC-0066,
    `CLOCK_SKEW_SECONDS`); earlier than that it is `not-yet-valid`.
-8. **The record's own rules.** A violation is `rule-violation` with its `codes`, `FAC-SEM-072…076` and `FAC-SEM-092`
+8. **The record's own rules.** A violation is `rule-violation` with its `codes`, `FAC-SEM-072…076`, `FAC-SEM-110`,
+   `FAC-SEM-111` and `FAC-SEM-092`
    (each passkey the record lists is a signing credential, its origins within its RP ID).
 
 Dates are strict RFC 3339: a `T`, an offset, and a day that exists. `:60` and a space are refused. Passkey JWK `x`
@@ -90,14 +93,40 @@ gate = fd.delegation_gate(audience=..., jwks=keys, issuer=..., effects=..., esta
   `{certified: true, machine, revision}` or `{certified: false, fault, detail}`. Both kits are held to the contract's
   `fixtures/vectors/hub-key.json` (`test/fixtures/contract/hub-key-vectors.json`).
 
+## Contexts: one agent for you and for an organization
+
+A placement and a secret placement carry a `context` (DEC-0082): `personal`, or `org:<orgId>` with an organization id
+of `[A-Za-z0-9][A-Za-z0-9_-]{0,127}`. Absent is `personal`; `null` is not absent. A context is compared as written:
+`Personal`, `ORG:x` or a trailing newline names no context. `parse_context(value)` / `parseContext(value)` answer
+`{kind: "personal"}`, `{kind: "org", org}` or nothing.
+
+- **One agent, once per context.** A machine may place the same `agentRef` for the person and for each organization;
+  placements are keyed by agent and context (FAC-SEM-074), and a secret slot by agent, slot and context (FAC-SEM-075).
+  A secret fills a slot of an agent placed on that machine in the secret's own context.
+- **An organization's instance runs under a share grant** (FAC-SEM-111). Its placement names, in `grant`, a share grant
+  of the record whose `context` is the placement's, as written, and that the record does not revoke. A personal
+  placement names no grant. A context that is not `org:<orgId>` matches no grant, so it fails closed.
+- **An organization's slot is filled from its own machine.** An envelope names no context, so a secret placed in an
+  organization's context has `from` equal to the machine it sits on (FAC-SEM-075).
+- **A share grant is never personal** (FAC-SEM-110). A grant to a principal outside the estate (`principalKind:
+  external`) is used in that principal's organization; `context: "personal"` on it is a finding, and an absent one
+  means not stated. `grant_context_findings(grant, at)` / `grantContextFindings(grant, at)` check one grant on its own.
+
+Every rule is total on hostile JSON, as the contract's are: an `instancePath` names an item by its index as written (a
+non-object before it does not shift it), and a value whose own `toString` member is data is shown as its JSON. Both kits
+answer the contract's contexts fixtures and variants of them (`test/fixtures/contract/estate-vectors.json`).
+
 ## Checking a record you produce
 
 `estate_record_rules(kind, value)` / `estateRecordRules(kind, value)` are the contract's rules, finding for finding:
-- `estate-record` (FAC-SEM-072…076);
+- `estate-record` (FAC-SEM-072…076, 110, 111);
 - `estate-record-revision` `{parent, next}` (072);
-- `estate-placement` `{record, machine, package}` (074, 075).
+- `estate-placement` `{record, machine, package, context?}` (074, 075, 111): the package placed on that machine in that
+  context, `personal` when `context` is absent.
 
-`placement_trust(record, machine, agentRef)` names the publisher keys a package verifier trusts for a placed package.
+`placement_trust(record, machine, agentRef, context="personal")` / `placementTrust(record, machine, agentRef, context)`
+names the publisher keys a package verifier trusts for the package placed in that context. A caller that passes no
+context gets the personal placement, as before contexts.
 
 ## What the kit does not do
 

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 `1636fa97262f4a26e2086572d540c2ee701e0010`
+Pinned to `fabric-agent-contract` commit `82e163665e156a08aa3b92e4711015582c06162c`
 (`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;

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

@@ -26,6 +26,41 @@ export const FLAGS = Object.freeze({ UP: 0x01, UV: 0x04, BE: 0x08, BS: 0x10, AT:
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const isString = (value) => typeof value === 'string';
 const list = (value) => (Array.isArray(value) ? value.filter(isObject) : []);
+/** The object items of an array with their index as written, so an instancePath names the item even after a non-object. */
+const indexed = (value) => (Array.isArray(value) ? value.flatMap((item, index) => (isObject(item) ? [[item, index]] : [])) : []);
+/** The contract's `show`: String(value), or its JSON where String() throws (an object whose own `toString` is data). */
+const show = (value) => {
+  if (typeof value === 'string') return value;
+  try {
+    return String(value);
+  } catch {
+    return JSON.stringify(value) ?? typeof value;
+  }
+};
+/** The contract's `toNumber`: Number(value), or NaN where Number() throws. */
+const toNumber = (value) => {
+  try {
+    return Number(value);
+  } catch {
+    return Number.NaN;
+  }
+};
+/** DEC-0082: the personal context, and an organization's context `org:<orgId>` (the contract's `context-route.ts`). */
+export const PERSONAL_CONTEXT = 'personal';
+export const ORG_CONTEXT_PREFIX = 'org:';
+const ORG_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+/** The context `value` names, or undefined: `personal` exactly, or `org:` and an organization id; compared as written. */
+export function parseContext(value) {
+  if (typeof value !== 'string') return undefined;
+  if (value === PERSONAL_CONTEXT) return { kind: 'personal' };
+  if (!value.startsWith(ORG_CONTEXT_PREFIX)) return undefined;
+  const org = value.slice(ORG_CONTEXT_PREFIX.length);
+  return ORG_ID.test(org) ? { kind: 'org', org } : undefined;
+}
+/** A placement's or a secret placement's context: its `context`, `personal` when absent (DEC-0082). */
+const contextOf = (entry) => (entry.context === undefined ? PERSONAL_CONTEXT : entry.context);
+/** A collision-free key over JSON values. */
+const keyOf = (...parts) => JSON.stringify(parts);
 const sha256 = (bytes) => crypto.createHash('sha256').update(bytes).digest();
 const B64URL = /^[A-Za-z0-9_-]+$/;
 const bytes = (text) => Buffer.from(text, 'base64url');
@@ -255,10 +290,13 @@ export function verifyEstateRecord(record, trust) {
   return { ok: true, digest, revision: record.revision, signedBy: credential.credentialId, signCount: assertion.signCount };
 }
 
-/** What a package verifier trusts for a package placed on a machine; undefined when the record places no such agent there. */
-export function placementTrust(record, machineId, agentRef) {
+/**
+ * What a package verifier trusts for a package placed on a machine in a context (DEC-0082; `personal` when not given);
+ * undefined when the record places no such agent there in that context.
+ */
+export function placementTrust(record, machineId, agentRef, context = PERSONAL_CONTEXT) {
   const machine = list(record.machines).find((entry) => entry.id === machineId);
-  const placement = list(machine?.packages).find((entry) => entry.agentRef === agentRef);
+  const placement = list(machine?.packages).find((entry) => entry.agentRef === agentRef && contextOf(entry) === context);
   if (!placement) return undefined;
   return { publisher: list(record.publisherKeys).filter((key) => key.kid === placement.publisherKid) };
 }
@@ -335,7 +373,7 @@ function revisionChain(value) {
   const parent = isObject(value.parent) ? value.parent : {};
   const next = isObject(value.next) ? value.next : {};
   if (next.estate !== parent.estate) flag('/next/estate', "a revision continues its parent's estate");
-  if (next.revision !== Number(parent.revision) + 1) flag('/next/revision', `the revision after ${String(parent.revision)} is ${Number(parent.revision) + 1}: a revision never skips or repeats one`);
+  if (next.revision !== toNumber(parent.revision) + 1) flag('/next/revision', `the revision after ${show(parent.revision)} is ${toNumber(parent.revision) + 1}: a revision never skips or repeats one`);
   let parentDigest;
   try {
     parentDigest = estateRecordDigest(parent);
@@ -345,14 +383,14 @@ function revisionChain(value) {
   if (next.parent !== parentDigest) flag('/next/parent', 'parent names the digest of the revision before it');
   if (estateTime(next.issuedAt) < estateTime(parent.issuedAt)) flag('/next/issuedAt', 'a revision is never issued before its parent');
   const kept = new Set(list(next.revocations).map(revocationKey));
-  list(parent.revocations).forEach((entry, index) => {
-    if (!kept.has(revocationKey(entry))) flag(`/parent/revocations/${index}`, `the ${String(entry.kind)} revocation of ${String(entry.ref)} is dropped: a revision keeps every revocation before it`);
+  indexed(parent.revocations).forEach(([entry, index]) => {
+    if (!kept.has(revocationKey(entry))) flag(`/parent/revocations/${index}`, `the ${show(entry.kind)} revocation of ${show(entry.ref)} is dropped: a revision keeps every revocation before it`);
   });
   return findings;
 }
 
 const validDeviceKey = (key) => {
-  const raw = Buffer.from(String(key.publicKey ?? ''), 'base64');
+  const raw = Buffer.from(show(key.publicKey ?? ''), 'base64');
   return key.alg === 'ed25519' ? raw.length === 32 && !smallOrder(raw) : isValidP256Key(raw);
 };
 
@@ -360,69 +398,73 @@ function keys(value, flag) {
   const ids = new Set();
   const hubKids = new Set();
   const hubKeys = new Set();
-  list(value.machines).forEach((machine, m) => {
+  indexed(value.machines).forEach(([machine, m]) => {
     const at = `/machines/${m}`;
-    if (ids.has(machine.id)) flag(`${at}/id`, `machine ${String(machine.id)} is listed twice`);
+    if (ids.has(machine.id)) flag(`${at}/id`, `machine ${show(machine.id)} is listed twice`);
     ids.add(machine.id);
     const deviceKeys = list(machine.deviceKeys);
     if (deviceKeys.filter((key) => key.use === 'sig').length !== 1) flag(`${at}/deviceKeys`, 'a machine has exactly one signing device key, <id>#sig');
     if (deviceKeys.filter((key) => key.use === 'kem').length > 1) flag(`${at}/deviceKeys`, 'a machine has at most one key-agreement device key, <id>#kem');
     const seen = new Set();
     deviceKeys.forEach((key, k) => {
-      if (key.kid !== `${String(machine.id)}#${String(key.use)}`) flag(`${at}/deviceKeys/${k}/kid`, 'a device key is listed as <machine id>#sig or <machine id>#kem, by its role');
+      if (key.kid !== `${show(machine.id)}#${show(key.use)}`) flag(`${at}/deviceKeys/${k}/kid`, 'a device key is listed as <machine id>#sig or <machine id>#kem, by its role');
       if (!validDeviceKey(key)) flag(`${at}/deviceKeys/${k}/publicKey`, 'an Ed25519 key is never of small order (DEC-0045) and a P-256 key is a valid point (SEC 1 §3.2.2)');
       if (seen.has(key.publicKey)) flag(`${at}/deviceKeys/${k}/publicKey`, 'one key is never used for the other role');
       seen.add(key.publicKey);
     });
     if (isObject(machine.hubKey)) {
       const hub = machine.hubKey;
-      if (hubKids.has(hub.kid)) flag(`${at}/hubKey/kid`, `hub key ${String(hub.kid)} is certified for two machines: one kid per machine`);
+      if (hubKids.has(hub.kid)) flag(`${at}/hubKey/kid`, `hub key ${show(hub.kid)} is certified for two machines: one kid per machine`);
       hubKids.add(hub.kid);
       if (hubKeys.has(hub.x)) flag(`${at}/hubKey/x`, 'one hub public key is certified for two machines under two kids: one key per machine');
       hubKeys.add(hub.x);
-      if (smallOrder(Buffer.from(String(hub.x ?? ''), 'base64url'))) flag(`${at}/hubKey/x`, 'a hub key of small order verifies forged tokens and is never certified (DEC-0045)');
+      if (smallOrder(Buffer.from(show(hub.x ?? ''), 'base64url'))) flag(`${at}/hubKey/x`, 'a hub key of small order verifies forged tokens and is never certified (DEC-0045)');
     }
   });
   const credentials = new Set();
-  list(value.authorities).forEach((authority, index) => {
+  indexed(value.authorities).forEach(([authority, index]) => {
     if (credentials.has(authority.credentialId)) flag(`/authorities/${index}/credentialId`, 'a passkey is listed once');
     credentials.add(authority.credentialId);
-    if ('problem' in credentialKey(authority.publicKey, String(authority.alg))) flag(`/authorities/${index}/publicKey`, "a passkey's public key is a valid P-256 point for ES256 or an Ed25519 key of full order for EdDSA");
+    if ('problem' in credentialKey(authority.publicKey, show(authority.alg))) flag(`/authorities/${index}/publicKey`, "a passkey's public key is a valid P-256 point for ES256 or an Ed25519 key of full order for EdDSA");
   });
 }
 
 function placements(value, flag) {
   const kids = new Set();
-  list(value.publisherKeys).forEach((key, index) => {
-    if (kids.has(key.kid)) flag(`/publisherKeys/${index}/kid`, `publisher key ${String(key.kid)} is pinned twice`);
+  indexed(value.publisherKeys).forEach(([key, index]) => {
+    if (kids.has(key.kid)) flag(`/publisherKeys/${index}/kid`, `publisher key ${show(key.kid)} is pinned twice`);
     kids.add(key.kid);
   });
-  list(value.machines).forEach((machine, m) => {
+  indexed(value.machines).forEach(([machine, m]) => {
     const agents = new Set();
-    list(machine.packages).forEach((placement, p) => {
+    indexed(machine.packages).forEach(([placement, p]) => {
       const at = `/machines/${m}/packages/${p}`;
-      if (agents.has(placement.agentRef)) flag(`${at}/agentRef`, `${String(placement.agentRef)} is placed twice on one machine`);
-      agents.add(placement.agentRef);
-      if (!kids.has(placement.publisherKid)) flag(`${at}/publisherKid`, `publisher key ${String(placement.publisherKid)} is not in publisherKeys, so the machine pins no key to verify the package under`);
+      const key = keyOf(placement.agentRef, contextOf(placement));
+      if (agents.has(key)) flag(`${at}/agentRef`, `${show(placement.agentRef)} is placed twice on one machine in the context ${show(contextOf(placement))}`);
+      agents.add(key);
+      if (!kids.has(placement.publisherKid)) flag(`${at}/publisherKid`, `publisher key ${show(placement.publisherKid)} is not in publisherKeys, so the machine pins no key to verify the package under`);
     });
   });
 }
 
 function secretReferences(value, flag) {
   const machineIds = new Set(list(value.machines).map((machine) => machine.id));
-  list(value.machines).forEach((machine, m) => {
-    const placed = new Set(list(machine.packages).map((placement) => placement.agentRef));
+  indexed(value.machines).forEach(([machine, m]) => {
+    const placed = new Set(list(machine.packages).map((placement) => keyOf(placement.agentRef, contextOf(placement))));
     const slots = new Set();
-    list(machine.secrets).forEach((secret, s) => {
+    indexed(machine.secrets).forEach(([secret, s]) => {
       const at = `/machines/${m}/secrets/${s}`;
-      for (const field of ['slot', 'from', 'agentRef']) {
+      // The message never repeats the value, and no message of this rule repeats a secret placement's context.
+      for (const field of ['slot', 'from', 'agentRef', 'context']) {
         const text = secret[field];
         if (isString(text) && secretValue(text)) flag(`${at}/${field}`, 'a secret placement names a slot, never a value: this looks like a credential');
       }
-      if (!placed.has(secret.agentRef)) flag(`${at}/agentRef`, 'a secret goes only where a placed package declares it (v4 Path 2): this agent is not placed on this machine');
+      if (!placed.has(keyOf(secret.agentRef, contextOf(secret)))) flag(`${at}/agentRef`, "a secret goes only where a placed package declares it (v4 Path 2): this agent is not placed on this machine in the secret's context");
       if (!machineIds.has(secret.from)) flag(`${at}/from`, 'the slot is filled from a machine of this estate');
-      const key = `${String(secret.agentRef)} ${String(secret.slot)}`;
-      if (slots.has(key)) flag(`${at}/slot`, `slot ${String(secret.slot)} is placed twice for one agent on one machine`);
+      // An envelope names no context (DEC-0082), so an organization's instance fills its slot on its own machine.
+      else if (contextOf(secret) !== PERSONAL_CONTEXT && secret.from !== machine.id) flag(`${at}/from`, "an organization's instance fills its slot from its own machine's vault, never by an envelope from another machine");
+      const key = keyOf(secret.agentRef, secret.slot, contextOf(secret));
+      if (slots.has(key)) flag(`${at}/slot`, `slot ${show(secret.slot)} is placed twice for one agent in one context on one machine`);
       slots.add(key);
     });
   });
@@ -432,10 +474,10 @@ function grantsAndRevocations(value, flag) {
   // A grant's id is a URI, so grants and their revocations are keyed by its normal form (DEC-0076).
   const grantKey = (id) => (typeof id === 'string' ? normalIdentifier(id) : id);
   const grantIds = new Set();
-  list(value.shareGrants).forEach((grant, index) => {
+  indexed(value.shareGrants).forEach(([grant, index]) => {
     if (grant.principalKind !== 'external') flag(`/shareGrants/${index}/principalKind`, 'a share grant is to a principal outside the estate: principalKind external');
     const id = isObject(grant.meta) ? grant.meta.id : undefined;
-    if (grantIds.has(grantKey(id))) flag(`/shareGrants/${index}/meta/id`, `grant ${String(id)} is listed twice`);
+    if (grantIds.has(grantKey(id))) flag(`/shareGrants/${index}/meta/id`, `grant ${show(id)} is listed twice`);
     grantIds.add(grantKey(id));
   });
   const machines = list(value.machines);
@@ -450,12 +492,50 @@ function grantsAndRevocations(value, flag) {
     grant: grantIds,
   }));
   const seen = new Set();
-  list(value.revocations).forEach((revocation, index) => {
+  indexed(value.revocations).forEach(([revocation, index]) => {
     const ref = revocation.kind === 'grant' ? grantKey(revocation.ref) : revocation.ref;
-    const key = `${String(revocation.kind)} ${String(ref)}`;
-    if (seen.has(key)) flag(`/revocations/${index}`, `the ${String(revocation.kind)} ${String(revocation.ref)} is revoked twice`);
+    const key = `${show(revocation.kind)} ${show(ref)}`;
+    if (seen.has(key)) flag(`/revocations/${index}`, `the ${show(revocation.kind)} ${show(revocation.ref)} is revoked twice`);
     seen.add(key);
-    if (listed.get(String(revocation.kind))?.has(ref)) flag(`/revocations/${index}/ref`, `the record still lists the ${String(revocation.kind)} it revokes: revocation outranks addition`);
+    if (listed.get(show(revocation.kind))?.has(ref)) flag(`/revocations/${index}/ref`, `the record still lists the ${show(revocation.kind)} it revokes: revocation outranks addition`);
+  });
+}
+
+/**
+ * FAC-SEM-110 (DEC-0082): a grant to a principal outside the estate (`principalKind: external`) is used in that
+ * principal's organization, so its `context` is never `personal`; absent means not stated.
+ */
+export function grantContextFindings(grant, at) {
+  if (!isObject(grant) || grant.principalKind !== 'external' || grant.context !== PERSONAL_CONTEXT) return [];
+  return [{ code: 'FAC-SEM-110', instancePath: `${at}/context`, message: "a grant to a principal outside the estate is used in that principal's organization, never in the personal context: name the organization's org:<orgId>, or leave context out" }];
+}
+
+/**
+ * FAC-SEM-111 (DEC-0082) for one placement: an instance in an organization's context names, in `grant`, a share grant
+ * of the same record (by the normal form of its id, DEC-0076) whose `context` is the placement's, as written, and that
+ * the record does not revoke; a personal instance names none; a malformed context fails closed.
+ */
+function placementGrantProblems(record, placement) {
+  const context = contextOf(placement);
+  if (context === PERSONAL_CONTEXT) {
+    return placement.grant === undefined ? [] : [['/grant', "a personal instance runs under no share grant: only a placement in an organization's context names one"]];
+  }
+  if (typeof placement.grant !== 'string') return [['/grant', `an instance placed in the context ${show(context)} names the share grant it runs under, by its id`]];
+  const id = normalIdentifier(placement.grant);
+  const grants = list(record.shareGrants).filter((grant) => isObject(grant.meta) && typeof grant.meta.id === 'string' && normalIdentifier(grant.meta.id) === id);
+  const problems = [];
+  if (grants.length === 0) problems.push(['/grant', `the record has no share grant ${placement.grant}`]);
+  else if (parseContext(context)?.kind !== 'org') problems.push(['/context', `${show(context)} is not an organization's context id (org:<orgId>), so no share grant matches it`]);
+  else if (!grants.some((grant) => grant.context === context)) problems.push(['/grant', `the share grant ${placement.grant} is not for the context ${show(context)}: its context must be the placement's, as written`]);
+  if (list(record.revocations).some((entry) => entry.kind === 'grant' && typeof entry.ref === 'string' && normalIdentifier(entry.ref) === id)) problems.push(['/grant', `the record revokes the share grant ${placement.grant}, so no instance runs under it`]);
+  return problems;
+}
+
+function placementGrants(value, flag) {
+  indexed(value.machines).forEach(([machine, m]) => {
+    indexed(machine.packages).forEach(([placement, p]) => {
+      for (const [suffix, message] of placementGrantProblems(value, placement)) flag(`/machines/${m}/packages/${p}${suffix}`, message);
+    });
   });
 }
 
@@ -466,8 +546,10 @@ function recordFindings(value) {
   placements(value, flagger(findings, 'FAC-SEM-074'));
   secretReferences(value, flagger(findings, 'FAC-SEM-075'));
   grantsAndRevocations(value, flagger(findings, 'FAC-SEM-076'));
+  indexed(value.shareGrants).forEach(([grant, index]) => findings.push(...grantContextFindings(grant, `/shareGrants/${index}`)));
+  placementGrants(value, flagger(findings, 'FAC-SEM-111'));
   // FAC-SEM-092 (DEC-0063) on each passkey the record lists.
-  list(value.authorities).forEach((authority, index) => signingCredential(authority, `/authorities/${index}`, flagger(findings, 'FAC-SEM-092')));
+  indexed(value.authorities).forEach(([authority, index]) => signingCredential(authority, `/authorities/${index}`, flagger(findings, 'FAC-SEM-092')));
   return findings;
 }
 
@@ -480,8 +562,7 @@ function installation(value) {
   const findings = [];
   const record = isObject(value.record) ? value.record : {};
   const pkg = isObject(value.package) ? value.package : {};
-  const machineIndex = list(record.machines).findIndex((entry) => entry.id === value.machine);
-  const machine = list(record.machines)[machineIndex];
+  const [machine, machineIndex] = indexed(record.machines).find(([entry]) => entry.id === value.machine) ?? [undefined, -1];
   let digest;
   try {
     digest = packageDigest(pkg);
@@ -490,18 +571,23 @@ function installation(value) {
   }
   const flag074 = flagger(findings, 'FAC-SEM-074');
   if (!machine) {
-    flag074('/machine', `machine ${String(value.machine)} is not in the estate record`);
+    flag074('/machine', `machine ${show(value.machine)} is not in the estate record`);
     return findings;
   }
   if (digest === undefined || digest !== pkg.digest) flag074('/package/digest', 'the package is not the one its digest names: it changed after it was packed');
-  const placement = list(machine.packages).find((entry) => entry.agentRef === pkg.agentRef);
-  if (!placement) flag074('/package/agentRef', `the record places no ${String(pkg.agentRef)} on machine ${String(value.machine)}`);
-  else if (placement.digest !== digest) flag074('/package', `the record places ${String(placement.digest)} of this agent on this machine, not this package`);
+  const context = contextOf(value);
+  const [placement, placementIndex] = indexed(machine.packages).find(([entry]) => entry.agentRef === pkg.agentRef && contextOf(entry) === context) ?? [undefined, -1];
+  if (!placement) flag074('/package/agentRef', `the record places no ${show(pkg.agentRef)} on machine ${show(value.machine)} in the context ${show(context)}`);
+  else if (placement.digest !== digest) flag074('/package', `the record places ${show(placement.digest)} of this agent on this machine in this context, not this package`);
   const declared = new Set(list(pkg.secrets).map((slot) => slot.name));
   const flag075 = flagger(findings, 'FAC-SEM-075');
-  list(machine.secrets).forEach((secret, index) => {
-    if (secret.agentRef === pkg.agentRef && !declared.has(secret.slot)) flag075(`/record/machines/${machineIndex}/secrets/${index}/slot`, `the package declares no slot ${String(secret.slot)}: a secret goes only where a placed package declares it`);
+  indexed(machine.secrets).forEach(([secret, index]) => {
+    if (secret.agentRef === pkg.agentRef && contextOf(secret) === context && !declared.has(secret.slot)) flag075(`/record/machines/${machineIndex}/secrets/${index}/slot`, `the package declares no slot ${show(secret.slot)}: a secret goes only where a placed package declares it`);
   });
+  if (placement) {
+    const flag111 = flagger(findings, 'FAC-SEM-111');
+    for (const [suffix, message] of placementGrantProblems(record, placement)) flag111(`/record/machines/${machineIndex}/packages/${placementIndex}${suffix}`, message);
+  }
   return findings;
 }
 

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_estate.py

@@ -151,6 +151,84 @@ def _list(value: Any) -> List[Dict[str, Any]]:
     return [item for item in value if isinstance(item, dict)] if isinstance(value, list) else []
 
 
+def _indexed(value: Any) -> List[Tuple[Dict[str, Any], int]]:
+    """The object items of an array with their index in the array as written, so an instancePath names the item it
+    flags even when a non-object precedes it (the contract's ``indexed``)."""
+    return [(item, i) for i, item in enumerate(value) if isinstance(item, dict)] if isinstance(value, list) else []
+
+
+class _Unshowable(Exception):
+    pass
+
+
+def _strict_string(value: Any) -> str:
+    """String(value), raising where JavaScript's String() throws: an object whose own ``toString`` is not a function
+    (every own member of parsed JSON is data), directly or inside an array it joins."""
+    if isinstance(value, dict):
+        if "toString" in value:
+            raise _Unshowable()
+        return "[object Object]"
+    if isinstance(value, list):
+        return ",".join("" if item is None else _strict_string(item) for item in value)
+    return _js_string(value)
+
+
+def _json_stringify(value: Any) -> str:
+    """JSON.stringify for a parsed JSON value: members in their order, numbers as JavaScript writes them."""
+    if isinstance(value, dict):
+        return "{" + ",".join(_delegation._string(k) + ":" + _json_stringify(v) for k, v in value.items()) + "}"
+    if isinstance(value, list):
+        return "[" + ",".join(_json_stringify(v) for v in value) + "]"
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if _number(value):
+        text = _js_string(value)
+        return "null" if text in ("NaN", "Infinity", "-Infinity") else text
+    return _delegation._string(value)
+
+
+def _show(value: Any) -> str:
+    """The contract's ``show``: String(value), or the value's JSON where String() would throw."""
+    try:
+        return _strict_string(value)
+    except _Unshowable:
+        return _json_stringify(value)
+
+
+def _key_of(*parts: Any) -> str:
+    """The contract's ``keyOf``: a collision-free key over JSON values, JSON.stringify of the parts (an absent value
+    is null inside an array, as JavaScript writes it)."""
+    return _json_stringify([None if part is _MISSING else part for part in parts])
+
+
+#: DEC-0082: the personal context, and an organization's context ``org:<orgId>`` (the contract's ``context-route.ts``).
+PERSONAL_CONTEXT = "personal"
+ORG_CONTEXT_PREFIX = "org:"
+_ORG_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9_-]{0,127}")
+
+
+def parse_context(value: Any) -> Optional[Dict[str, str]]:
+    """The context ``value`` names, or None when it names none: ``personal`` exactly, or ``org:`` and an organization id
+    (``[A-Za-z0-9][A-Za-z0-9_-]{0,127}``). Compared as written: ``Personal``, ``ORG:x`` or a trailing newline name no
+    context. Never raises."""
+    if not isinstance(value, str):
+        return None
+    if value == PERSONAL_CONTEXT:
+        return {"kind": "personal"}
+    if not value.startswith(ORG_CONTEXT_PREFIX):
+        return None
+    org = value[len(ORG_CONTEXT_PREFIX):]
+    return {"kind": "org", "org": org} if _ORG_ID.fullmatch(org) else None
+
+
+def _context_of(entry: Any) -> Any:
+    """A placement's or a secret placement's context: its ``context``, ``personal`` when absent (DEC-0082)."""
+    context = _get(entry, "context")
+    return PERSONAL_CONTEXT if context is _MISSING else context
+
+
 def _b64url_bytes(text: str) -> bytes:
     """Buffer.from(text, "base64url") for text of the base64url alphabet: a dangling sixth bit group is ignored."""
     return _delegation._b64decode(text)
@@ -514,7 +592,7 @@ def _signing_credential(credential: Any, path: str, flag) -> None:
 
 
 def _revocation_key(entry: Dict[str, Any]) -> str:
-    return "%s %s" % (_s(entry, "kind"), _s(entry, "ref"))
+    return "%s %s" % (_show(_get(entry, "kind")), _show(_get(entry, "ref")))
 
 
 def _lt(a: float, b: float) -> bool:
@@ -610,11 +688,13 @@ def verify_estate_record(record: Any, *, at: Any, parent: Any = _MISSING, author
     return {"ok": True, "digest": digest, "revision": record["revision"], "signedBy": credential["credentialId"], "signCount": assertion["signCount"]}
 
 
-def placement_trust(record: Dict[str, Any], machine_id: str, agent_ref: str) -> Optional[Dict[str, Any]]:
-    """What a package verifier (DEC-0051) trusts for a package placed on a machine: the publisher keys the placement
-    names, from the record's `publisherKeys`. None when the record places no such agent on that machine."""
+def placement_trust(record: Dict[str, Any], machine_id: str, agent_ref: str, context: str = PERSONAL_CONTEXT) -> Optional[Dict[str, Any]]:
+    """What a package verifier (DEC-0051) trusts for a package placed on a machine in a context (DEC-0082; ``personal``
+    when not given, so a caller written before contexts is unchanged): the publisher keys the placement names, from the
+    record's `publisherKeys`. None when the record places no such agent on that machine in that context."""
     machine = next((m for m in _list(_get(record, "machines")) if _same(_get(m, "id"), machine_id)), None)
-    placement = next((p for p in _list(_get(machine, "packages")) if _same(_get(p, "agentRef"), agent_ref)), None)
+    placement = next((p for p in _list(_get(machine, "packages"))
+                      if _same(_get(p, "agentRef"), agent_ref) and _same(_context_of(p), context)), None)
     if placement is None:
         return None
     return {"publisher": [k for k in _list(_get(record, "publisherKeys")) if _same(_get(k, "kid"), _get(placement, "publisherKid"))]}
@@ -720,7 +800,7 @@ def _revision_chain(value: Dict[str, Any]) -> List[Dict[str, str]]:
         flag("/next/estate", "a revision continues its parent's estate")
     expected = _js_to_number(_get(parent, "revision")) + 1
     if not _same(_get(nxt, "revision"), expected):
-        flag("/next/revision", "the revision after %s is %s: a revision never skips or repeats one" % (_s(parent, "revision"), _js_string(expected)))
+        flag("/next/revision", "the revision after %s is %s: a revision never skips or repeats one" % (_show(_get(parent, "revision")), _js_string(expected)))
     try:
         parent_digest: Any = estate_record_digest(parent)
     except TypeError:
@@ -730,15 +810,15 @@ def _revision_chain(value: Dict[str, Any]) -> List[Dict[str, str]]:
     if _lt(estate_time(_get(nxt, "issuedAt")), estate_time(_get(parent, "issuedAt"))):
         flag("/next/issuedAt", "a revision is never issued before its parent")
     kept = {_revocation_key(e) for e in _list(_get(nxt, "revocations"))}
-    for index, entry in enumerate(_list(_get(parent, "revocations"))):
+    for entry, index in _indexed(_get(parent, "revocations")):
         if _revocation_key(entry) not in kept:
-            flag("/parent/revocations/%d" % index, "the %s revocation of %s is dropped: a revision keeps every revocation before it" % (_s(entry, "kind"), _s(entry, "ref")))
+            flag("/parent/revocations/%d" % index, "the %s revocation of %s is dropped: a revision keeps every revocation before it" % (_show(_get(entry, "kind")), _show(_get(entry, "ref"))))
     return findings
 
 
 def _valid_device_key(key: Dict[str, Any]) -> bool:
     public = _get(key, "publicKey")
-    raw = _node_base64("" if public is _MISSING or public is None else _js_string(public))
+    raw = _node_base64("" if public is _MISSING or public is None else _show(public))
     if _get(key, "alg") == "ed25519":
         return len(raw) == 32 and not _delegation.is_small_order_key(raw)
     return is_valid_p256_key(raw)
@@ -748,10 +828,10 @@ def _keys(value: Dict[str, Any], flag) -> None:
     ids: List[Any] = []
     hub_kids: List[Any] = []
     hub_keys: List[Any] = []
-    for m, machine in enumerate(_list(_get(value, "machines"))):
+    for machine, m in _indexed(_get(value, "machines")):
         at = "/machines/%d" % m
         if _contains(ids, _get(machine, "id")):
-            flag("%s/id" % at, "machine %s is listed twice" % _s(machine, "id"))
+            flag("%s/id" % at, "machine %s is listed twice" % _show(_get(machine, "id")))
         ids.append(_get(machine, "id"))
         device_keys = _list(_get(machine, "deviceKeys"))
         if len([k for k in device_keys if _get(k, "use") == "sig"]) != 1:
@@ -759,8 +839,8 @@ def _keys(value: Dict[str, Any], flag) -> None:
         if len([k for k in device_keys if _get(k, "use") == "kem"]) > 1:
             flag("%s/deviceKeys" % at, "a machine has at most one key-agreement device key, <id>#kem")
         seen: List[Any] = []
-        for k, key in enumerate(device_keys):
-            if not _same(_get(key, "kid"), "%s#%s" % (_s(machine, "id"), _s(key, "use"))):
+        for key, k in _indexed(_get(machine, "deviceKeys")):
+            if not _same(_get(key, "kid"), "%s#%s" % (_show(_get(machine, "id")), _show(_get(key, "use")))):
                 flag("%s/deviceKeys/%d/kid" % (at, k), "a device key is listed as <machine id>#sig or <machine id>#kem, by its role")
             if not _valid_device_key(key):
                 flag("%s/deviceKeys/%d/publicKey" % (at, k), "an Ed25519 key is never of small order (DEC-0045) and a P-256 key is a valid point (SEC 1 §3.2.2)")
@@ -770,7 +850,7 @@ def _keys(value: Dict[str, Any], flag) -> None:
         hub = _get(machine, "hubKey")
         if isinstance(hub, dict):
             if _contains(hub_kids, _get(hub, "kid")):
-                flag("%s/hubKey/kid" % at, "hub key %s is certified for two machines: one kid per machine" % _s(hub, "kid"))
+                flag("%s/hubKey/kid" % at, "hub key %s is certified for two machines: one kid per machine" % _show(_get(hub, "kid")))
             hub_kids.append(_get(hub, "kid"))
             if _contains(hub_keys, _get(hub, "x")):
                 flag("%s/hubKey/x" % at, "one hub public key is certified for two machines under two kids: one key per machine")
@@ -780,49 +860,55 @@ def _keys(value: Dict[str, Any], flag) -> None:
             if _delegation.is_small_order_key(raw):
                 flag("%s/hubKey/x" % at, "a hub key of small order verifies forged tokens and is never certified (DEC-0045)")
     credentials: List[Any] = []
-    for index, authority in enumerate(_list(_get(value, "authorities"))):
+    for authority, index in _indexed(_get(value, "authorities")):
         if _contains(credentials, _get(authority, "credentialId")):
             flag("/authorities/%d/credentialId" % index, "a passkey is listed once")
         credentials.append(_get(authority, "credentialId"))
-        if "problem" in credential_key(_get(authority, "publicKey"), _s(authority, "alg")):
+        if "problem" in credential_key(_get(authority, "publicKey"), _show(_get(authority, "alg"))):
             flag("/authorities/%d/publicKey" % index, "a passkey's public key is a valid P-256 point for ES256 or an Ed25519 key of full order for EdDSA")
 
 
 def _placements(value: Dict[str, Any], flag) -> None:
     kids: List[Any] = []
-    for index, key in enumerate(_list(_get(value, "publisherKeys"))):
+    for key, index in _indexed(_get(value, "publisherKeys")):
         if _contains(kids, _get(key, "kid")):
-            flag("/publisherKeys/%d/kid" % index, "publisher key %s is pinned twice" % _s(key, "kid"))
+            flag("/publisherKeys/%d/kid" % index, "publisher key %s is pinned twice" % _show(_get(key, "kid")))
         kids.append(_get(key, "kid"))
-    for m, machine in enumerate(_list(_get(value, "machines"))):
-        agents: List[Any] = []
-        for p, placement in enumerate(_list(_get(machine, "packages"))):
+    for machine, m in _indexed(_get(value, "machines")):
+        agents: List[str] = []
+        for placement, p in _indexed(_get(machine, "packages")):
             at = "/machines/%d/packages/%d" % (m, p)
-            if _contains(agents, _get(placement, "agentRef")):
-                flag("%s/agentRef" % at, "%s is placed twice on one machine" % _s(placement, "agentRef"))
-            agents.append(_get(placement, "agentRef"))
+            key = _key_of(_get(placement, "agentRef"), _context_of(placement))
+            if key in agents:
+                flag("%s/agentRef" % at, "%s is placed twice on one machine in the context %s"
+                     % (_show(_get(placement, "agentRef")), _show(_context_of(placement))))
+            agents.append(key)
             if not _contains(kids, _get(placement, "publisherKid")):
-                flag("%s/publisherKid" % at, "publisher key %s is not in publisherKeys, so the machine pins no key to verify the package under" % _s(placement, "publisherKid"))
+                flag("%s/publisherKid" % at, "publisher key %s is not in publisherKeys, so the machine pins no key to verify the package under" % _show(_get(placement, "publisherKid")))
 
 
 def _secret_references(value: Dict[str, Any], flag) -> None:
     machine_ids = [_get(m, "id") for m in _list(_get(value, "machines"))]
-    for m, machine in enumerate(_list(_get(value, "machines"))):
-        placed = [_get(p, "agentRef") for p in _list(_get(machine, "packages"))]
+    for machine, m in _indexed(_get(value, "machines")):
+        placed = [_key_of(_get(p, "agentRef"), _context_of(p)) for p in _list(_get(machine, "packages"))]
         slots: List[str] = []
-        for s, secret in enumerate(_list(_get(machine, "secrets"))):
+        for secret, s in _indexed(_get(machine, "secrets")):
             at = "/machines/%d/secrets/%d" % (m, s)
-            for field in ("slot", "from", "agentRef"):
+            # The message never repeats the value, and no message of this rule repeats a secret placement's context.
+            for field in ("slot", "from", "agentRef", "context"):
                 text = _get(secret, field)
                 if isinstance(text, str) and _secrets.secret_value(text):
                     flag("%s/%s" % (at, field), "a secret placement names a slot, never a value: this looks like a credential")
-            if not _contains(placed, _get(secret, "agentRef")):
-                flag("%s/agentRef" % at, "a secret goes only where a placed package declares it (v4 Path 2): this agent is not placed on this machine")
+            if _key_of(_get(secret, "agentRef"), _context_of(secret)) not in placed:
+                flag("%s/agentRef" % at, "a secret goes only where a placed package declares it (v4 Path 2): this agent is not placed on this machine in the secret's context")
             if not _contains(machine_ids, _get(secret, "from")):
                 flag("%s/from" % at, "the slot is filled from a machine of this estate")
-            key = "%s %s" % (_s(secret, "agentRef"), _s(secret, "slot"))
+            elif not _same(_context_of(secret), PERSONAL_CONTEXT) and not _same(_get(secret, "from"), _get(machine, "id")):
+                # An envelope names no context (DEC-0082): an organization's instance fills its slot on its own machine.
+                flag("%s/from" % at, "an organization's instance fills its slot from its own machine's vault, never by an envelope from another machine")
+            key = _key_of(_get(secret, "agentRef"), _get(secret, "slot"), _context_of(secret))
             if key in slots:
-                flag("%s/slot" % at, "slot %s is placed twice for one agent on one machine" % _s(secret, "slot"))
+                flag("%s/slot" % at, "slot %s is placed twice for one agent in one context on one machine" % _show(_get(secret, "slot")))
             slots.append(key)
 
 
@@ -834,12 +920,12 @@ def _grant_key(ident: Any) -> Any:
 
 def _grants_and_revocations(value: Dict[str, Any], flag) -> None:
     grant_ids: List[Any] = []
-    for index, grant in enumerate(_list(_get(value, "shareGrants"))):
+    for grant, index in _indexed(_get(value, "shareGrants")):
         if _get(grant, "principalKind") != "external":
             flag("/shareGrants/%d/principalKind" % index, "a share grant is to a principal outside the estate: principalKind external")
         ident = _get(_get(grant, "meta"), "id") if isinstance(_get(grant, "meta"), dict) else _MISSING
         if _contains(grant_ids, _grant_key(ident)):
-            flag("/shareGrants/%d/meta/id" % index, "grant %s is listed twice" % _js_string(ident))
+            flag("/shareGrants/%d/meta/id" % index, "grant %s is listed twice" % _show(ident))
         grant_ids.append(_grant_key(ident))
     machines = _list(_get(value, "machines"))
     listed = {
@@ -852,14 +938,60 @@ def _grants_and_revocations(value: Dict[str, Any], flag) -> None:
         "grant": grant_ids,
     }
     seen: List[str] = []
-    for index, revocation in enumerate(_list(_get(value, "revocations"))):
+    for revocation, index in _indexed(_get(value, "revocations")):
         ref = _grant_key(_get(revocation, "ref")) if _get(revocation, "kind") == "grant" else _get(revocation, "ref")
-        key = "%s %s" % (_s(revocation, "kind"), _js_string(ref))
+        kind = _show(_get(revocation, "kind"))
+        key = "%s %s" % (kind, _show(ref))
         if key in seen:
-            flag("/revocations/%d" % index, "the %s %s is revoked twice" % (_s(revocation, "kind"), _s(revocation, "ref")))
+            flag("/revocations/%d" % index, "the %s %s is revoked twice" % (kind, _show(_get(revocation, "ref"))))
         seen.append(key)
-        if _contains(listed.get(_s(revocation, "kind"), []), ref):
-            flag("/revocations/%d/ref" % index, "the record still lists the %s it revokes: revocation outranks addition" % _s(revocation, "kind"))
+        if _contains(listed.get(kind, []), ref):
+            flag("/revocations/%d/ref" % index, "the record still lists the %s it revokes: revocation outranks addition" % kind)
+
+
+def grant_context_findings(grant: Any, at: str) -> List[Dict[str, str]]:
+    """FAC-SEM-110 (DEC-0082): a grant to a principal outside the estate (``principalKind: external``, a share grant) is
+    used in that principal's organization, so its ``context`` is never ``personal``; absent means not stated."""
+    if not isinstance(grant, dict) or _get(grant, "principalKind") != "external" or _get(grant, "context") != PERSONAL_CONTEXT:
+        return []
+    return [{"code": "FAC-SEM-110", "instancePath": "%s/context" % at,
+             "message": "a grant to a principal outside the estate is used in that principal's organization, never in the personal context: "
+                        "name the organization's org:<orgId>, or leave context out"}]
+
+
+def _placement_grant_problems(record: Dict[str, Any], placement: Dict[str, Any]) -> List[Tuple[str, str]]:
+    """FAC-SEM-111 (DEC-0082) for one placement: an instance in an organization's context names, in ``grant``, a share
+    grant of the same record (matched by the normal form of its id, DEC-0076) whose ``context`` is the placement's, as
+    written, and that the record does not revoke; a personal instance names none. Any other context needs a grant, and
+    only an ``org:<orgId>`` context can match one, so a malformed context fails closed."""
+    import fabric_identifiers  # noqa: E402 - beside this file
+    context = _context_of(placement)
+    grant = _get(placement, "grant")
+    if _same(context, PERSONAL_CONTEXT):
+        return [] if grant is _MISSING else [("/grant", "a personal instance runs under no share grant: only a placement in an organization's context names one")]
+    if not isinstance(grant, str):
+        return [("/grant", "an instance placed in the context %s names the share grant it runs under, by its id" % _show(context))]
+    ident = fabric_identifiers.normal_identifier(grant)
+    grants = [g for g in _list(_get(record, "shareGrants")) if isinstance(_get(g, "meta"), dict)
+              and isinstance(_get(g["meta"], "id"), str) and fabric_identifiers.normal_identifier(g["meta"]["id"]) == ident]
+    problems: List[Tuple[str, str]] = []
+    if not grants:
+        problems.append(("/grant", "the record has no share grant %s" % grant))
+    elif (parse_context(context) or {}).get("kind") != "org":
+        problems.append(("/context", "%s is not an organization's context id (org:<orgId>), so no share grant matches it" % _show(context)))
+    elif not any(_same(_get(g, "context"), context) for g in grants):
+        problems.append(("/grant", "the share grant %s is not for the context %s: its context must be the placement's, as written" % (grant, _show(context))))
+    if any(_get(e, "kind") == "grant" and isinstance(_get(e, "ref"), str) and fabric_identifiers.normal_identifier(e["ref"]) == ident
+           for e in _list(_get(record, "revocations"))):
+        problems.append(("/grant", "the record revokes the share grant %s, so no instance runs under it" % grant))
+    return problems
+
+
+def _placement_grants(value: Dict[str, Any], flag) -> None:
+    for machine, m in _indexed(_get(value, "machines")):
+        for placement, p in _indexed(_get(machine, "packages")):
+            for suffix, message in _placement_grant_problems(value, placement):
+                flag("/machines/%d/packages/%d%s" % (m, p, suffix), message)
 
 
 def _record_findings(value: Dict[str, Any]) -> List[Dict[str, str]]:
@@ -869,7 +1001,10 @@ def _record_findings(value: Dict[str, Any]) -> List[Dict[str, str]]:
     _placements(value, _finding(findings, "FAC-SEM-074"))
     _secret_references(value, _finding(findings, "FAC-SEM-075"))
     _grants_and_revocations(value, _finding(findings, "FAC-SEM-076"))
-    for index, authority in enumerate(_list(_get(value, "authorities"))):  # FAC-SEM-092 (DEC-0063)
+    for grant, index in _indexed(_get(value, "shareGrants")):  # FAC-SEM-110 (DEC-0082)
+        findings.extend(grant_context_findings(grant, "/shareGrants/%d" % index))
+    _placement_grants(value, _finding(findings, "FAC-SEM-111"))
+    for authority, index in _indexed(_get(value, "authorities")):  # FAC-SEM-092 (DEC-0063)
         _signing_credential(authority, "/authorities/%d" % index, _finding(findings, "FAC-SEM-092"))
     return findings
 
@@ -884,29 +1019,36 @@ def _installation(value: Dict[str, Any]) -> List[Dict[str, str]]:
     record = value["record"] if isinstance(_get(value, "record"), dict) else {}
     pkg = value["package"] if isinstance(_get(value, "package"), dict) else {}
     machines = _list(_get(record, "machines"))
-    machine_index = next((i for i, m in enumerate(machines) if _same(_get(m, "id"), _get(value, "machine"))), -1)
+    machine_index = next((i for m, i in _indexed(_get(record, "machines")) if _same(_get(m, "id"), _get(value, "machine"))), -1)
     flag074 = _finding(findings, "FAC-SEM-074")
     if machine_index < 0:
-        flag074("/machine", "machine %s is not in the estate record" % _s(value, "machine"))
+        flag074("/machine", "machine %s is not in the estate record" % _show(_get(value, "machine")))
         return findings
-    machine = machines[machine_index]
+    machine = record["machines"][machine_index]
     try:
         digest: Any = _package_digest(pkg)
     except TypeError:
         digest = _MISSING
     if digest is _MISSING or not _same(digest, _get(pkg, "digest")):
         flag074("/package/digest", "the package is not the one its digest names: it changed after it was packed")
-    placement = next((p for p in _list(_get(machine, "packages")) if _same(_get(p, "agentRef"), _get(pkg, "agentRef"))), None)
+    context = _context_of(value)
+    placement, placement_index = next(((p, i) for p, i in _indexed(_get(machine, "packages"))
+                                       if _same(_get(p, "agentRef"), _get(pkg, "agentRef")) and _same(_context_of(p), context)), (None, -1))
     if placement is None:
-        flag074("/package/agentRef", "the record places no %s on machine %s" % (_s(pkg, "agentRef"), _s(value, "machine")))
+        flag074("/package/agentRef", "the record places no %s on machine %s in the context %s"
+                % (_show(_get(pkg, "agentRef")), _show(_get(value, "machine")), _show(context)))
     elif not _same(_get(placement, "digest"), digest):
-        flag074("/package", "the record places %s of this agent on this machine, not this package" % _s(placement, "digest"))
+        flag074("/package", "the record places %s of this agent on this machine in this context, not this package" % _show(_get(placement, "digest")))
     declared = [_get(slot, "name") for slot in _list(_get(pkg, "secrets"))]
     flag075 = _finding(findings, "FAC-SEM-075")
-    for index, secret in enumerate(_list(_get(machine, "secrets"))):
-        if _same(_get(secret, "agentRef"), _get(pkg, "agentRef")) and not _contains(declared, _get(secret, "slot")):
+    for secret, index in _indexed(_get(machine, "secrets")):
+        if _same(_get(secret, "agentRef"), _get(pkg, "agentRef")) and _same(_context_of(secret), context) and not _contains(declared, _get(secret, "slot")):
             flag075("/record/machines/%d/secrets/%d/slot" % (machine_index, index),
-                    "the package declares no slot %s: a secret goes only where a placed package declares it" % _s(secret, "slot"))
+                    "the package declares no slot %s: a secret goes only where a placed package declares it" % _show(_get(secret, "slot")))
+    if placement is not None:
+        flag111 = _finding(findings, "FAC-SEM-111")
+        for suffix, message in _placement_grant_problems(record, placement):
+            flag111("/record/machines/%d/packages/%d%s" % (machine_index, placement_index, suffix), message)
     return findings
 
 

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.32.0"
+  version: "0.33.0"
   contract-version: "0.1.0"
-  contract-commit: "1636fa97262f4a26e2086572d540c2ee701e0010"
+  contract-commit: "82e163665e156a08aa3b92e4711015582c06162c"
 ---
 
 # 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 `1636fa97262f4a26e2086572d540c2ee701e0010` and
+Pin exactly contract `0.1.0` at commit `82e163665e156a08aa3b92e4711015582c06162c` 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.32.0"
+  version: "0.33.0"
 ---
 
 # 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
 

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.32.0"
+VERSION = "0.33.0"
 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