@agfpd/iapeer-memory 0.1.1 → 0.1.3

package/src/watcher.ts

@@ -4,10 +4,14 @@
  * registration.ts/peerProfileStore.ts + live run):
  *
  * - the REGISTRANT is the IAP envelope's from-personality:
- *   `iapeer send watcher --from index` puts the trigger into
+ *   `iapeer send watcher --from claude-index` puts the trigger into
  *   `<index-cwd>/.iapeer/peer-profile.json` → `notifier.triggers[]`,
  *   owner=index (writing into a foreign profile is impossible by
  *   invariant). We register from INDEX — the consumer of memoryd events.
+ *   `--from` takes the full IDENTITY `<runtime>-<personality>` (iapeer
+ *   cli fact, verified by e2e §A: bare "index" → exit 1 «invalid --from
+ *   identity»); the durable trigger's `owner` stays the parsed
+ *   PERSONALITY ("index") — readWatcherTrigger matching is unaffected.
  * - replies (✓ registered / teaching errors / list) go to the
  *   from-personality SESSION, never to this script — so registration
  *   success is verified by READING THE STATE, not the reply:
@@ -33,6 +37,17 @@ import fs from "node:fs";
 import path from "node:path";
 
 export const WATCHER_TRIGGER_ID = "iapeer-memory-memoryd";
+/** Fail-open sweep (инверсия, ADR-015): check-gated hourly timer → index. */
+export const SWEEP_TRIGGER_ID = "iapeer-memory-inbox-sweep";
+/** Weekly DreamWeaver tick (директива «всё КРОМЕ DREAM_TICK — копирайтеру»):
+ *  a notifier TIMER straight to the index — memoryd never emitted this event
+ *  (И1 fact), so the copywriter never sees it. */
+export const DREAM_TRIGGER_ID = "iapeer-memory-dream-tick";
+/** The inverted pipeline's first receiver of memoryd events (директива
+ *  Артура 10.06): the copywriter vets BEFORE placement and reports to the
+ *  index; same-id re-registration REPLACES the trigger (notifier contract),
+ *  so update/verify --repair re-target idempotently. */
+export const DEFAULT_EVENT_TARGET = "copywriter";
 
 /** The watcher runs one executable file — a launcher wrapping the stable binary. */
 export function launcherScriptContent(binaryPath: string): string {
@@ -46,21 +61,99 @@ export function launcherScriptContent(binaryPath: string): string {
   ].join("\n");
 }
 
+function writeExecutable(filePath: string, content: string): "written" | "identical" {
+  try {
+    if (fs.readFileSync(filePath, "utf-8") === content) return "identical";
+  } catch {
+    // absent — write
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, content, "utf-8");
+  fs.chmodSync(tmp, 0o755);
+  fs.renameSync(tmp, filePath);
+  return "written";
+}
+
 export function writeLauncherScript(opts: {
   launcherPath: string;
   binaryPath: string;
 }): "written" | "identical" {
-  const content = launcherScriptContent(opts.binaryPath);
+  return writeExecutable(opts.launcherPath, launcherScriptContent(opts.binaryPath));
+}
+
+/**
+ * Sweep check-script (fail-open, ADR-015): the notifier runs it before each
+ * sweep fire; exit 0 ⇔ stale drafts exist (the index is woken ONLY on a real
+ * backlog). Paths and the threshold are BAKED at generation — the notifier's
+ * env carries no IAPEER_MEMORY_* context. Covers BOTH inboxes: the human
+ * inbox has no memoryd emission yet (И1 fact) — the sweep is its bridge.
+ */
+export function staleCheckScriptContent(opts: {
+  vaultPath: string;
+  inboxFolders: string[];
+  staleSecs: number;
+}): string {
+  const dirs = opts.inboxFolders
+    .map((f) => `"${path.join(opts.vaultPath, f)}"`)
+    .join(" ");
+  return [
+    "#!/usr/bin/env bash",
+    "# iapeer-memory inbox-stale check — generated by init/update (package-owned).",
+    "# exit 0 = stale drafts exist (notifier fires the sweep), exit 1 = all clear.",
+    `T=${opts.staleSecs}`,
+    "now=$(date +%s)",
+    `for dir in ${dirs}; do`,
+    '  [ -d "$dir" ] || continue',
+    '  for f in "$dir"/*.md; do',
+    '    [ -e "$f" ] || continue',
+    '    m=$(stat -f %m "$f" 2>/dev/null || stat -c %Y "$f" 2>/dev/null) || continue',
+    '    [ $((now - m)) -ge "$T" ] && exit 0',
+    "  done",
+    "done",
+    "exit 1",
+    "",
+  ].join("\n");
+}
+
+export function writeStaleCheckScript(opts: {
+  checkScriptPath: string;
+  vaultPath: string;
+  inboxFolders: string[];
+  staleSecs?: number;
+}): "written" | "identical" {
+  return writeExecutable(
+    opts.checkScriptPath,
+    staleCheckScriptContent({
+      vaultPath: opts.vaultPath,
+      inboxFolders: opts.inboxFolders,
+      staleSecs: opts.staleSecs ?? 7200,
+    }),
+  );
+}
+
+/**
+ * Declare the copywriter an ephemeral worker (clean window per delivery,
+ * M1/M2/M3 — core canon «wake_policy ephemeral»). The profile is a CORE
+ * file: no-clobber merge of exactly one key, atomic write.
+ */
+export function patchWakePolicyEphemeral(
+  peerCwd: string,
+): "written" | "identical" | "missing-profile" {
+  const profilePath = path.join(peerCwd, ".iapeer", "peer-profile.json");
+  let profile: Record<string, unknown>;
   try {
-    if (fs.readFileSync(opts.launcherPath, "utf-8") === content) return "identical";
+    const raw = JSON.parse(fs.readFileSync(profilePath, "utf-8")) as unknown;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return "missing-profile";
+    profile = raw as Record<string, unknown>;
   } catch {
-    // absent — write
+    return "missing-profile";
   }
-  fs.mkdirSync(path.dirname(opts.launcherPath), { recursive: true });
-  const tmp = `${opts.launcherPath}.tmp`;
-  fs.writeFileSync(tmp, content, "utf-8");
-  fs.chmodSync(tmp, 0o755);
-  fs.renameSync(tmp, opts.launcherPath);
+  if (profile.wake_policy === "ephemeral") return "identical";
+  profile.wake_policy = "ephemeral";
+  const tmp = `${profilePath}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(profile, null, 2)}\n`, "utf-8");
+  fs.renameSync(tmp, profilePath);
   return "written";
 }
 
