@passioncode-ai/fabric-agent-adapter 0.5.1 → 0.5.3

package/README.md

@@ -6,20 +6,18 @@
 
 # Fabric Agent Adapter
 
-> **PassionCode.ai — The agent-agnostic operating system for AI-native teams.**
-
-**From vibe coding to passion coding.** PassionCode.ai moves the control point from
-managing agents one by one to operating Projects. Fabric Agent Adapter is the portable
-on-ramp: it helps an existing repository become a compatible, replaceable Provider
-without moving the Project onto one proprietary agent runtime.
+**Fabric Agent Adapter** makes any agent Fabric-compatible. Fabric is PassionCode.ai's
+product, the CEO AI agent: you talk to Fabric, and it chooses, binds and runs the agents that
+do the work. This adapter is how an agent becomes one Fabric can bind — three Agent Skills,
+Python and Node reference kits and a live conformance probe for the
+[Fabric Agent Contract](https://github.com/passioncode-ai/fabric-agent-contract). It also works
+on its own: the skills, kits and probe need no Fabric install.
 
 [![npm](https://img.shields.io/npm/v/%40passioncode-ai%2Ffabric-agent-adapter)](https://www.npmjs.com/package/@passioncode-ai/fabric-agent-adapter)
 [![validate](https://github.com/passioncode-ai/fabric-agent-adapter/actions/workflows/validate.yml/badge.svg)](https://github.com/passioncode-ai/fabric-agent-adapter/actions/workflows/validate.yml)
-[![license](https://img.shields.io/badge/license-source--available-blue.svg)](LICENSE)
+[![license](https://img.shields.io/badge/license-AGPL--3.0%20or%20commercial-blue.svg)](LICENSE)
 
-Portable Agent Skills that make any agent Fabric-compatible, for the
-[Fabric Agent Contract](https://github.com/passioncode-ai/fabric-agent-contract):
-`adapting-projects-to-fabric`, `creating-fabric-agents` and
+The skills are `adapting-projects-to-fabric`, `creating-fabric-agents` and
 `building-fabric-services`.
 
 `building-fabric-services` makes an agent a long-lived local service with a dashboard
@@ -52,17 +50,26 @@ For provider bundles the adapting skill helps an agent author:
 The skill never treats generated files as admission. Fabric contract `0.1.0` does not
 yet ship the host registry/runtime needed to connect and authorize a live provider.
 
-## Install
+## Quick start for a new teammate
 
-The repository and the npm package are public; neither path needs an account.
+### Install
 
-npm — no GitHub access required:
+With the [PassionCode.ai launcher](https://github.com/passioncode-ai/passioncode) the adapter
+comes with every other PassionCode.ai skill — `npx @passioncode-ai/passioncode@latest update`,
+then restart your agents. Alone, without any account:
 
 ```bash
 npx @passioncode-ai/fabric-agent-adapter        # installs every skill into the agents hub ~/.agents/skills
 npx @passioncode-ai/fabric-agent-adapter --prune-shadow   # remove ~/.claude/skills copies that shadow the plugin
 ```
 
+Claude Code plugin marketplace:
+
+```text
+/plugin marketplace add passioncode-ai/fabric-agent-adapter
+/plugin install fabric-agent-adapter@fabric-agent-adapter
+```
+
 Generic Agent Skills clients:
 
 ```bash
@@ -71,13 +78,62 @@ npx skills add passioncode-ai/fabric-agent-adapter --skill creating-fabric-agent
 npx skills add passioncode-ai/fabric-agent-adapter --skill building-fabric-services
 ```
 
-Claude Code plugin marketplace:
+### Configure
 
-```text
-/plugin marketplace add passioncode-ai/fabric-agent-adapter
-/plugin install fabric-agent-adapter@fabric-agent-adapter
+Nothing: no account, no key, no environment variable. A service built with the kit creates
+its own token file (mode 600) in its data directory.
+
+### MCP
+
+The adapter is not an MCP server; it builds them. Its sample service serves every capability
+as the MCP tool of its name (`fabric-interop/0.1`), so the proof is a real client calling one.
+With Python 3.9+ and the Claude Code CLI, in a throwaway directory and a temporary MCP config
+(your own Claude Code configuration is not read or written):
+
+```bash
+KIT=plugins/fabric-agent-adapter/skills/building-fabric-services/scripts   # or ~/.agents/skills/building-fabric-services/scripts
+DATA=$(mktemp -d); SERVICES=$(mktemp -d); WORK=$(mktemp -d)
+python3 "$KIT/sample_service.py" serve --port 47190 --data-dir "$DATA" &
+python3 "$KIT/sample_service.py" register --port 47190 --data-dir "$DATA" --services-dir "$SERVICES"
+python3 "$KIT/check_service.py" sample --services-dir "$SERVICES"   # exit 0: no FAIL
+# Register the service for one client run; the token goes in a header, never in argv.
+python3 - "$DATA/service.token" "$WORK/mcp.json" <<'EOF'
+import json, os, sys
+token = open(sys.argv[1]).read().strip()
+with os.fdopen(os.open(sys.argv[2], os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "w") as f:
+    json.dump({"mcpServers": {"sample": {"type": "http", "url": "http://127.0.0.1:47190/mcp",
+               "headers": {"Authorization": "Bearer " + token}}}}, f)
+EOF
+(cd "$WORK" && claude -p "Call the tool mcp__sample__sample_echo with text 'ping' and reply with only the text it returns." \
+  --strict-mcp-config --mcp-config "$WORK/mcp.json" --allowedTools mcp__sample__sample_echo --max-turns 3 < /dev/null)
+# -> ping
+kill %1
+```
+
+Verified 2026-09-30 with Claude Code 2.1.285: the CLI connected to the sample over
+streamable HTTP, called `sample.echo` and printed `ping`. The probe prints one line per rule —
+`PASS`, `FAIL` or `NOT_RUN` with its evidence — and exits 1 on any `FAIL`; run it against your
+own service by its id once its installer has written the descriptor.
+`FABRIC_REAL_CLIENT=1 python3 -m unittest discover -s test -p test_real_client.py` repeats the connection check
+(every sample tool listed, no model call) in the test suite.
+
+### Develop
+
+There is no build step and no dependency beyond Python 3.9+ and Node.js:
+
+```bash
+npm test                     # validate.py, the Python unit tests, the Node kit tests
+python3 -m unittest discover -s test -v
+python3 test/validate.py
+claude plugin validate ./plugins/fabric-agent-adapter --strict
+claude plugin validate . --strict
 ```
 
+`test/validate.py` reads every SKILL.md front matter as strictly as a YAML parser does; an
+unquoted value holding `: ` fails it. `python3 test/validate.py --frontmatter <SKILL.md ...>`
+checks copies installed elsewhere, such as `~/.agents/skills/*/SKILL.md`. Start in
+[AGENTS.md](AGENTS.md); contributions follow [CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## Use
 
 Ask the agent explicitly:
@@ -118,42 +174,12 @@ python3 "$SKILL_DIR/scripts/adapt_project.py" check /path/to/project \
 Scaffolding is non-destructive by default. It writes only the paths declared in the
 [delivery brief](docs/evidence/specs/2026-08-27-brief.md) and refuses collisions.
 
-## Verify one service (newcomer path)
-
-After installing (above), with Python 3.9+ and no other dependency:
-
-```bash
-KIT=plugins/fabric-agent-adapter/skills/building-fabric-services/scripts   # or ~/.agents/skills/building-fabric-services/scripts
-DATA=$(mktemp -d); SERVICES=$(mktemp -d)
-python3 "$KIT/sample_service.py" serve --port 47190 --data-dir "$DATA" &
-python3 "$KIT/sample_service.py" register --port 47190 --data-dir "$DATA" --services-dir "$SERVICES"
-python3 "$KIT/check_service.py" sample --services-dir "$SERVICES"   # exit 0: no FAIL
-kill %1
-```
-
-The probe prints one line per rule — `PASS`, `FAIL` or `NOT_RUN` with its evidence — and
-exits 1 on any `FAIL`. Run it against your own service by its id once its installer has
-written the descriptor.
-
-## Validate this repository
-
-```bash
-python3 -m unittest discover -s test -v
-python3 test/validate.py
-claude plugin validate ./plugins/fabric-agent-adapter --strict
-claude plugin validate . --strict
-```
-
-`test/validate.py` reads every SKILL.md front matter as strictly as a YAML parser does; an
-unquoted value holding `: ` fails it. `python3 test/validate.py --frontmatter <SKILL.md ...>`
-checks copies installed elsewhere, such as `~/.agents/skills/*/SKILL.md`.
-
 ## Contract pin
 
 The one pin is [`fabric-contract.lock.json`](fabric-contract.lock.json):
 
 - version: `0.1.0`
-- commit: `9cd778eb6f14b977f9a5b4930826f62dc95c5619`
+- commit: `2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f`
 
 Every other mention of the contract revision — this section, the skills' metadata, the
 skill card, `adapt_project.py` — must equal it; `python3 test/validate.py` fails a tree
@@ -162,9 +188,8 @@ new adapter release, fixture review, and a complete validation run.
 
 ## License
 
-Source-available under PolyForm Noncommercial or Internal Use; commercial license on
-request (contact@passioncode.ai). SPDX:
-`PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0` — see
-[LICENSE](LICENSE). Versions up to and including v0.4.2 (on GitHub and on npm) were
-released under the MIT License and remain available under it. Contributions are accepted under
-[CLA.md](CLA.md) ([CONTRIBUTING.md](CONTRIBUTING.md)).
+Open source under the [GNU AGPL-3.0](LICENSE). A [commercial license](COMMERCIAL-LICENSE.md) is
+available for use that does not meet the AGPL's terms — contact@passioncode.ai.
+Versions before 0.5.3 were released under PolyForm Noncommercial or Internal Use (v0.4.3 to
+v0.5.2) and MIT (v0.4.2 and earlier); each keeps the licence it was released under.
+Contributions are accepted under [CLA.md](CLA.md) ([CONTRIBUTING.md](CONTRIBUTING.md)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/fabric-agent-adapter",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "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'"
@@ -16,6 +16,8 @@
     "plugins",
     "README.md",
     "LICENSE",
+    "COMMERCIAL-LICENSE.md",
+    "CLA.md",
     "CHANGELOG.md",
     "SECURITY.md",
     "!**/__pycache__/**",
@@ -23,7 +25,7 @@
   ],
   "repository": "github:passioncode-ai/fabric-agent-adapter",
   "homepage": "https://github.com/passioncode-ai/fabric-agent-adapter",
-  "license": "PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0",
+  "license": "AGPL-3.0-only OR LicenseRef-PassionCode-Commercial",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

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

@@ -3,14 +3,14 @@
   "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.1",
+  "version": "0.5.3",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"
   },
   "homepage": "https://github.com/passioncode-ai/fabric-agent-adapter",
   "repository": "https://github.com/passioncode-ai/fabric-agent-adapter",
-  "license": "PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0",
+  "license": "AGPL-3.0-only OR LicenseRef-PassionCode-Commercial",
   "keywords": [
     "fabric",
     "agent",

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

@@ -1,13 +1,13 @@
 ---
 name: adapting-projects-to-fabric
 description: Use when adapting an existing agent, MCP server, A2A peer, HTTP service, or terminal CLI to the Fabric Agent Contract—choosing MCP/A2A/local-runner, scaffolding a provider bundle, or checking Fabric compatibility; also for «подключить проект к Fabric» or «сделать агента совместимым с Fabric». NOT for building the Fabric host/orchestrator, configuring an MCP client, or a brand-new agent — that is creating-fabric-agents.
-license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
+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 private fabric-agent-contract checkout. Works without those tools in an explicitly degraded structural-check mode.
 metadata:
   author: PassionCode.ai
-  version: "0.5.1"
+  version: "0.5.3"
   contract-version: "0.1.0"
-  contract-commit: "9cd778eb6f14b977f9a5b4930826f62dc95c5619"
+  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 `9cd778eb6f14b977f9a5b4930826f62dc95c5619`.
+- commit `2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f`.
 
 Read the pinned contract's guide
 `docs/guides/connecting-compatible-agents.md`, the selected profile specification, and
@@ -179,6 +179,27 @@ unverified surfaces. If live Fabric admission/runtime does not yet exist, the la
 remain `NOT VERIFIED`; the completed deliverable is an adaptation-ready provider bundle,
 not a connected provider.
 
+## The repository around the provider
+
+**For a PassionCode.ai repository**, the adapted project's repository follows the organization's
+[repository standard](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/repository-standard.md) (`knowledge/repository-standard.md`
+in the organization's knowledge base; a clone has it at `fabric-workspace/knowledge/`) from its
+first commit:
+
+- `LICENSE`, `COMMERCIAL-LICENSE.md` and `CLA.md` copied byte for byte from the knowledge base's
+  `templates/`, and `AGPL-3.0-only OR LicenseRef-PassionCode-Commercial` in every manifest and
+  every SKILL.md `license:`; `SECURITY.md` when the repository is public;
+- a README whose first heading is the full name, with `## Quick start for a new teammate`
+  (Install; Configure, key names only; MCP, the registration command and one proving tool call,
+  verified with a real client in a temporary config; Develop) and `## License`;
+- an `AGENTS.md` that opens with the template's *Read first* block and closes with *After work*,
+  and a `CLAUDE.md` whose first line is `@AGENTS.md`.
+
+org-index `scripts/check_format.py` reports 0 findings for it before it is called done. **An agent
+someone builds for themselves is not a PassionCode.ai repository:** its licence is its owner's
+choice, nothing about it is published or listed by the organization, and none of these files is
+required of it — though the verified MCP quick start is still how anyone learns to drive it.
+
 ## Completion format
 
 Report:

package/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 = "9cd778eb6f14b977f9a5b4930826f62dc95c5619"
+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/plugins/fabric-agent-adapter/skills/building-fabric-services/SKILL.md

@@ -11,14 +11,14 @@ description: >-
   descriptor, the well-known document, the events feed and notifications; ships Python and Node
   reference kits and a live conformance probe. NOT for a one-off script or cron job, a hosted
   SaaS, the provider manifest itself (adapting-projects-to-fabric), or building Fabric Dashboards.
-license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
+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 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.1"
+  version: "0.5.3"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "9cd778eb6f14b977f9a5b4930826f62dc95c5619"
+  extension-commit: "2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f"
 ---
 
 # Building Fabric services
@@ -209,6 +209,27 @@ Then prove the lock: start a second copy by hand against the same data directory
 must exit 75 while the first keeps serving. Prove recovery: `kill -9` the launchd pid;
 the well-known document must answer again with a new pid within about 15 seconds.
 
+## The repository around the service
+
+**For a PassionCode.ai repository**, the service's repository follows the organization's
+[repository standard](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/repository-standard.md) (`knowledge/repository-standard.md`
+in the organization's knowledge base; a clone has it at `fabric-workspace/knowledge/`) from its
+first commit:
+
+- `LICENSE`, `COMMERCIAL-LICENSE.md` and `CLA.md` copied byte for byte from the knowledge base's
+  `templates/`, and `AGPL-3.0-only OR LicenseRef-PassionCode-Commercial` in every manifest and
+  every SKILL.md `license:`; `SECURITY.md` when the repository is public;
+- a README whose first heading is the full name, with `## Quick start for a new teammate`
+  (Install; Configure, key names only; MCP, the registration command and one proving tool call,
+  verified with a real client in a temporary config; Develop) and `## License`;
+- an `AGENTS.md` that opens with the template's *Read first* block and closes with *After work*,
+  and a `CLAUDE.md` whose first line is `@AGENTS.md`.
+
+org-index `scripts/check_format.py` reports 0 findings for it before it is called done. **An agent
+someone builds for themselves is not a PassionCode.ai repository:** its licence is its owner's
+choice, nothing about it is published or listed by the organization, and none of these files is
+required of it — though the verified MCP quick start is still how anyone learns to drive it.
+
 ## Migrating an existing service
 
 Read [the migration reference](references/migrating-a-service.md) — the order of

package/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, rulings DEC-0017)
+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.
 
@@ -50,15 +50,32 @@ response = server.handle(json_rpc_message)          # POST /mcp body in, JSON re
 - 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.
 
-The contract owner's rulings (DEC-0017) the kit follows: a job tool's `outputSchema` is the
-self-contained union `oneOf[result envelope, job handle]` (`job_tool_output_schema`), so
-its `structuredContent` always conforms; an event about untraced work carries no trace pair.
+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.
+
+**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,6 +83,7 @@ its `structuredContent` always conforms; an event about untraced work carries no
 
 | 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`; 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 |

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 `9cd778eb6f14b977f9a5b4930826f62dc95c5619`
+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/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"]

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

@@ -66,10 +66,17 @@ export function expectedAnnotations(effect, idempotency) {
 }
 
 // DEC-0017: a job-backed tool serves oneOf[result envelope, job handle]; the manifest keeps the pure output schema.
-export const jobToolOutputSchema = (outputSchema) => ({ oneOf: [{ type: 'object', required: [...ENVELOPE_REQUIRED], properties: { output: outputSchema } }, JOB_HANDLE_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) {
+  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;

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

@@ -30,6 +30,10 @@ 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")
@@ -112,10 +116,18 @@ def expected_annotations(effect: str, idempotency: str) -> Dict[str, bool]:
 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 {"oneOf": [{"type": "object", "required": list(ENVELOPE_REQUIRED), "properties": {"output": 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
@@ -125,6 +137,7 @@ def tool_for_capability(capability: Dict[str, Any], input_schema: Dict[str, Any]
                         title: Optional[str] = None) -> Dict[str, Any]:
     """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,
@@ -391,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
 
@@ -423,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}}}

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

@@ -187,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/plugins/fabric-agent-adapter/skills/creating-fabric-agents/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: creating-fabric-agents
 description: Use when designing and building a NEW agent or provider that must be Fabric-compatible from its first commit — «создай агента, совместимого с фабрикой Passion Code», «новый агент под Fabric», "create a fabric-compatible agent", "build a new Fabric provider", "fabric-ready agent from scratch". Runs the intake grill (capability, named consumer, workflow-or-agent, MCP/A2A/local-runner profile, effect declarations), distils source projects into a knowledge pack whose recorded failures become planted eval fixtures, scaffolds the pinned contract bundle, and sets the two-clock eval expectation with the conformance report. NOT for adapting an existing project (use adapting-projects-to-fabric), building the Fabric host or orchestrator, or generic agent design where Fabric compatibility is not part of the request.
-license: PolyForm-Noncommercial-1.0.0 OR LicenseRef-PolyForm-Internal-Use-1.0.0
+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 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.1"
+  version: "0.5.3"
   contract-version: "0.1.0"
-  contract-commit: "9cd778eb6f14b977f9a5b4930826f62dc95c5619"
+  contract-commit: "2ea54f70c161c8b3bf7ec3c567735c7a2d4ce12f"
 ---
 
 # Creating Fabric-compatible agents
@@ -80,6 +80,25 @@ that would show it met, written now, before the implementation. The input corpus
 authored now: it grows from real traces once the provider runs, and the step-1 fixtures
 are its seed because a source project's recorded failures count as production.
 
+**For a PassionCode.ai repository**, the new agent's repository follows the organization's
+[repository standard](https://github.com/passioncode-ai/fabric-workspace/blob/main/knowledge/repository-standard.md) (`knowledge/repository-standard.md`
+in the organization's knowledge base; a clone has it at `fabric-workspace/knowledge/`) from its
+first commit:
+
+- `LICENSE`, `COMMERCIAL-LICENSE.md` and `CLA.md` copied byte for byte from the knowledge base's
+  `templates/`, and `AGPL-3.0-only OR LicenseRef-PassionCode-Commercial` in every manifest and
+  every SKILL.md `license:`; `SECURITY.md` when the repository is public;
+- a README whose first heading is the full name, with `## Quick start for a new teammate`
+  (Install; Configure, key names only; MCP, the registration command and one proving tool call,
+  verified with a real client in a temporary config; Develop) and `## License`;
+- an `AGENTS.md` that opens with the template's *Read first* block and closes with *After work*,
+  and a `CLAUDE.md` whose first line is `@AGENTS.md`.
+
+org-index `scripts/check_format.py` reports 0 findings for it before it is called done. **An agent
+someone builds for themselves is not a PassionCode.ai repository:** its licence is its owner's
+choice, nothing about it is published or listed by the organization, and none of these files is
+required of it — though the verified MCP quick start is still how anyone learns to drive it.
+
 ## Step 3 — scaffold the provider bundle
 
 Reuse the sibling skill's scaffolder against the new skeleton with the profile chosen at
@@ -93,7 +112,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 `9cd778eb6f14b977f9a5b4930826f62dc95c5619` 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