@passioncode-ai/fabric-agent-adapter 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 0.10.0 - 2026-10-11
+
+Contract DEC-0039, first part (FAA-20, issue #52): the operator's dashboard session now lives no longer than
+the contract allows, and the server enforces it; the probe treats `surfaces.mcp.auth: "delegation"` like `own`.
+The contract pin moves to Fabric Agent Contract `main` `8e49fbd` (the DEC-0039 merge, contract PR #30). Bundles
+issued under the DEC-0036, DEC-0035, DEC-0033, DEC-0031, DEC-0024, DEC-0021, DEC-0020 and DEC-0019 revisions
+stay valid.
+
+### Security
+
+- **Operator sessions end on the server (DEC-0039).** Until now `LoginCodes.session_valid` checked only an HMAC
+  and the cookie lived 30 days, so a copied cookie stayed valid until the session key was rotated. Now a
+  session ends 12 h after its last use, 7 days after the login code was redeemed however often it is used, on
+  `logout`, and when the descriptor token rotates. The cookie carries a signed claim (session id, sign-in time,
+  token revision); the code store keeps a record per session (last use, logout), so a cookie with no record is
+  refused. Both kits, the same behaviour.
+
+### Changed
+
+- **Every operator signs in once more after the upgrade**: a cookie of the old format is refused. The host does
+  it on the page's `401`.
+- **A remote service with `MemoryCodeStore` loses its sessions on a deploy** (it already lost its login codes):
+  the store now holds the session records. Pass a durable store to keep them.
+- **`session_cookie_header` / `remote_session_cookie_header`** (and the Node `sessionCookieHeader` /
+  `remoteSessionCookieHeader`) default to `Max-Age` 604800 (7 days), not 30 days.
+- **Default contract pin `a83bec6` → `8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5`.** `a83bec6` (DEC-0036) joins
+  `SUPPORTED_CONTRACT_COMMITS`. The revisions between (DEC-0037 spend policy, DEC-0038 grant windows,
+  DEC-0039 delegation, DEC-0040 Fabric's button) add schemas and optional properties only: the provider
+  manifest gains optional cost presets, the governance grant's `effects` may be omitted by a delegation grant,
+  and the well-known document gains `auth.delegation` and the `delegation` value of `surfaces.mcp.auth`.
+  Every descriptor, well-known document and bundle the kits wrote before stays valid.
+
+### Added
+
+- **`LoginCodes(..., token=, idle_seconds=, max_seconds=, clock=)`** (`{ token, idleSeconds, maxSeconds, clock }`
+  in Node): `token` is the descriptor token or a callable returning the current one; the bounds may be
+  shortened, and longer values are clamped. **`logout(cookie)`** and **`expired_session_cookie_header(remote=)`**
+  (`logout`, `expiredSessionCookieHeader`); `OPERATOR_SESSION_IDLE_SECONDS`, `OPERATOR_SESSION_MAX_SECONDS`.
+- **`check_service.py`**: `surfaces.mcp.auth: "delegation"` is checked like `own` — the MCP surface must refuse
+  the descriptor token, and the caller rules are `NOT_RUN` (DL-16); rule **`auth.delegation-declared`** (with
+  `delegation`, the well-known document names `auth.delegation {issuer, jwks}`); rule
+  **`login.session-lifetime`** (the cookie set at sign-in does not outlive 7 days).
+- **The sample services** pass `token=` and serve `POST /logout` (a browser write: it needs `X-Fabric-Request`).
+- `references/surfaces-and-auth.md`, `remote-placement.md` and `protocol.md` describe the lifetime, logout and
+  DL-16. Scenario evals `operator-session-lifetime` and `mcp-auth-delegation` came first.
+
+### Not yet
+
+- Verifying delegation tokens and approvals in the kits (`verifyDelegation` / `verifyApproval`) and Fabric's
+  button in the dashboard kit (FB-7) follow in a later release (FAA-20 stays open).
+
 ## 0.9.0 - 2026-10-11
 
 The dashboard kit (`fabric-dashboard/0.1`, contract DEC-0036): a Fabric service's dashboard holds inside a

package/README.md

@@ -202,7 +202,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: `a83bec6b47776af688402c18efec507143061f68`
+- commit: `8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5`
 
 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
@@ -229,8 +229,8 @@ FABRIC_CONTRACT_OLD=/path/to/legacy-contract FABRIC_CONTRACT_NEW=/path/to/curren
 ```
 
 Without both environment variables, those tests explicitly skip as `NOT_RUN`.
-This source checkout is 0.9.0. 0.8.3 is the latest published GitHub/npm release (2026-10-10; 0.7.0 was never
-released); 0.9.0 is published by its `v0.9.0` tag. Source delivery does not update installed skills or live sessions.
+This source checkout is 0.10.0. 0.9.0 is the latest published GitHub/npm release (2026-10-11; 0.7.0 was never
+released); 0.10.0 is published by its `v0.10.0` tag. Source delivery does not update installed skills or live sessions.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/fabric-agent-adapter",
-  "version": "0.9.0",
+  "version": "0.10.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.",
-  "version": "0.9.0",
+  "version": "0.10.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.9.0"
+  version: "0.10.0"
   contract-version: "0.1.0"
-  contract-commit: "a83bec6b47776af688402c18efec507143061f68"
+  contract-commit: "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5"
 ---
 
 # 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 `a83bec6b47776af688402c18efec507143061f68`.
+- commit `8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5`.
 
 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

@@ -16,10 +16,10 @@ from urllib.parse import urlparse
 
 CONTRACT_VERSION = "0.1.0"
 CONTRACT_REPOSITORY = "https://github.com/passioncode-ai/fabric-agent-contract"
-CONTRACT_COMMIT = "a83bec6b47776af688402c18efec507143061f68"
+CONTRACT_COMMIT = "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5"
 # #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, "52da526d7cc1e063d74c5b520dbc03d0ace15246", "78b2da018d2c4bd9ac1bde1dc3b7f1a110a175f5", "623bf61358c339cb10297807b3f024b5d9f1f327", "23f9fda4c05f8a3852246ee98d4f2adf74ed0875", "9091d3d6606b0c4b5591a38c3674356a01fd7f55", "df55c8c54a23251342a7ee57ba95642b7eb39e61", "2ce392291c6668598d12cd38327e24696b5ca15c")
+SUPPORTED_CONTRACT_COMMITS = (CONTRACT_COMMIT, "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

@@ -16,10 +16,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 use lifecycle manager none until a systemd adapter exists). 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.9.0"
+  version: "0.10.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "a83bec6b47776af688402c18efec507143061f68"
+  extension-commit: "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5"
 ---
 
 # Building Fabric services

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

@@ -1,11 +1,20 @@
 # fabric-service/0.1 — wire reference
 
-Pinned to `fabric-agent-contract` commit `a83bec6b47776af688402c18efec507143061f68`
+Pinned to `fabric-agent-contract` commit `8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5`
 (`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). The contract's schemas are normative;
+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 contract's schemas are normative;
 this page is the working summary. Extension key:
 `https://fabric.passioncode.ai/agent-contract/extensions/service/0.1`.
 
+## Contents
+
+- Descriptor — written by the installer
+- Well-known document
+- Events page
+- Login code and the operator session
+- Semantic rules a host applies
+
 ## Descriptor — written by the installer
 
 Directory: macOS `~/Library/Application Support/ai.passioncode.fabric/services/`,
@@ -59,6 +68,11 @@ No auth; the Host/Origin guard applies; answered from memory in under 100 ms.
   ED-9): `minWidth` 360…1280 (required), `appearance` ⊆ `scheme`, `theme`, `themes`, `kit`
   (`name@semver`), nothing else. The kits build it with `dashboard_extension()` /
   `dashboardExtension()`; see [the dashboard kit reference](dashboard-kit.md).
+- `surfaces.mcp.auth`: `descriptor` (default), `own` (DEC-0024) or `delegation` (DEC-0039, DL-16):
+  the MCP surface takes only the estate's delegation tokens, and the top-level
+  `auth.delegation {issuer, jwks}` is then required. With `own` or `delegation` the descriptor's
+  token is not an MCP credential: a host and the probe never call `/mcp` with it as a caller.
+  The kits do not verify delegation tokens yet (a later FAA-20 release).
 
 ## Events page — `GET /fabric/v1/events?after=<cursor>&limit=<n>`
 
@@ -78,11 +92,14 @@ empty, or `null` for an empty log. Retain at least seven days or 1000 events.
 path on the service origin, never an absolute URL. Optional SSE stream at
 `surfaces.events.stream` carrying the same objects.
 
-## Login code — `POST /fabric/v1/login-code`
+## Login code and the operator session — `POST /fabric/v1/login-code`
 
 Token required → `{ "url": "/fabric/v1/login?code=<16–256 url-safe chars>", "expiresAt": "…" }`,
 single use, at most 120 s, recorded as used before it is honoured. `GET` that URL →
 `Set-Cookie` `HttpOnly; SameSite=Strict`, `302` to `surfaces.dashboard.path`.
+The session it starts ends 12 h after its last use, 7 days after sign-in, on logout and when the
+descriptor token rotates (DEC-0039); a service may shorten either bound, never lengthen one. An
+ended session answers `401` on the dashboard page.
 
 ## Semantic rules a host applies
 

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

@@ -36,9 +36,11 @@ same objects — well-known document, events feed, login code — at the same pa
 - **Token**: a random value of at least 16 characters (32 bytes recommended), set as a secret;
   the same value is written on the operator's computer by `registerRemote`. Compare in constant
   time (`tokenMatches`).
-- **Session key**: 32 random bytes, a separate secret. With it, sessions survive a deploy; without
-  it, every deploy signs the operator out.
-- **Codes**: `MemoryCodeStore` — a restart forgets every outstanding code, so none can be replayed.
+- **Session key**: 32 random bytes, a separate secret; rotating it signs every operator out.
+- **Codes and sessions**: `MemoryCodeStore` — a restart forgets every outstanding code, so none
+  can be replayed, and every session record, so a deploy signs the operator out (DEC-0039: the
+  server keeps each session's last use and logout). The host signs in again on the page's `401`.
+  To keep sessions across a deploy, pass a durable store (any object with `load()` and `save()`).
   Several processes behind one origin need a shared store (a database row with the same
   "used before honoured" write); memory works for one process.
 - **Behind a router**: check the platform-set forwarded scheme; `Host` is preserved by common
@@ -68,4 +70,5 @@ reach the service, and still need its own `403`.
 
 Rotate the token by setting the new value on the platform and re-running `registerRemote` on the
 operator's computer with it; the old token stops working the moment the platform restarts with the
-new value. Rotate the session key on the platform to sign every operator out.
+new value, and so does every session begun under it when `LoginCodes` has `token=`. Rotate the
+session key on the platform to sign every operator out.

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

@@ -12,6 +12,11 @@
   for agents, `host.token` named by the descriptor), declare `surfaces.mcp.auth: "own"`, and
   make `/mcp` refuse the host's token. `check_service.py` then checks only that refusal
   (`interop.mcp-own-auth`) and leaves the caller rules NOT_RUN.
+- **Delegation (DEC-0039, DL-16).** `surfaces.mcp.auth: "delegation"` means `/mcp` takes only
+  the estate's delegation tokens; declare `auth.delegation {issuer, jwks}` in the well-known
+  document. The probe treats it like `own` and checks the declaration
+  (`auth.delegation-declared`). The kits do not verify the tokens yet; until they do, name what
+  checks them.
 - Register it into a client config with the service's own command
   (`<tool> mcp-register`), which writes `{"type":"http","url":"http://127.0.0.1:<port>/mcp","headers":{...}}`
   atomically, aborts if the file changed meanwhile, and keeps one 0600 backup. The token
@@ -50,8 +55,20 @@ else will notice it expire.
 - `POST /fabric/v1/login-code` (token) → single-use code, at most 120 s, persisted as
   used before it is honoured, burned even when expired.
 - `GET /fabric/v1/login?code=` → `HttpOnly; SameSite=Strict` cookie, 302 to the
-  dashboard. Sessions are HMAC-signed; `revoke_all` rotates the key and ends every
-  session at once.
+  dashboard. `revoke_all` rotates the session key and ends every session at once.
+- **The session's lifetime (DEC-0039).** A session ends 12 h after its last use, 7 days after
+  the code was redeemed however often it is used, on logout, and when the descriptor token
+  rotates. The server enforces all four, not the cookie: `LoginCodes` signs a claim (session
+  id, sign-in time, token revision) into the cookie and keeps a record per session (last use,
+  logout) in its code store; `session_valid` refuses a session past either bound and refreshes
+  the 12 hours on use (at most one write a minute). Pass `token=` (the descriptor token, or a
+  callable returning the current one), or a rotation goes unseen. `idle_seconds` and
+  `max_seconds` may shorten the bounds; longer values are clamped. The cookie headers default to
+  `Max-Age` 7 days, and the probe's `login.session-lifetime` fails a longer one.
+- **Logout** is the service's own route and a browser write (the custom header below):
+  `codes.logout(cookie)` ends the session for every copy of the cookie, and
+  `expired_session_cookie_header()` (`expiredSessionCookieHeader()`) clears the browser's copy.
+- An ended session answers `401` on the dashboard page itself, so the host can sign in again.
 - Browser writes need the cookie **and** a custom header such as `X-<Tool>-Request: 1`,
   which forces a preflight the service never answers.
 - A dashboard that is deliberately read-open to local pages declares

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

@@ -24,6 +24,7 @@ exist. They never call a capability.
 from __future__ import annotations
 
 import argparse
+import email.utils
 import errno
 import http.client
 import json
@@ -416,6 +417,12 @@ class Probe:
                      "the session cookie is __Host-, Secure, Path=/, no Domain" if host_bound else "cookie: %s" % cookie.split(";", 1)[0].split("=")[0])
         self.add("login.single-use", "PASS" if ok else "FAIL",
                  "first redeem HTTP %d (%s), second HTTP %d" % (status1, "cookie ok" if "HttpOnly" in cookie else "no HttpOnly cookie", status2))
