@agfpd/iapeer-memory 0.1.12 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory",
-  "version": "0.1.12",
+  "version": "0.2.0",
   "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.12"
+    "@agfpd/iapeer-memory-core": "0.2.0"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",

package/src/cli.ts

@@ -22,6 +22,7 @@ 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 { cmdProvisionPeer, cmdUnprovisionPeer } from "./commands/provision-peer.js";
 import { cmdRender } from "./commands/render.js";
 import { cmdStatus } from "./commands/status.js";
 import { cmdUninstall } from "./commands/uninstall.js";
@@ -47,6 +48,13 @@ Commands:
                             launcher, managed memoryd restart
   install-binary [--out P]  compile the stable CLI binary (~/.local/bin) —
                             init step / repair path; needs package sources
+  provision-peer --cwd P --runtime claude|codex --personality NAME [--occasion O]
+                            merge the direct session surfaces into one peer's
+                            cwd (claude: hooks/MCP/skills; codex: project MCP;
+                            idempotent, own keys only); the iapeer core shells
+                            into this at peer birth
+  unprovision-peer --cwd P --runtime claude|codex [--occasion O]
+                            strip OUR surfaces from one peer's cwd (mirror)
   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)
@@ -98,6 +106,10 @@ export async function main(argv: string[]): Promise<number> {
       return cmdUpdate(rest);
     case "install-binary":
       return cmdInstallBinary(rest);
+    case "provision-peer":
+      return cmdProvisionPeer(rest);
+    case "unprovision-peer":
+      return cmdUnprovisionPeer(rest);
     case "fm-update":
       return cmdFmUpdate(rest);
     case "migrate":

package/src/commands/init.ts

@@ -13,10 +13,12 @@
  * (sent only when exactly one natural peer exists in the registry).
  *
  * Step order: deps → vault → config → binary → templates → role peers +
- * doctrines + roles manifest → watcher registration → slot declaration →
- * native-memory sweep (core verb, soft-skip on old cores) → host-wide
- * guide fragment. Ecosystem steps are skippable (--skip-ecosystem) for
- * sandboxed runs; the binary compile is skippable (--skip-binary) for
+ * doctrines + roles manifest → fleet map → watcher registration → direct
+ * session surfaces sweep (ADR-009 v1.2) → legacy v1.1 plugin off (while the
+ * old declaration is still readable) → slot declaration (v1.2 provision
+ * command) → native-memory sweep (core verb, soft-skip on old cores) →
+ * host-wide guide fragment. Ecosystem steps are skippable (--skip-ecosystem)
+ * for sandboxed runs; the binary compile is skippable (--skip-binary) for
  * fast tests.
  */
 
@@ -33,7 +35,11 @@ import { installBinary } from "../binary.js";
 import { memoryPaths } from "../paths.js";
 import { provisionVault, writeDefaultConfig } from "../provision.js";
 import { writeRolesManifest, type RoleEntry } from "../roles.js";
-import { applyMemoryPlugin, writeSlot } from "../slot.js";
+import { applyMemoryPlugin, readSlot, writeSlot, SLOT_PROVIDER } from "../slot.js";
+import { readFleetMap, writeFleetMap } from "../fleet.js";
+import { withProvisionLock } from "../surfaces/lock.js";
+import { sweepProvision } from "../surfaces/sweep.js";
+import { mcpPort } from "./provision-peer.js";
 import {
   doctrineOwnership,
   guideText,
@@ -340,6 +346,27 @@ export async function cmdInit(argv: string[]): Promise<number> {
     );
   }
 
+  // 6b. fleet map — personality → cwd for memoryd's fragment renderer
+  // (docs/05; дыра 10.06: без карты пиры не получали paths-блок и индекс).
+  // ПЕРЕД watcher-регистрацией: memoryd, поднятый notifier'ом, рендерит
+  // весь флот уже на старте. Roles-степ выше уже создал ролевых пиров —
+  // карта включает их.
+  if (flags.skipEcosystem) {
+    step("fleet", "skipped (--skip-ecosystem)");
+  } else {
+    const fleet = writeFleetMap({
+      fleetMapPath: paths.fleetMapPath,
+      iapeerBin: flags.iapeerBin,
+    });
+    step(
+      "fleet",
+      fleet.action === "written"
+        ? fleet.detail
+        : `fleet map not written (${fleet.detail}) — fragments stay off until verify --repair`,
+      fleet.action === "written",
+    );
+  }
+
   // 7. notifier wiring (ADR-015, инверсия): the EVENT trigger targets the
   // SCRIBER (first receiver); two TIMERS target the index — weekly
   // DREAM_TICK and the check-gated fail-open sweep. Registrant = index for
@@ -388,39 +415,101 @@ export async function cmdInit(argv: string[]): Promise<number> {
     );
   }
 
