@agfpd/iapeer-memory-core 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory-core",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "iapeer-memory core — host-neutral TypeScript memory primitive: vault schema/taxonomy config, search engine, memoryd, context renderer, role contracts. Consumed by the @agfpd/iapeer-memory facade; version kept in lockstep by its release flow (docs/10-distribution.md).",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -58,6 +58,8 @@ export {
   MEMORYD_SERVER_NAME,
   type MemorydHandle,
   type MemorydOptions,
+  type MemorydFragmentsWiring,
+  type FleetPeer,
 } from "./memoryd.js";
 
 // auto-memory migration (engine; sources are adapter-scoped)

package/src/memoryd.ts

@@ -49,6 +49,15 @@ import {
   type VaultSnapshot,
 } from "./permanent-detect.js";
 import { makeLogger, type Logger } from "./log.js";
+import {
+  atomicWrite,
+  buildOutput,
+  collectNotes,
+  filterAgentNotes,
+  fullIndexPathFor,
+  type RenderContext,
+} from "./index-render.js";
+import { renderPeerFragment, type FragmentEnv } from "./context-render.js";
 
 // ── identity ────────────────────────────────────────────────────────────────
 
@@ -497,8 +506,37 @@ export type MemorydOptions = {
    * omit to use `config.mcp.port` (the configured default, ADR-012).
    */
   mcpPort?: number | null;
+  /** Continuous per-peer fragment rendering (docs/05: «триггер регенерации —
+   *  debounce от FS-изменений vault в memoryd»). Omit → rendering off
+   *  (host-neutral core: the ecosystem wiring comes from the package). */
+  fragments?: MemorydFragmentsWiring;
+};
+
+/**
+ * Fleet fragment wiring — assembled by the PACKAGE (ADR-009: ecosystem
+ * joints live there), consumed by core as plain data. The fleet map is a
+ * JSON state file (`{peers: [{personality, cwd}]}`) written by the package
+ * from `iapeer list --json` (init/update/verify --repair — the registry cwd
+ * is the FACT, iapeer 0.2.14); core only reads it, fail-open: missing or
+ * malformed map = rendering quietly off (дыра 10.06: контракт docs/05 был
+ * обещан шапкой render.ts и не подключён — пиры после рестарта не знали
+ * пути записи vault).
+ */
+export type MemorydFragmentsWiring = {
+  /** Fleet map JSON path (package state namespace). */
+  fleetMapPath: string;
+  /** paths-block facts for every fragment (vault/db/config/state/cache/logs). */
+  paths: FragmentEnv["paths"];
+  /** Author-index target (capped variant) for an agent; `-full` derived. */
+  authorIndexPathFor: (agent: string) => string;
+  /** Index curator personality (its branch adds the tags dictionary). */
+  indexAgent?: string;
+  /** ADR-014 projects root for `dir:` resolution. */
+  projectsRoot?: string;
 };
 
