@passioncode-ai/passioncode 0.2.44 → 0.2.46

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

@@ -13,7 +13,10 @@ once, and `sample.draft` is a job that stops for a titled choice before it compl
 Opt-in, off by default: `serve --board-project <Project uuid>` also answers that Project's `sample.echo` requests on
 Fabric's project board (fabric-project-comms/0.1, FAA-12b) with fabric_board.Responder, from a board.respond grant whose
 credential is in `<data>/board.credential` (0600; `--board-credential` names another file). The request body is data:
-the gate admits plain text of at most 2,000 characters, and the answer is a reply carrying the same text.
+the gate admits plain text of at most 2,000 characters, and the answer is a reply carrying the same text. Its
+dashboard's Take back has the tool `board.take-back`, which the manifest lists when registered with the same
+`--board-project`; a serve whose board mode differs from the registered manifest at its start logs
+`service.manifest.mismatch`.
 """
 
 from __future__ import annotations
@@ -52,8 +55,29 @@ PAGE = """<!doctype html><html lang="en"><head><meta charset="utf-8">
 <nav class="fd-nav" aria-label="Sections"><ul class="fd-nav-list"><li><a href="#events" aria-current="page">Events</a></li>
 <li><a href="#about">About</a></li></ul></nav></div>
 <main class="fd-page"><section id="events"><h2>Events</h2><ul>{rows}</ul></section>
