@agfpd/iapeer-memory 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "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",
@@ -27,7 +27,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@agfpd/iapeer-memory-core": "0.1.8"
+    "@agfpd/iapeer-memory-core": "0.1.9"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",

package/src/commands/init.ts

@@ -33,7 +33,7 @@ import { installBinary } from "../binary.js";
 import { memoryPaths } from "../paths.js";
 import { provisionVault, writeDefaultConfig } from "../provision.js";
 import { writeRolesManifest, type RoleEntry } from "../roles.js";
-import { writeSlot } from "../slot.js";
+import { applyMemoryPlugin, writeSlot } from "../slot.js";
 import {
   doctrineOwnership,
   guideText,
@@ -388,7 +388,8 @@ export async function cmdInit(argv: string[]): Promise<number> {
     );
   }
 
-  // 8. slot declaration (the contract: written by the provider, atomic)
+  // 8. slot declaration (the contract: written by the provider, atomic) —
+  // v1.1: includes the plugin block the core derives installs from.
   const slot = writeSlot({
     slotPath: paths.slotPath,
     version,
@@ -402,6 +403,26 @@ export async function cmdInit(argv: string[]): Promise<number> {
     slot.action !== "refused-foreign",
   );
 
+  // 8b. session plugin across the fleet — the core verb derives the plugin
+  // from the block JUST written (order matters), installs per-peer on claude
+  // and host-globally on codex; new peers get it from the core's birth-hook.
+  // Soft-skip on an older core (verb landed in iapeer 0.2.25).
+  if (flags.skipEcosystem) {
+    step("plugin", "skipped (--skip-ecosystem)");
+  } else if (slot.action === "refused-foreign") {
+    step("plugin", "skipped (slot refused — nothing to derive the plugin from)");
+  } else {
+    const plug = applyMemoryPlugin({ mode: "on", iapeerBin: flags.iapeerBin });
+    step(
+      "plugin",
+      plug.suppressed
+        ? "skipped (test sandbox — core calls suppressed)"
+        : plug.ok
+          ? "session plugin rolled out across the fleet (iapeer memory-plugin on --all)"
+          : `soft-skip: ${plug.detail.slice(0, 160) || "verb failed"} — upgrade the iapeer core (≥0.2.25) or run manually: iapeer memory-plugin on --all`,
+    );
+  }
+
   // 9. native-memory sweep — the core's lever (one home of runtime forms);
   // soft-skip when the verb is unavailable (older core), verify re-runs later.
   if (flags.skipEcosystem) {

package/src/commands/uninstall.ts

@@ -18,7 +18,7 @@
 import fs from "node:fs";
 import { memoryPaths } from "../paths.js";
 import { removeBinary } from "../binary.js";
-import { removeSlot } from "../slot.js";
+import { applyMemoryPlugin, readSlot, removeSlot, SLOT_PROVIDER } from "../slot.js";
 import {
   DREAM_TRIGGER_ID,
   SWEEP_TRIGGER_ID,
@@ -95,6 +95,28 @@ export function cmdUninstall(argv: string[]): number {
   const paths = memoryPaths();
   let failed = false;
 
+  // Session plugin OFF across the fleet BEFORE removing the declaration —
+  // the core verb DERIVES the plugin identity from the slot's v1.1 block;
+  // once the declaration is gone there is nothing to derive from (agreed
+  // order with the core, auto-removal: a dead provider's plugin must not
+  // keep injecting). Guard: only when the slot is OURS — running `off`
+  // against a foreign declaration would strip the FOREIGN provider's plugin.
+  // codex nuance: the codex plugin is host-global, so `off` there is always
+  // `--all` semantics; per-peer off on codex answers «use --all».
+  const declared = readSlot(paths.slotPath);
+  if (declared && declared.provider === SLOT_PROVIDER) {
+    const off = applyMemoryPlugin({ mode: "off", iapeerBin });
+    console.log(
+      `plugin    : ${
+        off.suppressed
+          ? "skipped (test sandbox — core calls suppressed)"
+          : off.ok
+            ? "session plugin removed across the fleet (memory-plugin off --all; codex side is host-global)"
+            : `off not applied (${off.detail.slice(0, 160)}) — manual fallback (works without the slot): per claude peer \`claude plugin uninstall iapeer-memory@agfpd --scope project\` from its cwd; codex (host-global): \`codex plugin remove iapeer-memory@agfpd\``
+      }`,
+    );
+  }
+
   const slot = removeSlot(paths.slotPath);
   if (slot === "refused-foreign") {
     console.log("slot      : held by a FOREIGN provider — left intact");

package/src/slot.ts

@@ -11,7 +11,15 @@
  * - `version` = the package version (the same single source as the doctrine
  *   marker, ADR-010); our `update` re-writes it (P4 obligation);
  * - `heartbeat` (optional) = the absolute path whose mtime memoryd touches —
- *   the core may show staleness in `iapeer status`, never acts on it.
+ *   the core may show staleness in `iapeer status`, never acts on it;
+ * - `plugin` (v1.1, agreed 10.06 + live in iapeer 0.2.25) = the marketplace
+ *   identity of the session plugin. The core DERIVES installs from this block:
+ *   birth-hook installs for new peers, `iapeer memory-plugin on|off (--peer|
+ *   --all)` is the operator verb (built-in marketplace ensure + stale-cache
+ *   retry). Reference reader: iapeer src/status/index.ts parsePluginBlock —
+ *   all three fields required non-empty, anything less = treated as a v1
+ *   declaration (no install). marketplaceRef matches iapeer onboard's
+ *   MARKETPLACE_REF for the distribution default.
  */
 
 import fs from "node:fs";
@@ -20,12 +28,29 @@ import path from "node:path";
 export const SLOT_PROVIDER = "iapeer-memory";
 export const SLOT_PACKAGE = "@agfpd/iapeer-memory";
 
+/** Mirror of iapeer's MemoryProviderPlugin (src/status/index.ts). */
+export type MemoryProviderPlugin = {
+  /** Plugin id in the marketplace (forms `<name>@<marketplace>`). */
+  name: string;
+  /** Marketplace NAME the plugin id keys on. */
+  marketplace: string;
+  /** Source ref for `plugin marketplace add` when absent on the host (owner/repo). */
+  marketplaceRef: string;
+};
+
+export const SLOT_PLUGIN: MemoryProviderPlugin = {
+  name: "iapeer-memory",
+  marketplace: "agfpd",
+  marketplaceRef: "agfpd/agfpd-marketplace",
+};
+
 export type MemoryProviderSlot = {
   provider: string;
   package: string;
   version: string;
   registeredAt: string;
   heartbeat?: string;
+  plugin?: MemoryProviderPlugin;
 };
 
 /** Never throws: missing / unreadable / malformed → null (empty slot). */
@@ -59,7 +84,11 @@ export function writeSlot(opts: {
     existing &&
     existing.version === opts.version &&
     existing.heartbeat === opts.heartbeat &&
-    existing.package === SLOT_PACKAGE
+    existing.package === SLOT_PACKAGE &&
+    existing.plugin &&
+    existing.plugin.name === SLOT_PLUGIN.name &&
+    existing.plugin.marketplace === SLOT_PLUGIN.marketplace &&
+    existing.plugin.marketplaceRef === SLOT_PLUGIN.marketplaceRef
   ) {
     return { action: "identical", existing }; // idempotent re-init: no churn
   }
@@ -69,6 +98,7 @@ export function writeSlot(opts: {
     version: opts.version,
     registeredAt: opts.nowIso ?? new Date().toISOString(),
     ...(opts.heartbeat ? { heartbeat: opts.heartbeat } : {}),
+    plugin: SLOT_PLUGIN,
   };
   fs.mkdirSync(path.dirname(opts.slotPath), { recursive: true });
   const tmp = `${opts.slotPath}.tmp`;
@@ -87,3 +117,57 @@ export function removeSlot(slotPath: string): SlotRemoveResult {
   fs.unlinkSync(slotPath);
   return "removed";
 }
+
+export type MemoryPluginApplyResult = {
+  ok: boolean;
+  detail: string;
+  /** True when the test-sandbox fuse blocked the call — callers report a
+   *  SKIP, not a failure (same contract as watcher.ts iapSend). */
+  suppressed?: boolean;
+};
+
+/**
+ * Fleet-wide install/remove of the slot-declared session plugin via the core
+ * verb `iapeer memory-plugin <on|off> --all` (iapeer ≥0.2.25; marketplace
+ * ensure + stale-cache retry live INSIDE the verb). The verb derives the
+ * plugin identity from the slot declaration — so `on` runs AFTER writeSlot
+ * and `off` runs BEFORE removeSlot (agreed order, auto-removal: a dead
+ * provider's plugin must not keep injecting).
+ *
+ * Hard fuse first (same class as iapSend, incident 10.06): `on --all`
+ * mutates the HOST fleet — no sandbox env contains it, tests must never
+ * reach the live core. Both belts honoured.
+ */
+export function applyMemoryPlugin(opts: {
+  mode: "on" | "off";
+  iapeerBin?: string;
+}): MemoryPluginApplyResult {
+  if (
+    process.env.IAPEER_MEMORY_SUPPRESS_IAP_SEND === "1" ||
+    process.env.IAPEER_TEST_SANDBOX === "1"
+  ) {
+    return {
+      ok: false,
+      suppressed: true,
+      detail: "memory-plugin call suppressed (test sandbox)",
+    };
+  }
+  const bin = opts.iapeerBin ?? "iapeer";
+  try {
+    const proc = Bun.spawnSync([bin, "memory-plugin", opts.mode, "--all"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (proc.exitCode !== 0) {
+      return {
+        ok: false,
+        detail:
+          (proc.stderr.toString().trim() || proc.stdout.toString().trim() || "").slice(0, 200) ||
+          `iapeer memory-plugin exited ${proc.exitCode}`,
+      };
+    }
+    return { ok: true, detail: proc.stdout.toString().trim() };
+  } catch (err) {
+    return { ok: false, detail: `${bin} unavailable: ${String(err)}` };
+  }
+}