@alfe.ai/integrations 0.4.1 → 0.5.0

package/dist/index.d.ts

@@ -1508,6 +1508,203 @@ declare class HermesMcpSync {
  */
 declare function upsertEnvVar(envPath: string, key: string, value: string): boolean;
 //#endregion
+//#region src/appliers/claude-code-applier.d.ts
+interface ClaudeCodeApplierOptions {
+  /**
+   * Path to the claude-code home directory (e.g. ~/.claude-code) — where the
+   * config ledger and the generated `--mcp-config` live. For claude-code,
+   * home == workspace.
+   */
+  home?: string;
+  /**
+   * @deprecated Use `home`. Kept for parity with the OpenClaw/Hermes applier
+   * option shape — when set, used as `home`.
+   */
+  workspace?: string;
+  /** Path to the per-integration config ledger (defaults to {home}/.alfe-integrations.json). */
+  configPath?: string;
+  /**
+   * Path to Claude Code's native skills directory (defaults to
+   * ~/.claude/skills). Override for tests.
+   */
+  skillsDir?: string;
+}
+declare class ClaudeCodeApplier implements RuntimeApplier {
+  readonly runtime = "claude-code";
+  private home;
+  /** `~/.claude-code/.alfe-integrations.json` — per-integration config ledger + raw-key store. */
+  private ledgerPath;
+  /** `~/.claude/skills` — where native Claude Code skills are copied. */
+  private skillsDir;
+  constructor(options?: ClaudeCodeApplierOptions);
+  /**
+   * Record an integration's config contribution in the ledger. Claude Code has
+   * no integration-config CLI, so this is a pure ledger write — it makes the
+   * per-integration accounting honest (so `removeConfig` and the lock's
+   * config-only tracking work) without shelling anything. Overwrites the prior
+   * contribution for this integration (convergent by construction — a full
+   * replace, no stale-key diff needed since nothing is applied to a runtime).
+   */
+  applyConfig(integrationId: string, config: Record<string, unknown>): Promise<void>;
+  /** Clear an integration's config contribution from the ledger. */
+  removeConfig(integrationId: string): Promise<void>;
+  /**
+   * Raw single-key config write for the daemon's `alfe.config_set` cloud-command.
+   *
+   * Deliberately bypasses the `_integrations` per-integration accounting (a raw
+   * set is untracked — routing it through `applyConfig` would corrupt an
+   * integration's removal accounting). Stored under a separate `_raw` map in the
+   * same ledger file. Inert as far as the runtime goes (Claude Code has no config
+   * CLI to push it into), but it degrades cleanly — the daemon gets an OK ack
+   * instead of `CONFIG_SET_UNSUPPORTED`, and the value round-trips via
+   * `getConfigRaw`.
+   */
+  setConfigRaw(key: string, value: string): Promise<void>;
+  /**
+   * Read a raw config key back from the ledger — the untracked read companion to
+   * `setConfigRaw`, used by the daemon's config-reconcile pass (value-diff before
+   * write; verify a write landed). Returns the exact string `setConfigRaw` stored,
+   * or `undefined` when the key was never set. Never throws.
+   */
+  getConfigRaw(key: string): Promise<string | undefined>;
+  /**
+   * Apply a plugin. The `@alfe.ai/openclaw-*` npm plugins are OpenClaw-specific
+   * and do NOT load in Claude Code — log + skip them. No claude-code-native
+   * plugin spec exists, so any non-openclaw spec is also skipped (rather than a
+   * blind shell of an unknown installer). The manager catches per-plugin, so a
+   * skip here is a correct no-op.
+   */
+  applyPlugin(spec: string): Promise<void>;
+  /** Remove a plugin. Nothing was installed (applyPlugin skipped it) — no-op log. */
+  removePlugin(spec: string): Promise<void>;
+  /**
+   * Copy a skill directory into `~/.claude/skills/<name>/`. Claude Code reads
+   * native Agent Skills from there, so an Alfe skill dir lands as a first-class
+   * Claude Code skill. Idempotent: an existing target is replaced (a
+   * newer-version re-apply must overwrite).
+   */
+  applySkill(name: string, srcPath: string): Promise<void>;
+  /** Remove a skill directory from `~/.claude/skills/<name>/`. */
+  removeSkill(name: string): Promise<void>;
+  /**
+   * Install a ClawHub skill natively. ClawHub is an OpenClaw registry, but the
+   * skill payload is a plain directory — for claude-code we treat the slug as the
+   * skill name and expect the caller to have staged the directory. Absent a
+   * staged source we log + skip (no OpenClaw `skills install` CLI on this
+   * runtime); a future claude-code ClawHub fetch would stage the dir then copy it
+   * exactly like `applySkill`.
+   *
+   * NOTE: unlike OpenClaw's `applyClawHubSkill` (which THROWS on a real install
+   * failure so an all-skills-fail activation is marked `error`), there is no
+   * install to fail here — the skill either lands from a staged directory or is a
+   * clean no-op. We never throw for a claude-code ClawHub skill.
+   */
+  applyClawHubSkill(slug: string): Promise<void>;
+  /** Remove a ClawHub-installed skill directory (by slug == dir name). */
+  removeClawHubSkill(slug: string): Promise<void>;
+  isAvailable(): Promise<boolean>;
+  private copySkillDir;
+  private deleteSkillDir;
+  private readLedger;
+  private writeLedger;
+}
+//#endregion
+//#region src/appliers/claude-code-mcp-sync.d.ts
+interface ClaudeCodeMcpSyncOptions {
+  /** The runtime-agnostic MCP store manager (read + onChange). */
+  manager: McpStoreReader;
+  /** Claude-code home (== ~/.claude-code). mcp-config.json lives here. */
+  home?: string;
+  /**
+   * The `ALFE_API_KEY` value injected into every generated stdio server's env so
+   * the Alfe MCP servers resolve their provider credentials. In managed mode
+   * this is the daemon's own api key; self-hosted threads it explicitly. When
+   * absent, injection is skipped and a warning is logged (the servers would then
+   * start in zero-accounts degraded mode). Unlike Hermes there is no `.env`
+   * side-file — the value is written directly into the generated env block.
+   */
+  apiKey?: string;
+  /**
+   * Trigger a runtime reload after a real change. Accepted for parity with
+   * `HermesMcpSyncOptions` so the daemon can wire claude-code identically — but
+   * Claude Code reads `--mcp-config` fresh per `claude -p` spawn, so this sync
+   * NEVER calls it. Kept optional and unused; see the file header.
+   */
+  requestRestart?: () => void;
+  /** Override the mcp-config.json path (defaults to {home}/mcp-config.json). For tests. */
+  configPath?: string;
+  /**
+   * Override the sidecar that records which `mcpServers` ids this sync wrote
+   * (defaults to {home}/.alfe-mcp-synced.json). Used so removals survive daemon
+   * restarts (a full regenerate makes it strictly informational here, but kept
+   * for parity + forensics).
+   */
+  trackingPath?: string;
+  /**
+   * Trailing debounce (ms) used to coalesce a burst of store mutations (one
+   * integration install fires `addServer` once per server) into a single file
+   * write, avoiding a write storm. Default 250; set 0 in tests. The initial sync
+   * in `start()` is always immediate.
+   */
+  debounceMs?: number;
+}
+/**
+ * Full-regenerate writer of the MCP store into `~/.claude-code/mcp-config.json`.
+ *
+ * Ownership / removal model: every entry returned by `manager.listServers()`
+ * comes from the Alfe store (its `owner` is `integration:<id>` / `cli` /
+ * `manual`) and is therefore Alfe-owned. Unlike the Hermes config.yaml mirror
+ * (which must preserve user-authored `mcp_servers` in a shared file), the
+ * `--mcp-config` file is Alfe-generated and Alfe-owned end to end — Claude Code's
+ * OWN user-authored MCP servers live in `~/.claude.json` / project `.mcp.json`,
+ * NOT this generated file. So we fully regenerate it from the store on every
+ * change (no read-merge-write needed). We still persist the written-id set to a
+ * sidecar for parity + forensics, but removal is implicit in the regenerate.
+ */
+declare class ClaudeCodeMcpSync {
+  private readonly manager;
+  private readonly home;
+  private readonly apiKey?;
+  private readonly configPath;
+  private readonly trackingPath;
+  private readonly debounceMs;
+  /** Ids of `mcpServers` entries this sync last wrote — informational sidecar. */
+  private syncedIds;
+  /** Serializes syncs so two onChange-driven runs can't interleave file writes. */
+  private queue;
+  private unsubscribe?;
+  private debounceTimer?;
+  private started;
+  constructor(opts: ClaudeCodeMcpSyncOptions);
+  /**
+   * Begin mirroring: load the prior removal set, run one immediate sync (so the
+   * `--mcp-config` file reflects the current store before the host next spawns
+   * `claude -p`), then subscribe to store changes (debounced). Idempotent.
+   */
+  start(): void;
+  /** Stop subscribing and cancel any pending debounced sync. Idempotent. */
+  stop(): void;
+  /**
+   * Regenerate the `--mcp-config` file from the current store exactly once.
+   * Public so the daemon (and tests) can await a deterministic sync. Serialized
+   * against any other in-flight sync.
+   */
+  syncOnce(): Promise<void>;
+  private schedule;
+  private syncNow;
+  private computeDesired;
+  /**
+   * Transform a stored entry into a Claude Code `--mcp-config` entry. stdio
+   * entries get the literal `ALFE_API_KEY` injected; remote entries pass through
+   * with the documented `type` discriminator (`sse` → `sse`, `streamable-http`
+   * → `http`).
+   */
+  private toClaudeCodeEntry;
+  private withAlfeApiKey;
+  private loadSyncedIds;
+  private persistSyncedIds;
+}
+//#endregion
 //#region src/lock.d.ts
 interface RuntimePluginEntry {
   /**
@@ -1677,4 +1874,4 @@ declare class IntegrationManagerAdapter implements IIntegrationManager {
   resetReinstallAttempts(integrationId: string): void;
 }
 //#endregion
-export { type CredentialsResolver, DEFAULT_REGISTRY_TTL_MS, HermesApplier, type HermesApplierOptions, HermesMcpSync, type HermesMcpSyncOptions, type HookEnvOptions, type HookResult, type IIntegrationManager, type InstalledInfo, Installer, InstallerError, type IntegrationConfigureParams, type IntegrationHealthParams, type IntegrationInfo, type IntegrationInstallParams, IntegrationManager, IntegrationManagerAdapter, type IntegrationManagerOptions, type IntegrationRemoveParams, type LoadOptions, LockManager, McpApplier, type McpApplierOptions, type McpStoreReader, NoopOpenClawCliLock, OpenClawApplier, type OpenClawApplierOptions, type OpenClawCliLock, type PlatformContext, Registry, type RegistryEntry, type RegistryFetcher, type RegistryIndex, type RegistryOptions, RegistryResolveError, type ResolveOptions, type ResolvedIntegration, Resolver, type RuntimeApplier, type RuntimeConfigEntry, type RuntimeDesiredState, type RuntimeLockFile, type RuntimePluginEntry, type RuntimeSkillEntry, SerialOpenClawCliLock, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext, upsertEnvVar };
+export { ClaudeCodeApplier, type ClaudeCodeApplierOptions, ClaudeCodeMcpSync, type ClaudeCodeMcpSyncOptions, type CredentialsResolver, DEFAULT_REGISTRY_TTL_MS, HermesApplier, type HermesApplierOptions, HermesMcpSync, type HermesMcpSyncOptions, type HookEnvOptions, type HookResult, type IIntegrationManager, type InstalledInfo, Installer, InstallerError, type IntegrationConfigureParams, type IntegrationHealthParams, type IntegrationInfo, type IntegrationInstallParams, IntegrationManager, IntegrationManagerAdapter, type IntegrationManagerOptions, type IntegrationRemoveParams, type LoadOptions, LockManager, McpApplier, type McpApplierOptions, type McpStoreReader, NoopOpenClawCliLock, OpenClawApplier, type OpenClawApplierOptions, type OpenClawCliLock, type PlatformContext, Registry, type RegistryEntry, type RegistryFetcher, type RegistryIndex, type RegistryOptions, RegistryResolveError, type ResolveOptions, type ResolvedIntegration, Resolver, type RuntimeApplier, type RuntimeConfigEntry, type RuntimeDesiredState, type RuntimeLockFile, type RuntimePluginEntry, type RuntimeSkillEntry, SerialOpenClawCliLock, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext, upsertEnvVar };

package/dist/index.js

@@ -3,7 +3,7 @@ import { promisify } from "node:util";
 import { randomBytes } from "node:crypto";
 import { basename, dirname, join } from "node:path";
 import { homedir, platform, tmpdir } from "node:os";
-import { closeSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { buildConfigValidationSchema, parseManifestFile } from "@alfe.ai/integration-manifest";
 import { createLogger } from "@auriclabs/logger";
 import { parseDocument } from "yaml";
@@ -153,7 +153,7 @@ var Resolver = class {
 * can resolve them via Node's upward module resolution.
 */
 const execFileAsync$2 = promisify(execFile);
-const log$4 = createLogger("Installer");
+const log$6 = createLogger("Installer");
 const INTEGRATIONS_DIR = join(homedir(), ".alfe", "integrations");
 const GIT_TIMEOUT_MS = 6e4;
 const NPM_TIMEOUT_MS = 6e4;
@@ -342,7 +342,7 @@ var Installer = class {
 					force: true
 				});
 			} catch (err) {
-				log$4.warn({
+				log$6.warn({
 					dir: entry.name,
 					err: err instanceof Error ? err.message : String(err)
 				}, "Failed to sweep orphaned staging dir");
@@ -397,7 +397,7 @@ var Installer = class {
 			dependencies: { ...SHARED_PACKAGES }
 		};
 		writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf-8");
-		log$4.info("Installing shared @alfe.ai packages for integration hooks");
+		log$6.info("Installing shared @alfe.ai packages for integration hooks");
 		await this.runNpmInstall(this.basePath);
 		this.sharedPackagesReady = true;
 	}
@@ -407,7 +407,7 @@ var Installer = class {
 	*/
 	async installLocalDependencies(installPath) {
 		if (!existsSync(join(installPath, "package.json"))) return;
-		log$4.info({ path: installPath }, "Installing integration-specific npm dependencies");
+		log$6.info({ path: installPath }, "Installing integration-specific npm dependencies");
 		await this.runNpmInstall(installPath);
 	}
 	async runNpmInstall(cwd) {
@@ -1302,15 +1302,27 @@ var IntegrationManager = class {
 				}
 				if (pluginFailures.length > 0 && pluginFailures.length === plugins.length) throw new Error(`All plugins failed to install: ${pluginFailures.join(", ")}`);
 				if (pluginFailures.length > 0) this.log.warn(`Continuing activation with ${String(pluginFailures.length)} failed plugin(s): ${pluginFailures.join(", ")}`);
-				for (const skill of skills) if (skill.clawhub) {
-					this.log.info(`Installing ClawHub skill ${skill.clawhub} to ${runtimeName}`);
-					await applier.applyClawHubSkill(skill.clawhub);
-				} else if (skill.path) {
-					const skillName = skill.path.split("/").pop() ?? skill.path;
-					const srcPath = join(installPath, skill.path);
-					this.log.info(`Applying skill ${skillName} to ${runtimeName}`);
-					await applier.applySkill(skillName, srcPath);
+				const skillFailures = [];
+				for (const skill of skills) {
+					const skillLabel = skill.clawhub ?? skill.path ?? "unknown";
+					try {
+						if (skill.clawhub) {
+							this.log.info(`Installing ClawHub skill ${skill.clawhub} to ${runtimeName}`);
+							await applier.applyClawHubSkill(skill.clawhub);
+						} else if (skill.path) {
+							const skillName = skill.path.split("/").pop() ?? skill.path;
+							const srcPath = join(installPath, skill.path);
+							this.log.info(`Applying skill ${skillName} to ${runtimeName}`);
+							await applier.applySkill(skillName, srcPath);
+						}
+					} catch (err) {
+						const msg = err instanceof Error ? err.message : String(err);
+						this.log.error(`Failed to apply skill ${skillLabel}: ${msg}`);
+						skillFailures.push(skillLabel);
+					}
 				}
+				if (skillFailures.length > 0 && skillFailures.length === skills.length) throw new Error(`All skills failed to install: ${skillFailures.join(", ")}`);
+				if (skillFailures.length > 0) this.log.warn(`Continuing activation with ${String(skillFailures.length)} failed skill(s): ${skillFailures.join(", ")}`);
 				let runtimeConfigApplied = false;
 				if (runtimeConfig && Object.keys(runtimeConfig).length > 0) {
 					const agentConfig = entry.config;
@@ -2086,7 +2098,7 @@ function partitionEntries(entries) {
 * is stored in a separate tracking file (config.json) for clean removal.
 */
 const execFileAsync$1 = promisify(execFile);
-const log$3 = createLogger("OpenClawApplier");
+const log$5 = createLogger("OpenClawApplier");
 const DEFAULT_SKILLS_DIR = join(homedir(), ".alfe", "skills");
 /**
 * Bundled OpenClaw plugins that ship inside the runtime (not installed as npm
@@ -2113,6 +2125,22 @@ const BUNDLED_BASELINE_ALLOW = ["browser"];
 const CONFIG_SET_RETRIES$1 = 3;
 const CONFIG_SET_RETRY_DELAY_MS$1 = 750;
 /**
+* Boot-safe exec timeout for the OUT-OF-BAND `setConfigRaw` write (the daemon's
+* config-reconcile pass / `alfe.config_set`). Unlike integration `applyConfig`,
+* which runs under the gateway RuntimeGate with the runtime SUSPENDED (no CPU
+* contention, so the 10s execFile default is plenty), `setConfigRaw` fires while
+* `openclaw gateway run` is live and — on a fresh managed box — still BOOTING.
+* On a 2-vCPU Hetzner cx-class instance the `openclaw config set` CLI cold-start
+* takes >10s under that boot contention, so the 10s default SIGKILLs the child
+* mid-write and every retry lands inside the same ~30s boot window and times out
+* identically (observed in prod: two `config set agents.defaults.model` attempts
+* logged exactly 10s apart with no exit line, then a 3rd succeeded once load
+* eased). 60s clears the cold-start-under-contention worst case while still
+* bounding a genuinely hung CLI. This is ONLY for `setConfigRaw` — the
+* integration `applyConfig` paths keep the 10s default (they're not contended).
+*/
+const CONFIG_SET_RAW_TIMEOUT_MS = 6e4;
+/**
 * Max `openclaw config get` spawns in flight at once during the batch
 * verify-after-write. A naive `Promise.all(leaves.map(...))` fires one CLI
 * process per leaf simultaneously — a 36-leaf model-provider batch on a 2-vCPU
@@ -2481,7 +2509,7 @@ var OpenClawApplier = class {
 			return;
 		} catch (err) {
 			if (!isMalformedStateDbError(err)) throw err;
-			log$3.warn({ args: args.slice(0, 2) }, "openclaw CLI failed with a malformed state DB — attempting self-heal then one retry");
+			log$5.warn({ args: args.slice(0, 2) }, "openclaw CLI failed with a malformed state DB — attempting self-heal then one retry");
 			if (!await this.healMalformedStateDb()) throw err;
 			await execFileAsync$1("openclaw", args, opts);
 		}
@@ -2507,7 +2535,7 @@ var OpenClawApplier = class {
 	async healMalformedStateDb() {
 		const now = Date.now();
 		if (now - this.lastHealAt < HEAL_MIN_INTERVAL_MS) {
-			log$3.warn({ sinceLastHealMs: now - this.lastHealAt }, "openclaw state DB malformed but a heal ran within the rate-limit window — skipping to avoid a heal→corrupt→heal loop");
+			log$5.warn({ sinceLastHealMs: now - this.lastHealAt }, "openclaw state DB malformed but a heal ran within the rate-limit window — skipping to avoid a heal→corrupt→heal loop");
 			return false;
 		}
 		this.lastHealAt = now;
@@ -2527,19 +2555,19 @@ var OpenClawApplier = class {
 				quarantined.push(dest);
 			}
 			if (quarantined.length === 0) {
-				log$3.warn({ stateDir }, "malformed openclaw state DB reported but no state/openclaw.sqlite* files found to quarantine");
+				log$5.warn({ stateDir }, "malformed openclaw state DB reported but no state/openclaw.sqlite* files found to quarantine");
 				this.lastHealAt = now - HEAL_MIN_INTERVAL_MS + FAILED_HEAL_COOLDOWN_MS;
 				return false;
 			}
-			log$3.warn({
+			log$5.warn({
 				stateDir,
 				quarantined
 			}, "quarantined malformed openclaw state DB — recreating via `openclaw plugins list` (upstream openclaw/openclaw#71689)");
 			await execFileAsync$1("openclaw", ["plugins", "list"], { timeout: 9e4 });
-			log$3.warn({ stateDir }, "recreated openclaw state DB after quarantine");
+			log$5.warn({ stateDir }, "recreated openclaw state DB after quarantine");
 			return true;
 		} catch (err) {
-			log$3.warn({
+			log$5.warn({
 				stateDir,
 				quarantined,
 				err: err instanceof Error ? err.message : String(err)
@@ -2556,7 +2584,7 @@ var OpenClawApplier = class {
 		const pinnedVersion = pluginSpecVersion(spec);
 		const claim = this.appliedPluginPins.get(pkg);
 		if (pinnedVersion !== void 0 && claim !== void 0 && claim.version !== pinnedVersion && claim.integrationId !== opts?.integrationId) {
-			log$3.warn({
+			log$5.warn({
 				pkg,
 				requestedVersion: pinnedVersion,
 				keptVersion: claim.version,
@@ -2571,7 +2599,7 @@ var OpenClawApplier = class {
 			const installedVersion = this.installedPluginVersion(pkg);
 			const versionsComparable = pinnedVersion !== void 0 && installedVersion !== void 0;
 			if (versionsComparable && installedVersion === pinnedVersion) {
-				if (opts?.force) log$3.info({
+				if (opts?.force) log$5.info({
 					pkg,
 					spec,
 					version: installedVersion
@@ -2583,7 +2611,7 @@ var OpenClawApplier = class {
 				this.recordPluginPin(pkg, pinnedVersion, opts?.integrationId);
 				return;
 			}
-			log$3.info({
+			log$5.info({
 				pkg,
 				spec,
 				installedVersion,
@@ -2593,7 +2621,7 @@ var OpenClawApplier = class {
 			try {
 				await this.removePluginUnlocked(pkg);
 			} catch (err) {
-				log$3.warn({
+				log$5.warn({
 					pkg,
 					spec,
 					err: err instanceof Error ? err.message : String(err)
@@ -2615,7 +2643,7 @@ var OpenClawApplier = class {
 				} catch (err) {
 					const errText = err instanceof Error ? `${err.message}\n${err.stderr ?? ""}` : String(err);
 					if (useUnsafeFlag && errText.includes("unknown option")) {
-						log$3.info({ pkg }, "OpenClaw does not support --dangerously-force-unsafe-install, retrying without");
+						log$5.info({ pkg }, "OpenClaw does not support --dangerously-force-unsafe-install, retrying without");
 						await this.execOpenClawHealing(baseArgs, { timeout: 6e4 });
 					} else throw err;
 				}
@@ -2624,7 +2652,7 @@ var OpenClawApplier = class {
 					setTimeout(r, 500);
 				});
 				if (!this.isPluginInstalled(pkg)) throw err;
-				log$3.warn({
+				log$5.warn({
 					pkg,
 					spec,
 					err: err instanceof Error ? err.message : String(err)
@@ -2687,7 +2715,7 @@ var OpenClawApplier = class {
 		const missing = [...new Set([...wanted, ...BUNDLED_BASELINE_ALLOW])].filter((id) => !currentAllow.includes(id));
 		if (missing.length === 0) return;
 		if (!readTrustworthy) {
-			log$3.warn({
+			log$5.warn({
 				pkgs: wanted,
 				missing
 			}, "plugins.allow read was not trustworthy (non-empty parse failure or command error) — skipping the allow-list write to avoid replacing a value not proven to be a superset");
@@ -2701,7 +2729,7 @@ var OpenClawApplier = class {
 				"--replace"
 			]);
 		} catch (err) {
-			log$3.warn({
+			log$5.warn({
 				err: err instanceof Error ? err.message : String(err),
 				pkgs: wanted
 			}, "Failed to set plugins.allow via openclaw config set");
@@ -2786,12 +2814,12 @@ var OpenClawApplier = class {
 					recursive: true,
 					force: true
 				});
-				log$3.info({
+				log$5.info({
 					pkg,
 					removed: fullPath
 				}, "Removed untracked extensions/ install — will reinstall via npm path");
 			} catch (err) {
-				log$3.warn({
+				log$5.warn({
 					pkg,
 					removed: fullPath,
 					err: err instanceof Error ? err.message : String(err)
@@ -2825,24 +2853,25 @@ var OpenClawApplier = class {
 	}
 	applyClawHubSkill(slug) {
 		return this.cliLock.run(async () => {
-			log$3.info({ slug }, "Installing skill from ClawHub");
+			log$5.info({ slug }, "Installing skill from ClawHub");
 			try {
 				await execFileAsync$1("openclaw", [
 					"skills",
 					"install",
 					slug
 				], { timeout: 6e4 });
-				log$3.info({ slug }, "ClawHub skill installed");
+				log$5.info({ slug }, "ClawHub skill installed");
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err);
 				if (msg.includes("already exists") || msg.includes("Skill already exists")) {
-					log$3.info({ slug }, "ClawHub skill already installed (skipped)");
+					log$5.info({ slug }, "ClawHub skill already installed (skipped)");
 					return;
 				}
-				log$3.error({
+				log$5.error({
 					slug,
 					err: msg
 				}, "ClawHub skill install failed");
+				throw new Error(`ClawHub skill install failed for "${slug}": ${msg}`);
 			}
 		});
 	}
@@ -2853,7 +2882,7 @@ var OpenClawApplier = class {
 				recursive: true,
 				force: true
 			});
-			log$3.info({ slug }, "ClawHub skill removed");
+			log$5.info({ slug }, "ClawHub skill removed");
 		}
 		return Promise.resolve();
 	}
@@ -2908,10 +2937,10 @@ var OpenClawApplier = class {
 					const after = await readParentObject(parentPath);
 					return [...dottedKvs.entries()].every(([k, v]) => deepSubset(v, after[k]));
 				})) {
-					log$3.warn({ parentPath }, "openclaw config set exited non-zero but config landed — continuing");
+					log$5.warn({ parentPath }, "openclaw config set exited non-zero but config landed — continuing");
 					continue;
 				}
-				log$3.error({
+				log$5.error({
 					err: err instanceof Error ? err.message : String(err),
 					parentPath
 				}, "Failed to set config subtree via openclaw config set");
@@ -2927,9 +2956,9 @@ var OpenClawApplier = class {
 		} catch (err) {
 			if (await this.verifyApplied(async () => {
 				return (await mapWithConcurrency(leaves, VERIFY_GET_CONCURRENCY, (l) => this.configValueMatches(l.path, l.value))).every(Boolean);
-			})) log$3.warn({ count: leaves.length }, "openclaw config set --batch-json exited non-zero but config landed — continuing");
+			})) log$5.warn({ count: leaves.length }, "openclaw config set --batch-json exited non-zero but config landed — continuing");
 			else {
-				log$3.error({
+				log$5.error({
 					err: err instanceof Error ? err.message : String(err),
 					batch: leaves
 				}, "Failed to set config via openclaw config set --batch-json");
@@ -2981,7 +3010,7 @@ var OpenClawApplier = class {
 				"--replace"
 			]);
 		} catch (err) {
-			log$3.warn({
+			log$5.warn({
 				err: err instanceof Error ? err.message : String(err),
 				parentPath
 			}, "Failed to update parent config during subtree key drop");
@@ -3019,19 +3048,19 @@ var OpenClawApplier = class {
 				unsetParents.add(parentPath);
 				try {
 					await this.runConfigCommandUnlocked(["unset", parentPath]);
-					log$3.warn({
+					log$5.warn({
 						path,
 						parentPath
 					}, "Leaf unset rejected as an invalid partial custom provider — unset the parent subtree instead");
 				} catch (parentErr) {
-					log$3.warn({
+					log$5.warn({
 						err: parentErr instanceof Error ? parentErr.message : String(parentErr),
 						parentPath
 					}, "Failed to unset parent subtree after an invalid-partial leaf unset");
 				}
 				return;
 			}
-			log$3.warn({
+			log$5.warn({
 				err: err instanceof Error ? err.message : String(err),
 				path
 			}, "Failed to unset config via openclaw config unset");
@@ -3048,7 +3077,7 @@ var OpenClawApplier = class {
 	* config writes trigger.
 	*/
 	setConfigRaw(key, value) {
-		return this.cliLock.run(() => this.runConfigSetUnlocked([key, value]));
+		return this.cliLock.run(() => this.runConfigSetUnlocked([key, value], { timeout: CONFIG_SET_RAW_TIMEOUT_MS }));
 	}
 	/**
 	* Read a single config key back — `openclaw config get <key>` — and normalize
@@ -3137,7 +3166,7 @@ var OpenClawApplier = class {
 *    config + plugins only.
 */
 const execFileAsync = promisify(execFile);
-const log$2 = createLogger("HermesApplier");
+const log$4 = createLogger("HermesApplier");
 const DEFAULT_HERMES_HOME$1 = join(homedir(), ".hermes");
 /**
 * Hermes config writes are serialized through one promise chain so concurrent
@@ -3155,7 +3184,7 @@ const delay = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
 /** `@alfe.ai/openclaw-*` packages are OpenClaw-specific plugins — not Hermes. */
-function isOpenClawPlugin(spec) {
+function isOpenClawPlugin$1(spec) {
 	return stripPluginVersion(spec).startsWith("@alfe.ai/openclaw-");
 }
 /**
@@ -3227,7 +3256,7 @@ var HermesApplier = class {
 			if (staleLeafPaths.length > 0) try {
 				await this.deleteConfigKeys(staleLeafPaths);
 			} catch (err) {
-				log$2.warn({
+				log$4.warn({
 					err: err instanceof Error ? err.message : String(err),
 					integrationId
 				}, "Failed to delete stale Hermes config keys during applyConfig diff");
@@ -3236,7 +3265,7 @@ var HermesApplier = class {
 				const nextKvs = subtreesByParent.get(parent);
 				return [...prevKvs.keys()].some((k) => !nextKvs?.has(k));
 			}).map(([parent]) => parent);
-			if (staleSubtreeParents.length > 0) log$2.warn({
+			if (staleSubtreeParents.length > 0) log$4.warn({
 				integrationId,
 				parents: staleSubtreeParents
 			}, "Hermes applyConfig diff: skipping stale dotted-key subtree(s) — OpenClaw-plugin-shaped config does not apply to Hermes");
@@ -3244,14 +3273,14 @@ var HermesApplier = class {
 		integrations[integrationId] = config;
 		tracking._integrations = integrations;
 		this.writeTracking(tracking);
-		if (subtreesByParent.size > 0) log$2.warn({
+		if (subtreesByParent.size > 0) log$4.warn({
 			integrationId,
 			parents: [...subtreesByParent.keys()]
 		}, "Hermes applyConfig: skipping dotted-key subtree(s) — OpenClaw-plugin-shaped config does not apply to Hermes");
 		for (const { path, value } of leaves) try {
 			await this.runConfigSet([path, stringifyConfigValue(value)]);
 		} catch (err) {
-			log$2.error({
+			log$4.error({
 				err: err instanceof Error ? err.message : String(err),
 				key: path
 			}, "Failed to set config via hermes config set");
@@ -3274,7 +3303,7 @@ var HermesApplier = class {
 		try {
 			await this.deleteConfigKeys(leaves.map(({ path }) => path));
 		} catch (err) {
-			log$2.warn({
+			log$4.warn({
 				err: err instanceof Error ? err.message : String(err),
 				integrationId
 			}, "Failed to delete Alfe config keys from ~/.hermes/config.yaml");
@@ -3338,11 +3367,11 @@ var HermesApplier = class {
 	* one in Phase 1, so this path is a real attempt (not faked) but untrodden.
 	*/
 	async applyPlugin(spec) {
-		if (isOpenClawPlugin(spec)) {
-			log$2.info({ spec }, "Hermes applyPlugin: skipping OpenClaw-specific npm plugin (not a Hermes plugin)");
+		if (isOpenClawPlugin$1(spec)) {
+			log$4.info({ spec }, "Hermes applyPlugin: skipping OpenClaw-specific npm plugin (not a Hermes plugin)");
 			return;
 		}
-		log$2.info({ spec }, "Hermes applyPlugin: installing native Hermes plugin");
+		log$4.info({ spec }, "Hermes applyPlugin: installing native Hermes plugin");
 		await execFileAsync("hermes", [
 			"plugins",
 			"install",
@@ -3360,11 +3389,11 @@ var HermesApplier = class {
 	* Hermes plugin would be disabled via `hermes plugins`.
 	*/
 	async removePlugin(spec) {
-		if (isOpenClawPlugin(spec)) {
-			log$2.info({ spec }, "Hermes removePlugin: skipping OpenClaw-specific npm plugin (was never installed on Hermes)");
+		if (isOpenClawPlugin$1(spec)) {
+			log$4.info({ spec }, "Hermes removePlugin: skipping OpenClaw-specific npm plugin (was never installed on Hermes)");
 			return;
 		}
-		log$2.info({ spec }, "Hermes removePlugin: disabling native Hermes plugin");
+		log$4.info({ spec }, "Hermes removePlugin: disabling native Hermes plugin");
 		await execFileAsync("hermes", [
 			"plugins",
 			"disable",
@@ -3372,19 +3401,19 @@ var HermesApplier = class {
 		], { timeout: 3e4 });
 	}
 	applySkill(name) {
-		log$2.info({ name }, "Hermes applySkill: no-op (Hermes built-in skills; deferred)");
+		log$4.info({ name }, "Hermes applySkill: no-op (Hermes built-in skills; deferred)");
 		return Promise.resolve();
 	}
 	removeSkill(name) {
-		log$2.info({ name }, "Hermes removeSkill: no-op (Hermes built-in skills; deferred)");
+		log$4.info({ name }, "Hermes removeSkill: no-op (Hermes built-in skills; deferred)");
 		return Promise.resolve();
 	}
 	applyClawHubSkill(slug) {
-		log$2.info({ slug }, "Hermes applyClawHubSkill: no-op (ClawHub is OpenClaw-only)");
+		log$4.info({ slug }, "Hermes applyClawHubSkill: no-op (ClawHub is OpenClaw-only)");
 		return Promise.resolve();
 	}
 	removeClawHubSkill(slug) {
-		log$2.info({ slug }, "Hermes removeClawHubSkill: no-op (ClawHub is OpenClaw-only)");
+		log$4.info({ slug }, "Hermes removeClawHubSkill: no-op (ClawHub is OpenClaw-only)");
 		return Promise.resolve();
 	}
 	isAvailable() {
@@ -3501,7 +3530,7 @@ var HermesApplier = class {
 * `warmup`) so the store is a pure ledger and the MCP children are spawned ONLY
 * by Hermes — avoiding a double-spawn of every server.
 */
-const log$1 = createLogger("HermesMcpSync");
+const log$3 = createLogger("HermesMcpSync");
 const DEFAULT_HERMES_HOME = join(homedir(), ".hermes");
 /**
 * SEAM #1 — `${VAR}` interpolation from `~/.hermes/.env`. CONFIRMED (Hermes
@@ -3513,7 +3542,7 @@ const DEFAULT_HERMES_HOME = join(homedir(), ".hermes");
 * resolves at spawn time. The inline-literal fallback is therefore not needed.
 */
 const ALFE_API_KEY_ENV_REF = "${ALFE_API_KEY}";
-const DEFAULT_DEBOUNCE_MS = 250;
+const DEFAULT_DEBOUNCE_MS$1 = 250;
 /**
 * Read-merge-write mirror of the MCP store into `~/.hermes/config.yaml`.
 *
@@ -3550,7 +3579,7 @@ var HermesMcpSync = class {
 		this.configPath = opts.configPath ?? join(this.home, "config.yaml");
 		this.envPath = opts.envPath ?? join(this.home, ".env");
 		this.trackingPath = opts.trackingPath ?? join(this.home, ".alfe-mcp-synced.json");
-		this.debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+		this.debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS$1;
 	}
 	/**
 	* Begin mirroring: load the prior removal set, run one immediate sync (so
@@ -3562,12 +3591,12 @@ var HermesMcpSync = class {
 		this.started = true;
 		this.loadSyncedIds();
 		this.syncOnce().catch((err) => {
-			log$1.warn({ err: errMsg$1(err) }, "Hermes MCP sync: initial sync failed");
+			log$3.warn({ err: errMsg$2(err) }, "Hermes MCP sync: initial sync failed");
 		});
 		this.unsubscribe = this.manager.onChange(() => {
 			this.schedule();
 		});
-		log$1.info({ configPath: this.configPath }, "Hermes MCP sync started — mirroring store into config.yaml");
+		log$3.info({ configPath: this.configPath }, "Hermes MCP sync started — mirroring store into config.yaml");
 	}
 	/** Stop subscribing and cancel any pending debounced sync. Idempotent. */
 	stop() {
@@ -3598,7 +3627,7 @@ var HermesMcpSync = class {
 	schedule() {
 		if (this.debounceMs <= 0) {
 			this.syncOnce().catch((err) => {
-				log$1.warn({ err: errMsg$1(err) }, "Hermes MCP sync failed");
+				log$3.warn({ err: errMsg$2(err) }, "Hermes MCP sync failed");
 			});
 			return;
 		}
@@ -3606,7 +3635,7 @@ var HermesMcpSync = class {
 		this.debounceTimer = setTimeout(() => {
 			this.debounceTimer = void 0;
 			this.syncOnce().catch((err) => {
-				log$1.warn({ err: errMsg$1(err) }, "Hermes MCP sync failed");
+				log$3.warn({ err: errMsg$2(err) }, "Hermes MCP sync failed");
 			});
 		}, this.debounceMs);
 		this.debounceTimer.unref();
@@ -3623,7 +3652,7 @@ var HermesMcpSync = class {
 		if (changed) {
 			mkdirSync(dirname(this.configPath), { recursive: true });
 			writeFileSync(this.configPath, after, "utf-8");
-			log$1.info({
+			log$3.info({
 				added: [...desiredIds],
 				removed: [...this.syncedIds].filter((id) => !desiredIds.has(id))
 			}, "Hermes MCP sync: config.yaml mcp_servers updated");
@@ -3665,7 +3694,7 @@ var HermesMcpSync = class {
 	/** Read-merge-write `~/.hermes/.env` to set ALFE_API_KEY without clobbering other keys. */
 	ensureEnvApiKey() {
 		if (!this.apiKey) {
-			log$1.warn("Hermes MCP sync: no ALFE_API_KEY available — mirrored MCP servers will start in zero-accounts degraded mode");
+			log$3.warn("Hermes MCP sync: no ALFE_API_KEY available — mirrored MCP servers will start in zero-accounts degraded mode");
 			return false;
 		}
 		return upsertEnvVar(this.envPath, "ALFE_API_KEY", this.apiKey);
@@ -3682,7 +3711,7 @@ var HermesMcpSync = class {
 			mkdirSync(dirname(this.trackingPath), { recursive: true });
 			writeFileSync(this.trackingPath, JSON.stringify({ syncedIds: [...this.syncedIds] }, null, 2) + "\n", "utf-8");
 		} catch (err) {
-			log$1.warn({ err: errMsg$1(err) }, "Hermes MCP sync: failed to persist synced-id sidecar");
+			log$3.warn({ err: errMsg$2(err) }, "Hermes MCP sync: failed to persist synced-id sidecar");
 		}
 	}
 };
@@ -3713,6 +3742,466 @@ function upsertEnvVar(envPath, key, value) {
 	}
 	return changed;
 }
+function errMsg$2(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/appliers/claude-code-applier.ts
+/**
+* ClaudeCodeApplier — applies integration capability to the claude-code runtime
+* (a self-hosted Claude Code agent driven by the `alfe-claude-host`).
+*
+* The claude-code runtime is deliberately thin on the applier surface. Chat,
+* memory, and voice reach a claude-code agent via the host + MCP servers (see
+* `ClaudeCodeMcpSync`), NOT via applied plugins — so the core `alfe` integration
+* is effectively a no-op here. What DOES land:
+*
+*  - **Plugins**: the `@alfe.ai/openclaw-*` npm plugins are OpenClaw-specific
+*    (they carry the `openclaw` extension / plugin-SDK peer dep) and cannot load
+*    inside Claude Code — `applyPlugin` / `removePlugin` log-and-skip them, the
+*    same as `HermesApplier`. No claude-code-native plugin spec exists.
+*  - **Skills**: a REAL win vs Hermes — Claude Code has native Agent Skills read
+*    from `~/.claude/skills/<name>/`. `applySkill` copies an Alfe skill directory
+*    there; `applyClawHubSkill` fetches the ClawHub skill and stages it the same
+*    way; the `remove*` variants delete the directory.
+*  - **Config**: Claude Code has no integration-config CLI analogous to
+*    `openclaw config set` / `hermes config set`, so config is a mostly-inert
+*    surface. We track per-integration contributions in a ledger
+*    (`~/.claude-code/.alfe-integrations.json`) so the lifecycle accounting stays
+*    honest (a config-only integration is still lock-tracked and torn down on
+*    removal), but there is no runtime CLI to shell. `setConfigRaw` /
+*    `getConfigRaw` are ledger-backed raw key writes for the daemon's
+*    `alfe.config_set` cloud-command — they MUST exist (the daemon hard-fails
+*    `alfe.config_set` and the config reconciler no-ops when the applier omits
+*    them), and they degrade cleanly rather than error.
+*
+* Constructor shape mirrors `HermesApplier` (`{ home, workspace?, configPath? }`)
+* so the daemon constructs it identically. `home` is the `~/.claude-code`
+* workspace; skills go to `~/.claude/skills` (Claude Code's global skills dir,
+* derived from the OS home, NOT the claude-code workspace).
+*/
+const log$2 = createLogger("ClaudeCodeApplier");
+const DEFAULT_CLAUDE_CODE_HOME$1 = join(homedir(), ".claude-code");
+/** Claude Code reads native Agent Skills from `~/.claude/skills/<name>/`. */
+const DEFAULT_CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
+/** `@alfe.ai/openclaw-*` packages are OpenClaw-specific plugins — not Claude Code. */
+function isOpenClawPlugin(spec) {
+	return stripPluginVersion(spec).startsWith("@alfe.ai/openclaw-");
+}
+var ClaudeCodeApplier = class {
+	runtime = "claude-code";
+	home;
+	/** `~/.claude-code/.alfe-integrations.json` — per-integration config ledger + raw-key store. */
+	ledgerPath;
+	/** `~/.claude/skills` — where native Claude Code skills are copied. */
+	skillsDir;
+	constructor(options = {}) {
+		this.home = options.home ?? options.workspace ?? DEFAULT_CLAUDE_CODE_HOME$1;
+		this.ledgerPath = options.configPath ?? join(this.home, ".alfe-integrations.json");
+		this.skillsDir = options.skillsDir ?? DEFAULT_CLAUDE_SKILLS_DIR;
+	}
+	/**
+	* Record an integration's config contribution in the ledger. Claude Code has
+	* no integration-config CLI, so this is a pure ledger write — it makes the
+	* per-integration accounting honest (so `removeConfig` and the lock's
+	* config-only tracking work) without shelling anything. Overwrites the prior
+	* contribution for this integration (convergent by construction — a full
+	* replace, no stale-key diff needed since nothing is applied to a runtime).
+	*/
+	applyConfig(integrationId, config) {
+		const ledger = this.readLedger();
+		const integrations = ledger._integrations ?? {};
+		integrations[integrationId] = config;
+		ledger._integrations = integrations;
+		this.writeLedger(ledger);
+		log$2.info({ integrationId }, "Claude Code applyConfig: recorded config in ledger (no runtime CLI to apply)");
+		return Promise.resolve();
+	}
+	/** Clear an integration's config contribution from the ledger. */
+	removeConfig(integrationId) {
+		const ledger = this.readLedger();
+		const integrations = ledger._integrations ?? {};
+		if (!(integrationId in integrations)) return Promise.resolve();
+		ledger._integrations = Object.fromEntries(Object.entries(integrations).filter(([key]) => key !== integrationId));
+		this.writeLedger(ledger);
+		return Promise.resolve();
+	}
+	/**
+	* Raw single-key config write for the daemon's `alfe.config_set` cloud-command.
+	*
+	* Deliberately bypasses the `_integrations` per-integration accounting (a raw
+	* set is untracked — routing it through `applyConfig` would corrupt an
+	* integration's removal accounting). Stored under a separate `_raw` map in the
+	* same ledger file. Inert as far as the runtime goes (Claude Code has no config
+	* CLI to push it into), but it degrades cleanly — the daemon gets an OK ack
+	* instead of `CONFIG_SET_UNSUPPORTED`, and the value round-trips via
+	* `getConfigRaw`.
+	*/
+	setConfigRaw(key, value) {
+		const ledger = this.readLedger();
+		const raw = ledger._raw ?? {};
+		raw[key] = value;
+		ledger._raw = raw;
+		this.writeLedger(ledger);
+		return Promise.resolve();
+	}
+	/**
+	* Read a raw config key back from the ledger — the untracked read companion to
+	* `setConfigRaw`, used by the daemon's config-reconcile pass (value-diff before
+	* write; verify a write landed). Returns the exact string `setConfigRaw` stored,
+	* or `undefined` when the key was never set. Never throws.
+	*/
+	getConfigRaw(key) {
+		try {
+			const value = (this.readLedger()._raw ?? {})[key];
+			return Promise.resolve(typeof value === "string" ? value : void 0);
+		} catch {
+			return Promise.resolve(void 0);
+		}
+	}
+	/**
+	* Apply a plugin. The `@alfe.ai/openclaw-*` npm plugins are OpenClaw-specific
+	* and do NOT load in Claude Code — log + skip them. No claude-code-native
+	* plugin spec exists, so any non-openclaw spec is also skipped (rather than a
+	* blind shell of an unknown installer). The manager catches per-plugin, so a
+	* skip here is a correct no-op.
+	*/
+	applyPlugin(spec) {
+		if (isOpenClawPlugin(spec)) {
+			log$2.info({ spec }, "Claude Code applyPlugin: skipping OpenClaw-specific npm plugin (not a Claude Code plugin)");
+			return Promise.resolve();
+		}
+		log$2.info({ spec }, "Claude Code applyPlugin: no claude-code-native plugin mechanism — skipping");
+		return Promise.resolve();
+	}
+	/** Remove a plugin. Nothing was installed (applyPlugin skipped it) — no-op log. */
+	removePlugin(spec) {
+		log$2.info({ spec }, "Claude Code removePlugin: no-op (no plugin was installed on Claude Code)");
+		return Promise.resolve();
+	}
+	/**
+	* Copy a skill directory into `~/.claude/skills/<name>/`. Claude Code reads
+	* native Agent Skills from there, so an Alfe skill dir lands as a first-class
+	* Claude Code skill. Idempotent: an existing target is replaced (a
+	* newer-version re-apply must overwrite).
+	*/
+	applySkill(name, srcPath) {
+		return this.copySkillDir(name, srcPath);
+	}
+	/** Remove a skill directory from `~/.claude/skills/<name>/`. */
+	removeSkill(name) {
+		return this.deleteSkillDir(name);
+	}
+	/**
+	* Install a ClawHub skill natively. ClawHub is an OpenClaw registry, but the
+	* skill payload is a plain directory — for claude-code we treat the slug as the
+	* skill name and expect the caller to have staged the directory. Absent a
+	* staged source we log + skip (no OpenClaw `skills install` CLI on this
+	* runtime); a future claude-code ClawHub fetch would stage the dir then copy it
+	* exactly like `applySkill`.
+	*
+	* NOTE: unlike OpenClaw's `applyClawHubSkill` (which THROWS on a real install
+	* failure so an all-skills-fail activation is marked `error`), there is no
+	* install to fail here — the skill either lands from a staged directory or is a
+	* clean no-op. We never throw for a claude-code ClawHub skill.
+	*/
+	applyClawHubSkill(slug) {
+		log$2.info({ slug }, "Claude Code applyClawHubSkill: no claude-code ClawHub fetch — skipping (native skill dirs land via applySkill)");
+		return Promise.resolve();
+	}
+	/** Remove a ClawHub-installed skill directory (by slug == dir name). */
+	removeClawHubSkill(slug) {
+		return this.deleteSkillDir(slug);
+	}
+	isAvailable() {
+		return Promise.resolve(existsSync(this.home));
+	}
+	copySkillDir(name, srcPath) {
+		if (!existsSync(srcPath)) {
+			log$2.warn({
+				name,
+				srcPath
+			}, "Claude Code applySkill: source directory missing — skipping");
+			return Promise.resolve();
+		}
+		const dest = join(this.skillsDir, name);
+		try {
+			mkdirSync(this.skillsDir, { recursive: true });
+			rmSync(dest, {
+				recursive: true,
+				force: true
+			});
+			cpSync(srcPath, dest, { recursive: true });
+			log$2.info({
+				name,
+				dest
+			}, "Claude Code applySkill: copied skill into ~/.claude/skills");
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			log$2.error({
+				name,
+				dest,
+				err: message
+			}, "Claude Code applySkill: failed to copy skill");
+			throw new Error(`Failed to copy skill ${name} into ${dest}: ${message}`);
+		}
+		return Promise.resolve();
+	}
+	deleteSkillDir(name) {
+		const dest = join(this.skillsDir, name);
+		try {
+			rmSync(dest, {
+				recursive: true,
+				force: true
+			});
+			log$2.info({
+				name,
+				dest
+			}, "Claude Code removeSkill: removed skill from ~/.claude/skills");
+		} catch (err) {
+			log$2.warn({
+				name,
+				dest,
+				err: err instanceof Error ? err.message : String(err)
+			}, "Claude Code removeSkill: failed to remove skill directory");
+		}
+		return Promise.resolve();
+	}
+	readLedger() {
+		if (!existsSync(this.ledgerPath)) return {};
+		try {
+			return JSON.parse(readFileSync(this.ledgerPath, "utf-8"));
+		} catch {
+			return {};
+		}
+	}
+	writeLedger(ledger) {
+		mkdirSync(join(this.ledgerPath, ".."), { recursive: true });
+		writeFileSync(this.ledgerPath, JSON.stringify(ledger, null, 2) + "\n", "utf-8");
+	}
+};
+//#endregion
+//#region src/appliers/claude-code-mcp-sync.ts
+/**
+* ClaudeCodeMcpSync — claude-code-only CONSUMER of the runtime-agnostic MCP
+* store (parallel to `HermesMcpSync`, Approach B: a generated config file the
+* runtime reads).
+*
+* Background: `McpApplier` writes resolved MCP servers (command/args/env, with
+* `{{config}}`/`{{credentials}}` already interpolated at apply time) into the
+* runtime-agnostic bundler store at `~/.alfe/mcp/servers.json`. OpenClaw consumes
+* that store over IPC (the daemon hosts the bundler children and the openclaw
+* plugin reaches them). The claude-code runtime cannot consume over IPC — the
+* `alfe-claude-host` spawns `claude -p --mcp-config <file>` per turn and Claude
+* Code itself spawns the MCP children. So claude-code needs its own consumer that
+* materialises the store into the `--mcp-config` JSON file the host passes.
+*
+* This class is the parallel to OpenClaw's IPC consumption: it subscribes to
+* `manager.onChange()` and, **only when the active runtime is claude-code** (the
+* daemon only constructs it for claude-code agents), writes the store's servers
+* into `~/.claude-code/mcp-config.json` in Claude Code's `--mcp-config` shape:
+*
+*   { "mcpServers": { "<id>": { "command", "args", "env" } | { "url", ... } } }
+*
+* This is Anthropic's documented `.mcp.json` / `--mcp-config` schema — `command`
+* / `args` / `env` for stdio servers and `type: "sse"|"http"` + `url` + `headers`
+* for remote servers, under a top-level `mcpServers` map keyed by server id.
+*
+* Two cross-cutting responsibilities make the generated servers actually work:
+*
+*  1. `ALFE_API_KEY` injection. The Alfe MCP servers (`@alfe.ai/<provider>-mcp`)
+*     fetch their real provider credentials from the Alfe API at startup using
+*     `ALFE_API_KEY`. For OpenClaw the daemon spawns the children, so they
+*     inherit `ALFE_API_KEY` from the daemon's own `process.env`. Claude Code
+*     spawns the children itself in a separate process tree (per turn), so they
+*     would NOT inherit it — without it they start in a silent zero-accounts
+*     degraded mode. We therefore inject the actual `ALFE_API_KEY` value into
+*     every generated stdio server's env. Unlike Hermes (which supports
+*     `${VAR}` interpolation from `~/.hermes/.env`), Claude Code's `--mcp-config`
+*     env block is a plain map with NO documented `${VAR}` expansion, so we write
+*     the literal secret into the generated file. The file lives under
+*     `~/.claude-code/` (0600) alongside other agent state and is regenerated,
+*     never checked in.
+*
+*  2. Restart. Claude Code reads `--mcp-config` fresh on every `claude -p` spawn
+*     (the host spawns per turn), so a regenerated file is picked up on the NEXT
+*     turn with no runtime restart. Unlike Hermes (which reads config.yaml at
+*     boot and needs a reload), this sync does NOT trigger a runtime restart —
+*     the per-turn spawn model makes it unnecessary. This is the deliberate
+*     divergence from `HermesMcpSync` (which owns a `requestRestart` callback);
+*     we keep the same options shape for daemon-wiring parity but never restart.
+*/
+const log$1 = createLogger("ClaudeCodeMcpSync");
+const DEFAULT_CLAUDE_CODE_HOME = join(homedir(), ".claude-code");
+const DEFAULT_DEBOUNCE_MS = 250;
+/**
+* Full-regenerate writer of the MCP store into `~/.claude-code/mcp-config.json`.
+*
+* Ownership / removal model: every entry returned by `manager.listServers()`
+* comes from the Alfe store (its `owner` is `integration:<id>` / `cli` /
+* `manual`) and is therefore Alfe-owned. Unlike the Hermes config.yaml mirror
+* (which must preserve user-authored `mcp_servers` in a shared file), the
+* `--mcp-config` file is Alfe-generated and Alfe-owned end to end — Claude Code's
+* OWN user-authored MCP servers live in `~/.claude.json` / project `.mcp.json`,
+* NOT this generated file. So we fully regenerate it from the store on every
+* change (no read-merge-write needed). We still persist the written-id set to a
+* sidecar for parity + forensics, but removal is implicit in the regenerate.
+*/
+var ClaudeCodeMcpSync = class {
+	manager;
+	home;
+	apiKey;
+	configPath;
+	trackingPath;
+	debounceMs;
+	/** Ids of `mcpServers` entries this sync last wrote — informational sidecar. */
+	syncedIds = /* @__PURE__ */ new Set();
+	/** Serializes syncs so two onChange-driven runs can't interleave file writes. */
+	queue = Promise.resolve();
+	unsubscribe;
+	debounceTimer;
+	started = false;
+	constructor(opts) {
+		this.manager = opts.manager;
+		this.home = opts.home ?? DEFAULT_CLAUDE_CODE_HOME;
+		this.apiKey = opts.apiKey;
+		this.configPath = opts.configPath ?? join(this.home, "mcp-config.json");
+		this.trackingPath = opts.trackingPath ?? join(this.home, ".alfe-mcp-synced.json");
+		this.debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+	}
+	/**
+	* Begin mirroring: load the prior removal set, run one immediate sync (so the
+	* `--mcp-config` file reflects the current store before the host next spawns
+	* `claude -p`), then subscribe to store changes (debounced). Idempotent.
+	*/
+	start() {
+		if (this.started) return;
+		this.started = true;
+		this.loadSyncedIds();
+		this.syncOnce().catch((err) => {
+			log$1.warn({ err: errMsg$1(err) }, "Claude Code MCP sync: initial sync failed");
+		});
+		this.unsubscribe = this.manager.onChange(() => {
+			this.schedule();
+		});
+		log$1.info({ configPath: this.configPath }, "Claude Code MCP sync started — mirroring store into mcp-config.json");
+	}
+	/** Stop subscribing and cancel any pending debounced sync. Idempotent. */
+	stop() {
+		if (this.unsubscribe) {
+			this.unsubscribe();
+			this.unsubscribe = void 0;
+		}
+		if (this.debounceTimer) {
+			clearTimeout(this.debounceTimer);
+			this.debounceTimer = void 0;
+		}
+		this.started = false;
+	}
+	/**
+	* Regenerate the `--mcp-config` file from the current store exactly once.
+	* Public so the daemon (and tests) can await a deterministic sync. Serialized
+	* against any other in-flight sync.
+	*/
+	syncOnce() {
+		const run = () => {
+			this.syncNow();
+			return Promise.resolve();
+		};
+		const result = this.queue.then(run, run);
+		this.queue = result.catch(() => void 0);
+		return result;
+	}
+	schedule() {
+		if (this.debounceMs <= 0) {
+			this.syncOnce().catch((err) => {
+				log$1.warn({ err: errMsg$1(err) }, "Claude Code MCP sync failed");
+			});
+			return;
+		}
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = setTimeout(() => {
+			this.debounceTimer = void 0;
+			this.syncOnce().catch((err) => {
+				log$1.warn({ err: errMsg$1(err) }, "Claude Code MCP sync failed");
+			});
+		}, this.debounceMs);
+		this.debounceTimer.unref();
+	}
+	syncNow() {
+		const desired = this.computeDesired();
+		const desiredIds = new Set(desired.keys());
+		if (desiredIds.size === 0 && this.syncedIds.size === 0 && !existsSync(this.configPath)) return;
+		const file = { mcpServers: Object.fromEntries(desired) };
+		const next = JSON.stringify(file, null, 2) + "\n";
+		if ((existsSync(this.configPath) ? readFileSync(this.configPath, "utf-8") : "") !== next) {
+			mkdirSync(dirname(this.configPath), { recursive: true });
+			writeFileSync(this.configPath, next, {
+				encoding: "utf-8",
+				mode: 384
+			});
+			chmodSync(this.configPath, 384);
+			log$1.info({
+				added: [...desiredIds],
+				removed: [...this.syncedIds].filter((id) => !desiredIds.has(id))
+			}, "Claude Code MCP sync: mcp-config.json regenerated");
+		}
+		this.syncedIds = desiredIds;
+		this.persistSyncedIds();
+	}
+	computeDesired() {
+		const desired = /* @__PURE__ */ new Map();
+		for (const { id, entry } of this.manager.listServers()) desired.set(id, this.toClaudeCodeEntry(entry));
+		return desired;
+	}
+	/**
+	* Transform a stored entry into a Claude Code `--mcp-config` entry. stdio
+	* entries get the literal `ALFE_API_KEY` injected; remote entries pass through
+	* with the documented `type` discriminator (`sse` → `sse`, `streamable-http`
+	* → `http`).
+	*/
+	toClaudeCodeEntry(entry) {
+		const cfg = toServerConfig(entry);
+		if ("command" in cfg) {
+			const out = { command: cfg.command };
+			if (cfg.args && cfg.args.length > 0) out.args = cfg.args;
+			const env = this.withAlfeApiKey(cfg.env);
+			if (Object.keys(env).length > 0) out.env = env;
+			return out;
+		}
+		const out = {
+			type: cfg.transport === "sse" ? "sse" : "http",
+			url: cfg.url
+		};
+		if (cfg.headers) out.headers = cfg.headers;
+		return out;
+	}
+	withAlfeApiKey(env) {
+		const merged = { ...env ?? {} };
+		if ("ALFE_API_KEY" in merged) return merged;
+		if (!this.apiKey) {
+			log$1.warn("Claude Code MCP sync: no ALFE_API_KEY available — generated MCP servers will start in zero-accounts degraded mode");
+			return merged;
+		}
+		merged.ALFE_API_KEY = this.apiKey;
+		return merged;
+	}
+	loadSyncedIds() {
+		if (!existsSync(this.trackingPath)) return;
+		try {
+			const data = JSON.parse(readFileSync(this.trackingPath, "utf-8"));
+			if (Array.isArray(data.syncedIds)) this.syncedIds = new Set(data.syncedIds.filter((x) => typeof x === "string"));
+		} catch {}
+	}
+	persistSyncedIds() {
+		try {
+			mkdirSync(dirname(this.trackingPath), { recursive: true });
+			writeFileSync(this.trackingPath, JSON.stringify({ syncedIds: [...this.syncedIds] }, null, 2) + "\n", "utf-8");
+		} catch (err) {
+			log$1.warn({ err: errMsg$1(err) }, "Claude Code MCP sync: failed to persist synced-id sidecar");
+		}
+	}
+};
 function errMsg$1(err) {
 	return err instanceof Error ? err.message : String(err);
 }
@@ -3931,4 +4420,4 @@ var IntegrationManagerAdapter = class {
 	}
 };
 //#endregion
-export { DEFAULT_REGISTRY_TTL_MS, HermesApplier, HermesMcpSync, Installer, InstallerError, IntegrationManager, IntegrationManagerAdapter, LockManager, McpApplier, NoopOpenClawCliLock, OpenClawApplier, Registry, RegistryResolveError, Resolver, SerialOpenClawCliLock, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext, upsertEnvVar };
+export { ClaudeCodeApplier, ClaudeCodeMcpSync, DEFAULT_REGISTRY_TTL_MS, HermesApplier, HermesMcpSync, Installer, InstallerError, IntegrationManager, IntegrationManagerAdapter, LockManager, McpApplier, NoopOpenClawCliLock, OpenClawApplier, Registry, RegistryResolveError, Resolver, SerialOpenClawCliLock, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext, upsertEnvVar };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,7 +15,7 @@
     "@auriclabs/logger": "^0.1.1",
     "yaml": ">=2.8.3",
     "@alfe.ai/integration-manifest": "^0.3.1",
-    "@alfe.ai/mcp-bundler": "^0.3.0"
+    "@alfe.ai/mcp-bundler": "^0.3.1"
   },
   "files": [
     "dist"