@passioncode-ai/fabric-agent-adapter 0.19.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.20.0 - 2026-10-12
+
+Runner routes in both kits: the closed probe results and the route checks FAC-SEM-028…034. These come from contract
+DEC-0026 and DEC-0029, at the pin (FAA-11).
+
+### Added
+
+- **The closed probe result.** `runner_check` / `runnerCheck` answer with `probe`. The values follow the walk's order:
+  - `not-installed`: no catalogued binary is on PATH;
+  - `not-responding`: the version probe did not answer, failed or did not match, or the `auth` probe did not answer;
+  - `not-connected`: the runner answers but is signed out;
+  - null: the runner can serve.
+
+  The doctor still names every problem it found.
+- **The route checks.** `route_problems(kind, value)` / `routeProblems(kind, value)` are the contract's `routeRules`,
+  finding for finding: code, path and message.
+  - `runner-route`: one candidate per runner kind (FAC-SEM-028), and every candidate can attach or spawn (029).
+  - `route-bundle`:
+    - provider revisions are admitted by id, revision and hash (030);
+    - the binding agrees with the route (032);
+    - kinds and drives are in the runner catalogue (033).
+  - `route-event` tells the truth about its route (034):
+    - candidates by position;
+    - probes in order;
+    - the session, hold and recovery policy.
+- `PROBE_RESULTS` lists the closed vocabulary of a passed-over candidate.
+- **Tests.** `test/fixtures/contract/route-vectors.json` holds 43 cases, generated by `make_route_vectors.mjs` from the
+  contract's own `src/route-rules.ts` at the pin. Both kits answer every case exactly.
+  - Mutation testing: 23 planted defects, all caught.
+- **Docs.** `references/profiles.md` gains *Runner routes* and the probe result. `SKILL.md` points to it. The scenario
+  eval `runner-routes-and-probe-results` and a trigger came first.
+
 ## 0.19.0 - 2026-10-12
 
 Settings backups, every spending limit and the feed client's token header in both kits. These are the

package/README.md

@@ -230,8 +230,8 @@ FABRIC_CONTRACT_OLD=/path/to/legacy-contract FABRIC_CONTRACT_NEW=/path/to/curren
 ```
 
 Without both environment variables, those tests explicitly skip as `NOT_RUN`.
-This source checkout is 0.19.0. 0.18.0 is the latest published GitHub/npm release (2026-10-12; 0.7.0 and 0.11.0
-were never released); 0.19.0 is published by its `v0.19.0` tag. Source delivery does not update installed skills or live sessions.
+This source checkout is 0.20.0. 0.19.0 is the latest published GitHub/npm release (2026-10-12; 0.7.0 and 0.11.0
+were never released); 0.20.0 is published by its `v0.20.0` tag. Source delivery does not update installed skills or live sessions.
 
 ## License
 

package/package.json

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

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

@@ -3,7 +3,7 @@
   "name": "fabric-agent-adapter",
   "displayName": "Fabric Agent Adapter",
   "description": "Create new Fabric-compatible agents, build them as always-alive local services with dashboards (fabric-service/0.1), and adapt existing projects to the Fabric Agent Contract through evidence-backed MCP, A2A, or local-runner provider bundles.",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

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

@@ -5,7 +5,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode.
 metadata:
   author: PassionCode.ai
-  version: "0.19.0"
+  version: "0.20.0"
   contract-version: "0.1.0"
   contract-commit: "0cacd08b0e95b6abf131eae1206b60792138bc3c"
 ---

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

@@ -16,7 +16,7 @@ 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.19.0"
+  version: "0.20.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
   extension-commit: "0cacd08b0e95b6abf131eae1206b60792138bc3c"
@@ -84,7 +84,8 @@ are in [`scripts/fabric_interop.py`](scripts/fabric_interop.py) and
 service checks each call's delegation token (DEC-0039): read [the delegation reference](references/delegation.md);
 the verifier is [`scripts/fabric_delegation.py`](scripts/fabric_delegation.py) /
 [`scripts/fabric-delegation.mjs`](scripts/fabric-delegation.mjs). When Fabric chooses the service's runner and models
-(DEC-0046), read [the profiles reference](references/profiles.md).
+(DEC-0046), or a project routes its work through an ordered list of runners (DEC-0026: the doctor's closed probe
+results, the route checks FAC-SEM-028…034), read [the profiles reference](references/profiles.md).
 
 ## Step 2 — the non-negotiables
 

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

@@ -13,6 +13,7 @@ Python: [`scripts/fabric_profiles.py`](../scripts/fabric_profiles.py); Node:
 - Checking the documents
 - Declaring and showing what applies
 - The doctor
+- Runner routes
 - Usage by route
 
 ## Resolving the model profile
@@ -58,6 +59,28 @@ catalogued binary found on `PATH`, only with the catalogued version argv (and `a
 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.
 
