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

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

@@ -8,7 +8,8 @@
 //     `x-forwarded-proto` must say https or the request is refused.
 //
 //   node sample-remote-service.mjs --origin https://agent.example.com --port 8443 \
-//     --token-file token --session-key-file session.key [--tls-cert c.pem --tls-key k.pem]
+//     --token-file service.token --session-key-file session.key [--tls-cert c.pem --tls-key k.pem]
+// (service.token, as the Python sample names it: the source check reads a *.token file as a credential, FAA-190.)
 //
 // Secrets come from files (or from the platform as FABRIC_SERVICE_TOKEN / FABRIC_SESSION_KEY),
 // never from an argument vector.

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

@@ -154,7 +154,8 @@ class Service:
             # After the lock, like every other piece of state: the responder's checkpoint lives in the data directory.
             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)
+                                       handler=self.board_answer, admit=self.board_admit, emit=self.log.append, service=self.id,
+                                       links={"board.slot.moved": "/"})  # the page with Take back (FAA-187 (21))
             # 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,
@@ -205,13 +206,21 @@ class Service:
         # (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 {}
+        via = act.get("via") if isinstance(act.get("via"), str) else None  # a via that is no string names none (FAA-187 (25))
         how = {"dashboard": " on this service's page", "relayed-instruction": " through an agent they told",
-               "mandate": " under a standing mandate"}.get(act.get("via"), "")
+               "mandate": " under a standing mandate", "approval": " with an approval they signed",
+               "elicitation": " answering this service's question"}.get(via or "", "")
+        who = "An approver" if via == "approval" else "The operator"  # an approval is the approver's act (FAA-187 (28))
         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),
+        extra = {}
+        for kept in (value, {k: v for k, v in value.items() if k != "caller"}):  # the caller alone dropped first (24)
+            data = {"schema": fbd.EVENT_SCHEMA, "value": kept}
+            if not fs.feed_data_problems(data):  # data the feed refuses never undoes the answer
+                extra = {"data": data}
+                break
+        # Its own kind (FAA-325): the slot is still away; the kit says board.slot.returned once it is held again.
+        self.log.append("board.slot.taken_back", "info", "%s took the %s slot back%s; the service enrolls once the "
+                        "other session lets it go." % (who, capability, how),
                         subject={"type": "capability", "id": capability}, **extra)
         return {"capability": capability, "moved": False}
 
@@ -437,8 +446,9 @@ def make_handler(svc: Service):
                 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).
+                    # caller: a machine id, as the tool records one (FAA-187 (31)): the operator's signed-in dashboard session
                     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"}))
