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

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # Changelog
 
+## 0.34.1 - 2026-10-15
+
+A review of 0.33.0 and 0.34.0 found the profile and route rules disagreeing with the contract on JSON they never met in
+its vectors. The kits now answer as the contract's TypeScript does on any input. The contract pin is unchanged
+(`d8146cf`).
+
+### Fixed
+
+- **FAC-SEM-059 (`runner-profile`) compared loosely.** Python read a missing member and `null` as the same and `1`
+  and `true` as equal: an unknown login with `runnerKind: null`, or an allow-list `true` against a profile `1`, passed.
+  Node threw on a login or runner kind whose own `toString` member is data. Both now compare with `===`, show such a
+  value as its JSON, and read only the vendor table's own members.
+- **FAC-SEM-060 compared a recorded resolution loosely.** Python's `!=` called `1` and `true` equal; Node's
+  `JSON.stringify` comparison called `NaN` and `null` equal. Both now use the contract's `jsonEqual`, where NaN equals
+  nothing.
+- **A refusal (`model-classes-empty`) named its policy wrongly on hostile input.** Node threw on an id or revision
+  whose own `toString` is data; Python wrote `[object Object]`, read `null` as `undefined`, and did not read a revision
+  as `Number()` does (`"0x10"`, `[5]`, `null`). Both now use the contract's `show` and `toNumber`; a revision that is
+  not a number is written as null.
+- **Route rules (FAC-SEM-028…034) threw or misread hostile JSON.** Node used `String()` where the contract uses `show`;
+  Python wrote `[object Object]`, and compared a probe's runner kind and a drive with `!=` (`1` equal to `true`).
+- **The doctor's `model_usable` raised on a catalogue row whose id is an object** (Python), and threw on a policy id
+  whose own `toString` is data (Node).
+- **Python wrote and compared JSON values unlike JavaScript** (found by an independent review of this fix):
+  - a lone surrogate (`"\ud800"`, valid JSON) raised `TypeError` wherever a message wrote a value, because
+    `_json_stringify` used the RFC 8785 writer that refuses one; it now escapes it as `JSON.stringify` does;
+  - members whose keys are array indexes came out in the order written, where JavaScript writes them first and
+    ascending, so two equal hostile runner kinds were not a FAC-SEM-028 duplicate;
+  - integers past 2**53 compared exactly, where JavaScript compares doubles (`9007199254740993` is
+    `9007199254740992`), and integers past the double range raised `OverflowError` where JavaScript reads Infinity;
+  - a probe index was written as an exact integer instead of JavaScript's number (`1e+21`).
+  These helpers are shared with the estate and identifier kits, whose vectors stay green.
+- **Node looked a rule kind up on inherited members**: `routeProblems("__proto__", …)` threw and `"constructor"`
+  answered the value; both now answer `undefined`, as the contract does.
+- **The task board broke the workspace's publication**: rows FAA-28 and FAA-27a split into six cells (an escaped
+  `\|`, and a fragment a 0.31.0 edit left behind). Both are fixed, and `test/validate.py` now refuses any board row that
+  does not split into the header's columns.
+
+### Evidence
+
+- 38 new profile cases and 21 new route cases (`make_profile_vectors.mjs`, `make_route_vectors.mjs`), each answered by
+  the contract's own rules; cases JavaScript cannot carry as an object (big integers, key order) keep their JSON text.
+  Against 0.34.0's kits the first 44 of them fail 27 Python subtests and two Node tests.
+- The reviewer's side-by-side comparison of the contract, the Node kit and the Python kit on 17 hostile inputs: 17 of
+  17 identical after the fix (Python 1 of 17 before).
+- Unit tests for the doctor and the rule dispatch on hostile input, in both kits; `BoardRowTests` for the board check.
+- Planted defects in the new code, all caught; two were redundant code, now removed.
+
+## 0.34.0 - 2026-10-15
+
+The adapter is pinned at contract `d8146cf`. The profile kits now read what a lane reads (DEC-0083; FAA-45, contract
+CT-52): a model profile that reads what members, clients or the public send keeps an open-vendor model on its route,
+so the lane never runs on closed vendors alone, which refuse the content it exists to handle.
+
+### Changed
+
+- **Repin** from `82e1636` to `d8146cf`. Every vendored vector is byte-identical except `profile-vectors.json`.
+  `82e1636` stays a supported revision.
+- **`open-vendor` is descriptive** in `resolve_model_profile` / `resolveModelProfile` and in the doctor's `model_usable` /
+  `modelUsable`: a project's `modelClasses` never admit or exclude a model by it, and a model whose only class is
+  `open-vendor` is admitted on nothing. Both copies of the every-class rule answer the contract's shared
+  `model-admission.json` vectors.
+- **FAC-SEM-058 and FAC-SEM-060 are total on hostile input**, as the contract's became in DEC-0083's fix round: an
+  `instancePath` names an item by its index as written (a non-object before it no longer shifts it, and every model
+  counts at its own index), a duplicate id is what JavaScript's `Set` calls one (`1` and `true`, `null` and absent, are
+  two), and an id whose own `toString` member is data is shown as its JSON.
+
+### Added
+
+- **FAC-SEM-112** on a `profile-resolution`: a profile with `reads: ["user-content"]` has an open-vendor route — with
+  `fallback: none` its first model is `open-vendor` in the catalogue, with `between-turns` at least one is — and the
+  models the project's policy leaves must still give one, or the finding at `/resolved/models` names the policy.
+  `closed_user_content_route` / `closedUserContentRoute` name the models that would run on a closed route.
+- `creating-fabric-agents` asks in its grill which lanes read user content; `profile-selection.md` and the profiles
+  reference say how such a lane is declared and routed, and that a content refusal or an empty answer is a failed turn.
+
+### Fixed
+
+- **`make_profile_vectors.mjs` read the contract's newer fixtures vacuously.** Since DEC-0083 a profile fixture wraps
+  its document as `{description, kind, expect, input}`; the generator fed the wrapper to the rules, so every expectation
+  came out empty and the Node test passed without checking anything. It now unwraps them and stops when a fixture's own
+  `expect` disagrees with the contract's answer.
+- `resolve_model_profile` takes `catalogue` and `profiles` as optional, as the contract's resolver does, so an absent
+  catalogue resolves instead of raising.
+
+### Evidence
+
+- Both kits answer 72 rule cases (45 crafted: FAC-SEM-112 edges, the policy's outcome, hostile ids and indexes), 81
+  resolutions and 8 admission cases.
+- 51 planted defects (30 in Python, 21 in Node), all caught but two that cannot differ on JSON input: a redundant
+  type check, now removed from the code, and the Node message of a duplicate object id, which parsed JSON never
+  produces. A unit test covers `1` and `1.0` as one id, a case JSON written by JavaScript cannot hold.
+- Eval scenarios `lanes-that-read-user-content` and `user-content-open-vendor-route`.
+
 ## 0.33.0 - 2026-10-15
 
 The adapter is pinned at contract `82e1636`. The estate kits now read contexts (DEC-0082; FAA-41, the RM-28 pilot): one

package/README.md

@@ -251,7 +251,7 @@ Scaffolding is non-destructive by default. It writes only the paths declared in
 The default pin for new bundles is [`fabric-contract.lock.json`](fabric-contract.lock.json):
 
 - version: `0.1.0`
-- commit: `82e163665e156a08aa3b92e4711015582c06162c`
+- commit: `d8146cfb0a1c74fc6432284c4356bb0c864b37b5`
 
 Every other mention of the default contract revision — this section, the skills' metadata, the
 skill card, `adapt_project.py` — must equal it; `python3 test/validate.py` fails a tree

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/fabric-agent-adapter",
-  "version": "0.33.0",
+  "version": "0.34.1",
   "description": "Create Fabric-compatible agents, run them as always-alive local services with dashboards (fabric-service/0.1), and adapt existing projects to the Fabric Agent Contract. This package is the installer CLI.",
   "scripts": {
     "test": "python3 test/validate.py && python3 -m unittest discover -s test -q && node --test 'test/*.test.mjs'"

package/plugins/fabric-agent-adapter/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "fabric-agent-adapter",
   "displayName": "Fabric Agent Adapter",
   "description": "Create new Fabric-compatible agents, build them as always-alive local services with dashboards (fabric-service/0.1), and adapt existing projects to the Fabric Agent Contract through evidence-backed MCP, A2A, or local-runner provider bundles; and teach a coding agent to work in a project through Fabric (fabric-mcp, fabric_whoami, claim and release), with Claude Code session hooks.",
-  "version": "0.33.0",
+  "version": "0.34.1",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/SKILL.md

@@ -5,9 +5,9 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode.
 metadata:
   author: PassionCode.ai
-  version: "0.33.0"
+  version: "0.34.1"
   contract-version: "0.1.0"
-  contract-commit: "82e163665e156a08aa3b92e4711015582c06162c"
+  contract-commit: "d8146cfb0a1c74fc6432284c4356bb0c864b37b5"
 ---
 
 # Adapting projects to Fabric
@@ -70,7 +70,7 @@ Use exactly:
 
 - contract version `0.1.0`;
 - repository `https://github.com/passioncode-ai/fabric-agent-contract`;
-- commit `82e163665e156a08aa3b92e4711015582c06162c`.
+- commit `d8146cfb0a1c74fc6432284c4356bb0c864b37b5`.
 
 This is the default for new bundles. When checking an issued legacy bundle, preserve its
 explicit supported lock and use that exact clean checkout. Never silently upgrade or

package/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/profile-selection.md

@@ -57,7 +57,10 @@ Use when Fabric launches an installed process such as a coding CLI. Require:
 - project-scoped account selection outside the manifest.
 
 The user may choose the project's default terminal and override it per agent. Model choice
-stays inside the selected agent/provider; the Fabric profile remains model-agnostic.
+stays inside the selected agent/provider; the Fabric profile remains model-agnostic. The one
+exception is a lane that reads what members, clients or the public send: its model profile
+declares `reads: ["user-content"]` and has an open-vendor route (contract DEC-0083,
+FAC-SEM-112), whichever models the agent picks.
 
 ## Reject or defer
 

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

@@ -21,10 +21,10 @@ import fabric_secrets as _secrets  # noqa: E402 - the contract's credential dete
 
 CONTRACT_VERSION = "0.1.0"
 CONTRACT_REPOSITORY = "https://github.com/passioncode-ai/fabric-agent-contract"
-CONTRACT_COMMIT = "82e163665e156a08aa3b92e4711015582c06162c"
+CONTRACT_COMMIT = "d8146cfb0a1c74fc6432284c4356bb0c864b37b5"
 # #region supported-contract-revisions — docs: README.md#contract-pin
 # Only this declaration may name a legacy revision in live files.
-SUPPORTED_CONTRACT_COMMITS = (CONTRACT_COMMIT, "1636fa97262f4a26e2086572d540c2ee701e0010", "f00a7685e3861c27f7899c033fb850a145a1708f", "a046f57cf46ea9e3da57ff8ce6a3ed4d26d8774b", "fe55fc67cba1a9e34a736da7d148d4fe2a8fbfa0", "b291bf09e0a9f9fd3c16cf540832cd021203b7d1", "0cacd08b0e95b6abf131eae1206b60792138bc3c", "2eb91c00e852d9c31d804310d38fad91589fcbac", "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5", "a83bec6b47776af688402c18efec507143061f68", "52da526d7cc1e063d74c5b520dbc03d0ace15246", "78b2da018d2c4bd9ac1bde1dc3b7f1a110a175f5", "623bf61358c339cb10297807b3f024b5d9f1f327", "23f9fda4c05f8a3852246ee98d4f2adf74ed0875", "9091d3d6606b0c4b5591a38c3674356a01fd7f55", "df55c8c54a23251342a7ee57ba95642b7eb39e61", "2ce392291c6668598d12cd38327e24696b5ca15c")
+SUPPORTED_CONTRACT_COMMITS = (CONTRACT_COMMIT, "82e163665e156a08aa3b92e4711015582c06162c", "1636fa97262f4a26e2086572d540c2ee701e0010", "f00a7685e3861c27f7899c033fb850a145a1708f", "a046f57cf46ea9e3da57ff8ce6a3ed4d26d8774b", "fe55fc67cba1a9e34a736da7d148d4fe2a8fbfa0", "b291bf09e0a9f9fd3c16cf540832cd021203b7d1", "0cacd08b0e95b6abf131eae1206b60792138bc3c", "2eb91c00e852d9c31d804310d38fad91589fcbac", "8e49fbd5fbbf230e32c1969cd24ac3c22422f0a5", "a83bec6b47776af688402c18efec507143061f68", "52da526d7cc1e063d74c5b520dbc03d0ace15246", "78b2da018d2c4bd9ac1bde1dc3b7f1a110a175f5", "623bf61358c339cb10297807b3f024b5d9f1f327", "23f9fda4c05f8a3852246ee98d4f2adf74ed0875", "9091d3d6606b0c4b5591a38c3674356a01fd7f55", "df55c8c54a23251342a7ee57ba95642b7eb39e61", "2ce392291c6668598d12cd38327e24696b5ca15c")
 # #endregion supported-contract-revisions
 INTEROP_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1"
 MCP_REVISION = "2026-07-28"

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

@@ -163,12 +163,19 @@ def normal_identifier(value: Any) -> Optional[str]:
     return _urn_form(authority, path, query) if scheme.lower() == "urn" else _generic_form(scheme, authority, path, query, fragment)
 
 
+def _double(value: Any) -> float:
+    try:
+        return float(value)
+    except OverflowError:
+        return float("inf") if value > 0 else float("-inf")
+
+
 def _strict_equal(a: Any, b: Any) -> bool:
     """JavaScript's === on parsed JSON: numbers by value, booleans only with booleans, objects by identity."""
     if isinstance(a, bool) or isinstance(b, bool):
         return isinstance(a, bool) and isinstance(b, bool) and a == b
     if isinstance(a, (int, float)) and isinstance(b, (int, float)):
-        return a == b
+        return _double(a) == _double(b)  # as JavaScript holds them: 2**53 + 1 is 2**53
     if isinstance(a, (dict, list)) or isinstance(b, (dict, list)):
         return a is b
     return type(a) is type(b) and a == b

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

@@ -18,10 +18,10 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Python 3.9+ or Node.js 20+ for the kits; the probe needs Python 3.9+. launchd steps are macOS-only; Linux services install a systemd user unit and Windows ones a per-user Scheduled Task with the kits' writers. Dashboard handoff optionally uses Fabric Dashboards MCP link/host_status/open; without it, report unresolved host capability. The contract checkout is optional.
 metadata:
   author: PassionCode.ai
-  version: "0.33.0"
+  version: "0.34.1"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "82e163665e156a08aa3b92e4711015582c06162c"
+  extension-commit: "d8146cfb0a1c74fc6432284c4356bb0c864b37b5"
 ---
 
 # Building Fabric services

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

@@ -11,6 +11,7 @@ Python: [`scripts/fabric_profiles.py`](../scripts/fabric_profiles.py); Node:
 
 - Resolving the model profile
 - Checking the documents
+- A lane that reads user content
 - Declaring and showing what applies
 - The doctor
 - Runner routes
@@ -27,7 +28,8 @@ resolution = fp.resolve_model_profile(catalogue=catalogue, profiles=estate_and_a
 
 The first level that names a profile wins: **request, agent, binding or project, estate default**. The project's
 `modelClasses` narrow the profile's models — a model stays only if every class the catalogue gives it is allowed — and
-never choose one. An empty result is `{"refused": "model-classes-empty", "policy": {id, revision}}`: refuse the launch
+never choose one. `open-vendor` is descriptive (DEC-0083): it is never checked against the policy, and a model whose
+only class is `open-vendor` does not stay. An empty result is `{"refused": "model-classes-empty", "policy": {id, revision}}`: refuse the launch
 and name the policy; never fall back to a model outside it. No level at all is `no-profile`; an id nobody offers is
 `unknown-profile`.
 
@@ -37,7 +39,30 @@ and name the policy; never fall back to a model outside it. No level at all is `
 (a model catalogued once; a provider never both ordered and ignored, a base slug covering its variants), a
 `model-profiles` set (an id once), a `runner-profile` (a subscription only in its vendor's runner — Claude in Claude
 Code, Kimi in Kimi Code, ChatGPT in Codex; a key route's allow-list is its own model profile; a key named by reference,
-never by value) and a recorded `profile-resolution` (it equals the order's answer).
+never by value) and a recorded `profile-resolution` (it equals the order's answer). Every rule compares as the contract
+does — `===` (`1` and `true` differ, `null` is not absent) and its `jsonEqual` for a recorded resolution, where NaN
+equals nothing — and never raises on hostile JSON: a value whose own `toString` member is data is shown as its JSON.
+
+## A lane that reads user content
+
+A model profile names what the lane it serves reads (DEC-0083, `reads`): `user-content` — what a member, a client or
+the public sends (messages, questions, images, reviews, screenshots, voice); `operator` — only what the estate's own
+operator or its agents write; `web` — pages fetched from the open web. Absent is "not declared", which stays valid.
+
+A profile that reads `user-content` has an **open-vendor route** (FAC-SEM-112): with `fallback: none` (or any value the
+contract does not name) its first model is `open-vendor` in the catalogue; with `between-turns` at least one of its
+models is. Closed vendors refuse the content such a lane exists to handle, so a closed route alone skips the worst of
+it. Which models are `open-vendor` is the catalogue writer's fact; the service never keeps a vendor list of its own,
+and a model the catalogue does not hold counts as closed.
+
+- `profile_problems("profile-resolution", doc)` / `profileProblems(...)` answer FAC-SEM-112 beside FAC-SEM-060, on each
+  profile (`/profiles/<i>/models`) and on the resolution's outcome: when the resolved profile's own route is open but the
+  models the project's policy leaves are all closed, the finding is at `/resolved/models` and names the policy.
+- `closed_user_content_route(profile, catalogue)` / `closedUserContentRoute(profile, catalogue)` name the models that
+  would run on such a lane when none is open-vendor, or `None`/`undefined` when the route holds.
+- On such a lane a content refusal, or an empty answer to a non-empty request, is a **failed turn**: under
+  `between-turns` the runner moves to the next model; it never counts that answer as done.
+- `operator` and `web` carry no model rule in this revision; they let a lane say that it reads no user content.
 
 ## Declaring and showing what applies
 
@@ -57,7 +82,8 @@ declaration (`configuration.declared`).
 and answers whether the runner is installed, which version answers and whether it is signed in. It runs only a bare
 catalogued binary found on `PATH`, only with the catalogued version argv (and `auth` argv), without a shell, within
 the entry's timeout (at most 5 s); an entry outside these rules is refused and nothing runs. `model_usable(model,
-catalogue, policy)` names why a model cannot be used here: not catalogued, or a class the project does not allow.
+catalogue, policy)` names why a model cannot be used here: not catalogued, a class the project does not allow, or
+only `open-vendor`, which admits nothing — the same admission the resolution applies.
 
 `probe` is the contract's closed probe result for that runner, the one Fabric's walk records (DEC-0026):
 `not-installed` (no catalogued binary on `PATH`), `not-responding` (the version probe did not answer in its bound,

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

@@ -1,6 +1,6 @@
 # fabric-service/0.1 — wire reference
 
-Pinned to `fabric-agent-contract` commit `82e163665e156a08aa3b92e4711015582c06162c`
+Pinned to `fabric-agent-contract` commit `d8146cfb0a1c74fc6432284c4356bb0c864b37b5`
 (`docs/specification/service.md`, DEC-0015; the usage report DEC-0021; Windows and Linux supervision
 DEC-0032 and DEC-0033; the operator channel DEC-0034 and DEC-0035; the embedded dashboard DEC-0036;
 delegation and the operator session's lifetime DEC-0039; the meter's call window DEC-0041; session handoff DEC-0042;

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

@@ -21,12 +21,40 @@ export class ProfileError extends Error {}
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const list = (value) => (Array.isArray(value) ? value.filter(isObject) : []);
 const strings = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === 'string') : []);
-const jsonEqual = (a, b) => JSON.stringify(sortKeys(a)) === JSON.stringify(sortKeys(b));
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
-  if (isObject(value)) return Object.fromEntries(Object.keys(value).sort().map((k) => [k, sortKeys(value[k])]));
-  return value;
+/** The object items of an array with their index as written, so an instancePath names the item even after a non-object. */
+const indexed = (value) => (Array.isArray(value) ? value.flatMap((item, index) => (isObject(item) ? [[item, index]] : [])) : []);
+/** DEC-0083: the model class of a model whose vendor publishes its weights openly — descriptive: a policy admits and
+ * excludes nothing by it — and what a lane reads when it reads what a member, a client or the public sends. */
+export const OPEN_VENDOR = 'open-vendor';
+export const USER_CONTENT = 'user-content';
+/** The contract's `show`: String(value), or its JSON where String() throws (an object whose own `toString` is data). */
+const show = (value) => {
+  if (typeof value === 'string') return value;
+  try {
+    return String(value);
+  } catch {
+    return JSON.stringify(value) ?? typeof value;
+  }
+};
+/** The contract's jsonEqual: arrays by item, objects by own member whatever the order, anything else by ===, so 1 and
+ * true differ and NaN equals nothing (a JSON.stringify comparison would call NaN and null equal). */
+function jsonEqual(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, i) => jsonEqual(item, b[i]));
+  if (isObject(a) || isObject(b)) {
+    if (!isObject(a) || !isObject(b)) return false;
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && jsonEqual(a[key], b[key]));
+  }
+  return a === b;
 }
