@passioncode-ai/fabric-agent-adapter 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.30.0 - 2026-10-13
+
+The Node service kit installs and uninstalls a launchd job, as the Python kit does (FAA-04). The probe fails a plist
+whose copy would not know launchd supervises it (FAA-05).
+
+### Added
+
+- **launchd in the Node kit** (`fabric-service.mjs`, FAA-04): `launchdPlist`, `launchdLoaded`, `launchdOverride`,
+  `launchdInstall` and `launchdUninstall`, the twins of the Python `launchd_*` helpers.
+  - `launchdPlist` writes the same bytes as Python's `plistlib`.
+  - It writes `FABRIC_SERVICE_SUPERVISOR=launchd` itself and refuses a marker argument.
+  - It refuses a secret-named variable (a `*_FILE` path is fine), and any variable value or argument shaped like a
+    credential, a control character or an empty program.
+  - `launchdInstall` follows the LC-14 order: lint, then enable only on a first install. A label the operator
+    disabled stays off, with the plist rewritten. The bootout is waited out, the bootstrap retried five times, and
+    the install resolves once the well-known document answers with this `id.instance`.
+  - `launchdUninstall` waits for the unload, removes the plist and resets the override to `enabled`. `purge` (with
+    the service id) removes data, logs and cache; a symlinked folder loses only its link.
+  - Off macOS both are refused, with the name of that platform's installer. `run`, `fetchWellKnown` and `sleep` are
+    injectable, so tests never reach the real launchctl.
+- **Probe rule `lifecycle.supervisor-marker`** (`check_service.py`, FAA-05). It reads the plist's
+  `EnvironmentVariables` and `ProgramArguments` the way the started copy reads them (`supervisor_marker`,
+  DEC-0057). It fails these cases:
+  - no marker;
+  - a marker naming another supervisor, or naming none;
+  - markers that disagree.
+
+  Without the marker, a copy that finds the lock held exits 75 at once, and KeepAlive restarts it every
+  `ThrottleInterval`. Plists written by `launchd_plist` since 0.8.0 (FAA-06) carry the marker; an older one fails
+  until it is regenerated and reinstalled.
+
+### Evidence
+
+- `test/fabric-service-launchd.test.mjs` (20 cases) runs against a launchd stand-in with the Python fake's
+  semantics. Its byte-identity case compares `launchdPlist` with `plistlib` output.
+- Two Python cases in `test/test_fabric_service.py` check `marker_problem` and the rule run on a written plist.
+- 16 planted defects were all caught, after replacing two equivalent mutants with real ones. Among them: enable on
+  every install, a skipped unload wait, a kept override, unsorted keys, an early bootstrap give-up, an ignored
+  instance, a dropped marker, a skipped lint, the legacy override format, an endless uninstall wait, and a probe
+  that accepts any supervisor or none.
+
 ## 0.29.0 - 2026-10-13
 
 `working-with-fabric` carries the limit-stop rule (fabric-workspace principle 10, item 6, operator 2026-10-13).

package/package.json

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

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