+                                                               {"by": "operator", "via": "dashboard", "caller": "dashboard:session"}))
                 except (ValueError, RecursionError, fs.ServiceError, fbd.BoardError) as exc:
                     return self._send(400, {"error": str(exc)})
             if url.path == "/api/emit":

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/tailnet-groups.schema.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "urn:passioncode-ai:fabric-agent-adapter:tailnet-groups:1",
+  "title": "tailnet-groups/1: who may open which door of a service behind tailscale serve (FAA-324)",
+  "description": "The groups file an organization writes for a service that reads Tailscale-User-Login through fabric_tailnet_identity (Python) or fabric-tailnet-identity.mjs (Node). A login is allowed at a door for a capability when it belongs to a group that has a rule for that door listing the capability, or listing \"*\". Logins are compared lowercased as ASCII. One rule this schema cannot say and the module enforces: every rule's group is a key of groups. A file that is unreadable or breaks this schema closes every door of the service until it is fixed.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema", "groups", "rules"],
+  "properties": {
+    "schema": {
+      "const": "tailnet-groups/1"
+    },
+    "about": {
+      "type": "string",
+      "maxLength": 1000,
+      "description": "Free text for the people who keep the file; the service never reads it."
+    },
+    "groups": {
+      "type": "object",
+      "description": "Group name to its members' Tailscale login names.",
+      "propertyNames": {
+        "pattern": "^[a-z][a-z0-9._:/-]{0,127}$"
+      },
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "pattern": "^[A-Za-z0-9._%+-]{1,128}@[A-Za-z0-9.-]{1,125}$"
+        }
+      }
+    },
+    "rules": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["group", "door", "capabilities"],
+        "properties": {
+          "group": {
+            "type": "string",
+            "pattern": "^[a-z][a-z0-9._:/-]{0,127}$",
+            "description": "A key of groups."
+          },
+          "door": {
+            "enum": ["dashboard", "mcp", "service"],
+            "description": "dashboard: the service's pages; mcp: its MCP endpoint; service: its own door (an API, a webhook)."
+          },
+          "capabilities": {
+            "oneOf": [
+              {
+                "const": "*",
+                "description": "Every capability of the door."
+              },
+              {
+                "type": "array",
+                "minItems": 1,
+                "items": {
+                  "type": "string",
+                  "pattern": "^[a-z][a-z0-9._:/-]{0,127}$"
+                },
+                "description": "The capability names the service asks for at this door (a page, a tool, an action)."
+              }
+            ]
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -9,7 +9,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.82.0"
+  version: "0.84.1"
   contract-version: "0.1.0"
   contract-commit: "93e7db164c7829e2783b4b7705c4113bb5201131"
 ---
@@ -70,10 +70,10 @@ board (or, with a grant, its scan tool over the source projects), and build from
 | **Which profile?** | `mcp` when Fabric owns planning and retries and the capability has a schema; `a2a` when the provider owns its task lifecycle end to end; `local-runner` when it is a terminal agent Fabric drives. When unsure, the sibling skill's profile-selection reference is the decision record |
 | **What effects?** | declare anything money-, deletion-, or publication-adjacent now; the host's floor and grants are designed against these declarations, and one discovered late invalidates the admission |
 | **Where does it run, for whom?** | this machine, the person's cloud or an organization's, and in which contexts (`personal`, `org:<id>`): one instance per context, its secrets, spend and journal never crossing into another. Record which capabilities need the person's machine and what they answer when it is off (references/where-agents-run.md) |
-| **Does it run around the clock?** | the uptime category, decided now: **A** when a capability must answer while the owner's machine is off or asleep (a schedule, a chat, callers outside the machine): the agent gets a cloud host from its first release, Heroku unless a reason names another (the person's or an organization's cloud, or PassionCode's for a paid agent), built as an online service (building-fabric-services, the remote placement) and started from the cloud Fabric-server template once that template's repository exists; **B** when nothing needs it then: a local service only, no cloud, reading an A agent's data through that agent's MCP or API. The README names the category (references/where-agents-run.md) |
+| **Does it run around the clock?** | the uptime category, decided now: **A** when a capability must answer while the owner's machine is off or asleep (a schedule, a chat, callers outside the machine): the agent gets a cloud host from its first release, Heroku unless a reason names another (the person's or an organization's cloud, or PassionCode's for a paid agent), built as an online service (building-fabric-services, the remote placement) and started from the cloud Fabric-server template, whose repository an agent reads from the instance's settings or the estate's agent map, never from this skill; **B** when nothing needs it then: local only, no cloud (a local service, or a CLI or local runner when nothing calls it while the owner is away), reading an A agent's data through that agent's MCP or API. The README names the category (references/where-agents-run.md) |
 | **Whose data does it keep?** | the kind of its data, named in the README: **U** when it keeps data of people outside the owner's team (messages, support requests, reviews, customers' answers), which never enters the source, a copy of it or its tests: the source holds the schema and synthetic fixtures, and a copy starts with an empty store of its own; **O** when it keeps none (a tool or service for other agents, the owner's reports, runs and media). In doubt, U. Either way the data lives in `<agent>-data` (a kit service: the kit's folders; on a cloud host: a durable store), apart from the source, from the first commit (references/source-and-instance.md) |
 | **Who holds the copyright?** | the holder the agent's `LICENSE` names: a new private agent (built for its owner or for a client) gets a `LICENSE` naming that holder in its first commit, all rights reserved unless the owner gives other terms; a public product keeps its own licence (a PassionCode.ai repository: the organization's, step 2) |
-| **Which models?** | per lane (planning, replies, volume work, media): a primary, a fallback of another vendor, an open-vendor model where it reads what users send, the input kinds each reads, declared as classes in the profile (references/models-and-providers.md) |
+| **Which models?** | per lane (planning, replies, volume work, media): a primary, a fallback of another vendor, an open-vendor model where it reads what users send, the input kinds each reads, named as catalogue models in the profile, narrowed by classes on the spend policy or grant (references/models-and-providers.md) |
 | **Who pays?** | one key per agent and context with its own ceiling (USD 100 a month by default, more only where the operator names it), from the estate's key manager, read from the environment; checked before every call, the agent's own stop under the key's limit; 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*) |
@@ -139,7 +139,7 @@ lists them. An agent someone builds for themselves, or a private agent built for
 is its owner's choice and none of those files is required of it, but its first commit carries a `LICENSE` naming
 the copyright holder the grill recorded (all rights reserved unless the owner gives other terms); it covers the
 holder's own files, and the kit files the adapter copies in keep their own licence (AGPL-3.0-only OR