-<section id="about"><h2>About</h2><p class="fd-hint">A sample fabric-service/0.1 service built on the kit.</p></section></main>
+{board}<section id="about"><h2>About</h2><p class="fd-hint">A sample fabric-service/0.1 service built on the kit.</p></section></main>
 </body></html>"""
+# FAA-157: a moved board slot comes back only by the operator's act, a button on this page. The button posts from the
+# operator's signed-in dashboard session with the request header; a service token alone cannot reach it.
+BOARD_SECTION = """<section id="board"><h2>Project board</h2><p class="fd-hint">These slots were moved to another
+session; this service no longer answers them there. Take back asks for one again: the service enrolls once the other
+session lets it go, or at once when it restarts with accepted work for the slot.</p><ul>{items}</ul>
+<script src="/board.js" defer></script></section>"""
+#: The dashboard's Take back button and its tool (FAA-157, DEC-0121): the operator's decision, relayed in `_meta`.
+TAKE_BACK = {"id": "board.take-back", "title": "Take back", "tool": "board.take-back", "gate": "relayed"}
+TAKE_BACK_INPUT = {"type": "object", "properties": {"capability": {"type": "string"}}, "required": ["capability"],
+                   "additionalProperties": False}
+BOARD_ITEM = '<li>{capability} <button type="button" data-take-back="{capability}">Take back</button></li>'
+BOARD_JS = """document.addEventListener('click', function (e) {
+  var cap = e.target && e.target.getAttribute && e.target.getAttribute('data-take-back');
+  if (!cap) return;
+  e.target.disabled = true;
+  fetch('/api/board/take-back', {method: 'POST', credentials: 'same-origin',
+    headers: {'Content-Type': 'application/json', 'X-Fabric-Request': '1'}, body: JSON.stringify({capability: cap})})
+    .then(function (r) { e.target.textContent = r.ok ? 'Asked back: waiting for the other session' : 'Refused (' + r.status + ')'; })
+    .catch(function () { e.target.disabled = false; e.target.textContent = 'Failed: try again'; });
+});
+"""
 
 
 def _schema(name: str, body: Dict[str, Any]) -> Dict[str, Any]:
@@ -72,10 +96,26 @@ CAPABILITIES = [
      "output": _schema("sample.draft-output", {"type": "object", "additionalProperties": False,
                                                  "properties": {"title": {"type": "string"}, "body": {"type": "string"}}, "required": ["title", "body"]})},
 ]
+#: The take-back tool as a manifest capability (0.56.0 product r28): every tool the well-known lists is in the
+#: manifest, so `register --board-project` writes it there.
+TAKE_BACK_CAPABILITY: Dict[str, Any] = {
+    "name": TAKE_BACK["tool"], "effect": "change-policy", "idempotency": "required", "job": False,
+    "description": "Take back a board slot the operator moved away.",
+    # A relayed action: a probe call carries no operator decision, so it is refused and changes nothing (unit r28).
+    "probeAssertion": "is refused as operator-decision-required without the operator's decision in _meta",
+    "input": _schema("board.take-back-input", TAKE_BACK_INPUT),
+    "output": _schema("board.take-back-output", {"type": "object", "additionalProperties": False,
+                                                  "properties": {"capability": {"type": "string"}, "moved": {"const": False}},
+                                                  "required": ["capability", "moved"]})}
+
+
+def served_capabilities(board: bool) -> list:
+    return CAPABILITIES + ([TAKE_BACK_CAPABILITY] if board else [])
 
 
 class Service:
     def __init__(self, args: argparse.Namespace):
+        self.args = args
         self.id = args.id
         self.instance = args.instance
         self.name = args.name
@@ -110,9 +150,73 @@ class Service:
             self.board = fbd.Responder(hub=fhb.HubClient(), project_id=self.board_project, capabilities=[self.board_capability],
                                        credential_file=self.board_credential, checkpoint_file=self.data / "board-checkpoint.json",
                                        handler=self.board_answer, admit=self.board_admit, emit=self.log.append, service=self.id)
+            # Every button has a tool (DEC-0121): the page's Take back is this relayed action, the operator's decision.
+            cap = TAKE_BACK_CAPABILITY
+            self.mcp.add_tool(fi.tool_for_capability(cap, cap["input"], cap["output"]), self.board_take_back_tool,
+                              action=TAKE_BACK, target="capability")
         self.log.append("service.started", "info", "%s started on build %s." % (self.name, self.build["commit"]))
+        self.check_manifest()
+
+    def check_manifest(self) -> None:
+        """The registered manifest is register's to write, never serve's (0.56.0 seam r28): a serve whose board mode
+        differs from it at its start says so, and the probe fails until it is registered again (interop.tools-match when
+        the manifest lists a take-back this run does not serve, interop.well-known-capabilities when it lacks one this run
+        lists)."""
+        try:
+            listed = {c.get("name") for c in json.loads((self.data / "fabric-agent.json").read_text(encoding="utf-8"))["capabilities"]
+                      if isinstance(c, dict)}
+        except (OSError, ValueError, KeyError, TypeError, AttributeError):
+            return  # not registered here, or not a manifest of this shape: nothing to compare
+        if (TAKE_BACK["tool"] in listed) != (self.board is not None):
+            self.log.append("service.manifest.mismatch", "warning",
+                            "The registered manifest %s the take-back tool, which this run %s: register again %s --board-project."
+                            % ("lists" if TAKE_BACK["tool"] in listed else "lacks",
+                               "does not serve" if self.board is None else "serves", "without" if self.board is None else "with"))
 
     # --- the project board (opt-in): the input gate and the answer -------------------
+    def board_moved(self) -> list:
+        """The capabilities whose slot the operator moved to another session (FAA-155): the page offers their take-back.
+        The live slot or the checkpoint's record says so: before a restart has reconnected (or while Fabric is down) the
+        record alone knows the move (0.56.0 seam r3)."""
+        if not self.board:
+            return []
+        live = {c for c, slot in dict(self.board.slots).items() if slot.get("state") == "moved"}
+        kept = {c for c, record in dict(self.board.checkpoint.slots).items()
+                if isinstance(record, dict) and record.get("project") == self.board_project and "moved" in record}
+        return sorted((live | kept) & set(self.board.capabilities))
+
+    def board_take_back(self, capability: Any, record: Any = None) -> Dict[str, Any]:
+        """The operator's take-back (FAA-157): the next tick enrolls once the other session lets the slot go. `record` is
+        the act the action gate recorded (by, via, caller), kept in the event; never the decision's words. A repeat for a
+        capability of this service that is no longer moved (its first answer lost) answers the same, from the page's
+        route as from the tool (0.56.0 seam r6)."""
+        if self.board is not None and isinstance(capability, str) and capability in self.board.capabilities \
+                and capability not in self.board_moved():
+            return {"capability": capability, "moved": False}
+        if not isinstance(capability, str) or capability not in self.board_moved():
+            raise fs.ServiceError("No slot of that capability has moved away from this service.")
+        self.board.take_back(capability)
+        # Who decided and by which route are words in the sentence; the caller, a machine id, goes in data only
+        # (events-and-notifications.md, "Writing an event"; 0.56.0 product r34).
+        # The route in words; the tokens by and via, with the caller, in data (product r35).
+        act = record if isinstance(record, dict) else {}
+        how = {"dashboard": " on this service's page", "relayed-instruction": " through an agent they told",
+               "mandate": " under a standing mandate"}.get(act.get("via"), "")
+        value = {"capability": capability, **{k: act[k] for k in ("by", "via", "caller") if isinstance(act.get(k), str)}}
+        data = {"schema": fbd.EVENT_SCHEMA, "value": value}
+        extra = {} if fs.feed_data_problems(data) else {"data": data}  # a caller the feed refuses never undoes the answer
+        self.log.append("board.slot.returned", "info", "The operator took the %s slot back%s; the service enrolls once the "
+                        "other session lets it go." % (capability, how),
+                        subject={"type": "capability", "id": capability}, **extra)
+        return {"capability": capability, "moved": False}
+
+    def board_take_back_tool(self, args: Dict[str, Any], ctx: fi.CallContext) -> Dict[str, Any]:
+        """The take-back as a tool: the action gate has already read the operator's relayed decision (gate `relayed`)."""
+        try:
+            return self.board_take_back(args.get("capability"), ctx.record)  # a repeat answers moved: false
+        except (fs.ServiceError, fbd.BoardError) as exc:
+            raise fi.InteropError(str(exc))
+
     def board_admit(self, request: fbd.BoardRequest) -> Optional[str]:
         """The service's own input gate: the body is data, never an instruction; only short plain text is echoed."""
         if request.body_format != "text/plain":