+        if cookie:
+            problem = session_lifetime_problem(cookie)
+            self.add("login.session-lifetime", "FAIL" if problem else "PASS",
+                     problem or "the session cookie lives at most 7 days (DEC-0039); the server's own bounds are not observable from here")
+        else:
+            self.add("login.session-lifetime", "NOT_RUN", "no session cookie was set")
 
     # interop (fabric-interop/0.1) ----------------------------------------------------
     # #region probe-interop — docs: plugins/fabric-agent-adapter/skills/building-fabric-services/references/interop.md#what-the-probe-checks
@@ -479,21 +486,25 @@ class Probe:
             extra = sorted(set(listed) - names)
             self.add("interop.well-known-capabilities", "FAIL" if extra else "PASS",
                      ("listed but not in the manifest: " + ", ".join(extra)) if extra else "%d listed, all in the manifest" % len(listed))
-        own = bool(mcp_surface) and mcp_surface.get("auth") == "own"
+        auth = (mcp_surface or {}).get("auth")
+        # DEC-0024 own, and DEC-0039 DL-16 delegation: the descriptor's token is not an MCP credential.
+        own = bool(mcp_surface) and auth in ("own", "delegation")
+        why = "DL-16, DEC-0039" if auth == "delegation" else "DEC-0024"
+        self.delegation_declared_rule(mcp_surface)
         if own and self.token:
-            # DEC-0024: the MCP surface has credentials of its own and must refuse the host's token.
+            # The MCP surface has credentials of its own and must refuse the host's token.
             try:
                 self.mcp_call("tools/list", {})
-                self.add("interop.mcp-own-auth", "FAIL", "surfaces.mcp.auth is own, yet the MCP surface accepted the descriptor's token")
+                self.add("interop.mcp-own-auth", "FAIL", "surfaces.mcp.auth is %s, yet the MCP surface accepted the descriptor's token (%s)" % (auth, why))
             except OSError as exc:
                 refused = any(code in str(exc) for code in ("HTTP 401", "HTTP 403"))
                 self.add("interop.mcp-own-auth", "PASS" if refused else "NOT_RUN",
-                         ("the MCP surface refuses the host's token (%s), as auth: own says" % exc) if refused else str(exc))
+                         ("the MCP surface refuses the host's token (%s), as auth: %s says (%s)" % (exc, auth, why)) if refused else str(exc))
             except ValueError as exc:
                 self.add("interop.mcp-own-auth", "NOT_RUN", str(exc))
         if not mcp_surface or not self.token or own:
             reason = ("no MCP surface" if not mcp_surface
-                      else "surfaces.mcp.auth is own: the MCP surface takes its callers' credentials, not the host's token (DEC-0024)" if own
+                      else "surfaces.mcp.auth is %s: the MCP surface takes its callers' credentials, not the host's token (%s)" % (auth, why) if own
                       else "no readable token")
             for rule in ("interop.output-schema-object", "interop.tools-match", "interop.job-tools", "interop.unknown-job", "interop.trace-propagation"):
                 self.add(rule, "NOT_RUN", reason)
