@agfpd/iapeer-memory 0.1.1

package/README.md

@@ -0,0 +1,3 @@
+# package
+
+npm-фасад iapeer-фундамента: CLI (init/verify/update/fm-update/render), регистрация memoryd-watcher у notifier, рендер доктрин ролей, шаблоны vault (ADR-009/010). Наполняется после core.

package/bin/iapeer-memory

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# npx @agfpd/iapeer-memory bootstrap.
+#
+# Runs the iapeer-memory CLI from the package SOURCE via bun — the package is
+# TypeScript-only, no precompiled JS is shipped (ADR-003; same pattern as the
+# @agfpd/iapeer foundation bin). All args pass straight through to the CLI;
+# a BARE invocation prints usage — provisioning is always explicit:
+# `npx @agfpd/iapeer-memory init`.
+set -euo pipefail
+
+# Resolve the real path of this script BEFORE computing the package root.
+# npm/npx expose the bin as a SYMLINK at node_modules/.bin/iapeer-memory →
+# ../@agfpd/iapeer-memory/bin/iapeer-memory; without resolving it, dirname/..
+# lands on node_modules (not the package dir) and src/cli.ts is not found.
+SOURCE="${BASH_SOURCE[0]}"
+while [ -L "$SOURCE" ]; do
+  DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+PKG_ROOT="$(cd -P "$(dirname "$SOURCE")/.." && pwd)"
+CLI="$PKG_ROOT/src/cli.ts"
+
+if ! command -v bun >/dev/null 2>&1; then
+  echo "iapeer-memory: 'bun' is required on PATH to run the CLI — install it from https://bun.sh" >&2
+  exit 1
+fi
+
+exec bun "$CLI" "$@"

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@agfpd/iapeer-memory",
+  "version": "0.1.1",
+  "description": "iapeer-memory — peer memory for the iapeer ecosystem: vault, memoryd (index/search/MCP-http), layer-5 context fragments, role doctrines. The package IS the system; the claude/codex plugins are thin session sockets (docs/10-distribution.md, ADR-009).",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "iapeer-memory": "bin/iapeer-memory"
+  },
+  "files": [
+    "src",
+    "bin",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "preversion": "bun run test && bun run typecheck",
+    "version": "bun src/sync-versions.ts && git add -A ..",
+    "release": "npm version patch --workspaces-update=false && npm run release:finish",
+    "release:minor": "npm version minor --workspaces-update=false && npm run release:finish",
+    "release:major": "npm version major --workspaces-update=false && npm run release:finish",
+    "release:finish": "V=$(bun -e 'console.log(JSON.parse(require(\"fs\").readFileSync(\"package.json\",\"utf-8\")).version)') && git -C .. commit -m \"$V\" && git -C .. tag \"v$V\" && (cd ../core && npm publish) && npm publish && git push --follow-tags",
+    "prepublishOnly": "test -z \"$(git status --porcelain)\" || (echo 'release: working tree is dirty — commit or stash before release' >&2 && exit 1)"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@agfpd/iapeer-memory-core": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/binary.ts

@@ -0,0 +1,75 @@
+/**
+ * Stable CLI binary — `bun build --compile` into `~/.local/bin/iapeer-memory`
+ * (the @agfpd/iapeer precedent: notifier/telegram runtime packages ship the
+ * same Mach-O form). WHY a compiled binary and not the npx cache: hooks,
+ * the notifier watcher launcher and the shims need a path that survives
+ * npx-cache eviction — the proven MergeMind production defect class
+ * («daemons executing a deleted cache snapshot») is closed by owning a
+ * stable artifact (ADR-010).
+ *
+ * Facts from the P3a compile check (live, bun 1.3.13):
+ * - the whole workspace (package + core) bundles into one ~61MB binary;
+ * - runtime fs reads of package.json do NOT work inside the binary
+ *   (`/$bunfs/`) — versions are embedded via static json imports;
+ * - bun:sqlite works compiled (memoryd ran live: DB created, MCP up,
+ *   heartbeat, clean SIGTERM); the sqlite-vec extension path is exercised
+ *   only with an embedding endpoint configured and degrades to BM25-only
+ *   with a logged reason — re-checked at the P3c live smoke.
+ *
+ * Recompilation needs SOURCES: a compiled binary cannot rebuild itself from
+ * /$bunfs — `install-binary` run from the installed binary reports
+ * `skipped-compiled` (re-install goes through npx, which runs from source).
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+export function isCompiledRuntime(): boolean {
+  return import.meta.url.includes("/$bunfs/");
+}
+
+export type InstallBinaryOutcome =
+  | { action: "compiled"; outPath: string; bytes: number }
+  | { action: "skipped-compiled"; outPath: string }
+  | { action: "failed"; outPath: string; detail: string };
+
+export function installBinary(opts: { outPath: string }): InstallBinaryOutcome {
+  const { outPath } = opts;
+  if (isCompiledRuntime()) {
+    return { action: "skipped-compiled", outPath };
+  }
+
+  const cliPath = new URL("./cli.ts", import.meta.url).pathname;
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  const tmp = path.join(
+    path.dirname(outPath),
+    `.${path.basename(outPath)}.build.tmp`,
+  );
+
+  const proc = Bun.spawnSync(
+    [process.execPath, "build", "--compile", cliPath, "--outfile", tmp],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+  if (proc.exitCode !== 0 || !fs.existsSync(tmp)) {
+    try {
+      if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    } catch {
+      // best effort
+    }
+    return {
+      action: "failed",
+      outPath,
+      detail: proc.stderr.toString().trim() || `bun build exited ${proc.exitCode}`,
+    };
+  }
+
+  fs.chmodSync(tmp, 0o755);
+  fs.renameSync(tmp, outPath); // atomic swap — safe over a running binary on macOS
+  return { action: "compiled", outPath, bytes: fs.statSync(outPath).size };
+}
+
+export function removeBinary(outPath: string): "removed" | "absent" {
+  if (!fs.existsSync(outPath)) return "absent";
+  fs.unlinkSync(outPath);
+  return "removed";
+}

package/src/cli.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env bun
+/**
+ * iapeer-memory CLI — the package facade over core (docs/10-distribution.md).
+ *
+ * The package IS the system (ADR-009): everything live — memoryd with the
+ * MCP-http endpoint, fragment/index/doctrine rendering, frontmatter tooling,
+ * install/verify/update — enters through this binary. The claude/codex
+ * plugins are thin session sockets that call back into it.
+ *
+ * Boot order: resolve the path namespace → load the package config file
+ * (env precedence: flags > process env > config file > defaults,
+ * `config-env.ts`) → dispatch. Exit codes: 0 ok, 1 command failed /
+ * verify found problems, 2 usage error or not-yet-implemented stage.
+ */
+
+import { loadConfigFile } from "./config-env.js";
+import { memoryPaths } from "./paths.js";
+import { packageVersion } from "./version.js";
+import { cmdFmUpdate } from "./commands/fm-update.js";
+import { cmdHook } from "./commands/hook.js";
+import { cmdInit } from "./commands/init.js";
+import { cmdInstallBinary } from "./commands/install-binary.js";
+import { cmdMemoryd } from "./commands/memoryd.js";
+import { cmdMigrate } from "./commands/migrate.js";
+import { cmdRender } from "./commands/render.js";
+import { cmdStatus } from "./commands/status.js";
+import { cmdUninstall } from "./commands/uninstall.js";
+import { cmdUpdate } from "./commands/update.js";
+import { cmdVerify } from "./commands/verify.js";
+
+export const USAGE = `iapeer-memory — peer memory for the iapeer ecosystem
+
+Usage: iapeer-memory <command> [options]
+
+Commands:
+  init                      provision the system on this host (vault, config,
+                            role peers, memoryd registration); idempotent
+  uninstall [--keep-binary] remove the system: slot declaration + binary
+                            (vault and config are kept — user-owned)
+  status                    read-only diagnostics: verify + slot + MCP probe
+                            + inbox load
+  verify [--repair]         check (and repair) the live surfaces: config,
+                            memory-provider slot, memoryd heartbeat, role
+                            doctrine versions
+  update [--skip-binary]    update every surface (ADR-010): binary recompile,
+                            templates, doctrine re-render, slot version,
+                            launcher, managed memoryd restart
+  install-binary [--out P]  compile the stable CLI binary (~/.local/bin) —
+                            init step / repair path; needs package sources
+  fm-update [ops] FILE...   structural frontmatter edits + attribution stamp
+  migrate --source DIR      move harness auto-memory into the vault
+                            (dry-run by default; --apply to execute)
+  render index|fragment|doctrine|guide
+                            render one artifact explicitly (memoryd does this
+                            continuously; render is the manual/scripted path)
+  memoryd                   run the daemon in the foreground (stdout = event
+                            lines; supervised by a notifier watcher)
+  hook post-write|session-start
+                            plugin-hook engine (the adapters' bash hooks are
+                            3-line shims around these; fail-open by contract)
+  version                   print the package version
+  help                      print this help
+
+Config file: ~/.iapeer/plugins/iapeer-memory/config.env (env format;
+overridable via IAPEER_MEMORY_CONFIG_FILE). An explicit IAPEER_MEMORY_* in
+the process env always wins over the file.`;
+
+export async function main(argv: string[]): Promise<number> {
+  const [cmd, ...rest] = argv;
+
+  // The config file is the env context of every command (except pure
+  // help/version, where a broken file must not block the output).
+  if (cmd && !["help", "--help", "-h", "version", "--version", "-V"].includes(cmd)) {
+    loadConfigFile(memoryPaths().configFile);
+  }
+
+  switch (cmd) {
+    case undefined:
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(USAGE);
+      return 0;
+    case "version":
+    case "--version":
+    case "-V":
+      console.log(packageVersion());
+      return 0;
+    case "init":
+      return cmdInit(rest);
+    case "uninstall":
+      return cmdUninstall(rest);
+    case "status":
+      return cmdStatus(rest);
+    case "verify":
+      return cmdVerify(rest);
+    case "update":
+      return cmdUpdate(rest);
+    case "install-binary":
+      return cmdInstallBinary(rest);
+    case "fm-update":
+      return cmdFmUpdate(rest);
+    case "migrate":
+      return cmdMigrate(rest);
+    case "render":
+      return cmdRender(rest);
+    case "memoryd":
+      return cmdMemoryd(rest);
+    case "hook":
+      return cmdHook(rest);
+    default:
+      console.error(`iapeer-memory: unknown command: ${cmd}\n`);
+      console.error(USAGE);
+      return 2;
+  }
+}
+
+if (import.meta.main) {
+  process.exitCode = await main(process.argv.slice(2));
+}

package/src/commands/fm-update.ts

@@ -0,0 +1,104 @@
+/**
+ * `iapeer-memory fm-update` — argv glue for the core `fmUpdate` engine.
+ * The contract is fixed in the core module header (core/src/fm-update.ts):
+ *
+ *     iapeer-memory fm-update [--agent NAME] [--vault PATH] [--no-stamp]
+ *       [--set KEY VALUE | --unset KEY | --list-add KEY VALUE
+ *        | --list-remove KEY VALUE]...
+ *       FILE [FILE ...]
+ *
+ * - identity: `--agent` → PEER_PERSONALITY → IAPEER_MEMORY_AGENT_NAME
+ *   (resolveAgentName, нюанс 10 — never guessed from cwd);
+ * - with no operations it is a pure attribution stamp;
+ * - taxonomy/curator-set come from the env context (config file already
+ *   loaded by the CLI boot), NOT from configFromEnv — fm-update must work
+ *   on explicit paths without a provisioned vault env.
+ */
+
+import {
+  collectOps,
+  DEFAULT_CURATOR_SET,
+  fmUpdate,
+  getTaxonomy,
+  isLocaleId,
+  resolveAgentName,
+} from "@agfpd/iapeer-memory-core";
+
+export function cmdFmUpdate(argv: string[]): number {
+  let agent: string | null = null;
+  let vault = "";
+  let stamp = true;
+  const set: Array<[string, string]> = [];
+  const unset: string[] = [];
+  const listAdd: Array<[string, string]> = [];
+  const listRemove: Array<[string, string]> = [];
+  const files: string[] = [];
+
+  const take = (flag: string, i: number): string => {
+    const v = argv[i];
+    if (v === undefined) throw new UsageError(`${flag} requires a value`);
+    return v;
+  };
+
+  try {
+    for (let i = 0; i < argv.length; i++) {
+      const a = argv[i];
+      switch (a) {
+        case "--agent":
+          agent = take(a, ++i);
+          break;
+        case "--vault":
+          vault = take(a, ++i);
+          break;
+        case "--no-stamp":
+          stamp = false;
+          break;
+        case "--set":
+          set.push([take(a, ++i), take(a, ++i)]);
+          break;
+        case "--unset":
+          unset.push(take(a, ++i));
+          break;
+        case "--list-add":
+          listAdd.push([take(a, ++i), take(a, ++i)]);
+          break;
+        case "--list-remove":
+          listRemove.push([take(a, ++i), take(a, ++i)]);
+          break;
+        default:
+          if (a.startsWith("--")) throw new UsageError(`unknown flag: ${a}`);
+          files.push(a);
+      }
+    }
+    if (!files.length) throw new UsageError("no files given");
+  } catch (err) {
+    if (err instanceof UsageError) {
+      console.error(`iapeer-memory fm-update: ${err.message}`);
+      return 2;
+    }
+    throw err;
+  }
+
+  const localeRaw = process.env.IAPEER_MEMORY_LOCALE || "en";
+  if (!isLocaleId(localeRaw)) {
+    console.error(`iapeer-memory fm-update: unknown locale "${localeRaw}"`);
+    return 2;
+  }
+  const curatorSet = (process.env.IAPEER_MEMORY_CURATOR_SET || "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  fmUpdate({
+    files,
+    ops: collectOps({ set, unset, listAdd, listRemove }),
+    agent: resolveAgentName(agent),
+    vault: vault || process.env.IAPEER_MEMORY_VAULT_PATH || "",
+    taxonomy: getTaxonomy(localeRaw),
+    curatorSet: curatorSet.length ? curatorSet : DEFAULT_CURATOR_SET,
+    stamp,
+  });
+  return 0;
+}
+
+class UsageError extends Error {}