-LicenseRef-PassionCode-Commercial).
+LicenseRef-PassionCode-Commercial), each service kit module in its own SPDX line.
 
 **Every credential the agent uses is read by name, never held as a value**, from its first commit:
 the README's Configure section lists key NAMES. With Project Observatory installed, the agent finds
@@ -147,7 +147,8 @@ them with `observatory_credentials` and runs under
 `python3 "$(project-observatory full-path)/tools/use_secret.py" run --vault-only <project> <NAME> -- <command>`
 (a long-running service: `use_secret.py serve`), with `OBSERVATORY_VAULT_ONLY=1` in its environment.
 Without it, the person's OS keychain or secret manager injects the key into the agent's environment
-at start. Either way: no `.env` of its own, no key file beside its data, no value in argv, code,
+at start. An uptime A agent's keys are its platform's secrets, set from Observatory or the person's secret manager,
+never a file in the deploy. Either way: no `.env` of its own, no key file beside its data, no value in argv, code,
 configuration or a commit. A workflow names the keys it needs in its checkpoint (`credentials`),
 never their values.
 

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

@@ -42,3 +42,19 @@ has, 2 on a usage error; `--json` prints `{ok, folders: {<folder>: [{level, file
 `never_*` keys, `block`, `spend`, `checkedAgainst`) and names each as a warning with its canonical form; a missing
 `direction` or manifest `version` is a warning there and an error otherwise. Use it to migrate a folder, then fix the
 warnings: a template is done when the check passes without it.
+
+## The admission check
+
+```
+python3 <skill>/scripts/admit.py <project-root> [--service ID[.INSTANCE]] [--services-dir DIR] [--template FOLDER ...]
+                                 [--private-terms FILE] [--json]
+```
+
+One command for the checks a new agent passes before it runs (FAA-271): the source check
+(adapting-projects-to-fabric's `fabric_source_check.py check`), the probe (`check_service.py`, with `--service`), this
+template check, strict, on each `--template` folder, and the tracked files against the operator's private-terms list
+(`--private-terms`, else `$PASSIONCODE_PRIVATE_TERMS`, else `~/.config/passioncode/private-terms.txt`). Each step reads
+PASS, FAIL or NOT_RUN; a step with nothing to read (no service, no template, no list) is NOT_RUN, which is not a pass.
+It reads only and prints paths, lines and kinds, never a value or a term. Exit 0: no FAIL and the source check read
+every file; 1: a FAIL; 2: a usage error or a source check that could not run. Which role runs it, and when, is
+Observatory's to decide.

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

@@ -48,6 +48,16 @@ repository-relative path at a commit, an eval report). A decision without a numb
 | building-fabric-services | at each release | contribute the release's measured wins as success cases and its new technical decisions |
 | working-with-fabric | the retro after work | a lesson with a measured effect is also a success case: contribute it beside the lesson it records |
 
+## A template and the communication prompt
+
+For an agent that talks with people on a channel, the database's template and creating-fabric-agents' communication
+agent prompt (`references/communication-agent-template.md`) are read together, never as two templates (the database's
+own rule). Where they disagree, the template wins, in every part and not only the first-release ones: it is the merged
+practice of the agents of its kind. A part the prompt carries and the template lacks (a first-release part, a check, a
+pipeline step) is built too, unless the template rules it out, and goes back to the database as feedback on that
+template (`agents-db.contribute`); the completion report names each such part. Without a template for the kind, the
+prompt is the recipe.
+
 ## Recording the template
 
 An agent built from a template declares it: `provenance.template` with its id and version, so a later template

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

@@ -17,8 +17,9 @@ practices arrive with [PR #70](https://github.com/ssheleg/agent-stack/pull/70),
 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,
+default) and the rest of its checks that caught real defects, its weekly assessment loop, P4's other lane rules (the
+classifier's closed output schema, the writer as the strongest model the latency allows, the fallback writer's
+triggers, the switch rule), 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; with a repairing `on_handoff` it rewrites a refused draft once (`repair=`, a
 spent repair being `fallback: true`: a second refusal, a declined repair or no knowledge on the retry; a `model:*`
@@ -44,7 +45,8 @@ outage during the repair is a plain hand-off), and research and the hold stay th
   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.
+  most 30 days. Check: a test that a turn without a trace id, or with an outcome outside the list, is refused, and a
+  test that conversation text past 30 days is gone and that what is kept carries no address, number or key.
 - **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
@@ -58,7 +60,10 @@ outage during the repair is a plain hand-off), and research and the hold stay th
   every reader of the feed it knows of has adopted DEC-0144: the producer then re-publishes its copy from DEC-0144's
   bytes (CT-188), and leaves the calibration out when the judge or the rubric changed after the labelled week. A
   reader validates against its own pinned copy, never one fetched by `$id`: the bytes under the unchanged `$id`
-  widened. Check: the producer's day passes `make_event` and validates against the producer's pinned copy of the
+  widened. At the contract repin to DEC-0144 (FAA-176), a producer that pinned its own copy keeps its URI in
+  `data.schema` and re-publishes that URI's bytes from DEC-0144's: since the `$id` did not change and the bytes only
+  widened, every day the older copy accepted still validates, so a reader needs no window of two URIs (this page's
+  rule, not the contract's words). Check: the producer's day passes `make_event` and validates against the producer's pinned copy of the
   schema; 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.
 
@@ -66,8 +71,8 @@ outage during the repair is a plain hand-off), and research and the hold stay th
 
 - **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
+  reads what people wrote. Name each lane's catalogue models in the profile, narrowed by the classes the spend policy
+  or grant holds (`modelClasses`), 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
@@ -110,8 +115,8 @@ outage during the repair is a plain hand-off), and research and the hold stay th
   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,
+  what to fix. A hold after a checker or model outage, or at the research time cap, is `infrastructure` (this page's
+  reading of P3, not the sources' words); 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
@@ -126,7 +131,7 @@ outage during the repair is a plain hand-off), and research and the hold stay th
 - **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.
+  hold in place, and a hold after a checker outage opens no gap (this page's reading of P7, not the sources' words).
 
 ## Reading the events feed
 

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/models-and-providers.md

@@ -30,8 +30,10 @@ model, FAC-SEM-112) and `openrouter-attribution.md` (FAC-SEM-098). The kit that
   primary is closed (DEC-0083: declare `reads: ["user-content"]` on the profile; FAC-SEM-112 refuses a route without
   one). Closed vendors refuse or hedge on whole topics; the lane must still handle the worst message it receives.
 - **A judge is another vendor than the writer.** A model grading its own family rates its own habits.
-- **Declare classes, not names, in the agent's profile** (`modelClasses`): the policy and the binding narrow them, and
-  the host resolves the model. A hard-coded model name in code is a release to change it.
+- **Name catalogue models in the profile, and classes where the contract keeps them**: at the pin a model profile names
+  catalogue model ids per lane, and `modelClasses` lives on the project's spend policy or a grant, which narrow the
+  profile's models (building-fabric-services, `references/profiles.md`); the host resolves the model. A hard-coded model
+  name in code is a release to change it.
 
 ## A starting choice
 

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/source-and-instance.md

@@ -54,7 +54,11 @@ source under it.
 
 - **The data has a home of its own from the first commit: `<agent>-data`.** For an agent that is not a kit service it
   is a folder beside the checkout, never inside it, and `<AGENT>_DATA_DIR` names it (its default is
-  `../<agent>-data`); a kit service keeps the kit's folders above. When the owner keeps the data in Git, it goes to a
+  `../<agent>-data`, resolved against the checkout's root, the folder that holds the agent's source, never the working
+  directory). Two sibling checkouts, and a second context's instance from the same checkout (an organization's beside
+  the personal one), would share that default: each sets its own `<AGENT>_DATA_DIR` (`../<agent>-data.<instance>`), so
+  no copy reads another's data. A kit service keeps the kit's folders above, and on a host whose disk does not persist
+  `FABRIC_DATA_HOME` moves its data folder onto a durable volume (building-fabric-services, the remote placement). When the owner keeps the data in Git, it goes to a
   separate private repository named `<agent>-data`, never to the source's repository. On a cloud host that does not
   keep its disk across a restart (Heroku and the like, an uptime A agent's default), the data home is a durable store
   the same variable names (a database, an object store, that private repository); the folder and the kit's folders
@@ -114,13 +118,22 @@ untracked ones that are not ignored, as they are in the work tree; a staged copy
 | Kind | Finds |
 |---|---|
 | `home-path` | an absolute path inside a person's home folder (a web route under `/home/` is reported too; a route under `/users/` is not): `/Users/<name>/`, `/home/<name>/`, `C:\Users\<name>\`, Git Bash's `/c/Users/<name>/`, WSL's `/mnt/c/Users/<name>/`, and the dashed (`-Users-<name>-`, `C--Users-<name>-`) and URL-encoded forms a tool makes of one. The name is ASCII, and in the dashed form it ends at the next dash: an owner whose home name holds a space, a dash, a dot, an underscore or an apostrophe (each a dash in the dashed form; a slashed name also ends at a space) declares it with `home: <name>` in the owner's list, which reads it whole in every form, and one whose home name is not ASCII, or holds another character, lists it as a plain string (a typographic apostrophe a keyboard typed, which the folder's name does not hold, is written as `'` in `home:`; a folder whose name holds `’` is listed as a plain string with `’` kept and declared too with `home: <name>` written with `'`, which reads the dashed forms; its URL-encoded `’` is not read; a name outside ASCII of one or two characters cannot be checked) |
-| `secret` | a value shaped like a credential by the contract's detector (DEC-0044), read line by line: a provider key starting a word, a JWT, a bearer token, a long random value assigned to a credential's name (but a whole Ed25519 signature under a JSON `"sig"`, `"signature"` or `"signatures"` member, as `sign` writes it, which is public); or a private key: a PEM, OpenSSH or PGP block, or a JWK's `d` as a JSON member, escaped JSON or a Python dict; a URL with a password of 8 or more characters mixing letters and digits (a password without a digit or without a letter is not read) or a credential in its query, percent-encoded or not, JSON-escaped (`\u0026`, `\/`) or nested in another URL's parameter (two levels deep); a file that is a credential by its name, as `pack` refuses it (`.env`, `*.pem`, `*.key`, `.npmrc` and the rest), or a kit credential file (`*.token`, `board.credential`) |
+| `secret` | a value shaped like a credential by the contract's detector (DEC-0044), read line by line: a provider key starting a word, a JWT, a bearer token, a long random value assigned to a credential's name (a run of 40 or more characters mixing upper case, lower case and digits, so a shorter key under `X_API_KEY=` is not read; but a whole Ed25519 signature under a JSON `"sig"`, `"signature"` or `"signatures"` member, as `sign` writes it, which is public); or a private key: a PEM, OpenSSH or PGP block, or a JWK's `d` as a JSON member, escaped JSON or a Python dict; a URL with a password of 8 or more characters mixing letters and digits (a password without a digit or without a letter is not read) or a credential in its query, percent-encoded or not, JSON-escaped (`\u0026`, `\/`) or nested in another URL's parameter (two levels deep); a file that is a credential by its name, as `pack` refuses it (`.env`, `*.pem`, `*.key`, `.npmrc` and the rest), or a kit credential file (`*.token`, `board.credential`) |
 | `instance-string` | a string from the owner's list, in a file, in a file's path or in a link's target |
 
 ```bash
 python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/fabric_source_check.py check <project-root>
 ```
 
+Run it by path, with its scripts folder whole: it loads its siblings (`fabric_source_ignore.py`,
+`fabric_source_homes.py`, `fabric_source_restart.py`, `fabric_source_check_cli.py`, `fabric_source_tree.py` and the
+contract's detector `fabric_secrets.py`) and refuses with exit `2` when one is missing or from another version, a
+detector without one of the public names it reads included (FAA-190). `python3 -m fabric_source_check` writes its own
+`.pyc` before the check turns bytecode off; run by path, it writes nothing. `ROOT` defaults to the current folder.
+`--json` prints one object: `mode` (`git` or a walk), `files`, `findings` (`path`, `line`, `kind`, `rule`),
+`notRead`, `skipped`, `dependencies`, `instanceStrings`, `ownerHomes`, `instanceList`, `blocking` (a finding) and
+`complete` (every file read); `--help` names each option.
+
 - It **never repeats** a value it found: no value, no line holding one, no entry of the owner's list and not the
   folder it checks reaches its output. A file's path is checked like its text (line `0` of a finding), and printed
   with an entry of the list as `<line N>`, a home folder's name as `<home>` and each segment holding a
@@ -167,7 +180,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/fabric_source_ch
   percent-encodings or an escaped apostrophe (`\'`, `\x27`, `\u0027`, `&#39;`, `&#x27;`, `&apos;`), the same separators it is found with in every form; a home that is also your name goes in the list
   as a plain string too, to be found in text. It is `--instance-strings FILE`, else the file
   `FABRIC_INSTANCE_STRINGS` names, else `passioncode-fabric/instance-strings.txt` in the user's configuration folder
