@ken-jo/agent-connector 0.1.0 → 0.2.0

package/dist/claude-code-4275HQU4.js

@@ -0,0 +1,1432 @@
+#!/usr/bin/env node
+import {
+  readRegisteredMeta
+} from "./chunk-3JCRUROU.js";
+import {
+  addLedgerOwner,
+  configPatchManualEdit,
+  configPatchNamespaceViolation,
+  createLedgerEntry,
+  describeJsonValue,
+  dropLedgerEntry,
+  findLedgerEntry,
+  hashJsonValue,
+  isValidConfigPatchKey,
+  jsonDeepEquals,
+  ledgerEntriesOwnedBy,
+  loadConfigPatchLedger,
+  removeLedgerOwner,
+  saveConfigPatchLedger
+} from "./chunk-GSGDG2BV.js";
+import {
+  resolveEnvRefsDeep,
+  rewriteEnvRefs
+} from "./chunk-DBQMX75U.js";
+import {
+  BaseAdapter
+} from "./chunk-PD4VFEBY.js";
+import {
+  renderCommandMd,
+  renderSkillMd,
+  renderSubagentMd
+} from "./chunk-7L6ITC4T.js";
+import {
+  buildHomeBinHookCommand,
+  buildServeWrapperCommand,
+  isHomeBinHookCommand,
+  shouldWrapForTelemetry
+} from "./chunk-MEH7GC7R.js";
+import {
+  linesOutsideFences,
+  listManagedBlocks,
+  loadMemoryLedger,
+  recordMemoryTarget,
+  removeBlocksFromText,
+  removeManagedBlocksFile,
+  saveMemoryLedger,
+  upsertManagedBlockFile
+} from "./chunk-N6HH7K6P.js";
+import {
+  backupsDir,
+  ensureDir
+} from "./chunk-TRQKHP7D.js";
+
+// src/adapters/claude-code/index.ts
+import { copyFileSync, existsSync, lstatSync, readFileSync, realpathSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join } from "path";
+
+// src/adapters/claude-code/wire.ts
+function extractSessionId(input) {
+  if (typeof input.transcript_path === "string") {
+    const m = input.transcript_path.match(/([a-f0-9-]{36})\.jsonl$/);
+    if (m && m[1]) return m[1];
+  }
+  if (typeof input.session_id === "string" && input.session_id !== "") {
+    return input.session_id;
+  }
+  return "";
+}
+function toolResponseToString(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/adapters/claude-code/index.ts
+var HOST = "claude-code";
+var MCP_ROOT_KEY = "mcpServers";
+var CLAUDE_AGENTS_IMPORT_BLOCK_ID = "_shared/claude-agents-import";
+var ClaudeCodeAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Claude Code";
+  paradigm = "json-stdio";
+  capabilities = {
+    preToolUse: true,
+    postToolUse: true,
+    preCompact: true,
+    sessionStart: true,
+    sessionEnd: true,
+    userPromptSubmit: true,
+    stop: true,
+    notification: true,
+    // Newer events — Claude Code is the reference host for all four.
+    permissionRequest: true,
+    postToolUseFailure: true,
+    subagentStart: true,
+    subagentStop: true,
+    // Claude Code can rewrite PreToolUse input (updatedInput) but does NOT let a
+    // PostToolUse hook rewrite already-emitted tool output.
+    canModifyArgs: true,
+    canModifyOutput: false,
+    canInjectSessionContext: true,
+    // Native passthrough hooks: settings.json hook keys are free-form event
+    // names, so any host event (TaskCreated, TeammateIdle, WorktreeCreate, …)
+    // declared under platforms["claude-code"].nativeHooks installs verbatim.
+    supportsNativeHooks: true,
+    // Declarative host-config key patches: claude-code is the ONLY v1 host
+    // (set-if-absent leaf keys in settings.json, refcounted ownership ledger,
+    // sensitive-key denylist — see SENSITIVE_KEY_RULES below).
+    supportsConfigPatch: true,
+    transports: ["stdio", "http"],
+    // Content surfaces: Claude Code is the reference implementation for all three.
+    supportsCommands: true,
+    supportsSkills: true,
+    supportsSubagents: true,
+    // Memory surface — EXCEPTION host: Claude Code reads CLAUDE.md, NOT
+    // AGENTS.md (docs are explicit; no AGENTS.md support through v2.1.172), so
+    // memoryTargets/installMemory below override the base AGENTS.md default.
+    supportsMemory: true
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = join(homedir(), ".claude");
+    const userSettings = join(userDir, "settings.json");
+    const userServers = join(homedir(), ".claude.json");
+    const projectServers = join(projectDir, ".mcp.json");
+    const userInstalled = existsSync(userDir) || existsSync(userSettings) || existsSync(userServers);
+    const projInstalled = existsSync(projectServers);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projectServers : userSettings;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? scope === "project" ? `found project Claude Code config at ${projectServers}` : `found Claude Code config under ${userDir}` : `no Claude Code config at ${userDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".claude") : join(homedir(), ".claude");
+  }
+  getServerConfigPath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".mcp.json") : join(homedir(), ".claude.json");
+  }
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "settings.json");
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? "server registration disabled for claude-code" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const server = override && typeof override === "object" ? { ...connector.server, ...override } : connector.server;
+    const serverPath = this.getServerConfigPath(ctx);
+    const entry = this.renderServerEntry(ctx, server);
+    return [
+      this.upsertServerInJson(serverPath, MCP_ROOT_KEY, connector.id, entry, ctx.dryRun)
+    ];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [
+      this.removeServerFromJson(serverPath, MCP_ROOT_KEY, ctx.connector.id, ctx.dryRun)
+    ];
+  }
+  /** Render a normalized ServerDef into Claude Code's native mcpServers entry. */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      if (shouldWrapForTelemetry(server, ctx.connector.telemetry)) {
+        const wrapped = buildServeWrapperCommand(
+          ctx.homeBinPath,
+          ctx.connector.id,
+          command,
+          args,
+          ctx.scope,
+          this.id
+        );
+        command = wrapped.command;
+        args = wrapped.args;
+      }
+      const entry2 = { type: "stdio", command, args };
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      if (server.cwd) entry2.cwd = resolveEnvRefsDeep(server.cwd);
+      return entry2;
+    }
+    const entry = {
+      type: "http",
+      url: rewriteEnvRefs(server.url ?? "", claudeEnvToken)
+    };
+    if (server.headers) {
+      entry.headers = this.renderEnv(server.headers) ?? {};
+    }
+    return entry;
+  }
+  /**
+   * Render env/header values. Claude Code supports its own `${VAR}` native
+   * interpolation, so translate `${env:VAR}` refs to that native token rather
+   * than baking secrets into the file. Literals pass through unchanged.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(env)) {
+      out[k] = rewriteEnvRefs(v, claudeEnvToken);
+    }
+    return out;
+  }
+  // ── Hook install / uninstall ─────────────────────────────────────────────
+  installHooks(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST];
+    const normalizedEvents = override?.hooks === false ? [] : connector.hookEvents;
+    const nativeHooks = override?.nativeHooks ?? {};
+    const nativeEvents = Object.keys(nativeHooks);
+    if (normalizedEvents.length === 0 && nativeEvents.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: override?.hooks === false ? "hooks disabled for claude-code" : "connector declares no hooks"
+        }
+      ];
+    }
+    const settingsPath = this.getHookConfigPath(ctx);
+    const settings = this.readJson(settingsPath) ?? {};
+    const hooks = settings.hooks ??= {};
+    const changes = [];
+    let mutated = false;
+    const pending = [
+      ...normalizedEvents.map((event) => ({
+        event,
+        matcher: connector.hooks[event]?.matcher ?? ""
+      })),
+      ...nativeEvents.map((event) => ({
+        event,
+        matcher: nativeHooks[event]?.matcher ?? ""
+      }))
+    ];
+    for (const { event, matcher } of pending) {
+      const command = buildHomeBinHookCommand(ctx.homeBinPath, HOST, event, connector.id);
+      const entry = {
+        matcher,
+        hooks: [{ type: "command", command }]
+      };
+      const bucket = hooks[event] ??= [];
+      const existingIdx = bucket.findIndex((e) => this.entryHasCommand(e, command));
+      if (existingIdx >= 0) {
+        if (JSON.stringify(bucket[existingIdx]) === JSON.stringify(entry)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: settingsPath,
+            detail: `hooks.${event} already registered`
+          });
+          continue;
+        }
+        bucket[existingIdx] = entry;
+        changes.push({
+          platform: this.id,
+          action: "update",
+          path: settingsPath,
+          detail: `hooks.${event}`
+        });
+      } else {
+        bucket.push(entry);
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: settingsPath,
+          detail: `hooks.${event}`
+        });
+      }
+      mutated = true;
+    }
+    if (mutated) this.writeJson(settingsPath, settings, ctx.dryRun);
+    return changes;
+  }
+  uninstallHooks(ctx) {
+    const settingsPath = this.getHookConfigPath(ctx);
+    const settings = this.readJson(settingsPath);
+    const hooks = settings?.hooks;
+    if (!settings || !hooks) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: settingsPath,
+          detail: "no hooks section present"
+        }
+      ];
+    }
+    const changes = [];
+    let mutated = false;
+    for (const event of Object.keys(hooks)) {
+      const bucket = hooks[event];
+      if (!Array.isArray(bucket)) continue;
+      const next = [];
+      let removed = 0;
+      for (const e of bucket) {
+        const innerBefore = e.hooks?.length ?? 0;
+        const inner = (e.hooks ?? []).filter(
+          (h) => !this.isOurCommand(h.command, ctx)
+        );
+        removed += innerBefore - inner.length;
+        if (inner.length > 0) next.push({ matcher: e.matcher ?? "", hooks: inner });
+      }
+      if (removed > 0) {
+        if (next.length > 0) hooks[event] = next;
+        else delete hooks[event];
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: settingsPath,
+          detail: `hooks.${event} (${removed})`
+        });
+        mutated = true;
+      }
+    }
+    if (mutated) this.writeJson(settingsPath, settings, ctx.dryRun);
+    if (changes.length === 0) {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: settingsPath,
+        detail: "no matching hook entries"
+      });
+    }
+    return changes;
+  }
+  entryHasCommand(entry, command) {
+    return (entry.hooks ?? []).some((h) => h.command === command);
+  }
+  // ── Declarative host-config key patches (configPatch) ────────────────────
+  // FIXED semantics (docs/ARCHITECTURE.md §4): set-if-absent on a single
+  // dotted LEAF key of settings.json, skip-warn on ANY conflict (present key,
+  // non-object intermediate, drift), refcounted ownership in the persisted
+  // ledger at <dataRoot>/state/config-patches.json. Reuses the adapter's
+  // existing whole-file settings.json JSON IO (the same handling the hook
+  // install performs on this exact file) — Claude Code itself rewrites this
+  // file, so format preservation is a non-issue here. NOTE for future hosts:
+  // VS Code JSONC needs jsonc-parser modify/applyEdits and Codex TOML needs an
+  // anchored edit — core/toml.ts's round-trip is BANNED for configPatch.
+  /** The ONLY file configPatch may touch on claude-code: settings.json at scope. */
+  getPatchableConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "settings.json");
+  }
+  installConfigPatches(ctx) {
+    const { connector } = ctx;
+    const patches = connector.platforms[HOST]?.configPatch ?? [];
+    if (patches.length === 0) {
+      return [
+        { platform: this.id, action: "skip", detail: "connector declares no configPatch entries" }
+      ];
+    }
+    const filePath = this.getPatchableConfigPath(ctx);
+    if (this.isPresentButUnparseable(filePath)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `existing ${filePath} is not parseable; configPatch left unapplied (back it up / fix it, then re-run)`
+        }
+      ];
+    }
+    const settings = this.readJson(filePath) ?? {};
+    if (typeof settings !== "object" || Array.isArray(settings)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `existing ${filePath} is not a JSON object; configPatch left unapplied`
+        }
+      ];
+    }
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const changes = [];
+    let fileMutated = false;
+    let ledgerMutated = false;
+    for (const patch of patches) {
+      if (!isValidConfigPatchKey(patch.key)) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          detail: `configPatch ${JSON.stringify(patch.key)} refused: not a dotted leaf path (segments must match [A-Za-z0-9_-]+; no array indices)`
+        });
+        continue;
+      }
+      const namespace = configPatchNamespaceViolation(patch.key);
+      if (namespace) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          detail: `configPatch refused: ${namespace}`
+        });
+        continue;
+      }
+      const sensitive = claudeSensitiveKeyViolation(patch.key);
+      if (sensitive) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          detail: `configPatch ${patch.key} refused: matches the claude-code sensitive-key denylist (${sensitive}); security-relevant keys are never patched`
+        });
+        continue;
+      }
+      const desired = resolveEnvRefsDeep(patch.value);
+      const segments = patch.key.split(".");
+      const leaf = readJsonLeaf(settings, segments);
+      const entry = findLedgerEntry(ledger, HOST, filePath, patch.key);
+      if (leaf.kind === "blocked") {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `configPatch ${patch.key} skipped: "${leaf.atPath}" exists but is not an object \u2014 ${configPatchManualEdit(patch)}`
+        });
+        continue;
+      }
+      if (leaf.kind === "absent") {
+        writeJsonLeaf(settings, segments, desired);
+        fileMutated = true;
+        if (entry) {
+          entry.writtenValue = desired;
+          entry.writtenValueHash = hashJsonValue(desired);
+          addLedgerOwner(entry, connector.id, connector.version);
+        } else {
+          createLedgerEntry(ledger, {
+            platform: HOST,
+            file: filePath,
+            key: patch.key,
+            value: desired,
+            connectorId: connector.id,
+            connectorVersion: connector.version
+          });
+        }
+        ledgerMutated = true;
+        changes.push({
+          platform: this.id,
+          action: "create",
+          path: filePath,
+          detail: `configPatch ${patch.key}: <absent> \u2192 ${describeJsonValue(desired)} (${patch.reason})`
+        });
+        continue;
+      }
+      if (!entry) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `configPatch ${patch.key} skipped: already set to ${describeJsonValue(leaf.value)} (not created by agent-connector; desired ${describeJsonValue(desired)}) \u2014 ` + configPatchManualEdit(patch)
+        });
+        continue;
+      }
+      if (!jsonDeepEquals(leaf.value, entry.writtenValue)) {
+        changes.push({
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `configPatch ${patch.key}: value changed since install (current ${describeJsonValue(leaf.value)}, wrote ${describeJsonValue(entry.writtenValue)}); leaving in place \u2014 ${configPatchManualEdit(patch)}`
+        });
+        continue;
+      }
+      if (jsonDeepEquals(desired, leaf.value)) {
+        const owners = entry.owners.map((o) => o.connectorId);
+        if (addLedgerOwner(entry, connector.id, connector.version)) {
+          ledgerMutated = true;
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `configPatch ${patch.key} already installed; registered as co-owner (co-owned with ${owners.join(", ")})`
+          });
+        } else {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `configPatch ${patch.key} already installed`
+          });
+        }
+        continue;
+      }
+      changes.push({
+        platform: this.id,
+        action: "warn",
+        path: filePath,
+        detail: `configPatch ${patch.key} skipped: already owned by ${entry.owners.map((o) => o.connectorId).join(", ")} with a different value (current ${describeJsonValue(leaf.value)}, desired ${describeJsonValue(desired)}) \u2014 ` + configPatchManualEdit(patch)
+      });
+    }
+    if (fileMutated) this.writeJson(filePath, settings, ctx.dryRun);
+    if (ledgerMutated && !ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+    return changes;
+  }
+  uninstallConfigPatches(ctx) {
+    const connectorId = ctx.connector.id;
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const owned = ledgerEntriesOwnedBy(ledger, HOST, connectorId);
+    const declared = ctx.connector.platforms[HOST]?.configPatch ?? [];
+    const changes = [];
+    const ownedKeys = new Set(owned.map((e) => e.key));
+    for (const patch of declared) {
+      if (!ownedKeys.has(patch.key)) {
+        changes.push({
+          platform: this.id,
+          action: "skip",
+          detail: `configPatch ${patch.key}: no ownership recorded; left untouched`
+        });
+      }
+    }
+    if (owned.length === 0) return changes;
+    let ledgerMutated = false;
+    const backedUp = /* @__PURE__ */ new Set();
+    const byFile = /* @__PURE__ */ new Map();
+    for (const entry of owned) {
+      const bucket = byFile.get(entry.file) ?? [];
+      bucket.push(entry);
+      byFile.set(entry.file, bucket);
+    }
+    for (const [filePath, entries] of byFile) {
+      const unparseable = this.isPresentButUnparseable(filePath);
+      const settings = unparseable ? null : this.readJson(filePath);
+      let fileMutated = false;
+      for (const entry of entries) {
+        const { lastOwner } = removeLedgerOwner(entry, connectorId);
+        ledgerMutated = true;
+        if (!lastOwner) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `configPatch ${entry.key} retained: still owned by ${entry.owners.map((o) => o.connectorId).join(", ")}`
+          });
+          continue;
+        }
+        dropLedgerEntry(ledger, entry);
+        if (unparseable) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: filePath,
+            detail: `configPatch ${entry.key}: ${filePath} is not parseable; key left in place (ownership released)`
+          });
+          continue;
+        }
+        if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `configPatch ${entry.key} already absent (no settings file); ownership record dropped`
+          });
+          continue;
+        }
+        const leaf = readJsonLeaf(settings, entry.key.split("."));
+        if (leaf.kind !== "present") {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `configPatch ${entry.key} already absent; ownership record dropped`
+          });
+          continue;
+        }
+        if (entry.prior?.present !== false || !jsonDeepEquals(leaf.value, entry.writtenValue)) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: filePath,
+            detail: `configPatch ${entry.key}: value changed since install (current ${describeJsonValue(leaf.value)}, wrote ${describeJsonValue(entry.writtenValue)}); left in place`
+          });
+          continue;
+        }
+        if (!ctx.dryRun && !backedUp.has(filePath) && existsSync(filePath)) {
+          const backup = this.backupFileForConfigPatch(filePath);
+          backedUp.add(filePath);
+          if (backup) {
+            changes.push({
+              platform: this.id,
+              action: "create",
+              path: backup,
+              detail: "backed up settings before configPatch removal"
+            });
+          }
+        }
+        deleteJsonLeaf(settings, entry.key.split("."));
+        fileMutated = true;
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: filePath,
+          detail: `configPatch ${entry.key} removed (was ${describeJsonValue(entry.writtenValue)})`
+        });
+      }
+      if (fileMutated && settings) this.writeJson(filePath, settings, ctx.dryRun);
+    }
+    if (ledgerMutated && !ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+    return changes;
+  }
+  /**
+   * Back up ONE exact file (the ledger-recorded patch target, which may belong
+   * to a different scope than the current ctx) into the standard backups dir.
+   * Best-effort: a failed copy returns null and the caller proceeds — the
+   * removal is already value-verified.
+   */
+  backupFileForConfigPatch(filePath) {
+    try {
+      ensureDir(backupsDir());
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const dest = join(backupsDir(), `${this.id}-${stamp}-${basename(filePath)}`);
+      copyFileSync(filePath, dest);
+      return dest;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Doctor: per-ledger-entry configPatch state for this connector —
+   *   ok       → key present and still exactly what we wrote;
+   *   drifted  → user changed the value (we print the manual edit, NEVER
+   *              auto-fix — sync re-asserts only absent keys);
+   *   missing  → key deleted by the user; sync will re-assert it;
+   *   orphaned → ledger row whose owners' connector records are all gone.
+   * Plus a re-print of the manual edit for declared patches that hold no
+   * ownership (skipped at install).
+   */
+  configPatchDiagnostics(ctx) {
+    const results = [];
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const connectorId = ctx.connector.id;
+    const platformEntries = ledger.entries.filter((e) => e.platform === this.id);
+    for (const entry of platformEntries) {
+      const ownedByThis = entry.owners.some((o) => o.connectorId === connectorId);
+      if (!ownedByThis) {
+        const orphaned = entry.owners.length === 0 || entry.owners.every((o) => readRegisteredMeta(o.connectorId) === null);
+        if (orphaned) {
+          results.push({
+            check: `${this.name}: configPatch ${entry.key}`,
+            status: "warn",
+            message: `orphaned ledger entry in ${entry.file}: owning connector record(s) gone (${entry.owners.map((o) => o.connectorId).join(", ") || "none"})`,
+            fix: `re-run \`agent-connector uninstall <owner-id>\` to release it, or remove ${entry.key} from ${entry.file} manually`
+          });
+        }
+        continue;
+      }
+      const state = this.configPatchState(entry);
+      if (state.kind === "ok") {
+        results.push({
+          check: `${this.name}: configPatch ${entry.key}`,
+          status: "pass",
+          message: `ok \u2014 ${entry.key} = ${describeJsonValue(entry.writtenValue)} (${entry.file})`
+        });
+      } else if (state.kind === "missing") {
+        results.push({
+          check: `${this.name}: configPatch ${entry.key}`,
+          status: "warn",
+          message: `missing \u2014 key deleted from ${entry.file} since install`,
+          fix: `agent-connector install (sync) will re-assert it`
+        });
+      } else {
+        results.push({
+          check: `${this.name}: configPatch ${entry.key}`,
+          status: "warn",
+          message: `drifted \u2014 value changed since install (current ${describeJsonValue(state.current)}, wrote ${describeJsonValue(entry.writtenValue)}); never auto-fixed`,
+          fix: `manual edit if wanted: set ${entry.key} = ${describeJsonValue(entry.writtenValue)} in ${entry.file}`
+        });
+      }
+    }
+    const declared = ctx.connector.platforms[HOST]?.configPatch ?? [];
+    const ownedKeys = new Set(
+      ledgerEntriesOwnedBy(ledger, HOST, connectorId).map((e) => e.key)
+    );
+    for (const patch of declared) {
+      if (ownedKeys.has(patch.key)) continue;
+      results.push({
+        check: `${this.name}: configPatch ${patch.key}`,
+        status: "warn",
+        message: `declared but not owned (skipped at install or not yet installed)`,
+        fix: configPatchManualEdit(patch)
+      });
+    }
+    return results;
+  }
+  /** Current on-disk state of one owned ledger entry. */
+  configPatchState(entry) {
+    const settings = this.readJson(entry.file);
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+      return { kind: "missing" };
+    }
+    const leaf = readJsonLeaf(settings, entry.key.split("."));
+    if (leaf.kind !== "present") return { kind: "missing" };
+    if (jsonDeepEquals(leaf.value, entry.writtenValue)) return { kind: "ok" };
+    return { kind: "drifted", current: leaf.value };
+  }
+  doctor(ctx) {
+    const results = super.doctor(ctx);
+    results.push(...this.configPatchDiagnostics(ctx));
+    return results;
+  }
+  // ── Content surfaces: commands / skills / subagents ──────────────────────
+  // CONTENT-ONLY: pure native-file writers under <configDir>/{commands,skills,
+  // agents}. No runtime dispatch, no home-bin pointer, no telemetry wrap. Each
+  // method is idempotent (byte-identical → skip) via BaseAdapter.writeContentFile
+  // and reversible via removeContentFile. Honors platforms["claude-code"]
+  // per-surface false to skip.
+  commandsDir(ctx) {
+    return join(this.getConfigDir(ctx), "commands");
+  }
+  skillsDir(ctx) {
+    return join(this.getConfigDir(ctx), "skills");
+  }
+  agentsDir(ctx) {
+    return join(this.getConfigDir(ctx), "agents");
+  }
+  /** Native command file path: <configDir>/commands/<name>.md. */
+  commandPath(ctx, name) {
+    return join(this.commandsDir(ctx), `${name}.md`);
+  }
+  /** Native skill dir: <configDir>/skills/<name>. */
+  skillDir(ctx, name) {
+    return join(this.skillsDir(ctx), name);
+  }
+  /** Native subagent file path: <configDir>/agents/<name>.md. */
+  subagentPath(ctx, name) {
+    return join(this.agentsDir(ctx), `${name}.md`);
+  }
+  // ── Commands ──────────────────────────────────────────────────────────────
+  installCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.commands === false) {
+      return [{ platform: this.id, action: "skip", detail: "commands disabled for claude-code" }];
+    }
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.writeContentFile(
+        this.commandPath(ctx, cmd.name),
+        this.renderCommand(cmd),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallCommands(ctx) {
+    const { connector } = ctx;
+    if (connector.commands.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no commands" }];
+    }
+    return connector.commands.map(
+      (cmd) => this.removeContentFile(this.commandPath(ctx, cmd.name), ctx.dryRun)
+    );
+  }
+  /** Render a command to md+frontmatter (delegates to the shared renderer). */
+  renderCommand(cmd) {
+    return renderCommandMd(cmd);
+  }
+  // ── Skills ────────────────────────────────────────────────────────────────
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for claude-code" }];
+    }
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(
+        this.writeContentFile(join(dir, "SKILL.md"), this.renderSkill(skill), ctx.dryRun)
+      );
+      for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            detail: `skill resource "${rel}" escapes the skill dir; skipped`
+          });
+          continue;
+        }
+        changes.push(this.writeContentFile(target, contents, ctx.dryRun));
+      }
+    }
+    return changes;
+  }
+  uninstallSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(this.removeContentFile(join(dir, "SKILL.md"), ctx.dryRun));
+      for (const rel of Object.keys(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) continue;
+        changes.push(this.removeContentFile(target, ctx.dryRun));
+      }
+      changes.push(this.removeDirIfEmpty(dir, ctx.dryRun));
+    }
+    return changes;
+  }
+  /** Render a skill's SKILL.md (delegates to the shared renderer). */
+  renderSkill(skill) {
+    return renderSkillMd(skill);
+  }
+  // ── Subagents ───────────────────────────────────────────────────────────────
+  installSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.subagents === false) {
+      return [{ platform: this.id, action: "skip", detail: "subagents disabled for claude-code" }];
+    }
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => this.writeContentFile(
+        this.subagentPath(ctx, agent.name),
+        this.renderSubagent(agent),
+        ctx.dryRun
+      )
+    );
+  }
+  uninstallSubagents(ctx) {
+    const { connector } = ctx;
+    if (connector.subagents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no subagents" }];
+    }
+    return connector.subagents.map(
+      (agent) => this.removeContentFile(this.subagentPath(ctx, agent.name), ctx.dryRun)
+    );
+  }
+  /** Render a subagent to md+frontmatter (delegates to the shared renderer). */
+  renderSubagent(agent) {
+    return renderSubagentMd(agent);
+  }
+  // ── Memory surface: CLAUDE.md managed block + AGENTS.md interop ────────────
+  // EXCEPTION host. Claude Code reads CLAUDE.md, NOT AGENTS.md (docs verbatim:
+  // "Claude Code reads CLAUDE.md, not AGENTS.md"; no AGENTS.md support through
+  // v2.1.172), so the base AGENTS.md-first default is overridden:
+  //   - mode "block" (default): the managed block goes straight into CLAUDE.md.
+  //     HTML-comment markers are CORRECT here — Claude strips HTML comments
+  //     from CLAUDE.md before context injection, so the markers and the
+  //     do-not-edit notice are INVISIBLE to the model while remaining fully
+  //     parseable by us for sync/doctor/uninstall.
+  //   - mode "agents-import" (opt-in via platforms["claude-code"].memory.mode):
+  //     canonical block goes into AGENTS.md, plus a SHARED `@AGENTS.md` import
+  //     bridge block in CLAUDE.md (Anthropic's documented interop). Opt-in
+  //     because the import makes Claude read the ENTIRE AGENTS.md — a behavior
+  //     change agent-connector must not make silently.
+  //   - AUTO interop: when CLAUDE.md ALREADY imports `@AGENTS.md` (a line
+  //     outside code fences and outside our own blocks) or IS a symlink
+  //     resolving to AGENTS.md, the canonical block goes to AGENTS.md and
+  //     CLAUDE.md is NOT touched — the pre-existing user wiring is never
+  //     claimed as agent-connector-managed (prevents double-reads and writes
+  //     "through" a symlink). Order-independent: keyed off the import/symlink
+  //     existing, never off whether the AGENTS.md block was written yet.
+  /** CLAUDE.md path: project `<projectDir>/CLAUDE.md`, user `~/.claude/CLAUDE.md`. */
+  claudeMdPath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, "CLAUDE.md") : join(homedir(), ".claude", "CLAUDE.md");
+  }
+  /** Sibling AGENTS.md at the same scope (agents-import / auto-interop target). */
+  agentsMdPath(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, "AGENTS.md") : join(homedir(), ".claude", "AGENTS.md");
+  }
+  /**
+   * True when the user ALREADY wired CLAUDE.md to AGENTS.md themselves:
+   * an `@AGENTS.md` import line outside code fences and outside agent-connector
+   * managed blocks (our own bridge must not count), or CLAUDE.md being a
+   * symlink that resolves to the sibling AGENTS.md.
+   */
+  claudeMdWiredToAgentsMd(ctx) {
+    const claudeMd = this.claudeMdPath(ctx);
+    if (!existsSync(claudeMd)) return false;
+    try {
+      if (lstatSync(claudeMd).isSymbolicLink()) {
+        const agentsMd = this.agentsMdPath(ctx);
+        const resolved = realpathSync(claudeMd);
+        const agentsResolved = existsSync(agentsMd) ? realpathSync(agentsMd) : agentsMd;
+        if (resolved === agentsResolved) return true;
+      }
+    } catch {
+    }
+    let raw;
+    try {
+      raw = readFileSync(claudeMd, "utf8");
+    } catch {
+      return false;
+    }
+    const withoutBlocks = removeBlocksFromText(raw, { blockIdPrefix: "" }).text;
+    const importRe = /(^|\s)@(?:AGENTS\.md|~\/\.claude\/AGENTS\.md)(\s|$)/;
+    return linesOutsideFences(withoutBlocks).some((line) => importRe.test(line));
+  }
+  /**
+   * Effective memory mode for this install:
+   *   "user-import"   — the user already wired CLAUDE.md→AGENTS.md (wins over
+   *                     everything; we never write a duplicate or a second import);
+   *   "agents-import" — explicit opt-in via platforms["claude-code"].memory.mode;
+   *   "block"         — the default (managed block directly in CLAUDE.md).
+   */
+  effectiveMemoryMode(ctx) {
+    if (this.claudeMdWiredToAgentsMd(ctx)) return "user-import";
+    return this.memoryOverride(ctx)?.mode === "agents-import" ? "agents-import" : "block";
+  }
+  memoryTargets(ctx) {
+    if (this.memoryOverride(ctx)?.path) return super.memoryTargets(ctx);
+    if (ctx.scope !== "project" && ctx.scope !== "user") return [];
+    const mode = this.effectiveMemoryMode(ctx);
+    if (mode === "block") {
+      return [
+        {
+          path: this.claudeMdPath(ctx),
+          reason: "CLAUDE.md (Claude Code reads CLAUDE.md, not AGENTS.md; HTML-comment markers are stripped from the model's context)"
+        }
+      ];
+    }
+    return [
+      {
+        path: this.agentsMdPath(ctx),
+        reason: mode === "user-import" ? "AGENTS.md (CLAUDE.md already imports/symlinks it \u2014 user wiring respected)" : "AGENTS.md (agents-import mode; @AGENTS.md bridge managed in CLAUDE.md)"
+      }
+    ];
+  }
+  installMemory(ctx) {
+    const changes = super.installMemory(ctx);
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.memory === false || (connector.memory ?? []).length === 0) {
+      return changes;
+    }
+    if (ctx.scope !== "project" && ctx.scope !== "user") return changes;
+    if (this.memoryOverride(ctx)?.path) return changes;
+    const mode = this.effectiveMemoryMode(ctx);
+    if (mode === "user-import") {
+      changes.push({
+        platform: this.id,
+        action: "skip",
+        path: this.claudeMdPath(ctx),
+        detail: "memory: CLAUDE.md already imports AGENTS.md; canonical block in AGENTS.md suffices (pre-existing user import never claimed as managed)"
+      });
+      return changes;
+    }
+    if (mode !== "agents-import") return changes;
+    const claudeMd = this.claudeMdPath(ctx);
+    const importLine = ctx.scope === "project" ? "@AGENTS.md" : "@~/.claude/AGENTS.md";
+    const res = upsertManagedBlockFile(claudeMd, {
+      blockId: CLAUDE_AGENTS_IMPORT_BLOCK_ID,
+      connectorId: "_shared",
+      content: importLine,
+      notice: "Managed by agent-connector (shared bridge). This import makes Claude Code read AGENTS.md; it is removed automatically when the last agent-connector block leaves AGENTS.md.",
+      force: ctx.force ?? false,
+      dryRun: ctx.dryRun
+    });
+    changes.push({
+      platform: this.id,
+      action: res.action,
+      path: claudeMd,
+      detail: `memory: ${res.detail} \u2014 @AGENTS.md import bridge (agents-import mode)`
+    });
+    if (res.backupPath) {
+      changes.push({
+        platform: this.id,
+        action: "create",
+        path: res.backupPath,
+        detail: "backed up CLAUDE.md before destructive change"
+      });
+    }
+    if (res.action !== "warn" && !ctx.dryRun) {
+      const ledger = loadMemoryLedger(connector.id);
+      recordMemoryTarget(ledger, {
+        platform: this.id,
+        scope: ctx.scope,
+        path: claudeMd,
+        blockId: CLAUDE_AGENTS_IMPORT_BLOCK_ID,
+        createdFile: res.createdFile,
+        hash: res.hash
+      });
+      saveMemoryLedger(connector.id, ledger);
+    }
+    return changes;
+  }
+  uninstallMemory(ctx) {
+    const priorRows = loadMemoryLedger(ctx.connector.id).targets.filter(
+      (t) => t.platform === this.id && t.blockId === CLAUDE_AGENTS_IMPORT_BLOCK_ID
+    );
+    const changes = super.uninstallMemory(ctx);
+    const pairs = /* @__PURE__ */ new Map();
+    if (ctx.scope === "project" || ctx.scope === "user") {
+      pairs.set(this.claudeMdPath(ctx), {
+        agentsMd: this.agentsMdPath(ctx),
+        createdFile: false
+      });
+    }
+    for (const row of priorRows) {
+      const existing = pairs.get(row.path);
+      pairs.set(row.path, {
+        agentsMd: existing?.agentsMd ?? join(dirname(row.path), "AGENTS.md"),
+        createdFile: (existing?.createdFile ?? false) || row.createdFile
+      });
+    }
+    for (const [claudeMd, { agentsMd, createdFile }] of pairs) {
+      changes.push(...this.releaseAgentsImportBridge(ctx, claudeMd, agentsMd, createdFile));
+    }
+    return changes;
+  }
+  /**
+   * Refcounted bridge release: remove the `_shared/claude-agents-import` block
+   * from CLAUDE.md ONLY when the sibling AGENTS.md holds zero agent-connector
+   * blocks from OTHER connectors (namespace-wide count, excluding this
+   * connector's own blocks so the answer is identical on dry-run and real run).
+   * A user-authored `@AGENTS.md` import (no markers) is NEVER touched.
+   */
+  releaseAgentsImportBridge(ctx, claudeMd, agentsMd, createdFile) {
+    if (!existsSync(claudeMd)) return [];
+    let raw;
+    try {
+      raw = readFileSync(claudeMd, "utf8");
+    } catch {
+      return [];
+    }
+    if (!listManagedBlocks(raw).some((b) => b.blockId === CLAUDE_AGENTS_IMPORT_BLOCK_ID)) {
+      return [];
+    }
+    let remaining = 0;
+    if (existsSync(agentsMd)) {
+      try {
+        remaining = listManagedBlocks(readFileSync(agentsMd, "utf8")).filter(
+          (b) => !b.blockId.startsWith(`${ctx.connector.id}/`)
+        ).length;
+      } catch {
+        remaining = 1;
+      }
+    }
+    if (remaining > 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: claudeMd,
+          detail: `memory: @AGENTS.md import bridge retained \u2014 ${remaining} agent-connector block(s) from other connectors remain in ${agentsMd}`
+        }
+      ];
+    }
+    return removeManagedBlocksFile(
+      claudeMd,
+      { blockId: CLAUDE_AGENTS_IMPORT_BLOCK_ID },
+      { dryRun: ctx.dryRun, deleteFileIfCreated: createdFile }
+    ).map((r) => ({
+      platform: this.id,
+      action: r.action,
+      path: r.path,
+      detail: `memory: ${r.detail}`
+    }));
+  }
+  /** True when a hook command references our home binary AND this connector id
+   *  (anchored so a shared-prefix id can't collide — see isHomeBinHookCommand). */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const settingsPath = this.getHookConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const hookEvents = ctx.connector.hookEvents;
+    const declaredHookCount = hookEvents.length + Object.keys(ctx.connector.platforms[HOST]?.nativeHooks ?? {}).length;
+    const checks = [
+      {
+        name: `${this.name}: settings.json present`,
+        check: () => {
+          if (declaredHookCount === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          return existsSync(settingsPath) ? { status: "OK", detail: settingsPath } : { status: "FAIL", detail: `not found: ${settingsPath}` };
+        }
+      },
+      {
+        name: `${this.name}: hook command registered`,
+        check: () => {
+          if (declaredHookCount === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const settings = this.readJson(
+            settingsPath
+          );
+          if (!settings) return { status: "FAIL", detail: `cannot read ${settingsPath}` };
+          const hooks = settings.hooks ?? {};
+          const registered = Object.values(hooks).some(
+            (entries) => (entries ?? []).some(
+              (e) => (e.hooks ?? []).some(
+                (h) => isHomeBinHookCommand(h.command, homeBin, connectorId)
+              )
+            )
+          );
+          return registered ? { status: "OK", detail: "hook command present" } : {
+            status: "FAIL",
+            detail: `no hook for ${connectorId} in ${settingsPath}`
+          };
+        }
+      }
+    ];
+    for (const cmd of ctx.connector.commands) {
+      const p = this.commandPath(ctx, cmd.name);
+      checks.push({
+        name: `${this.name}: command ${cmd.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const skill of ctx.connector.skills) {
+      const p = join(this.skillDir(ctx, skill.name), "SKILL.md");
+      checks.push({
+        name: `${this.name}: skill ${skill.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    for (const agent of ctx.connector.subagents) {
+      const p = this.subagentPath(ctx, agent.name);
+      checks.push({
+        name: `${this.name}: subagent ${agent.name} present`,
+        check: () => existsSync(p) ? { status: "OK", detail: p } : { status: "FAIL", detail: `not found: ${p}` }
+      });
+    }
+    return checks;
+  }
+  // ── Runtime: parse Claude stdin JSON → normalized event ──────────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = extractSessionId(input);
+    const projectDir = typeof input.cwd === "string" ? input.cwd : void 0;
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...toolResponseToString(input.tool_response) !== void 0 ? { toolOutput: toolResponseToString(input.tool_response) } : {}
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source)
+        };
+        return ev;
+      }
+      case "SessionEnd": {
+        const ev = {
+          ...base,
+          ...typeof input.reason === "string" ? { reason: input.reason } : {}
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "PreCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "Notification": {
+        const ev = {
+          ...base,
+          message: typeof input.message === "string" ? input.message : ""
+        };
+        return ev;
+      }
+      case "PermissionRequest": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...Array.isArray(input.permission_suggestions) ? { permissionSuggestions: input.permission_suggestions } : {}
+        };
+        return ev;
+      }
+      case "PostToolUseFailure": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          error: typeof input.error === "string" ? input.error : "",
+          ...typeof input.tool_use_id === "string" ? { toolUseId: input.tool_use_id } : {},
+          ...typeof input.is_interrupt === "boolean" ? { isInterrupt: input.is_interrupt } : {},
+          ...typeof input.duration_ms === "number" ? { durationMs: input.duration_ms } : {}
+        };
+        return ev;
+      }
+      case "SubagentStart": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_id === "string" ? { agentId: input.agent_id } : {},
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {}
+        };
+        return ev;
+      }
+      case "SubagentStop": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_id === "string" ? { agentId: input.agent_id } : {},
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {},
+          ...typeof input.agent_transcript_path === "string" ? { agentTranscriptPath: input.agent_transcript_path } : {},
+          ...typeof input.last_assistant_message === "string" ? { lastAssistantMessage: input.last_assistant_message } : {},
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      default: {
+        const _never = event;
+        throw new Error(`unsupported claude-code hook event: ${String(_never)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → Claude native hook reply ──────────────
+  formatReply(event, response) {
+    const hookEventName = event;
+    const decision = response.decision ?? "allow";
+    if (event === "PermissionRequest") {
+      if (response.decision === "deny") {
+        return this.stdout({
+          hookSpecificOutput: {
+            hookEventName,
+            decision: {
+              behavior: "deny",
+              message: response.reason ?? "Blocked by hook"
+            }
+          }
+        });
+      }
+      if (response.decision === "allow" || response.decision === "modify" && response.updatedInput) {
+        return this.stdout({
+          hookSpecificOutput: {
+            hookEventName,
+            decision: {
+              behavior: "allow",
+              ...response.updatedInput ? { updatedInput: response.updatedInput } : {}
+            }
+          }
+        });
+      }
+      return { exitCode: 0 };
+    }
+    if (event === "PostToolUseFailure" || event === "SubagentStart") {
+      const context = decision === "context" ? response.additionalContext : decision === "deny" ? response.reason ?? response.additionalContext : void 0;
+      if (context) {
+        return this.stdout({
+          hookSpecificOutput: { hookEventName, additionalContext: context }
+        });
+      }
+      return { exitCode: 0 };
+    }
+    if (decision === "deny") {
+      if (event === "Stop" || event === "SubagentStop" || event === "UserPromptSubmit" || event === "PostToolUse") {
+        return this.stdout({
+          decision: "block",
+          reason: response.reason ?? "Blocked by hook"
+        });
+      }
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "deny",
+          permissionDecisionReason: response.reason ?? "Blocked by hook"
+        }
+      });
+    }
+    if (decision === "ask") {
+      return this.stdout({
+        hookSpecificOutput: {
+          hookEventName,
+          permissionDecision: "ask",
+          permissionDecisionReason: response.reason ?? "Confirmation required by hook"
+        }
+      });
+    }
+    if (decision === "modify") {
+      if (event === "PreToolUse" && response.updatedInput) {
+        return this.stdout({
+          hookSpecificOutput: { hookEventName, updatedInput: response.updatedInput }
+        });
+      }
+    }
+    if (decision === "context" && response.additionalContext) {
+      return this.stdout({
+        hookSpecificOutput: { hookEventName, additionalContext: response.additionalContext }
+      });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+var SENSITIVE_KEY_RULES = [
+  { re: /^permissions(\.|$)/, label: "permissions" },
+  { re: /^allowedTools(\.|$)/, label: "allowedTools" },
+  { re: /^disallowedTools(\.|$)/, label: "disallowedTools" },
+  { re: /^apiKey/i, label: "apiKey*" },
+  { re: /^awsAuthRefresh$/, label: "awsAuthRefresh" },
+  { re: /^awsCredentialExport$/, label: "awsCredentialExport" },
+  { re: /^forceLoginMethod$/, label: "forceLoginMethod" },
+  { re: /^forceLoginOrgUUID$/, label: "forceLoginOrgUUID" },
+  { re: /^otelHeadersHelper$/, label: "otelHeadersHelper" },
+  { re: /^env\.ANTHROPIC_/, label: "env.ANTHROPIC_*" },
+  { re: /^env\.AWS_/, label: "env.AWS_*" },
+  { re: /^env\.[^.]*_PROXY(\.|$)/i, label: "env.*_PROXY" },
+  { re: /^env\.[^.]*TOKEN/i, label: "env.*TOKEN*" },
+  { re: /^env\.[^.]*KEY/i, label: "env.*KEY*" },
+  { re: /^env\.[^.]*SECRET/i, label: "env.*SECRET*" }
+];
+function claudeSensitiveKeyViolation(key) {
+  for (const rule of SENSITIVE_KEY_RULES) {
+    if (rule.re.test(key)) return rule.label;
+  }
+  return null;
+}
+function readJsonLeaf(root, segments) {
+  let node = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const next = node[segments[i]];
+    if (next === void 0) return { kind: "absent" };
+    if (next === null || typeof next !== "object" || Array.isArray(next)) {
+      return { kind: "blocked", atPath: segments.slice(0, i + 1).join(".") };
+    }
+    node = next;
+  }
+  const leaf = node[segments[segments.length - 1]];
+  if (leaf === void 0) return { kind: "absent" };
+  return { kind: "present", value: leaf };
+}
+function writeJsonLeaf(root, segments, value) {
+  let node = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const next = node[seg];
+    if (next === void 0) {
+      const created = {};
+      node[seg] = created;
+      node = created;
+    } else {
+      node = next;
+    }
+  }
+  node[segments[segments.length - 1]] = value;
+}
+function deleteJsonLeaf(root, segments) {
+  let node = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const next = node[segments[i]];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) return;
+    node = next;
+  }
+  delete node[segments[segments.length - 1]];
+}
+function claudeEnvToken(name) {
+  return `\${${name}}`;
+}
+function normalizeSessionSource(source) {
+  switch (source) {
+    case "compact":
+      return "compact";
+    case "resume":
+      return "resume";
+    case "clear":
+      return "clear";
+    default:
+      return "startup";
+  }
+}
+var adapter = new ClaudeCodeAdapter();
+var claude_code_default = adapter;
+export {
+  ClaudeCodeAdapter,
+  adapter,
+  claudeSensitiveKeyViolation,
+  claude_code_default as default
+};
+//# sourceMappingURL=claude-code-4275HQU4.js.map