@@ -172,11 +276,14 @@ class Service:
             started_at=self.started_at, status="ready", degraded=self.degraded,
             summary=[{"label": "Events", "value": len(self.log.fetch(None, fs.EVENTS_MAX_LIMIT))}],
             surfaces={"dashboard": {"path": "/", "login": True}, "events": {"path": "/fabric/v1/events"},
-                      "mcp": {"path": "/mcp", "transport": "streamable-http", "capabilities": [c["name"] for c in CAPABILITIES]},
+                      "mcp": {"path": "/mcp", "transport": "streamable-http", "capabilities": [c["name"] for c in CAPABILITIES]
+                              + ([TAKE_BACK["tool"]] if self.board is not None else [])},
                       "usage": {"path": fs.USAGE_PATH}},
             extensions=fs.dashboard_extension() if (KIT_DIR / "fabric-dashboard.css").is_file() else None,
             # DEC-0067: listed only when the board is on — a host pinned before DEC-0067 refuses the member.
-            protocols=["fabric-service/0.1", "fabric-project-comms/0.1"] if self.board is not None else None,
+            # DEC-0126 OA-7: a server serving a relayed action reads `source`, so it lists operator-source/1 too.
+            protocols=self.mcp.well_known_protocols(["fabric-service/0.1", "fabric-project-comms/0.1"]) if self.board is not None else None,
+            actions=self.mcp.action_table() or None,
         )
 
 
@@ -195,7 +302,8 @@ def make_handler(svc: Service):
             self.send_response(status)
             self.send_header("Cache-Control", "no-store")
             self.send_header("X-Content-Type-Options", "nosniff")
-            self.send_header("Content-Security-Policy", "default-src 'none'; style-src 'self'; script-src 'self'; frame-ancestors 'self'")
+            self.send_header("Content-Security-Policy", "default-src 'none'; style-src 'self'; script-src 'self'; connect-src 'self'; "
+                             "frame-ancestors 'self'")
             if body is not None:
                 self.send_header("Content-Type", content_type)
                 self.send_header("Content-Length", str(len(payload)))
@@ -261,8 +369,12 @@ def make_handler(svc: Service):
                     return self._send(401, "Open this dashboard from Fabric Dashboards.", content_type="text/plain")
                 rows = "".join("<li>%s: %s</li>" % (html.escape(e["at"]), html.escape(e["text"]))
                                for e in reversed(svc.log.fetch(None, 20)))