@@ -3,7 +3,7 @@
   "name": "fabric-agent-adapter",
   "displayName": "Fabric Agent Adapter",
   "description": "Create new Fabric-compatible agents, build them as always-alive local services with dashboards (fabric-service/0.1), and adapt existing projects to the Fabric Agent Contract through evidence-backed MCP, A2A, or local-runner provider bundles; and teach a coding agent to work in a project through Fabric (fabric-mcp, fabric_whoami, claim and release), with Claude Code session hooks.",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "author": {
     "name": "PassionCode.ai",
     "url": "https://passioncode.ai/"

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

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

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

@@ -17,7 +17,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Python 3.9+ or Node.js 20+ for the kits; the probe needs Python 3.9+. launchd steps are macOS-only; Linux services install a systemd user unit and Windows ones a per-user Scheduled Task with the kits' writers. Dashboard handoff optionally uses Fabric Dashboards MCP link/host_status/open; without it, report unresolved host capability. The contract checkout is optional.
 metadata:
   author: PassionCode.ai
-  version: "0.29.0"
+  version: "0.30.0"
   contract-version: "0.1.0"
   extension: "fabric-service/0.1"
   extension-commit: "f00a7685e3861c27f7899c033fb850a145a1708f"
@@ -203,7 +203,8 @@ The installer, not the service, owns the plist and the descriptor. Sequence:
 
 On Linux the supervisor is a systemd user unit (`systemd_unit` + `systemd_install`), on
 Windows a per-user Scheduled Task (`task_xml` + `task_install`); the Node kit has the same
-writers (`systemdUnit`, `taskXml`, …) and both kits write identical files.
+writers and installers (`launchdPlist` + `launchdInstall`, `systemdUnit`, `taskXml`, …) and
+both kits write identical files.
 
 Code runs from an immutable release directory; an upgrade writes a new release,
 rewrites the plist and restarts. Read [the lifecycle reference](references/lifecycle.md)

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

@@ -12,7 +12,7 @@ wins and this page is the defect. The rule each section serves:
 | LC-09 the footprint is declared | the descriptor and the plist, unit or task; the service's own `AGENTS.md` names its label (unit, task) and port | `write_descriptor`, `launchd_plist`, `systemd_unit` / `systemdUnit`, `task_xml` / `taskXml` |
 | LC-11 previous release kept, older pruned | [Install, upgrade, uninstall](#install-upgrade-uninstall) | `prune_releases` / `pruneReleases` |
 | LC-12 every file is bounded | [Logs](#logs) | `RotatingLog`, `cap_stdout_log` / `RotatingLog`, `capStdoutLog` |
-| LC-14 operator intent wins; uninstall is symmetric | [Install, upgrade, uninstall](#install-upgrade-uninstall), [Linux and Windows](#linux-and-windows) | `launchd_install`, `launchd_uninstall` (Python); `systemd_install` / `systemdInstall`, `task_install` / `taskInstall` and their uninstalls |
+| LC-14 operator intent wins; uninstall is symmetric | [Install, upgrade, uninstall](#install-upgrade-uninstall), [Linux and Windows](#linux-and-windows) | `launchd_install` / `launchdInstall`, `launchd_uninstall` / `launchdUninstall`; `systemd_install` / `systemdInstall`, `task_install` / `taskInstall` and their uninstalls |
 | LC-15 builds clean up after themselves | release pruning runs inside the installer, not later | `prune_releases` / `pruneReleases` |
 
 ## Contents
@@ -26,7 +26,7 @@ wins and this page is the defect. The rule each section serves:
 - [Being managed by a host lifecycle broker](#being-managed-by-a-host-lifecycle-broker)
 - [Linux and Windows](#linux-and-windows)
 
-## launchd plist (generate it with `launchd_plist`)
+## launchd plist (generate it with `launchd_plist` or `launchdPlist`; both kits write the same bytes)
 
 | Key | Value | Why |
 |---|---|---|
@@ -37,7 +37,7 @@ wins and this page is the defect. The rule each section serves:
 | `ThrottleInterval` | `10` | bounds a crash loop |
 | `ExitTimeOut` | above the drain and its hard exit (15 s default; `Drain` ends by 10 s) | SIGKILL arrives after it, so it must never come first |
 | `ProcessType` | `Standard` — never `Background`, and no `Nice` > 0 or `LowPriorityIO` | a host probes the service and agents call it while the Mac is busy; a background job is starved for tens of seconds under load and every host reports an outage that never happened (the probe's `lifecycle.priority` rule fails it) |
-| `EnvironmentVariables` | `PATH` set explicitly; `*_FILE` paths to secrets; `FABRIC_SERVICE_SUPERVISOR=launchd` | never a secret value — the plist is world-readable in backups; the supervisor marker is how the lock knows to back off |
+| `EnvironmentVariables` | `PATH` set explicitly; `*_FILE` paths to secrets; `FABRIC_SERVICE_SUPERVISOR=launchd` | never a secret value — the plist is world-readable in backups; the supervisor marker is how the lock knows to back off (the probe's `lifecycle.supervisor-marker` rule fails a plist without it: a copy that finds the lock held would exit 75 at once into a respawn every `ThrottleInterval`) |
 | `StandardOutPath`/`StandardErrorPath` | `~/Library/Logs/<id>/service.log` | one place the host tails |
 
 ## Install, upgrade, uninstall
@@ -45,14 +45,14 @@ wins and this page is the defect. The rule each section serves:
 1. Build or unpack the release into `~/.local/share/<id>/releases/<version>-<sha12>/`
    (a venv or `node_modules` inside it). Never edit a release after it is written.
 2. `write_descriptor` (port and id claims are checked here).
-3. `launchd_install`: write + `plutil -lint`, read `launchctl print-disabled gui/<uid>`,
+3. `launchd_install` (Node: `await launchdInstall(...)`, the same steps): write + `plutil -lint`, read `launchctl print-disabled gui/<uid>`,
    `enable` **only when no override is recorded** (a first install), `bootout` and wait
    until `launchctl print gui/<uid>/<label>` fails, `bootstrap` with up to five retries,
    then poll the well-known document until it answers with this `id.instance`.
 4. Upgrade = new release, rewrite the plist with the new path, `launchd_install`
    again, then `prune_releases(releases_dir, current=<new release>)`: the running release
    and the one before it stay for rollback, older ones go (LC-11, LC-15).
-5. Uninstall = `launchd_uninstall` + `remove_descriptor`. Data stays; `purge=True`
+5. Uninstall = `launchd_uninstall` (Node: `await launchdUninstall(...)`) + `remove_descriptor`. Data stays; `purge=True`
    (with `service_id`) removes data, logs and cache when the operator asks.
 
 **The operator's intent wins (LC-14).** A host stops a service with `bootout` **and**

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

@@ -75,6 +75,29 @@ def plist_problems(plist: dict, label: object, token: object = None) -> list:
     return problems
 
 
+def marker_problem(plist: dict) -> Optional[str]:
+    """What is wrong with the job's supervisor marker (DEC-0057; FAA-05), read the way the copy it starts reads it.
+
+    Without ``FABRIC_SERVICE_SUPERVISOR=launchd`` (or ``--fabric-supervisor launchd``) a copy that finds the
+    lock held exits 75 at once, and KeepAlive starts it again every ThrottleInterval."""
+    env = plist.get("EnvironmentVariables")
+    env = {str(k): str(v) for k, v in env.items()} if isinstance(env, dict) else {}
+    argv = plist.get("ProgramArguments")
+    argv = [str(a) for a in argv] if isinstance(argv, list) else []
+    marker = fs.supervisor_marker(env, argv)
+    if marker["kind"] == "supervised" and marker["manager"] == "launchd":
+        return None
+    fix = ("a copy that finds the lock held exits 75 at once and KeepAlive respawns it every ThrottleInterval; "
+           "regenerate the plist with launchd_plist / launchdPlist and reinstall")
+    if marker["kind"] == "conflict":
+        return "%s — %s" % (fs.marker_conflict_message(marker), fix)
+    if marker["kind"] == "supervised":
+        return "the marker names %s, not launchd — %s" % (marker["manager"], fix)
+    if marker.get("unreadable") is not None:
+        return "the marker %r names no supervisor — %s" % (marker["unreadable"], fix)
+    return "no %s=launchd — %s" % (fs.SUPERVISOR_ENV, fix)
+
+
 def priority_problems(plist: dict) -> list:
     """A service that answers hosts and agents must not be scheduled as background work."""
     out = []
@@ -701,6 +724,9 @@ class Probe:
             return
         problems = plist_problems(plist, life.get("label"), self.token)
         self.add("lifecycle.plist", "FAIL" if problems else "PASS", "; ".join(problems) or "%s: RunAtLoad, KeepAlive, no secrets" % plist_path.name)
+        marker = marker_problem(plist)
+        self.add("lifecycle.supervisor-marker", "FAIL" if marker else "PASS",
+                 marker or "%s: %s=launchd, so a copy that finds the lock held backs off" % (plist_path.name, fs.SUPERVISOR_ENV))
         slow = priority_problems(plist)
         self.add("lifecycle.priority", "FAIL" if slow else "PASS",
                  "; ".join(slow) + " — macOS may starve the service under load and hosts then see an outage; use ProcessType Standard"

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

@@ -2328,3 +2328,185 @@ export function taskUninstall(task, { run = defaultRun, platform = process.platf
   run(['schtasks', '/End', '/TN', task]);
   check(run(['schtasks', '/Delete', '/TN', task, '/F']), 'schtasks /Delete');
 }
+
+// --- launchd (macOS; lifecycle.md "Install, upgrade, uninstall", LC-14; FAA-04) ------------------------------------
+// The twins of fabric_service.launchd_plist / launchd_loaded / launchd_override / launchd_install / launchd_uninstall.
+// `run(argv)` returns spawnSync's {status, stdout, stderr}; the tests pass a launchd stand-in, never the real launchctl.
+
+const LABEL = /^[A-Za-z0-9][A-Za-z0-9._-]{0,250}$/;
+const DEFAULT_PATH = '/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin';
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function launchdLabel(label) {
+  if (!LABEL.test(String(label))) throw new ServiceError(`label must match ${LABEL.source}`);
+  return String(label);
+}
+
+function plistValue(value, depth) {
+  // plistlib.dumps's layout, byte for byte: one tab per level, keys sorted, & < > escaped, empty containers self-closed.
+  const pad = '\t'.repeat(depth);
+  if (value === true || value === false) return `${pad}<${value}/>\n`;
+  if (Number.isInteger(value)) return `${pad}<integer>${value}</integer>\n`;
+  if (typeof value === 'string') return `${pad}<string>${plain(value, 'A plist string').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</string>\n`;
+  if (Array.isArray(value)) return value.length ? `${pad}<array>\n${value.map((v) => plistValue(v, depth + 1)).join('')}${pad}</array>\n` : `${pad}<array/>\n`;
+  const keys = Object.keys(value).sort();
+  if (!keys.length) return `${pad}<dict/>\n`;
+  const inner = keys.map((k) => `${pad}\t<key>${plain(k, 'A plist key').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</key>\n${plistValue(value[k], depth + 1)}`).join('');
+  return `${pad}<dict>\n${inner}${pad}</dict>\n`;
+}
+
+/**
+ * The launchd job: RunAtLoad + KeepAlive true + ThrottleInterval 10, ProcessType Standard, ExitTimeOut above the drain.
+ * FABRIC_SERVICE_SUPERVISOR=launchd tells the lock to back off instead of exiting into a respawn loop (DEC-0057).
+ * No secret is written: an environment name ending TOKEN/SECRET/PASSWORD/KEY (a `*_FILE` path is fine), a value or an
+ * argument shaped like a credential is refused. Returns the XML text, the same bytes Python's plistlib writes.
+ */
+export function launchdPlist(label, programArguments, { workingDirectory, stdoutPath, environment = {}, exitTimeout = DEFAULT_EXIT_TIMEOUT } = {}) {
+  launchdLabel(label);
+  const argv = programArguments.map(String);
+  if (!argv.length) throw new ServiceError('A launchd job starts a program; ProgramArguments is empty.');
+  if (!(exitTimeout > DRAIN_SECONDS)) throw new ServiceError(`ExitTimeOut must outlast the ${DRAIN_SECONDS} s drain.`);
+  if (workingDirectory === undefined || stdoutPath === undefined) throw new ServiceError('A launchd job names its working directory and its log file.');
+  const env = { ...environment };
+  for (const [name, value] of Object.entries(env)) {
+    if (/(TOKEN|SECRET|PASSWORD|KEY)$/.test(name) && !name.endsWith('_FILE')) throw new ServiceError(`Environment variable ${name} looks like a secret; pass a *_FILE path instead.`);
+    if (secretValue(String(value))) throw new ServiceError(`Environment ${name} holds a value shaped like a credential; a plist never carries one.`);
+  }
+  for (const arg of argv) {
+    if (secretArgument(arg)) throw new ServiceError('An argument carries a credential; a plist never does (read it from the token file or a secret reference).');
+  }
+  noMarkerArgument(argv);
+  if (env.PATH === undefined) env.PATH = DEFAULT_PATH;
+  env[SUPERVISOR_ENV] = 'launchd'; // the plist's writer writes the marker, whatever the caller passed
+  const job = {
+    Label: label,
+    ProgramArguments: argv,
+    WorkingDirectory: String(workingDirectory),
+    RunAtLoad: true,
+    KeepAlive: true,
+    ThrottleInterval: 10,
+    ExitTimeOut: Math.trunc(exitTimeout),
+    // Standard, never Background: macOS starves a Background job under load and every host then reports an outage.
+    ProcessType: 'Standard',
+    StandardOutPath: String(stdoutPath),
+    StandardErrorPath: String(stdoutPath),
+    EnvironmentVariables: env,
+  };
+  return '<?xml version="1.0" encoding="UTF-8"?>\n'
+    + '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
+    + `<plist version="1.0">\n${plistValue(job, 0)}</plist>\n`;
+}
+
+function launchdDomain(platform, uid) {
+  // DEC-0032: launchd is macOS's supervisor; Linux has systemd and Windows Task Scheduler.
+  if (platform !== 'darwin') throw new ServiceError('launchd is the supervisor on macOS only; use systemdInstall on Linux and taskInstall on Windows.');
+  return `gui/${uid ?? process.getuid()}`;
+}
+
+/** True when launchd has the job loaded (`launchctl print gui/<uid>/<label>` answers). */
+export function launchdLoaded(label, { run = defaultRun, platform = process.platform, uid } = {}) {
+  return run(['launchctl', 'print', `${launchdDomain(platform, uid)}/${launchdLabel(label)}`])?.status === 0;
+}
+
+const OVERRIDE_ROW = /^\s*"([^"]+)"\s*=>\s*(\S+)\s*$/;
+
+/**
+ * The operator's launchd override for `label`: 'disabled', 'enabled', null when none is recorded (a first install), or
+ * 'unknown' when the table cannot be read. macOS 14+ prints `=> disabled|enabled`, older releases `=> true|false`.
+ */
+export function launchdOverride(label, { run = defaultRun, platform = process.platform, uid } = {}) {
+  const result = run(['launchctl', 'print-disabled', launchdDomain(platform, uid)]);
+  if (result?.status !== 0) return 'unknown';
+  for (const line of String(result.stdout ?? '').split('\n')) {
+    const match = OVERRIDE_ROW.exec(line);
+    if (match && match[1] === label) return ['disabled', 'true'].includes(match[2]) ? 'disabled' : 'enabled';
+  }
+  return null;
+}
+
+async function wellKnownOf(origin) {
+  try {
+    const response = await fetch(`${origin}/.well-known/fabric-service`, { signal: AbortSignal.timeout(2000) });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write and lint the plist, bootout and WAIT for the unload, bootstrap (retrying launchd's EIO 5 times), then poll the
+ * well-known document until it answers with this identity; resolves to that document.
+ *
+ * The operator's intent wins (LC-14): only a first install (no override recorded) enables the label. A label the
+ * operator disabled stays disabled and unloaded — the plist is still rewritten, so the new release is what starts once
+ * they turn it back on — and the answer is {disabled: true, label, plist, loaded}. `forceEnable` is for an operator
+ * who asked for the service to be switched on.
+ */
+export async function launchdInstall(label, plistPath, plistText, { origin, serviceId, instance = 'default', timeout = 40, forceEnable = false,
+  run = defaultRun, platform = process.platform, uid, fetchWellKnown = wellKnownOf, sleep = pause } = {}) {
+  const domain = launchdDomain(platform, uid);
+  launchdLabel(label);
+  if (!origin || !serviceId) throw new ServiceError('launchdInstall needs the origin and the service id it waits to see answer.');
+  const opts = { run, platform, uid };
+  atomicWrite(plistPath, plistText, 0o644);
+  const lint = run(['plutil', '-lint', String(plistPath)]);
+  if (lint?.status !== 0) throw new ServiceError(`plist failed plutil -lint: ${String(lint?.stdout || lint?.stderr || '').trim().slice(0, 200)}`);
+  const target = `${domain}/${label}`;
+  const override = launchdOverride(label, opts);
+  if (forceEnable || override === null) run(['launchctl', 'enable', target]);
+  else if (override === 'disabled') return { disabled: true, label, plist: String(plistPath), loaded: launchdLoaded(label, opts) };
+  run(['launchctl', 'bootout', target]);
+  const unloaded = Date.now() + 15_000;
+  while (launchdLoaded(label, opts) && Date.now() < unloaded) await sleep(250);
+  let last = '';
+  for (let attempt = 0; ; attempt += 1) {
+    const result = run(['launchctl', 'bootstrap', domain, String(plistPath)]);
+    if (result?.status === 0) break;
+    last = String(result?.stderr || result?.stdout || '').trim();
+    if (attempt === 4) throw new ServiceError(`launchctl bootstrap failed: ${last.slice(0, 200)}`);
+    await sleep(1000);
+  }
+  const deadline = Date.now() + timeout * 1000;
+  while (Date.now() < deadline) {
+    const doc = await fetchWellKnown(origin);
+    if (doc?.service?.id === serviceId && doc?.service?.instance === instance) return doc;
+    await sleep(500);
+  }
+  throw new ServiceError(`${origin} did not answer as ${serviceId}.${instance} within ${timeout} s; read its log.`);
+}
+
+/**
+ * Symmetric with launchdInstall (LC-14): bootout and WAIT until the job is gone, remove the plist, and reset the
+ * override to enabled — launchctl has no verb that deletes an override, and a leftover `disabled` would keep a later
+ * fresh install off. Data stays unless `purge` (then `serviceId` names whose data, logs and cache go). A job still
+ * loaded at `timeout` seconds throws, leaving the plist and the data in place.
+ */
+export async function launchdUninstall(label, plistPath, { timeout = 30, purge = false, serviceId, run = defaultRun, platform = process.platform, uid, sleep = pause } = {}) {
+  const domain = launchdDomain(platform, uid);
+  launchdLabel(label);
+  if (purge && !serviceId) throw new ServiceError('purge needs the service id whose data, logs and cache to remove.');
+  const dirs = purge ? serviceDirs(serviceId, platform) : {};
+  const opts = { run, platform, uid };
+  const target = `${domain}/${label}`;
+  run(['launchctl', 'bootout', target]);
+  const deadline = Date.now() + timeout * 1000;
+  while (launchdLoaded(label, opts)) {
+    if (Date.now() >= deadline) throw new ServiceError(`launchd job ${label} is still loaded ${timeout} s after bootout; nothing was removed.`);
+    await sleep(100);
+  }
+  let plistRemoved = true;
+  try {
+    fs.unlinkSync(plistPath);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    plistRemoved = false;
+  }
+  run(['launchctl', 'enable', target]);
+  const purged = [];
+  for (const dir of Object.values(dirs)) {
+    try { fs.lstatSync(dir); } catch { continue; }
+    fs.rmSync(dir, { recursive: true, force: true }); // a symlinked folder: the link goes, never what it points at
+    purged.push(dir);
+  }
+  return { unloaded: true, plistRemoved, override: 'enabled', purged };
+}

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

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

package/plugins/fabric-agent-adapter/skills/working-with-fabric/SKILL.md

@@ -19,7 +19,7 @@ compatibility: >-
   this plugin; Codex and Kimi Code get the session-start preamble hook on the person's consent.
 metadata:
   author: PassionCode.ai
-  version: "0.29.0"
+  version: "0.30.0"
 ---
 
 # Working with Fabric

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session.py

@@ -60,7 +60,7 @@ WATCH_MAX_BACKOFF_S = 900
 SESSION_ID = re.compile(r"[A-Za-z0-9._:-]{1,128}")
 LOOPBACK_ORIGIN = re.compile(r"http://127\.0\.0\.1:(\d{1,5})")
 LOCAL_ORIGIN = re.compile(r'"origin": "http://(?:127\.0\.0\.1|localhost)')
-VERSION = "0.29.0"
+VERSION = "0.30.0"
 HOSTS = {"claude": "Claude Code", "codex": "Codex", "kimi": "Kimi Code"}
 # A session Fabric launched. FABRIC_LAUNCHED_SESSION=1 is the marker Fabric is asked to set (need D6); the others are
 # what Fabric already gives a launched session (fabric sessionBundle.ts): only their NAMES are looked at, never a value