package/src/commands/hook.ts

@@ -0,0 +1,264 @@
+/**
+ * `iapeer-memory hook <event>` — the TESTABLE engine of the plugin hooks
+ * (ADR-009: the plugin is a thin session socket; its bash hooks are 3-line
+ * shims that exec this CLI). All parsing/gating logic lives here under
+ * tests — the reference's bash/python JSON juggling is deliberately not
+ * ported.
+ *
+ *   hook post-write     stdin: PostToolUse event JSON. Claude tools
+ *                       Write|Edit|MultiEdit (the codex `apply_patch`
+ *                       branch lands in P5 behind the live-format gate).
+ *                       Stamps vault-note frontmatter through the SAME
+ *                       core fill the fm-update path uses; a NEW note
+ *                       (Write) in the author's own agent-memory folder
+ *                       additionally emits the "team material?" reminder.
+ *                       Reference fact: PostToolUse plain stdout is NOT
+ *                       injected — the reminder goes out as
+ *                       hookSpecificOutput.additionalContext JSON.
+ *
+ *   hook session-start  SessionStart health-check (ADR-009 п.3): NEVER a
+ *                       content inject. Provisioned + fresh heartbeat →
+ *                       silent. Unprovisioned → one-line hint. Missing /
+ *                       stale heartbeat → one-line degraded warning
+ *                       (SessionStart plain stdout IS injected — reference
+ *                       fact) + a DEBOUNCED background kick of
+ *                       `verify --repair` (stamp file in state dir — many
+ *                       peers waking at once must not storm repairs).
+ *
+ * Both verbs are FAIL-OPEN: any internal error is appended to
+ * `<logs>/hook-errors.log` and the exit code stays 0 — a memory hook must
+ * never block the author's tool flow or session start.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  DEFAULT_CURATOR_SET,
+  fmUpdate,
+  getTaxonomy,
+  isLocaleId,
+  resolveAgentName,
+} from "@agfpd/iapeer-memory-core";
+import { memoryPaths, type MemoryPaths } from "../paths.js";
+import { DEFAULT_HEARTBEAT_STALE_MS } from "./verify.js";
+
+/** Tools whose writes stamp frontmatter. P5 adds "apply_patch" (codex). */
+export const POST_WRITE_TOOLS: ReadonlySet<string> = new Set([
+  "Write",
+  "Edit",
+  "MultiEdit",
+]);
+
+/** Min interval between background verify-kicks (anti-storm). */
+export const KICK_DEBOUNCE_MS = 5 * 60_000;
+
+// ── post-write ───────────────────────────────────────────────────────────────
+
+export type PostWriteResult = {
+  stamped: boolean;
+  /** JSON string for stdout (hookSpecificOutput), or null for silence. */
+  output: string | null;
+};
+
+export function reminderText(inboxFolder: string): string {
+  return (
+    "[iapeer-memory] New note in your agent memory. Check the guide's " +
+    "canon-vs-memory filter: does any part of it belong to the team's shared " +
+    `knowledge? If yes — also drop a draft into ${inboxFolder}/ and mention ` +
+    "this note inline as [[Title]] in the draft body; the Index will link them."
+  );
+}
+
+export function runPostWrite(
+  eventJson: string,
+  env: Record<string, string | undefined> = process.env,
+): PostWriteResult {
+  const silent: PostWriteResult = { stamped: false, output: null };
+
+  let event: { tool_name?: string; tool_input?: { file_path?: string } };
+  try {
+    event = JSON.parse(eventJson) as typeof event;
+  } catch {
+    return silent; // malformed event — not our problem to escalate
+  }
+  const tool = event.tool_name ?? "";
+  // Cheap tool gate FIRST (codex sends post_tool_use for EVERY tool —
+  // reference live-smoke fact; the same ordering keeps claude cheap too).
+  if (!POST_WRITE_TOOLS.has(tool)) return silent;
+
+  const filePath = event.tool_input?.file_path ?? "";
+  if (!filePath.endsWith(".md")) return silent;
+
+  const vault = env.IAPEER_MEMORY_VAULT_PATH ?? "";
+  if (!vault) return silent; // socket without a provisioned system
+  if (!filePath.startsWith(vault.endsWith(path.sep) ? vault : vault + path.sep)) {
+    return silent; // outside the vault — никогда не трогаем чужие файлы
+  }
+  if (!fs.existsSync(filePath)) return silent; // failed write — nothing to stamp
+
+  // Identity: PEER_PERSONALITY → IAPEER_MEMORY_AGENT_NAME. NO cwd guessing
+  // (нюанс 10 — deliberate divergence from the reference basename(PWD)).
+  const agent = resolveAgentName(null, env);
+  if (!agent) return silent;
+
+  const localeRaw = env.IAPEER_MEMORY_LOCALE || "en";
+  if (!isLocaleId(localeRaw)) return silent;
+  const taxonomy = getTaxonomy(localeRaw);
+  const curatorSet = (env.IAPEER_MEMORY_CURATOR_SET || "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  fmUpdate({
+    files: [filePath],
+    ops: [],
+    agent,
+    vault,
+    taxonomy,
+    curatorSet: curatorSet.length ? curatorSet : DEFAULT_CURATOR_SET,
+    stamp: true,
+  });
+
+  // Reminder: ONLY on Write (new note) in the author's OWN memory folder —
+  // an Edit-loop on one note must not spam the context (reference semantics).
+  const ownMemoryDir =
+    path.join(vault, taxonomy.folders.agentMemory, agent) + path.sep;
+  const output =
+    tool === "Write" && filePath.startsWith(ownMemoryDir)
+      ? JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: reminderText(taxonomy.folders.inbox),
+          },
+        })
+      : null;
+
+  return { stamped: true, output };
+}
+
+// ── session-start ────────────────────────────────────────────────────────────
+
+export type SessionStartResult = {
+  /** One-line context message, or null for a healthy silent start. */
+  output: string | null;
+  kicked: boolean;
+};
+
+export function runSessionStart(opts: {
+  paths?: MemoryPaths;
+  env?: Record<string, string | undefined>;
+  nowMs?: number;
+  staleMs?: number;
+  /** Injectable background-kicker (the CLI glue spawns verify --repair). */
+  kick?: () => void;
+}): SessionStartResult {
+  const env = opts.env ?? process.env;
+  const paths = opts.paths ?? memoryPaths(env);
+  const nowMs = opts.nowMs ?? Date.now();
+  const staleMs = opts.staleMs ?? DEFAULT_HEARTBEAT_STALE_MS;
+
+  // Not provisioned at all (no config file AND no env context): one hint,
+  // no repair kick — there is nothing to repair yet.
+  const vault = env.IAPEER_MEMORY_VAULT_PATH ?? "";
+  if (!vault && !fs.existsSync(paths.configFile)) {
+    return {
+      output:
+        "[iapeer-memory] plugin is installed but the system is not " +
+        "provisioned on this host — run: npx @agfpd/iapeer-memory init",
+      kicked: false,
+    };
+  }
+
+  let problem: string | null = null;
+  try {
+    const ageMs = nowMs - fs.statSync(paths.heartbeatPath).mtimeMs;
+    if (ageMs > staleMs) {
+      problem = `memoryd heartbeat is stale (${Math.round(ageMs / 1000)}s old) — the daemon looks hung`;
+    }
+  } catch {
+    problem = "memoryd is not running (no heartbeat)";
+  }
+  if (!problem) return { output: null, kicked: false };
+
+  // Debounced self-repair kick (ADR-010: the system is repaired by whichever
+  // peer is alive). The stamp file gates the storm of simultaneous wakes.
+  let kicked = false;
+  const stamp = path.join(paths.stateDir, "verify-kick.stamp");
+  let recentKick = false;
+  try {
+    recentKick = nowMs - fs.statSync(stamp).mtimeMs < KICK_DEBOUNCE_MS;
+  } catch {
+    recentKick = false;
+  }
+  if (!recentKick) {
+    try {
+      fs.mkdirSync(paths.stateDir, { recursive: true });
+      fs.writeFileSync(stamp, `${new Date(nowMs).toISOString()}\n`);
+      opts.kick?.();
+      kicked = true;
+    } catch {
+      // best effort — the warning still reaches the context
+    }
+  }
+
+  return {
+    output:
+      `[iapeer-memory] degraded: ${problem}. ` +
+      (kicked
+        ? "Kicked `verify --repair` in the background; "
+        : "Repair was kicked recently; ") +
+      "check with: iapeer-memory verify",
+    kicked,
+  };
+}
+
+// ── CLI glue ─────────────────────────────────────────────────────────────────
+
+function logHookError(err: unknown): void {
+  try {
+    const dir = memoryPaths().logsDir;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(
+      path.join(dir, "hook-errors.log"),
+      `${new Date().toISOString()} ${String(err)}\n`,
+    );
+  } catch {
+    // truly nowhere to report — stay silent, stay fail-open
+  }
+}
+
+export async function cmdHook(argv: string[]): Promise<number> {
+  const [event] = argv;
+  try {
+    switch (event) {
+      case "post-write": {
+        const result = runPostWrite(await Bun.stdin.text());
+        if (result.output) console.log(result.output);
+        return 0;
+      }
+      case "session-start": {
+        const result = runSessionStart({
+          kick: () => {
+            const cli = new URL("../cli.ts", import.meta.url).pathname;
+            const proc = Bun.spawn([process.execPath, cli, "verify", "--repair"], {
+              stdout: "ignore",
+              stderr: "ignore",
+              stdin: "ignore",
+            });
+            proc.unref();
+          },
+        });
+        if (result.output) console.log(result.output);
+        return 0;
+      }
+      default:
+        console.error(
+          `iapeer-memory hook: unknown event: ${event ?? "(none)"} (expected post-write | session-start)`,
+        );
+        return 2;
+    }
+  } catch (err) {
+    logHookError(err);
+    return 0; // fail-open by contract
+  }
+}