@@ -513,6 +524,23 @@ class Probe:
                 self.trace_rule(listing, sent)
         self.events_trace_rule(self.events)
 
+    def delegation_declared_rule(self, mcp_surface: Optional[Dict[str, Any]]) -> None:
+        """DL-16 (DEC-0039): a service that accepts delegation tokens names the issuer it trusts and its JWKS
+        in auth.delegation; with surfaces.mcp.auth delegation that declaration is required."""
+        auth = (self.wk or {}).get("auth")
+        declared = auth.get("delegation") if isinstance(auth, dict) else None
+        required = bool(mcp_surface) and mcp_surface.get("auth") == "delegation"
+        if declared is None and not required:
+            self.add("auth.delegation-declared", "NOT_RUN", "the service declares no delegation")
+            return
+        if not isinstance(declared, dict):
+            self.add("auth.delegation-declared", "FAIL", "surfaces.mcp.auth is delegation, yet auth.delegation is missing (DL-16)")
+            return
+        missing = [k for k in ("issuer", "jwks") if not isinstance(declared.get(k), str) or not declared.get(k)]
+        self.add("auth.delegation-declared", "FAIL" if missing else "PASS",
+                 ("auth.delegation lacks %s (DL-16)" % ", ".join(missing)) if missing
+                 else "auth.delegation names its issuer and JWKS (DL-16)")
+
     def object_root_rule(self, tools: Dict[str, Any]) -> None:
         """FAC-SEM-023 (DEC-0018): every listed tool's outputSchema, when present, has root type object —
         a client may refuse the whole tools/list otherwise, whatever the SDK in the tests accepted."""
@@ -728,6 +756,30 @@ class Probe:
         return self.results
 
 
+def session_lifetime_problem(set_cookie: str, now: Optional[float] = None) -> Optional[str]:
+    """DEC-0039: a session cookie set at sign-in lives at most 7 days. Max-Age wins over Expires (RFC 6265
+    §5.3); a cookie with neither ends with the browser session. None when it is within the bound."""
+    attrs = {}
+    for part in set_cookie.split(";")[1:]:
+        name, _, value = part.strip().partition("=")
+        attrs[name.strip().lower()] = value.strip()
+    bound = fs.OPERATOR_SESSION_MAX_SECONDS
+    if "max-age" in attrs:
+        if not re.fullmatch(r"-?\d+", attrs["max-age"]):
+            return "the session cookie's Max-Age %r is not a number" % attrs["max-age"]
+        if int(attrs["max-age"]) > bound:
+            return "the session cookie's Max-Age %s outlives 7 days (%d s, DEC-0039)" % (attrs["max-age"], bound)
+        return None
+    if "expires" in attrs:
+        try:
+            at = email.utils.parsedate_to_datetime(attrs["expires"]).timestamp()
+        except (TypeError, ValueError, IndexError, OverflowError):
+            return "the session cookie's Expires %r is not a date" % attrs["expires"]
+        if at - (time.time() if now is None else now) > bound:
+            return "the session cookie's Expires %s outlives 7 days (DEC-0039)" % attrs["expires"]
+    return None
+
+
 def _semver(text: str) -> Tuple[int, int, int]:
     m = re.match(r"^(\d+)\.(\d+)\.(\d+)", text or "")
     return (int(m.group(1)), int(m.group(2)), int(m.group(3))) if m else (0, 0, 0)

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