+export type FleetPeer = { personality: string; cwd: string };
+
 export type MemorydHandle = {
   mcpPort: number | null;
   /** Force one detect pass immediately (used by tests and shutdown flush). */
@@ -571,6 +609,94 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
    *  last_edited_by читается ИЗ ФАЙЛА на момент пачки — правки
    *  index/scriber/dreamweaver в пачку не попадают (эхо-брейкер механикой,
    *  не доктриной). */
+  // ── per-peer fragments (docs/05: свежесть за секунды от FS-изменений) ──
+  const fragments = opts.fragments ?? null;
+  let fleetCache: { mtimeMs: number; peers: FleetPeer[] } | null = null;
+
+  /** Fail-open fleet map reader with an mtime cache: missing/malformed file
+   *  → empty fleet (rendering quietly off), never throws. */
+  function readFleetMap(): FleetPeer[] {
+    if (!fragments) return [];
+    try {
+      const st = fs.statSync(fragments.fleetMapPath);
+      if (fleetCache && fleetCache.mtimeMs === st.mtimeMs) return fleetCache.peers;
+      const raw = JSON.parse(fs.readFileSync(fragments.fleetMapPath, "utf-8")) as {
+        peers?: Array<{ personality?: unknown; cwd?: unknown }>;
+      };
+      const peers: FleetPeer[] = (Array.isArray(raw?.peers) ? raw.peers : [])
+        .filter(
+          (p): p is { personality: string; cwd: string } =>
+            typeof p?.personality === "string" &&
+            p.personality.trim() !== "" &&
+            typeof p?.cwd === "string" &&
+            p.cwd.trim() !== "",
+        )
+        .map((p) => ({ personality: p.personality.trim(), cwd: p.cwd.trim() }));
+      fleetCache = { mtimeMs: st.mtimeMs, peers };
+      return peers;
+    } catch {
+      fleetCache = null;
+      return [];
+    }
+  }
+
+  /** One render pass over the whole fleet: collectNotes ONCE (the full
+   *  vault scan is the expensive part), then filter/build/write per peer.
+   *  Per-peer failures are isolated; a peer whose cwd is gone is skipped
+   *  (never scaffold directories for a removed peer). */
+  function renderFleetFragments(reason: string): void {
+    if (!fragments || !vaultAvailable()) return;
+    const peers = readFleetMap();
+    if (!peers.length) return;
+    const ctx: RenderContext = { taxonomy, ranking: config.ranking };
+    let collected: ReturnType<typeof collectNotes>;
+    try {
+      collected = collectNotes(config.vaultPath, ctx);
+    } catch (err) {
+      logger.warn(`fragments: vault collect failed (${String(err)}) — pass skipped`);
+      return;
+    }
+    const indexAgent = fragments.indexAgent ?? "index";
+    let rendered = 0;
+    for (const peer of peers) {
+      try {
+        if (!fs.existsSync(peer.cwd)) continue;
+        const mine = filterAgentNotes(collected.notes, collected.incomingCount, peer.personality, ctx);
+        const outFile = fragments.authorIndexPathFor(peer.personality);
+        fs.mkdirSync(path.dirname(outFile), { recursive: true }); // atomicWrite не создаёт родителя
+        const fullOut = fullIndexPathFor(outFile);
+        const [text] = buildOutput(mine, peer.personality, {
+          ctx,
+          projectsRoot: fragments.projectsRoot,
+          fullIndexPath: fullOut,
+        });
+        atomicWrite(outFile, text);
+        const [fullText] = buildOutput(mine, peer.personality, {
+          ctx,
+          projectsRoot: fragments.projectsRoot,
+          memoryCap: null,
+          canonCap: null,
+          projectHardCap: null,
+        });
+        atomicWrite(fullOut, fullText);
+        renderPeerFragment({
+          peerCwd: peer.cwd,
+          env: {
+            agent: peer.personality,
+            indexAgent,
+            paths: fragments.paths,
+            authorIndexPath: outFile,
+            tagsDictionaryPath: peer.personality === indexAgent ? tagsMirrorPath : undefined,
+          },
+        });
+        rendered++;
+      } catch (err) {
+        logger.warn(`fragments: ${peer.personality} render failed (${String(err)})`);
+      }
+    }
+    if (rendered) logger.info(`fragments: rendered ${rendered} peer fragment(s) (${reason})`);
+  }
+
   function lastEditedByOf(absPath: string): string | null {
     try {
       const head = fs.readFileSync(absPath, "utf-8").slice(0, 4096);
@@ -680,10 +806,26 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
     // over the WHOLE inbox folder; no dependency on fs.watch filenames).
     const inboxNext = snapshotInbox(config.vaultPath, taxonomy);
     for (const name of diffSnapshots(inboxSnapshot, inboxNext)) {
+      const abs = path.join(config.vaultPath, taxonomy.folders.inbox, name);
+      // Source-фильтр кураторов — ПАРИТЕТ с PERMANENT_BATCH (живое эхо
+      // 10.06: стилистическая правка Scriber'а ВО ВРЕМЯ вычитки породила
+      // повторный INBOX_NEW по тому же черновику — вычитывающая сессия и
+      // есть конвейер). Правки автора (reject→fix→re-review) проходят:
+      // last_edited_by остаётся автором. Цена документирована: черновик,
+      // чья ПОСЛЕДНЯЯ правка до первого анонса — кураторская, не
+      // анонсируется; в конвейере не возникает (кураторы трогают черновики
+      // только по событиям, т.е. после анонса). Baseline обновляется ниже
+      // безусловно — подавленное НЕ реплеится, авторская правка поверх
+      // кураторской диффится от свежего снапшота и проходит.
+      const leb = lastEditedByOf(abs);
+      if (leb && config.curatorSet.includes(leb)) {
+        logger.info(`inbox event suppressed (curator ${leb}): ${name}`);
+        continue;
+      }
       logger.info(`inbox event: ${name}`);
       // ABSOLUTE path (B-приёмка 10.06): a consumer must never guess the
       // vault root — a role peer once `find`-guessed a stale copy.
-      emit(`INBOX_NEW: ${path.join(config.vaultPath, taxonomy.folders.inbox, name)}`);
+      emit(`INBOX_NEW: ${abs}`);
     }
     if (inboxNext.size > 0 || inboxSnapshot.size === 0) {
       inboxSnapshot = inboxNext;
@@ -693,6 +835,7 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
     humanEditPass(changed);
     syncTagsMirror();
     await indexAll({ db, config, logger }); // incremental by content hash
+    renderFleetFragments("vault-change"); // docs/05: свежесть за секунды
     // PERMANENT правки НЕ эмитятся мгновенно — копятся до batch-прохода
     // (каденция 6h); см. runPermanentBatch.
   }
@@ -768,9 +911,27 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
     }
   }
   touchHeartbeat();
-  const heartbeatTimer = setInterval(touchHeartbeat, heartbeatMs);
+  const heartbeatTimer = setInterval(() => {
+    touchHeartbeat();
+    // Fleet-map change without a vault change (a new peer landed in the
+    // registry, the package re-wrote the map) → render the newcomers on
+    // the next tick; the mtime cache makes the no-change case a stat().
+    if (fragments) {
+      try {
+        const st = fs.statSync(fragments.fleetMapPath);
+        if (st.mtimeMs !== fleetCache?.mtimeMs) renderFleetFragments("fleet-map-change");
+      } catch {
+        // no map — rendering stays off (fail-open)
+      }
+    }
+  }, heartbeatMs);
   heartbeatTimer.unref?.();
 
+  // Cold-start coverage (дыра 10.06): render the WHOLE fleet at startup —
+  // a memoryd restart after install/update populates every peer's fragment
+  // before the fleet's own restarts pick them up.
+  renderFleetFragments("startup");
+
   // Periodic atomic persist of the detect baseline (only when changed —
   // no churn); a non-graceful exit loses at most one interval.
   let lastPersistedJson: string | null = null;