-  // 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,
-    heartbeat: paths.heartbeatPath,
-  });
-  step(
-    "slot",
-    slot.action === "refused-foreign"
-      ? `slot held by foreign provider "${slot.existing?.provider}" — uninstall it first`
-      : `${paths.slotPath} (${slot.action}, v${version})`,
-    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)");
+  // 8. slot + surfaces + v1.1 migration — ORDER MATTERS (ADR-009 v1.2):
+  //   8a. a FOREIGN slot refuses the whole block (never lay surfaces over
+  //       another provider's host);
+  //   8b. direct surfaces sweep across the existing fleet (the new channel
+  //       must be in place BEFORE the old one is stripped);
+  //   8c. legacy plugin off — while the v1.1 slot is STILL on disk (the
+  //       core verb derives the plugin identity from the live declaration;
+  //       overwriting first would leave it nothing to derive from);
+  //   8d. slot declaration re-written in the v1.2 form (provision command,
+  //       no plugin block). Newborns are then the core birth-hook's duty.
+  const existingSlot = readSlot(paths.slotPath);
+  const slotForeign = existingSlot !== null && existingSlot.provider !== SLOT_PROVIDER;
+  if (slotForeign) {
+    step("slot", `slot held by foreign provider "${existingSlot?.provider}" — uninstall it first`, false);
+    step("surfaces", "skipped (foreign slot — not our host)");
   } 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`,
-    );
+    // 8b. direct session surfaces across the EXISTING fleet — the package's
+    // own rail over the fleet map written in 6b.
+    let surfacesOk = false;
+    if (flags.skipEcosystem) {
+      step("surfaces", "skipped (--skip-ecosystem)");
+      surfacesOk = true; // sandboxed run — don't block the slot/migration steps
+    } else {
+      const fleet = readFleetMap(paths.fleetMapPath) ?? [];
+      const locked = withProvisionLock({
+        stateDir: paths.stateDir,
+        fn: () => sweepProvision({ fleet, hooksDir: paths.hooksDir, port: mcpPort() }),
+      });
+      if (!locked.acquired) {
+        step("surfaces", locked.detail, false);
+      } else {
+        const { results, skipped } = locked.result;
+        const failed = results.filter((r) => !r.ok);
+        surfacesOk = failed.length === 0;
+        step(
+          "surfaces",
+          `${results.length - failed.length}/${results.length} peer-runtime(s) provisioned` +
+            (skipped.length ? `, ${skipped.length} skipped (no session runtime / missing cwd)` : "") +
+            " — live sessions pick them up on next restart",
+          surfacesOk,
+        );
+        for (const f of failed) {
+          console.log(
+            `      surfaces    FAIL ${f.personality}:${f.runtime} — ${f.outcomes
+              .filter((o) => o.action === "failed")
+              .map((o) => `${o.surface}: ${o.detail ?? "failed"}`)
+              .join("; ")}`,
+          );
+        }
+      }
+    }
+
+    // 8c. v1.1 → v1.2 migration: sweep the legacy session plugin off the
+    // fleet while the old declaration is STILL readable — and ONLY after
+    // the direct surfaces landed cleanly.
+    let migrationBlocked = false;
+    if (!flags.skipEcosystem && existingSlot?.plugin) {
+      if (!surfacesOk) {
+        migrationBlocked = true;
+        step(
+          "plugin-off",
+          "POSTPONED: direct surfaces did not land cleanly — legacy plugin and v1.1 slot kept (re-run init after fixing)",
+          false,
+        );
+      } else {
+        const off = applyMemoryPlugin({ mode: "off", iapeerBin: flags.iapeerBin });
+        step(
+          "plugin-off",
+          off.suppressed
+            ? "skipped (test sandbox — core calls suppressed)"
+            : off.ok
+              ? "legacy v1.1 session plugin swept off the fleet (memory-plugin off --all)"
+              : `legacy plugin off failed (${off.detail.slice(0, 120)}) — manual: iapeer memory-plugin off --all (or per peer: claude plugin uninstall iapeer-memory@agfpd --scope project)`,
+        );
+      }
+    }
+
+    // 8d. slot declaration (atomic; provider-owned). Kept in the v1.1 form
+    // while the migration is blocked — the legacy plugin channel stays
+    // derivable until the new channel lands.
+    if (migrationBlocked) {
+      step("slot", "kept v1.1 declaration (migration postponed — see plugin-off)", false);
+    } else {
+      const slot = writeSlot({
+        slotPath: paths.slotPath,
+        version,
+        binaryPath: paths.binaryPath,
+        heartbeat: paths.heartbeatPath,
+      });
+      step(
+        "slot",
+        `${paths.slotPath} (${slot.action}, v${version}, provision-command declared)`,
+        slot.action !== "refused-foreign",
+      );
+    }
   }
 
   // 9. native-memory sweep — the core's lever (one home of runtime forms);
@@ -448,7 +537,9 @@ export async function cmdInit(argv: string[]): Promise<number> {
   if (flags.skipGuide) {
     step("guide", "skipped (--skip-guide) — roll out by a separate decision after the fleet plugin swap");
   } else {
-    const guidePath = writeHostWideGuideFragment(iapeerDir, guideText(locale));
+    // vault substituted into the {{VAULT_PATH}} marker (дыра 10.06: the
+    // literal placeholder left peers without the write path).
+    const guidePath = writeHostWideGuideFragment(iapeerDir, guideText(locale, vault));
     step("guide", guidePath);
   }
 

package/src/commands/memoryd.ts

@@ -18,7 +18,7 @@
 
 import fs from "node:fs";
 import { configFromEnv, startMemoryd } from "@agfpd/iapeer-memory-core";
-import { memoryPaths } from "../paths.js";
+import { authorIndexPath, memoryPaths } from "../paths.js";
 
 export async function cmdMemoryd(argv: string[]): Promise<number> {
   let mcpPort: number | undefined;
@@ -72,6 +72,23 @@ export async function cmdMemoryd(argv: string[]): Promise<number> {
     humanName: human ?? process.env.IAPEER_MEMORY_HUMAN_NAME ?? null,
     freshEditWindowS,
     mcpPort: noMcp ? null : mcpPort,
+    // Per-peer fragment rendering (docs/05; дыра 10.06): the package owns
+    // the ecosystem joint — fleet-map path + paths-block facts; core
+    // renders at startup, on vault changes and on fleet-map changes.
+    fragments: {
+      fleetMapPath: paths.fleetMapPath,
+      paths: {
+        vault: config.vaultPath,
+        db: config.index.dbPath,
+        config: paths.configFile,
+        state: paths.stateDir,
+        cache: paths.cacheDir,
+        logs: paths.logsDir,
+      },
+      authorIndexPathFor: (agent) => authorIndexPath(paths, agent),
+      indexAgent: process.env.IAPEER_MEMORY_INDEX_AGENT || "index",
+      projectsRoot: process.env.IAPEER_MEMORY_PROJECTS_ROOT || undefined,
+    },
   });
 
   return await new Promise<number>((resolve) => {

package/src/commands/provision-peer.ts

@@ -0,0 +1,172 @@
+/**
+ * `iapeer-memory provision-peer|unprovision-peer --cwd <abs> --runtime <r>
+ * --personality <p> [--occasion <o>]` — the provider half of the iapeer
+ * v1.2 slot contract
+ * (ADR-009 v1.2: direct per-peer surfaces; the core shells into THIS command
+ * at peer birth/sweeps and never learns the surface forms).
+ *
+ * Contract obligations (§7, agreed with the iapeer core 10.06):
+ *   - argv form, absolute paths, no shell — the core spawns us directly;
+ *   - IDEMPOTENT: re-running repairs, never corrupts (every surface is a
+ *     read-merge-write of our own keys only, atomic);
+ *   - tolerant of PARALLEL calls — the host-wide provision lock serialises
+ *     bodies (lock.ts);
+ *   - {occasion} dictionary: birth | sweep-on | off-peer | off-all | remove.
+ *     We have NO host-global surfaces (требование Артура №3 «глобально не
+ *     класть» — even the codex MCP form is project-local), so the ref-count
+ *     distinction off-peer vs off-all is moot here: every occasion of the
+ *     un-verb means «strip this peer's surfaces». Validated, logged, not
+ *     branched on.
+ *
+ * Runtime forms: claude — hooks + mcp + skills (surfaces/claude.ts);
+ * codex — per-peer MCP via `<cwd>/.codex/config.toml` (surfaces/codex.ts;
+ * hooks/skills are the P5 experiment). Exit: 0 ok, 1 a surface failed,
+ * 2 usage.
+ */
+
+import fs from "node:fs";
+import { memoryPaths } from "../paths.js";
+import {
+  provisionClaudePeer,
+  unprovisionClaudePeer,
+  type SurfaceOutcome,
+} from "../surfaces/claude.js";
+import { provisionCodexPeer, unprovisionCodexPeer } from "../surfaces/codex.js";
+import { withProvisionLock } from "../surfaces/lock.js";
+
+/** The memoryd MCP port FACT of this host (config.env is already loaded into
+ *  the process env by the CLI boot) — baked literally into both MCP surface
+ *  forms (no env substitution in either, D2 decision). Shared by the verbs
+ *  here and the fleet sweeps in init/update/verify. Same resolution as
+ *  status.ts. */
+export function mcpPort(): number {
+  return Number(process.env.IAPEER_MEMORY_MCP_PORT || "") || 8766;
+}
+
+export const OCCASIONS = ["birth", "sweep-on", "off-peer", "off-all", "remove"] as const;
+export type Occasion = (typeof OCCASIONS)[number];
+
+const RUNTIMES = ["claude", "codex"] as const;
+
+type Flags = {
+  cwd: string;
+  runtime: (typeof RUNTIMES)[number];
+  occasion: Occasion;
+  personality: string;
+};
+
+function parseFlags(
+  verb: "provision-peer" | "unprovision-peer",
+  argv: string[],
+  defaultOccasion: Occasion,
+): Flags | null {
+  let cwd = "";
+  let runtime = "";
+  let occasion: string = defaultOccasion;
+  let personality = "";
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "--cwd": cwd = argv[++i] ?? ""; break;
+      case "--runtime": runtime = argv[++i] ?? ""; break;
+      case "--occasion": occasion = argv[++i] ?? ""; break;
+      case "--personality": personality = argv[++i] ?? ""; break;
+      default:
+        console.error(`iapeer-memory ${verb}: unknown flag: ${a}`);
+        return null;
+    }
+  }
+  if (!cwd || !cwd.startsWith("/")) {
+    console.error(`iapeer-memory ${verb}: --cwd must be an absolute path (got "${cwd}")`);
+    return null;
+  }
+  if (!(RUNTIMES as readonly string[]).includes(runtime)) {
+    console.error(`iapeer-memory ${verb}: --runtime must be one of ${RUNTIMES.join("|")} (got "${runtime}")`);
+    return null;
+  }
+  if (!(OCCASIONS as readonly string[]).includes(occasion)) {
+    console.error(`iapeer-memory ${verb}: --occasion must be one of ${OCCASIONS.join("|")} (got "${occasion}")`);
+    return null;
+  }
+  // claude provision bakes the LITERAL identity header (battle form of the
+  // core's own .mcp.json) — without the personality there is nothing honest
+  // to bake. The core's executor supports the {personality} placeholder
+  // (agreed 11.06); the package sweep reads it from fleet.json. The un-verb
+  // needs no identity: removal matches our key/marks, not the header value.
+  if (verb === "provision-peer" && runtime === "claude" && !personality) {
+    console.error(
+      "iapeer-memory provision-peer: --personality is required for --runtime claude " +
+        "(the literal MCP identity header is baked at provision time)",
+    );
+    return null;
+  }
+  return {
+    cwd,
+    runtime: runtime as Flags["runtime"],
+    occasion: occasion as Occasion,
+    personality,
+  };
+}
+
+function report(verb: string, flags: Flags, outcomes: SurfaceOutcome[]): number {
+  let failed = false;
+  for (const o of outcomes) {
+    if (o.action === "failed") failed = true;
+    console.log(
+      `${o.action === "failed" ? "FAIL" : "ok  "}  ${o.surface.padEnd(7)} ${o.action}${o.detail ? ` — ${o.detail}` : ""} (${o.path})`,
+    );
+  }
+  console.log(
+    `${verb}: ${flags.runtime} peer at ${flags.cwd} (occasion: ${flags.occasion})` +
+      (failed ? " — FAILED; re-run is the repair path (idempotent)" : "") +
+      "\npickup: surfaces apply on the peer's NEXT session start (live sessions do not re-read them)",
+  );
+  return failed ? 1 : 0;
+}
+
+export function cmdProvisionPeer(argv: string[]): number {
+  const flags = parseFlags("provision-peer", argv, "sweep-on");
+  if (!flags) return 2;
+  if (!fs.existsSync(flags.cwd)) {
+    console.error(`iapeer-memory provision-peer: cwd does not exist: ${flags.cwd}`);
+    return 1;
+  }
+  const paths = memoryPaths();
+  const locked = withProvisionLock({
+    stateDir: paths.stateDir,
+    fn: () =>
+      flags.runtime === "codex"
+        ? provisionCodexPeer({ cwd: flags.cwd, port: mcpPort() })
+        : provisionClaudePeer({
+            cwd: flags.cwd,
+            hooksDir: paths.hooksDir,
+            port: mcpPort(),
+            personality: flags.personality,
+          }),
+  });
+  if (!locked.acquired) {
+    console.error(`iapeer-memory provision-peer: ${locked.detail}`);
+    return 1;
+  }
+  return report("provision-peer", flags, locked.result);
+}
+
+export function cmdUnprovisionPeer(argv: string[]): number {
+  const flags = parseFlags("unprovision-peer", argv, "off-peer");
+  if (!flags) return 2;
+  // a vanished cwd is a VALID un-provision target (occasion=remove races the
+  // peer directory removal) — every surface simply reports `absent`
+  const paths = memoryPaths();
+  const locked = withProvisionLock({
+    stateDir: paths.stateDir,
+    fn: () =>
+      flags.runtime === "codex"
+        ? unprovisionCodexPeer({ cwd: flags.cwd })
+        : unprovisionClaudePeer({ cwd: flags.cwd }),
+  });
+  if (!locked.acquired) {
+    console.error(`iapeer-memory unprovision-peer: ${locked.detail}`);
+    return 1;
+  }
+  return report("unprovision-peer", flags, locked.result);
+}

package/src/commands/render.ts

@@ -166,7 +166,14 @@ function renderGuide(argv: string[]): number {
         "the whole fleet — the target is never implicit)",
     );
   }
-  const text = fs.readFileSync(source, "utf-8");
+  let text = fs.readFileSync(source, "utf-8");
+  // {{VAULT_PATH}} marker → host fact (дыра 10.06); unprovisioned env
+  // keeps the marker — an honest template passthrough, never a guess.
+  try {
+    text = text.replaceAll("{{VAULT_PATH}}", configFromEnv().vaultPath);
+  } catch {
+    // no config — leave the marker as is
+  }
   const written = writeHostWideGuideFragment(target, text);
   console.log(`render guide: ${written}`);
   return 0;

package/src/commands/uninstall.ts

@@ -3,11 +3,12 @@
  * host. SYMMETRY OBLIGATION of the memory-slot contract: the provider that
  * writes the slot declaration removes it.
  *
- * What it removes: slot declaration (own only — a foreign slot is refused),
- * the compiled binary. What it deliberately KEEPS: the vault (user data),
- * the package config (operator-owned), state/cache (cheap to rebuild, may
- * hold migrate backups!). What lands in P3c: notifier deregistration +
- * memoryd stop (the watcher owns the process lifecycle).
+ * What it removes: direct session surfaces across the fleet (ADR-009 v1.2 —
+ * own entries/keys/dirs only, swept BEFORE the declaration falls), the slot
+ * declaration (own only — a foreign slot is refused), notifier triggers,
+ * memoryd (verified-pid stop), the compiled binary. What it deliberately
+ * KEEPS: the vault (user data), the package config (operator-owned),
+ * state/cache (cheap to rebuild, may hold migrate backups!).
  *
  * Native auto-memory of the fleet is NOT restored (contract decision,
  * c968219): silent re-enabling would quietly resurrect split memory across
@@ -18,7 +19,10 @@
 import fs from "node:fs";
 import { memoryPaths } from "../paths.js";
 import { removeBinary } from "../binary.js";
+import { readFleetMap } from "../fleet.js";
 import { applyMemoryPlugin, readSlot, removeSlot, SLOT_PROVIDER } from "../slot.js";
+import { withProvisionLock } from "../surfaces/lock.js";
+import { sweepUnprovision } from "../surfaces/sweep.js";
 import {
   DREAM_TRIGGER_ID,
   SWEEP_TRIGGER_ID,
@@ -95,26 +99,59 @@ 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».
+  // Direct session surfaces OFF across the fleet BEFORE removing the
+  // declaration (ADR-009 v1.2 mirror symmetry: a dead provider's surfaces
+  // must not keep pointing at a void). Guard: only when the slot is OURS.
   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 fleet = readFleetMap(paths.fleetMapPath);
+    if (!fleet) {
+      console.log(
+        `surfaces  : fleet map missing/unreadable (${paths.fleetMapPath}) — nothing swept; ` +
+          "manual per peer: iapeer-memory unprovision-peer --cwd <cwd> --runtime <r>",
+      );
+    } else {
+      const locked = withProvisionLock({
+        stateDir: paths.stateDir,
+        fn: () => sweepUnprovision({ fleet }),
+      });
+      if (!locked.acquired) {
+        console.log(`surfaces  : ${locked.detail}`);
+        failed = true;
+      } else {
+        const { results, skipped } = locked.result;
+        const bad = results.filter((r) => !r.ok);
+        console.log(
+          `surfaces  : stripped from ${results.length - bad.length}/${results.length} peer-runtime(s)` +
+            (skipped.length ? ` (${skipped.length} skipped)` : ""),
+        );
+        for (const b of bad) {
+          failed = true;
+          console.log(
+            `surfaces  : FAIL ${b.personality}:${b.runtime} — ${b.outcomes
+              .filter((o) => o.action === "failed")
+              .map((o) => `${o.surface}: ${o.detail ?? "failed"}`)
+              .join("; ")}`,
+          );
+        }
+      }
+    }
+
+    // Legacy v1.1 path: the slot still carries a plugin block — sweep the
+    // session plugin off via the core verb WHILE the declaration is alive
+    // (it derives the identity from it; agreed order, auto-removal).
+    if (declared.plugin) {
+      const off = applyMemoryPlugin({ mode: "off", iapeerBin });
+      console.log(
+        `plugin    : ${
+          off.suppressed
+            ? "skipped (test sandbox — core calls suppressed)"
+            : off.ok
+              ? "legacy 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);