-                return self._send(200, PAGE.format(name=html.escape(svc.name), agent=html.escape("%s.%s" % (svc.id, svc.instance)), status="ready", rows=rows),
+                moved = "".join(BOARD_ITEM.format(capability=html.escape(c)) for c in svc.board_moved())
+                return self._send(200, PAGE.format(name=html.escape(svc.name), agent=html.escape("%s.%s" % (svc.id, svc.instance)), status="ready", rows=rows,
+                                                   board=BOARD_SECTION.format(items=moved) if moved else ""),
                                   content_type="text/html; charset=utf-8")
+            if url.path == "/board.js" and svc.board is not None:
+                return self._send(200, BOARD_JS, content_type="text/javascript; charset=utf-8")
             self._send(404, {"error": "Not found."})
 
         def _length(self, cap: int) -> "int | None":
@@ -290,7 +402,8 @@ def make_handler(svc: Service):
                     return self._send(400, {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error."}})
                 try:
                     with svc.drain.work():
-                        response = svc.mcp.handle(message, self.headers)
+                        # T0 (DL-25): a loopback call the service token authenticated is the local floor's caller.
+                        response = svc.mcp.handle(message, self.headers, tier="T0")
                 except fs.Stopping as exc:
                     return self._send(503, {"jsonrpc": "2.0", "id": None, "error": {"code": -32000, "message": str(exc)}},
                                       {"Retry-After": "5"})
@@ -307,6 +420,21 @@ def make_handler(svc: Service):
                     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/board/take-back" and svc.board is not None:
+                if not self._session_ok():  # the operator's dashboard session only: never the service token (FAA-157)
+                    return self._send(401, {"error": "Sign in from Fabric Dashboards first."})
+                if self.headers.get("X-Fabric-Request") != "1":
+                    return self._send(403, {"error": "Missing request header."})
+                length = self._length(4096)
+                if length is None:
+                    return
+                try:
+                    body = json.loads(self.rfile.read(length) or b"{}")
+                    # The event names who decided, as the tool's does: the operator, at the dashboard (0.56.0 seam r7).
+                    return self._send(200, svc.board_take_back(body.get("capability") if isinstance(body, dict) else None,
+                                                               {"by": "operator", "via": "dashboard", "caller": "the signed-in page"}))
+                except (ValueError, RecursionError, fs.ServiceError, fbd.BoardError) as exc:
+                    return self._send(400, {"error": str(exc)})
             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."})
@@ -343,11 +471,6 @@ def serve(args: argparse.Namespace) -> int:
     # hand-over that hangs is cut by the kit's hard exit, inside launchd's ExitTimeOut.
     import threading
     board_stop = threading.Event()
-    board_thread = None
-    if svc.board is not None:
-        board_thread = threading.Thread(target=svc.board.run, args=(board_stop, 5.0), name="board-responder", daemon=True)
-        board_thread.start()
-
     stop_asked: list = []
 
     def stopping() -> None:
@@ -355,30 +478,39 @@ def serve(args: argparse.Namespace) -> int:
         board_stop.set()  # stop claiming; the responder drains its request and leaves its board session
         svc.log.append("service.stopping", "info", "%s is stopping." % svc.name)
     svc.drain.install(lambda drained: server.shutdown(), on_stopping=stopping)
+    # The board thread starts only once the stop handler is installed: a SIGTERM in between would end the process with
+    # no drain and no DELETE, and the slot would stay held until its lease lapses (0.56.0 seam r6).
+    board_thread = None
+    if svc.board is not None:
+        board_thread = threading.Thread(target=svc.board.run, args=(board_stop, 5.0), name="board-responder", daemon=True)
+        board_thread.start()
     try:
         server.serve_forever(poll_interval=0.2)
     finally:
         board_stop.set()
         if board_thread is not None:
             # The responder drains (5 s at most) and leaves its board session, which releases its slots and forgets their
-            # records (FAA-155): joined, so the process does not end before that.
-            # Bounded by the kit's hard exit, 8 + 2 s after the stop was asked: 1.5 s are left for the rest of the stop.
-            board_thread.join(max(0.5, 8.5 - (time.monotonic() - (stop_asked[0] if stop_asked else time.monotonic()))))
+            # records (FAA-155): joined, so the process does not end before that. Idle, it waits 3 s for the DELETE and the
+            # join ends within LC-01's 5 s (FAA-173); with work, it is bounded by the kit's hard exit, 8 + 2 s after the
+            # stop was asked: 1.5 s are left for the rest of the stop.
+            bound = 4.5 if svc.board.current is None else 8.5
+            board_thread.join(max(0.5, bound - (time.monotonic() - (stop_asked[0] if stop_asked else time.monotonic()))))
         server.server_close()
         svc.lock.release()
     return 0
 
 
-def write_manifest(args: argparse.Namespace, data: Path) -> Path:
-    """The provider manifest for this service, naming its descriptor (G-07), with its schemas beside it."""
+def write_manifest(args: argparse.Namespace, data: Path, board: bool = False) -> Path:
+    """The provider manifest for this service, naming its descriptor (G-07), with its schemas beside it; with `board`,
+    the take-back tool too."""
     schemas = data / "fabric" / "schemas"
-    for cap in CAPABILITIES:
+    for cap in served_capabilities(board):
         for side in ("input", "output"):
             fs.atomic_write(schemas / ("%s-%s.schema.json" % (cap["name"], side)),
                             (json.dumps(cap[side], indent=2) + "\n").encode(), 0o600)
     origin = "http://127.0.0.1:%d" % args.port
     capabilities = []
-    for cap in CAPABILITIES:
+    for cap in served_capabilities(board):
         capabilities.append({
             "id": "urn:fabric:capability:%s" % cap["name"], "name": cap["name"], "description": cap["description"],
             "inputSchema": cap["input"]["$id"], "outputSchema": cap["output"]["$id"],
@@ -388,7 +520,7 @@ def write_manifest(args: argparse.Namespace, data: Path) -> Path:
                         "requiredFeatures": ["tool:%s" % cap["name"]],
                         "probes": [{"id": "%s-shape" % cap["name"].replace(".", "-"), "inputFixture": "urn:fabric:fixture:%s" % cap["name"],
                                     "outputSchema": cap["output"]["$id"], "timeoutMs": 5000, "sideEffectCeiling": "none",
-                                    "assertions": ["returns a value valid against its output schema"]}]},
+                                    "assertions": [cap.get("probeAssertion", "returns a value valid against its output schema")]}]},
             "extensions": {fi.EXTENSION_KEY: {"job": cap["job"]}},
         })
     digest = hashlib.sha256(json.dumps(capabilities, sort_keys=True).encode()).hexdigest()