@@ -71,23 +164,96 @@ export function registrationMessage(opts: {
 }): string {
   return JSON.stringify({
     script: opts.script,
-    target: opts.target ?? "index",
+    target: opts.target ?? DEFAULT_EVENT_TARGET,
     id: opts.id ?? WATCHER_TRIGGER_ID,
   });
 }
 
-export type IapSendResult = { ok: boolean; detail: string };
+/** Sweep timer registration body (sent to the `timer` peer). The message is
+ *  self-contained — it lands in a FRESH index session. */
+export function sweepTimerMessage(opts: {
+  checkScriptPath: string;
+  every?: string;
+  target?: string;
+  id?: string;
+}): string {
+  return JSON.stringify({
+    when: opts.every ?? "@every 1h",
+    message:
+      "INBOX_SWEEP: stale drafts sit in the inbox folders — the copywriter " +
+      "thread did not process them in time. Place them per your doctrine, " +
+      "unvetted: needs_review: true on each; the copywriter re-vets via " +
+      "PERMANENT_CHANGED when alive.",
+    target: opts.target ?? "index",
+    check: opts.checkScriptPath,
+    id: opts.id ?? SWEEP_TRIGGER_ID,
+  });
+}
+
+/** Weekly DreamWeaver tick (Mondays 04:00 by default — the human sleeps). */
+export function dreamTimerMessage(opts?: {
+  cron?: string;
+  target?: string;
+  id?: string;
+}): string {
+  return JSON.stringify({
+    when: opts?.cron ?? "0 4 * * 1",
+    message:
+      "DREAM_TICK: weekly agent-memory consolidation. Fan out DreamWeaver " +
+      "over the agent-memory subfolders (including your own), strictly one " +
+      "folder per task, sequentially — per your doctrine.",
+    target: opts?.target ?? "index",
+    id: opts?.id ?? DREAM_TRIGGER_ID,
+  });
+}
+
+export type IapSendResult = {
+  ok: boolean;
+  detail: string;
+  /** True when the test-sandbox fuse blocked the send — callers report a
+   *  SKIP, not a failure (the iapeer `skipped-sandbox` precedent). */
+  suppressed?: boolean;
+};
+
+/** Default registrant personality (trigger owner + event target). */
+const DEFAULT_REGISTRANT = "index";
+/** Role peers are claude-runtime sessions (init creates them via `iapeer create`). */
+const DEFAULT_FROM_RUNTIME = "claude";
+
+/** `--from` wants the full identity `<runtime>-<personality>`, never a bare name. */
+export function fromIdentity(personality: string, runtime = DEFAULT_FROM_RUNTIME): string {
+  return `${runtime}-${personality}`;
+}
 
 function iapSend(opts: {
   message: string;
-  from: string;
+  fromIdentity: string;
+  /** Notifier peer to address: `watcher` (events) or `timer` (cron/sweep). */
+  to?: "watcher" | "timer";
   iapeerBin?: string;
 }): IapSendResult {
+  // Hard fuse (incident 10.06, prod Index): verify-repair tests reached the
+  // LIVE watcher peer and registered crashlooping temp-path triggers — /tmp
+  // tmux sockets are host-global, no sandbox env can contain a real send.
+  // Test scripts set this env (package.json), mirroring IAPEER_TEST_SANDBOX.
+  // BOTH vars honoured (belt and braces): a test helper once stripped all
+  // IAPEER_MEMORY_* env before spawning the CLI — the ecosystem-wide
+  // IAPEER_TEST_SANDBOX survives generic prefix-stripping.
+  if (
+    process.env.IAPEER_MEMORY_SUPPRESS_IAP_SEND === "1" ||
+    process.env.IAPEER_TEST_SANDBOX === "1"
+  ) {
+    return {
+      ok: false,
+      suppressed: true,
+      detail: "iap send suppressed (test sandbox)",
+    };
+  }
   const bin = opts.iapeerBin ?? "iapeer";
   let proc: ReturnType<typeof Bun.spawnSync>;
   try {
     proc = Bun.spawnSync(
-      [bin, "send", "watcher", "--from", opts.from, "--message", opts.message],
+      [bin, "send", opts.to ?? "watcher", "--from", opts.fromIdentity, "--message", opts.message],
       { stdout: "pipe", stderr: "pipe" },
     );
   } catch (err) {
@@ -108,55 +274,97 @@ function iapSend(opts: {
 
 export function registerWatcher(opts: {
   launcherPath: string;
-  from?: string;
+  /** Registrant PERSONALITY (owner of the durable trigger + default target). */
+  registrant?: string;
+  /** Runtime prefix of the registrant's identity (claude for role peers). */
+  runtime?: string;
   target?: string;
   id?: string;
   iapeerBin?: string;
 }): IapSendResult {
+  const registrant = opts.registrant ?? DEFAULT_REGISTRANT;
   return iapSend({
-    from: opts.from ?? "index",
+    fromIdentity: fromIdentity(registrant, opts.runtime),
     iapeerBin: opts.iapeerBin,
     message: registrationMessage({
       script: opts.launcherPath,
-      target: opts.target ?? opts.from ?? "index",
+      // No fallback to the registrant here: the EVENT target default
+      // (copywriter, inverted pipeline) lives in registrationMessage.
+      target: opts.target,
       id: opts.id,
     }),
   });
 }
 
 export function unregisterWatcher(opts: {
-  from?: string;
+  registrant?: string;
+  runtime?: string;
   id?: string;
   iapeerBin?: string;
 }): IapSendResult {
   return iapSend({
-    from: opts.from ?? "index",
+    fromIdentity: fromIdentity(opts.registrant ?? DEFAULT_REGISTRANT, opts.runtime),
     iapeerBin: opts.iapeerBin,
     message: JSON.stringify({ cmd: "unregister", id: opts.id ?? WATCHER_TRIGGER_ID }),
   });
 }
 
+/** Register a timer trigger (sweep/dream) — body built by *TimerMessage(). */
+export function registerTimer(opts: {
+  message: string;
+  registrant?: string;
+  runtime?: string;
+  iapeerBin?: string;
+}): IapSendResult {
+  return iapSend({
+    to: "timer",
+    fromIdentity: fromIdentity(opts.registrant ?? DEFAULT_REGISTRANT, opts.runtime),
+    iapeerBin: opts.iapeerBin,
+    message: opts.message,
+  });
+}
+
+export function unregisterTimer(opts: {
+  id: string;
+  registrant?: string;
+  runtime?: string;
+  iapeerBin?: string;
+}): IapSendResult {
+  return iapSend({
+    to: "timer",
+    fromIdentity: fromIdentity(opts.registrant ?? DEFAULT_REGISTRANT, opts.runtime),
+    iapeerBin: opts.iapeerBin,
+    message: JSON.stringify({ cmd: "unregister", id: opts.id }),
+  });
+}
+
 export type WatcherTrigger = {
+  /** Durable role token: "event" (watcher) | "time" (timer) — notifier fact. */
   role: string;
   id: string;
   owner: string;
   target?: string;
   script?: string;
+  /** Timer-only: the check-gate script path. */
+  check?: string;
   heartbeatSec?: number;
   topic?: string;
 };
 
 /**
- * Read the durable trigger from the registrant's peer profile — the
+ * Read a durable trigger from the registrant's peer profile — the
  * canonical storage contract (sanctioned). Never throws.
  */
 export function readWatcherTrigger(opts: {
   registrantCwd: string;
   id?: string;
   owner?: string;
+  /** "event" (default, watcher triggers) or "time" (timers). */
+  role?: "event" | "time";
 }): WatcherTrigger | null {
   const id = opts.id ?? WATCHER_TRIGGER_ID;
   const owner = opts.owner ?? "index";
+  const role = opts.role ?? "event";
   try {
     const profile = JSON.parse(
       fs.readFileSync(
@@ -166,7 +374,7 @@ export function readWatcherTrigger(opts: {
     ) as { notifier?: { triggers?: WatcherTrigger[] } };
     const triggers = profile.notifier?.triggers ?? [];
     return (
-      triggers.find((t) => t.role === "event" && t.id === id && t.owner === owner) ??
+      triggers.find((t) => t.role === role && t.id === id && t.owner === owner) ??
       null
     );
   } catch {