+/** The contract's toNumber: Number(value), or NaN where Number() throws (an object whose own toString is data). */
+const toNumber = (value) => {
+  try {
+    return Number(value);
+  } catch {
+    return Number.NaN;
+  }
+};
 
 /** FAC-SEM-060: the request's profile, else the agent's, else the binding's or project's, else the estate default. */
 export function resolveModelProfile({ catalogue, profiles, choices = {}, policy } = {}) {
@@ -39,10 +67,15 @@ export function resolveModelProfile({ catalogue, profiles, choices = {}, policy
   if (!isObject(policy) || !Array.isArray(policy.modelClasses)) return { from: level, profile: id, models };
   const allowed = new Set(strings(policy.modelClasses));
   const rows = new Map(list(isObject(catalogue) ? catalogue.models : undefined).map((row) => [row.id, row]));
-  const within = models.filter((model) => { const row = rows.get(model); return row !== undefined && strings(row.classes).every((name) => allowed.has(name)); });
+  // The descriptive class open-vendor is not checked (DEC-0083), and a model with no other class does not stay.
+  const within = models.filter((model) => {
+    const row = rows.get(model);
+    const admission = row === undefined ? [] : strings(row.classes).filter((name) => name !== OPEN_VENDOR);
+    return admission.length > 0 && admission.every((name) => allowed.has(name));
+  });
   if (within.length) return { from: level, profile: id, models: within };
   const meta = isObject(policy.meta) ? policy.meta : {};
-  return { refused: 'model-classes-empty', profile: id, policy: { id: String(meta.id), revision: Number(meta.revision) } };
+  return { refused: 'model-classes-empty', profile: id, policy: { id: show(meta.id), revision: toNumber(meta.revision) } };
 }
 
 const finding = (code, instancePath, message) => ({ code, instancePath, message });
@@ -50,13 +83,13 @@ const finding = (code, instancePath, message) => ({ code, instancePath, message
 function modelCatalogue(value) {
   const findings = [];
   const seen = new Set();
-  list(value.models).forEach((row, index) => {
-    if (seen.has(row.id)) findings.push(finding('FAC-SEM-058', `/models/${index}/id`, `model ${String(row.id)} is catalogued more than once`));
+  indexed(value.models).forEach(([row, index]) => {
+    if (seen.has(row.id)) findings.push(finding('FAC-SEM-058', `/models/${index}/id`, `model ${show(row.id)} is catalogued more than once`));
     seen.add(row.id);
     const routing = isObject(row.provider) ? row.provider : {};
     const ignored = new Set(strings(routing.ignore));
     for (const slug of strings(routing.order)) {
-      if (ignored.has(slug) || ignored.has(slug.split('/')[0])) findings.push(finding('FAC-SEM-058', `/models/${index}/provider`, `model ${String(row.id)} both orders and ignores provider ${slug}`));
+      if (ignored.has(slug) || ignored.has(slug.split('/')[0])) findings.push(finding('FAC-SEM-058', `/models/${index}/provider`, `model ${show(row.id)} both orders and ignores provider ${slug}`));
     }
   });
   return findings;
@@ -65,8 +98,8 @@ function modelCatalogue(value) {
 function modelProfiles(value) {
   const findings = [];
   const seen = new Set();
-  list(value.profiles).forEach((profile, index) => {
-    if (seen.has(profile.id)) findings.push(finding('FAC-SEM-058', `/profiles/${index}/id`, `model profile ${String(profile.id)} is declared more than once`));
+  indexed(value.profiles).forEach(([profile, index]) => {
+    if (seen.has(profile.id)) findings.push(finding('FAC-SEM-058', `/profiles/${index}/id`, `model profile ${show(profile.id)} is declared more than once`));
     seen.add(profile.id);
   });
   return findings;
@@ -75,12 +108,12 @@ function modelProfiles(value) {
 function runnerProfile(value) {
   const findings = [];
   if (value.route === 'subscription' && isObject(value.subscription)) {
-    const login = String(value.subscription.login);
+    const login = show(value.subscription.login);
     const runner = Object.hasOwn(SUBSCRIPTION_RUNNER, login) ? SUBSCRIPTION_RUNNER[login] : undefined;
-    if (runner !== value.runnerKind) findings.push(finding('FAC-SEM-059', '/runnerKind', `a ${login} subscription runs only in ${runner ?? "its vendor's runner"}, not in ${String(value.runnerKind)}; another runner takes the key route`));
+    if (runner !== value.runnerKind) findings.push(finding('FAC-SEM-059', '/runnerKind', `a ${login} subscription runs only in ${runner ?? "its vendor's runner"}, not in ${show(value.runnerKind)}; another runner takes the key route`));
   }
   if (value.route === 'key' && isObject(value.key)) {
-    if (value.key.modelAllowList !== value.modelProfile) findings.push(finding('FAC-SEM-059', '/key/modelAllowList', `the key admits the models of ${String(value.key.modelAllowList)}, but the profile runs ${String(value.modelProfile)}`));
+    if (value.key.modelAllowList !== value.modelProfile) findings.push(finding('FAC-SEM-059', '/key/modelAllowList', `the key admits the models of ${show(value.key.modelAllowList)}, but the profile runs ${show(value.modelProfile)}`));
     if (typeof value.key.ref === 'string' && secretValue(value.key.ref)) findings.push(finding('FAC-SEM-059', '/key/ref', 'the key is named by its secret reference, never by its value'));
   }
   return findings;
@@ -90,11 +123,11 @@ function profileResolution(value) {
   const findings = [];
   const catalogued = new Set(list(isObject(value.catalogue) ? value.catalogue.models : undefined).map((row) => row.id));
   const ids = new Set();
-  list(value.profiles).forEach((profile, i) => {
-    if (ids.has(profile.id)) findings.push(finding('FAC-SEM-060', `/profiles/${i}/id`, `profile id ${String(profile.id)} is offered more than once to one resolution`));
+  indexed(value.profiles).forEach(([profile, i]) => {
+    if (ids.has(profile.id)) findings.push(finding('FAC-SEM-060', `/profiles/${i}/id`, `profile id ${show(profile.id)} is offered more than once to one resolution`));
     ids.add(profile.id);
-    strings(profile.models).forEach((model, j) => {
-      if (!catalogued.has(model)) findings.push(finding('FAC-SEM-060', `/profiles/${i}/models/${j}`, `profile ${String(profile.id)} names ${model}, which the catalogue does not hold`));
+    (Array.isArray(profile.models) ? profile.models : []).forEach((model, j) => {
+      if (typeof model === 'string' && !catalogued.has(model)) findings.push(finding('FAC-SEM-060', `/profiles/${i}/models/${j}`, `profile ${show(profile.id)} names ${model}, which the catalogue does not hold`));
     });
   });
   const choices = isObject(value.choices) ? value.choices : {};
@@ -103,9 +136,53 @@ function profileResolution(value) {
   return findings;
 }
 
+/**
+ * FAC-SEM-112 (DEC-0083) for one profile: the models that run when the lane reads user content and none of them is an
+ * open-vendor model, or undefined when the profile does not read user content or its route has one. Under
+ * `between-turns` every model may run; under `none`, or any other value (failing closed), only the first. A model the
+ * catalogue does not hold, or whose row is not `open-vendor`, counts as closed. Never throws.
+ */
+export function closedUserContentRoute(profile, catalogue) {
+  if (!isObject(profile) || !strings(profile.reads).includes(USER_CONTENT)) return undefined;
+  const models = Array.isArray(profile.models) ? profile.models : [];
+  const route = profile.fallback === 'between-turns' ? models : models.slice(0, 1);
+  const open = new Set();
+  for (const row of list(isObject(catalogue) ? catalogue.models : undefined)) {
+    if (typeof row.id === 'string' && strings(row.classes).includes(OPEN_VENDOR)) open.add(row.id);
+  }
+  if (route.some((model) => typeof model === 'string' && open.has(model))) return undefined;
+  return route.map((model) => show(model));
+}
+
+/** FAC-SEM-112: a profile that reads user content has an open-vendor route, so the lane never runs on closed vendors alone. */
+const closedRoute = (fallback, closed) => (fallback === 'between-turns' ? 'none of its models is' : `its first model, ${closed[0] ?? 'none'}, is not`);
+
+/** FAC-SEM-112 on the profiles and on the resolution's outcome: the models the policy leaves keep an open-vendor route. */
+function openVendorRoutes(value) {
+  const findings = [];
+  const profiles = list(value.profiles);
+  indexed(value.profiles).forEach(([profile, i]) => {
+    const closed = closedUserContentRoute(profile, value.catalogue);
+    if (closed === undefined) return;
+    findings.push(finding('FAC-SEM-112', `/profiles/${i}/models`, `profile ${show(profile.id)} reads user content, but ${closedRoute(profile.fallback, closed)} open-vendor in the catalogue: the lane would run on closed vendors alone`));
+  });
+  const choices = isObject(value.choices) ? value.choices : {};
+  const outcome = resolveModelProfile({ catalogue: value.catalogue, profiles: value.profiles, choices, policy: value.policy });
+  if (!('models' in outcome)) return findings;
+  const profile = profiles.find((item) => item.id === outcome.profile);
+  if (!profile || closedUserContentRoute(profile, value.catalogue) !== undefined) return findings;
+  const closed = closedUserContentRoute({ ...profile, models: outcome.models }, value.catalogue);
+  if (closed === undefined) return findings;
+  const meta = isObject(value.policy) && isObject(value.policy.meta) ? value.policy.meta : {};
+  findings.push(finding('FAC-SEM-112', '/resolved/models', `the policy ${show(meta.id)} leaves profile ${show(profile.id)}'s lane on closed vendors alone: of the models it admits, ${closedRoute(profile.fallback, closed)} open-vendor in the catalogue`));
+  return findings;
+}
+
 /** The contract's profileRules: findings for a model-catalogue, model-profiles, runner-profile or profile-resolution; else undefined. */
 export function profileProblems(kind, value) {
-  return { 'model-catalogue': modelCatalogue, 'model-profiles': modelProfiles, 'runner-profile': runnerProfile, 'profile-resolution': profileResolution }[kind]?.(value);
+  const table = { 'model-catalogue': modelCatalogue, 'model-profiles': modelProfiles, 'runner-profile': runnerProfile, 'profile-resolution': (v) => [...profileResolution(v), ...openVendorRoutes(v)] };
+  // Own members only: a kind such as `constructor` or `__proto__` names no rule.
+  return typeof kind === 'string' && Object.hasOwn(table, kind) ? table[kind](value) : undefined;
 }
 
 // ---- the doctor's checks ----
@@ -169,12 +246,16 @@ export function runnerCheck(entry, { searchPath = process.env.PATH, run = spawnS
 
 /** Problems with running `model` here: not in the catalogue, or a class the project's policy does not allow. */
 export function modelUsable(model, catalogue, policy) {
+  // The last row of an id wins, as the Map the resolver builds; a model that is not a string matches no row.
   const rows = new Map(list(isObject(catalogue) ? catalogue.models : undefined).map((row) => [row.id, row]));
-  if (!rows.has(model)) return [`model ${model} is not in the model catalogue`];
+  if (typeof model !== 'string' || !rows.has(model)) return [`model ${show(model)} is not in the model catalogue`];
   if (isObject(policy) && Array.isArray(policy.modelClasses)) {
     const allowed = new Set(strings(policy.modelClasses));
-    const outside = strings(rows.get(model).classes).filter((c) => !allowed.has(c));
-    if (outside.length) return [`model ${model} has class ${outside.join(', ')}, which policy ${String((isObject(policy.meta) ? policy.meta : {}).id)} does not allow`];
+    const policyId = show((isObject(policy.meta) ? policy.meta : {}).id);
+    const admission = strings(rows.get(model).classes).filter((c) => c !== OPEN_VENDOR);
+    if (!admission.length) return [`model ${model} has no class but ${OPEN_VENDOR}, which admits nothing, so policy ${policyId} does not allow it`];
+    const outside = admission.filter((c) => !allowed.has(c));
+    if (outside.length) return [`model ${model} has class ${outside.join(', ')}, which policy ${policyId} does not allow`];
   }
   return [];
 }
@@ -212,14 +293,14 @@ export const PROBE_RESULTS = Object.freeze(['not-catalogued', 'not-admitted', 'n
 const routeCandidates = (value) => (Array.isArray(value?.candidates) ? value.candidates.filter(isObject) : []);
 const objectAt = (value, key) => (isObject(value?.[key]) ? value[key] : {});
 // A revision reference compared whole; its id is an identifier, so it enters the key in its normal form (DEC-0076).
-const refKey = (ref) => (isObject(ref) ? `${String(normalIdentifier(ref.id) ?? ref.id)}@${String(ref.revision)}#${String(ref.contentHash)}` : '');
+const refKey = (ref) => (isObject(ref) ? `${show(normalIdentifier(ref.id) ?? ref.id)}@${show(ref.revision)}#${show(ref.contentHash)}` : '');
 const sameRef = (a, b) => refKey(a) !== '' && refKey(a) === refKey(b);
 
 function runnerRoute(value) {
   const findings = [];
   const kinds = new Set();
   routeCandidates(value).forEach((candidate, index) => {
-    const kind = String(candidate.runnerKind);
+    const kind = show(candidate.runnerKind);
     if (kinds.has(kind)) findings.push(finding('FAC-SEM-028', `/candidates/${index}/runnerKind`, `runner kind ${kind} appears in the route more than once`));
     kinds.add(kind);
     const session = objectAt(candidate, 'session');
@@ -235,25 +316,25 @@ function routeBundle(value) {
   const findings = [];
   routeCandidates(route).forEach((candidate, index) => {
     const key = refKey(candidate.provider);
-    if (!admitted.has(key)) findings.push(finding('FAC-SEM-030', `/route/candidates/${index}/provider`, `candidate ${String(candidate.runnerKind)} names provider ${key}, which is not a revision admitted for ${String(route.capability)}`));
+    if (!admitted.has(key)) findings.push(finding('FAC-SEM-030', `/route/candidates/${index}/provider`, `candidate ${show(candidate.runnerKind)} names provider ${key}, which is not a revision admitted for ${show(route.capability)}`));
   });
   if (isObject(value.binding)) {
     const binding = value.binding;
     const disagree = (where, message) => findings.push(finding('FAC-SEM-032', `/binding/${where}`, message));
     // DEC-0076: project and capability are identifiers, compared by normal form.
-    if (!sameIdentifier(binding.project, route.project)) disagree('project', `the binding is for ${String(binding.project)}, the route for ${String(route.project)}`);
-    if (!sameIdentifier(binding.capability, route.capability)) disagree('capability', `the binding binds ${String(binding.capability)}, the route orders ${String(route.capability)}`);
-    if (binding.profileKind !== 'local-runner') disagree('profileKind', `a runner route serves the local-runner profile, not ${String(binding.profileKind)}`);
+    if (!sameIdentifier(binding.project, route.project)) disagree('project', `the binding is for ${show(binding.project)}, the route for ${show(route.project)}`);
+    if (!sameIdentifier(binding.capability, route.capability)) disagree('capability', `the binding binds ${show(binding.capability)}, the route orders ${show(route.capability)}`);
+    if (binding.profileKind !== 'local-runner') disagree('profileKind', `a runner route serves the local-runner profile, not ${show(binding.profileKind)}`);
     if (!routeCandidates(route).some((c) => sameRef(c.provider, binding.provider))) disagree('provider', `the binding's provider ${refKey(binding.provider)} is not a candidate of the route`);
     if (binding.runnerRoute !== undefined && !sameRef(binding.runnerRoute, route.meta)) disagree('runnerRoute', `the binding pins ${refKey(binding.runnerRoute)}, not this route ${refKey(route.meta)}`);
   }
   if (Array.isArray(value.catalogue)) {
-    const byKind = new Map(value.catalogue.filter(isObject).map((entry) => [String(entry.kind), entry]));
+    const byKind = new Map(value.catalogue.filter(isObject).map((entry) => [show(entry.kind), entry]));
     routeCandidates(route).forEach((candidate, index) => {
-      const kind = String(candidate.runnerKind);
+      const kind = show(candidate.runnerKind);
       const entry = byKind.get(kind);
       if (!entry) { findings.push(finding('FAC-SEM-033', `/route/candidates/${index}/runnerKind`, `runner kind ${kind} has no entry in the host's catalogue`)); return; }
-      if (candidate.drive !== undefined && !Object.hasOwn(objectAt(entry, 'drives'), String(candidate.drive))) findings.push(finding('FAC-SEM-033', `/route/candidates/${index}/drive`, `the catalogue entry for ${kind} offers no drive ${String(candidate.drive)}`));
+      if (candidate.drive !== undefined && !Object.hasOwn(objectAt(entry, 'drives'), show(candidate.drive))) findings.push(finding('FAC-SEM-033', `/route/candidates/${index}/drive`, `the catalogue entry for ${kind} offers no drive ${show(candidate.drive)}`));
     });
   }
   return findings;
@@ -266,14 +347,14 @@ function routeEvent(value) {
   const findings = [];
   const wrong = (where, message) => findings.push(finding('FAC-SEM-034', `/event${where}`, message));
   if (!sameRef(event.route, route.meta)) wrong('/route', `the event names route ${refKey(event.route)}, not ${refKey(route.meta)}`);
-  if (!sameIdentifier(event.project, route.project)) wrong('/project', `the event is for ${String(event.project)}, the route for ${String(route.project)}`);
-  if (!sameIdentifier(event.capability, route.capability)) wrong('/capability', `the event names ${String(event.capability)}, the route orders ${String(route.capability)}`);
+  if (!sameIdentifier(event.project, route.project)) wrong('/project', `the event is for ${show(event.project)}, the route for ${show(route.project)}`);
+  if (!sameIdentifier(event.capability, route.capability)) wrong('/capability', `the event names ${show(event.capability)}, the route orders ${show(route.capability)}`);
   const indexOf = (ref) => (typeof ref.index === 'number' && Number.isInteger(ref.index) ? ref.index : -1);
   const candidateAt = (ref, where) => {
     const index = indexOf(ref);
     const candidate = index >= 0 ? list[index] : undefined;
     if (!candidate || candidate.runnerKind !== ref.runnerKind || (ref.provider !== undefined && !sameRef(candidate.provider, ref.provider))) {
-      wrong(where, `candidate ${String(ref.index)} (${String(ref.runnerKind)}) is not that position of the route`);
+      wrong(where, `candidate ${show(ref.index)} (${show(ref.runnerKind)}) is not that position of the route`);
       return undefined;
     }
     return candidate;
@@ -281,8 +362,8 @@ function routeEvent(value) {
   const probes = Array.isArray(event.probes) ? event.probes.filter(isObject) : [];
   probes.forEach((probe, position) => {
     const candidate = candidateAt(probe, `/probes/${position}`);
-    if (candidate && probe.result === 'no-held-session' && objectAt(candidate, 'session').spawn !== 'never') wrong(`/probes/${position}/result`, `${String(probe.runnerKind)} may spawn, so finding no held session does not pass it over`);
-    if (candidate && probe.result === 'spawn-failed' && objectAt(candidate, 'session').spawn !== 'allowed') wrong(`/probes/${position}/result`, `${String(probe.runnerKind)} has spawn: never, so it cannot have failed to spawn`);
+    if (candidate && probe.result === 'no-held-session' && objectAt(candidate, 'session').spawn !== 'never') wrong(`/probes/${position}/result`, `${show(probe.runnerKind)} may spawn, so finding no held session does not pass it over`);
+    if (candidate && probe.result === 'spawn-failed' && objectAt(candidate, 'session').spawn !== 'allowed') wrong(`/probes/${position}/result`, `${show(probe.runnerKind)} has spawn: never, so it cannot have failed to spawn`);
   });
   const expectProbes = (count) => {
     const indexes = probes.map(indexOf);
@@ -300,9 +381,9 @@ function routeEvent(value) {
   const chosen = candidateAt(selected, '/selected');
   if (chosen) {
     const session = objectAt(chosen, 'session');
-    if (selected.session === 'attached' && session.attach !== 'preferred') wrong('/selected/session', `${String(selected.runnerKind)} has attach: never, so the host cannot attach it`);
-    if (selected.session === 'spawned' && session.spawn !== 'allowed') wrong('/selected/session', `${String(selected.runnerKind)} has spawn: never, so the host cannot spawn it`);
-    if (chosen.drive !== undefined && selected.drive !== undefined && selected.drive !== chosen.drive) wrong('/selected/drive', `the route runs ${String(selected.runnerKind)} through ${String(chosen.drive)}, not ${String(selected.drive)}`);
+    if (selected.session === 'attached' && session.attach !== 'preferred') wrong('/selected/session', `${show(selected.runnerKind)} has attach: never, so the host cannot attach it`);
+    if (selected.session === 'spawned' && session.spawn !== 'allowed') wrong('/selected/session', `${show(selected.runnerKind)} has spawn: never, so the host cannot spawn it`);
+    if (chosen.drive !== undefined && selected.drive !== undefined && selected.drive !== chosen.drive) wrong('/selected/drive', `the route runs ${show(selected.runnerKind)} through ${show(chosen.drive)}, not ${show(selected.drive)}`);
     if (event.sticky === true) {
       // A sticky relaunch keeps the conversation's runner and walks nothing above it.
       if (route.recovery === 'reprobe') wrong('/sticky', 'a route with recovery: reprobe walks from the top at every launch');
@@ -329,5 +410,6 @@ function routeEvent(value) {
  */
 export function routeProblems(kind, value) {
   if (!isObject(value)) return undefined;
-  return { 'runner-route': runnerRoute, 'route-bundle': routeBundle, 'route-event': routeEvent }[kind]?.(value);
+  const table = { 'runner-route': runnerRoute, 'route-bundle': routeBundle, 'route-event': routeEvent };
+  return typeof kind === 'string' && Object.hasOwn(table, kind) ? table[kind](value) : undefined;
 }

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

@@ -90,6 +90,14 @@ def _number(value: Any) -> bool:
     return isinstance(value, (int, float)) and not isinstance(value, bool)
 
 
+def _double(value: Any) -> float:
+    """A JSON number as JavaScript holds it: the nearest double, and an integer beyond the double range ±Infinity."""
+    try:
+        return float(value)
+    except OverflowError:
+        return math.inf if value > 0 else -math.inf
+
+
 def _same(a: Any, b: Any) -> bool:
     """JavaScript's === (and a Set's SameValueZero) on parsed JSON: an object equals only itself."""
     if a is _MISSING or b is _MISSING:
@@ -99,7 +107,7 @@ def _same(a: Any, b: Any) -> bool:
     if isinstance(a, bool) or isinstance(b, bool):
         return isinstance(a, bool) and isinstance(b, bool) and a == b
     if _number(a) and _number(b):
-        return a == b
+        return _double(a) == _double(b)  # 2**53 + 1 is 2**53 in JavaScript
     return type(a) is type(b) and a == b
 
 
@@ -137,7 +145,7 @@ def _js_to_number(value: Any) -> float:
         radix = _JS_RADIX.fullmatch(text)
         if radix:
             digits, base = next((radix.group(k), b) for k, b in (("x", 16), ("o", 8), ("b", 2)) if radix.group(k))
-            return float(int(digits, base))
+            return _double(int(digits, base))
     return math.nan
 
 
@@ -173,10 +181,37 @@ def _strict_string(value: Any) -> str:
     return _js_string(value)
 
 
+_INDEX_KEY = re.compile(r"0|[1-9][0-9]*", re.ASCII)
+
+
+def _js_keys(value: Dict[str, Any]) -> List[str]:
+    """An object's own keys in the order JavaScript lists them: array-index keys ("0" … "4294967294", no leading zero)
+    ascending, then the others in the order written."""
+    index = sorted((k for k in value if _INDEX_KEY.fullmatch(k) and int(k) <= 2 ** 32 - 2), key=int)
+    taken = set(index)
+    return index + [k for k in value if k not in taken]
+
+
+def _js_json_string(text: str) -> str:
+    """JSON.stringify of a string (well-formed, ES2019): a lone surrogate is escaped as \\uXXXX, never refused."""
+    out = ['"']
+    for ch in text:
+        code = ord(ch)
+        if ch in _delegation._ESCAPES:
+            out.append(_delegation._ESCAPES[ch])
+        elif code < 0x20 or 0xD800 <= code <= 0xDFFF:
+            out.append("\\u%04x" % code)
+        else:
+            out.append(ch)
+    out.append('"')
+    return "".join(out)
+
+
 def _json_stringify(value: Any) -> str:
-    """JSON.stringify for a parsed JSON value: members in their order, numbers as JavaScript writes them."""
+    """JSON.stringify for a parsed JSON value: members in JavaScript's key order, numbers as JavaScript writes them, a
+    lone surrogate escaped."""
     if isinstance(value, dict):
-        return "{" + ",".join(_delegation._string(k) + ":" + _json_stringify(v) for k, v in value.items()) + "}"
+        return "{" + ",".join(_js_json_string(k) + ":" + _json_stringify(value[k]) for k in _js_keys(value)) + "}"
     if isinstance(value, list):
         return "[" + ",".join(_json_stringify(v) for v in value) + "]"
     if value is None:
@@ -186,7 +221,7 @@ def _json_stringify(value: Any) -> str:
     if _number(value):
         text = _js_string(value)
         return "null" if text in ("NaN", "Infinity", "-Infinity") else text
-    return _delegation._string(value)
+    return _js_json_string(value)
 
 
 def _show(value: Any) -> str:

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

@@ -163,12 +163,19 @@ def normal_identifier(value: Any) -> Optional[str]:
     return _urn_form(authority, path, query) if scheme.lower() == "urn" else _generic_form(scheme, authority, path, query, fragment)
 
 
+def _double(value: Any) -> float:
+    try:
+        return float(value)
+    except OverflowError:
+        return float("inf") if value > 0 else float("-inf")
+
+
 def _strict_equal(a: Any, b: Any) -> bool:
     """JavaScript's === on parsed JSON: numbers by value, booleans only with booleans, objects by identity."""
     if isinstance(a, bool) or isinstance(b, bool):
         return isinstance(a, bool) and isinstance(b, bool) and a == b
     if isinstance(a, (int, float)) and isinstance(b, (int, float)):
-        return a == b
+        return _double(a) == _double(b)  # as JavaScript holds them: 2**53 + 1 is 2**53
     if isinstance(a, (dict, list)) or isinstance(b, (dict, list)):
         return a is b
     return type(a) is type(b) and a == b

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

@@ -19,6 +19,7 @@ import shutil
 import subprocess
 from typing import Any, Callable, Dict, List, Optional, Sequence
 
+import fabric_estate as _estate
 import fabric_identifiers as _ids
 import fabric_secrets as _secrets
 import fabric_service as _fs
@@ -27,6 +28,10 @@ RESOLUTION_ORDER = ("request", "agent", "binding", "estate")
 # The vendor login each subscription is, and the one runner kind it runs in (DEC-0046, ADR-0147 decision 2).
 SUBSCRIPTION_RUNNER = {"claude": "claude-code", "kimi": "kimi-code", "chatgpt": "codex"}
 MAX_PROBE_MS = 5000
+#: DEC-0083: the model class of a model whose vendor publishes its weights openly — descriptive: a policy admits and
+#: excludes nothing by it — and what a lane reads when it reads what a member, a client or the public sends.
+OPEN_VENDOR = "open-vendor"
+USER_CONTENT = "user-content"
 _BARE_BINARY = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
 
 
@@ -38,47 +43,77 @@ def _list(value: Any) -> List[Dict[str, Any]]:
     return [item for item in value if isinstance(item, dict)] if isinstance(value, list) else []
 
 
-def _strings(value: Any) -> List[str]:
-    return [item for item in value if isinstance(item, str)] if isinstance(value, list) else []
+_MISSING_KEY = _estate._MISSING
+
+
+def _at(value: Any, key: str) -> Any:
+    """value[key] as JavaScript reads a member: absent is distinct from null (``_MISSING_KEY``)."""
+    return _estate._get(value, key)
+
+
+def _json_equal(a: Any, b: Any) -> bool:
+    """The contract's jsonEqual on parsed JSON: arrays by item, objects by member whatever the order, anything else by
+    ===, so 1 and true differ and NaN equals nothing."""
+    if isinstance(a, list) or isinstance(b, list):
+        return isinstance(a, list) and isinstance(b, list) and len(a) == len(b) and all(_json_equal(x, y) for x, y in zip(a, b))
+    if isinstance(a, dict) or isinstance(b, dict):
+        return (isinstance(a, dict) and isinstance(b, dict) and len(a) == len(b)
+                and all(k in b and _json_equal(v, b[k]) for k, v in a.items()))
+    return _estate._same(a, b)  # NaN != NaN in Python too
+
+
+def _without_nan(value: Any) -> Any:
+    """A resolution as JSON writes it: NaN and an infinity become null."""
+    if isinstance(value, dict):
+        return {k: _without_nan(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_without_nan(v) for v in value]
+    return None if isinstance(value, float) and not math.isfinite(value) else value
+
+
+def _indexed(value: Any) -> List[tuple]:
+    """The object items of an array with their index as written, so an instancePath names the item even after a
+    non-object (the contract's ``indexed``)."""
+    return [(item, i) for i, item in enumerate(value) if isinstance(item, dict)] if isinstance(value, list) else []
 
 
-def _js_string(value: Any) -> str:
-    """JavaScript's String(value), which the contract's messages and policy ids use."""
+def _set_key(value: Any) -> Any:
+    """A key with JavaScript's Set semantics for a JSON value: 1 and true, null and absent, are different; two objects
+    are never the same member however equal."""
+    if value is _MISSING_ID:
+        return ("undefined",)
     if value is None:
-        return "undefined"
-    if value is True:
-        return "true"
-    if value is False:
-        return "false"
-    if isinstance(value, float) and value.is_integer():
-        return str(int(value))
-    if isinstance(value, (dict, list)):
-        return "[object Object]" if isinstance(value, dict) else ",".join(_js_string(v) for v in value)
-    return str(value)
-
-
-def _js_number(value: Any) -> Optional[float]:
-    """JavaScript's Number(value); NaN is None (JSON writes it as null)."""
+        return ("null",)
     if isinstance(value, bool):
-        return 1 if value else 0
+        return ("boolean", value)
     if isinstance(value, (int, float)):
-        return value if not (isinstance(value, float) and math.isnan(value)) else None
+        return ("number", _estate._double(value))
     if isinstance(value, str):
-        text = value.strip()
-        if text == "":
-            return 0
-        try:
-            number = float(text)
-        except ValueError:
-            return None
-        return int(number) if number.is_integer() else number
-    return None
+        return ("string", value)
+    return ("object", id(value))
+
+
+_MISSING_ID = object()
+
+
+def _id_of(item: Dict[str, Any]) -> Any:
+    return item.get("id", _MISSING_ID)
+
+
+def _strings(value: Any) -> List[str]:
+    return [item for item in value if isinstance(item, str)] if isinstance(value, list) else []
 
 
-def resolve_model_profile(*, catalogue: Any, profiles: Any, choices: Any, policy: Any = None) -> Dict[str, Any]:
+def resolve_model_profile(*, catalogue: Any = None, profiles: Any = None, choices: Any = None, policy: Any = None) -> Dict[str, Any]:
+    """FAC-SEM-060, as JSON writes the contract's answer (a policy revision that is not a number is null)."""
+    return _without_nan(_resolve(catalogue=catalogue, profiles=profiles, choices=choices, policy=policy))
+
+
+def _resolve(*, catalogue: Any = None, profiles: Any = None, choices: Any = None, policy: Any = None) -> Dict[str, Any]:
     """FAC-SEM-060: the request's profile, else the agent's, else the binding's or project's, else the estate default.
     When the project's policy names `modelClasses`, a model stays only if every class the catalogue gives it is
-    allowed; an empty result refuses the launch, naming the policy."""
+    allowed; the descriptive class `open-vendor` is not checked (DEC-0083), and a model with no other class does not stay.
+    An empty result refuses the launch, naming the policy."""
     choices = choices if isinstance(choices, dict) else {}
     level = next((name for name in RESOLUTION_ORDER if isinstance(choices.get(name), str)), None)
     if level is None:
@@ -94,11 +129,16 @@ def resolve_model_profile(*, catalogue: Any, profiles: Any, choices: Any, policy
     rows = {}
     for row in _list(catalogue.get("models") if isinstance(catalogue, dict) else None):
         rows[json.dumps(row.get("id"))] = row
-    within = [m for m in models if json.dumps(m) in rows and all(c in allowed for c in _strings(rows[json.dumps(m)].get("classes")))]
+    def admitted(model: str) -> bool:
+        row = rows.get(json.dumps(model))
+        admission = [c for c in _strings(row.get("classes")) if c != OPEN_VENDOR] if row is not None else []
+        return bool(admission) and all(c in allowed for c in admission)
+    within = [m for m in models if admitted(m)]
     if within:
         return {"from": level, "profile": profile_id, "models": within}
     meta = policy.get("meta") if isinstance(policy.get("meta"), dict) else {}
-    return {"refused": "model-classes-empty", "profile": profile_id, "policy": {"id": _js_string(meta.get("id")), "revision": _js_number(meta.get("revision"))}}
+    return {"refused": "model-classes-empty", "profile": profile_id,
+            "policy": {"id": _estate._show(_at(meta, "id")), "revision": _estate._js_to_number(_at(meta, "revision"))}}
 
 
 def _finding(code: str, path: str, message: str) -> Dict[str, str]:
@@ -106,41 +146,41 @@ def _finding(code: str, path: str, message: str) -> Dict[str, str]:
 
 
 def _model_catalogue(value: Dict[str, Any]) -> List[Dict[str, str]]:
-    findings, seen = [], []
-    for index, row in enumerate(_list(value.get("models"))):
-        if row.get("id") in seen:
-            findings.append(_finding("FAC-SEM-058", "/models/%d/id" % index, "model %s is catalogued more than once" % _js_string(row.get("id"))))
-        seen.append(row.get("id"))
+    findings, seen = [], set()
+    for row, index in _indexed(value.get("models")):
+        if _set_key(_id_of(row)) in seen:
+            findings.append(_finding("FAC-SEM-058", "/models/%d/id" % index, "model %s is catalogued more than once" % _show_id(row)))
+        seen.add(_set_key(_id_of(row)))
         routing = row.get("provider") if isinstance(row.get("provider"), dict) else {}
         ignored = set(_strings(routing.get("ignore")))
         for slug in _strings(routing.get("order")):
             if slug in ignored or slug.split("/")[0] in ignored:
-                findings.append(_finding("FAC-SEM-058", "/models/%d/provider" % index, "model %s both orders and ignores provider %s" % (_js_string(row.get("id")), slug)))
+                findings.append(_finding("FAC-SEM-058", "/models/%d/provider" % index, "model %s both orders and ignores provider %s" % (_show_id(row), slug)))
     return findings
 
 
 def _model_profiles(value: Dict[str, Any]) -> List[Dict[str, str]]:
-    findings, seen = [], []
-    for index, profile in enumerate(_list(value.get("profiles"))):
-        if profile.get("id") in seen:
-            findings.append(_finding("FAC-SEM-058", "/profiles/%d/id" % index, "model profile %s is declared more than once" % _js_string(profile.get("id"))))
-        seen.append(profile.get("id"))
+    findings, seen = [], set()
+    for profile, index in _indexed(value.get("profiles")):
+        if _set_key(_id_of(profile)) in seen:
+            findings.append(_finding("FAC-SEM-058", "/profiles/%d/id" % index, "model profile %s is declared more than once" % _show_id(profile)))
+        seen.add(_set_key(_id_of(profile)))
     return findings
 
 
 def _runner_profile(value: Dict[str, Any]) -> List[Dict[str, str]]:
     findings = []
     if value.get("route") == "subscription" and isinstance(value.get("subscription"), dict):
-        login = _js_string(value["subscription"].get("login"))
-        runner = SUBSCRIPTION_RUNNER.get(login)
-        if runner != value.get("runnerKind"):
+        login = _estate._show(_at(value["subscription"], "login"))
+        runner = SUBSCRIPTION_RUNNER.get(login, _MISSING_KEY)
+        if not _estate._same(runner, _at(value, "runnerKind")):
             findings.append(_finding("FAC-SEM-059", "/runnerKind", "a %s subscription runs only in %s, not in %s; another runner takes the key route"
-                                     % (login, runner if runner is not None else "its vendor's runner", _js_string(value.get("runnerKind")))))
+                                     % (login, runner if runner is not _MISSING_KEY else "its vendor's runner", _estate._show(_at(value, "runnerKind")))))
     if value.get("route") == "key" and isinstance(value.get("key"), dict):
         key = value["key"]
-        if key.get("modelAllowList") != value.get("modelProfile") or ("modelAllowList" in key) != ("modelProfile" in value):
+        if not _estate._same(_at(key, "modelAllowList"), _at(value, "modelProfile")):
             findings.append(_finding("FAC-SEM-059", "/key/modelAllowList", "the key admits the models of %s, but the profile runs %s"
-                                     % (_js_string(key.get("modelAllowList")), _js_string(value.get("modelProfile")))))
+                                     % (_estate._show(_at(key, "modelAllowList")), _estate._show(_at(value, "modelProfile")))))
         if isinstance(key.get("ref"), str) and _secrets.secret_value(key["ref"]):
             findings.append(_finding("FAC-SEM-059", "/key/ref", "the key is named by its secret reference, never by its value"))
     return findings
@@ -154,26 +194,85 @@ def _profile_resolution(value: Dict[str, Any]) -> List[Dict[str, str]]:
     findings = []
     catalogue = value.get("catalogue")
     catalogued = [row.get("id") for row in _list(catalogue.get("models") if isinstance(catalogue, dict) else None)]
-    ids: List[Any] = []
-    for i, profile in enumerate(_list(value.get("profiles"))):
-        if profile.get("id") in ids:
-            findings.append(_finding("FAC-SEM-060", "/profiles/%d/id" % i, "profile id %s is offered more than once to one resolution" % _js_string(profile.get("id"))))
-        ids.append(profile.get("id"))
-        for j, model in enumerate(_strings(profile.get("models"))):
-            if model not in catalogued:
-                findings.append(_finding("FAC-SEM-060", "/profiles/%d/models/%d" % (i, j), "profile %s names %s, which the catalogue does not hold" % (_js_string(profile.get("id")), model)))
+    ids = set()
+    for profile, i in _indexed(value.get("profiles")):
+        if _set_key(_id_of(profile)) in ids:
+            findings.append(_finding("FAC-SEM-060", "/profiles/%d/id" % i, "profile id %s is offered more than once to one resolution" % _show_id(profile)))
+        ids.add(_set_key(_id_of(profile)))
+        # Every model by its index as written; only a string can name a catalogued model.
+        for j, model in enumerate(profile.get("models") if isinstance(profile.get("models"), list) else []):
+            if isinstance(model, str) and model not in catalogued:
+                findings.append(_finding("FAC-SEM-060", "/profiles/%d/models/%d" % (i, j), "profile %s names %s, which the catalogue does not hold" % (_show_id(profile), model)))
+    choices = value.get("choices") if isinstance(value.get("choices"), dict) else {}
+    expected = _resolve(catalogue=catalogue, profiles=value.get("profiles"), choices=choices, policy=value.get("policy"))
+    if not _json_equal(_at(value, "resolved"), expected):
+        findings.append(_finding("FAC-SEM-060", "/resolved", "the resolution is %s" % _estate._json_stringify(_without_nan(expected))))
+    return findings
+
+
+def closed_user_content_route(profile: Any, catalogue: Any) -> Optional[List[str]]:
+    """FAC-SEM-112 (DEC-0083) for one profile: the models that run when the lane reads user content and none of them is
+    an open-vendor model, or None when the profile does not read user content or its route has one. Under
+    ``between-turns`` every model may run; under ``none``, or any other value (failing closed), only the first. A model
+    the catalogue does not hold, or whose row is not ``open-vendor``, counts as closed. Never raises."""
+    if not isinstance(profile, dict) or USER_CONTENT not in _strings(profile.get("reads")):
+        return None
+    models = profile.get("models") if isinstance(profile.get("models"), list) else []
+    route = models if profile.get("fallback") == "between-turns" else models[:1]
+    open_ids = {row["id"] for row in _list(catalogue.get("models") if isinstance(catalogue, dict) else None)
+                if isinstance(row.get("id"), str) and OPEN_VENDOR in _strings(row.get("classes"))}
+    if any(isinstance(model, str) and model in open_ids for model in route):
+        return None
+    return [_estate._show(model) for model in route]
+
+
+def _closed_route(fallback: Any, closed: List[str]) -> str:
+    """How a closed route is named in a finding: under ``between-turns`` all of it, otherwise its first model."""
+    return "none of its models is" if fallback == "between-turns" else "its first model, %s, is not" % (closed[0] if closed else "none")
+
+
+def _open_vendor_routes(value: Dict[str, Any]) -> List[Dict[str, str]]:
+    """FAC-SEM-112: a profile that reads user content has an open-vendor route, so the lane never runs on closed vendors
+    alone, which refuse the content it exists to handle. The resolution's outcome is held to the same test: when the
+    resolved profile reads user content and its own route is open, the models the policy leaves must still give one,
+    or the policy is named as what leaves the lane closed (one cause, one finding)."""
+    findings = []
+    profiles = _list(value.get("profiles"))
+    for profile, i in _indexed(value.get("profiles")):
+        closed = closed_user_content_route(profile, value.get("catalogue"))
+        if closed is None:
+            continue
+        findings.append(_finding("FAC-SEM-112", "/profiles/%d/models" % i, "profile %s reads user content, but %s open-vendor in "
+                                 "the catalogue: the lane would run on closed vendors alone" % (_show_id(profile), _closed_route(profile.get("fallback"), closed))))
     choices = value.get("choices") if isinstance(value.get("choices"), dict) else {}
-    expected = resolve_model_profile(catalogue=catalogue, profiles=value.get("profiles"), choices=choices, policy=value.get("policy"))
-    if "resolved" not in value or value["resolved"] != expected:
-        findings.append(_finding("FAC-SEM-060", "/resolved", "the resolution is %s" % _compact(expected)))
+    outcome = resolve_model_profile(catalogue=value.get("catalogue"), profiles=value.get("profiles"), choices=choices, policy=value.get("policy"))
+    if "models" not in outcome:
+        return findings
+    profile = next((item for item in profiles if item.get("id") == outcome["profile"]), None)  # a string: == is ===
+    if profile is None or closed_user_content_route(profile, value.get("catalogue")) is not None:
+        return findings
+    closed = closed_user_content_route(dict(profile, models=outcome["models"]), value.get("catalogue"))
+    if closed is None:
+        return findings
+    policy = value.get("policy")
+    meta = policy.get("meta") if isinstance(policy, dict) and isinstance(policy.get("meta"), dict) else {}
+    findings.append(_finding("FAC-SEM-112", "/resolved/models", "the policy %s leaves profile %s's lane on closed vendors alone: of the "
+                             "models it admits, %s open-vendor in the catalogue" % (_estate._show(meta["id"]) if "id" in meta else "undefined",
+                                                                                    _show_id(profile), _closed_route(profile.get("fallback"), closed))))
     return findings
 
 
+
+def _show_id(profile: Dict[str, Any]) -> str:
+    """show(profile.id), where an absent id is JavaScript's undefined."""
+    return _estate._show(profile["id"]) if "id" in profile else "undefined"
+
+
 def profile_problems(kind: str, value: Dict[str, Any]) -> Optional[List[Dict[str, str]]]:
     """The contract's profileRules: findings for a `model-catalogue`, `model-profiles`, `runner-profile` or
     `profile-resolution` document; None for another kind."""
     return {"model-catalogue": _model_catalogue, "model-profiles": _model_profiles, "runner-profile": _runner_profile,
-            "profile-resolution": _profile_resolution}.get(kind, lambda v: None)(value)
+            "profile-resolution": lambda v: _profile_resolution(v) + _open_vendor_routes(v)}.get(kind, lambda v: None)(value)
 
 
 # --- the doctor's checks ----------------------------------------------------------------------------------------
@@ -248,15 +347,20 @@ def runner_check(entry: Dict[str, Any], *, path: Optional[str] = None,
 
 def model_usable(model: str, catalogue: Any, policy: Any = None) -> List[str]:
     """Problems with running `model` here: not in the catalogue, or a class the project's policy does not allow."""
-    rows = {row.get("id"): row for row in _list(catalogue.get("models") if isinstance(catalogue, dict) else None)}
-    if model not in rows:
-        return ["model %s is not in the model catalogue" % model]
+    # The last row of an id wins, as a JavaScript Map built from the rows; only a string id can match a model's name.
+    rows = {row["id"]: row for row in _list(catalogue.get("models") if isinstance(catalogue, dict) else None) if isinstance(row.get("id"), str)}
+    if not isinstance(model, str) or model not in rows:
+        return ["model %s is not in the model catalogue" % _estate._show(model)]
     if isinstance(policy, dict) and isinstance(policy.get("modelClasses"), list):
         allowed = set(_strings(policy["modelClasses"]))
-        outside = [c for c in _strings(rows[model].get("classes")) if c not in allowed]
+        meta = policy.get("meta") if isinstance(policy.get("meta"), dict) else {}
+        policy_id = _estate._show(_at(meta, "id"))
+        admission = [c for c in _strings(rows[model].get("classes")) if c != OPEN_VENDOR]  # DEC-0083: descriptive
+        if not admission:
+            return ["model %s has no class but %s, which admits nothing, so policy %s does not allow it" % (model, OPEN_VENDOR, policy_id)]
+        outside = [c for c in admission if c not in allowed]
         if outside:
-            meta = policy.get("meta") if isinstance(policy.get("meta"), dict) else {}
-            return ["model %s has class %s, which policy %s does not allow" % (model, ", ".join(outside), _js_string(meta.get("id")))]
+            return ["model %s has class %s, which policy %s does not allow" % (model, ", ".join(outside), policy_id)]
     return []
 
 
@@ -300,13 +404,9 @@ _MISSING = object()
 
 
 def _field(value: Dict[str, Any], key: str) -> str:
-    """String(value[key]) as JavaScript writes it: `undefined` for a missing key, `null` for null."""
-    found = value.get(key, _MISSING) if isinstance(value, dict) else _MISSING
-    if found is _MISSING:
-        return "undefined"
-    if found is None:
-        return "null"
-    return _js_string(found)
+    """The contract's show(value[key]): `undefined` for a missing key, `null` for null, and an object whose own
+    `toString` is data as its JSON, where String() would throw."""
+    return _estate._show(_at(value, key))
 
 
 def _object_at(value: Any, key: str) -> Dict[str, Any]:
@@ -395,11 +495,14 @@ def _catalogue_agreement(catalogue: List[Dict[str, Any]], route: Dict[str, Any])
     return findings
 
 
-def _index_of(ref: Dict[str, Any]) -> int:
+def _index_of(ref: Dict[str, Any]) -> float:
+    """The contract's indexOf: a JSON number that is an integer, as JavaScript holds it (a double; beyond the double
+    range it is Infinity, which is no integer), else -1."""
     index = ref.get("index")
-    if isinstance(index, bool) or not isinstance(index, (int, float)) or not float(index).is_integer():
+    if isinstance(index, bool) or not isinstance(index, (int, float)):
         return -1
-    return int(index)
+    number = _estate._double(index)
+    return number if math.isfinite(number) and number.is_integer() else -1
 
 
 def _route_event(value: Dict[str, Any]) -> List[Dict[str, str]]:
@@ -420,8 +523,8 @@ def _route_event(value: Dict[str, Any]) -> List[Dict[str, str]]:
 
     def candidate_at(ref: Dict[str, Any], path: str) -> Optional[Dict[str, Any]]:
         index = _index_of(ref)
-        candidate = candidates[index] if 0 <= index < len(candidates) else None
-        if (candidate is None or candidate.get("runnerKind", _MISSING) != ref.get("runnerKind", _MISSING)
+        candidate = candidates[int(index)] if 0 <= index < len(candidates) else None
+        if (candidate is None or not _estate._same(_at(candidate, "runnerKind"), _at(ref, "runnerKind"))
                 or ("provider" in ref and not _same_ref(candidate.get("provider"), ref["provider"]))):
             wrong(path, "candidate %s (%s) is not that position of the route" % (_field(ref, "index"), _field(ref, "runnerKind")))
             return None
@@ -435,12 +538,12 @@ def _route_event(value: Dict[str, Any]) -> List[Dict[str, str]]:
         if candidate is not None and probe.get("result") == "spawn-failed" and _object_at(candidate, "session").get("spawn") != "allowed":
             wrong("/probes/%d/result" % position, "%s has spawn: never, so it cannot have failed to spawn" % _field(probe, "runnerKind"))
 
-    def expect_probes(count: int) -> None:
+    def expect_probes(count: float) -> None:
         indexes = [_index_of(p) for p in probes]
-        expected = list(range(max(count, 0)))
-        if indexes != expected:
+        expected = range(int(max(count, 0)))  # Array.from({length: count}): ToLength, built only where it is read
+        if len(indexes) != len(expected) or any(index != expected[position] for position, index in enumerate(indexes)):
             wrong("/probes", "the walk must record candidates %s in order; it records %s"
-                  % (", ".join(map(str, expected)) or "none", ", ".join(map(str, indexes)) or "none"))
+                  % (", ".join(map(_estate._js_string, expected)) or "none", ", ".join(map(_estate._js_string, indexes)) or "none"))
 
     if event.get("kind") == "runner-exhausted":
         expect_probes(len(candidates))
@@ -456,7 +559,7 @@ def _route_event(value: Dict[str, Any]) -> List[Dict[str, str]]:
             wrong("/selected/session", "%s has attach: never, so the host cannot attach it" % _field(selected, "runnerKind"))
         if selected.get("session") == "spawned" and session.get("spawn") != "allowed":
             wrong("/selected/session", "%s has spawn: never, so the host cannot spawn it" % _field(selected, "runnerKind"))
-        if "drive" in chosen and "drive" in selected and selected["drive"] != chosen["drive"]:
+        if "drive" in chosen and "drive" in selected and not _estate._same(selected["drive"], chosen["drive"]):
             wrong("/selected/drive", "the route runs %s through %s, not %s" % (_field(selected, "runnerKind"), _field(chosen, "drive"), _field(selected, "drive")))
         if event.get("sticky") is True:
             # A sticky relaunch keeps the conversation's runner and walks nothing above it.

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

@@ -5,9 +5,9 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.33.0"
+  version: "0.34.1"
   contract-version: "0.1.0"
-  contract-commit: "82e163665e156a08aa3b92e4711015582c06162c"
+  contract-commit: "d8146cfb0a1c74fc6432284c4356bb0c864b37b5"
 ---
 
 # Creating Fabric-compatible agents
@@ -123,7 +123,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py
 The effect class is declared, never defaulted: ask the author what the agent does outside itself when the request
 does not say. Cost presets are only for a run whose cost varies; their amounts come from the author or measured runs.
 
-Pin exactly contract `0.1.0` at commit `82e163665e156a08aa3b92e4711015582c06162c` and
+Pin exactly contract `0.1.0` at commit `d8146cfb0a1c74fc6432284c4356bb0c864b37b5` and
 read the pinned guide before implementing protocol details. If this skill is installed
 without its sibling, the scaffolder is absent: create the bundle by hand from the pinned
 contract's `docs/guides/connecting-compatible-agents.md` and mark the structural check
@@ -152,7 +152,11 @@ absent, apply the `fabric-service/0.1` rules from the pinned contract's
 `docs/specification/service.md` by hand and mark its probe `NOT_RUN`.
 
 Build the capability behind the chosen surface. Keep model choice and internal reasoning
-outside the contract; expose typed outcomes, evidence, and protocol-visible state. Every
+outside the contract; expose typed outcomes, evidence, and protocol-visible state. One fact
+about each model lane is the contract's (DEC-0083): what it reads. Ask in the grill which
+lanes read what members, clients or the public send, declare it as the profile's `reads`,
+and give such a lane an open-vendor route (FAC-SEM-112; the `building-fabric-services`
+profiles reference). Every
 provider output is untrusted until schemas and semantic assertions pass. The step-2
 observables are the definition of done; an observable attached after the code exists
 lets the output decide what counts as success.

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

@@ -19,7 +19,7 @@ compatibility: >-
   this plugin; Codex and Kimi Code get the session-start preamble hook on the person's consent.
 metadata:
   author: PassionCode.ai
-  version: "0.33.0"
+  version: "0.34.1"
 ---
 
 # Working with Fabric

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session.py

@@ -60,7 +60,7 @@ WATCH_MAX_BACKOFF_S = 900
 SESSION_ID = re.compile(r"[A-Za-z0-9._:-]{1,128}")
 LOOPBACK_ORIGIN = re.compile(r"http://127\.0\.0\.1:(\d{1,5})")
 LOCAL_ORIGIN = re.compile(r'"origin": "http://(?:127\.0\.0\.1|localhost)')
-VERSION = "0.33.0"
+VERSION = "0.34.1"
 HOSTS = {"claude": "Claude Code", "codex": "Codex", "kimi": "Kimi Code"}
 # A session Fabric launched. FABRIC_LAUNCHED_SESSION=1 is the marker Fabric is asked to set (need D6); the others are
 # what Fabric already gives a launched session (fabric sessionBundle.ts): only their NAMES are looked at, never a value