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

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

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""Create a Fabric agent project with the contract built in, in one command (FAA-270, North Star G21).
+
+  python3 new_agent.py <folder> --id <agent-id> [--profile mcp|a2a|local-runner] [--service]
+                       [--capability NAME] [--effect CLASS] [--force] [--json]
+
+It writes, into an empty (or new) folder:
+
+- the provider bundle `adapt_project.py scaffold` writes, pinned to the contract (`fabric-agent.json`,
+  `fabric-contract.lock.json`, `fabric/`), every value it invents a sentinel `adapt_project.py check` names;
+- `fabric.source.json`, the agent's source manifest (DEC-0149, `fabric-source/1`): what is source, default deny, and the
+  slots an installation fills (the publisher's URI behind `provider.createdBy`, the placement record and, for a
+  service, its supervisor label and port), never a value;
+- the placement guard (`src/placement.py`, with its tests in `tests/`): at start the agent reads Project Observatory's
+  placement record (`observatory-placement/1`) and refuses to start where the record places it on another machine,
+  starts degraded when it cannot read it, and starts when there is none; `config/placement.example.json` shows the
+  record's shape on neutral values;
+- `README.md`, `LICENSE` (all rights reserved until the owner names the terms), `.gitignore`;
+- with `--service`: `service/`, the service kit's sample (`service.py`, a fabric-service/0.1 service with one capability
+  and a job) and the kit modules it imports, copied by `fabric_kit.py install`, whose digests `fabric_kit.py status`
+  checks later.
+
+A repeat with the same arguments in a folder this command made changes nothing and answers the same line. A folder that
+holds anything else is refused unless `--force`, which writes the planned files over it and leaves every other file as
+it is. The last stdout line is `{"folder": "<path>", "id": "<id>", "profile": "<profile>", "service": <bool>,
+"created": [<paths>], "repeated": <bool>}` (`--json` prints only it). Exit 0 made or already made, 1 refused (the
+reason on stderr), 2 usage. Writes nothing outside the folder; reads no key and no instance data. Standard library only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import re
+import shutil
+import sys
+from typing import Any, Dict, List, Optional, Sequence
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import adapt_project as ap  # noqa: E402 - the scaffolder and the source manifest, beside this file
+
+VERSION = "0.1.0"
+RECORD = "fabric/new-agent.json"
+#: The agent's id: the package's `name` grammar (`fabric-package.schema.json#/$defs/name`), kebab case.
+AGENT_ID = re.compile(r"[a-z][a-z0-9]*(?:-[a-z0-9]+)*\Z")
+CAPABILITY = re.compile(r"[a-z][a-z0-9._-]{1,127}\Z")
+KIT = HERE.parent.parent / "building-fabric-services" / "scripts"
+#: What the sample service imports; `fabric_kit.py install` copies each one's closure.
+SERVICE_MODULES = ("fabric_service", "fabric_interop", "fabric_board", "fabric_hub")
+
+
+class Refused(Exception):
+    """The folder cannot be made as asked; the reason is printed, never a value."""
+
+
+PLACEMENT_PY = '''"""The placement guard: at start, before the agent polls, schedules or listens, it reads Project Observatory's
+placement record and runs only on the machine that record names (creating-fabric-agents, where-agents-run.md).
+
+    verdict(service_id, label) -> {"state": "ok" | "placed-elsewhere" | "placement-unreadable", "machine"?}
+
+`placed-elsewhere`: the record's `elsewhere` list names this agent (its `serviceId` or its supervisor `label`) on a
+machine that is not this one: refuse to start, log one line, report it as degraded. `placement-unreadable`: the file is
+there and cannot be read, or is of another schema: start, and report it as degraded. No file: start.
+"""
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+SCHEMA = "observatory-placement/1"
+
+
+def placement_path(env: Optional[Dict[str, str]] = None) -> Path:
+    env = os.environ if env is None else env
+    base = env.get("XDG_DATA_HOME") or ""
+    root = Path(base) if os.path.isabs(base) else Path.home() / ".local" / "share"
+    return root / "project-observatory" / "placement.json"
+
+
+def verdict(service_id: str, label: str, path: Optional[Path] = None) -> Dict[str, Any]:
+    path = placement_path() if path is None else path
+    try:
+        data = path.read_bytes()
+    except FileNotFoundError:
+        return {"state": "ok"}
+    except OSError:
+        return {"state": "placement-unreadable"}
+    try:
+        doc = json.loads(data.decode("utf-8"))
+    except ValueError:
+        return {"state": "placement-unreadable"}
+    if not isinstance(doc, dict) or doc.get("schema") != SCHEMA or not isinstance(doc.get("elsewhere"), list):
+        return {"state": "placement-unreadable"}
+    for entry in doc["elsewhere"]:
+        if not isinstance(entry, dict):
+            continue
+        ours = (service_id and entry.get("serviceId") == service_id) or (label and entry.get("label") == label)
+        if ours and entry.get("placedOn") and entry.get("placedOn") != doc.get("machine"):
+            return {"state": "placed-elsewhere", "machine": entry.get("placedOn")}
+    return {"state": "ok"}
+'''
+
+PLACEMENT_TEST = '''"""The placement guard: one copy placed elsewhere refuses, one with no file and one with a malformed file start."""
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+import placement  # noqa: E402
+
+EXAMPLE = Path(__file__).resolve().parents[1] / "config" / "placement.example.json"
+
+
+class PlacementTests(unittest.TestCase):
+    def setUp(self):
+        self.folder = tempfile.TemporaryDirectory()
+        self.addCleanup(self.folder.cleanup)
+        self.path = Path(self.folder.name) / "placement.json"
+
+    def test_placed_elsewhere_refuses(self):
+        self.path.write_text(EXAMPLE.read_text(encoding="utf-8"), encoding="utf-8")
+        found = placement.verdict("{service_id}", "{label}", self.path)
+        self.assertEqual(found["state"], "placed-elsewhere")
+
+    def test_no_file_starts(self):
+        self.assertEqual(placement.verdict("{service_id}", "{label}", self.path), {{"state": "ok"}})
+
+    def test_a_malformed_file_starts_degraded(self):
+        self.path.write_text("{{not json", encoding="utf-8")
+        self.assertEqual(placement.verdict("{service_id}", "{label}", self.path), {{"state": "placement-unreadable"}})
+        self.path.write_text(json.dumps({{"schema": "another/1"}}), encoding="utf-8")
+        self.assertEqual(placement.verdict("{service_id}", "{label}", self.path)["state"], "placement-unreadable")
+
+    def test_placed_on_this_machine_starts(self):
+        doc = json.loads(EXAMPLE.read_text(encoding="utf-8"))
+        doc["machine"] = doc["elsewhere"][0]["placedOn"]
+        self.path.write_text(json.dumps(doc), encoding="utf-8")
+        self.assertEqual(placement.verdict("{service_id}", "{label}", self.path), {{"state": "ok"}})
+
+
+if __name__ == "__main__":
+    unittest.main()
+'''
+
+README = '''# {agent_id}
+
+A Fabric agent made with the Fabric Agent Adapter's `new` command, contract `{contract}` at `{commit}`.
+
+## Layout
+
+- `fabric-agent.json`, `fabric-contract.lock.json`, `fabric/`: the provider bundle, pinned to the contract. Every value
+  the scaffold invented is a sentinel: `adapt_project.py check` names each one until it is replaced.
+- `fabric.source.json`: the agent's source manifest (DEC-0149): what is source, and the slots an installation fills,
+  never a value. `fabric_source_check.py check .` reads the source under it (exit 0 before every release).
+- `src/placement.py`: the placement guard the agent runs at start, before it polls, schedules or listens.
+{service_line}
+## Configure
+
+Keys are read by name from the environment or the secret store, never from a file of this repository. Slots:
+{slots}
+
+## Data
+
+The agent's data lives apart from this source, in its data home (`<agent>-data`, or the service kit's folders), from
+the first commit.
+'''
+
+GITIGNORE = """# the instance: real configuration, keys and what running the agent leaves
+config/*.json
+!config/*.example.json
+.env
+.env.*
+!.env.example
+*.token
+*.credential
+__pycache__/
+*.pyc
+"""
+
+
+def _placement_example(service_id: str, label: str) -> str:
+    return ap._json_text({"schema": "observatory-placement/1", "machine": "example-machine-a", "updatedAt": "2026-01-01T00:00:00Z",
+                          "elsewhere": [{"label": label, "serviceId": service_id, "placedOn": "example-machine-b",
+                                         "since": "2026-01-01T00:00:00Z", "by": "full machine-move leave"}]})
+
+
+def plan(args: argparse.Namespace) -> Dict[str, str]:
+    """Every file the command writes, by its path, with its text (the scaffold's own included)."""
+    agent_id = args.id
+    capability = args.capability or "%s.run" % agent_id.replace("-", "_")
+    if not CAPABILITY.match(capability):
+        raise Refused("--capability %r is not a capability name (lower case, `domain.action`)" % capability)
+    scaffold = argparse.Namespace(
+        profile=args.profile, provider_id="urn:fabric:provider:%s" % agent_id, provider_name=agent_id,
+        capability_id="urn:fabric:capability:%s" % capability, capability_name=capability,
+        schema_base="https://replace.invalid/%s/schemas" % agent_id, mcp_mode="streamable-http",
+        mcp_url="https://replace.invalid/mcp", agent_card_url="https://replace.invalid/.well-known/agent-card.json",
+        runner_kind="replace-me", executable_ref="urn:executable:replace-me", runtime_arg=[], effect=args.effect,
+        idempotency="none", cost_preset=[], default_cost_preset=None, job=False, created_by=None, identity_method=None,
+        data_class=[], probe_assertion=[])
+    files = dict(ap._generated_files(scaffold))
+    service_id = "%s.default" % agent_id
+    label = "com.example.%s" % agent_id
+    include = ["README.md", "LICENSE", ".gitignore", "src/", "tests/", "config/placement.example.json",
+               "fabric-agent.json", "fabric-contract.lock.json", "fabric/"] + (["service/"] if args.service else [])
+    manifest = ap.source_manifest(include, "%s, a Fabric agent" % agent_id, service=args.service)
+    slots = "\n".join("- `%s` (%s%s): %s" % (s["name"], s["kind"], ", optional" if s.get("optional") else "", s["purpose"])
+                      for s in manifest["slots"])
+    files.update({
+        ap.SOURCE_FILE: ap._json_text(manifest),
+        "README.md": README.format(agent_id=agent_id, contract=ap.CONTRACT_VERSION, commit=ap.CONTRACT_COMMIT[:12], slots=slots,
+                                   service_line="- `service/`: the service kit's sample, run as `python3 service/service.py "
+                                   "serve --id %s --port <port> --data-dir <data>`, and the kit modules it imports.\n" % agent_id
+                                   if args.service else ""),
+        "LICENSE": "Copyright (c) the owner of %s. All rights reserved, until the owner names other terms.\n" % agent_id,
+        ".gitignore": GITIGNORE,
+        "src/placement.py": PLACEMENT_PY,
+        "tests/test_placement.py": PLACEMENT_TEST.format(service_id=service_id, label=label),
+        "config/placement.example.json": _placement_example(service_id, label),
+    })
+    record = {"tool": "fabric-agent-adapter new %s" % VERSION, "id": agent_id, "profile": args.profile, "service": args.service,
+              "capability": capability, "effect": args.effect, "contract": ap.CONTRACT_COMMIT}
+    files[RECORD] = ap._json_text(record)
+    return files
+
+
+def _service_files(folder: Path) -> List[str]:
+    """Copy the kit's sample and the closure of what it imports into `service/` (fabric_kit.py install)."""
+    import importlib.util
+    found = importlib.util.spec_from_file_location("fabric_kit", KIT / "fabric_kit.py")  # the kit's own installer
+    fabric_kit = importlib.util.module_from_spec(found)
+    found.loader.exec_module(fabric_kit)  # type: ignore[union-attr]
+    target = folder / "service"
+    result = fabric_kit.install(target, "python", list(SERVICE_MODULES))
+    if result["refused"]:
+        raise Refused("service/ holds kit modules this kit does not recognise: %s" % ", ".join(result["refused"]))
+    shutil.copyfile(KIT / "sample_service.py", target / "service.py")
+    return ["service/" + name for name in result["copied"] + result["kept"]] + ["service/service.py"]
+
+
+def make(folder: Path, args: argparse.Namespace) -> Dict[str, Any]:
+    if not AGENT_ID.match(args.id) or len(args.id) > 64:
+        raise Refused("--id %r is not an agent id (lower case words joined by -, at most 64 characters)" % args.id)
+    files = plan(args)
+    answer = {"folder": str(folder), "id": args.id, "profile": args.profile, "service": args.service}
+    if folder.exists() and not folder.is_dir():
+        raise Refused("%s is not a folder" % folder.name)
+    present = sorted(p.relative_to(folder).as_posix() for p in folder.rglob("*")) if folder.is_dir() else []
+    if present:
+        record = folder / RECORD
+        try:
+            same = record.is_file() and json.loads(record.read_text(encoding="utf-8")) == json.loads(files[RECORD])
+        except ValueError:
+            same = False
+        if same and all((folder / path).is_file() for path in files) and not args.force:
+            return dict(answer, created=[], repeated=True)
+        if not args.force:
+            raise Refused("the folder is not empty and was not made by this command with these arguments: "
+                          "name another folder, or pass --force to write the planned files over it")
+    for path, text in files.items():
+        target = folder / path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(text, encoding="utf-8")
+    created = sorted(files)
+    if args.service:
+        created = sorted(created + _service_files(folder))
+    return dict(answer, created=created, repeated=False)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="new_agent.py", description="Create a Fabric agent project with the contract built in.")
+    parser.add_argument("folder", type=Path)
+    parser.add_argument("--id", required=True, help="the agent's id, kebab case (example-agent)")
+    parser.add_argument("--profile", choices=("mcp", "a2a", "local-runner"), default="mcp")
+    parser.add_argument("--service", action="store_true", help="also wire the service kit's sample (fabric-service/0.1)")
+    parser.add_argument("--capability", help="its capability, `domain.action` (default <id>.run)")
+    parser.add_argument("--effect", choices=ap.EFFECT_CLASSES, default="none",
+                        help="the capability's effect class (default none: declare money, deletion or publication now)")
+    parser.add_argument("--force", action="store_true", help="write the planned files into a folder that holds others")
+    parser.add_argument("--json", action="store_true", help="print only the last line")
+    return parser
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    try:
+        args = build_parser().parse_args(argv)
+    except SystemExit as exc:
+        return exc.code if isinstance(exc.code, int) else 2
+    try:
+        answer = make(args.folder.expanduser().resolve(), args)
+    except (Refused, ap.AdaptationError, OSError) as exc:
+        print("new_agent.py: %s" % (exc if not isinstance(exc, OSError) else "the folder cannot be written (%s)"
+                                    % type(exc).__name__), file=sys.stderr)
+        return 1
+    if not args.json:
+        print("%s %s: %d file(s)%s" % ("already made" if answer["repeated"] else "made", args.id, len(answer["created"]),
+                                       "" if answer["repeated"] else "; next: replace the sentinels `adapt_project.py check` "
+                                       "names, then run fabric_source_check.py check on the folder"))
+    print(json.dumps(answer, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -9,10 +9,10 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Python 3.9+ or Node.js 20+ for the kits (Node.js 22+ for a Linux service's instance lock); the probe needs Python 3.9+. launchd steps are macOS-only; Linux services install a systemd user unit and Windows ones a per-user Scheduled Task with the kits' writers. Dashboard handoff optionally uses Fabric Dashboards MCP link/host_status/open; without it, report unresolved host capability. The contract checkout is optional.
 metadata:
   author: PassionCode.ai
-  version: "0.80.2"
+  version: "0.82.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "18f8d48762edc5bfb1433657cbfe1c16196df1a6"
+  extension-commit: "93e7db164c7829e2783b4b7705c4113bb5201131"
 ---
 
 # Building Fabric services
@@ -82,7 +82,9 @@ MCP registration into a client config, the login flow or the CSRF header.
 When other agents or Fabric call the service over MCP, it follows `fabric-interop/0.1`:
 each manifest capability is the tool of its name, long work is a job with a stable id,
 a question for a person is an elicitation, and every call carries one trace. A job a limit stops or pauses, and an
-effect nobody saw, have their own codes and a key per caller (DEC-0087). Read
+effect nobody saw, have their own codes and a key per caller (DEC-0087); work held by the service's own limits is
+said on the job, pushed to the operator once per hold and lifted by their scoped answer (`scripts/fabric_holds.py`,
+FAA-298). Read
 [the interop reference](references/interop.md) before writing an MCP tool; the helpers
 are in [`scripts/fabric_interop.py`](scripts/fabric_interop.py) and
 [`scripts/fabric-interop.mjs`](scripts/fabric-interop.mjs). When the callers are agents of the estate, the
@@ -308,7 +310,8 @@ reference's *A2A for remote agents* section), `channel-agent.declaration` (DEC-0
 `board.responder` for a service that declares the project board) and exits 1 on any `FAIL`. A `NOT_RUN` is not a pass;
 name it in the report. A service with a dashboard also runs the layout probe,
 `node <skill-dir>/scripts/check_dashboard_layout.mjs --service <id>` (WebKit at 360, 480, 768
-and 1280 px; needs Playwright, else `NOT_RUN` and exit 3: nothing was measured).
+and 1280 px; needs Playwright, else `NOT_RUN` and exit 3: nothing was measured; also `NOT_RUN`
+and exit 3 where the socket table is restricted, `table-restricted`, since 0.81.0: FAA-318).
 
 Then prove the lock: start a second copy by hand against the same data directory; it
 must exit 75 while the first keeps serving. Prove recovery: `kill -9` the launchd pid;

package/plugins/fabric-agent-adapter/skills/building-fabric-services/assets/dashboard-kit/fabric-button.js

@@ -1,4 +1,4 @@
-/* fabric-dashboard-kit@1.1.6 · Fabric's button (Fabric Agent Contract DEC-0040, FB-1…FB-8, FL-1…FL-6)
+/* fabric-dashboard-kit@1.1.7 · Fabric's button (Fabric Agent Contract DEC-0040, FB-1…FB-8, FL-1…FL-6)
    Load it same-origin, after fabric-dashboard.css, with the service it opens Fabric on:
      <script src="fabric-button.js" defer data-service="example-agent.default" data-service-name="Example Agent"
              data-project="project-a" data-project-name="Project A"></script>
@@ -11,7 +11,7 @@
 (function (root) {
   'use strict';
 
-  var VERSION = '1.1.6';
+  var VERSION = '1.1.7';
   var COOKIE = 'fabric_button';
   var GET_FABRIC = 'https://passioncode.ai/fabric';
   var ABSENT_AFTER_MS = 1500;
@@ -37,8 +37,26 @@
     session: ['token', 'id'],
     code: ['login', 'auth', 'access', 'session']
   };
-  var JWT_SHAPE = /eyJ[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]*/;
-  var SECRET_VALUE = /(^bearer\s.+|sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[abposr]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|glpat-[A-Za-z0-9_-]{20,})/i;
+  // Whether /eyJ[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]{2,}\.[A-Za-z0-9_-]*/ matches anywhere, read in one pass (the
+  // contract's hasJwt, FAA-313): the expression backtracks from every `eyJ` of a long run, while every `eyJ` of one run
+  // shares that run's end, so only its first is tried.
+  var URL_BASE64 = /[A-Za-z0-9_-]/;
+  function runEnd(text, from) { while (from < text.length && URL_BASE64.test(text.charAt(from))) from += 1; return from; }
+  function hasJwt(text) {
+    var at = text.indexOf('eyJ');
+    while (at >= 0) {
+      var one = runEnd(text, at + 3);
+      if (one - at - 3 >= 2 && text.charAt(one) === '.') {
+        var two = runEnd(text, one + 1);
+        if (two - one - 1 >= 2 && text.charAt(two) === '.') return true;
+      }
+      at = text.indexOf('eyJ', one);
+    }
+    return false;
+  }
+  // The contract's SECRET_VALUE at the pin (DEC-0151), as the kit's fabric-secrets.mjs writes it (FAA-314, kit 1.1.7):
+  // `Bearer ` only at a value's start, a provider key's prefix in its canonical case after a boundary.
+  var SECRET_VALUE = /(^[Bb][Ee][Aa][Rr][Ee][Rr]\s.+|(?:^|[^A-Za-z0-9]|%[0-9A-Fa-f]{2}|\\[nrt"']|\\u[0-9A-Fa-f]{4}|\\x[0-9A-Fa-f]{2}|\\[bfv0ae]|\\[0-7]{1,3}|%25[0-9A-Fa-f]{2}|\x1b\[[0-9;:]*m|(?:\\u001[bB]|\\x1[bB]|\\e|\\033|\\33)\[[0-9;:]*m)(?:sk-(?=[A-Za-z0-9_-]{0,255}?\d)(?:(?=[A-Za-z0-9_-]{0,255}?[A-Z])[A-Za-z0-9_-]{16,}|[A-Za-z0-9_-]{32,})|gh[pousr]_[A-Za-z0-9]{20,}|xox[abposr]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|glpat-[A-Za-z0-9_-]{20,}))/;
   var LONG_RUN = /[A-Za-z0-9+/=_-]{40,}/g;
 
   function nameWords(name) {
@@ -60,7 +78,7 @@
   function longSecret(value) {
     return (value.match(LONG_RUN) || []).some(function (run) { return /[a-z]/.test(run) && /[A-Z]/.test(run) && /[0-9]/.test(run); });
   }
-  function secretValue(value) { return JWT_SHAPE.test(value) || SECRET_VALUE.test(value) || longSecret(value); }
+  function secretValue(value) { return hasJwt(value) || SECRET_VALUE.test(value) || longSecret(value); }
   function decodeKeepingPlus(raw) { try { return decodeURIComponent(raw); } catch (e) { return raw; } }
   function firstKey(text) { var it = new URLSearchParams(text).keys().next(); return it.done ? '' : it.value; }
   function rawValues(query) {

package/plugins/fabric-agent-adapter/skills/building-fabric-services/assets/dashboard-kit/fabric-dashboard.css

@@ -1,4 +1,4 @@
-/* fabric-dashboard-kit@1.1.6 · fabric-dashboard/0.1 (Fabric Agent Contract DEC-0036)
+/* fabric-dashboard-kit@1.1.7 · fabric-dashboard/0.1 (Fabric Agent Contract DEC-0036)
    A Fabric service dashboard shown inside a host pane: usable from 360 CSS px up, navigation always
    reachable, wide content in its own scroll box, one vertical scroller, appearance from the host.
    Copy this file next to fabric-dashboard.js; do not edit it in place. Put the page's own rules in

package/plugins/fabric-agent-adapter/skills/building-fabric-services/assets/dashboard-kit/fabric-dashboard.js

@@ -1,4 +1,4 @@
-/* fabric-dashboard-kit@1.1.6 · fabric-dashboard/0.1 (Fabric Agent Contract DEC-0036)
+/* fabric-dashboard-kit@1.1.7 · fabric-dashboard/0.1 (Fabric Agent Contract DEC-0036)
    Load it same-origin with <script src="fabric-dashboard.js" defer></script>: no inline script, no
    eval, nothing from a CDN. It applies the host's appearance (ED-6, ED-8), folds navigation that
    does not fit into a More menu (ED-3), makes wide boxes keyboard-reachable (ED-4) and keeps
@@ -8,7 +8,7 @@
   'use strict';
 
   var KIT = 'fabric-dashboard-kit';
-  var VERSION = '1.1.6';
+  var VERSION = '1.1.7';
   /* fabric-dashboard-kit:theme-ids:begin */
   var THEMES = ['graphite', 'fabric', 'paper', 'forest', 'ocean', 'ember', 'contrast'];
 /* fabric-dashboard-kit:theme-ids:end */

package/plugins/fabric-agent-adapter/skills/building-fabric-services/assets/dashboard-kit/kit.json

@@ -1,6 +1,6 @@
 {
   "name": "fabric-dashboard-kit",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "profile": "fabric-dashboard/0.1",
   "decision": "DEC-0036",
   "declarationKey": "https://fabric.passioncode.ai/agent-contract/extensions/dashboard/0.1",
@@ -15,9 +15,9 @@
     "contrast"
   ],
   "files": {
-    "fabric-dashboard.css": "7a90bbe1f1a2170df5dac0f596a3f302167bef9a7243457bb21dd0eb34f4d359",
-    "fabric-dashboard.js": "146ec9a0fd50af2df3245c02ec7dfba75b7d4e8cb5476fedb5ef727869fef1cc",
-    "fabric-button.js": "60c2b6d44571213e0237c29a94a4cf220f9de3efcfa697ac6a33777d1ad25fd6",
+    "fabric-dashboard.css": "549c1c1546bc9f8d2c1a579e7ad1035d009c94c3324b91d89d892afc437d5800",
+    "fabric-dashboard.js": "fa966a8f3b228391c2dae33674887a0d44b102cb58e42dbe6331f08bab57b391",
+    "fabric-button.js": "220c5c9719a9f6e35851d8748e2abb1d6606ffdb9fc43f3aff2b01f34637d925",
     "themes.json": "511839f1a1a83eb37fadfd132791474497d5c28c5091700b9aa31ad076e359b5"
   },
   "history": {
@@ -59,6 +59,11 @@
       "fabric-dashboard.css": "7a90bbe1f1a2170df5dac0f596a3f302167bef9a7243457bb21dd0eb34f4d359",
       "fabric-dashboard.js": "146ec9a0fd50af2df3245c02ec7dfba75b7d4e8cb5476fedb5ef727869fef1cc",
       "fabric-button.js": "60c2b6d44571213e0237c29a94a4cf220f9de3efcfa697ac6a33777d1ad25fd6"
+    },
+    "1.1.7": {
+      "fabric-dashboard.css": "549c1c1546bc9f8d2c1a579e7ad1035d009c94c3324b91d89d892afc437d5800",
+      "fabric-dashboard.js": "fa966a8f3b228391c2dae33674887a0d44b102cb58e42dbe6331f08bab57b391",
+      "fabric-button.js": "220c5c9719a9f6e35851d8748e2abb1d6606ffdb9fc43f3aff2b01f34637d925"
     }
   }
 }

package/plugins/fabric-agent-adapter/skills/building-fabric-services/recipes/support-agent/README.md

@@ -2,7 +2,7 @@
 
 A service answers one inbound question from its own knowledge file, or hands it to a person. It is a step of an
 agent that answers people, not that agent: see the paragraph after the table. Under the creating-fabric-agents
-template (`communication-agent-template.md`) the plan-and-draft call writes the draft, not this recipe's `answer()`:
+template (`templates/communication-agent/`, read through `references/communication-agent-template.md`) the plan-and-draft call writes the draft, not this recipe's `answer()`:
 the draft carries a `[KB:<id>]` marker for each knowledge id the plan used, and the agent runs `check_reply(draft,
 question, prompt_ids, max_chars=..., sources=...)` on it for the code checks. `prompt_ids` are the ids of the items
 placed in the plan's prompt, never the plan's own list (an id the plan names outside them is held as a suspected

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

@@ -37,7 +37,8 @@ refuses it with `invalid_arguments` (FAA-244).
    binding credential, shown once, goes into `credential_file` (0600, atomic) and never into the answer, a log or argv.
    Keep the file in the service's data directory or the operator's vault.
 3. Each connection joins with `fabric.board.join {projectId}` (`join_board` / `joinBoard`). It re-reads `hub.json`,
-   checks the pid it names is alive, tells the owner of the door's listener from the socket table (DEC-0154 HA-2:
+   checks the pid it names is alive (a process of another OS account under that id is `HubError` code `not-a-hub`,
+   retryable, saying not verified, as the session hooks say it, FAA-304; none at all is `not-running`), tells the owner of the door's listener from the socket table (DEC-0154 HA-2:
    another OS account's process, or one whose owner cannot be told, is `HubError` code `foreign-user`, retryable, with
    nothing sent; a restricted macOS table, which a retry never clears, is `data.reason` `table-restricted` and not
    retryable, protocol.md, FAA-272), and only then sends the credential (a session already running carries that refusal as `BoardError` code
@@ -403,7 +404,8 @@ Python (`fabric_hub`): `fabric_root(platform, env)`, `locate_hub(root=None, aliv
 `read_door_token(location)`, `read_credential(path)`, `HubClient(root=None, *, alive, timeout, estate, post)` with
 `request_board_access(agent_id, project_id, capabilities, reason)`, `poll_access(request_id, poll_secret,
 credential_file)`, `join_board(project_id, credential_file) -> BoardGrant`, `call_door(tool, args)`,
-`call_binding(tool, args, credential_file)`; `Backoff(first=2, cap=300, jitter=0.2, floor=1)`; `HubError(code,
+`call_binding(tool, args, credential_file)`; `pid_alive(pid)` answers True, False, or None for another OS account's
+process (not verified); `Backoff(first=2, cap=300, jitter=0.2, floor=1)`; `HubError(code,
 message, retryable, data)`.
 
 Python (`fabric_board`): `Responder(*, hub, project_id, capabilities, credential_file, checkpoint_file, handler,

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

@@ -105,7 +105,8 @@ service. Load it after the stylesheet, with ids only:
   Fabric* on a Russian page, or the page's `data-label-open`);
   `--ink` on `--panel` with an `--edge` boundary, the pairs the themes are measured on.
 - **Links (FL-1…FL-6):** built with the kit's port of the contract's `buildFabricLink`; a value outside the grammar
-  (or one shaped like a credential) means no button, never a bad link. A press opens a view in Fabric and starts
+  (or one shaped like a credential, by the contract's DEC-0151 detector as the kit's `fabric-secrets.mjs` reads it, since
+  1.1.7) means no button, never a bad link. A press opens a view in Fabric and starts
   nothing (FB-8).
 - **The host (FB-6):** when the host's `fabric_button` cookie says `owner=host`, the page hides its own button.
 - **Fabric absent (FB-5):** when the cookie says `fabric=absent`, or `data-fabric="absent"`, or when the page is still
@@ -148,6 +149,16 @@ vertically by the viewport or a clipping ancestor; ED-4 is `NOT_RUN` on a page p
 the scroll position: say so in the report. A `NOT_RUN` is not a pass. Exit codes: 0 when no rule fails and at least
 one passed, 1 on a `FAIL`, 2 on a usage error, 3 when no rule was measured (every rule `NOT_RUN`, since 0.44.0).
 
+Since 0.81.0 the probe opens a loopback page (and asks a local service for its login code) only after it reads the
+page's listener from the socket table as this OS account's (DEC-0154 PL-3, HA-2; FAA-260). On a Mac whose socket
+table is restricted for the runtime that runs the probe (macOS 27.2 shows an ad-hoc-signed Node, such as Homebrew's,
+nothing through `netstat`; DEC-0155 RT-1) the listener reads `unknown` (`table-restricted`), so every rule is
+`NOT_RUN` and the probe exits 3, whatever the page. That is not a pass and not the page's fault: say so in the report,
+with the reason the probe printed. The probe does not vouch for the listener by the service's pid, since only a
+caller that started the process may (DEC-0155 RT-3, the installers' route), and the well-known `process.pid` proves
+nothing. To measure the page, run the probe with a Node whose table reads (an Apple-signed or Developer ID one), or
+on a host without the restriction (FAA-318).
+
 ## Upgrading an existing dashboard
 
 A session that starts (or is cleared) in a repository that owns a service, whose dashboard has no
@@ -166,7 +177,9 @@ In the middle of an unrelated task, finish that first or record the upgrade as a
 3. A page with an older kit: `dashboard_kit.py install <dir>`. A `changed` copy is refused; move the
    edits into the page's own files, then install (or `--force` when the operator says the edits go).
 4. Raise `kit` in the declaration (`dashboard_extension()` does it), restart the service, and run
-   both probes above. Report the layout table with every `NOT_RUN`.
+   both probes above. Report the layout table with every `NOT_RUN`. On a Mac with a restricted socket
+   table the layout probe measures nothing since 0.81.0 (every rule `NOT_RUN`, exit 3, the reason
+   `table-restricted`; *Proving it* above): report that as not measured, never as a pass.
 
 ## When something is missing
 

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

@@ -65,8 +65,8 @@ host's `open` with `fallback=never`. Never `open <url>`, `open -a Safari`,
 agent's pages. A browser only when `host_status` confirms `not_installed`, and
 a raw `http://127.0.0.1:<port>` address only after the listener on that port is
 this OS account's (DEC-0154 PL-3 and HA-2; the adapter's `building-fabric-services/scripts/fabric_peer_owner.py`: `server_end` of a connection it opens and sends nothing on; `check_service.py <id>.<instance>` prints it as `listener.owner`): a
-`foreign-user` listener is reported, never opened (the link gate below does not
-read the owner yet, FAA-251). An installed host that failed
+`foreign-user` listener is reported, never opened (the link gate below takes
+that owner as `listener_owner`). An installed host that failed
 to open is reported, not replaced by HTTP. Links
 carry no token or login code. Every completion and notification action passes
 the Fabric Agent Adapter's link gate before delivery: `check_dashboard_link.py`
@@ -119,7 +119,20 @@ Its trusted context is supplied by the host, not by untrusted model output:
 
 `native_link` must equal the resolved open_link, with an available host on the
 viewer's device. `browser_link` must equal http_url, with confirmed not_installed,
-if_absent policy and the same device. Contract DEC-0123 PL-3 also allows a browser
+if_absent policy, the same device and `"listener_owner": "this-account"`: the kind
+the host read for the listener on http_url's port (`fabric_peer_owner`'s
+`this-account`, `another-account`, `system`, `unknown`, `none`, or
+`check_service.py`'s `foreign-user`); any other, or none given, refuses the
+browser (DEC-0154 PL-3, FAA-251). The host reads that kind right before it opens
+the page with the adapter's
+`python3 building-fabric-services/scripts/fabric_peer_owner.py listener <port>`
+(or `node building-fabric-services/scripts/fabric-peer-owner.mjs listener <port>`),
+which prints it on one line (`--json` prints the whole owner) and sends nothing
+to the port (FAA-315). Where the socket table is restricted (macOS 27.2 for an
+ad-hoc-signed Python or Node, DEC-0155 RT-4) only this account's listener on
+exactly `127.0.0.1` reads `this-account`; a wildcard or `::1` bind reads
+`unknown` (`table-restricted`), and the browser is refused. The native link does not take it: Fabric
+Dashboards checks its own listener. Contract DEC-0123 PL-3 also allows a browser
 on `unsupported` (a system the host does not ship for); the gate treats
 `unsupported` as no fallback, by the operator's rule that a browser opens only on a
 confirmed `not_installed`, and macOS never reports it (FAA-137). `remote_open` instead contains `device_id`,

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

@@ -53,8 +53,11 @@ the same owner; **T2** everyone else, and any call relayed onto loopback from of
 hub forwarding a T2 caller). DL-26: a T0 or T1 caller is never required to present a token; pass the tier,
 `gate(tool, headers, tier="T0")` or `server.handle(message, headers, tier="T0")`, and the call passes with no
 delegation. On a computer with more than one counted OS account, a loopback caller with no token is T0 only after the
-door checks the peer's account (the pinned DEC-0154 HA-3 and DL-25; the kit's own peer check is FAA-227), so pass
-`tier="T0"` there only for a caller the descriptor token authenticated. A token such a caller presents is still verified and refused when invalid. A T2 caller takes the whole
+door checks the peer's account (the pinned DEC-0154 HA-3 and DL-25): the kit's `LoopbackHTTPServer` with `peer_check="strict"` (Node
+`loopbackServer(app, {peerCheck: 'strict'})`, [protocol.md](protocol.md#the-listeners-owner-dec-0154-ha-2)) is that check,
+for loopback peers: pass `tier="T0"` only when the handler's `self.server.peer_owner()` (`connectionOwner(req.socket)`)
+names an owner, since a peer off loopback is served without one and is T2;
+otherwise pass `tier="T0"` there only for a caller the descriptor token authenticated. A token such a caller presents is still verified and refused when invalid. A T2 caller takes the whole
 profile. Money limits and human gates bind at every tier.
 
 **The family and the agent network** (DEC-0130, wording settled by DEC-0137). The operator's family is every agent

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

@@ -159,6 +159,33 @@ node keys every per-caller rule with `job_caller_key`, counts every started job
 and paused ones too) as running, and answers another caller's job id `unknown-job`. The text-only `queue-full` result
 and `fabric.job.list` are still the node's own (FAA-103).
 
+### Work held by the service's own limits
+
+A service that holds work by a limit of its own (a daily quota, a per-caller share, a concurrency cap, a money cap)
+says so, so a hold is never seen only by a caller who waits (FAA-298). `fabric_holds` (Node `fabric-holds.mjs`) does
+the three parts:
+
+- **On the job.** `hold_job(jobs, job_id, reason, since, until, message)` (Node `holdJob`) pauses the job with the
+  statusMessage `waiting_message` writes: `quota-exhausted[ until <until>]: waiting <reason> since <since>[: <message>]`,
+  `reason` one of `daily-quota`, `caller-share`, `concurrency`, `money`. The pinned `interop-job` schema is closed
+  (`additionalProperties: false`), so `waiting {reason, since, until, message}` is carried in `statusMessage`, the
+  contract's pause grammar, never as a field of the job: every caller already reads it as wait (until `until` when
+  given), and `read_waiting(answer)` (Node `readWaiting`) gives the four parts back. A job waiting its normal turn in
+  the call queue keeps `queued <position> of <length>`; a hold is the service's own limit.
+- **One push per hold.** `HoldBook(path, events=log)` (Node `new HoldBook(file, {events})`) opens a hold per reason and
+  caller: `hold(caller=, work=, reason=, until=, job_id=)` returns `{hold, statusMessage, push}`, and only the call that
+  opens the hold pushes: one `limit.held` event, level `notice`, `notify: true`, naming the caller, the work, the reason
+  and when it frees by itself, and asking whether to raise the limit. More work held by the same limit for the same
+  caller joins the hold silently. A hold closes by `release`, when its `until` passes, or by a lift that covers it;
+  the next hold pushes again. Names that read as a credential are refused.
+- **The operator's answer as a scoped lift.** `lift(reason=, decision=, caller=, job_id=, jobs= | usd= | limit=,
+  until=)` records the operator's words (`fabric_actions.operator_decision("limit.lift", words)`) with its scope (this
+  order, one caller, or every caller) and its size: a number of jobs, an amount of money, or a raised limit for a window
+  (100 a day for today: `limit=100, until=<midnight>`), and writes `limit.lifted`. `admit(reason=, caller=, job_id=,
+  cost_usd=)` spends a jobs or money lift (the narrowest scope first) and answers whether the work may pass the limit;
+  pass its answer to `jobs.create(..., limit_holds=not admitted)` for a repeated key. `limit(reason=, base=, caller=)`
+  is the limit in force. A lift falls back by itself when its window ends or its amount is spent.
+
 <a id="actions"></a>
 
 ## Actions
@@ -412,5 +439,6 @@ your own record, keep it (OA-6).
 | `interop.events-trace` | every event with a trace carries both `traceId` and `spanId`, well formed | no events page was read |
 | `interop.action-tools` | every action the well-known `extensions/actions/0.1` declares names a tool `tools/list` serves (DEC-0121 AP-1); one it does not serve is a `FAIL`, and so is a local service that declares actions with no MCP surface (beyond FAC-SEM-142, which reads only a present list) | no declaration, an unreadable one (`well-known.actions` reports it), no listing was read, or a remote service with no MCP surface (its twin may be on A2A or behind a gateway) |
 | `channel-agent.declaration` | a channel agent's declaration (DEC-0150) passes the contract's FAC-SEM-162 to 165 at the pin, read from `provider.extensions` of the manifest the descriptor names, else from `extensions` of the well-known answer (CA-1); a `FAIL` on the obligations of a declaration the reader still reads (FAC-SEM-164) or a string shaped like a credential (FAC-SEM-165, not a declaration too large to read for credentials) in the read declaration or in any copy beside it, the first five findings shown as code and path, never a declared value | nothing declared, the named manifest unreadable (`interop.manifest-link` fails it), or a key read as not declared (a manifest's own `extensions`, a capability's, another version's key, a well-known copy beside a manifest, a form the schema or FAC-SEM-163 refuses), each named in the evidence, never a failure while producers move to this revision unless a copy holds a string shaped like a credential (that fails in any copy the probe reads: a manifest's own `extensions`, a capability's, the well-known copy, CA-5); no line when the well-known answer is not read; credentials are read as the contract reads them, within its reading budget and under the `0.1` key only (a key of another version is named, not read); a well-known answer carrying the declaration at 75 % of the 2 MiB cap or over is named, never a failure (until the contract's CT-223) |
+| `limits.holds` | a service that declares limits (a load declaration's `limits`, the usage report's `budget` or `budgets`) holds work through `fabric_holds` (`HoldBook`, `waiting_message`, `hold_job`) in a tracked code file (`.py`, `.mjs`, `.js`, `.ts`) of its checkout outside the kit's copy, a vendored `check_service_rules.py` and the tests (FAA-298) | no limits declared, or no checkout found (`--repo` names it), git missing or out of time; and, since 0.81.0, a service that declares limits and holds none through the kit: a migration note naming `fabric_holds`, never a `FAIL`, since services built before the module could not have adopted it |
 
 `python3 scripts/check_service.py <id>` prints them with the rest; `--json` for a machine.