@ken-jo/agent-connector 0.1.0 → 0.2.0

package/dist/chunk-N6HH7K6P.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+import {
+  backupsDir,
+  connectorDir,
+  ensureDir
+} from "./chunk-TRQKHP7D.js";
+
+// src/core/managed-block.ts
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join } from "path";
+var MANAGED_BLOCK_BEGIN_TOKEN = "agent-connector:begin";
+var MANAGED_BLOCK_END_TOKEN = "agent-connector:end";
+var MEMORY_CONTENT_HARD_CAP_BYTES = 16 * 1024;
+var MEMORY_CONTENT_SOFT_BUDGET_BYTES = 4 * 1024;
+function normalizeInner(s) {
+  return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+function hashBlockContent(inner) {
+  return createHash("sha256").update(normalizeInner(inner), "utf8").digest("hex").slice(0, 12);
+}
+function defaultNotice(connectorId) {
+  return `Managed by agent-connector for "${connectorId}". Do not edit between these markers: \`agent-connector sync\` rewrites this block; \`agent-connector uninstall ${connectorId}\` removes it.`;
+}
+function beginLine(blockId, hash, style) {
+  return style === "hash" ? `# ${MANAGED_BLOCK_BEGIN_TOKEN} ${blockId} hash=${hash}` : `<!-- ${MANAGED_BLOCK_BEGIN_TOKEN} ${blockId} hash=${hash} -->`;
+}
+function endLine(blockId, style) {
+  return style === "hash" ? `# ${MANAGED_BLOCK_END_TOKEN} ${blockId}` : `<!-- ${MANAGED_BLOCK_END_TOKEN} ${blockId} -->`;
+}
+function noticeLine(notice, style) {
+  return style === "hash" ? `# ${notice}` : `<!-- ${notice} -->`;
+}
+function renderBlockLines(opts) {
+  const style = opts.commentStyle ?? "html";
+  const inner = [
+    noticeLine(opts.notice ?? defaultNotice(opts.connectorId), style),
+    ...normalizeInner(opts.content).split("\n")
+  ];
+  const hash = hashBlockContent(inner.join("\n"));
+  return [beginLine(opts.blockId, hash, style), ...inner, endLine(opts.blockId, style)];
+}
+var BEGIN_RE = /^(?:<!--\s+agent-connector:begin\s+(\S+)\s+hash=([0-9a-f]{12})\s+-->|#\s+agent-connector:begin\s+(\S+)\s+hash=([0-9a-f]{12}))\s*$/;
+var END_RE = /^(?:<!--\s+agent-connector:end\s+(\S+)\s+-->|#\s+agent-connector:end\s+(\S+))\s*$/;
+function stripCr(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function scanMarkers(logical) {
+  const events = [];
+  let fence = null;
+  for (let i = 0; i < logical.length; i++) {
+    const line = logical[i];
+    if (fence) {
+      const close = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/);
+      if (close && close[1][0] === fence.char && close[1].length >= fence.len) fence = null;
+      continue;
+    }
+    const open = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (open) {
+      fence = { char: open[1][0], len: open[1].length };
+      continue;
+    }
+    const b = line.match(BEGIN_RE);
+    if (b) {
+      events.push({ kind: "begin", blockId: b[1] ?? b[3], hash: b[2] ?? b[4], index: i });
+      continue;
+    }
+    const e = line.match(END_RE);
+    if (e) events.push({ kind: "end", blockId: e[1] ?? e[2], index: i });
+  }
+  return events;
+}
+function linesOutsideFences(raw) {
+  const body = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+  const logical = body.split("\n").map(stripCr);
+  const out = [];
+  let fence = null;
+  for (const line of logical) {
+    if (fence) {
+      const close = line.match(/^ {0,3}(`{3,}|~{3,})\s*$/);
+      if (close && close[1][0] === fence.char && close[1].length >= fence.len) fence = null;
+      continue;
+    }
+    const open = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (open) {
+      fence = { char: open[1][0], len: open[1].length };
+      continue;
+    }
+    out.push(line);
+  }
+  return out;
+}
+function pairMarkers(events) {
+  const open = /* @__PURE__ */ new Map();
+  const pairs = [];
+  const strays = [];
+  for (const ev of events) {
+    if (ev.kind === "begin") {
+      if (!open.has(ev.blockId)) open.set(ev.blockId, ev);
+    } else {
+      const b = open.get(ev.blockId);
+      if (b) {
+        pairs.push({ blockId: ev.blockId, begin: b, end: ev });
+        open.delete(ev.blockId);
+      } else {
+        strays.push(ev);
+      }
+    }
+  }
+  for (const b of open.values()) strays.push(b);
+  return { pairs, strays };
+}
+function listManagedBlocks(raw) {
+  const body = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+  const logical = body.split("\n").map(stripCr);
+  const { pairs } = pairMarkers(scanMarkers(logical));
+  return pairs.map((p) => {
+    const inner = logical.slice(p.begin.index + 1, p.end.index).join("\n");
+    const actualHash = hashBlockContent(inner);
+    const recordedHash = p.begin.hash ?? "";
+    return {
+      blockId: p.blockId,
+      recordedHash,
+      actualHash,
+      drifted: recordedHash !== actualHash,
+      beginLine: p.begin.index,
+      endLine: p.end.index
+    };
+  });
+}
+function detectEol(body) {
+  const crlf = (body.match(/\r\n/g) ?? []).length;
+  const total = (body.match(/\n/g) ?? []).length;
+  return crlf > 0 && crlf >= total - crlf ? "\r\n" : "\n";
+}
+function withEol(lines, eol) {
+  return eol === "\r\n" ? lines.map((l) => `${l}\r`) : lines;
+}
+function trimTrailingBlank(body) {
+  let out = body;
+  for (; ; ) {
+    const m = out.match(/\r?\n[ \t]*$/);
+    if (!m) return out;
+    out = out.slice(0, out.length - m[0].length);
+  }
+}
+function appendBlock(body, blockLines, eol) {
+  const blockText = blockLines.join(eol) + eol;
+  if (body.trim() === "") return blockText;
+  return trimTrailingBlank(body) + eol + eol + blockText;
+}
+function upsertBlockInText(raw, opts) {
+  const bom = raw.startsWith("\uFEFF");
+  const body = bom ? raw.slice(1) : raw;
+  const eol = detectEol(body);
+  const lines = body.split("\n");
+  const logical = lines.map(stripCr);
+  const events = scanMarkers(logical).filter((e) => e.blockId === opts.blockId);
+  const { pairs, strays } = pairMarkers(events);
+  const newLines = renderBlockLines(opts);
+  const newHash = hashBlockContent(newLines.slice(1, -1).join("\n"));
+  const finish = (text, r) => ({
+    text: bom ? `\uFEFF${text}` : text,
+    hash: newHash,
+    ...r
+  });
+  if (pairs.length > 0) {
+    const { begin, end } = pairs[0];
+    const recorded = begin.hash ?? "";
+    const actualHash = hashBlockContent(logical.slice(begin.index + 1, end.index).join("\n"));
+    const drifted = actualHash !== recorded;
+    if (drifted && !opts.force) {
+      return finish(body, {
+        action: "warn",
+        detail: `block ${opts.blockId} was edited inside the markers (recorded hash ${recorded}, found ${actualHash}); left untouched \u2014 re-run with --force to overwrite the in-block edits`,
+        changed: false,
+        recovered: false
+      });
+    }
+    const duplicates = pairs.slice(1);
+    const needsWrite = drifted || recorded !== newHash || duplicates.length > 0 || strays.length > 0;
+    if (!needsWrite) {
+      return finish(body, {
+        action: "skip",
+        detail: `block ${opts.blockId} already up to date (hash ${newHash})`,
+        changed: false,
+        recovered: false
+      });
+    }
+    const del = /* @__PURE__ */ new Set();
+    for (let i = begin.index; i <= end.index; i++) del.add(i);
+    for (const dup of duplicates) {
+      for (let i = dup.begin.index; i <= dup.end.index; i++) del.add(i);
+      reclaimBlankLine(logical, dup.begin.index, dup.end.index, del, lines.length);
+    }
+    for (const s of strays) del.add(s.index);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (i === begin.index) out.push(...withEol(newLines, eol));
+      if (!del.has(i)) out.push(lines[i]);
+    }
+    const notes = [];
+    if (drifted) notes.push("in-block edits overwritten (--force; backup taken)");
+    if (duplicates.length > 0) notes.push(`${duplicates.length} duplicate pair(s) collapsed`);
+    if (strays.length > 0) notes.push(`${strays.length} stray marker line(s) removed`);
+    return finish(out.join("\n"), {
+      action: "update",
+      detail: `block ${opts.blockId} updated (hash ${recorded || "?"} \u2192 ${newHash})` + (notes.length > 0 ? `; ${notes.join("; ")}` : ""),
+      changed: true,
+      recovered: drifted || duplicates.length > 0 || strays.length > 0
+    });
+  }
+  if (strays.length > 0) {
+    const del = new Set(strays.map((s) => s.index));
+    const cleaned = lines.filter((_, i) => !del.has(i)).join("\n");
+    return finish(appendBlock(cleaned, newLines, eol), {
+      action: "create",
+      detail: `block ${opts.blockId} appended after recovery: ${strays.length} stray marker line(s) removed (backup taken)`,
+      changed: true,
+      recovered: true
+    });
+  }
+  return finish(appendBlock(body, newLines, eol), {
+    action: "create",
+    detail: `block ${opts.blockId} appended (hash ${newHash})`,
+    changed: true,
+    recovered: false
+  });
+}
+function reclaimBlankLine(logical, beginIdx, endIdx, del, lineCount) {
+  const before = beginIdx - 1;
+  if (before >= 0 && !del.has(before) && logical[before].trim() === "") {
+    del.add(before);
+    return;
+  }
+  const after = endIdx + 1;
+  const isSentinel = after === lineCount - 1 && logical[after] === "";
+  if (after < lineCount && !isSentinel && !del.has(after) && logical[after].trim() === "") {
+    del.add(after);
+  }
+}
+function removeBlocksFromText(raw, match) {
+  const bom = raw.startsWith("\uFEFF");
+  const body = bom ? raw.slice(1) : raw;
+  const lines = body.split("\n");
+  const logical = lines.map(stripCr);
+  const matches = (id) => match.blockId !== void 0 && id === match.blockId || match.blockIdPrefix !== void 0 && id.startsWith(match.blockIdPrefix);
+  const { pairs, strays } = pairMarkers(scanMarkers(logical));
+  const targetPairs = pairs.filter((p) => matches(p.blockId));
+  const targetStrays = strays.filter((s) => matches(s.blockId));
+  if (targetPairs.length === 0 && targetStrays.length === 0) {
+    return { text: raw, changed: false, records: [], fileNowEmpty: false, recovered: false };
+  }
+  const del = /* @__PURE__ */ new Set();
+  const records = [];
+  let recovered = false;
+  for (const p of targetPairs) {
+    const recorded = p.begin.hash ?? "";
+    const actualHash = hashBlockContent(
+      logical.slice(p.begin.index + 1, p.end.index).join("\n")
+    );
+    for (let i = p.begin.index; i <= p.end.index; i++) del.add(i);
+    reclaimBlankLine(logical, p.begin.index, p.end.index, del, lines.length);
+    if (actualHash !== recorded) {
+      recovered = true;
+      records.push({
+        blockId: p.blockId,
+        action: "warn",
+        detail: `block ${p.blockId} had in-block edits (recorded hash ${recorded}, found ${actualHash}); removed anyway (backup taken)`
+      });
+    }
+    records.push({ blockId: p.blockId, action: "remove", detail: `block ${p.blockId} removed` });
+  }
+  for (const s of targetStrays) {
+    del.add(s.index);
+    recovered = true;
+    records.push({
+      blockId: s.blockId,
+      action: "warn",
+      detail: `stray ${s.kind} marker for ${s.blockId} removed (marker line only)`
+    });
+  }
+  const text = lines.filter((_, i) => !del.has(i)).join("\n");
+  return {
+    text: bom ? `\uFEFF${text}` : text,
+    changed: true,
+    records,
+    fileNowEmpty: text.trim() === "",
+    recovered
+  };
+}
+function backupFile(path) {
+  try {
+    ensureDir(backupsDir());
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const dest = join(backupsDir(), `memory-${stamp}-${basename(path)}`);
+    copyFileSync(path, dest);
+    return dest;
+  } catch {
+    return null;
+  }
+}
+function atomicWriteFile(path, text) {
+  const dir = dirname(path);
+  ensureDir(dir);
+  const tmp = join(dir, `.${basename(path)}.ac-tmp-${process.pid}-${Date.now()}`);
+  try {
+    writeFileSync(tmp, text, "utf8");
+    try {
+      chmodSync(tmp, statSync(path).mode);
+    } catch {
+    }
+    renameSync(tmp, path);
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+function upsertManagedBlockFile(path, opts) {
+  let raw = null;
+  if (existsSync(path)) {
+    try {
+      raw = readFileSync(path, "utf8");
+    } catch {
+      return {
+        action: "warn",
+        path,
+        detail: `cannot read ${path}; memory block ${opts.blockId} not written`,
+        createdFile: false,
+        hash: ""
+      };
+    }
+  }
+  if (raw === null) {
+    const lines = renderBlockLines(opts);
+    const hash = hashBlockContent(lines.slice(1, -1).join("\n"));
+    if (!opts.dryRun) atomicWriteFile(path, `${lines.join("\n")}
+`);
+    return {
+      action: "create",
+      path,
+      detail: `created ${basename(path)} with block ${opts.blockId} (hash ${hash})`,
+      createdFile: true,
+      hash
+    };
+  }
+  const res = upsertBlockInText(raw, opts);
+  const change = {
+    action: res.action,
+    path,
+    detail: res.detail,
+    createdFile: false,
+    hash: res.hash
+  };
+  if (res.changed && !opts.dryRun) {
+    if (res.recovered) {
+      const backup = backupFile(path);
+      if (backup) change.backupPath = backup;
+    }
+    atomicWriteFile(path, res.text);
+  }
+  return change;
+}
+function removeManagedBlocksFile(path, match, opts) {
+  if (!existsSync(path)) {
+    return [
+      {
+        action: "skip",
+        path,
+        detail: `${basename(path)} absent; nothing to remove`,
+        createdFile: false,
+        hash: ""
+      }
+    ];
+  }
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return [
+      {
+        action: "warn",
+        path,
+        detail: `cannot read ${path}; managed blocks left in place`,
+        createdFile: false,
+        hash: ""
+      }
+    ];
+  }
+  const res = removeBlocksFromText(raw, match);
+  if (!res.changed) {
+    return [
+      {
+        action: "skip",
+        path,
+        detail: `no agent-connector blocks matching ${match.blockId ?? match.blockIdPrefix ?? "?"} in ${basename(path)}`,
+        createdFile: false,
+        hash: ""
+      }
+    ];
+  }
+  const changes = [];
+  let backupPath;
+  if (!opts.dryRun) {
+    if (res.recovered) backupPath = backupFile(path) ?? void 0;
+    if (res.fileNowEmpty && opts.deleteFileIfCreated) {
+      rmSync(path, { force: true });
+    } else {
+      atomicWriteFile(path, res.text);
+    }
+  }
+  for (const r of res.records) {
+    changes.push({
+      action: r.action,
+      path,
+      detail: r.detail,
+      createdFile: false,
+      hash: "",
+      ...backupPath && r.action === "warn" ? { backupPath } : {}
+    });
+  }
+  if (res.fileNowEmpty && opts.deleteFileIfCreated) {
+    changes.push({
+      action: "remove",
+      path,
+      detail: `${basename(path)} deleted (agent-connector created it; only whitespace remained)`,
+      createdFile: false,
+      hash: ""
+    });
+  }
+  return changes;
+}
+function memoryLedgerPath(connectorId) {
+  return join(connectorDir(connectorId), "memory-state.json");
+}
+function loadMemoryLedger(connectorId) {
+  const p = memoryLedgerPath(connectorId);
+  if (!existsSync(p)) return { version: 1, targets: [] };
+  try {
+    const parsed = JSON.parse(readFileSync(p, "utf8"));
+    if (parsed && Array.isArray(parsed.targets)) return { version: 1, targets: parsed.targets };
+  } catch {
+  }
+  return { version: 1, targets: [] };
+}
+function saveMemoryLedger(connectorId, ledger) {
+  const p = memoryLedgerPath(connectorId);
+  if (ledger.targets.length === 0) {
+    rmSync(p, { force: true });
+    return;
+  }
+  ensureDir(dirname(p));
+  writeFileSync(p, `${JSON.stringify(ledger, null, 2)}
+`, "utf8");
+}
+function hasMemoryLedger(connectorId) {
+  return loadMemoryLedger(connectorId).targets.length > 0;
+}
+function recordMemoryTarget(ledger, t) {
+  const i = ledger.targets.findIndex(
+    (x) => x.platform === t.platform && x.scope === t.scope && x.path === t.path && x.blockId === t.blockId
+  );
+  if (i >= 0) {
+    ledger.targets[i] = { ...t, createdFile: ledger.targets[i].createdFile || t.createdFile };
+  } else {
+    ledger.targets.push(t);
+  }
+}
+
+export {
+  MANAGED_BLOCK_BEGIN_TOKEN,
+  MANAGED_BLOCK_END_TOKEN,
+  MEMORY_CONTENT_HARD_CAP_BYTES,
+  MEMORY_CONTENT_SOFT_BUDGET_BYTES,
+  linesOutsideFences,
+  listManagedBlocks,
+  removeBlocksFromText,
+  upsertManagedBlockFile,
+  removeManagedBlocksFile,
+  loadMemoryLedger,
+  saveMemoryLedger,
+  hasMemoryLedger,
+  recordMemoryTarget
+};
+//# sourceMappingURL=chunk-N6HH7K6P.js.map

package/dist/chunk-N6HH7K6P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/managed-block.ts"],"sourcesContent":["/**\n * core/managed-block — the marker-fenced MANAGED BLOCK engine behind the\n * `memory` content surface.\n *\n * Memory/rules files (AGENTS.md, CLAUDE.md, GEMINI.md, …) are SHARED,\n * user-authored files — unlike commands/skills/subagents, agent-connector does\n * not own them. Every write therefore goes through this one module, which\n * implements idempotent, hash-stamped, uninstall-reversible blocks:\n *\n *   <!-- agent-connector:begin <connectorId>/<name> hash=<sha256-12> -->\n *   <!-- Managed by agent-connector for \"<connectorId>\". Do not edit … -->\n *   …guidance…\n *   <!-- agent-connector:end <connectorId>/<name> -->\n *\n * Design rules (each grounded in surveyed prior art — ansible blockinfile,\n * conda init, OMC mergeClaudeMd, Ruler, doctoc):\n *   • UNIQUE marker per block: the blockId (`<connectorId>/<entryName>`) lives\n *     ON the marker line, so multiple connectors coexist in one file and each\n *     update path only ever touches its own pair (ansible's documented\n *     multi-block rule). The shared `agent-connector` namespace token lets\n *     doctor/uninstall enumerate every block with one scan.\n *   • `hash=` is the first 12 hex chars of sha256 over the NORMALIZED inner\n *     region (CRLF→LF + trim — stable under prettier/EOL converters): O(1)\n *     idempotence (unchanged → skip, no mtime/git churn) and tamper detection\n *     (actual inner hash ≠ recorded ⇒ the user edited inside the block ⇒ warn,\n *     never clobber without an explicit force).\n *   • IN-PLACE replacement (conda semantics): zero bytes outside the marker\n *     pair ever change — no move-to-top, no user blank-line reflow.\n *   • Line-anchored matching that explicitly tolerates `\\r` line ends and a\n *     FENCE-AWARE scanner (markers quoted inside ``` / ~~~ code fences never\n *     match) — fixes the CRLF duplicate-block and quoted-marker classes.\n *   • First-begin / FIRST-end-after pairing (never last-end): a missing end\n *     marker must not swallow a sibling connector's block.\n *   • HTML-comment markers are CORRECT for CLAUDE.md: Claude Code strips HTML\n *     comments from CLAUDE.md before context injection (verified against docs\n *     and the 2.1.172 binary), so the markers and the do-not-edit notice are\n *     INVISIBLE to the model there while remaining fully parseable by us for\n *     sync/doctor/uninstall. On AGENTS.md hosts (which inline the whole file\n *     into the prompt) the short notice doubles as an in-prompt \"do not edit\"\n *     instruction to the host's own agent. A `commentStyle: \"hash\"` variant\n *     exists for future non-markdown targets (`#`-prefixed marker lines).\n *\n * The module also owns the per-connector MEMORY OWNERSHIP LEDGER\n * (`connectorDir(id)/memory-state.json`): the markers in the file remain the\n * source of truth for uninstall (a teammate's machine with no ledger still\n * uninstalls via the prefix scan); the ledger only adds the created-vs-modified\n * distinction (file deletion rights) and doctor diagnostics.\n */\n\nimport { createHash } from \"node:crypto\";\nimport {\n  chmodSync,\n  copyFileSync,\n  existsSync,\n  readFileSync,\n  renameSync,\n  rmSync,\n  statSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { basename, dirname, join } from \"node:path\";\n\nimport { backupsDir, connectorDir, ensureDir } from \"./paths.js\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// Grammar constants (shared with defineConnector's content validation)\n// ─────────────────────────────────────────────────────────────────────────\n\n/** Literal begin token. Connector memory content MUST NOT contain it. */\nexport const MANAGED_BLOCK_BEGIN_TOKEN = \"agent-connector:begin\";\n/** Literal end token. Connector memory content MUST NOT contain it. */\nexport const MANAGED_BLOCK_END_TOKEN = \"agent-connector:end\";\n\n/** Hard cap on one memory entry's content (ConnectorConfigError above this). */\nexport const MEMORY_CONTENT_HARD_CAP_BYTES = 16 * 1024;\n/**\n * Soft per-entry budget — exceeded → install-time `warn` ChangeRecord (memory\n * files are injected into EVERY prompt of EVERY session on the host; codex\n * additionally caps combined project docs at 32 KiB).\n */\nexport const MEMORY_CONTENT_SOFT_BUDGET_BYTES = 4 * 1024;\n\n/** Marker comment style: HTML comments (default, all v1 markdown targets) or `#` lines. */\nexport type BlockCommentStyle = \"html\" | \"hash\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// Hashing / rendering\n// ─────────────────────────────────────────────────────────────────────────\n\n/** CRLF/CR → LF + trim: the normalization both hashing sides use. */\nfunction normalizeInner(s: string): string {\n  return s.replace(/\\r\\n/g, \"\\n\").replace(/\\r/g, \"\\n\").trim();\n}\n\n/** First 12 hex chars of sha256 over the NORMALIZED inner region. */\nexport function hashBlockContent(inner: string): string {\n  return createHash(\"sha256\").update(normalizeInner(inner), \"utf8\").digest(\"hex\").slice(0, 12);\n}\n\n/** The conda-style in-block warning, adapted for the LLM era (see header). */\nfunction defaultNotice(connectorId: string): string {\n  return (\n    `Managed by agent-connector for \"${connectorId}\". Do not edit between these markers: ` +\n    `\\`agent-connector sync\\` rewrites this block; ` +\n    `\\`agent-connector uninstall ${connectorId}\\` removes it.`\n  );\n}\n\nfunction beginLine(blockId: string, hash: string, style: BlockCommentStyle): string {\n  return style === \"hash\"\n    ? `# ${MANAGED_BLOCK_BEGIN_TOKEN} ${blockId} hash=${hash}`\n    : `<!-- ${MANAGED_BLOCK_BEGIN_TOKEN} ${blockId} hash=${hash} -->`;\n}\n\n/** END line is a fixed exact string (no hash) so a content change never strands it. */\nfunction endLine(blockId: string, style: BlockCommentStyle): string {\n  return style === \"hash\"\n    ? `# ${MANAGED_BLOCK_END_TOKEN} ${blockId}`\n    : `<!-- ${MANAGED_BLOCK_END_TOKEN} ${blockId} -->`;\n}\n\nfunction noticeLine(notice: string, style: BlockCommentStyle): string {\n  return style === \"hash\" ? `# ${notice}` : `<!-- ${notice} -->`;\n}\n\nexport interface RenderBlockOptions {\n  /** `<connectorId>/<entryName>` (or the reserved `_shared/<name>` bridge prefix). */\n  blockId: string;\n  /** Connector id named in the default do-not-edit notice line. */\n  connectorId: string;\n  /** The guidance payload (plain markdown; normalized + trimmed on emit). */\n  content: string;\n  /** Marker comment style; default \"html\". */\n  commentStyle?: BlockCommentStyle;\n  /** Override the default notice line TEXT (without comment delimiters). */\n  notice?: string;\n}\n\n/**\n * Render the block as LOGICAL lines (no EOL chars). The recorded `hash=`\n * covers the full inner region (notice line + content) so install and scan\n * compare like for like.\n */\nexport function renderBlockLines(opts: RenderBlockOptions): string[] {\n  const style = opts.commentStyle ?? \"html\";\n  const inner = [\n    noticeLine(opts.notice ?? defaultNotice(opts.connectorId), style),\n    ...normalizeInner(opts.content).split(\"\\n\"),\n  ];\n  const hash = hashBlockContent(inner.join(\"\\n\"));\n  return [beginLine(opts.blockId, hash, style), ...inner, endLine(opts.blockId, style)];\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Scanning (fence-aware, line-anchored, CRLF-tolerant)\n// ─────────────────────────────────────────────────────────────────────────\n\n// Both comment styles are RECOGNIZED in one pass (a file may legitimately mix\n// styles only across rewrites; emission always uses the requested style).\nconst BEGIN_RE =\n  /^(?:<!--\\s+agent-connector:begin\\s+(\\S+)\\s+hash=([0-9a-f]{12})\\s+-->|#\\s+agent-connector:begin\\s+(\\S+)\\s+hash=([0-9a-f]{12}))\\s*$/;\nconst END_RE = /^(?:<!--\\s+agent-connector:end\\s+(\\S+)\\s+-->|#\\s+agent-connector:end\\s+(\\S+))\\s*$/;\n\ninterface MarkerEvent {\n  kind: \"begin\" | \"end\";\n  blockId: string;\n  /** Recorded hash (begin markers only). */\n  hash?: string;\n  /** Line index into the logical-lines array. */\n  index: number;\n}\n\n/** Strip ONE trailing `\\r` — `raw.split(\"\\n\")` leaves it on CRLF files. */\nfunction stripCr(line: string): string {\n  return line.endsWith(\"\\r\") ? line.slice(0, -1) : line;\n}\n\n/**\n * Scan logical lines for marker events, tracking ``` / ~~~ fence state so a\n * marker QUOTED inside a fenced code block never matches (the OMC class of\n * false positives, eliminated rather than just reduced).\n */\nfunction scanMarkers(logical: string[]): MarkerEvent[] {\n  const events: MarkerEvent[] = [];\n  let fence: { char: string; len: number } | null = null;\n  for (let i = 0; i < logical.length; i++) {\n    const line = logical[i]!;\n    if (fence) {\n      const close = line.match(/^ {0,3}(`{3,}|~{3,})\\s*$/);\n      if (close && close[1]![0] === fence.char && close[1]!.length >= fence.len) fence = null;\n      continue;\n    }\n    const open = line.match(/^ {0,3}(`{3,}|~{3,})/);\n    if (open) {\n      fence = { char: open[1]![0]!, len: open[1]!.length };\n      continue;\n    }\n    const b = line.match(BEGIN_RE);\n    if (b) {\n      events.push({ kind: \"begin\", blockId: (b[1] ?? b[3])!, hash: (b[2] ?? b[4])!, index: i });\n      continue;\n    }\n    const e = line.match(END_RE);\n    if (e) events.push({ kind: \"end\", blockId: (e[1] ?? e[2])!, index: i });\n  }\n  return events;\n}\n\n/**\n * Logical lines of `raw` that sit OUTSIDE ``` / ~~~ code fences — for host\n * probes that must ignore quoted examples (e.g. the claude-code `@AGENTS.md`\n * import detection). Fence lines themselves are excluded.\n */\nexport function linesOutsideFences(raw: string): string[] {\n  const body = raw.startsWith(\"\\uFEFF\") ? raw.slice(1) : raw;\n  const logical = body.split(\"\\n\").map(stripCr);\n  const out: string[] = [];\n  let fence: { char: string; len: number } | null = null;\n  for (const line of logical) {\n    if (fence) {\n      const close = line.match(/^ {0,3}(`{3,}|~{3,})\\s*$/);\n      if (close && close[1]![0] === fence.char && close[1]!.length >= fence.len) fence = null;\n      continue;\n    }\n    const open = line.match(/^ {0,3}(`{3,}|~{3,})/);\n    if (open) {\n      fence = { char: open[1]![0]!, len: open[1]!.length };\n      continue;\n    }\n    out.push(line);\n  }\n  return out;\n}\n\ninterface BlockPair {\n  blockId: string;\n  begin: MarkerEvent;\n  end: MarkerEvent;\n}\n\n/**\n * Pair markers per blockId: first begin, then the FIRST end at-or-after it.\n * A nested begin for the SAME id (inside an open pair) is treated as inner\n * content; unpaired markers are returned as strays. Per-id state means a\n * missing end for connector A can never swallow connector B's block.\n */\nfunction pairMarkers(events: MarkerEvent[]): { pairs: BlockPair[]; strays: MarkerEvent[] } {\n  const open = new Map<string, MarkerEvent>();\n  const pairs: BlockPair[] = [];\n  const strays: MarkerEvent[] = [];\n  for (const ev of events) {\n    if (ev.kind === \"begin\") {\n      if (!open.has(ev.blockId)) open.set(ev.blockId, ev);\n      // else: a begin inside an open pair — inner content / abuse; the hash\n      // check will flag the pair as drifted rather than guessing boundaries.\n    } else {\n      const b = open.get(ev.blockId);\n      if (b) {\n        pairs.push({ blockId: ev.blockId, begin: b, end: ev });\n        open.delete(ev.blockId);\n      } else {\n        strays.push(ev);\n      }\n    }\n  }\n  for (const b of open.values()) strays.push(b);\n  return { pairs, strays };\n}\n\n/** One discovered block (for doctor / refcount / uninstall enumeration). */\nexport interface ManagedBlockInfo {\n  blockId: string;\n  /** The hash recorded on the begin marker line. */\n  recordedHash: string;\n  /** Hash of the actual normalized inner region as found on disk. */\n  actualHash: string;\n  /** True when recordedHash ≠ actualHash — the user edited inside the block. */\n  drifted: boolean;\n  beginLine: number;\n  endLine: number;\n}\n\n/** Enumerate every complete agent-connector block in `raw` (namespace scan). */\nexport function listManagedBlocks(raw: string): ManagedBlockInfo[] {\n  const body = raw.startsWith(\"\\uFEFF\") ? raw.slice(1) : raw;\n  const logical = body.split(\"\\n\").map(stripCr);\n  const { pairs } = pairMarkers(scanMarkers(logical));\n  return pairs.map((p) => {\n    const inner = logical.slice(p.begin.index + 1, p.end.index).join(\"\\n\");\n    const actualHash = hashBlockContent(inner);\n    const recordedHash = p.begin.hash ?? \"\";\n    return {\n      blockId: p.blockId,\n      recordedHash,\n      actualHash,\n      drifted: recordedHash !== actualHash,\n      beginLine: p.begin.index,\n      endLine: p.end.index,\n    };\n  });\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Pure text upsert / removal\n// ─────────────────────────────────────────────────────────────────────────\n\nexport interface UpsertBlockOptions extends RenderBlockOptions {\n  /** Overwrite a USER-EDITED (drifted) block. Default false → warn + leave intact. */\n  force?: boolean;\n}\n\nexport interface BlockTextResult {\n  /** Resulting full text (=== input when nothing changed). */\n  text: string;\n  action: \"create\" | \"update\" | \"skip\" | \"warn\";\n  detail: string;\n  changed: boolean;\n  /**\n   * True when the rewrite was DESTRUCTIVE-ADJACENT (force-overwrote a drifted\n   * block, collapsed duplicate pairs, or stripped stray markers) — the file\n   * wrapper writes a timestamped backup before persisting such a change.\n   */\n  recovered: boolean;\n  /** Hash of the (new) rendered inner region — recorded in the ledger. */\n  hash: string;\n}\n\n/** Detect the file's dominant EOL; new/replaced lines are emitted with it. */\nfunction detectEol(body: string): \"\\n\" | \"\\r\\n\" {\n  const crlf = (body.match(/\\r\\n/g) ?? []).length;\n  const total = (body.match(/\\n/g) ?? []).length;\n  return crlf > 0 && crlf >= total - crlf ? \"\\r\\n\" : \"\\n\";\n}\n\n/** Add `\\r` to logical lines when the file is CRLF (joined with \"\\n\" later). */\nfunction withEol(lines: string[], eol: \"\\n\" | \"\\r\\n\"): string[] {\n  return eol === \"\\r\\n\" ? lines.map((l) => `${l}\\r`) : lines;\n}\n\n/**\n * Strip trailing newline(s) + whitespace-only line tails WITHOUT touching\n * trailing spaces on the last content line (bytes outside our block).\n */\nfunction trimTrailingBlank(body: string): string {\n  let out = body;\n  for (;;) {\n    const m = out.match(/\\r?\\n[ \\t]*$/);\n    if (!m) return out;\n    out = out.slice(0, out.length - m[0].length);\n  }\n}\n\n/** Append the rendered block at EOF with exactly ONE blank separator line. */\nfunction appendBlock(body: string, blockLines: string[], eol: \"\\n\" | \"\\r\\n\"): string {\n  const blockText = blockLines.join(eol) + eol;\n  if (body.trim() === \"\") return blockText;\n  return trimTrailingBlank(body) + eol + eol + blockText;\n}\n\n/**\n * Idempotent upsert of one managed block into `raw` (pure; no I/O).\n * See the module header for the full algorithm contract.\n */\nexport function upsertBlockInText(raw: string, opts: UpsertBlockOptions): BlockTextResult {\n  const bom = raw.startsWith(\"\\uFEFF\");\n  const body = bom ? raw.slice(1) : raw;\n  const eol = detectEol(body);\n  const lines = body.split(\"\\n\"); // elements keep a trailing \"\\r\" on CRLF files\n  const logical = lines.map(stripCr);\n\n  const events = scanMarkers(logical).filter((e) => e.blockId === opts.blockId);\n  const { pairs, strays } = pairMarkers(events);\n\n  const newLines = renderBlockLines(opts);\n  const newHash = hashBlockContent(newLines.slice(1, -1).join(\"\\n\"));\n  const finish = (text: string, r: Omit<BlockTextResult, \"text\" | \"hash\">): BlockTextResult => ({\n    text: bom ? `\\uFEFF${text}` : text,\n    hash: newHash,\n    ...r,\n  });\n\n  if (pairs.length > 0) {\n    const { begin, end } = pairs[0]!;\n    const recorded = begin.hash ?? \"\";\n    const actualHash = hashBlockContent(logical.slice(begin.index + 1, end.index).join(\"\\n\"));\n    const drifted = actualHash !== recorded;\n\n    if (drifted && !opts.force) {\n      return finish(body, {\n        action: \"warn\",\n        detail:\n          `block ${opts.blockId} was edited inside the markers ` +\n          `(recorded hash ${recorded}, found ${actualHash}); left untouched — ` +\n          `re-run with --force to overwrite the in-block edits`,\n        changed: false,\n        recovered: false,\n      });\n    }\n\n    const duplicates = pairs.slice(1);\n    const needsWrite =\n      drifted || recorded !== newHash || duplicates.length > 0 || strays.length > 0;\n    if (!needsWrite) {\n      return finish(body, {\n        action: \"skip\",\n        detail: `block ${opts.blockId} already up to date (hash ${newHash})`,\n        changed: false,\n        recovered: false,\n      });\n    }\n\n    // Build the deletion set: the canonical pair region (replaced in place),\n    // duplicate pairs (+ ONE adjacent blank line each), and stray marker LINES.\n    const del = new Set<number>();\n    for (let i = begin.index; i <= end.index; i++) del.add(i);\n    for (const dup of duplicates) {\n      for (let i = dup.begin.index; i <= dup.end.index; i++) del.add(i);\n      reclaimBlankLine(logical, dup.begin.index, dup.end.index, del, lines.length);\n    }\n    for (const s of strays) del.add(s.index);\n\n    const out: string[] = [];\n    for (let i = 0; i < lines.length; i++) {\n      if (i === begin.index) out.push(...withEol(newLines, eol));\n      if (!del.has(i)) out.push(lines[i]!);\n    }\n    const notes: string[] = [];\n    if (drifted) notes.push(\"in-block edits overwritten (--force; backup taken)\");\n    if (duplicates.length > 0) notes.push(`${duplicates.length} duplicate pair(s) collapsed`);\n    if (strays.length > 0) notes.push(`${strays.length} stray marker line(s) removed`);\n    return finish(out.join(\"\\n\"), {\n      action: \"update\",\n      detail:\n        `block ${opts.blockId} updated (hash ${recorded || \"?\"} → ${newHash})` +\n        (notes.length > 0 ? `; ${notes.join(\"; \")}` : \"\"),\n      changed: true,\n      recovered: drifted || duplicates.length > 0 || strays.length > 0,\n    });\n  }\n\n  if (strays.length > 0) {\n    // Corruption recovery: strip ONLY the stray marker line(s) (never the text\n    // between guessed boundaries), then proceed as not-found.\n    const del = new Set(strays.map((s) => s.index));\n    const cleaned = lines.filter((_, i) => !del.has(i)).join(\"\\n\");\n    return finish(appendBlock(cleaned, newLines, eol), {\n      action: \"create\",\n      detail:\n        `block ${opts.blockId} appended after recovery: ${strays.length} stray ` +\n        `marker line(s) removed (backup taken)`,\n      changed: true,\n      recovered: true,\n    });\n  }\n\n  // Not found → append at EOF (one blank separator; whole file when empty).\n  return finish(appendBlock(body, newLines, eol), {\n    action: \"create\",\n    detail: `block ${opts.blockId} appended (hash ${newHash})`,\n    changed: true,\n    recovered: false,\n  });\n}\n\n/**\n * Mark ONE blank line adjacent to a removed begin..end region for deletion\n * (prefer the line before; never the post-final-newline \"\" sentinel).\n */\nfunction reclaimBlankLine(\n  logical: string[],\n  beginIdx: number,\n  endIdx: number,\n  del: Set<number>,\n  lineCount: number,\n): void {\n  const before = beginIdx - 1;\n  if (before >= 0 && !del.has(before) && logical[before]!.trim() === \"\") {\n    del.add(before);\n    return;\n  }\n  const after = endIdx + 1;\n  // The final \"\" element of split(\"\\n\") on a newline-terminated file is the\n  // trailing-newline sentinel, not a blank line — leave it alone.\n  const isSentinel = after === lineCount - 1 && logical[after] === \"\";\n  if (after < lineCount && !isSentinel && !del.has(after) && logical[after]!.trim() === \"\") {\n    del.add(after);\n  }\n}\n\nexport interface RemoveBlocksOptions {\n  /** Remove the block with EXACTLY this id… */\n  blockId?: string;\n  /** …or every block whose id starts with this prefix (e.g. `<connectorId>/`). */\n  blockIdPrefix?: string;\n}\n\nexport interface RemoveRecord {\n  blockId: string;\n  action: \"remove\" | \"warn\";\n  detail: string;\n}\n\nexport interface RemoveBlocksResult {\n  text: string;\n  changed: boolean;\n  records: RemoveRecord[];\n  /** True when the remaining text is whitespace-only (file-deletion candidate). */\n  fileNowEmpty: boolean;\n  /** True when a drifted block was removed or stray markers were stripped. */\n  recovered: boolean;\n}\n\n/**\n * Remove every matching managed block (begin..end inclusive + at most ONE\n * adjacent blank separator line — no blank-line accumulation across cycles).\n * Drifted blocks are removed WITH a warn (uninstall intent is explicit; the\n * file wrapper backs the file up first). Stray matching markers are stripped\n * line-only with a warn. Pure; no I/O.\n */\nexport function removeBlocksFromText(raw: string, match: RemoveBlocksOptions): RemoveBlocksResult {\n  const bom = raw.startsWith(\"\\uFEFF\");\n  const body = bom ? raw.slice(1) : raw;\n  const lines = body.split(\"\\n\");\n  const logical = lines.map(stripCr);\n\n  const matches = (id: string): boolean =>\n    (match.blockId !== undefined && id === match.blockId) ||\n    (match.blockIdPrefix !== undefined && id.startsWith(match.blockIdPrefix));\n\n  const { pairs, strays } = pairMarkers(scanMarkers(logical));\n  const targetPairs = pairs.filter((p) => matches(p.blockId));\n  const targetStrays = strays.filter((s) => matches(s.blockId));\n\n  if (targetPairs.length === 0 && targetStrays.length === 0) {\n    return { text: raw, changed: false, records: [], fileNowEmpty: false, recovered: false };\n  }\n\n  const del = new Set<number>();\n  const records: RemoveRecord[] = [];\n  let recovered = false;\n\n  for (const p of targetPairs) {\n    const recorded = p.begin.hash ?? \"\";\n    const actualHash = hashBlockContent(\n      logical.slice(p.begin.index + 1, p.end.index).join(\"\\n\"),\n    );\n    for (let i = p.begin.index; i <= p.end.index; i++) del.add(i);\n    reclaimBlankLine(logical, p.begin.index, p.end.index, del, lines.length);\n    if (actualHash !== recorded) {\n      recovered = true;\n      records.push({\n        blockId: p.blockId,\n        action: \"warn\",\n        detail:\n          `block ${p.blockId} had in-block edits (recorded hash ${recorded}, found ` +\n          `${actualHash}); removed anyway (backup taken)`,\n      });\n    }\n    records.push({ blockId: p.blockId, action: \"remove\", detail: `block ${p.blockId} removed` });\n  }\n  for (const s of targetStrays) {\n    del.add(s.index);\n    recovered = true;\n    records.push({\n      blockId: s.blockId,\n      action: \"warn\",\n      detail: `stray ${s.kind} marker for ${s.blockId} removed (marker line only)`,\n    });\n  }\n\n  const text = lines.filter((_, i) => !del.has(i)).join(\"\\n\");\n  return {\n    text: bom ? `\\uFEFF${text}` : text,\n    changed: true,\n    records,\n    fileNowEmpty: text.trim() === \"\",\n    recovered,\n  };\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// File-level wrappers (atomic write, backups, dry-run)\n// ─────────────────────────────────────────────────────────────────────────\n\nexport interface BlockFileChange {\n  action: \"create\" | \"update\" | \"skip\" | \"warn\" | \"remove\";\n  path: string;\n  detail: string;\n  /** True when the FILE did not exist and this upsert created it (ledger fact). */\n  createdFile: boolean;\n  /** Set when a pre-mutation backup was written (destructive/recovery paths only). */\n  backupPath?: string;\n  /** Hash of the rendered inner region (ledger / doctor). */\n  hash: string;\n}\n\n/** Timestamped copy into backupsDir(); best-effort (null on failure). */\nfunction backupFile(path: string): string | null {\n  try {\n    ensureDir(backupsDir());\n    const stamp = new Date().toISOString().replace(/[:.]/g, \"-\");\n    const dest = join(backupsDir(), `memory-${stamp}-${basename(path)}`);\n    copyFileSync(path, dest);\n    return dest;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Atomic write: temp file in the SAME directory + rename, preserving the\n * destination's mode. Shrinks (does not eliminate) the read-modify-write race\n * with hosts that append to memory files mid-session (Claude `#` quick-memory).\n */\nfunction atomicWriteFile(path: string, text: string): void {\n  const dir = dirname(path);\n  ensureDir(dir);\n  const tmp = join(dir, `.${basename(path)}.ac-tmp-${process.pid}-${Date.now()}`);\n  try {\n    writeFileSync(tmp, text, \"utf8\");\n    try {\n      chmodSync(tmp, statSync(path).mode);\n    } catch {\n      /* destination absent — default mode is fine */\n    }\n    renameSync(tmp, path);\n  } catch (err) {\n    rmSync(tmp, { force: true });\n    throw err;\n  }\n}\n\n/**\n * Upsert one managed block into the file at `path` (created when absent).\n * Re-reads immediately before computing+writing; honors dryRun (the action is\n * computed and reported, nothing is written).\n */\nexport function upsertManagedBlockFile(\n  path: string,\n  opts: UpsertBlockOptions & { dryRun: boolean },\n): BlockFileChange {\n  let raw: string | null = null;\n  if (existsSync(path)) {\n    try {\n      raw = readFileSync(path, \"utf8\");\n    } catch {\n      return {\n        action: \"warn\",\n        path,\n        detail: `cannot read ${path}; memory block ${opts.blockId} not written`,\n        createdFile: false,\n        hash: \"\",\n      };\n    }\n  }\n\n  if (raw === null) {\n    const lines = renderBlockLines(opts);\n    const hash = hashBlockContent(lines.slice(1, -1).join(\"\\n\"));\n    if (!opts.dryRun) atomicWriteFile(path, `${lines.join(\"\\n\")}\\n`);\n    return {\n      action: \"create\",\n      path,\n      detail: `created ${basename(path)} with block ${opts.blockId} (hash ${hash})`,\n      createdFile: true,\n      hash,\n    };\n  }\n\n  const res = upsertBlockInText(raw, opts);\n  const change: BlockFileChange = {\n    action: res.action,\n    path,\n    detail: res.detail,\n    createdFile: false,\n    hash: res.hash,\n  };\n  if (res.changed && !opts.dryRun) {\n    if (res.recovered) {\n      const backup = backupFile(path);\n      if (backup) change.backupPath = backup;\n    }\n    atomicWriteFile(path, res.text);\n  }\n  return change;\n}\n\n/**\n * Remove every matching managed block from the file at `path`. Missing file or\n * no matching markers → a single idempotent \"skip\". When the remaining content\n * is whitespace-only AND `deleteFileIfCreated` is true (the ledger recorded\n * that agent-connector created this file), the file itself is deleted (Ruler\n * revert semantics: delete only what we created).\n */\nexport function removeManagedBlocksFile(\n  path: string,\n  match: RemoveBlocksOptions,\n  opts: { dryRun: boolean; deleteFileIfCreated?: boolean },\n): BlockFileChange[] {\n  if (!existsSync(path)) {\n    return [\n      {\n        action: \"skip\",\n        path,\n        detail: `${basename(path)} absent; nothing to remove`,\n        createdFile: false,\n        hash: \"\",\n      },\n    ];\n  }\n  let raw: string;\n  try {\n    raw = readFileSync(path, \"utf8\");\n  } catch {\n    return [\n      {\n        action: \"warn\",\n        path,\n        detail: `cannot read ${path}; managed blocks left in place`,\n        createdFile: false,\n        hash: \"\",\n      },\n    ];\n  }\n\n  const res = removeBlocksFromText(raw, match);\n  if (!res.changed) {\n    return [\n      {\n        action: \"skip\",\n        path,\n        detail: `no agent-connector blocks matching ${match.blockId ?? match.blockIdPrefix ?? \"?\"} in ${basename(path)}`,\n        createdFile: false,\n        hash: \"\",\n      },\n    ];\n  }\n\n  const changes: BlockFileChange[] = [];\n  let backupPath: string | undefined;\n  if (!opts.dryRun) {\n    if (res.recovered) backupPath = backupFile(path) ?? undefined;\n    if (res.fileNowEmpty && opts.deleteFileIfCreated) {\n      rmSync(path, { force: true });\n    } else {\n      atomicWriteFile(path, res.text);\n    }\n  }\n  for (const r of res.records) {\n    changes.push({\n      action: r.action,\n      path,\n      detail: r.detail,\n      createdFile: false,\n      hash: \"\",\n      ...(backupPath && r.action === \"warn\" ? { backupPath } : {}),\n    });\n  }\n  if (res.fileNowEmpty && opts.deleteFileIfCreated) {\n    changes.push({\n      action: \"remove\",\n      path,\n      detail: `${basename(path)} deleted (agent-connector created it; only whitespace remained)`,\n      createdFile: false,\n      hash: \"\",\n    });\n  }\n  return changes;\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Memory ownership ledger — connectorDir(id)/memory-state.json\n// ─────────────────────────────────────────────────────────────────────────\n\nexport interface MemoryLedgerTarget {\n  platform: string;\n  scope: string;\n  path: string;\n  blockId: string;\n  /** True when agent-connector CREATED the file (grants deletion rights). */\n  createdFile: boolean;\n  /** Inner-region hash we last wrote (doctor drift detection). */\n  hash: string;\n}\n\nexport interface MemoryLedger {\n  version: 1;\n  targets: MemoryLedgerTarget[];\n}\n\nexport function memoryLedgerPath(connectorId: string): string {\n  return join(connectorDir(connectorId), \"memory-state.json\");\n}\n\nexport function loadMemoryLedger(connectorId: string): MemoryLedger {\n  const p = memoryLedgerPath(connectorId);\n  if (!existsSync(p)) return { version: 1, targets: [] };\n  try {\n    const parsed = JSON.parse(readFileSync(p, \"utf8\")) as MemoryLedger;\n    if (parsed && Array.isArray(parsed.targets)) return { version: 1, targets: parsed.targets };\n  } catch {\n    /* corrupt → fresh ledger; the markers remain the source of truth */\n  }\n  return { version: 1, targets: [] };\n}\n\n/** Persist the ledger; an EMPTY ledger deletes the file (no orphan state). */\nexport function saveMemoryLedger(connectorId: string, ledger: MemoryLedger): void {\n  const p = memoryLedgerPath(connectorId);\n  if (ledger.targets.length === 0) {\n    rmSync(p, { force: true });\n    return;\n  }\n  ensureDir(dirname(p));\n  writeFileSync(p, `${JSON.stringify(ledger, null, 2)}\\n`, \"utf8\");\n}\n\n/** True when the connector has any recorded memory targets (uninstall guard). */\nexport function hasMemoryLedger(connectorId: string): boolean {\n  return loadMemoryLedger(connectorId).targets.length > 0;\n}\n\n/**\n * Upsert one ledger row (keyed by platform+scope+path+blockId). The\n * `createdFile` fact is STICKY: once we created the file, deletion rights\n * survive later syncs that found it present.\n */\nexport function recordMemoryTarget(ledger: MemoryLedger, t: MemoryLedgerTarget): void {\n  const i = ledger.targets.findIndex(\n    (x) =>\n      x.platform === t.platform &&\n      x.scope === t.scope &&\n      x.path === t.path &&\n      x.blockId === t.blockId,\n  );\n  if (i >= 0) {\n    ledger.targets[i] = { ...t, createdFile: ledger.targets[i]!.createdFile || t.createdFile };\n  } else {\n    ledger.targets.push(t);\n  }\n}\n"],"mappings":"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","names":[]}