+`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,
+failed or did not match the catalogue's pattern, or the `auth` probe did not answer), `not-connected` (it answers but
+the `auth` probe says signed out), or `None`/`null` when the runner can serve. The order is the walk's: installed,
+then responding, then connected. `problems` still names every problem the doctor found.
+
+## Runner routes
+
+A project may pin a **runner route** (DEC-0026, DEC-0029, `runners.md` §"Runner routes"): the ordered terminal agents
+that serve one capability, each with a session policy (`attach`, `spawn`), what happens when all are unavailable
+(`exhausted`) and whether a conversation returns to a preferred runner (`recovery`). Fabric walks it; a service that
+pins, records or shows routes checks them with `route_problems(kind, value)` / `routeProblems(kind, value)`, the
+contract's `routeRules` finding for finding:
+
+| `kind` | value | rules |
+|---|---|---|
+| `runner-route` | the route | one candidate per runner kind (FAC-SEM-028); a candidate can attach or spawn (029) |
+| `route-bundle` | `{route, admissions, binding?, catalogue?}` | every candidate's provider revision admitted for the capability by id, revision and hash (030); the binding agrees — project, capability, local-runner, a candidate as provider, this route as `runnerRoute` (032); every kind and named drive is in the runner catalogue (033) |
+| `route-event` | `{route, event}` | the event names this route, project and capability; candidates by position; the probes cover every candidate above the selection in order (all for an exhausted walk, none for a sticky relaunch); attach, spawn, `no-held-session` and `spawn-failed` obey the session policy; `held` only under `exhausted: hold`; `preferred-available` only under `recovery: reprobe`, moving up (034) |
+
+A probe result in an event is one of `PROBE_RESULTS`; a host never appends a runner the route does not name.
+
 ## Usage by route
 
 `make_usage_receipt(..., route="subscription"|"key")` records how the call was paid — the operator's own login in its

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

@@ -126,6 +126,10 @@ function which(name, searchPath) {
  * runners.md C2: is the catalogued runner installed, which version answers, and is it signed in. Only a bare
  * catalogued binary on PATH is run, only with the catalogued version (and auth) argv, without a shell, within its
  * timeout (at most 5 s). An entry outside these rules is refused and nothing runs.
+ *
+ * `probe` is the contract's closed probe result for a walk (DEC-0026): `not-installed`, `not-responding` (the version
+ * probe did not answer, failed or did not match), `not-connected` (signed out by the `auth` probe), or null when the
+ * runner can serve. The twin of fabric_profiles.runner_check.
  */
 export function runnerCheck(entry, { searchPath = process.env.PATH, run = spawnSync } = {}) {
   const { kind, binaries } = entry ?? {};
@@ -136,10 +140,10 @@ export function runnerCheck(entry, { searchPath = process.env.PATH, run = spawnS
   const timeoutMs = version.timeoutMs ?? MAX_PROBE_MS;
   if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_PROBE_MS) throw new ProfileError(`version.timeoutMs is at most ${MAX_PROBE_MS}`);
   const authArgv = 'auth' in entry ? argvOf(entry.auth, 'auth') : null;
-  const out = { kind, installed: false, binary: null, version: null, signedIn: null, problems: [] };
+  const out = { kind, installed: false, binary: null, version: null, signedIn: null, probe: 'not-installed', problems: [] };
   const binary = binaries.map((name) => which(name, searchPath)).find(Boolean) ?? null;
   if (!binary) { out.problems.push(`${kind} is not installed: none of ${binaries.join(', ')} is on PATH`); return out; }
-  Object.assign(out, { installed: true, binary });
+  Object.assign(out, { installed: true, binary, probe: 'not-responding' });
   const probe = (argv) => {
     const result = run(binary, argv, { encoding: 'utf8', timeout: timeoutMs, shell: false });
     if (result.error?.code === 'ETIMEDOUT' || result.signal === 'SIGTERM') { out.problems.push(`${kind} ${argv.join(' ')} did not answer within ${timeoutMs} ms`); return null; }
@@ -153,10 +157,12 @@ export function runnerCheck(entry, { searchPath = process.env.PATH, run = spawnS
     if (match && match.length > 1) out.version = match[1];
     else out.problems.push(`${kind} answered, but its version did not match the catalogue's pattern`);
   }