-  (`$XDG_CONFIG_HOME` when it is absolute, else `~/.config`; `%APPDATA%` on Windows). A list inside the tree is refused, because it would
+  (`$XDG_CONFIG_HOME` when it is absolute, else `~/.config`; on Windows `%APPDATA%` when it is absolute, else `~\AppData\Roaming`). A list inside the tree is refused, because it would
   travel with the source. A person who already keeps private terms for org-index's `check_private.py`
   (`~/.config/passioncode/private-terms.txt`) passes that file with `--instance-strings`; this check matches a term
   anywhere in a word, and it does not look for e-mail addresses or account ids by their shape.
@@ -183,7 +196,8 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/fabric_source_ch
   repository is not read; `--every-file` and a folder outside Git read its files, its `.git` left out. An exception line (`!`) is refused, since what it would
   bring back would go unread. Name the files, or a folder that holds
   only synthetic vectors, never a whole source folder (a nested repository checked in its own tree is the one
-  exception), and say why on the line above. The `LICENSE` is the other: its copyright line names the holder, which is
+  exception), and say why on the line above. The one owner's file named this way is the `LICENSE` (a file, never a
+  folder exception): its copyright line names the holder, which is
   authorship and travels with the source, so when the holder is on the owner's list the licence file is named in the ignore
   file by its own path (`LICENSE`, `LICENSE.md`) with that reason (`# the copyright holder is authorship and travels with the source`); no other file of the
   owner's is. A file `pack` refuses by its name cannot ship in a package: a public

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/where-agents-run.md