@@ -707,15 +707,41 @@ export function pruneReleases(releasesDir, { keep = 2, current } = {}) {
 
 // --- operator login -------------------------------------------------------------------
 
+/** DEC-0039 (service.md "The session's lifetime"): the longest a service may keep an operator session. */
+export const OPERATOR_SESSION_IDLE_SECONDS = 12 * 60 * 60;
+export const OPERATOR_SESSION_MAX_SECONDS = 7 * 24 * 60 * 60;
+
+// Compare bytes, not UTF-16 units: a non-ASCII value of the right length must be a refusal, not a RangeError.
+const safeEqual = (a, b) => {
+  const x = Buffer.from(String(a)), y = Buffer.from(String(b));
+  return x.length === y.length && crypto.timingSafeEqual(x, y);
+};
+const sessionBound = (value, longest) => {
+  if (typeof value !== 'number' || !Number.isFinite(value)) throw new ServiceError('a session bound must be a finite number of seconds.');
+  return Math.min(Math.trunc(value), longest);
+};
+
+// Single-use login codes, and operator sessions with the DEC-0039 lifetime: a session ends 12 h after its
+// last use, 7 days after the code was redeemed, on logout, and when the descriptor token rotates. The server
+// enforces all four: the cookie carries a signed claim (session id, sign-in time, token revision) and the
+// code store keeps a record per session (last use, logout). Rotating the key with revokeAll() ends every one.
 export class LoginCodes {
-  // `stateDir` — a local service keeps codes and the session key in files. An online service
-  // (DEC-0019) usually has no durable disk: pass `stateDir = null` with `{ store, key }` — `store`
-  // like `new MemoryCodeStore()` (a restart forgets every code, so none can be replayed) and
-  // `key` a Buffer from a platform secret, so sessions survive a deploy.
-  constructor(stateDir, ttlSeconds = 120, { store = null, key = null } = {}) {
+  // `stateDir` — a local service keeps codes, sessions and the session key in files. An online service
+  // (DEC-0019) usually has no durable disk: pass `stateDir = null` with `{ store, key }` — `store` like
+  // `new MemoryCodeStore()` and `key` a Buffer from a platform secret. A memory store forgets codes AND
+  // sessions on a restart, so a deploy signs the operator out (the host signs in again on the page's 401);
+  // pass a durable store to keep sessions. `token` is the descriptor token, or a function returning the
+  // current one: a session begun under one token is refused once it rotates. A service MAY shorten
+  // `idleSeconds` or `maxSeconds`, never lengthen them.
+  constructor(stateDir, ttlSeconds = 120, { store = null, key = null, token = null,
+    idleSeconds = OPERATOR_SESSION_IDLE_SECONDS, maxSeconds = OPERATOR_SESSION_MAX_SECONDS, clock = () => Date.now() / 1000 } = {}) {
     this.ttl = Math.min(ttlSeconds, 120);
+    this.idleSeconds = sessionBound(idleSeconds, OPERATOR_SESSION_IDLE_SECONDS);
+    this.maxSeconds = sessionBound(maxSeconds, OPERATOR_SESSION_MAX_SECONDS);
     this.store = store;
     this.fixedKey = key;
+    this.token = token;
+    this.clock = clock;
     if (stateDir) {
       this.dir = ensurePrivateDir(stateDir);
       this.keyPath = path.join(this.dir, 'session.key');
@@ -738,7 +764,7 @@ export class LoginCodes {
   }
 
   save(codes) {
-    const horizon = Date.now() / 1000 - 3600;
+    const horizon = this.clock() - 3600;
     const kept = Object.fromEntries(Object.entries(codes).filter(([, v]) => (v.expires ?? 0) > horizon));
     if (this.store) { this.store.save(kept); return; }
     atomicWrite(this.codesPath, JSON.stringify(kept), 0o600);
@@ -746,7 +772,7 @@ export class LoginCodes {
 
   issue() {
     const code = crypto.randomBytes(24).toString('base64url');
-    const expires = Date.now() / 1000 + this.ttl;
+    const expires = this.clock() + this.ttl;
     const codes = this.load();
     codes[crypto.createHash('sha256').update(code).digest('hex')] = { expires, used: false };
     this.save(codes);
@@ -762,19 +788,66 @@ export class LoginCodes {
     if (!entry || entry.used) return null;
     entry.used = true;
     this.save(codes);
-    if (entry.expires < Date.now() / 1000) return null;
+    const now = this.clock();
+    if (entry.expires < now) return null;
     const session = crypto.randomBytes(18).toString('base64url');
-    return `${session}.${crypto.createHmac('sha256', this.key()).update(session).digest('hex')}`;
+    const signedInAt = Math.trunc(now);
+    codes[LoginCodes.recordKey(session)] = { expires: signedInAt + this.maxSeconds, signedInAt, lastUsedAt: now };
+    this.save(codes);
+    const claim = `v2.${session}.${signedInAt}.${this.tokenRevision()}`;
+    return `${claim}.${this.mac(claim)}`;
   }
 
+  /** True while the session is live; a use within the bounds refreshes the idle bound. */
   sessionValid(value) {
-    if (!value || !value.includes('.')) return false;
-    const i = value.lastIndexOf('.');
-    const expected = crypto.createHmac('sha256', this.key()).update(value.slice(0, i)).digest('hex');
-    const mac = value.slice(i + 1);
-    return mac.length === expected.length && crypto.timingSafeEqual(Buffer.from(mac), Buffer.from(expected));
+    const parsed = this.parse(value);
+    if (!parsed) return false;
+    const [session, signedInAt] = parsed;
+    const now = this.clock();
+    if (now >= signedInAt + this.maxSeconds) return false;
+    const codes = this.load();
+    const record = codes[LoginCodes.recordKey(session)];
+    if (!record || record.signedInAt !== signedInAt || record.loggedOutAt != null) return false;
+    const last = Number(record.lastUsedAt ?? 0);
+    if (now >= last + this.idleSeconds) return false;
+    if (now - last >= Math.min(60, Math.max(1, Math.trunc(this.idleSeconds / 10)))) {
+      record.lastUsedAt = now;
+      this.save(codes);
+    }
+    return true;
   }
 
+  /** End this session on the server; clear the browser's copy with expiredSessionCookieHeader(). */
+  logout(value) {
+    const parsed = this.parse(value);
+    if (!parsed) return false;
+    const codes = this.load();
+    const record = codes[LoginCodes.recordKey(parsed[0])];
+    if (!record || record.signedInAt !== parsed[1] || record.loggedOutAt != null) return false;
+    record.loggedOutAt = this.clock();
+    this.save(codes);
+    return true;
+  }
+
+  parse(value) {
+    if (typeof value !== 'string' || !/^[\x21-\x7e]*$/.test(value)) return null;
+    const parts = value.split('.');
+    if (parts.length !== 5 || parts[0] !== 'v2' || !parts[1] || !/^\d+$/.test(parts[2])) return null;
+    if (!safeEqual(parts[4], this.mac(parts.slice(0, 4).join('.')))) return null;
+    if (!safeEqual(parts[3], this.tokenRevision())) return null;
+    return [parts[1], Number(parts[2])];
+  }
+
+  mac(claim) { return crypto.createHmac('sha256', this.key()).update(claim).digest('hex'); }
+
+  tokenRevision() {
+    const token = typeof this.token === 'function' ? this.token() : this.token;
+    if (!token) return '-';
+    return crypto.createHmac('sha256', this.key()).update(`token-revision\0${token}`).digest('hex').slice(0, 16);
+  }
+
+  static recordKey(session) { return `s:${crypto.createHash('sha256').update(session).digest('hex')}`; }
+
   revokeAll() {
     if (this.fixedKey) throw new ServiceError('a platform-held session key is rotated on the platform, not here.');
     atomicWrite(this.keyPath, crypto.randomBytes(32), 0o600);
@@ -788,9 +861,12 @@ export class MemoryCodeStore {
   save(codes) { this.codes = JSON.parse(JSON.stringify(codes)); }
 }
 
-export const sessionCookieHeader = (value, maxAge = 30 * 86400) => `${SESSION_COOKIE}=${value}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${maxAge}`;
+/** The cookie lives no longer than the absolute bound (DEC-0039); the server ends it sooner. */
+export const sessionCookieHeader = (value, maxAge = OPERATOR_SESSION_MAX_SECONDS) => `${SESSION_COOKIE}=${value}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${maxAge}`;
 /** DEC-0019: the remote cookie — `__Host-` name, Secure, no Domain, Path=/. */
-export const remoteSessionCookieHeader = (value, maxAge = 30 * 86400) => `${REMOTE_SESSION_COOKIE}=${value}; Path=/; Secure; HttpOnly; SameSite=Strict; Max-Age=${maxAge}`;
+export const remoteSessionCookieHeader = (value, maxAge = OPERATOR_SESSION_MAX_SECONDS) => `${REMOTE_SESSION_COOKIE}=${value}; Path=/; Secure; HttpOnly; SameSite=Strict; Max-Age=${maxAge}`;
+/** The header that clears the browser's session cookie, sent with a logout. */
+export const expiredSessionCookieHeader = (remote = false) => (remote ? remoteSessionCookieHeader : sessionCookieHeader)('', 0);
 
 /**
  * DEC-0019: the request guard of an online service. `origin` is the service's own origin

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

@@ -63,6 +63,9 @@ DEFAULT_EXIT_TIMEOUT = 15
 LOG_MAX_BYTES = 5 * 1024 * 1024
 LOG_BACKUPS = 5
 LOGIN_CODE_TTL_SECONDS = 120
+# DEC-0039 (service.md "The session's lifetime"): the longest a service may keep an operator session.
+OPERATOR_SESSION_IDLE_SECONDS = 12 * 60 * 60
+OPERATOR_SESSION_MAX_SECONDS = 7 * 24 * 60 * 60
 EVENTS_DEFAULT_LIMIT = 50
 EVENTS_MAX_LIMIT = 200
 LEVELS = ("info", "notice", "warning", "error")
@@ -1203,17 +1206,35 @@ class Drain:
 # --- operator login ----------------------------------------------------------
 
 class LoginCodes:
-    """Single-use login codes (<=120 s), recorded as used BEFORE they are honoured,
-    and HMAC-signed session cookies revoked by rotating the key."""
+    """Single-use login codes (<=120 s), recorded as used BEFORE they are honoured, and operator
+    sessions with the DEC-0039 lifetime: a session ends 12 h after its last use, 7 days after the code
+    was redeemed, on logout, and when the descriptor token rotates. The server enforces all four: the
+    cookie carries a signed claim (session id, sign-in time, token revision) and the code store keeps a
+    record per session (last use, logout). Rotating the key with revoke_all() ends every session."""
 
     def __init__(self, state_dir: Optional[Path], ttl: int = LOGIN_CODE_TTL_SECONDS, *,
-                 store: Optional["MemoryCodeStore"] = None, key: Optional[bytes] = None):
-        # A local service keeps codes and the key in files. An online one (DEC-0019) usually has no
-        # durable disk: pass state_dir=None with store=MemoryCodeStore() (a restart forgets every
-        # code, so none can be replayed) and key= bytes from a platform secret (sessions survive a deploy).
+                 store: Optional["MemoryCodeStore"] = None, key: Optional[bytes] = None,
+                 token: "Optional[str | Callable[[], str]]" = None,
+                 idle_seconds: int = OPERATOR_SESSION_IDLE_SECONDS,
+                 max_seconds: int = OPERATOR_SESSION_MAX_SECONDS,
+                 clock: Callable[[], float] = time.time):
+        # A local service keeps codes, sessions and the key in files. An online one (DEC-0019) usually has
+        # no durable disk: pass state_dir=None with store=MemoryCodeStore() and key= bytes from a platform
+        # secret. A memory store forgets codes AND sessions on a restart, so a deploy signs the operator
+        # out (the host signs in again on the page's 401); pass a durable store to keep sessions.
+        # token= is the descriptor token, or a callable returning the current one: a session begun under
+        # one token is refused once it rotates. A service MAY shorten either bound, never lengthen one.
         self.ttl = min(ttl, LOGIN_CODE_TTL_SECONDS)
+        self.idle_seconds = _session_bound(idle_seconds, OPERATOR_SESSION_IDLE_SECONDS)
+        self.max_seconds = _session_bound(max_seconds, OPERATOR_SESSION_MAX_SECONDS)
+        # One lock around every load-modify-save, so a concurrent refresh never saves over a logout or a
+        # burned code (a threading server checks sessions on several threads; the instance lock keeps
+        # other processes out of the state directory).
+        self._lock = threading.RLock()
         self._store = store
         self._fixed_key = key
+        self._token = token
+        self._clock = clock
         if state_dir is not None:
             self.dir = ensure_private_dir(Path(state_dir))
             self._key_path = self.dir / "session.key"
@@ -1239,7 +1260,7 @@ class LoginCodes:
             return {}
 
     def _save(self, codes: Dict[str, Any]) -> None:
-        horizon = time.time() - 3600
+        horizon = self._clock() - 3600
         codes = {k: v for k, v in codes.items() if v.get("expires", 0) > horizon}
         if self._store is not None:
             self._store.save(codes)
@@ -1247,39 +1268,101 @@ class LoginCodes:
         atomic_write(self._codes_path, json.dumps(codes).encode(), 0o600)
 
     def issue(self) -> Dict[str, str]:
-        code = secrets.token_urlsafe(24)
-        expires = time.time() + self.ttl
-        codes = self._load()
-        codes[hashlib.sha256(code.encode()).hexdigest()] = {"expires": expires, "used": False}
-        self._save(codes)
-        at = _dt.datetime.fromtimestamp(expires, _dt.timezone.utc).replace(microsecond=0)
-        return {"url": "/fabric/v1/login?code=" + code, "expiresAt": at.isoformat().replace("+00:00", "Z")}
+        with self._lock:
+            code = secrets.token_urlsafe(24)
+            expires = self._clock() + self.ttl
+            codes = self._load()
+            codes[hashlib.sha256(code.encode()).hexdigest()] = {"expires": expires, "used": False}
+            self._save(codes)
+            at = _dt.datetime.fromtimestamp(expires, _dt.timezone.utc).replace(microsecond=0)
+            return {"url": "/fabric/v1/login?code=" + code, "expiresAt": at.isoformat().replace("+00:00", "Z")}
 
     def redeem(self, code: Optional[str]) -> Optional[str]:
         """Return a session cookie value, or None. The code is burned even when it has expired."""
-        if not code or not _CODE.match(code):
+        with self._lock:
+            if not code or not _CODE.match(code):
+                return None
+            digest = hashlib.sha256(code.encode()).hexdigest()
+            codes = self._load()
+            entry = codes.get(digest)
+            if not entry or entry.get("used"):
+                return None
+            entry["used"] = True
+            self._save(codes)
+            now = self._clock()
+            if entry.get("expires", 0) < now:
+                return None
+            session_id = secrets.token_urlsafe(18)
+            signed_in = int(now)
+            codes[self._record_key(session_id)] = {"expires": signed_in + self.max_seconds,
+                                                   "signedInAt": signed_in, "lastUsedAt": now}
+            self._save(codes)
+            claim = "v2.%s.%d.%s" % (session_id, signed_in, self._token_revision())
+            return claim + "." + self._mac(claim)
+
+    def session_valid(self, cookie_value: Optional[str]) -> bool:
+        """True while the session is live; a use within the bounds refreshes the idle bound."""
+        with self._lock:
+            parsed = self._parse(cookie_value)
+            if parsed is None:
+                return False
+            session_id, signed_in = parsed
+            now = self._clock()
+            if now >= signed_in + self.max_seconds:
+                return False
+            codes = self._load()
+            record = codes.get(self._record_key(session_id))
+            if not record or record.get("signedInAt") != signed_in or record.get("loggedOutAt") is not None:
+                return False
+            last = float(record.get("lastUsedAt", 0))
+            if now >= last + self.idle_seconds:
+                return False
+            if now - last >= min(60, max(1, self.idle_seconds // 10)):
+                record["lastUsedAt"] = now
+                self._save(codes)
+            return True
+
+    def logout(self, cookie_value: Optional[str]) -> bool:
+        """End this session on the server: every copy of the cookie is refused from now on. Clear the
+        browser's copy with expired_session_cookie_header(). False when there was no live record."""
+        with self._lock:
+            parsed = self._parse(cookie_value)
+            if parsed is None:
+                return False
+            codes = self._load()
+            record = codes.get(self._record_key(parsed[0]))
+            if not record or record.get("signedInAt") != parsed[1] or record.get("loggedOutAt") is not None:
+                return False
+            record["loggedOutAt"] = self._clock()
+            self._save(codes)
+            return True
+
+    def _parse(self, cookie_value: Optional[str]) -> Optional[Tuple[str, int]]:
+        """The signed claim of a cookie under the current key and token, or None."""
+        if not isinstance(cookie_value, str) or not cookie_value.isascii():
+            return None
+        parts = cookie_value.split(".")
+        if len(parts) != 5 or parts[0] != "v2" or not parts[1] or not parts[2].isdigit():
             return None
-        digest = hashlib.sha256(code.encode()).hexdigest()
-        codes = self._load()
-        entry = codes.get(digest)
-        if not entry or entry.get("used"):
+        claim, mac = ".".join(parts[:4]), parts[4]
+        if not hmac.compare_digest(mac, self._mac(claim)):
             return None
-        entry["used"] = True
-        self._save(codes)
-        if entry.get("expires", 0) < time.time():
+        if not hmac.compare_digest(parts[3], self._token_revision()):
             return None
-        return self._sign(secrets.token_urlsafe(18))
+        return parts[1], int(parts[2])
 
-    def _sign(self, session_id: str) -> str:
-        mac = hmac.new(self._key(), session_id.encode(), hashlib.sha256).hexdigest()
-        return session_id + "." + mac
+    def _mac(self, claim: str) -> str:
+        return hmac.new(self._key(), claim.encode(), hashlib.sha256).hexdigest()
 
-    def session_valid(self, cookie_value: Optional[str]) -> bool:
-        if not cookie_value or "." not in cookie_value:
-            return False
-        session_id, mac = cookie_value.rsplit(".", 1)
-        expected = hmac.new(self._key(), session_id.encode(), hashlib.sha256).hexdigest()
-        return hmac.compare_digest(mac, expected)
+    def _token_revision(self) -> str:
+        token = self._token() if callable(self._token) else self._token
+        if not token:
+            return "-"
+        return hmac.new(self._key(), b"token-revision\0" + token.encode(), hashlib.sha256).hexdigest()[:16]
+
+    @staticmethod
+    def _record_key(session_id: str) -> str:
+        return "s:" + hashlib.sha256(session_id.encode()).hexdigest()
 
     def revoke_all(self) -> None:
         if self._fixed_key is not None:
@@ -1287,6 +1370,13 @@ class LoginCodes:
         atomic_write(self._key_path, secrets.token_bytes(32), 0o600)
 
 
+def _session_bound(value: Any, longest: int) -> int:
+    """A session bound in seconds: a finite number, never longer than the contract's (DEC-0039)."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or value != value or value in (float("inf"), float("-inf")):
+        raise ServiceError("a session bound must be a finite number of seconds.")
+    return min(int(value), longest)
+
+
 class MemoryCodeStore:
     """DEC-0019: a login-code store held in memory — for an online service with no durable disk."""
 
@@ -1304,15 +1394,21 @@ SESSION_COOKIE = "fabric_session"
 REMOTE_SESSION_COOKIE = "__Host-fabric_session"
 
 
-def session_cookie_header(value: str, max_age: int = 30 * 86400) -> str:
+def session_cookie_header(value: str, max_age: int = OPERATOR_SESSION_MAX_SECONDS) -> str:
+    """The cookie lives no longer than the absolute bound (DEC-0039); the server ends it sooner."""
     return "%s=%s; Path=/; HttpOnly; SameSite=Strict; Max-Age=%d" % (SESSION_COOKIE, value, max_age)
 
 
-def remote_session_cookie_header(value: str, max_age: int = 30 * 86400) -> str:
+def remote_session_cookie_header(value: str, max_age: int = OPERATOR_SESSION_MAX_SECONDS) -> str:
     """DEC-0019: the remote cookie — __Host- name, Secure, no Domain, Path=/."""
     return "%s=%s; Path=/; Secure; HttpOnly; SameSite=Strict; Max-Age=%d" % (REMOTE_SESSION_COOKIE, value, max_age)
 
 
+def expired_session_cookie_header(remote: bool = False) -> str:
+    """The header that clears the browser's session cookie, sent with a logout."""
+    return (remote_session_cookie_header if remote else session_cookie_header)("", 0)
+
+
 def check_remote_request(origin: str, host: Optional[str], request_origin: Optional[str] = None,
                          sec_fetch_site: Optional[str] = None, forwarded_proto: Optional[str] = None) -> Optional[str]:
     """DEC-0019: the request guard of an online service; returns the refusal sentence or None.

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

@@ -27,7 +27,9 @@ if (!origin || k.remoteOriginProblems(origin).length) { console.error(`origin: $
 if (token.length < 16) { console.error('the service token is missing or shorter than 16 characters'); process.exit(2); }
 
 const startedAt = k.nowIso();
-const codes = new k.LoginCodes(null, 120, { store: new k.MemoryCodeStore(), key });
+// DEC-0039: sessions end 12 h after last use, 7 days after sign-in, on logout and when the token rotates.
+// The memory store forgets them on a deploy; the host signs in again on the page's 401.
+const codes = new k.LoginCodes(null, 120, { store: new k.MemoryCodeStore(), key, token });
 const events = [k.makeEvent('1', startedAt, 'service.started', 'info', 'The example agent started.')];
 const tlsSelf = Boolean(args['tls-cert']);
 
@@ -65,6 +67,12 @@ function handler(req, res) {
     if (!session) return send(res, 403, 'This login link has expired or was used. Open the dashboard from Fabric again.', { 'Content-Type': 'text/plain; charset=utf-8' });
     return send(res, 302, null, { Location: '/', 'Set-Cookie': k.remoteSessionCookieHeader(session) });
   }
+  if (req.method === 'POST' && url.pathname === '/logout') {
+    // A browser write: the custom header keeps another site's form from signing the operator out.
+    if (req.headers['x-fabric-request'] !== '1') return send(res, 403, 'Missing request header.', { 'Content-Type': 'text/plain; charset=utf-8' });
+    codes.logout(k.cookieValue(req.headers.cookie, k.REMOTE_SESSION_COOKIE));
+    return send(res, 204, null, { 'Set-Cookie': k.expiredSessionCookieHeader(true) });
+  }
   if (req.method === 'GET' && url.pathname === '/') {
     if (!codes.sessionValid(k.cookieValue(req.headers.cookie, k.REMOTE_SESSION_COOKIE))) return send(res, 401, 'Sign in from Fabric Dashboards.', { 'Content-Type': 'text/plain; charset=utf-8' });
     return send(res, 200, '<!doctype html><meta charset="utf-8"><title>Example Agent</title><h1>Example Agent</h1>', { 'Content-Type': 'text/html; charset=utf-8', 'Content-Security-Policy': "default-src 'none'" });

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

@@ -84,7 +84,8 @@ class Service:
         self.log = fs.JsonlEventLog(self.data / "events.jsonl")
         self.usage = fs.JsonlUsageLedger(self.data / "usage.jsonl")  # DEC-0021
         self.usage.prune()
-        self.codes = fs.LoginCodes(self.data / "auth")
+        # DEC-0039: the token= revision ends sessions begun under a token that has since rotated.
+        self.codes = fs.LoginCodes(self.data / "auth", token=self.token)
         self.jobs = fi.JobStore(self.data / "jobs")
         self.mcp = fi.McpToolServer(self.id, VERSION, jobs=self.jobs, on_job_started=self.draft_started, on_input=self.draft_answered)
         for cap in CAPABILITIES:
@@ -255,6 +256,12 @@ def make_handler(svc: Service):
                 if not self._token_ok():
                     return
                 return self._send(200, svc.codes.issue())
+            if url.path == "/logout":
+                # A browser write: the custom header keeps another site's form from signing the operator out.
+                if self.headers.get("X-Fabric-Request") != "1":
+                    return self._send(403, {"error": "Missing request header."})
+                svc.codes.logout(fs.cookie_value(self.headers.get("Cookie")))
+                return self._send(204, None, {"Set-Cookie": fs.expired_session_cookie_header()})
             if url.path == "/api/emit":
                 if not (self._session_ok() or fs.token_matches(self.headers.get("Authorization"), svc.token)):
                     return self._send(401, {"error": "Sign in first."})

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.9.0"
+  version: "0.10.0"
   contract-version: "0.1.0"
-  contract-commit: "a83bec6b47776af688402c18efec507143061f68"
+  contract-commit: "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5"
 ---
 
 # Creating Fabric-compatible agents
@@ -119,7 +119,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py
   --schema-base <immutable-base-uri>
 ```
 
-Pin exactly contract `0.1.0` at commit `a83bec6b47776af688402c18efec507143061f68` and
+Pin exactly contract `0.1.0` at commit `8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5` 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