@passioncode-ai/fabric-agent-adapter 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+## 0.3.1 - 2026-08-27
+
+- Fix the executable bit on `bin/fabric-agent-adapter.js` and `install.sh`: the
+  packed tarball shipped them non-executable, so `npx` failed with exit 126.
+  Caught by the release workflow's own packed-tarball smoke — the gate this
+  release added, doing its job on its first run.
+
+## 0.3.0 - 2026-08-27
+
+- Ship the npm channel: the package is `@passioncode-ai/fabric-agent-adapter`,
+  an installer CLI (`bin/fabric-agent-adapter.js`) plus the plugin tree, with
+  `install.sh` as the POSIX fallback.
+- Add toggleable release automation (`release.yml`): a `v*` tag runs validate,
+  checks tag reachability and version sync, cuts the GitHub release from the
+  CHANGELOG section, smoke-tests the packed tarball from a clean cwd (the
+  repository is private, so the tarball — not `npx github:` — is the artifact
+  under test), and publishes to npm with provenance. Armed by RELEASE_ENABLED
+  and PUBLISH_NPMJS repository variables.
+- Extend the validator: package.json joins the version sync, the files
+  whitelist and scoped-access rules are checked, and the new files are required.
+
+## 0.2.0 - 2026-08-27
+
+- Add the `creating-fabric-agents` skill: the intake grill (capability, named
+  consumer, workflow-or-agent, profile, effect and tenancy declarations), the
+  knowledge intake whose recorded traps become planted eval fixtures, skeleton
+  and scaffold reuse of the pinned contract machinery, two-clock evals, and the
+  canary-binding expectation in the conformance report.
+- Point the adapting skill's boundary at its new sibling for greenfield requests.
+- Rework the repository validator for multiple skills with per-skill trigger and
+  scenario evals.
+
+## 0.1.0 - 2026-08-27
+
+- Add the `adapting-projects-to-fabric` skill.
+- Add evidence-based MCP, A2A, and local-runner profile selection.
+- Add a standard-library project inspector, non-destructive scaffolder, and checker.
+- Add contract pinning and independent conformance gate reporting.
+- Add trigger/scenario evals, unit tests, repository validator, and plugin packaging.
+

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 passioncode-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,96 @@
+# Fabric Agent Adapter
+
+[![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-MIT-green.svg)](LICENSE)
+
+Private, portable Agent Skill for adapting an existing agent project to the
+[Fabric Agent Contract](https://github.com/passioncode-ai/fabric-agent-contract).
+
+It helps an agent author:
+
+- inspect the project's stable integration surfaces without executing it;
+- choose A2A `1.0`, MCP `2026-07-28`, or `fabric-local-runner/0.1` per capability;
+- scaffold a version-pinned provider manifest, schemas, safe fixture, probes, and
+  conformance report;
+- distinguish structural validation from live protocol negotiation, semantic
+  admission, and project binding.
+
+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
+
+The repository is private; the npm package is public. The npm path needs no GitHub access — the GitHub paths do.
+
+npm — no GitHub access required:
+
+```bash
+npx @passioncode-ai/fabric-agent-adapter        # installs both skills into ~/.claude/skills
+```
+
+Generic Agent Skills clients:
+
+```bash
+npx skills add passioncode-ai/fabric-agent-adapter --skill adapting-projects-to-fabric
+npx skills add passioncode-ai/fabric-agent-adapter --skill creating-fabric-agents
+```
+
+Claude Code plugin marketplace:
+
+```text
+/plugin marketplace add passioncode-ai/fabric-agent-adapter
+/plugin install fabric-agent-adapter@fabric-agent-adapter
+```
+
+## Use
+
+Ask the agent explicitly:
+
+```text
+Adapt this project for Fabric compatibility. Inspect it, choose the profile per
+capability, scaffold the provider bundle, and report every conformance gate.
+```
+
+Or, for an agent that does not exist yet:
+
+```text
+Create a new fabric-compatible agent for <capability>; its consumer is <who calls it>.
+```
+
+Or run the deterministic helper directly:
+
+```bash
+SKILL_DIR=plugins/fabric-agent-adapter/skills/adapting-projects-to-fabric
+python3 "$SKILL_DIR/scripts/adapt_project.py" inspect /path/to/project --json
+python3 "$SKILL_DIR/scripts/adapt_project.py" scaffold /path/to/project \
+  --profile mcp \
+  --provider-id https://agents.example/providers/demo \
+  --provider-name "Demo provider" \
+  --capability-id https://agents.example/capabilities/demo \
+  --capability-name demo.run \
+  --schema-base https://agents.example/fabric
+python3 "$SKILL_DIR/scripts/adapt_project.py" check /path/to/project \
+  --contract /path/to/fabric-agent-contract --json
+```
+
+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.
+
+## 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
+```
+
+## Contract pin
+
+- version: `0.1.0`
+- commit: `20a818e648a4c09a60df0126d11626922e8b9094`
+
+The contract repository is normative. Updating the pin requires a new adapter release,
+fixture review, and a complete validation run.
+

package/SECURITY.md

@@ -0,0 +1,10 @@
+# Security
+
+Report vulnerabilities privately to the maintainers of the `passioncode-ai`
+organization. Do not open a public issue containing credentials, private provider URLs,
+or customer project data.
+
+The adapter must not write secret values to manifests, fixtures, probes, logs, or command
+arguments. Generated and external provider outputs are untrusted. Live probes must be
+bounded and non-publishing until explicit scoped grants exist in a project binding.
+

package/bin/fabric-agent-adapter.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/*
+ * fabric-agent-adapter installer CLI.
+ *
+ * Installs every skill this plugin ships into ~/.claude/skills/<name>
+ * (same layout as install.sh). Idempotent: an existing install is skipped unless
+ * --force. Zero dependencies.
+ *
+ * For other agents (Cursor, Codex, 70+) use:
+ *   npx skills add passioncode-ai/fabric-agent-adapter   (needs GitHub access —
+ *   the repository is private; the npm package needs none)
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ROOT = path.resolve(__dirname, '..');
+const REPO = 'passioncode-ai/fabric-agent-adapter';
+
+function usage() {
+  console.log(`fabric-agent-adapter installer
+
+Usage:
+  npx @passioncode-ai/fabric-agent-adapter [--force]
+      install every skill this plugin ships into ~/.claude
+      (skip existing unless --force)
+  npx @passioncode-ai/fabric-agent-adapter --help
+
+Other install paths:
+  Claude Code plugin:  /plugin marketplace add ${REPO}
+                       /plugin install fabric-agent-adapter@fabric-agent-adapter
+  Any agent (70+):     npx skills add ${REPO}   (private repo — GitHub auth required)`);
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+function installOne(label, src, dest, force) {
+  if (fs.existsSync(dest) && !force) {
+    console.log(`skip: ${label} already installed at ${dest} (rerun with --force to overwrite)`);
+    return;
+  }
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  copyDir(src, dest);
+  console.log(`Installed ${label} -> ${dest}`);
+}
+
+function main(argv) {
+  const args = argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) {
+    usage();
+    return 0;
+  }
+  const force = args.includes('--force');
+  const unknown = args.filter((a) => a !== '--force');
+  if (unknown.length) {
+    console.error(`unknown argument(s): ${unknown.join(' ')}`);
+    usage();
+    return 2;
+  }
+
+  const skillRoot = path.join(ROOT, 'plugins/fabric-agent-adapter/skills');
+  if (!fs.existsSync(skillRoot)) {
+    console.error(`error: skill sources missing at ${skillRoot} — corrupted package?`);
+    return 1;
+  }
+
+  // Iterate rather than name one skill: a skill added to the plugin must not
+  // require an installer change to reach anybody.
+  const names = fs
+    .readdirSync(skillRoot, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+  if (!names.length) {
+    console.error(`error: no skills found under ${skillRoot} — corrupted package?`);
+    return 1;
+  }
+
+  const home = os.homedir();
+  for (const name of names) {
+    installOne(
+      `${name} skill`,
+      path.join(skillRoot, name),
+      path.join(home, '.claude', 'skills', name),
+      force
+    );
+  }
+  console.log('Restart your agent — skills load at session start.');
+  return 0;
+}
+
+process.exit(main(process.argv));

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@passioncode-ai/fabric-agent-adapter",
+  "version": "0.3.1",
+  "description": "Create new Fabric-compatible agents and adapt existing projects to the Fabric Agent Contract — evidence-backed MCP, A2A, or local-runner provider bundles. This package is the installer CLI.",
+  "scripts": {
+    "test": "python3 test/validate.py && python3 -m unittest discover -s test -q"
+  },
+  "bin": {
+    "fabric-agent-adapter": "bin/fabric-agent-adapter.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "plugins",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "SECURITY.md"
+  ],
+  "repository": "github:passioncode-ai/fabric-agent-adapter",
+  "homepage": "https://github.com/passioncode-ai/fabric-agent-adapter",
+  "license": "MIT",
+  "author": {
+    "name": "passioncode-ai",
+    "url": "https://github.com/passioncode-ai"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "keywords": [
+    "fabric",
+    "agent",
+    "compatibility",
+    "mcp",
+    "a2a",
+    "local-runner",
+    "provider",
+    "conformance",
+    "claude-code",
+    "skill"
+  ]
+}

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

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
+  "name": "fabric-agent-adapter",
+  "displayName": "Fabric Agent Adapter",
+  "description": "Create new Fabric-compatible agents and adapt existing projects to the Fabric Agent Contract through evidence-backed MCP, A2A, or local-runner provider bundles.",
+  "version": "0.3.1",
+  "author": {
+    "name": "passioncode-ai",
+    "url": "https://github.com/passioncode-ai"
+  },
+  "homepage": "https://github.com/passioncode-ai/fabric-agent-adapter",
+  "repository": "https://github.com/passioncode-ai/fabric-agent-adapter",
+  "license": "MIT",
+  "keywords": [
+    "fabric",
+    "agent",
+    "compatibility",
+    "mcp",
+    "a2a",
+    "local-runner",
+    "provider",
+    "conformance"
+  ]
+}
+

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

@@ -0,0 +1,175 @@
+---
+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: MIT
+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.3.1"
+  contract-version: "0.1.0"
+  contract-commit: "20a818e648a4c09a60df0126d11626922e8b9094"
+---
+
+# Adapting projects to Fabric
+
+Turn an existing stable interface into a proposed Fabric provider bundle, then prove
+only the compatibility gates for which receipts exist. The Fabric Agent Contract is
+normative; this skill is an authoring workflow pinned to one immutable revision.
+
+## Boundary
+
+Use this skill to adapt or assess a provider project. Do not use it to:
+
+- design the Fabric host, registry, scheduler, admission service, or project binding runtime;
+- add an MCP server to Claude Code, Codex, or an agent gateway;
+- design a new agent from scratch — that is the sibling skill creating-fabric-agents;
+- claim admission merely because generated files or a valid manifest exist.
+
+If the project has only a browser interface and no stable API, MCP/A2A surface, or CLI,
+stop with that missing prerequisite. Browser automation is not a base Fabric profile.
+
+## Required inputs
+
+Establish these values from the request or target repository:
+
+- project root;
+- the one capability being adapted;
+- stable provider and capability URIs;
+- who owns the task lifecycle;
+- the interface Fabric can actually reach;
+- expected inputs, outputs, effects, data classes, and safe probe behaviour;
+- a public or private immutable base URI for published schemas and fixtures.
+
+Do not ask for all fields before inspecting. Discover safe facts first and ask only
+for decisions that remain material. Never request or copy secret values into the bundle.
+
+## Workflow
+
+### 1. Inspect without execution
+
+Resolve this skill's directory and run:
+
+```bash
+python3 <skill-dir>/scripts/adapt_project.py inspect <project-root> --json
+```
+
+The inspector samples repository files but does not execute the project. Verify its
+evidence manually. Existing runtime documentation and code outrank filename heuristics.
+
+If the inspector returns `undetermined`, answer its lifecycle question before creating
+files. A repository can expose multiple surfaces; choose a profile per capability, not
+per vendor. Load [profile selection](references/profile-selection.md) whenever choosing
+or reviewing a profile.
+
+### 2. Pin the normative contract
+
+Use exactly:
+
+- contract version `0.1.0`;
+- repository `https://github.com/passioncode-ai/fabric-agent-contract`;
+- commit `20a818e648a4c09a60df0126d11626922e8b9094`.
+
+Read the pinned contract's guide
+`docs/guides/connecting-compatible-agents.md`, the selected profile specification, and
+the referenced JSON Schemas before implementing protocol details. If the private checkout
+is unavailable, continue only through local structure and mark exact schema validation
+`NOT_RUN`; do not reconstruct missing normative rules from memory.
+
+### 3. Scaffold the provider bundle
+
+Load [provider bundle](references/provider-bundle.md) before creating or mapping files.
+Then run one explicit profile command:
+
+```bash
+python3 <skill-dir>/scripts/adapt_project.py scaffold <project-root> \
+  --profile mcp \
+  --provider-id https://agents.example/providers/example \
+  --provider-name "Example provider" \
+  --capability-id https://agents.example/capabilities/example \
+  --capability-name example.run \
+  --schema-base https://agents.example/fabric
+```
+
+Valid profiles are `mcp`, `a2a`, and `local-runner`. The helper creates only the locked
+target paths. It refuses any collision. Do not use `--force` unless the user explicitly
+authorizes replacement after the exact conflicting files and diff are shown.
+
+The generated zero hash, `.invalid` endpoints, `replace-me` values, generic schemas, and
+assertions are deliberate blockers. Replace them with implementation-backed facts. A
+template that still contains one is not ready for admission.
+
+### 4. Implement the adapter seam
+
+Preserve the chosen ownership boundary:
+
+- A2A maps the provider's remote task, progress, artifact, cancellation, and terminal
+  states; Fabric does not take over its internal loop.
+- MCP exposes bounded tools/resources/prompts while Fabric owns planning and retries.
+- Local runner maps typed input, executable identity, result location, cancellation,
+  heartbeat, and partial results without relying on ambient accounts.
+
+Keep model selection and provider-internal reasoning outside the Fabric contract. Expose
+typed outcomes, evidence, artifacts, and protocol-visible state—not chain-of-thought.
+Treat all provider output as untrusted until schemas and semantic assertions pass.
+
+### 5. Make probes safe and meaningful
+
+For each capability, create at least one bounded fixture that:
+
+- can run repeatedly;
+- has an explicit timeout;
+- cannot publish, charge, message real recipients, or mutate production;
+- validates the declared output shape;
+- tests a semantic property a fake or wrong implementation would fail;
+- preserves a typed partial/stopped result on timeout or cancellation.
+
+A transport success is not semantic success. Assertions such as “returns JSON” are too
+weak; assert the capability's intended meaning and evidence obligations.
+
+### 6. Run independent checks
+
+First run local structure:
+
+```bash
+python3 <skill-dir>/scripts/adapt_project.py check <project-root> --json
+```
+
+When the exact contract checkout and dependencies are available, run:
+
+```bash
+python3 <skill-dir>/scripts/adapt_project.py check <project-root> \
+  --contract /path/to/fabric-agent-contract --json
+```
+
+Load [verification](references/verification.md) before interpreting or publishing the
+result. Fix every local error. Fix every placeholder warning or record why the bundle is
+still a draft. Do not convert `NOT_RUN` or `NOT_VERIFIED` to `PASS` without the named
+runtime receipt.
+
+### 7. Update the conformance report
+
+Update `fabric/FABRIC-CONFORMANCE.md` with dated receipts for:
+
+1. declaration shape;
+2. exact protocol negotiation;
+3. bounded semantic probes;
+4. project-binding readiness.
+
+Include commands and exit codes, immutable endpoint or artifact identities, and explicit
+unverified surfaces. If live Fabric admission/runtime does not yet exist, the last gates
+remain `NOT VERIFIED`; the completed deliverable is an adaptation-ready provider bundle,
+not a connected provider.
+
+## Completion format
+
+Report:
+
+- selected capability and profile, with lifecycle-owner evidence;
+- created or changed files;
+- contract version and commit;
+- gate table with `PASS`, `FAIL`, `NOT_RUN`, or `NOT_VERIFIED`;
+- remaining placeholders and blockers;
+- the exact next command or runtime action.
+
+Never summarize the outcome as “Fabric-compatible” unless all required admission gates
+passed against a real provider and the project binding is valid.

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

@@ -0,0 +1,71 @@
+# Profile selection
+
+Load this reference when choosing or reviewing a profile for one capability.
+
+## Decision
+
+```text
+Does a remote peer accept an outcome and own task progress, artifacts,
+cancellation, and terminal state?
+  yes -> A2A 1.0
+  no  -> Does Fabric call a bounded remote or stdio capability?
+          yes -> MCP 2026-07-28
+          no  -> Does Fabric start an installed terminal process?
+                  yes -> fabric-local-runner/0.1
+                  no  -> unsupported until a stable surface exists
+```
+
+The protocol is selected per capability. A provider may expose several capabilities
+through different profiles, but one capability cannot change profile during a pinned run.
+
+## A2A
+
+Use when the remote system owns an opaque autonomous task lifecycle. Require:
+
+- HTTPS Agent Card and stable skill IDs;
+- A2A `1.0` binding and authentication declaration;
+- mapping for submitted, working, input-required, completed, failed, and cancelled states;
+- artifact and evidence mapping;
+- cancellation and safe semantic probes.
+
+An ordinary job API may be wrapped as A2A only when the adapter faithfully owns these
+task semantics. A long HTTP request alone is not proof of autonomy.
+
+## MCP
+
+Use when Fabric owns planning, ordering, retries, and task completion while invoking
+bounded provider features. Require:
+
+- MCP `2026-07-28` over streamable HTTP or stdio;
+- exact required feature names (`tool:`, `resource:`, or `prompt:`);
+- typed inputs and outputs;
+- idempotency and effect declarations;
+- bounded feature-level probes.
+
+An MCP server is a capability provider, not automatically an autonomous peer.
+
+## Local runner
+
+Use when Fabric launches an installed process such as a coding CLI. Require:
+
+- profile `fabric-local-runner/0.1`;
+- stable `executableRef`, never a secret-bearing shell string;
+- argument array and typed input mode;
+- immutable result URI convention;
+- signal or declared cancellation behaviour;
+- heartbeat and partial-result behaviour;
+- project-scoped account selection outside the manifest.
+
+The user may choose the project's default terminal and override it per agent. Model choice
+stays inside the selected agent/provider; the Fabric profile remains model-agnostic.
+
+## Reject or defer
+
+Return `undetermined` or blocked when:
+
+- more than one surface exists and the requested capability is unclear;
+- task lifecycle ownership is not observable;
+- the only integration surface is a browser UI;
+- the provider cannot supply typed input/output boundaries;
+- safe non-publishing probes cannot be defined.
+

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

@@ -0,0 +1,62 @@
+# Provider bundle
+
+Load this reference before scaffolding files or implementing the adapter mapping.
+
+## Files
+
+| Path | Responsibility |
+|---|---|
+| `fabric-agent.json` | versioned provider identity, capabilities, effects, profile, and probes |
+| `fabric-contract.lock.json` | normative repository, contract version, immutable commit, selected profile |
+| `fabric/schemas/capability-input.schema.json` | provider-specific input boundary |
+| `fabric/schemas/capability-output.schema.json` | provider-specific output boundary |
+| `fabric/fixtures/admission-input.json` | bounded repeatable probe input |
+| `fabric/probes/assertions.md` | semantic and safety properties checked by admission |
+| `fabric/FABRIC-CONFORMANCE.md` | receipts and explicit unverified gates |
+
+The layout packages an implementation; it does not replace the normative contract.
+
+## Manifest mapping
+
+For every capability, establish:
+
+- a stable provider URI, monotonic revision, immutable content hash, author, and identity method;
+- a stable capability URI and semantic name independent of implementation or model;
+- absolute, immutable input/output schema URIs;
+- the real side-effect class and idempotency behaviour;
+- every accepted data class;
+- exactly one profile and exact revision;
+- safe input fixture, output schema, timeout, effect ceiling, and semantic assertions.
+
+Do not include tokens, passwords, cookies, account IDs selected from an ambient shell, raw
+environment dumps, or chain-of-thought. A future project binding supplies allowlisted
+secret references, account pools, grants, data policy, coordination, and checker policy.
+
+## Implementation seam
+
+| Existing project | Adapter responsibility |
+|---|---|
+| Native MCP | map stable features directly and preserve MCP errors/cancellation |
+| Native A2A | declare the Agent Card/skills and normalize artifacts/evidence |
+| Terminal CLI | create typed input/result adapters and stable executable identity |
+| Bounded HTTP API | wrap operations with MCP while Fabric owns the loop |
+| Autonomous job API | map job lifecycle and artifacts to A2A tasks |
+| Browser-only app | first add a supported stable API or CLI |
+
+Completed and stopped invocations ultimately map to the Fabric result envelope: atomic
+`done` claims, resolvable `proof`, pinned `scope`, `notVerified`, and immutable artifacts.
+Provider-specific output schemas do not remove that normalization obligation.
+
+## Normative paths at the pinned commit
+
+Read these from `fabric-agent-contract` rather than copying them here:
+
+- `schemas/manifest.schema.json`
+- `schemas/result.schema.json`
+- `schemas/binding.schema.json`
+- `docs/specification/profiles.md`
+- `docs/specification/results-and-evidence.md`
+- `docs/specification/registry.md`
+- `docs/specification/versioning.md`
+- `fixtures/positive/manifest-{mcp,a2a,local}.json`
+