@passioncode-ai/passioncode 0.1.44 → 0.1.46

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.46 - 2026-10-12
+
+### Added
+
+- **`update` registers the Fabric Dashboards MCP server for every agent that is present**
+  (`fabric-dashboards`, stdio, the app bundle's `bin/fabric-dashboards-mcp`): Claude Code
+  through `claude mcp add --scope user`, Codex CLI as a `["mcp_servers"."fabric-dashboards"]`
+  table appended to `~/.codex/config.toml`, Gemini CLI and Kimi Code in the `mcpServers` of
+  `~/.gemini/settings.json` and `$KIMI_CODE_HOME/mcp.json`. A machine without the app skips
+  the step; an entry that already points at the same command is left alone, and one that
+  points elsewhere, or is declared in a form the launcher does not edit, is reported and
+  kept. Each registration is journalled before the file changes and removed again by
+  `restore` and `uninstall` only while it is still exactly what the launcher wrote
+  ([ADR-0003](docs/adr/0003-fabric-dashboards-mcp-registration.md)).
+
+## 0.1.45 - 2026-10-12
+
+### Changed
+
+- **Fabric Agent Adapter is pinned at `v0.21.0`** (it was `v0.20.0`). Fabric Agent Adapter 0.21.0 (FAA-31): both service kits verify the operator's signed estate record (estate-record/1, contract DEC-0055) — the chain of revisions, the passkey's WebAuthn assertion checked offline, the 30-day window and the record's rules — and a delegation gate given the current record trusts a token's key only while that record certifies it. The adapter now pins contract b291bf0.
+
 ## 0.1.44 - 2026-10-12
 
 ### Changed

package/README.md

@@ -55,6 +55,12 @@ out of it, even when they implement Fabric protocols.
   `~/.passioncode/quarantine/` — `npx @passioncode-ai/passioncode@latest restore` puts them back.
 - Each version is an immutable release under `~/.passioncode/releases/<version>`; an update
   keeps the release it replaced for rollback and removes older ones.
+- When the Fabric Dashboards app is installed, `update` also registers its MCP server
+  (`fabric-dashboards`) for every agent that is present — Claude Code (through
+  `claude mcp add --scope user`), Codex CLI (`~/.codex/config.toml`), Gemini CLI
+  (`~/.gemini/settings.json`) and Kimi Code (`~/.kimi-code/mcp.json`). An entry that
+  already points at the same command is left alone; one that points elsewhere is reported
+  and kept. `restore` and `uninstall` remove what the launcher added.
 
 ## Staying current
 

package/SECURITY.md

@@ -11,7 +11,12 @@ that replaces it is verified. For a member's old single-member marketplace
 (`legacyMarketplaces` in `family.json`), once that plugin is verified and nothing else
 installed comes from it, it also moves the `extraKnownMarketplaces` entry out of
 `~/.claude/settings.json` (a copy of the file is kept in the quarantine) and runs
-`claude plugin marketplace remove <name>`. Displaced files are moved rather than
+`claude plugin marketplace remove <name>`. When the Fabric Dashboards app is installed it
+also registers a `fabric-dashboards` MCP entry for every agent that is present: through
+`claude mcp add --scope user` for Claude Code (it never writes `~/.claude.json` itself),
+and in `~/.codex/config.toml`, `~/.gemini/settings.json` and `~/.kimi-code/mcp.json`,
+copying each existing file into the quarantine first; an entry that already exists is
+left alone and reported. Displaced files are moved rather than
 deleted: a recovery record is written before the move in
 `~/.passioncode/quarantine/<run>/moved.json`. `restore` processes the latest batch,
 checkpoints completed entries and refuses to overwrite a conflicting user replacement.

package/family.json

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

package/lib/launcher.js

@@ -2,8 +2,9 @@
 /**
  * The PassionCode.ai launcher: installs the vendored payload as one release,
  * gives Claude Code the plugins through a local marketplace, gives every other
- * agent the same skills through the ~/.agents/skills hub, and removes what
- * would shadow them — reversibly. Every step is recorded; nothing is deleted.
+ * agent the same skills through the ~/.agents/skills hub, registers the Fabric
+ * Dashboards MCP server for every agent that is present, and removes what would
+ * shadow them — reversibly. Every step is recorded; nothing is deleted.
  *
  * One channel per agent: Claude Code reads plugins, so nothing is written to
  * ~/.claude/skills (a plain copy there shadows the plugin and serves its frozen
@@ -47,6 +48,12 @@ function writeJson(file, value) {
   fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n');
   fs.renameSync(tmp, file);
 }
+function writeText(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, text);
+  fs.renameSync(tmp, file);
+}
 function lstat(p) { try { return fs.lstatSync(p); } catch (_) { return null; } }
 function linkTarget(p) { try { return fs.readlinkSync(p); } catch (_) { return null; } }
 function pointsTo(at, target) { const link = linkTarget(at); return link !== null && path.resolve(path.dirname(at), link) === target; }
@@ -187,6 +194,103 @@ function marketplaceAddArg(source) {
   return source.url || source.repo || source.path || null;
 }
 
+const MCP_NAME = 'fabric-dashboards';
+const MCP_COMMAND = () => process.env.PASSIONCODE_FABRIC_DASHBOARDS_MCP
+  || '/Applications/Fabric Dashboards.app/Contents/Resources/bin/fabric-dashboards-mcp';
+
+/**
+ * The agents besides Claude Code the Fabric Dashboards MCP server is registered for, and
+ * the file each keeps its MCP configuration in. An agent is present when its directory
+ * is; a missing file under a present agent is created. Claude Code is registered through
+ * its own CLI instead: every running session rewrites ~/.claude.json, so a second writer
+ * there would lose one side's change.
+ */
+function mcpFileTargets(home) {
+  const kimiHome = process.env.KIMI_CODE_HOME || path.join(home, '.kimi-code');
+  return [
+    { agent: 'Codex CLI', dir: path.join(home, '.codex'), file: path.join(home, '.codex', 'config.toml'), kind: 'toml' },
+    { agent: 'Gemini CLI', dir: path.join(home, '.gemini'), file: path.join(home, '.gemini', 'settings.json'), kind: 'json' },
+    { agent: 'Kimi Code', dir: kimiHome, file: path.join(kimiHome, 'mcp.json'), kind: 'json' },
+  ];
+}
+
+/** The line range of the `["mcp_servers"."<name>"]` table in a TOML text, or null. */
+function tomlTableRange(text, name) {
+  const lines = text.split('\n');
+  const header = new RegExp(`^\\s*\\[\\s*["']?mcp_servers["']?\\s*\\.\\s*["']?${name}["']?\\s*\\]\\s*(?:#.*)?$`);
+  for (let i = 0; i < lines.length; i++) {
+    if (!header.test(lines[i])) continue;
+    let end = lines.length;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (/^\s*\[/.test(lines[j])) { end = j; break; }
+    }
+    return { start: i, end, lines };
+  }
+  return null;
+}
+
+/**
+ * Any other way a TOML text can already define the server — a sub-table such as
+ * `[mcp_servers.<name>.env]` or an inline `<name> = { … }` under `[mcp_servers]`.
+ * Appending a table then would declare the key twice and Codex would refuse the file.
+ */
+function tomlMentions(text, name) {
+  return new RegExp(`^\\s*\\[\\s*["']?mcp_servers["']?\\s*\\.\\s*["']?${name}["']?\\s*\\.`, 'm').test(text)
+    || new RegExp(`^\\s*["']?${name}["']?\\s*=`, 'm').test(text);
+}
+
+/** The `command` of a TOML table range: the string, null when absent, undefined when unreadable. */
+function tomlTableCommand(range) {
+  for (let i = range.start + 1; i < range.end; i++) {
+    const m = /^\s*command\s*=\s*("(?:[^"\\]|\\.)*")\s*(?:#.*)?$/.exec(range.lines[i]);
+    if (m) { try { return JSON.parse(m[1]); } catch (_) { return undefined; } }
+  }
+  return null;
+}
+
+function mcpTomlTable(command) {
+  return `["mcp_servers"."${MCP_NAME}"]\ncommand = ${JSON.stringify(command)}\nargs = []\n`;
+}
+
+/** Two MCP entries are the same when their JSON lines up at every depth, key order aside. */
+function sameEntry(a, b) {
+  const canon = (v) => (v && typeof v === 'object' && !Array.isArray(v)
+    ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, canon(v[k])]))
+    : Array.isArray(v) ? v.map(canon) : v);
+  return JSON.stringify(canon(a)) === JSON.stringify(canon(b));
+}
+
+/**
+ * Remove an MCP entry the launcher added, only while it is still exactly that entry.
+ * Returns a note, or null when the entry is already gone. Never deletes the file.
+ */
+function removeMcpRegistration(record, claude) {
+  const kept = (why) => `${record.file}: ${record.name} for ${record.agent} ${why}; kept`;
+  const removed = `${record.name} for ${record.agent} removed from ${record.file}`;
+  if (record.file.endsWith('.toml')) {
+    let text;
+    try { text = fs.readFileSync(record.file, 'utf8'); } catch (_) { return null; }
+    const range = tomlTableRange(text, record.name);
+    if (!range) return null;
+    if (tomlTableCommand(range) !== record.entry.command) return kept('was changed');
+    writeText(record.file, range.lines.slice(0, range.start).concat(range.lines.slice(range.end)).join('\n'));
+    return removed;
+  }
+  let cfg;
+  try { cfg = readSettings(record.file); } catch (error) { return kept(`could not be read (${error.message})`); }
+  const servers = cfg.doc.mcpServers;
+  if (!servers || !Object.prototype.hasOwnProperty.call(servers, record.name)) return null;
+  if (!sameEntry(servers[record.name], record.entry)) return kept('was changed');
+  if (record.via === 'claude') {
+    if (!claude.available()) return kept('is registered with Claude Code, whose CLI was not found');
+    const r = claude.run(['mcp', 'remove', '--scope', 'user', record.name]);
+    return r.code === 0 ? removed : kept(`could not be removed (${r.out || 'claude mcp remove failed'})`);
+  }
+  delete servers[record.name];
+  writeJson(record.file, cfg.doc);
+  return removed;
+}
+
 function payloadManifest(dir = PAYLOAD()) {
   const m = readJson(path.join(dir, 'manifest.json'), null);
   if (!m || !Array.isArray(m.members)) throw new Error(`No payload in ${dir}: the package is incomplete (run scripts/vendor.mjs).`);
@@ -391,7 +495,93 @@ function update({ home, dryRun = false, claude = claudeRunner(), log = () => {}
     }
   }
 
-  // 5. The launcher's own releases: keep this one and the one it replaced, remove the rest.
+  // 5. The Fabric Dashboards MCP server, for every agent that is present. Entries a
+  //    person or another tool set are never rewritten: a matching entry is left, a
+  //    different one is reported. What the launcher adds is journalled before it is
+  //    written, so restore and uninstall can take it out again.
+  const registered = [];
+  const mcpCommand = MCP_COMMAND();
+  const mcpBackup = (file, agent) => {
+    if (!lstat(file)) return null;
+    fs.mkdirSync(quarantineDir, { recursive: true });
+    const backup = path.join(quarantineDir, `${path.basename(file)}.before-mcp-${agent.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`);
+    fs.copyFileSync(file, backup);
+    return backup;
+  };
+  const register = (record, write) => step('mcp', `register ${MCP_NAME} for ${record.agent} in ${record.file}`, () => {
+    recordMove(record);
+    write();
+    registered.push({ agent: record.agent, file: record.file, name: record.name, entry: record.entry, ...(record.via ? { via: record.via } : {}) });
+  });
+  const existingNote = (agent, existing) => existing === mcpCommand
+    ? { kind: 'mcp', detail: `${agent} already runs ${MCP_NAME} from ${mcpCommand}`, outcome: 'skipped' }
+    : { kind: 'mcp', detail: `${agent} has its own ${MCP_NAME} entry (${existing || 'not a stdio server'}); it was kept`, outcome: 'skipped' };
+  if (!lstat(mcpCommand)) {
+    steps.push({ kind: 'mcp', detail: `no Fabric Dashboards MCP at ${mcpCommand}; nothing was registered`, outcome: 'skipped' });
+  } else {
+    const claudeJson = path.join(p.home, '.claude.json');
+    if (!hasClaude) {
+      steps.push({ kind: 'mcp', detail: `Claude Code CLI not found; ${MCP_NAME} was not registered for it`, outcome: 'skipped' });
+    } else {
+      let servers = null;
+      try { servers = readSettings(claudeJson).doc.mcpServers || {}; } catch (error) {
+        steps.push({ kind: 'mcp', detail: `keep ${claudeJson}: it could not be read`, outcome: 'failed', error: error.message });
+      }
+      const existing = servers && servers[MCP_NAME];
+      if (existing) steps.push(existingNote('Claude Code', typeof existing === 'object' ? existing.command || existing.url : null));
+      else if (servers) {
+        const entry = { type: 'stdio', command: mcpCommand, args: [], env: {} };
+        register({ kind: 'mcp', via: 'claude', agent: 'Claude Code', file: claudeJson, name: MCP_NAME, entry, backup: null }, () => {
+          const r = claude.run(['mcp', 'add', '--scope', 'user', MCP_NAME, '--', mcpCommand], { cwd: p.state });
+          if (r.code !== 0) throw new Error(r.out || 'claude mcp add failed');
+          const now = readSettings(claudeJson).doc.mcpServers || {};
+          if (!now[MCP_NAME] || now[MCP_NAME].command !== mcpCommand) throw new Error(`Claude Code did not register ${MCP_NAME} in ${claudeJson}`);
+          // What the CLI wrote is what restore and uninstall compare against.
+          entry.type = now[MCP_NAME].type; entry.args = now[MCP_NAME].args; entry.env = now[MCP_NAME].env;
+        });
+      }
+    }
+    for (const target of mcpFileTargets(p.home)) {
+      if (!isDirectory(target.dir)) {
+        steps.push({ kind: 'mcp', detail: `${target.agent} not found; ${MCP_NAME} was not registered for it`, outcome: 'skipped' });
+        continue;
+      }
+      if (target.kind === 'json') {
+        let cfg;
+        try { cfg = readSettings(target.file); } catch (error) {
+          steps.push({ kind: 'mcp', detail: `keep ${target.file}: it could not be read`, outcome: 'failed', error: error.message });
+          continue;
+        }
+        const existing = (cfg.doc.mcpServers || {})[MCP_NAME];
+        if (existing) { steps.push(existingNote(target.agent, typeof existing === 'object' ? existing.command || existing.url : null)); continue; }
+        const entry = { command: mcpCommand, args: [], env: {} };
+        register({ kind: 'mcp', agent: target.agent, file: target.file, name: MCP_NAME, entry, backup: mcpBackup(target.file, target.agent) }, () => {
+          cfg.doc.mcpServers = { ...(cfg.doc.mcpServers || {}), [MCP_NAME]: entry };
+          writeJson(target.file, cfg.doc);
+        });
+      } else {
+        let text = '';
+        try { text = fs.readFileSync(target.file, 'utf8'); } catch (error) {
+          if (error.code !== 'ENOENT') {
+            steps.push({ kind: 'mcp', detail: `keep ${target.file}: it could not be read`, outcome: 'failed', error: error.message });
+            continue;
+          }
+        }
+        const range = tomlTableRange(text, MCP_NAME);
+        if (range) { const c = tomlTableCommand(range); steps.push(existingNote(target.agent, c == null ? null : c)); continue; }
+        if (tomlMentions(text, MCP_NAME)) {
+          steps.push({ kind: 'mcp', detail: `${target.agent} declares ${MCP_NAME} in ${target.file} in a form the launcher does not edit; it was kept`, outcome: 'skipped' });
+          continue;
+        }
+        const entry = { command: mcpCommand, args: [] };
+        register({ kind: 'mcp', agent: target.agent, file: target.file, name: MCP_NAME, entry, backup: mcpBackup(target.file, target.agent) }, () => {
+          writeText(target.file, text ? `${text.endsWith('\n') ? text : `${text}\n`}\n${mcpTomlTable(mcpCommand)}` : mcpTomlTable(mcpCommand));
+        });
+      }
+    }
+  }
+
+  // 6. The launcher's own releases: keep this one and the one it replaced, remove the rest.
   //    They are its own output, reinstallable from npm — not the person's files, which are
   //    only ever moved to the quarantine.
   const stale = staleReleases(p, version, state.installed || null);
@@ -410,6 +600,9 @@ function update({ home, dryRun = false, claude = claudeRunner(), log = () => {}
     fresh.members = manifest.members.map((m) => ({ name: m.name, version: m.version, ref: m.ref, commit: m.commit }));
     fresh.quarantines = [...new Set([...(fresh.quarantines || []), ...(moved.length ? [quarantineDir] : [])])];
     if (state.legacyRemoved) fresh.legacyRemoved = state.legacyRemoved;
+    if (registered.length) {
+      fresh.mcpRegistrations = [...(fresh.mcpRegistrations || []).filter((r) => !registered.some((n) => n.file === r.file && n.name === r.name)), ...registered];
+    }
     delete fresh.updatingSince;
     writeJson(p.stateFile, fresh);
   }
@@ -430,6 +623,15 @@ function restore({ home, which, claude = claudeRunner() } = {}) {
       if (entry.restoredAt) continue;
       if (entry.kind === 'marketplace') {
         restored.push(restoreMarketplace(p, entry, claude));
+      } else if (entry.kind === 'mcp') {
+        const note = removeMcpRegistration(entry, claude);
+        if (note) restored.push(note);
+        const state = readState(p.stateFile);
+        if (state.mcpRegistrations) {
+          state.mcpRegistrations = state.mcpRegistrations.filter((r) => !(r.file === entry.file && r.name === entry.name));
+          if (!state.mcpRegistrations.length) delete state.mcpRegistrations;
+          writeJson(p.stateFile, state);
+        }
       } else if (lstat(entry.to)) {
         if (lstat(entry.from)) {
           // Old journals did not record the replacement. Only recognise a link
@@ -561,6 +763,13 @@ function uninstall({ home, claude = claudeRunner() } = {}) {
     fs.unlinkSync(p.current);
   }
   const state = readState(p.stateFile);
+  // The MCP registrations this launcher added — only while they are still exactly what
+  // it wrote; an entry a person changed since stays.
+  for (const record of state.mcpRegistrations || []) {
+    const note = removeMcpRegistration(record, claude);
+    if (note) removed.push(note);
+  }
+  delete state.mcpRegistrations;
   state.installed = null;
   state.members = [];
   state.config = { ...(state.config || {}), auto: false };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@passioncode-ai/passioncode",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "The PassionCode.ai agent skill set \u2014 Fabric Agent Adapter, Observatory Log and the organisation's working rules \u2014 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.20.0",
+      "version": "0.21.0",
       "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.44",
+      "version": "0.1.46",
       "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.44",
+  "version": "0.1.46",
   "release": true,
   "members": [
     {
       "name": "fabric-agent-adapter",
       "displayName": "Fabric Agent Adapter",
       "repo": "passioncode-ai/fabric-agent-adapter",
-      "ref": "v0.20.0",
-      "commit": "925d052d682572dc4ba60a7e1dea3da5a77a4de7",
-      "version": "0.20.0",
+      "ref": "v0.21.0",
+      "commit": "7dfbb0a7af36dc1a28e266c0ef248168dabc904f",
+      "version": "0.21.0",
       "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:9ae4b03e68e22f96174fff64430c47a7d575471efc5d0303560c4eed9adec038",
+      "contentHash": "sha256:c849515947a8e3ccb28b9bcc570e5cb7a3b417eb5c61e5ab9e1d2a7e656c78ef",
       "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.44",
+      "ref": "v0.1.46",
       "commit": null,
-      "version": "0.1.44",
+      "version": "0.1.46",
       "via": "this repository",
       "skills": [
         "working-in-passioncode"
       ],
       "legacyPluginIds": [],
       "legacyMarketplaces": [],
-      "contentHash": "sha256:209f32cdc3656684b3622173cfc630add724f38d50bb9d9c3d80d57f926f6981",
+      "contentHash": "sha256:eceb409d950b38814a892a29ffe028c41a3000c3323af46458ec345f1faa37f3",
       "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.20.0",
+  "version": "0.21.0",
   "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: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode.
 metadata:
   author: PassionCode.ai
-  version: "0.20.0"
+  version: "0.21.0"
   contract-version: "0.1.0"
-  contract-commit: "0cacd08b0e95b6abf131eae1206b60792138bc3c"
+  contract-commit: "b291bf09e0a9f9fd3c16cf540832cd021203b7d1"
 ---
 
 # 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 `0cacd08b0e95b6abf131eae1206b60792138bc3c`.
+- commit `b291bf09e0a9f9fd3c16cf540832cd021203b7d1`.
 
 This is the default for new bundles. When checking an issued legacy bundle, preserve its
 explicit supported lock and use that exact clean checkout. Never silently upgrade or

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

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

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

@@ -16,10 +16,10 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Python 3.9+ or Node.js 20+ for the kits; the probe needs Python 3.9+. launchd steps are macOS-only; Linux services install a systemd user unit and Windows ones a per-user Scheduled Task with the kits' writers. Dashboard handoff optionally uses Fabric Dashboards MCP link/host_status/open; without it, report unresolved host capability. The contract checkout is optional.
 metadata:
   author: PassionCode.ai
-  version: "0.20.0"
+  version: "0.21.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
-  extension-commit: "0cacd08b0e95b6abf131eae1206b60792138bc3c"
+  extension-commit: "b291bf09e0a9f9fd3c16cf540832cd021203b7d1"
 ---
 
 # Building Fabric services
@@ -83,7 +83,9 @@ are in [`scripts/fabric_interop.py`](scripts/fabric_interop.py) and
 [`scripts/fabric-interop.mjs`](scripts/fabric-interop.mjs). When the callers are agents of the estate, the
 service checks each call's delegation token (DEC-0039): read [the delegation reference](references/delegation.md);
 the verifier is [`scripts/fabric_delegation.py`](scripts/fabric_delegation.py) /
-[`scripts/fabric-delegation.mjs`](scripts/fabric-delegation.mjs). When Fabric chooses the service's runner and models
+[`scripts/fabric-delegation.mjs`](scripts/fabric-delegation.mjs). A service on the operator's machines that
+applies the estate record (DEC-0055) verifies each revision first and trusts only the keys it certifies: read
+[the estate record reference](references/estate-record.md). When Fabric chooses the service's runner and models
 (DEC-0046), or a project routes its work through an ordered list of runners (DEC-0026: the doctor's closed probe
 results, the route checks FAC-SEM-028…034), read [the profiles reference](references/profiles.md).
 

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

@@ -16,6 +16,7 @@ contract's own verifier does.
 - Approvals
 - What a refusal looks like
 - Keys and the cache
+- Keys the estate record certifies
 - What the kit does not do
 
 ## Declaring it
@@ -92,6 +93,19 @@ Python kit verifies Ed25519 itself (RFC 8032, standard library only, strict as O
 canonical points, no small-order key); it follows no redirect when it reads the key set; the Node kit uses `node:crypto` and refuses small-order keys
 itself (`isSmallOrderKey`), because Node before 26 lets OpenSSL accept a signature under one.
 
+## Keys the estate record certifies
+
+A verifier that also reads the estate's record (DEC-0055, [the estate record reference](estate-record.md)) trusts a
+`kid` only while a current revision certifies it for a machine and does not revoke it (DL-14). Pass the current
+verified revision as `estate=` / `{ estate }`, as a value or as a function returning it, to `delegation_gate`,
+`verify_delegation` or `verify_approval`.
+- An uncertified `kid` is refused `unauthenticated` (`approval-invalid` for an approval), with detail
+  `kid-not-certified`.
+- An unreadable record is refused `issuer-unavailable`, with detail `estate-unreadable`.
+- Without `estate`, nothing changes.
+- Pass only a revision `verify_estate_record` accepted, and the highest one the machine has applied. The rule trusts
+  what it is given, so an unverified or older revision would certify a key the current one revoked.
+
 ## What the kit does not do
 
 It does not mint tokens, check attenuation against a parent (the issuer's rule, DL-5), check a grant or a spend

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

@@ -0,0 +1,90 @@
+# The estate record — what the operator's machines are, signed by their passkey (DEC-0055)
+
+Fabric Agent Contract DEC-0055, `docs/specification/estate-record.md`, schema `schemas/estate-record.schema.json`,
+rules `FAC-SEM-072…076`. One revision of one person's estate lists:
+- the passkeys that sign it;
+- the machines, with their device keys and a certificate of each machine's hub key;
+- the packages placed on each machine;
+- where each secret slot is filled from (by reference only);
+- share grants and revocations.
+
+A revision names its parent's digest and is signed by a passkey assertion (WebAuthn Level 3) over a challenge
+derived from its own digest. Python: [`scripts/fabric_estate.py`](../scripts/fabric_estate.py). Node:
+[`scripts/fabric-estate.mjs`](../scripts/fabric-estate.mjs). Both answer the contract's own vectors.
+
+## Contents
+
+- Applying a revision
+- Trusting a delegation key
+- Checking a record you produce
+- What the kit does not do
+
+## Applying a revision
+
+A machine applies a revision only when it is valid against `estate-record.schema.json` **and** the verifier accepts
+it. The verifier does not check the schema.
+
+```python
+verdict = fe.verify_estate_record(record, at=datetime.now(timezone.utc), parent=current)   # revision 2 and later
+verdict = fe.verify_estate_record(record, at=now, authorities=pinned_passkeys)             # revision 1
+if verdict["ok"]:
+    current = record          # verdict: digest, revision, signedBy, signCount
+```
+
+```js
+const verdict = verifyEstateRecord(record, { at: new Date(), parent: current });
+```
+
+It checks, in the order of the ER table:
+1. **The clock.** An unreadable one is `no-clock`, and it comes first.
+2. **The shape.**
+3. **The digest.** SHA-256 over the RFC 8785 form, without `digest` and `signature`.
+4. **The chain to the parent.** Same estate, the next revision number, the parent's digest, never issued before the
+   parent, and no revocation dropped.
+5. **The signer.** The signing passkey must be among the trusted ones and not revoked by the parent. A revision may
+   revoke its own signer: that is rotation.
+6. **The assertion.**
+   - Client data: type, challenge, origin, no cross-origin use.
+   - The RP ID hash, and the user-presence and user-verification flags.
+   - The signature: ES256 or EdDSA, under a key validated first (a valid P-256 point; an Ed25519 key of full order).
+7. **The window.** At most 30 days.
+8. **The record's own rules.** A violation is `rule-violation` with its `codes`.
+
+Dates are strict RFC 3339: a `T`, an offset, and a day that exists. `:60` and a space are refused. Passkey JWK `x`
+and `y` must be canonical base64url. The Python kit verifies ES256 in pure Python (P-256, strict DER), and the Node
+kit through `node:crypto`.
+
+## Trusting a delegation key
+
+A delegation verifier that reads the estate record trusts a token's `kid` only while a current revision certifies it
+for a machine and does not revoke it (DL-14, contract CT-20). Give the gate the current verified revision, or a
+function that returns it:
+
+```python
+gate = fd.delegation_gate(audience=..., jwks=keys, issuer=..., effects=..., estate=lambda: current)
+```
+
+- A `kid` the record does not certify is refused like an unknown key: `unauthenticated` (for an approval,
+  `approval-invalid`) with detail `kid-not-certified`. The same holds when the record names another key under that
+  kid, revokes it, or is outside its window.
+- A record that cannot be read certifies nothing: `issuer-unavailable` with detail `estate-unreadable`.
+- **What you pass in.** Pass only a revision that `verify_estate_record` accepted, and the highest revision the
+  machine has applied. The rule trusts the record it is given. A record nobody verified, or an older revision still
+  inside its window, would certify a key the current revision revoked (a rollback).
+- `hub_key_certified(record, kid, x, at)` / `hubKeyCertified(...)` answers the question on its own.
+
+## Checking a record you produce
+
+`estate_record_rules(kind, value)` / `estateRecordRules(kind, value)` are the contract's rules, finding for finding:
+- `estate-record` (FAC-SEM-072…076);
+- `estate-record-revision` `{parent, next}` (072);
+- `estate-placement` `{record, machine, package}` (074, 075).
+
+`placement_trust(record, machine, agentRef)` names the publisher keys a package verifier trusts for a placed package.
+
+## What the kit does not do
+
+- It does not sign: it holds no passkey and no private key.
+- It does not check the schema or verify packages.
+- It does not attest the authenticator (an assertion carries no attestation).
+- It does not track the signature counter: passkeys sync between devices.

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 `0cacd08b0e95b6abf131eae1206b60792138bc3c`
+Pinned to `fabric-agent-contract` commit `b291bf09e0a9f9fd3c16cf540832cd021203b7d1`
 (`docs/specification/service.md`, DEC-0015; the usage report DEC-0021; Windows and Linux supervision
 DEC-0032 and DEC-0033; the operator channel DEC-0034 and DEC-0035; the embedded dashboard DEC-0036;
 delegation and the operator session's lifetime DEC-0039; the meter's call window DEC-0041; session handoff DEC-0042;