@passioncode-ai/passioncode 0.1.9 → 0.1.11

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.1.11 - 2026-09-30
+
+### Fixed
+
+- Fabric Agent Adapter 0.5.2 in the set (`family.json` pins `v0.5.2`, was `v0.5.1`): services built on its
+  kits answer the MCP `initialize` handshake, so a real client such as Claude Code connects (0.5.0
+  and 0.5.1 did not), and every tool's `outputSchema` has an object root (contract DEC-0018).
+
+## 0.1.10 - 2026-09-30
+
+### Changed
+
+- Fabric Agent Adapter 0.5.1 in the set (`family.json` pins `v0.5.1`, was `v0.5.0`): the kits follow the
+  contract rulings of DEC-0017 — full result envelope with its trace for jobs, a job tool's
+  `outputSchema` as the union of envelope and handle, `providers/` entries carrying `providerId`.
+
 ## 0.1.9 - 2026-09-30
 
 ### Changed

package/family.json

@@ -8,7 +8,7 @@
       "name": "fabric-agent-adapter",
       "displayName": "Fabric Agent Adapter",
       "repo": "passioncode-ai/fabric-agent-adapter",
-      "ref": "v0.5.0",
+      "ref": "v0.5.2",
       "kind": "plugin",
       "path": "plugins/fabric-agent-adapter",
       "legacyPluginIds": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/passioncode",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Every PassionCode.ai agent skill — Fabric Agent Adapter, Observatory Log and the organisation's working rules — for Claude Code and every other agent on the machine, updated as one set.",
   "bin": {
     "passioncode": "bin/passioncode.js"

package/payload/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "fabric-agent-adapter",
       "displayName": "Fabric Agent Adapter",
       "source": "./plugins/fabric-agent-adapter",
-      "version": "0.5.0",
+      "version": "0.5.2",
       "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.",
       "author": {
         "name": "PassionCode.ai",
@@ -35,7 +35,7 @@
       "name": "passioncode",
       "displayName": "PassionCode.ai",
       "source": "./plugins/passioncode",
-      "version": "0.1.9",
+      "version": "0.1.11",
       "description": "The organisation's working rules for every contributor's agent (working-in-passioncode), and a once-a-day check that keeps the PassionCode.ai set current.",
       "author": {
         "name": "PassionCode.ai",

package/payload/manifest.json

@@ -1,15 +1,15 @@
 {
   "family": "passioncode",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "release": true,
   "members": [
     {
       "name": "fabric-agent-adapter",
       "displayName": "Fabric Agent Adapter",
       "repo": "passioncode-ai/fabric-agent-adapter",
-      "ref": "v0.5.0",
-      "commit": "f31c2b2792f77153b1a5adda4bec6c622fc8af97",
-      "version": "0.5.0",
+      "ref": "v0.5.2",
+      "commit": "b7a6b8ea081894ea8c0d3765879721c17f6a3655",
+      "version": "0.5.2",
       "via": "clone of https://***@github.com/passioncode-ai/fabric-agent-adapter.git",
       "skills": [
         "adapting-projects-to-fabric",
@@ -22,7 +22,7 @@
       "legacyMarketplaces": [
         "fabric-agent-adapter"
       ],
-      "contentHash": "sha256:0f275fc3d94e42c1e8f387c409d25b675496d384a8c3eb418959d5a87d3cd64b",
+      "contentHash": "sha256:8d2a7d2795b1ab1e0dd3a1fc9a073c70e6085f160fa125bd5ada5a5f3d8d4c0b",
       "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.",
       "author": {
         "name": "PassionCode.ai",
@@ -61,16 +61,16 @@
       "name": "passioncode",
       "displayName": "PassionCode.ai",
       "repo": "passioncode-ai/passioncode",
-      "ref": "v0.1.9",
+      "ref": "v0.1.11",
       "commit": null,
-      "version": "0.1.9",
+      "version": "0.1.11",
       "via": "this repository",
       "skills": [
         "working-in-passioncode"
       ],
       "legacyPluginIds": [],
       "legacyMarketplaces": [],
-      "contentHash": "sha256:c810e4afb3cfccaa5a367933ce258b97a7d608be6f3bc791cd5c821893fd4554",
+      "contentHash": "sha256:917c5c1429a60a70666f1f8c7b2ee73d2e50bb8db56f64104f418ab0b7a46816",
       "description": "The organisation's working rules for every contributor's agent (working-in-passioncode), and a once-a-day check that keeps the PassionCode.ai set current.",
       "author": {
         "name": "PassionCode.ai",

package/payload/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.5.0",
+  "version": "0.5.2",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

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

@@ -5,9 +5,9 @@ license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned private fabric-agent-contract checkout. Works without those tools in an explicitly degraded structural-check mode.
 metadata:
   author: PassionCode.ai
-  version: "0.5.0"
+  version: "0.5.2"
   contract-version: "0.1.0"
-  contract-commit: "a22dea359ba04b8fe549abe81a5131552cb90eff"
+  contract-commit: "2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f"
 ---
 
 # 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 `a22dea359ba04b8fe549abe81a5131552cb90eff`.
+- commit `2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f`.
 
 Read the pinned contract's guide
 `docs/guides/connecting-compatible-agents.md`, the selected profile specification, and
@@ -128,7 +128,7 @@ Treat all provider output as untrusted until schemas and semantic assertions pas
 An agent Fabric reaches as a CLI or a stdio MCP server gets a provider entry, written by
 its installer with [`scripts/fabric_provider.py`](scripts/fabric_provider.py) and removed
 by its uninstaller — argv arrays only, env values as `secret-ref:` references, never the
-id of an existing service. Load [provider entries](references/provider-entry.md). An
+id of an existing service, and a `providerId` equal to the manifest's `provider.id`. Load [provider entries](references/provider-entry.md). An
 agent that runs as a service uses a descriptor instead (`building-fabric-services`).
 
 ### 5. Make probes safe and meaningful

package/payload/plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/provider-entry.md

@@ -1,7 +1,7 @@
 # Provider entries: agents that are not services
 
 Normative source: the Fabric Agent Contract's `docs/specification/provider.md`
-(`fabric-provider/0.1`, DEC-0016) at the commit this plugin pins.
+(`fabric-provider/0.1`, DEC-0016, rulings DEC-0017) at the commit this plugin pins.
 
 An agent Fabric reaches as a CLI or a stdio MCP server — not a long-running service —
 is announced by one entry, `providers/<id>.json`, in the same root as the services
@@ -22,7 +22,8 @@ service or a provider, never both.
 and refuses what the contract refuses.
 
 ```bash
-python3 scripts/fabric_provider.py write --id example-agent --name "Example Agent" \
+python3 scripts/fabric_provider.py write --id example-agent --provider-id https://agents.example/providers/example-agent \
+  --name "Example Agent" \
   --manifest ~/.local/share/example-agent/fabric-agent.json --installed-by "example-agent 1.0.0" \
   --env EXAMPLE_API_KEY=secret-ref:example-agent/EXAMPLE_API_KEY \
   --stdio ~/.local/bin/example-agent mcp
@@ -35,19 +36,22 @@ python3 scripts/fabric_provider.py remove example-agent      # the uninstaller
 
 It refuses, with one sentence that never quotes a value:
 
+- a manifest that does not resolve, or whose `provider.id` is not the entry's
+  `providerId` — the two URIs are compared as URIs (FAC-SEM-014);
 - an id that is already a service in `services/` (FAC-SEM-013);
 - an env value that is not `secret-ref:<name>`, or a reference that has the shape of a
-  credential itself — a token prefix, a private key, a JWT (FAC-SEM-015);
+  credential itself — a token prefix, a private key, a JWT (FAC-SEM-015: a value is
+  checked by its form; name patterns apply to names);
 - a URL other than `http://127.0.0.1:<port>/mcp`, a manifest path that is not an
   absolute or `~/` path to `fabric-agent.json`, a shell-string command, unknown fields.
 
+`validate` also checks that the file is named `<id>.json` (FAC-SEM-014, slug half).
 From Python: `write_provider_entry(entry)`, `remove_provider_entry(id)`,
-`validate_provider_entry(entry)`, `providers_dir()`.
+`validate_provider_entry(entry)`, `manifest_problems(entry)`, `providers_dir()`.
 
 ## What the entry does not do
 
 It grants nothing: Fabric lists the agent, and admission (probes) and a project binding
 still decide what it may do. The manifest it points at is the authority for the
-agent's capabilities. The contract's rule that the manifest's `provider.id` "equals" the
-entry's id cannot hold as written — `provider.id` is a URI, the entry id a slug — so only
-"the manifest resolves" is checked until the contract answers OQ-0001.
+agent's capabilities. Equality is between like things (DEC-0017): the slug `id` with the
+file name, the URI `providerId` with the manifest's URI `provider.id`.

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

@@ -16,7 +16,7 @@ from urllib.parse import urlparse
 
 CONTRACT_VERSION = "0.1.0"
 CONTRACT_REPOSITORY = "https://github.com/passioncode-ai/fabric-agent-contract"
-CONTRACT_COMMIT = "a22dea359ba04b8fe549abe81a5131552cb90eff"
+CONTRACT_COMMIT = "2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f"
 INTEROP_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1"
 MCP_REVISION = "2026-07-28"
 A2A_VERSION = "1.0"

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

@@ -6,13 +6,13 @@ the providers directory, beside the services directory. Only its installer write
 entry and only its uninstaller removes it; the entry grants no Project access.
 Standard library only; it does not import the service kit, so this skill stands alone.
 
-  fabric_provider.py write --id ID --name NAME --manifest PATH --installed-by TEXT
+  fabric_provider.py write --id ID --provider-id URI --name NAME --manifest PATH --installed-by TEXT
                            (--url http://127.0.0.1:PORT/mcp | --stdio EXECUTABLE [ARG ...])
                            [--env NAME=secret-ref:REF ...] [--summary TEXT] [--repository URL]
   fabric_provider.py remove ID
   fabric_provider.py validate PATH
 
-Normative source: fabric-agent-contract docs/specification/provider.md (DEC-0016).
+Normative source: fabric-agent-contract docs/specification/provider.md (DEC-0016, rulings DEC-0017).
 """
 
 # #region provider-writer — docs: plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric/references/provider-entry.md#the-writer
@@ -35,7 +35,8 @@ _ENV_NAME = re.compile(r"^[A-Z_][A-Z0-9_]*$")
 _SECRET_REF = re.compile(r"^secret-ref:([A-Za-z0-9][A-Za-z0-9._/:@-]{0,255})$")
 _LOCAL_PATH = re.compile(r"^(~/|/)[^\x00]*$")
 _URL = re.compile(r"^http://127\.0\.0\.1:([0-9]{1,5})/mcp$")
-FIELDS = {"protocol", "id", "name", "summary", "manifest", "run", "source", "installedAt", "installedBy", "extensions"}
+_URI = re.compile(r"^[A-Za-z][A-Za-z0-9+.-]*:[^\s]+$")
+FIELDS = {"protocol", "id", "providerId", "name", "summary", "manifest", "run", "source", "installedAt", "installedBy", "extensions"}
 # FAC-SEM-015 reads a credential by its SHAPE: a reference named after a key is fine.
 CREDENTIAL_SHAPES = [re.compile(p) for p in (
     r"^(sk|pk|rk)[-_](live|test|proj|or|ant)?[-_]?[A-Za-z0-9_-]{16,}",
@@ -82,7 +83,7 @@ def validate_provider_entry(entry: Any) -> List[str]:
     if not isinstance(entry, dict):
         return ["an entry is a JSON object"]
     problems: List[str] = []
-    for key in ("protocol", "id", "name", "manifest", "run", "installedAt", "installedBy"):
+    for key in ("protocol", "id", "providerId", "name", "manifest", "run", "installedAt", "installedBy"):
         if key not in entry:
             problems.append("missing %s" % key)
     for key in sorted(set(entry) - FIELDS):
@@ -93,6 +94,8 @@ def validate_provider_entry(entry: Any) -> List[str]:
         problems.append("protocol must be %s" % PROTOCOL)
     if not _ID.match(str(entry["id"])):
         problems.append("id must match %s" % _ID.pattern)
+    if not _URI.match(str(entry["providerId"])):
+        problems.append("providerId is the absolute URI of the manifest's provider.id")
     if not isinstance(entry["name"], str) or not 1 <= len(entry["name"]) <= 80:
         problems.append("name is 1 to 80 characters")
     if "summary" in entry and (not isinstance(entry["summary"], str) or len(entry["summary"]) > 200):
@@ -130,6 +133,20 @@ def _run_problems(run: Any) -> List[str]:
     return problems
 
 
+def manifest_problems(entry: Dict[str, Any]) -> List[str]:
+    """FAC-SEM-014 (DEC-0017), URI half: the manifest resolves and its provider.id equals providerId."""
+    try:
+        manifest = json.loads(Path(os.path.expanduser(str(entry["manifest"]))).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return ["the manifest %s does not resolve (FAC-SEM-014)" % entry["manifest"]]
+    provider = manifest.get("provider") if isinstance(manifest, dict) else None
+    if not isinstance(provider, dict) or not isinstance(manifest.get("capabilities"), list):
+        return ["%s is not a provider manifest (FAC-SEM-014)" % entry["manifest"]]
+    if provider.get("id") != entry["providerId"]:
+        return ["providerId %s is not the manifest's provider.id %s (FAC-SEM-014)" % (entry["providerId"], provider.get("id"))]
+    return []
+
+
 def _atomic_write(path: Path, data: bytes) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     os.chmod(path.parent, 0o700)
@@ -163,6 +180,8 @@ def _service_ids(directory: Path) -> Dict[str, str]:
 def write_provider_entry(entry: Dict[str, Any], directory: Optional[Path] = None, services: Optional[Path] = None) -> Path:
     """Installer-only. Refuses an invalid entry and an id that is already a service (FAC-SEM-013)."""
     problems = validate_provider_entry(entry)
+    if not problems:
+        problems = manifest_problems(entry)
     if problems:
         raise ProviderError("Provider entry is invalid: %s." % "; ".join(problems))
     clash = _service_ids(services or services_dir()).get(entry["id"])
@@ -193,6 +212,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     sub = parser.add_subparsers(dest="command", required=True)
     write = sub.add_parser("write")
     write.add_argument("--id", required=True)
+    write.add_argument("--provider-id", required=True, help="the manifest's provider.id (a URI)")
     write.add_argument("--name", required=True)
     write.add_argument("--summary")
     write.add_argument("--manifest", required=True)
@@ -212,7 +232,12 @@ def main(argv: Optional[List[str]] = None) -> int:
             print("removed" if remove_provider_entry(args.id) else "no entry for %s" % args.id)
             return 0
         if args.command == "validate":
-            problems = validate_provider_entry(json.loads(args.path.read_text(encoding="utf-8")))
+            entry = json.loads(args.path.read_text(encoding="utf-8"))
+            problems = validate_provider_entry(entry)
+            if isinstance(entry, dict) and entry.get("id") != args.path.stem:
+                problems.append("the file name %s is not <id>.json for %s (FAC-SEM-014)" % (args.path.name, entry.get("id")))
+            if not problems:
+                problems = manifest_problems(entry)
             print("; ".join(problems) if problems else "valid")
             return 1 if problems else 0
         env: Dict[str, str] = {}
@@ -224,7 +249,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         run: Dict[str, Any] = {"mcp": {"url": args.url}} if args.url else {"mcp": {"stdio": {"command": args.stdio}}}
         if env and args.stdio:
             run["mcp"]["stdio"]["env"] = env
-        entry: Dict[str, Any] = {"protocol": PROTOCOL, "id": args.id, "name": args.name, "manifest": args.manifest,
+        entry: Dict[str, Any] = {"protocol": PROTOCOL, "id": args.id, "providerId": args.provider_id, "name": args.name, "manifest": args.manifest,
                                  "run": run, "installedAt": _now(), "installedBy": args.installed_by}
         if args.summary:
             entry["summary"] = args.summary

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

@@ -15,10 +15,10 @@ license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
 compatibility: Python 3.9+ or Node.js 20+ for the kits; the probe needs Python 3.9+. launchd steps are macOS-only (Linux services use lifecycle manager none until a systemd adapter exists). No network or package install; the contract checkout is optional.
 metadata:
   author: PassionCode.ai
-  version: "0.5.0"
+  version: "0.5.2"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "a22dea359ba04b8fe549abe81a5131552cb90eff"
+  extension-commit: "2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f"
 ---
 
 # Building Fabric services

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

@@ -1,6 +1,6 @@
 # Being called: `fabric-interop/0.1`
 
-Normative source: the Fabric Agent Contract's `docs/specification/interop.md` (DEC-0016)
+Normative source: the Fabric Agent Contract's `docs/specification/interop.md` (DEC-0016, rulings DEC-0017 and DEC-0018)
 at the commit this plugin pins. This page says how the kit implements it; where the two
 differ, the contract is right.
 
@@ -9,11 +9,11 @@ A service that other agents — and Fabric — call does five things. Each has o
 
 | Rule | What the service does | Helper |
 |---|---|---|
-| C3.1 capability = tool | serves each `mcp` capability of its manifest as the MCP tool of the same name, with the manifest's two schemas unchanged and annotations from the effect | `tool_for_capability` / `toolForCapability`, `expected_annotations` |
+| C3.1 capability = tool | serves each `mcp` capability of its manifest as the MCP tool of the same name, with the manifest's input schema unchanged, its output schema unchanged — or, for a job, wrapped as `oneOf[result envelope, job handle]` — and annotations from the effect | `tool_for_capability` / `toolForCapability`, `job_tool_output_schema`, `expected_annotations` |
 | C3.2 long work = job | a capability whose work can outlive one request declares `"job": true` in its interop block, returns `{"job": {"id", "status": "working"}}`, and serves `fabric.job.get` and `fabric.job.cancel` | `JobStore`, `McpToolServer` (Python), `unknown_job_result` |
-| C3.2 result | a completed job carries the result envelope: `done`, `proof`, `scope`, `notVerified`, `output`, `usage` | `result_envelope` / `resultEnvelope` |
+| C3.2 result | a completed job carries the full result envelope — the shape a synchronous call returns: `id`, `contractVersion`, `outcome`, `done`, `proof`, `scope`, `notVerified`, `artifacts`, `createdAt`, `producer`, `output`, `usage`, and its `trace` | `result_envelope` / `resultEnvelope` |
 | C3.3 a person decides | the job goes `input_required` with an elicitation: a titled single-select in form mode, and URL mode for anything secret | `choice_request`, `form_request`, `url_request` |
-| C3.4 trace | every call runs as a child span of the caller's `_meta.traceparent`; outgoing calls carry the same trace; events about the work carry `traceId` and `spanId` | `child_traceparent`, `trace_ids`, `make_event(..., trace_id=, span_id=)` |
+| C3.4 trace | every call runs as a child span of the caller's `_meta.traceparent`; outgoing calls carry the same trace; the result envelope records it; events about traced work carry `traceId` and `spanId`, events about untraced work none | `child_traceparent`, `trace_ids`, `make_event(..., trace_id=, span_id=)` |
 
 The interop block sits in the manifest under the capability's `extensions`:
 
@@ -40,25 +40,42 @@ response = server.handle(json_rpc_message)          # POST /mcp body in, JSON re
 - `jobs.request_input(job_id, {"title_choice": fi.choice_request(...)}, "Two titles are ready.")`
   stops for a person. Fabric answers through `fabric.job.get` with `inputResponses`; the
   server calls `on_input(job_id, answers, ctx)` with the answers that matched.
-- `jobs.complete(job_id, fi.result_envelope(...))`, `jobs.fail(job_id, code, message)`,
-  `jobs.cancel(job_id)`. A terminal job never changes again.
-- Every result carries `_meta.traceparent`. For a job it is the span of the call that
-  started it, so the result is traced (the contract's FAC-SEM-019 records an untraced
-  result as an incomplete span).
+- `jobs.complete(job_id, fi.result_envelope(outcome=..., producer=..., ...))`,
+  `jobs.fail(job_id, code, message)`, `jobs.cancel(job_id)`. A terminal job never changes
+  again. A result with unverified claims is `partial`, never `succeeded`.
+- The envelope's `trace` is authoritative for a stored result (DEC-0017): `complete` fills
+  it with the span of the call that started the job and refuses one naming another span,
+  and `fabric.job.get` answers with that same traceparent in `_meta` (FAC-SEM-022). The
+  contract's FAC-SEM-019 records a result without a trace as an incomplete span.
 - Log events about the work with `**fi.trace_ids(ctx.traceparent)` so the pair lands on
   the event.
 
-`McpToolServer` answers `server/discover`, `tools/list` and `tools/call` with JSON
-responses — enough for Fabric and for the probe. A service already on an MCP SDK keeps
+`McpToolServer` answers `initialize` and `ping` (clients such as Claude Code 2.1.285 still
+open with a handshake, and a server that refuses it is marked failed), `server/discover`,
+`tools/list` and `tools/call` with JSON responses. Every tool's `outputSchema` must be
+rooted at `type: object` (DEC-0018): `add_tool` refuses any other root, because a client may
+drop the whole tool list over one bad schema — an SDK-level test will not show it, so check
+with the real client (below). A service already on an MCP SDK keeps
 the SDK and uses only the helpers. The Node kit has the helpers and the same job file
 format, without the dispatcher. `scripts/sample_service.py` is the worked example:
 `sample.echo` answers at once, `sample.draft` is a job that stops for a title choice.
 
-Two readings the contract leaves open, and what the kit does meanwhile:
+The contract owner's rulings the kit follows: a job tool's `outputSchema` is the
+self-contained `{type: object, oneOf: [result envelope, job handle]}` (`job_tool_output_schema`,
+DEC-0017 amended by DEC-0018), so its `structuredContent` always conforms; an event about
+untraced work carries no trace pair.
 
-- a job tool serves the capability's `outputSchema` although its `structuredContent` is
-  the handle (contract OQ-0006);
-- events that belong to no traced work carry no trace pair (contract OQ-0007).
+**Check with a real client**, never only an SDK: `FABRIC_REAL_CLIENT=1 python3 -m unittest
+test.test_real_client` in the adapter repository, or by hand — a throwaway directory, a
+temporary `--mcp-config` (mode 600, the token in a header) and `--strict-mcp-config`, so
+the operator's own configuration is not touched:
+
+```bash
+claude -p "Reply with the single word OK." --strict-mcp-config --mcp-config "$TMP/mcp.json" \
+  --output-format stream-json --verbose --max-turns 1
+```
+
+The first `system/init` event lists `mcp_servers` (`connected`) and the `mcp__<server>__*` tools.
 
 ## What the probe checks
 
@@ -66,9 +83,10 @@ Two readings the contract leaves open, and what the kit does meanwhile:
 
 | Rule | PASS when | NOT_RUN when |
 |---|---|---|
+| `interop.output-schema-object` | every listed tool's `outputSchema`, when present, has root `type: object` (FAC-SEM-023) | no MCP surface |
 | `interop.manifest-link` | the manifest `fabricManifest` names carries the service key with this `<id>.<instance>` (G-07) | the descriptor names no manifest |
 | `interop.well-known-capabilities` | every name in `surfaces.mcp.capabilities` is a manifest capability | the surface lists none |
-| `interop.tools-match` | every `mcp` capability is served as its tool, schemas equal to the files beside the manifest (matched by `$id`), annotations derived | no manifest, no MCP surface, or a schema is not beside the manifest |
+| `interop.tools-match` | every `mcp` capability is served as its tool, schemas equal to the files beside the manifest (matched by `$id`; a job's output wrapped in the DEC-0017 union), annotations derived | no manifest, no MCP surface, or a schema is not beside the manifest |
 | `interop.job-tools` | a `job: true` capability comes with `fabric.job.get` and `fabric.job.cancel` | no capability is a job |
 | `interop.unknown-job` | `fabric.job.get` for a made-up id answers `isError` with `unknown-job` | `fabric.job.get` is not served |
 | `interop.trace-propagation` | the answer's `_meta.traceparent` has the probe's trace id and a new span | the answer carries no traceparent |

package/payload/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 `a22dea359ba04b8fe549abe81a5131552cb90eff`
+Pinned to `fabric-agent-contract` commit `2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f`
 (`docs/specification/service.md`, DEC-0015). The contract's schemas are normative;
 this page is the working summary. Extension key:
 `https://fabric.passioncode.ai/agent-contract/extensions/service/0.1`.

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

@@ -287,7 +287,7 @@ class Probe:
             self.add("interop.well-known-capabilities", "FAIL" if extra else "PASS",
                      ("listed but not in the manifest: " + ", ".join(extra)) if extra else "%d listed, all in the manifest" % len(listed))
         if not mcp_surface or not self.token:
-            for rule in ("interop.tools-match", "interop.job-tools", "interop.unknown-job", "interop.trace-propagation"):
+            for rule in ("interop.output-schema-object", "interop.tools-match", "interop.job-tools", "interop.unknown-job", "interop.trace-propagation"):
                 self.add(rule, "NOT_RUN", "no MCP surface" if not mcp_surface else "no readable token")
         else:
             try:
@@ -298,12 +298,21 @@ class Probe:
             if listing is not None:
                 sent = self.sent_traceparent
                 tools = {t.get("name"): t for t in (listing.get("result") or {}).get("tools", []) if isinstance(t, dict)}
+                self.object_root_rule(tools)
                 self.tools_match_rule(capabilities, manifest_path, tools)
                 self.job_tools_rule(capabilities, tools)
                 self.unknown_job_rule(list(tools))
                 self.trace_rule(listing, sent)
         self.events_trace_rule(self.events)
 
+    def object_root_rule(self, tools: Dict[str, Any]) -> None:
+        """FAC-SEM-023 (DEC-0018): every listed tool's outputSchema, when present, has root type object —
+        a client may refuse the whole tools/list otherwise, whatever the SDK in the tests accepted."""
+        bad = sorted(n for n, t in tools.items() if "outputSchema" in t and (t.get("outputSchema") or {}).get("type") != "object")
+        with_schema = sum(1 for t in tools.values() if "outputSchema" in t)
+        self.add("interop.output-schema-object", "FAIL" if bad else "PASS",
+                 ("outputSchema root is not type object: " + ", ".join(bad)) if bad else "%d outputSchemas, every root type object" % with_schema)
+
     def tools_match_rule(self, capabilities: List[Dict[str, Any]], manifest_path: Optional[Path], tools: Dict[str, Any]) -> None:
         """FAC-SEM-017: each mcp capability is served as the tool of its name, with its schemas and derived annotations."""
         served = [c for c in capabilities if (c.get("profile") or {}).get("kind") == "mcp"]
@@ -321,6 +330,9 @@ class Probe:
                 schema = self.resolve_schema(manifest_path, str(cap.get(side)))
                 if schema is None:
                     unresolved.append("%s %s" % (name, cap.get(side)))
+                elif side == "outputSchema" and fi.is_job_capability(cap):
+                    if tool.get(side) != fi.job_tool_output_schema(schema):
+                        problems.append("%s is a job: its outputSchema must be oneOf[result envelope, job handle] around %s (DEC-0017)" % (name, cap.get(side)))
                 elif tool.get(side) != schema:
                     problems.append("%s serves an %s that differs from %s" % (name, side, cap.get(side)))
             annotations = tool.get("annotations") or {}

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

@@ -2,7 +2,7 @@
 // The Node twin of fabric_interop.py: the same rules and the same job file format, so a
 // job written by one kit is read by the other. The minimal MCP dispatcher is Python-only;
 // a Node service uses the official MCP SDK for the wire and these helpers for the rules.
-// Normative source: fabric-agent-contract docs/specification/interop.md (DEC-0016).
+// Normative source: fabric-agent-contract docs/specification/interop.md (DEC-0016, rulings DEC-0017).
 // #region interop-kit-node — docs: plugins/fabric-agent-adapter/skills/building-fabric-services/references/interop.md#the-kit
 
 import crypto from 'node:crypto';
@@ -14,6 +14,15 @@ export const PROTOCOL = 'fabric-interop/0.1';
 export const EXTENSION_KEY = 'https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1';
 export const MCP_REVISION = '2026-07-28';
 export const TERMINAL = ['completed', 'failed', 'cancelled'];
+export const CONTRACT_VERSION = '0.1.0';
+const OUTCOMES = ['succeeded', 'partial', 'failed', 'cancelled', 'blocked'];
+const ENVELOPE_REQUIRED = ['id', 'contractVersion', 'outcome', 'done', 'proof', 'scope', 'notVerified', 'artifacts', 'createdAt', 'producer', 'output', 'usage'];
+// The job handle inline, as a job tool's outputSchema carries it (contract interop-job-handle.schema.json).
+export const JOB_HANDLE_SCHEMA = {
+  type: 'object', required: ['job'], additionalProperties: false,
+  properties: { job: { type: 'object', required: ['id', 'status'], additionalProperties: false,
+    properties: { id: { type: 'string', minLength: 1, maxLength: 128, pattern: '^[A-Za-z0-9._:-]+$' }, status: { const: 'working' } } } },
+};
 
 const TRACEPARENT = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
 const JOB_ID = /^[A-Za-z0-9._:-]{1,128}$/;
@@ -56,9 +65,20 @@ export function expectedAnnotations(effect, idempotency) {
   return hints;
 }
 
-// A job-capable tool still serves the capability's outputSchema (contract OQ-0006).
+// DEC-0017: a job-backed tool serves oneOf[result envelope, job handle]; the manifest keeps the pure output schema.
+export const jobToolOutputSchema = (outputSchema) => ({ type: 'object', oneOf: [{ type: 'object', required: [...ENVELOPE_REQUIRED], properties: { output: outputSchema } }, JOB_HANDLE_SCHEMA] });
+export const isJobCapability = (capability) => capability.job === true || capability.extensions?.[EXTENSION_KEY]?.job === true;
+
+// DEC-0018 (FAC-SEM-023): an outputSchema is rooted at type object; a client may reject the whole
+// tools/list when one tool's outputSchema is, say, a bare oneOf.
+export function requireObjectRoot(name, outputSchema) {
+  if (!outputSchema || typeof outputSchema !== 'object' || outputSchema.type !== 'object') throw new InteropError(`Tool ${name}: an outputSchema must have root type "object".`);
+}
+
 export function toolForCapability(capability, inputSchema, outputSchema, title) {
-  const tool = { name: capability.name, inputSchema, outputSchema, annotations: expectedAnnotations(capability.effect, capability.idempotency) };
+  requireObjectRoot(capability.name, outputSchema);
+  const served = isJobCapability(capability) ? jobToolOutputSchema(outputSchema) : outputSchema;
+  const tool = { name: capability.name, inputSchema, outputSchema: served, annotations: expectedAnnotations(capability.effect, capability.idempotency) };
   if (capability.description) tool.description = capability.description;
   if (title) tool.title = title;
   return tool;
@@ -85,12 +105,21 @@ function checkUsage(usage) {
   return { ...usage };
 }
 
-export function resultEnvelope({ done, proof, scope, notVerified, output, usage }) {
-  for (const [label, value] of [['done', done], ['proof', proof], ['notVerified', notVerified]]) {
+// The full result envelope (contract result.schema.json, DEC-0017): the shape a synchronous call returns.
+export function resultEnvelope({ outcome, done, proof, scope, notVerified, output, usage, producer, artifacts = [], traceparent, id, createdAt }) {
+  if (!OUTCOMES.includes(outcome)) throw new InteropError(`outcome must be one of ${OUTCOMES.join(', ')}.`);
+  for (const [label, value] of [['done', done], ['proof', proof], ['notVerified', notVerified], ['artifacts', artifacts]]) {
     if (!Array.isArray(value)) throw new InteropError(`${label} must be a list, even when empty.`);
   }
-  if (!scope || typeof scope !== 'object') throw new InteropError('scope must be an object.');
-  return { done: [...done], proof: [...proof], scope: { ...scope }, notVerified: [...notVerified], output, usage: checkUsage(usage) };
+  if (outcome === 'succeeded' && notVerified.length) throw new InteropError('A succeeded result cannot keep unverified claims (FAC-SEM-001); report partial.');
+  if (!scope || typeof scope !== 'object' || !producer || typeof producer !== 'object') throw new InteropError('scope and producer must be objects.');
+  const envelope = {
+    id: id ?? `urn:fabric:result:${crypto.randomBytes(12).toString('hex')}`, contractVersion: CONTRACT_VERSION, outcome,
+    done: [...done], proof: [...proof], scope: { ...scope }, notVerified: [...notVerified], artifacts: [...artifacts],
+    createdAt: createdAt ?? nowIso(), producer: { ...producer }, output, usage: checkUsage(usage),
+  };
+  if (parseTraceparent(traceparent)) envelope.trace = { traceparent };
+  return envelope;
 }
 
 // --- C3.3 awaiting a choice ------------------------------------------------------------------
@@ -176,10 +205,15 @@ export class JobStore {
     return matched;
   }
 
+  // The envelope carries the job's trace, authoritative for the stored result (DEC-0017, FAC-SEM-022).
   complete(jobId, envelope) {
-    const needed = ['done', 'proof', 'scope', 'notVerified', 'output', 'usage'];
-    if (!envelope || !needed.every((k) => k in envelope)) throw new InteropError('A completed job carries the full result envelope; build it with resultEnvelope.');
-    return this.transition(jobId, 'completed', { result: envelope });
+    if (!envelope || !ENVELOPE_REQUIRED.every((k) => k in envelope)) throw new InteropError('A completed job carries the full result envelope; build it with resultEnvelope.');
+    const stored = this.traceparent(jobId);
+    const given = envelope.trace?.traceparent;
+    const ids = (v) => { const p = parseTraceparent(v); return p ? `${p.traceId}-${p.spanId}` : null; };
+    if (stored && given && ids(given) !== ids(stored)) throw new InteropError(`Job ${jobId} ran in span ${stored}; its result names another trace.`);
+    const result = stored && !given ? { ...envelope, trace: { traceparent: stored } } : envelope;
+    return this.transition(jobId, 'completed', { result });
   }
 
   fail(jobId, code, message) { return this.transition(jobId, 'failed', { error: { code, message } }); }

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

@@ -10,7 +10,7 @@ it, so a service that calls these functions inherits the rule:
 - C3.3 a question for a person is an elicitation (form mode, never a secret; URL mode for those);
 - C3.4 every answer is a child span of the caller's traceparent, and so is every event.
 
-Normative source: fabric-agent-contract docs/specification/interop.md (DEC-0016).
+Normative source: fabric-agent-contract docs/specification/interop.md (DEC-0016, rulings DEC-0017).
 """
 
 # #region interop-kit — docs: plugins/fabric-agent-adapter/skills/building-fabric-services/references/interop.md#the-kit
@@ -30,7 +30,22 @@ import fabric_service as _fs  # noqa: E402
 PROTOCOL = "fabric-interop/0.1"
 EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/interop/0.1"
 MCP_REVISION = "2026-07-28"
+# Revisions a client may name in `initialize`. MCP 2026-07-28 needs no handshake, but clients
+# built on earlier revisions (Claude Code 2.1.285 among them) still open with one, and a server
+# that refuses it is marked failed before tools/list is ever called.
+HANDSHAKE_REVISIONS = ("2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28")
+CONTRACT_VERSION = "0.1.0"
 JOB_STATES = ("working", "input_required", "completed", "failed", "cancelled")
+OUTCOMES = ("succeeded", "partial", "failed", "cancelled", "blocked")
+ENVELOPE_REQUIRED = ["id", "contractVersion", "outcome", "done", "proof", "scope", "notVerified", "artifacts",
+                     "createdAt", "producer", "output", "usage"]
+# The job handle inline, as a job tool's outputSchema carries it (contract interop-job-handle.schema.json).
+JOB_HANDLE_SCHEMA: Dict[str, Any] = {
+    "type": "object", "required": ["job"], "additionalProperties": False,
+    "properties": {"job": {"type": "object", "required": ["id", "status"], "additionalProperties": False,
+                           "properties": {"id": {"type": "string", "minLength": 1, "maxLength": 128, "pattern": "^[A-Za-z0-9._:-]+$"},
+                                          "status": {"const": "working"}}}},
+}
 TERMINAL = ("completed", "failed", "cancelled")
 
 _TRACEPARENT = re.compile(r"^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$")
@@ -98,16 +113,35 @@ def expected_annotations(effect: str, idempotency: str) -> Dict[str, bool]:
     return hints
 
 
+def job_tool_output_schema(output_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """DEC-0017: a job-backed tool's outputSchema is oneOf[result envelope, job handle], self-contained,
+    so structuredContent always conforms; the manifest's capability keeps the pure output schema."""
+    return {"type": "object",
+            "oneOf": [{"type": "object", "required": list(ENVELOPE_REQUIRED), "properties": {"output": output_schema}},
+                      JOB_HANDLE_SCHEMA]}
+
+
+def require_object_root(name: str, output_schema: Any) -> None:
+    """DEC-0018 (FAC-SEM-023): an outputSchema is rooted at type object. MCP requires it, and a client
+    may reject the WHOLE tools/list when one tool's outputSchema is, say, a bare oneOf."""
+    if not isinstance(output_schema, dict) or output_schema.get("type") != "object":
+        raise InteropError("Tool %s: an outputSchema must have root type \"object\"." % name)
+
+
+def is_job_capability(capability: Dict[str, Any]) -> bool:
+    block = (capability.get("extensions") or {}).get(EXTENSION_KEY) or {}
+    return capability.get("job") is True or block.get("job") is True
+
+
 def tool_for_capability(capability: Dict[str, Any], input_schema: Dict[str, Any], output_schema: Dict[str, Any],
                         title: Optional[str] = None) -> Dict[str, Any]:
-    """The MCP tool for one manifest capability: its name, its two schemas as they are, derived annotations.
-
-    A job-capable tool still serves the capability's outputSchema, though its
-    structuredContent is the job handle (contract OQ-0006)."""
+    """The MCP tool for one manifest capability: its name, its input schema as it is, derived annotations,
+    and its output schema — wrapped in the job union when the capability is a job (DEC-0017)."""
+    require_object_root(capability["name"], output_schema)
     tool: Dict[str, Any] = {
         "name": capability["name"],
         "inputSchema": input_schema,
-        "outputSchema": output_schema,
+        "outputSchema": job_tool_output_schema(output_schema) if is_job_capability(capability) else output_schema,
         "annotations": expected_annotations(capability.get("effect", ""), capability.get("idempotency", "")),
     }
     if capability.get("description"):
@@ -153,16 +187,30 @@ def _usage(usage: Any) -> Dict[str, Any]:
     return dict(usage)
 
 
-def result_envelope(*, done: List[Dict[str, Any]], proof: List[Dict[str, Any]], scope: Dict[str, Any],
-                    not_verified: List[Dict[str, Any]], output: Any, usage: Dict[str, Any]) -> Dict[str, Any]:
-    """DONE / PROOF / SCOPE / NOT VERIFIED (DEC-0011) plus the output and usage; the four collections are always present."""
-    for label, value in (("done", done), ("proof", proof), ("notVerified", not_verified)):
+def result_envelope(*, outcome: str, done: List[Dict[str, Any]], proof: List[Dict[str, Any]], scope: Dict[str, Any],
+                    not_verified: List[Dict[str, Any]], output: Any, usage: Dict[str, Any], producer: Dict[str, Any],
+                    artifacts: Optional[List[Dict[str, Any]]] = None, traceparent: Optional[str] = None,
+                    result_id: Optional[str] = None, created_at: Optional[str] = None) -> Dict[str, Any]:
+    """The full result envelope (contract result.schema.json, DEC-0011, DEC-0017): the same shape a
+    synchronous call returns, with output, usage and — when the work was traced — its trace."""
+    if outcome not in OUTCOMES:
+        raise InteropError("outcome must be one of %s." % ", ".join(OUTCOMES))
+    for label, value in (("done", done), ("proof", proof), ("notVerified", not_verified), ("artifacts", artifacts or [])):
         if not isinstance(value, list):
             raise InteropError("%s must be a list, even when empty." % label)
-    if not isinstance(scope, dict):
-        raise InteropError("scope must be an object.")
-    return {"done": list(done), "proof": list(proof), "scope": dict(scope), "notVerified": list(not_verified),
-            "output": output, "usage": _usage(usage)}
+    if outcome == "succeeded" and not_verified:
+        raise InteropError("A succeeded result cannot keep unverified claims (FAC-SEM-001); report partial.")
+    if not isinstance(scope, dict) or not isinstance(producer, dict):
+        raise InteropError("scope and producer must be objects.")
+    envelope: Dict[str, Any] = {
+        "id": result_id or "urn:fabric:result:" + secrets.token_hex(12), "contractVersion": CONTRACT_VERSION,
+        "outcome": outcome, "done": list(done), "proof": list(proof), "scope": dict(scope),
+        "notVerified": list(not_verified), "artifacts": list(artifacts or []), "createdAt": created_at or _fs.now_iso(),
+        "producer": dict(producer), "output": output, "usage": _usage(usage),
+    }
+    if parse_traceparent(traceparent):
+        envelope["trace"] = {"traceparent": traceparent}
+    return envelope
 
 
 # --- C3.3 awaiting a choice ------------------------------------------------------------
@@ -287,8 +335,17 @@ class JobStore:
         return matched
 
     def complete(self, job_id: str, envelope: Dict[str, Any]) -> Dict[str, Any]:
-        if not isinstance(envelope, dict) or not {"done", "proof", "scope", "notVerified", "output", "usage"} <= set(envelope):
+        """The envelope carries the job's trace, authoritative for the stored result (DEC-0017); one that names
+        another span is refused, so fabric.job.get's _meta and the envelope always agree (FAC-SEM-022)."""
+        if not isinstance(envelope, dict) or not set(ENVELOPE_REQUIRED) <= set(envelope):
             raise InteropError("A completed job carries the full result envelope; build it with result_envelope.")
+        stored = self.traceparent(job_id)
+        given = (envelope.get("trace") or {}).get("traceparent")
+        ids = lambda value: ((parse_traceparent(value) or {}).get("trace_id"), (parse_traceparent(value) or {}).get("span_id"))
+        if stored and given and ids(given) != ids(stored):
+            raise InteropError("Job %s ran in span %s; its result names another trace." % (job_id, stored))
+        if stored and not given:
+            envelope = dict(envelope, trace={"traceparent": stored})
         return self._transition(job_id, "completed", result=envelope)
 
     def fail(self, job_id: str, code: Any, message: str) -> Dict[str, Any]:
@@ -347,6 +404,8 @@ class McpToolServer:
     def add_tool(self, tool: Dict[str, Any], handler: Handler) -> None:
         if tool["name"] in self.handlers:
             raise InteropError("Tool %s is served twice." % tool["name"])
+        if "outputSchema" in tool:
+            require_object_root(tool["name"], tool["outputSchema"])
         self.tools.append(tool)
         self.handlers[tool["name"]] = handler
 
@@ -379,6 +438,13 @@ class McpToolServer:
         meta = params.get("_meta") or {}
         span = child_traceparent(meta.get("traceparent"))
         method = message["method"]
+        if method == "initialize":
+            asked = params.get("protocolVersion")
+            return {"jsonrpc": "2.0", "id": rid, "result": {
+                "protocolVersion": asked if asked in HANDSHAKE_REVISIONS else MCP_REVISION,
+                "capabilities": {"tools": {"listChanged": False}}, "serverInfo": self.info}}
+        if method == "ping":
+            return {"jsonrpc": "2.0", "id": rid, "result": {}}
         if method == "server/discover":
             return {"jsonrpc": "2.0", "id": rid, "result": {"resultType": "complete", "capabilities": {"tools": {}},
                                                              "serverInfo": self.info, "_meta": {"traceparent": span}}}
@@ -404,6 +470,8 @@ class McpToolServer:
         job_id = str(arguments.get("id", ""))
         try:
             job_span = self.jobs.traceparent(job_id) or span
+            state = self.jobs.get(job_id)
+            job_span = ((state.get("result") or {}).get("trace") or {}).get("traceparent") or job_span
             if name == "fabric.job.cancel":
                 state = self.jobs.get(job_id)
                 if state["status"] not in TERMINAL:

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

@@ -110,6 +110,8 @@ class Service:
         title = "About %s" % topic if choice == "plain" else "What is %s?" % topic
         body = "%s. This sample note was written by the sample service." % title
         self.jobs.complete(job_id, fi.result_envelope(
+            outcome="partial", traceparent=ctx.traceparent,
+            producer={"id": "urn:fabric:provider:%s" % self.id, "revision": 1, "contentHash": "sha256:" + "0" * 64},
             done=[{"claimId": "NOTE", "statement": "A note titled %s was drafted." % title}], proof=[],
             scope={"project": "urn:fabric:project:sample", "run": "urn:fabric:run:%s" % job_id, "node": "urn:fabric:node:draft",
                    "binding": {"id": "urn:fabric:binding:sample.draft", "revision": 1, "contentHash": "sha256:" + "0" * 64}, "writeScopes": []},
@@ -185,6 +187,9 @@ def make_handler(svc: Service):
                 except fs.ServiceError as exc:
                     return self._send(400, {"error": str(exc)})
                 return self._send(200, page)
+            if url.path == "/mcp":
+                # No server-to-client stream here: Streamable HTTP says 405 for a GET.
+                return self._send(405, {"error": "POST JSON-RPC to /mcp."}, {"Allow": "POST"})
             if url.path == "/fabric/v1/login":
                 cookie = svc.codes.redeem((query.get("code") or [None])[0])
                 if not cookie:

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

@@ -5,9 +5,9 @@ license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned private fabric-agent-contract checkout. 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.5.0"
+  version: "0.5.2"
   contract-version: "0.1.0"
-  contract-commit: "a22dea359ba04b8fe549abe81a5131552cb90eff"
+  contract-commit: "2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f"
 ---
 
 # Creating Fabric-compatible agents
@@ -93,7 +93,7 @@ python3 <plugin-dir>/skills/adapting-projects-to-fabric/scripts/adapt_project.py
   --schema-base <immutable-base-uri>
 ```
 
-Pin exactly contract `0.1.0` at commit `a22dea359ba04b8fe549abe81a5131552cb90eff` and
+Pin exactly contract `0.1.0` at commit `2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f` 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

package/payload/plugins/passioncode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "passioncode",
   "displayName": "PassionCode.ai",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "The organisation's working rules for every contributor's agent (working-in-passioncode), and a once-a-day check at session start that keeps the PassionCode.ai skill set current.",
   "author": {
     "name": "PassionCode.ai",