@@ -106,11 +106,12 @@ Every new agent is given an uptime category on its first day, and the README nam
   (the places above), and a paid agent stays in PassionCode's cloud (selling an agent, below). On a host with no
   Fabric hub it answers what reaches its own origin (its schedule, its chat, its API); a call Fabric admits needs a
   cloud hub, as running while the laptop is closed says. The agent is an online service (building-fabric-services, the remote placement), often
-  alongside its local instance, and starts from the cloud Fabric-server template once that template's repository
-  exists. Its data lives where the cloud reaches it, in a durable store (a database, an object store, the private
+  alongside its local instance, and starts from the cloud Fabric-server template, whose repository an agent reads from
+  the instance's settings or the estate's agent map; this public skill names no repository or address for it. Its data lives where the cloud reaches it, in a durable store (a database, an object store, the private
   `<agent>-data` repository), never the host's own folder, which a platform such as Heroku does not keep across a
   restart.
-- **B, local only.** Nothing needs it while the machine sleeps: a local service and no cloud. It reads an A agent's
+- **B, local only.** Nothing needs it while the machine sleeps: no cloud, and a local service only when other
+  agents call it or it shows a page (building-fabric-services Step 0), else a CLI or a local runner. It reads an A agent's
   data through that agent's MCP or API, never from its store.
 
 A B agent that gains a capability that must answer around the clock becomes A for that capability; record the change

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/scripts/admit.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""The admission check a new agent passes before it runs (FAA-271, North Star G27, the adapter's part): one command
+that chains the checks this plugin ships and reports each as PASS, FAIL or NOT_RUN.
+
+    python3 admit.py <project-root> [--service ID[.INSTANCE]] [--services-dir DIR] [--template FOLDER ...]
+                     [--private-terms FILE] [--json]
+
+1. `source`: adapting-projects-to-fabric's `fabric_source_check.py check <project-root>`: no instance data in what
+   Git would commit (exit 1 a finding, 2 a file not read; both are no admission).
+2. `probe`: building-fabric-services' `check_service.py <service>` with `--service`: the running service against
+   fabric-service/0.1; NOT_RUN for an agent that is no service.
+3. `template`: this skill's `template_check.py` (strict) on each `--template` folder; NOT_RUN with none.
+4. `private-terms`: the tracked files against the operator's private-terms list (the organization's rule P1:
+   `--private-terms`, else `$PASSIONCODE_PRIVATE_TERMS`, else `~/.config/passioncode/private-terms.txt`); NOT_RUN where
+   there is no list, which is not a pass.
+
+It reads only and writes nothing; it never prints a value a check found, a term of the list or a line holding one (the
+checks it runs print paths, lines and kinds). Exit 0: no FAIL and the source check read every file; 1: a FAIL; 2: a
+usage error or a check that could not run. Who runs it and when (Observatory's security role) is not decided here.
+Standard library only.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+from typing import Dict, List, Optional
+
+SKILLS = Path(__file__).resolve().parent.parent.parent
+SOURCE_CHECK = SKILLS / "adapting-projects-to-fabric/scripts/fabric_source_check.py"
+PROBE = SKILLS / "building-fabric-services/scripts/check_service.py"
+TEMPLATE_CHECK = Path(__file__).resolve().parent / "template_check.py"
+PRIVATE_TERMS_ENV = "PASSIONCODE_PRIVATE_TERMS"
+SKIP = {".git", "node_modules", "__pycache__", ".venv", "venv"}
+
+
+def _run(command: List[str]) -> "subprocess.CompletedProcess[str]":
+    return subprocess.run([sys.executable, "-B"] + command, capture_output=True, text=True, encoding="utf-8",
+                          errors="replace", check=False)
+
+
+def _result(step: str, verdict: str, evidence: str, lines: Optional[List[str]] = None) -> Dict[str, object]:
+    return {"step": step, "verdict": verdict, "evidence": evidence, "lines": lines or []}
+
+
+def source_step(root: Path) -> Dict[str, object]:
+    done = _run([str(SOURCE_CHECK), "check", str(root)])
+    lines = [line for line in done.stdout.splitlines() if line.strip()]
+    summary = lines[-1] if lines else (done.stderr.strip().splitlines() or ["no output"])[-1]
+    if done.returncode == 0:
+        return _result("source", "PASS", summary)
+    if done.returncode == 1:
+        return _result("source", "FAIL", summary, lines[:-1])
+    return _result("source", "NOT_RUN", "the source check did not read every file or could not run: %s" % summary,
+                   lines[:-1])
+
+
+def probe_step(service: Optional[str], services_dir: Optional[str]) -> Dict[str, object]:
+    if not service:
+        return _result("probe", "NOT_RUN", "no --service: an agent that is no service has no descriptor to probe")
+    command = [str(PROBE), service, "--json"] + (["--services-dir", services_dir] if services_dir else [])
+    done = _run(command)
+    try:
+        report = json.loads(done.stdout)
+    except ValueError:
+        reason = (done.stderr.strip().splitlines() or ["no report"])[-1]
+        return _result("probe", "FAIL", "the probe gave no report for %s: %s" % (service, reason))
+    failed = [r for r in report.get("results", []) if r.get("verdict") == "FAIL"]
+    not_run = sum(r.get("verdict") == "NOT_RUN" for r in report.get("results", []))
+    evidence = "%d rule(s), %d FAIL, %d NOT_RUN" % (len(report.get("results", [])), len(failed), not_run)
+    return _result("probe", "FAIL" if failed else "PASS", evidence, ["%s: %s" % (r["rule"], r["evidence"]) for r in failed])
+
+
+def template_step(folders: List[str]) -> Dict[str, object]:
+    if not folders:
+        return _result("template", "NOT_RUN", "no --template folder named")
+    done = _run([str(TEMPLATE_CHECK), "--json"] + folders)
+    try:
+        report = json.loads(done.stdout)
+    except ValueError:
+        return _result("template", "FAIL", "the template check gave no report (exit %d)" % done.returncode)
+    errors = ["%s: %s %s: %s" % (folder, f["file"], f["path"], f["message"])
+              for folder, findings in report.get("folders", {}).items() for f in findings if f.get("level") == "error"]
+    return _result("template", "PASS" if report.get("ok") else "FAIL",
+                   "%d folder(s), %d error(s)" % (len(folders), len(errors)), errors)
+
+
+# The one private-terms reader (FAA-328): test/validate.py, the repository's own check, reads the list with these
+# functions too, so the two never drift. They match as org-index's check_private.py does: case-insensitive, not inside a
+# run of ASCII letters and digits, longest term first. Callers report paths and lines only, never a term.
+def terms_file(named: Optional[str] = None) -> Path:
+    """The list: `named`, else `$PASSIONCODE_PRIVATE_TERMS`, else ~/.config/passioncode/private-terms.txt; `~` expanded."""
+    named = named or os.environ.get(PRIVATE_TERMS_ENV)
+    return Path(named).expanduser() if named else Path.home() / ".config/passioncode/private-terms.txt"
+
+
+def terms_pattern(lines: List[str]) -> "Optional[re.Pattern[str]]":
+    """One alternation of the list's terms (a line that is blank or starts with # is none), longest first; None when
+    the list holds no term."""
+    terms = sorted({t.strip() for t in lines if t.strip() and not t.strip().startswith("#")}, key=len, reverse=True)
+    if not terms:
+        return None
+    return re.compile(r"(?<![A-Za-z0-9])(?:" + "|".join(re.escape(t) for t in terms) + r")(?![A-Za-z0-9])", re.IGNORECASE)
+
+
+def term_lines(text: str, pattern: "re.Pattern[str]") -> List[int]:
+    """The 1-based numbers of the lines of `text` that hold a term."""
+    return [n for n, line in enumerate(text.splitlines(), 1) if pattern.search(line)]
+
+
+def listed_files(root: Path) -> List[str]:
+    """Every tracked file and every untracked one Git does not ignore, as check_private.py reads a work tree; outside a
+    work tree, or where git cannot run, every file but the usual generated folders, never nothing."""
+    if (root / ".git").exists():
+        try:
+            listed = subprocess.run(["git", "-C", str(root), "ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+                                    capture_output=True, check=False)
+        except OSError:
+            listed = None
+        if listed is not None and listed.returncode == 0:
+            return sorted({rel for rel in listed.stdout.decode("utf-8", "replace").split("\0") if rel})
+    return sorted(p.relative_to(root).as_posix() for p in root.rglob("*")
+                  if p.is_file() and not SKIP.intersection(p.relative_to(root).parts))
+
+
+def private_terms_step(root: Path, named: Optional[str]) -> Dict[str, object]:
+    path = terms_file(named)
+    if not path.is_file():
+        return _result("private-terms", "NOT_RUN", "no private-terms list on this machine (set %s): not a pass"
+                       % PRIVATE_TERMS_ENV)
+    pattern = terms_pattern(path.read_text(encoding="utf-8").splitlines())
+    if pattern is None:
+        return _result("private-terms", "PASS", "the list holds no term")
+    hits: List[str] = []
+    files = listed_files(root)
+    for rel in files:
+        try:
+            data = (root / rel).read_bytes()
+        except OSError:
+            continue
+        if b"\0" in data[:8192]:
+            continue
+        found = [str(n) for n in term_lines(data.decode("utf-8", "replace"), pattern)]
+        if found:
+            hits.append("%s: line%s %s" % (rel, "s" if len(found) > 1 else "", ", ".join(found)))
+    return _result("private-terms", "FAIL" if hits else "PASS",
+                   "%d file(s) read, %d naming a term of the list (paths and lines only)" % (len(files), len(hits)), hits)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="admit.py", description="The admission check a new agent passes before it runs.")
+    parser.add_argument("root", help="the agent's project root")
+    parser.add_argument("--service", help="the service to probe, ID or ID.INSTANCE")
+    parser.add_argument("--services-dir", help="the services folder the probe reads (default: Fabric's)")
+    parser.add_argument("--template", action="append", default=[], metavar="FOLDER", help="a template folder to check")
+    parser.add_argument("--private-terms", metavar="FILE", help="the operator's private-terms list")
+    parser.add_argument("--json", action="store_true", help="one JSON object: steps, admitted")
+    args = parser.parse_args(argv)
+    root = Path(args.root).expanduser()
+    if not root.is_dir():
+        print("admit.py: %s is not a folder" % root, file=sys.stderr)
+        return 2
+    steps = [source_step(root), probe_step(args.service, args.services_dir), template_step(args.template),
+             private_terms_step(root, args.private_terms)]
+    failed = any(s["verdict"] == "FAIL" for s in steps)
+    source_ran = steps[0]["verdict"] != "NOT_RUN"
+    admitted = not failed and source_ran
+    if args.json:
+        print(json.dumps({"steps": steps, "admitted": admitted}, indent=2, ensure_ascii=False))
+    else:
+        for step in steps:
+            print("%-8s %-14s %s" % (step["verdict"], step["step"], step["evidence"]))
+            for line in step["lines"]:  # type: ignore[union-attr]
+                print("         %s" % line)
+        print("admitted" if admitted else "not admitted")
+    return 1 if failed else (0 if source_ran else 2)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/fabric-agent-adapter/skills/observing-products/SKILL.md

@@ -12,7 +12,7 @@ compatibility: >-
   from Project Observatory's vault by slot name when it is installed.
 metadata:
   author: PassionCode.ai
-  version: "0.82.0"
+  version: "0.84.1"
 ---
 
 # Observing products

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

@@ -13,7 +13,7 @@ compatibility: >-
   this plugin; Codex/Kimi use command hooks; Hermes/OpenCode/OpenClaw/Pi use native context plugins after opt-in.
 metadata:
   author: PassionCode.ai
-  version: "0.82.0"
+  version: "0.84.1"
 ---
 
 # Working with Fabric

package/plugins/fabric-agent-adapter/skills/working-with-fabric/references/agents-database.md

@@ -48,6 +48,16 @@ repository-relative path at a commit, an eval report). A decision without a numb
 | building-fabric-services | at each release | contribute the release's measured wins as success cases and its new technical decisions |
 | working-with-fabric | the retro after work | a lesson with a measured effect is also a success case: contribute it beside the lesson it records |
 
+## A template and the communication prompt
+
+For an agent that talks with people on a channel, the database's template and creating-fabric-agents' communication
+agent prompt (`references/communication-agent-template.md`) are read together, never as two templates (the database's
+own rule). Where they disagree, the template wins, in every part and not only the first-release ones: it is the merged
+practice of the agents of its kind. A part the prompt carries and the template lacks (a first-release part, a check, a
+pipeline step) is built too, unless the template rules it out, and goes back to the database as feedback on that
+template (`agents-db.contribute`); the completion report names each such part. Without a template for the kind, the
+prompt is the recipe.
+
 ## Recording the template
 
 An agent built from a template declares it: `provenance.template` with its id and version, so a later template