-  if (authArgv) {
-    const signed = probe(authArgv);
-    if (signed) { out.signedIn = signed.status === 0; if (!out.signedIn) out.problems.push(`${kind} is installed but not signed in`); }
-  }
+  const signed = authArgv ? probe(authArgv) : null;
+  if (signed) { out.signedIn = signed.status === 0; if (!out.signedIn) out.problems.push(`${kind} is installed but not signed in`); }
+  // The walk's order (runners.md): installed, then responding, then connected. The doctor still reports every problem.
+  if (out.version === null || (authArgv && !signed)) out.probe = 'not-responding';
+  else if (out.signedIn === false) out.probe = 'not-connected';
+  else out.probe = null;
   return out;
 }
 
@@ -194,3 +200,131 @@ export function configurationSummary(doc) {
   if (resolved.modelProfile) tiles.push({ label: 'Model', value: [resolved.modelProfile, (resolved.models ?? [])[0]].filter(Boolean).join(' · ') });
   return tiles;
 }
+
+// ---- runner routes (DEC-0026, DEC-0029; FAC-SEM-028…034) ----
+// The contract's routeRules (src/route-rules.ts), finding for finding: code, path and message. The twin of
+// fabric_profiles.route_problems.
+
+/** The closed probe results a walk records for a candidate it passed over (runner-route-event.schema.json). */
+export const PROBE_RESULTS = Object.freeze(['not-catalogued', 'not-admitted', 'not-installed', 'not-responding', 'not-connected', 'no-held-session', 'quota-unknown', 'refused', 'spawn-failed']);
+
+const routeCandidates = (value) => (Array.isArray(value?.candidates) ? value.candidates.filter(isObject) : []);
+const objectAt = (value, key) => (isObject(value?.[key]) ? value[key] : {});
+const refKey = (ref) => (isObject(ref) ? `${String(ref.id)}@${String(ref.revision)}#${String(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);
+    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');
+    if (session.attach === 'never' && session.spawn === 'never') findings.push(finding('FAC-SEM-029', `/candidates/${index}/session`, `candidate ${kind} can never run: attach and spawn are both "never"`));
+  });
+  return findings;
+}
+
+function routeBundle(value) {
+  const route = objectAt(value, 'route');
+  const admissions = Array.isArray(value.admissions) ? value.admissions.filter(isObject) : [];
+  const admitted = new Set(admissions.filter((a) => a.state === 'admitted' && a.capability === route.capability).map((a) => refKey(a.provider)));
+  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 (isObject(value.binding)) {
+    const binding = value.binding;
+    const disagree = (where, message) => findings.push(finding('FAC-SEM-032', `/binding/${where}`, message));
+    if (binding.project !== route.project) disagree('project', `the binding is for ${String(binding.project)}, the route for ${String(route.project)}`);
+    if (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 (!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]));
+    routeCandidates(route).forEach((candidate, index) => {
+      const kind = String(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)}`));
+    });
+  }
+  return findings;
+}
+
+function routeEvent(value) {
+  const route = objectAt(value, 'route');
+  const event = objectAt(value, 'event');
+  const list = routeCandidates(route);
+  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 (event.project !== route.project) wrong('/project', `the event is for ${String(event.project)}, the route for ${String(route.project)}`);
+  if (event.capability !== route.capability) wrong('/capability', `the event names ${String(event.capability)}, the route orders ${String(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`);
+      return undefined;
+    }
+    return candidate;
+  };
+  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`);
+  });
+  const expectProbes = (count) => {
+    const indexes = probes.map(indexOf);
+    const expected = Array.from({ length: Math.max(count, 0) }, (_, index) => index);
+    if (indexes.length !== expected.length || indexes.some((index, position) => index !== expected[position])) {
+      wrong('/probes', `the walk must record candidates ${expected.join(', ') || 'none'} in order; it records ${indexes.join(', ') || 'none'}`);
+    }
+  };
+  if (event.kind === 'runner-exhausted') {
+    expectProbes(list.length);
+    if (event.answer === 'held' && route.exhausted !== 'hold') wrong('/answer', 'the route does not declare exhausted: hold, so an exhausted walk answers capability-unavailable');
+    return findings;
+  }
+  const selected = objectAt(event, 'selected');
+  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 (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');
+      if (event.conversation === undefined) wrong('/sticky', 'only a conversation can keep its runner');
+      expectProbes(0);
+    } else expectProbes(indexOf(selected));
+  }
+  if (event.kind === 'runner-switched') {
+    const from = objectAt(event, 'from');
+    candidateAt(from, '/from');
+    if (indexOf(from) === indexOf(selected)) wrong('/from', 'a switch moves to another candidate');
+    if (event.reason === 'preferred-available') {
+      if (route.recovery !== 'reprobe') wrong('/reason', 'only a route with recovery: reprobe moves a conversation back to a preferred runner');
+      if (!(indexOf(selected) < indexOf(from))) wrong('/reason', 'preferred-available moves to a higher-preference candidate');
+    }
+  }
+  return findings;
+}
+
+/**
+ * The contract's routeRules: findings for a `runner-route` (FAC-SEM-028, 029), a `route-bundle` `{route, admissions,
+ * binding?, catalogue?}` (030, 032, 033) or a `route-event` `{route, event}` (034); undefined for another kind or a
+ * value that is not an object.
+ */
+export function routeProblems(kind, value) {
+  if (!isObject(value)) return undefined;
+  return { 'runner-route': runnerRoute, 'route-bundle': routeBundle, 'route-event': routeEvent }[kind]?.(value);
+}

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

@@ -187,7 +187,11 @@ def runner_check(entry: Dict[str, Any], *, path: Optional[str] = None,
                  run: Callable[..., Any] = subprocess.run) -> Dict[str, Any]:
     """runners.md C2: is the catalogued runner installed, which version answers, and is it signed in. Only a bare
     catalogued binary found on PATH is run, only with the catalogued version argv (and `auth` argv), without a shell,
-    within its timeout (at most 5 s). A catalogue entry outside these rules is refused and nothing runs."""
+    within its timeout (at most 5 s). A catalogue entry outside these rules is refused and nothing runs.
+
+    ``probe`` is the contract's closed probe result for a walk (DEC-0026): ``not-installed`` (no catalogued binary on
+    PATH), ``not-responding`` (the version probe did not answer, failed or did not match the catalogue's pattern),
+    ``not-connected`` (it answers, but the ``auth`` probe says signed out), or None when the runner can serve."""
     kind = entry.get("kind")
     binaries = entry.get("binaries")
     if not isinstance(binaries, list) or not binaries or not all(isinstance(b, str) and _BARE_BINARY.match(b) and ".." not in b for b in binaries):
@@ -201,11 +205,13 @@ def runner_check(entry: Dict[str, Any], *, path: Optional[str] = None,
     if not isinstance(timeout_ms, int) or isinstance(timeout_ms, bool) or not 0 < timeout_ms <= MAX_PROBE_MS:
         raise ProfileError("version.timeoutMs is at most %d" % MAX_PROBE_MS)
     auth_argv = _argv(entry["auth"], "auth") if "auth" in entry else None
-    out: Dict[str, Any] = {"kind": kind, "installed": False, "binary": None, "version": None, "signedIn": None, "problems": []}
+    out: Dict[str, Any] = {"kind": kind, "installed": False, "binary": None, "version": None, "signedIn": None,
+                           "probe": "not-installed", "problems": []}
     binary = next((found for found in (shutil.which(name, path=path) for name in binaries) if found), None)
     if binary is None:
         out["problems"].append("%s is not installed: none of %s is on PATH" % (kind, ", ".join(binaries)))
         return out
+    out["probe"] = "not-responding"
     out.update(installed=True, binary=binary)
 
     def probe(argv: List[str]) -> Optional[Any]:
@@ -224,12 +230,18 @@ def runner_check(entry: Dict[str, Any], *, path: Optional[str] = None,
             out["version"] = match.group(1)
         else:
             out["problems"].append("%s answered, but its version did not match the catalogue's pattern" % kind)
-    if auth_argv is not None:
-        signed = probe(auth_argv)
-        if signed is not None:
-            out["signedIn"] = signed.returncode == 0
-            if not out["signedIn"]:
-                out["problems"].append("%s is installed but not signed in" % kind)
+    signed = probe(auth_argv) if auth_argv is not None else None
+    if signed is not None:
+        out["signedIn"] = signed.returncode == 0
+        if not out["signedIn"]:
+            out["problems"].append("%s is installed but not signed in" % kind)
+    # The walk's order (runners.md): installed, then responding, then connected. The doctor still reports every problem.
+    if out["version"] is None or (auth_argv is not None and signed is None):
+        out["probe"] = "not-responding"
+    elif out["signedIn"] is False:
+        out["probe"] = "not-connected"
+    else:
+        out["probe"] = None
     return out
 
 
@@ -275,3 +287,200 @@ def configuration_summary(doc: Dict[str, Any]) -> List[Dict[str, Any]]:
         first = (resolved.get("models") or [None])[0]
         tiles.append({"label": "Model", "value": " · ".join(x for x in (resolved["modelProfile"], first) if x)})
     return tiles
+
+
+# --- runner routes (DEC-0026, DEC-0029; FAC-SEM-028…034) ----------------------------------------------------------
+# The contract's routeRules (src/route-rules.ts), ported finding for finding: code, path and message.
+
+#: The closed probe results a walk records for a candidate it passed over (runner-route-event.schema.json).
+PROBE_RESULTS = ("not-catalogued", "not-admitted", "not-installed", "not-responding", "not-connected", "no-held-session",
+                 "quota-unknown", "refused", "spawn-failed")
+_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)
+
+
+def _object_at(value: Any, key: str) -> Dict[str, Any]:
+    found = value.get(key) if isinstance(value, dict) else None
+    return found if isinstance(found, dict) else {}
+
+
+def _ref_key(ref: Any) -> str:
+    if not isinstance(ref, dict):
+        return ""
+    return "%s@%s#%s" % (_field(ref, "id"), _field(ref, "revision"), _field(ref, "contentHash"))
+
+
+def _same_ref(a: Any, b: Any) -> bool:
+    return _ref_key(a) != "" and _ref_key(a) == _ref_key(b)
+
+
+def _candidates(value: Any) -> List[Dict[str, Any]]:
+    return _list(value.get("candidates") if isinstance(value, dict) else None)
+
+
+def _runner_route(value: Dict[str, Any]) -> List[Dict[str, str]]:
+    findings, kinds = [], set()
+    for index, candidate in enumerate(_candidates(value)):
+        kind = _field(candidate, "runnerKind")
+        if kind in kinds:
+            findings.append(_finding("FAC-SEM-028", "/candidates/%d/runnerKind" % index, "runner kind %s appears in the route more than once" % kind))
+        kinds.add(kind)
+        session = _object_at(candidate, "session")
+        if session.get("attach") == "never" and session.get("spawn") == "never":
+            findings.append(_finding("FAC-SEM-029", "/candidates/%d/session" % index, 'candidate %s can never run: attach and spawn are both "never"' % kind))
+    return findings
+
+
+def _route_bundle(value: Dict[str, Any]) -> List[Dict[str, str]]:
+    route = _object_at(value, "route")
+    admitted = {_ref_key(a.get("provider")) for a in _list(value.get("admissions"))
+                if a.get("state") == "admitted" and a.get("capability", _MISSING) == route.get("capability", _MISSING)}
+    findings = []
+    for index, candidate in enumerate(_candidates(route)):
+        key = _ref_key(candidate.get("provider"))
+        if key not in admitted:
+            findings.append(_finding("FAC-SEM-030", "/route/candidates/%d/provider" % index, "candidate %s names provider %s, which is not a revision admitted for %s"
+                                     % (_field(candidate, "runnerKind"), key, _field(route, "capability"))))
+    if isinstance(value.get("binding"), dict):
+        findings.extend(_binding_agreement(value["binding"], route))
+    if isinstance(value.get("catalogue"), list):
+        findings.extend(_catalogue_agreement(_list(value["catalogue"]), route))
+    return findings
+
+
+def _binding_agreement(binding: Dict[str, Any], route: Dict[str, Any]) -> List[Dict[str, str]]:
+    findings = []
+
+    def disagree(path: str, message: str) -> None:
+        findings.append(_finding("FAC-SEM-032", "/binding/" + path, message))
+
+    if binding.get("project", _MISSING) != route.get("project", _MISSING):
+        disagree("project", "the binding is for %s, the route for %s" % (_field(binding, "project"), _field(route, "project")))
+    if binding.get("capability", _MISSING) != route.get("capability", _MISSING):
+        disagree("capability", "the binding binds %s, the route orders %s" % (_field(binding, "capability"), _field(route, "capability")))
+    if binding.get("profileKind") != "local-runner":
+        disagree("profileKind", "a runner route serves the local-runner profile, not %s" % _field(binding, "profileKind"))
+    if not any(_same_ref(c.get("provider"), binding.get("provider")) for c in _candidates(route)):
+        disagree("provider", "the binding's provider %s is not a candidate of the route" % _ref_key(binding.get("provider")))
+    if "runnerRoute" in binding and not _same_ref(binding["runnerRoute"], route.get("meta")):
+        disagree("runnerRoute", "the binding pins %s, not this route %s" % (_ref_key(binding["runnerRoute"]), _ref_key(route.get("meta"))))
+    return findings
+
+
+def _catalogue_agreement(catalogue: List[Dict[str, Any]], route: Dict[str, Any]) -> List[Dict[str, str]]:
+    by_kind = {_field(entry, "kind"): entry for entry in catalogue}
+    findings = []
+    for index, candidate in enumerate(_candidates(route)):
+        kind = _field(candidate, "runnerKind")
+        entry = by_kind.get(kind)
+        if entry is None:
+            findings.append(_finding("FAC-SEM-033", "/route/candidates/%d/runnerKind" % index, "runner kind %s has no entry in the host's catalogue" % kind))
+            continue
+        if "drive" in candidate and _field(candidate, "drive") not in _object_at(entry, "drives"):
+            findings.append(_finding("FAC-SEM-033", "/route/candidates/%d/drive" % index, "the catalogue entry for %s offers no drive %s" % (kind, _field(candidate, "drive"))))
+    return findings
+
+
+def _index_of(ref: Dict[str, Any]) -> int:
+    index = ref.get("index")
+    if isinstance(index, bool) or not isinstance(index, (int, float)) or not float(index).is_integer():
+        return -1
+    return int(index)
+
+
+def _route_event(value: Dict[str, Any]) -> List[Dict[str, str]]:
+    route = _object_at(value, "route")
+    event = _object_at(value, "event")
+    candidates = _candidates(route)
+    findings: List[Dict[str, str]] = []
+
+    def wrong(path: str, message: str) -> None:
+        findings.append(_finding("FAC-SEM-034", "/event" + path, message))
+
+    if not _same_ref(event.get("route"), route.get("meta")):
+        wrong("/route", "the event names route %s, not %s" % (_ref_key(event.get("route")), _ref_key(route.get("meta"))))
+    if event.get("project", _MISSING) != route.get("project", _MISSING):
+        wrong("/project", "the event is for %s, the route for %s" % (_field(event, "project"), _field(route, "project")))
+    if event.get("capability", _MISSING) != route.get("capability", _MISSING):
+        wrong("/capability", "the event names %s, the route orders %s" % (_field(event, "capability"), _field(route, "capability")))
+
+    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)
+                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
+        return candidate
+
+    probes = _list(event.get("probes"))
+    for position, probe in enumerate(probes):
+        candidate = candidate_at(probe, "/probes/%d" % position)
+        if candidate is not None and probe.get("result") == "no-held-session" and _object_at(candidate, "session").get("spawn") != "never":
+            wrong("/probes/%d/result" % position, "%s may spawn, so finding no held session does not pass it over" % _field(probe, "runnerKind"))
+        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:
+        indexes = [_index_of(p) for p in probes]
+        expected = list(range(max(count, 0)))
+        if indexes != expected:
+            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"))
+
+    if event.get("kind") == "runner-exhausted":
+        expect_probes(len(candidates))
+        if event.get("answer") == "held" and route.get("exhausted") != "hold":
+            wrong("/answer", "the route does not declare exhausted: hold, so an exhausted walk answers capability-unavailable")
+        return findings
+
+    selected = _object_at(event, "selected")
+    chosen = candidate_at(selected, "/selected")
+    if chosen is not None:
+        session = _object_at(chosen, "session")
+        if selected.get("session") == "attached" and session.get("attach") != "preferred":
+            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"]:
+            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.
+            if route.get("recovery") == "reprobe":
+                wrong("/sticky", "a route with recovery: reprobe walks from the top at every launch")
+            if "conversation" not in event:
+                wrong("/sticky", "only a conversation can keep its runner")
+            expect_probes(0)
+        else:
+            expect_probes(_index_of(selected))
+
+    if event.get("kind") == "runner-switched":
+        source = _object_at(event, "from")
+        candidate_at(source, "/from")
+        if _index_of(source) == _index_of(selected):
+            wrong("/from", "a switch moves to another candidate")
+        if event.get("reason") == "preferred-available":
+            if route.get("recovery") != "reprobe":
+                wrong("/reason", "only a route with recovery: reprobe moves a conversation back to a preferred runner")
+            if not _index_of(selected) < _index_of(source):
+                wrong("/reason", "preferred-available moves to a higher-preference candidate")
+    return findings
+
+
+def route_problems(kind: str, value: Any) -> Optional[List[Dict[str, str]]]:
+    """The contract's routeRules: findings for a `runner-route` (FAC-SEM-028, 029), a `route-bundle`
+    `{route, admissions, binding?, catalogue?}` (030, 032, 033) or a `route-event` `{route, event}` (034); None for
+    another kind or a value that is not an object."""
+    if not isinstance(value, dict):
+        return None
+    rules = {"runner-route": _runner_route, "route-bundle": _route_bundle, "route-event": _route_event}.get(kind)
+    return rules(value) if rules else None

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

@@ -5,7 +5,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.19.0"
+  version: "0.20.0"
   contract-version: "0.1.0"
   contract-commit: "0cacd08b0e95b6abf131eae1206b60792138bc3c"
 ---