@ken-jo/agent-connector 0.1.0 → 0.3.0

package/dist/{chunk-XUCWLJY5.js → chunk-NJU275US.js}

@@ -4,39 +4,39 @@
 var ADAPTER_REGISTRY = [
   {
     id: "claude-code",
-    load: () => import("./claude-code-HKDV7T32.js").then((m) => m.default)
+    load: () => import("./claude-code-4275HQU4.js").then((m) => m.default)
   },
   {
     id: "codex",
-    load: () => import("./codex-JFQTS6LU.js").then((m) => m.default)
+    load: () => import("./codex-4BY2ZJIW.js").then((m) => m.default)
   },
   {
     id: "cursor",
-    load: () => import("./cursor-4TMXKJOZ.js").then((m) => m.default)
+    load: () => import("./cursor-UH3W622V.js").then((m) => m.default)
   },
   // vscode-copilot after cursor: cursor is a VS Code fork, so the fork's runtime
   // markers must be checked first during host detection.
   {
     id: "vscode-copilot",
-    load: () => import("./vscode-copilot-CK3NO54M.js").then((m) => m.default)
+    load: () => import("./vscode-copilot-4RVRTCKV.js").then((m) => m.default)
   },
   {
     id: "copilot-cli",
-    load: () => import("./copilot-cli-MTCGHZ2T.js").then((m) => m.default)
+    load: () => import("./copilot-cli-IPISKO3V.js").then((m) => m.default)
   },
   {
     id: "gemini-cli",
-    load: () => import("./gemini-cli-Y35FFK4M.js").then((m) => m.default)
+    load: () => import("./gemini-cli-ZSUK55UA.js").then((m) => m.default)
   },
   {
     id: "warp",
-    load: () => import("./warp-QNVDXOG4.js").then((m) => m.default)
+    load: () => import("./warp-X6MB67NT.js").then((m) => m.default)
   },
   // ts-plugin paradigm: OpenCode loads a generated plugin module that bridges
   // its in-process events to the universal hook entrypoint.
   {
     id: "opencode",
-    load: () => import("./opencode-FZ33JKUZ.js").then((m) => m.default)
+    load: () => import("./opencode-NZBRLJN3.js").then((m) => m.default)
   },
   // kilo-cli is the SQLite-backed OpenCode FORK command-line product (ts-plugin,
   // loads @kilocode/plugin modules registered in kilo.jsonc's "plugin" array;
@@ -45,27 +45,27 @@ var ADAPTER_REGISTRY = [
   // the "kilo" extension so there is no fork-ordering constraint between them.
   {
     id: "kilo-cli",
-    load: () => import("./kilo-cli-EAQTHXUW.js").then((m) => m.default)
+    load: () => import("./kilo-cli-QWUVXG2O.js").then((m) => m.default)
   },
   // Wave 1 — mcp-only adapters (no lifecycle hooks; MCP registration only).
   {
     id: "droid",
-    load: () => import("./droid-KN6VRMMT.js").then((m) => m.default)
+    load: () => import("./droid-T5VBRXZF.js").then((m) => m.default)
   },
   {
     id: "roo-code",
-    load: () => import("./roo-code-IOIUXRDE.js").then((m) => m.default)
+    load: () => import("./roo-code-NI5UU6JB.js").then((m) => m.default)
   },
   // kilo is the Kilo Code VS Code extension (kilocode.kilo-code) — a Roo/Cline
   // fork, so it sits beside roo-code (mcp-only, root key "mcpServers", VS Code
   // globalStorage / .kilocode project scope). Distinct host from "kilo-cli".
   {
     id: "kilo",
-    load: () => import("./kilo-QXJRCSLT.js").then((m) => m.default)
+    load: () => import("./kilo-PKAJCWPX.js").then((m) => m.default)
   },
   {
     id: "trae",
-    load: () => import("./trae-JSNDZFKL.js").then((m) => m.default)
+    load: () => import("./trae-CQC72RHH.js").then((m) => m.default)
   },
   // antigravity-cli BEFORE antigravity: the `agy` CLI is a fork of the IDE
   // adapter with its own runtime markers (the universal hook command tags the
@@ -73,73 +73,73 @@ var ADAPTER_REGISTRY = [
   // before the IDE/parent during host detection.
   {
     id: "antigravity-cli",
-    load: () => import("./antigravity-cli-YQDFVV4U.js").then((m) => m.default)
+    load: () => import("./antigravity-cli-JEOUP2VN.js").then((m) => m.default)
   },
   {
     id: "antigravity",
-    load: () => import("./antigravity-CX2YLSY7.js").then((m) => m.default)
+    load: () => import("./antigravity-7IBYFO6P.js").then((m) => m.default)
   },
   {
     id: "zed",
-    load: () => import("./zed-VRJKWYUR.js").then((m) => m.default)
+    load: () => import("./zed-NTCYW4V2.js").then((m) => m.default)
   },
   {
     id: "amp",
-    load: () => import("./amp-QSFH2V7Y.js").then((m) => m.default)
+    load: () => import("./amp-YGV66GJT.js").then((m) => m.default)
   },
   {
     id: "codebuff",
-    load: () => import("./codebuff-QX57FJDN.js").then((m) => m.default)
+    load: () => import("./codebuff-LE3KBZGM.js").then((m) => m.default)
   },
   {
     id: "mux",
-    load: () => import("./mux-T2TV4CIQ.js").then((m) => m.default)
+    load: () => import("./mux-5CI5FP2W.js").then((m) => m.default)
   },
   // Pi — mcp-only host with no writable MCP config; drives the Agent Skills
   // surface only (writes <piDir>/skills/<name>/SKILL.md).
   {
     id: "pi",
-    load: () => import("./pi-CIU2QHT4.js").then((m) => m.default)
+    load: () => import("./pi-WMTUX6ES.js").then((m) => m.default)
   },
   // Wave 2 — json-stdio adapters (full hook dispatch via the universal entrypoint).
   // jetbrains-copilot before vscode-copilot is unnecessary (distinct hosts); grouped here.
   {
     id: "jetbrains-copilot",
-    load: () => import("./jetbrains-copilot-HWA3DMH7.js").then((m) => m.default)
+    load: () => import("./jetbrains-copilot-C3HDGGML.js").then((m) => m.default)
   },
   {
     id: "qwen-code",
-    load: () => import("./qwen-code-5POCNU6P.js").then((m) => m.default)
+    load: () => import("./qwen-code-MRRIUQ3P.js").then((m) => m.default)
   },
   {
     id: "kiro",
-    load: () => import("./kiro-VQTT6LO2.js").then((m) => m.default)
+    load: () => import("./kiro-UQRY6EIO.js").then((m) => m.default)
   },
   {
     id: "kimi",
-    load: () => import("./kimi-GQ7VXNYT.js").then((m) => m.default)
+    load: () => import("./kimi-EVD7YKXS.js").then((m) => m.default)
   },
   {
     id: "crush",
-    load: () => import("./crush-I7PK3FGI.js").then((m) => m.default)
+    load: () => import("./crush-X3E25EQG.js").then((m) => m.default)
   },
   // Wave 3 — json-stdio adapters with YAML config (MCP in YAML; hooks per host).
   {
     id: "goose",
-    load: () => import("./goose-ZTGTSUFJ.js").then((m) => m.default)
+    load: () => import("./goose-M3RR3CZG.js").then((m) => m.default)
   },
   {
     id: "hermes",
-    load: () => import("./hermes-H2KV44GK.js").then((m) => m.default)
+    load: () => import("./hermes-CUNKIAR5.js").then((m) => m.default)
   },
   // Wave 4 — ts-plugin adapters (generate a bridge module to the universal entrypoint).
   {
     id: "omp",
-    load: () => import("./omp-PB4VDKS6.js").then((m) => m.default)
+    load: () => import("./omp-AXA7XY22.js").then((m) => m.default)
   },
   {
     id: "openclaw",
-    load: () => import("./openclaw-ETN2M63O.js").then((m) => m.default)
+    load: () => import("./openclaw-UZ5BMCGQ.js").then((m) => m.default)
   }
 ];
 var REGISTRY_BY_ID = new Map(
@@ -235,4 +235,4 @@ export {
   detectInstalledPlatforms,
   detectRuntimeHost
 };
-//# sourceMappingURL=chunk-XUCWLJY5.js.map
+//# sourceMappingURL=chunk-NJU275US.js.map

package/dist/{chunk-WCETQWWK.js → chunk-OP4KBXUO.js}

@@ -1,19 +1,4 @@
 #!/usr/bin/env node
-import {
-  resolveSpawnCommand
-} from "./chunk-MEH7GC7R.js";
-
-// src/core/spawn-child.ts
-import { spawn } from "child_process";
-function winQuoteArg(s) {
-  return `"${s.replace(/"/g, '""')}"`;
-}
-function spawnChild(command, args, options) {
-  const resolved = resolveSpawnCommand(command);
-  if (!resolved.needsShell) return spawn(resolved.file, args, options);
-  const line = [resolved.file, ...args].map(winQuoteArg).join(" ");
-  return spawn(line, { ...options, shell: true });
-}
 
 // src/telemetry/jsonrpc.ts
 import { StringDecoder } from "string_decoder";
@@ -51,9 +36,8 @@ var LineBuffer = class {
 };
 
 export {
-  spawnChild,
   isObject,
   idKey,
   LineBuffer
 };
-//# sourceMappingURL=chunk-WCETQWWK.js.map
+//# sourceMappingURL=chunk-OP4KBXUO.js.map

package/dist/chunk-OP4KBXUO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/telemetry/jsonrpc.ts"],"sourcesContent":["/**\n * telemetry/jsonrpc — shared MCP stdio wire primitives.\n *\n * The MCP stdio transport is NEWLINE-DELIMITED JSON-RPC: one single-line JSON\n * object per message, terminated by `\\n` (no Content-Length framing). These\n * primitives — the message shape, the id key, the line buffer — are used by BOTH\n * the telemetry proxy (which tees + measures) and `doctor --probe` (which sends\n * a real initialize/ping/tools-list handshake), so framing + id-correlation are\n * byte-identical across the two paths. Extracted here rather than duplicated.\n */\n\nimport { StringDecoder } from \"node:string_decoder\";\n\n/** Any newline-delimited JSON-RPC message — request, response, or notification. */\nexport interface JsonRpcMessage {\n  jsonrpc?: unknown;\n  id?: unknown;\n  method?: unknown;\n  params?: unknown;\n  result?: unknown;\n  error?: unknown;\n}\n\nexport function isObject(v: unknown): v is Record<string, unknown> {\n  return typeof v === \"object\" && v !== null;\n}\n\n/** JSON-RPC ids are number | string; normalize to a Map key. `null` → no key. */\nexport function idKey(id: unknown): string | null {\n  if (typeof id === \"string\") return `s:${id}`;\n  if (typeof id === \"number\") return `n:${id}`;\n  return null;\n}\n\n/**\n * Buffer a byte stream into complete `\\n`-terminated lines and invoke `onLine`\n * for each. Carriage returns are tolerated (some hosts emit CRLF). This is a\n * pure side-channel: it never owns or mutates the bytes being forwarded — the\n * caller has already written the original chunk downstream verbatim.\n */\nexport class LineBuffer {\n  private buf = \"\";\n  private readonly onLine: (line: string) => void;\n  // Incremental UTF-8 decoder: `data` events split on arbitrary byte\n  // boundaries, so a multi-byte sequence (emoji/CJK in a tool arg or result)\n  // can straddle two chunks. StringDecoder holds back a trailing partial\n  // sequence until it completes, keeping the measured copy byte-accurate.\n  // (The forwarded stream is untouched — this is only the tee copy.)\n  private readonly decoder = new StringDecoder(\"utf8\");\n\n  constructor(onLine: (line: string) => void) {\n    this.onLine = onLine;\n  }\n\n  push(chunk: Buffer): void {\n    this.buf += this.decoder.write(chunk);\n    let nl = this.buf.indexOf(\"\\n\");\n    while (nl !== -1) {\n      // Slice off one line (without the newline), tolerate a trailing CR.\n      let line = this.buf.slice(0, nl);\n      if (line.endsWith(\"\\r\")) line = line.slice(0, -1);\n      if (line.length > 0) this.onLine(line);\n      this.buf = this.buf.slice(nl + 1);\n      nl = this.buf.indexOf(\"\\n\");\n    }\n  }\n}\n"],"mappings":";;;AAWA,SAAS,qBAAqB;AAYvB,SAAS,SAAS,GAA0C;AACjE,SAAO,OAAO,MAAM,YAAY,MAAM;AACxC;AAGO,SAAS,MAAM,IAA4B;AAChD,MAAI,OAAO,OAAO,SAAU,QAAO,KAAK,EAAE;AAC1C,MAAI,OAAO,OAAO,SAAU,QAAO,KAAK,EAAE;AAC1C,SAAO;AACT;AAQO,IAAM,aAAN,MAAiB;AAAA,EACd,MAAM;AAAA,EACG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAU,IAAI,cAAc,MAAM;AAAA,EAEnD,YAAY,QAAgC;AAC1C,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,KAAK,OAAqB;AACxB,SAAK,OAAO,KAAK,QAAQ,MAAM,KAAK;AACpC,QAAI,KAAK,KAAK,IAAI,QAAQ,IAAI;AAC9B,WAAO,OAAO,IAAI;AAEhB,UAAI,OAAO,KAAK,IAAI,MAAM,GAAG,EAAE;AAC/B,UAAI,KAAK,SAAS,IAAI,EAAG,QAAO,KAAK,MAAM,GAAG,EAAE;AAChD,UAAI,KAAK,SAAS,EAAG,MAAK,OAAO,IAAI;AACrC,WAAK,MAAM,KAAK,IAAI,MAAM,KAAK,CAAC;AAChC,WAAK,KAAK,IAAI,QAAQ,IAAI;AAAA,IAC5B;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-TIIP3RG2.js → chunk-PD4VFEBY.js}

@@ -2,6 +2,15 @@
 import {
   renderFrontmatterMd
 } from "./chunk-7L6ITC4T.js";
+import {
+  MEMORY_CONTENT_SOFT_BUDGET_BYTES,
+  listManagedBlocks,
+  loadMemoryLedger,
+  recordMemoryTarget,
+  removeManagedBlocksFile,
+  saveMemoryLedger,
+  upsertManagedBlockFile
+} from "./chunk-N6HH7K6P.js";
 import {
   backupsDir,
   ensureDir
@@ -100,7 +109,48 @@ import {
   statSync,
   writeFileSync
 } from "fs";
-import { basename, dirname, join, relative, resolve, sep } from "path";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
+var AGENTS_MD_USER_PATHS = {
+  // codex resolves its own user path in-adapter ($CODEX_HOME with ~ expansion
+  // + the AGENTS.override.md shadow probe) — deliberately no row here.
+  zed: () => ({
+    path: process.platform === "win32" && process.env.APPDATA ? join(process.env.APPDATA, "Zed", "AGENTS.md") : join(homedir(), ".config", "zed", "AGENTS.md"),
+    reason: "zed personal instructions file"
+  }),
+  amp: () => ({
+    path: join(homedir(), ".config", "amp", "AGENTS.md"),
+    reason: "amp user-scope AGENTS.md"
+  }),
+  mux: () => ({
+    path: join(homedir(), ".mux", "AGENTS.md"),
+    reason: "mux global AGENTS.md"
+  }),
+  pi: () => ({
+    path: join(homedir(), ".pi", "agent", "AGENTS.md"),
+    reason: "pi global AGENTS.md"
+  }),
+  droid: () => ({
+    path: join(homedir(), ".factory", "AGENTS.md"),
+    reason: "droid (Factory) personal AGENTS.md"
+  }),
+  opencode: () => ({
+    path: join(homedir(), ".config", "opencode", "AGENTS.md"),
+    reason: "opencode global AGENTS.md"
+  }),
+  antigravity: () => ({
+    path: join(homedir(), ".gemini", "AGENTS.md"),
+    reason: "antigravity global rules (~/.gemini/AGENTS.md, shared tree)"
+  }),
+  "antigravity-cli": () => ({
+    path: join(homedir(), ".gemini", "AGENTS.md"),
+    reason: "agy shares the IDE's ~/.gemini tree (idempotent upsert dedupes)"
+  }),
+  omp: () => ({
+    path: join(homedir(), ".omp", "agent", "AGENTS.md"),
+    reason: "omp global AGENTS.md (pi-parity; verify for your version)"
+  })
+};
 var BaseAdapter = class {
   // ── Content surfaces (commands / skills / subagents) ─────────────────────
   // CONCRETE (overridable) defaults so every adapter inherits all six methods
@@ -126,6 +176,295 @@ var BaseAdapter = class {
   uninstallSubagents(ctx) {
     return this.unsupportedSurface(ctx, "subagents", ctx.connector.subagents.length);
   }
+  // ── Memory surface (managed marker blocks; AGENTS.md-first) ───────────────
+  // ONE generic implementation for every supporting host: the per-adapter
+  // `memoryTargets()` hook resolves WHERE to write (AGENTS.md defaults below;
+  // claude-code → CLAUDE.md and gemini-cli → GEMINI.md override it), and the
+  // core/managed-block engine performs the surgical, hash-stamped block edit.
+  // Unlike commands/skills/subagents these files are SHARED and user-authored —
+  // bytes outside this connector's own marker pair are never touched.
+  /**
+   * Resolve the memory/rules file(s) this host actually reads at ctx.scope.
+   * Base default (AGENTS.md-first, owner mandate):
+   *   - an explicit `platforms[<id>].memory.path` override wins;
+   *   - project scope → `<projectDir>/AGENTS.md` (the agents.md standard);
+   *   - user scope → the host's documented user-scope AGENTS.md, when one
+   *     exists ({@link AGENTS_MD_USER_PATHS}); otherwise [] → skip-warn.
+   * Exception hosts (claude-code, gemini-cli) override this hook.
+   */
+  memoryTargets(ctx) {
+    const override = this.memoryOverride(ctx);
+    if (override?.path) {
+      const base = ctx.scope === "project" ? ctx.projectDir : homedir();
+      return [
+        {
+          path: isAbsolute(override.path) ? override.path : join(base, override.path),
+          reason: `platforms.${this.id}.memory.path override`
+        }
+      ];
+    }
+    if (ctx.scope === "project") {
+      return [
+        { path: join(ctx.projectDir, "AGENTS.md"), reason: "AGENTS.md standard (project root)" }
+      ];
+    }
+    if (ctx.scope === "user") {
+      const user = AGENTS_MD_USER_PATHS[this.id]?.();
+      return user ? [user] : [];
+    }
+    return [];
+  }
+  /** The per-platform memory override object, when one is declared. */
+  memoryOverride(ctx) {
+    const o = ctx.connector.platforms[this.id]?.memory;
+    return o && typeof o === "object" ? o : void 0;
+  }
+  installMemory(ctx) {
+    const { connector } = ctx;
+    const entries = connector.memory ?? [];
+    if (connector.platforms[this.id]?.memory === false) {
+      return [{ platform: this.id, action: "skip", detail: `memory disabled for ${this.id}` }];
+    }
+    if (entries.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no memory" }];
+    }
+    if (!(this.capabilities.supportsMemory ?? false)) {
+      return this.unsupportedSurface(ctx, "memory", entries.length);
+    }
+    const changes = [];
+    const override = this.memoryOverride(ctx);
+    if (override?.mode && this.id !== "claude-code") {
+      changes.push({
+        platform: this.id,
+        action: "warn",
+        detail: `memory.mode is claude-code-only; ignored on ${this.id}`
+      });
+    }
+    if (ctx.scope !== "project" && ctx.scope !== "user") {
+      changes.push({
+        platform: this.id,
+        action: "warn",
+        detail: `memory not supported at ${ctx.scope} scope on ${this.id} (managed/admin memory files are out of scope); ${entries.length} skipped`
+      });
+      return changes;
+    }
+    const targets = this.memoryTargets(ctx);
+    if (targets.length === 0) {
+      changes.push({
+        platform: this.id,
+        action: "warn",
+        detail: `no ${ctx.scope}-scope memory file on ${this.id} (user rules are app/UI-managed or undocumented); ${entries.length} skipped`
+      });
+      return changes;
+    }
+    changes.push(...this.writeMemoryBlocks(ctx, targets));
+    return changes;
+  }
+  /**
+   * Upsert every declared memory entry's block into every resolved target and
+   * record the ownership ledger rows (`connectorDir(id)/memory-state.json`).
+   * Shared by the base implementation and the exception-host overrides.
+   */
+  writeMemoryBlocks(ctx, targets) {
+    const changes = [];
+    const ledger = loadMemoryLedger(ctx.connector.id);
+    let ledgerMutated = false;
+    for (const target of targets) {
+      for (const entry of ctx.connector.memory ?? []) {
+        const blockId = `${ctx.connector.id}/${entry.name ?? "memory"}`;
+        const res = upsertManagedBlockFile(target.path, {
+          blockId,
+          connectorId: ctx.connector.id,
+          content: entry.content,
+          ...target.commentStyle ? { commentStyle: target.commentStyle } : {},
+          force: ctx.force ?? false,
+          dryRun: ctx.dryRun
+        });
+        changes.push({
+          platform: this.id,
+          action: res.action,
+          path: target.path,
+          detail: `memory: ${res.detail} \u2014 ${target.reason}`
+        });
+        if (res.backupPath) {
+          changes.push({
+            platform: this.id,
+            action: "create",
+            path: res.backupPath,
+            detail: "backed up memory file before destructive change"
+          });
+        }
+        const bytes = Buffer.byteLength(entry.content, "utf8");
+        if (bytes > MEMORY_CONTENT_SOFT_BUDGET_BYTES) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: target.path,
+            detail: `memory entry "${entry.name ?? "memory"}" is ${bytes} bytes (soft budget ${MEMORY_CONTENT_SOFT_BUDGET_BYTES}); this file is injected into every prompt \u2014 keep guidance terse`
+          });
+        }
+        if (res.action !== "warn") {
+          recordMemoryTarget(ledger, {
+            platform: this.id,
+            scope: ctx.scope,
+            path: target.path,
+            blockId,
+            createdFile: res.createdFile,
+            hash: res.hash
+          });
+          ledgerMutated = true;
+        }
+      }
+      if (target.budgetBytes !== void 0 && !ctx.dryRun && existsSync(target.path)) {
+        const fileBytes = statSync(target.path).size;
+        if (fileBytes > target.budgetBytes) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: target.path,
+            detail: `memory file is ${fileBytes} bytes \u2014 over this host's ~${target.budgetBytes}-byte budget; the host may truncate or drop it`
+          });
+        }
+      }
+    }
+    if (ledgerMutated && !ctx.dryRun) saveMemoryLedger(ctx.connector.id, ledger);
+    return changes;
+  }
+  uninstallMemory(ctx) {
+    const { connector } = ctx;
+    if (!(this.capabilities.supportsMemory ?? false)) {
+      return this.unsupportedSurface(ctx, "memory", (connector.memory ?? []).length);
+    }
+    const ledger = loadMemoryLedger(connector.id);
+    const mine = ledger.targets.filter((t) => t.platform === this.id);
+    const candidates = /* @__PURE__ */ new Map();
+    if (ctx.scope === "project" || ctx.scope === "user") {
+      for (const t of this.memoryTargets(ctx)) {
+        candidates.set(t.path, { createdFile: false });
+      }
+    }
+    for (const row of mine) {
+      const existing = candidates.get(row.path);
+      candidates.set(row.path, { createdFile: (existing?.createdFile ?? false) || row.createdFile });
+    }
+    if (candidates.size === 0) {
+      return [
+        { platform: this.id, action: "skip", detail: `no memory targets to clean on ${this.id}` }
+      ];
+    }
+    const changes = [];
+    for (const [path, { createdFile }] of candidates) {
+      const results = removeManagedBlocksFile(
+        path,
+        { blockIdPrefix: `${connector.id}/` },
+        { dryRun: ctx.dryRun, deleteFileIfCreated: createdFile }
+      );
+      for (const r of results) {
+        changes.push({
+          platform: this.id,
+          action: r.action,
+          path: r.path,
+          detail: `memory: ${r.detail}`
+        });
+        if (r.backupPath) {
+          changes.push({
+            platform: this.id,
+            action: "create",
+            path: r.backupPath,
+            detail: "backed up memory file before block removal"
+          });
+        }
+      }
+    }
+    if (!ctx.dryRun && mine.length > 0) {
+      ledger.targets = ledger.targets.filter((t) => t.platform !== this.id);
+      saveMemoryLedger(connector.id, ledger);
+    }
+    return changes;
+  }
+  /**
+   * Doctor: per-ledger-row memory state for this platform — file present,
+   * block present, and recorded-vs-actual inner hash (drift → warn, the
+   * user edited inside our block; sync reports the same drift and never
+   * clobbers it without --force).
+   */
+  memoryDiagnostics(ctx) {
+    const results = [];
+    const rows = loadMemoryLedger(ctx.connector.id).targets.filter(
+      (t) => t.platform === this.id
+    );
+    for (const row of rows) {
+      const check = `${this.name}: memory block ${row.blockId}`;
+      if (!existsSync(row.path)) {
+        results.push({
+          check,
+          status: "warn",
+          message: `memory file missing: ${row.path}`,
+          fix: "agent-connector install (sync) will re-create the block"
+        });
+        continue;
+      }
+      let raw;
+      try {
+        raw = readFileSync(row.path, "utf8");
+      } catch {
+        results.push({ check, status: "warn", message: `cannot read ${row.path}` });
+        continue;
+      }
+      const block = listManagedBlocks(raw).find((b) => b.blockId === row.blockId);
+      if (!block) {
+        results.push({
+          check,
+          status: "warn",
+          message: `managed block not found in ${row.path}`,
+          fix: "agent-connector install (sync) will re-append it"
+        });
+      } else if (block.drifted) {
+        results.push({
+          check,
+          status: "warn",
+          message: `user-edited: inner content hash ${block.actualHash} differs from recorded ${block.recordedHash} in ${row.path}; sync leaves it intact (use --force to overwrite)`
+        });
+      } else {
+        results.push({ check, status: "pass", message: `intact in ${row.path}` });
+      }
+      if (!row.blockId.startsWith("_shared/") && row.scope === ctx.scope && (ctx.scope === "project" || ctx.scope === "user")) {
+        const current = this.memoryTargets(ctx);
+        if (current.length > 0 && !current.some((t) => t.path === row.path)) {
+          results.push({
+            check,
+            status: "warn",
+            message: `${this.id} now resolves its ${row.scope}-scope memory file to ${current[0].path} (${current[0].reason}) \u2014 the block in ${row.path} may no longer be read`,
+            fix: "agent-connector install (sync) re-probes and writes the file the host reads now"
+          });
+        }
+      }
+    }
+    return results;
+  }
+  // ── Declarative host-config key patches (configPatch) ─────────────────────
+  // CONCRETE (overridable) defaults, mirroring the content surfaces above: the
+  // installer additionally guards these behind capabilities.supportsConfigPatch
+  // (the nativeHooks precedent), so these defaults only fire if a capability-
+  // flagged adapter forgot to override them — still skip-warn, never silent.
+  installConfigPatches(ctx) {
+    const count = (ctx.connector.platforms[this.id]?.configPatch ?? []).length;
+    if (count === 0) {
+      return [
+        { platform: this.id, action: "skip", detail: "connector declares no configPatch entries" }
+      ];
+    }
+    return [
+      {
+        platform: this.id,
+        action: "warn",
+        detail: `configPatch not supported on ${this.id}; ${count} skipped`
+      }
+    ];
+  }
+  uninstallConfigPatches(_ctx) {
+    return [];
+  }
   /**
    * Default response for a content surface this platform cannot honor: a single
    * skip when the connector declares none of that surface, else a single "warn"
@@ -409,6 +748,7 @@ var BaseAdapter = class {
         message: r.detail ?? r.status
       });
     }
+    results.push(...this.memoryDiagnostics(ctx));
     return results;
   }
 };
@@ -417,4 +757,4 @@ export {
   parseJsonc,
   BaseAdapter
 };
-//# sourceMappingURL=chunk-TIIP3RG2.js.map
+//# sourceMappingURL=chunk-PD4VFEBY.js.map