@@ -408,7 +540,7 @@ def write_manifest(args: argparse.Namespace, data: Path) -> Path:
 
 def register(args: argparse.Namespace) -> int:
     data = Path(args.data_dir)
-    manifest = write_manifest(args, data)
+    manifest = write_manifest(args, data, board=bool(getattr(args, "board_project", None)))
     descriptor = {
         "protocol": fs.PROTOCOL, "id": args.id, "instance": args.instance, "name": args.name,
         "summary": "Sample fabric-service/0.1 service.",
@@ -449,6 +581,8 @@ def build_parser() -> argparse.ArgumentParser:
             p.add_argument("--board-capability", default="sample.echo")
             p.add_argument("--board-credential", help="the board.respond credential file (0600); default <data>/board.credential")
         else:
+            p.add_argument("--board-project", help="the Project the service will answer on the board: lists its take-back "
+                                                   "tool in the manifest (serve with the same --board-project)")
             p.add_argument("--services-dir")
             p.add_argument("--label")
             p.add_argument("--plist")

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

@@ -5,7 +5,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.54.0"
+  version: "0.56.0"
   contract-version: "0.1.0"
   contract-commit: "00e050ba7429c0c60261cec871779e0fd6aeeb28"
 ---
@@ -61,6 +61,7 @@ No file is created until every row has an answer. An answer of "later" fails the
 | **Who pays?** | one key per agent and context with its own ceiling, from the estate's key manager, read from the environment; checked before every call; a personal key never pays for an organization |
 | **How does it learn?** | decisions recorded with reasons, one trace per turn, every failure a planted fixture first, history replayed, learnings proposed and never self-approved (references/orchestration-and-learning.md) |
 | **Text for people?** | if it writes anything a person reads (a reply, a message, a post, a report, a UI string), its prompt forbids the em dash (U+2014) and any substitute for it, and a test fails on U+2014 in new output, from the first commit (the resilience reference, *Text for people*) |
+| **Does it answer people?** | if it answers people in a chat, by mail, in store reviews or in a group, it carries from its first release the turn record and the daily `support.quality_daily` report, the lane table with vendor exclusion and fallback recoveries counted, a writer change only after an offline replay, false-state gates and a checker that sees the material first, numbers and account state from tools, the live tail re-read before sending, repair then research then a hold that comes back, hand-offs by cause and never counted or judged as answers, a commitments ledger, a knowledge client that reads the service's `answer` flag, a gap queue and a feed re-read on a new event kind (references/agents-that-answer-people.md) |
 
 ## Step 1: the knowledge intake
 
@@ -93,6 +94,8 @@ prior art of its own:
   choice, several kinds of input and output, budgets, OpenRouter keys.
 - [orchestration-and-learning.md](references/orchestration-and-learning.md): the work graph,
   calling other agents, stops for a person, learning loops, the loop guard.
+- [agents-that-answer-people.md](references/agents-that-answer-people.md): what an agent that
+  answers people carries from its first release, each part with the check that proves it.
 
 ## Step 2: the project skeleton
 

package/payload/plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/agents-that-answer-people.md

@@ -0,0 +1,139 @@
+# Agents that answer people: what they carry from the first release
+
+**Load this when the agent you are building answers people**: private chats, mail, store reviews, group chats, any
+channel where a person asks and the agent writes back. Every item below is a part of the agent, built and tested in its
+first release, not a later improvement. Each comes from the sources below: what the quality standard requires (A1,
+A5), and what an audit of five production agents found working or failing (P1 to P8). The practices are field
+evidence: one estate, five agents, no control; their numbers are that estate's, never a forecast.
+
+Sources (public): the support quality standard,
+[`support-quality.md`](https://github.com/ssheleg/agent-stack/blob/28a0303c42038778e2650fc51096e589f4035239/plugins/agent-stack/skills/agent-evals/references/support-quality.md)
+(A1 the record, A5 `support.quality_daily`), and the practices from an audit of five such agents,
+[`support-practices.md`](https://github.com/ssheleg/agent-stack/blob/f882358e3fb9627f6edb20db3981818912a9844c/plugins/agent-stack/skills/agent-evals/references/support-practices.md)
+(P1 to P8), both in the `agent-evals` skill of [ssheleg/agent-stack](https://github.com/ssheleg/agent-stack); the
+practices arrive with [PR #70](https://github.com/ssheleg/agent-stack/pull/70), linked here at its commit until it
+merges. The standard says how such an agent is measured; the practices say what worked and what failed. This page
+lists parts that have a check, and the check that proves each; it leaves to the sources the standard's A2 families and
+per-channel targets, A3 (the rubric), A4 (the judge and its calibration), A6 (answer first, the queue's SLA, a safe
+default) and the rest of its checks that caught real defects, and the practices' other items of P1, P3, P5, P6, P7 and
+P8. Read both sources before you design the reply pipeline. The kit's support-agent recipe (building-fabric-services,
+`recipes/support-agent/`) is one draft-and-check step of such an agent, not the agent: used alone it hands the message
+to a person at the first refusal (the refused draft is not kept), where this page repairs, researches and holds.
+
+## Contents
+
+- [The record and the daily report](#the-record-and-the-daily-report)
+- [Model lanes](#model-lanes)
+- [Checks before a reply is sent](#checks-before-a-reply-is-sent)
+- [When the check refuses](#when-the-check-refuses)
+- [Hand-offs and promises](#hand-offs-and-promises)
+- [Knowledge and gaps](#knowledge-and-gaps)
+- [Reading the events feed](#reading-the-events-feed)
+- [Checklist](#checklist)
+
+## The record and the daily report
+
+- **Every inbound message is a turn with a trace id** (A1): the id is on the turn row, on each model call of that turn,
+  on its log line and on any copy a person reads. The turn stores its outcome (answered, general guidance, not covered,
+  handed off, small talk, limit, error), the hand-off reason and category, the latency, the knowledge revision the
+  answer used, and whether the channel accepted the reply. Conversation text stays inside the agent, redacted, for at
+  most 30 days. Check: a test that a turn without a trace id, or with an outcome outside the list, is refused.
+- **The agent publishes one `support.quality_daily` per closed UTC day and channel** (A5) on its events feed
+  (`/fabric/v1/events`; building-fabric-services, `references/events-and-notifications.md`): counts and codes only, the
+  judge model and rubric version, and `notMeasured` naming every family not computed that day. A metric not measured is
+  null and named, never 0. The day goes in the event's `data` (`{schema, value}`, as `fabric_events.py` writes it), at
+  level `info` and without a notification. Until the contract carries the schema (A7), the producer names and pins its
+  own: `data.schema` is the absolute URI of the payload schema the agent publishes, and `data.value` stays within
+  DEC-0070's bounds (at most 32 members, each a scalar, a list of scalars or a flat object; per-lane counts as objects
+  such as `laneFailures` and `laneRecovered`; building-fabric-services, `references/protocol.md`). Check: the producer's
+  day passes `make_event`; a planted day that writes 0 for a family not computed fails; and a test runs every
+  `notMeasured` name the producer can emit through the published name pattern, iterating the producer's own list.
+
+## Model lanes
+
+- **A table of lanes** (P4): classifier, writer, fallback writer, checker, research, judge. The checker is another
+  vendor than the writer; the judge is another vendor than both, at temperature 0, on an open-vendor model where it
+  reads what people wrote. Declare them as classes in the profile, where each lane's fallback is another vendor than its
+  primary ([models and providers](models-and-providers.md)); per turn the router picks the checker against the model
+  that actually drafted, a fallback writer included ([resilience and
+  autonomy](resilience-and-autonomy.md#model-answers-are-untrusted-until-accepted), item 3). A lane that reads what
+  people wrote has an open-vendor route (DEC-0083). Check: the config loader refuses a fallback that shares its own
+  lane's primary vendor, a profile where some writer route has no checker route of another vendor, and a judge with no
+  route outside the vendors of the writers and the checkers (the vendor is the prefix before `/`).
+- **Count what the fallback recovered** (P4), not only what the first attempt lost: a day's report says how many calls
+  failed and how many of those the fallback answered. Check: a test that a recovered call counts once as a failure of
+  the primary and once as a recovery, and is never counted as an error of the turn.
+- **A writer model or reasoning budget changes only after an offline replay** (P4) of last week's judged sample, judged
+  blind, on the current model and the candidates. Check: the config loader refuses a change of the writer lane's model
+  or reasoning budget that names no replay report.
+
+## Checks before a reply is sent
+
+- **Deterministic false-state gates come first** (P2): the reply may not say that money arrived, that something is live,
+  enabled or fixed, or that a person did something, unless the system backs it. Check: planted drafts with each false
+  claim are refused before any model checker runs.
+- **The checker sees the material, and sees it before the instructions** (P2): the knowledge items and account state the
+  writer used come first in its context, the operator's instructions after. A checker that receives the material cut
+  short after long instructions refuses correct answers as invented. Check: a planted correct answer whose material is
+  longer than the instructions passes the checker.
+- **Numbers and account state come from tools**, never from the model (P1): prices from a calculator, the person's
+  account state and order from the system, injected per turn. Check: a planted draft with a price or an account state
+  that no tool result of the turn carries is refused.
+- **Before sending, re-read the conversation's live tail** (P1): if a person or the agent already answered, skip the
+  turn. Check: a reply that lands in the conversation while the draft is checked makes the agent send nothing.
+
+## When the check refuses
+
+- **Repair, then research, then hold** (P2): one repair with the checker's reason; then one research turn on a stronger
+  model that sees both refused drafts and approved past answers, under a hard time cap; only then an honest holding
+  line. A refusal for a money reason is never researched. Check: a planted refusal walks all three steps in order.
+- **A hold comes back by itself** (P2): when a person or the knowledge base answers the held question, the conversation
+  is run again and the person gets the answer without asking twice. Check: closing the gap behind a held turn produces
+  one reply in that conversation, and only one.
+
+## Hand-offs and promises
+
+- **A hand-off is never an answer** (P3): it is not counted as answered, and hand-off and fallback templates stay out of
+  the judge's sample. Check: the daily report counts a hand-off under hand-offs, and the judge's sample builder leaves
+  templated replies out.
+- **Hand-offs are counted by cause** (P3): `policy`, `inability` and `infrastructure` apart, so the largest number names
+  what to fix. A hold after a checker or model outage, or at the research time cap, is `infrastructure`; only a hold
+  after a refusal on the material is `inability`. Check: a checker outage produces `infrastructure` hand-offs and holds,
+  never `inability`.
+- **A commitments ledger** (P3): every "I will pass this on and come back" is a row with an owner and a due date; the
+  week's report counts promises made and closed. Check: a reply that promises to come back without a ledger row is
+  refused.
+
+## Knowledge and gaps
+
+- **The knowledge client keeps no threshold of its own** (P1, P8): the knowledge service decides whether an item may be
+  given as an answer and returns an `answer` flag per item; the client reads the flag and nothing else. Small closed
+  rule sets (prices, payment terms, refunds, sign-in) go into the prompt whole, dated and ordered by owner. Check: a
+  test that changing the client's configuration cannot make an item with `answer: false` an answer.
+- **Every abstention and every inability, a hold on the material included, becomes a gap in a queue** (P7), restated
+  without personal data and grouped by meaning. When a gap closes, the client asks again and rewrites the held answer
+  only once the new answer is confident. Check: a closed gap whose new answer comes back with `answer: false` leaves the
+  hold in place, and a hold after a checker outage opens no gap.
+
+## Reading the events feed
+
+- **A reader that starts accepting a new event kind re-reads its feed once** (P6), from before its cursor: a reader that
+  only moves forward has already passed the first events of that kind. The re-read reaches back only as far as the
+  producer's feed keeps (at least 7 days or 1000 events, building-fabric-services
+  `references/events-and-notifications.md`); an older day is read from the producer's own store or not at all. Check: a
+  test adds a kind to the reader and sees the earlier events of that kind delivered once.
+
+## Checklist
+
+- [ ] Turn record with a trace id and an outcome from the fixed list (A1)
+- [ ] `support.quality_daily` per closed UTC day and channel; `notMeasured` names tested against the pattern (A5)
+- [ ] Lane table: fallback, checker and judge of other vendors; fallback recoveries counted
+- [ ] A writer model or reasoning budget changed only after an offline replay
+- [ ] False-state gates before the model checker; the checker sees the material before the instructions
+- [ ] Numbers and account state from tools; the live tail re-read before sending
+- [ ] Repair, research, hold; a hold that comes back by itself
+- [ ] Hand-offs by cause, never counted or judged as answers
+- [ ] A commitments ledger: promises made and closed per week
+- [ ] A knowledge client that reads the service's `answer` flag and keeps no threshold
+- [ ] A gap queue that asks again after a gap closes
+- [ ] A reader that adds an event kind re-reads its feed once

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

@@ -12,13 +12,13 @@ description: >-
   messaging people.
 license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: >-
-  Needs the Fabric desktop app (0.4.0 or later for fabric-mcp and the fabric_work tools) and an MCP client.
-  The status script needs Python 3.9+ (3.11+ to edit Kimi Code's config.toml). Starting Fabric needs the
-  local-lifecycle MCP server; without it the person opens Fabric. The full session hooks run in Claude Code from
+  Needs the Fabric desktop app (v0.3.5 or later for fabric-mcp and the fabric_work tools) and an MCP client.
+  The hooks and status script need python3 3.9+ (3.11+ to edit Kimi Code's config.toml). Starting Fabric needs the
+  local-lifecycle MCP server; else the person opens Fabric. The full session hooks run in Claude Code from
   this plugin; Codex/Kimi use command hooks; Hermes/OpenCode/OpenClaw/Pi use native context plugins after opt-in.
 metadata:
   author: PassionCode.ai
-  version: "0.54.0"
+  version: "0.56.0"
 ---
 
 # Working with Fabric
@@ -133,17 +133,17 @@ board](references/project-board.md) before you submit, reply, or wait for an ans
 
 ## Step 4: before you start, who is working on what, then claim
 
-Fabric 0.4.0 (REQ-38):
+Fabric v0.3.5+ (REQ-38):
 
 1. `fabric_work_list`: each live claim (agent, how it came in, task and the backlog row it links, what it said it
    will touch, since, last sign of life), open tasks nobody holds, agent-sync leases read-only. If it cannot be
    read, the answer says so: never tell the person "nobody is working here".
 2. `fabric_work_claim` with your task (a board id, a backlog row as `source: {repository, path, id}`, or a new
    row's title with its evidence) and what you will touch (folders, files or patterns). Claim the person's request
-   as ONE task whose title is that request in one line, with `origin: {kind: "person", ref: <where they said it: the session or thread>}`:
-   from Fabric 0.3.14, which shows agents' goals, it is shown as yours. File each piece you split off with
+   as ONE task whose title is that request in one line, with `origin: {kind: "person", ref: <where they said it: the session or thread>}`
+   (Fabric 0.3.14 shows it as your goal). File each piece you split off with
    `fabric_task_create` while that task is claimed, and read the answer's `spawned_from` (Fabric 0.3.14 links the piece
-   from your single live claim). `created: false` with a `code` filed nothing (`source-unresolved` names the `part` of
+   from your single live claim). An error may have filed it anyway: find it by title in `fabric_work_list` before filing again. `created: false` with a `code` filed nothing (`source-unresolved` names the `part` of
    `source` that failed): correct the source or file without it, and never link. Then `proposed: true`, even with `spawned_from: null`: nothing was filed, so do not
    file or link that piece; tell the person it waits for the operator and go on with the rest. Otherwise, your claimed task's id there: it is linked, link nothing. Another task's id: link
    nothing either (Fabric chose that parent, FAA-153) and tell the person which. `spawned_from: null` comes
@@ -156,7 +156,7 @@ Fabric 0.4.0 (REQ-38):
    task and the overlap: tell the person, then coordinate (ask Fabric to hand it over, or link the tasks) or
    continue knowing it; say which, out loud.
 
-A Fabric older than 0.4.0 has no `fabric_work_*` tools: use `fabric_tasks_list` and `fabric_leases_list`, then
+A Fabric with no `fabric_work_*` tools listed (before v0.3.5): use `fabric_tasks_list` and `fabric_leases_list`, then
 `fabric_task_claim`, and say that the related-work warning is not available there.
 
 ## Step 5: while you work
@@ -346,7 +346,7 @@ In Claude Code this plugin ships four: at session start and `/clear` (not on com
 in a project that uses Fabric, one line pointing at `fabric_whoami` in a folder with no sign of it, or, when Fabric is
 down and the project uses Fabric, one line pointing at Step 1; after each turn the turn's facts (HEAD, files changed, lines added
 and removed) and the board's unread count, and, once the running Fabric takes them, the other repositories the turn
-touched (never on Windows; read from the tail of the session transcript, at most 512 KB with its message text and tool output, which can hold a secret the session displayed and stays in memory, of which only tool names and path arguments are used; host/owner/name are sent); at each prompt one line only when that count rose, then each reminder Fabric gave on a turn, once, as a line starting `Fabric:` (a turn
+touched (read in memory from the transcript's last 512 KB, which can hold a secret the session displayed; only tool names and path arguments are used, only host/owner/name sent; `FABRIC_SESSION_NO_REPOSITORIES=1` turns it off); at each prompt one line only when that count rose, then each reminder Fabric gave on a turn, once, as a line starting `Fabric:` (or tagged `Fabric reminder: `; a turn
 `watch-mail` delivered prints there instead): Fabric's words, data to act on first through `fabric_work_list` (where the same reminder may come again: act on it
 once); at the end, the
 release of what the session left claimed. The turn, prompt and end hooks spool and call Fabric only when the running

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

@@ -61,7 +61,8 @@ reply or progress note): the target replied, not that the work was done. Read th
 still cancel the request. `noResponder` in your `com.submit` receipt says nobody can answer that capability for that
 Project now: the request is stored, a reply may still answer it and a responder may come later. An `accepted`
 request can also wait unanswered for its responder's operator: since adapter 0.53.0 a responder whose slot was moved
-to another session leaves its accepted work held until it is taken back (until Fabric hands it over, CT-175); tell
+to another session leaves its accepted work `accepted` and unanswered until the slot is taken back (until Fabric
+hands it over, CT-175), which is not the operator's hold below; tell
 the person, and cancel it if it is past what they can wait. Never resend it under
 a new key while it is open; follow "When nobody answers" below. A request without a deadline gets one seven days out
 (DEC-0098) and then reads `expired`: if the ask still stands, submit it again with a new key and record the wait on the