@agfpd/iapeer-memory 0.2.7 → 0.2.9

package/src/commands/hook.ts

@@ -39,6 +39,13 @@ import {
   getTaxonomy,
   isLocaleId,
   resolveAgentName,
+  resolveZone,
+  splitFrontmatter,
+  parseNoteTags,
+  parseDictionaryTags,
+  tagGateProblems,
+  tagsDictionarySourceRel,
+  type TaxonomyPreset,
 } from "@agfpd/iapeer-memory-core";
 import { memoryPaths, type MemoryPaths } from "../paths.js";
 import { DEFAULT_HEARTBEAT_STALE_MS } from "./verify.js";
@@ -113,15 +120,6 @@ export type PostWriteResult = {
   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,
@@ -182,26 +180,194 @@ export function runPostWrite(
     stamp: true,
   });
 
-  // Reminder: ONLY on a claude Write (new note) in the author's OWN memory
-  // folder — an Edit-loop must not spam the context (reference semantics).
-  // The codex branch NEVER emits: hookSpecificOutput.additionalContext is a
-  // claude protocol — codex support is unverified (upstream issue #19385
-  // ASKS for it, which reads as «not there»; fact-checked stance, not a gap).
-  const ownMemoryDir =
-    path.join(vault, taxonomy.folders.agentMemory, agent) + path.sep;
-  const output =
-    tool === "Write" && files[0]!.startsWith(ownMemoryDir)
-      ? JSON.stringify({
-          hookSpecificOutput: {
-            hookEventName: "PostToolUse",
-            additionalContext: reminderText(taxonomy.folders.inbox),
-          },
-        })
-      : null;
-
+  // TAG GATE (lean §3): validate the canon note's tags against the dictionary
+  // and teach the author to fix any problem (unknown tag / no tag). The guard
+  // stays SILENT on a clean write (§2.3) — output is non-null ONLY on a
+  // problem. RUNTIME-AGNOSTIC: codex supports PostToolUse `additionalContext`
+  // too (official codex hooks docs — the earlier «claude-only» was wrong), so
+  // the SAME schema reaches both runtimes. `files` already covers claude
+  // Write/Edit and codex apply_patch (multi-file).
+  const problems = collectTagProblems(files, vault, taxonomy);
+  const output = problems.length
+    ? JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: tagTeaching(problems),
+        },
+      })
+    : null;
   return { stamped: true, output };
 }
 
+/**
+ * Tag-gate problems across the just-written CANON files (lean §3). Reads the
+ * dictionary from the vault; FAIL-OPEN — an unreadable/empty dictionary (e.g.
+ * an evicted iCloud placeholder) yields no problems rather than rejecting
+ * every tag. Operative/inbox zones are not gated (canon only).
+ */
+export function collectTagProblems(
+  files: string[],
+  vault: string,
+  taxonomy: TaxonomyPreset,
+): string[] {
+  const dictRel = tagsDictionarySourceRel(taxonomy);
+  let allow: Set<string> | null = null;
+  try {
+    const dict = fs.readFileSync(path.join(vault, dictRel), "utf-8");
+    if (dict.trim()) allow = new Set(parseDictionaryTags(dict));
+  } catch {
+    // fail-open
+  }
+  if (!allow) return [];
+  const out: string[] = [];
+  for (const f of files) {
+    if (resolveZone(f, vault, taxonomy) !== "permanent") continue;
+    let fm: string;
+    try {
+      fm = splitFrontmatter(fs.readFileSync(f, "utf-8"))[0];
+    } catch {
+      continue;
+    }
+    const problems = tagGateProblems(parseNoteTags(fm), allow, {
+      requireAtLeastOne: true,
+      dictionaryRel: dictRel,
+    });
+    for (const p of problems) out.push(`${path.basename(f)}: ${p}`);
+  }
+  return out;
+}
+
+export function tagTeaching(problems: string[]): string {
+  return (
+    "[iapeer-memory] tag check — fix so this canon note indexes cleanly:\n" +
+    problems.map((p) => `- ${p}`).join("\n")
+  );
+}
+
+// ── dedup hint (lean §3a) ──────────────────────────────────────────────────────
+
+/** Short fail-open budget for the dedup RPC — a slow/down memoryd must never
+ *  hang a write-hook (same posture as the embedding circuit-breaker). */
+export const DEDUP_TIMEOUT_MS = 1500;
+
+type DedupResponse = {
+  enabled: boolean;
+  matches: Array<{ path: string; title: string; similarity: number }>;
+};
+
+/** POST the note body to memoryd's loopback /dedup RPC through the egress hub
+ *  (loopback allowance — П6 topology). Fail-open: any error (timeout,
+ *  connection refused, bad JSON) → null → the caller stays silent. */
+async function dedupFetch(
+  egress: Egress,
+  env: Record<string, string | undefined>,
+  content: string,
+): Promise<DedupResponse | null> {
+  const port = env.IAPEER_MEMORY_MCP_PORT || "8766";
+  const thr = env.IAPEER_MEMORY_DEDUP_THRESHOLD;
+  const body: { content: string; threshold?: number } = { content };
+  if (thr && !Number.isNaN(Number(thr))) body.threshold = Number(thr);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEDUP_TIMEOUT_MS);
+  try {
+    const res = await egress.fetch(`http://127.0.0.1:${port}/dedup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!res.ok) return null;
+    return (await res.json()) as DedupResponse;
+  } catch {
+    return null; // fail-open
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Dedup hint lines for a just-written CANON note (lean §3a). Re-parses the
+ * event independently of `runPostWrite` (keeps that sync contract intact).
+ * Claude-only (Write/Edit → additionalContext); canon-zone only; queries
+ * memoryd by the note BODY. Embeddings-off → memoryd returns enabled:false →
+ * no hint (silent).
+ */
+export async function collectDedupHints(
+  eventJson: string,
+  egress: Egress,
+  env: Record<string, string | undefined> = process.env,
+): Promise<string[]> {
+  let event: {
+    tool_name?: string;
+    cwd?: string;
+    tool_input?: { file_path?: string };
+    tool_response?: unknown;
+  };
+  try {
+    event = JSON.parse(eventJson) as typeof event;
+  } catch {
+    return [];
+  }
+  const tool = event.tool_name ?? "";
+  if (!POST_WRITE_TOOLS.has(tool)) return [];
+  const vault = env.IAPEER_MEMORY_VAULT_PATH ?? "";
+  if (!vault) return [];
+  const localeRaw = env.IAPEER_MEMORY_LOCALE || "en";
+  if (!isLocaleId(localeRaw)) return [];
+  const taxonomy = getTaxonomy(localeRaw);
+  // Candidate files: claude Write/Edit carry one file_path; codex apply_patch
+  // carries a patch over possibly many (RUNTIME-AGNOSTIC — codex receives the
+  // additionalContext hint via the same channel).
+  const candidates =
+    tool === "apply_patch" ? applyPatchPaths(event) : [event.tool_input?.file_path ?? ""];
+  const vaultPrefix = vault.endsWith(path.sep) ? vault : vault + path.sep;
+  const files = candidates.filter(
+    (p) => p.endsWith(".md") && p.startsWith(vaultPrefix) && fs.existsSync(p),
+  );
+  const hints: string[] = [];
+  for (const file of files) {
+    if (resolveZone(file, vault, taxonomy) !== "permanent") continue; // canon only (§3a)
+    let body: string;
+    try {
+      body = splitFrontmatter(fs.readFileSync(file, "utf-8"))[1];
+    } catch {
+      continue;
+    }
+    if (!body.trim()) continue;
+    const result = await dedupFetch(egress, env, body);
+    if (!result?.enabled || !result.matches?.length) continue;
+    for (const m of result.matches) {
+      if (path.basename(m.path) === path.basename(file)) continue; // self-guard (belt + braces)
+      hints.push(`[[${m.title}]] (${Math.round(m.similarity * 100)}%)`);
+    }
+  }
+  return hints;
+}
+
+/** Combine the sync tag-teaching output with async dedup hints into one
+ *  additionalContext blob (or null when both are empty). */
+export function mergeHookOutput(tagOutput: string | null, dedupHints: string[]): string | null {
+  let ctx = "";
+  if (tagOutput) {
+    try {
+      ctx = (JSON.parse(tagOutput).hookSpecificOutput?.additionalContext as string) ?? "";
+    } catch {
+      ctx = "";
+    }
+  }
+  if (dedupHints.length) {
+    const dedupText =
+      "[iapeer-memory] possible duplicate(s) of this canon note — verify, then extend " +
+      "the existing note or keep only new material:\n" +
+      dedupHints.map((h) => `- ${h}`).join("\n");
+    ctx = ctx ? `${ctx}\n\n${dedupText}` : dedupText;
+  }
+  if (!ctx) return null;
+  return JSON.stringify({
+    hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: ctx },
+  });
+}
+
 // ── session-start ────────────────────────────────────────────────────────────
 
 export type SessionStartResult = {
@@ -298,8 +464,11 @@ export async function cmdHook(argv: string[], egress: Egress): Promise<number> {
   try {
     switch (event) {
       case "post-write": {
-        const result = runPostWrite(await Bun.stdin.text());
-        if (result.output) console.log(result.output);
+        const text = await Bun.stdin.text();
+        const result = runPostWrite(text); // sync: stamp + tag gate
+        const dedupHints = await collectDedupHints(text, egress); // async, fail-open §3a
+        const output = mergeHookOutput(result.output, dedupHints);
+        if (output) console.log(output);
         return 0;
       }
       case "session-start": {

package/src/commands/init.ts

@@ -51,11 +51,13 @@ import {
 } from "../templates/index.js";
 import { packageVersion } from "../version.js";
 import {
+  DREAM_TARGET,
   dreamTimerMessage,
   patchWakePolicyEphemeral,
   registerTimer,
   registerWatcher,
   sweepTimerMessage,
+  writeDreamGateScript,
   writeLauncherScript,
   writeStaleCheckScript,
 } from "../watcher.js";
@@ -402,8 +404,15 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
       message: sweepTimerMessage({ checkScriptPath: paths.checkScriptPath }),
       iapeerBin: flags.iapeerBin,
     });
+    writeDreamGateScript({
+      dreamGateScriptPath: paths.dreamGateScriptPath,
+      binaryPath: paths.binaryPath,
+    });
     const dream = registerTimer(egress, {
-      message: dreamTimerMessage(),
+      message: dreamTimerMessage({
+        cron: process.env.IAPEER_MEMORY_DREAM_CRON,
+        dreamGateScriptPath: paths.dreamGateScriptPath,
+      }),
       iapeerBin: flags.iapeerBin,
     });
     const timersSandboxed = sweep.suppressed && dream.suppressed;
@@ -412,7 +421,7 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
       timersSandboxed
         ? "skipped (test sandbox — sends suppressed)"
         : sweep.ok && dream.ok
-          ? `sweep (@every 1h, check ${paths.checkScriptPath}) + dream-tick (weekly) → target index`
+          ? `sweep (@every 1h, check ${paths.checkScriptPath}) + dream-tick (weekly, gated, → ${DREAM_TARGET})`
           : `sweep: ${sweep.ok ? "sent" : sweep.detail}; dream: ${dream.ok ? "sent" : dream.detail}`,
       Boolean(timersSandboxed) || (sweep.ok && dream.ok),
     );

package/src/commands/render.ts

@@ -125,7 +125,10 @@ function renderFragment(argv: string[]): number {
       logs: paths.logsDir,
     },
     authorIndexPath: indexFile,
-    tagsDictionaryPath: agent === indexAgent ? paths.tagsMirrorPath : undefined,
+    // lean §3: the compact projection goes to EVERY peer (memoryd renders the
+    // projection file; a missing file is skipped gracefully by buildLayers).
+    tagsProjectionPath: paths.tagsProjectionPath,
+    tagsTitle: config.taxonomy.systemFiles.tagsDictionary,
   };
   const written = renderPeerFragment({ peerCwd, env });
   console.log(`render fragment: ${written}`);

package/src/commands/update.ts

@@ -51,10 +51,12 @@ import { mcpPort } from "./provision-peer.js";
 import { guideText, materialiseTemplates } from "../templates/index.js";
 import { packageVersion } from "../version.js";
 import {
+  DREAM_TARGET,
   dreamTimerMessage,
   registerTimer,
   registerWatcher,
   sweepTimerMessage,
+  writeDreamGateScript,
   writeLauncherScript,
   writeStaleCheckScript,
 } from "../watcher.js";
@@ -245,18 +247,27 @@ export function cmdUpdate(argv: string[], egress: Egress): number {
     } catch {
       // unprovisioned env — registrations below still re-target
     }
+    writeDreamGateScript({
+      dreamGateScriptPath: paths.dreamGateScriptPath,
+      binaryPath: paths.binaryPath,
+    });
     const w = registerWatcher(egress, { launcherPath: paths.launcherPath });
     const s = registerTimer(egress, {
       message: sweepTimerMessage({ checkScriptPath: paths.checkScriptPath }),
     });
-    const d = registerTimer(egress, { message: dreamTimerMessage() });
+    const d = registerTimer(egress, {
+      message: dreamTimerMessage({
+        cron: process.env.IAPEER_MEMORY_DREAM_CRON,
+        dreamGateScriptPath: paths.dreamGateScriptPath,
+      }),
+    });
     const sandboxed = w.suppressed && s.suppressed && d.suppressed;
     step(
       "triggers",
       sandboxed
         ? "skipped (test sandbox — sends suppressed)"
         : w.ok && s.ok && d.ok
-          ? `re-sent: event→scriber, sweep+dream→index (same id = replace); confirm: verify`
+          ? `re-sent: event→scriber, sweep→index, dream→${DREAM_TARGET} (gated; same id = replace); confirm: verify`
           : `event: ${w.ok ? "sent" : w.detail}; sweep: ${s.ok ? "sent" : s.detail}; dream: ${d.ok ? "sent" : d.detail}`,
       Boolean(sandboxed) || (w.ok && s.ok && d.ok),
     );

package/src/commands/verify.ts

@@ -35,6 +35,7 @@ import { checkFleetSurfaces, sweepProvision } from "../surfaces/sweep.js";
 import { mcpPort } from "./provision-peer.js";
 import { packageVersion } from "../version.js";
 import {
+  DREAM_TARGET,
   dreamTimerMessage,
   DEFAULT_EVENT_TARGET,
   DREAM_TRIGGER_ID,
@@ -43,6 +44,7 @@ import {
   registerWatcher,
   sweepTimerMessage,
   SWEEP_TRIGGER_ID,
+  writeDreamGateScript,
   writeLauncherScript,
   writeStaleCheckScript,
   WATCHER_TRIGGER_ID,
@@ -385,9 +387,24 @@ export function runVerify(egress: Egress, opts: VerifyOptions = {}): CheckResult
           id: DREAM_TRIGGER_ID,
           role: "time",
           expect: (t) =>
-            t.target !== "index" ? `target is ${t.target ?? "?"}, expected index` : null,
-          repairSend: () =>
-            registerTimer(egress, { message: dreamTimerMessage(), iapeerBin: opts.iapeerBin }),
+            t.target !== DREAM_TARGET
+              ? `target is ${t.target ?? "?"}, expected ${DREAM_TARGET}`
+              : (t as { check?: string }).check !== paths.dreamGateScriptPath
+                ? `check is ${(t as { check?: string }).check ?? "?"}, expected ${paths.dreamGateScriptPath}`
+                : null,
+          repairSend: () => {
+            writeDreamGateScript({
+              dreamGateScriptPath: paths.dreamGateScriptPath,
+              binaryPath: paths.binaryPath,
+            });
+            return registerTimer(egress, {
+              message: dreamTimerMessage({
+                cron: process.env.IAPEER_MEMORY_DREAM_CRON,
+                dreamGateScriptPath: paths.dreamGateScriptPath,
+              }),
+              iapeerBin: opts.iapeerBin,
+            });
+          },
         },
       ];
       for (const c of checks) {

package/src/fleet.ts

@@ -80,7 +80,7 @@ export function readFleetMap(fleetMapPath: string): FleetPeer[] | null {
 }
 
 /** Live-registry query — the ONE place `iapeer list --json` is parsed.
- *  Shared by writeFleetMap (the persisted map) and dream-paths (the
+ *  Shared by writeFleetMap (the persisted map) and dream-collect (the
  *  tick-time resolution; freshness fact: birth does NOT touch fleet.json
  *  and the SessionStart kick is heartbeat-gated, so the LIVE registry is
  *  the only source that sees a newborn before the next update). */

package/src/paths.ts

@@ -32,6 +32,8 @@ export type MemoryPaths = {
   heartbeatPath: string;
   hashStatePath: string;
   tagsMirrorPath: string;
+  /** Compact tags-dictionary projection, injected to all peers (lean §3). */
+  tagsProjectionPath: string;
   /** Roles manifest (written by init, read by verify/render): role → peerCwd/template. */
   rolesManifestPath: string;
   /** Rendered author indexes (`<agent>-vault-index.md` + `-full` variant). */
@@ -56,6 +58,9 @@ export type MemoryPaths = {
   launcherPath: string;
   /** Sweep check-script — gates the fail-open inbox sweep (ADR-015). */
   checkScriptPath: string;
+  /** Dream-tick gate check-script — the notifier `check` for the weekly timer
+   *  (shells the registry-free `dream-collect --gate`; a dead week wakes no one). */
+  dreamGateScriptPath: string;
   /** Fleet map (personality → cwd) — written by init/update/verify --repair
    *  from `iapeer list --json`, consumed by memoryd's fragment renderer
    *  (docs/05; дыра 10.06: без карты пиры не получали paths-блок и индекс). */
@@ -89,6 +94,7 @@ export function memoryPaths(
     heartbeatPath: path.join(stateDir, "memoryd.heartbeat"),
     hashStatePath: path.join(stateDir, "memoryd.hashes.json"),
     tagsMirrorPath: path.join(cacheDir, "tags-dictionary.md"),
+    tagsProjectionPath: path.join(cacheDir, "tags-projection.md"),
     rolesManifestPath: path.join(stateDir, "roles.json"),
     indexesDir: path.join(stateDir, "indexes"),
     pidPath: path.join(stateDir, "memoryd.pid"),
@@ -99,6 +105,7 @@ export function memoryPaths(
     hooksDir: path.join(path.dirname(configFile), "hooks"),
     launcherPath: path.join(path.dirname(configFile), "memoryd-launcher.sh"),
     checkScriptPath: path.join(path.dirname(configFile), "inbox-stale-check.sh"),
+    dreamGateScriptPath: path.join(path.dirname(configFile), "dream-tick-gate.sh"),
     fleetMapPath: path.join(stateDir, "fleet.json"),
   };
 }

package/src/provision.ts

@@ -176,6 +176,29 @@ export function defaultConfigContent(opts: ConfigContentOptions): string {
     "# Curator personalities exempt from needs_review stamping (ADR-006).",
     "# IAPEER_MEMORY_CURATOR_SET=index,scriber,dreamweaver",
     "",
+    "# Lean §3: per-tag boundary budget in the injected dictionary projection",
+    "# (×whole fleet — keep tight). Boundary text over this many chars is clipped.",
+    "# IAPEER_MEMORY_TAGS_BOUNDARY_MAXLEN=160",
+    "",
+    "# Lean §3a: dedup hint on canon writes — raw cosine similarity threshold",
+    "# above which an existing canon note is surfaced as a possible duplicate.",
+    "# Needs embeddings (semantic); with embeddings off the hint is silent.",
+    "# IAPEER_MEMORY_DEDUP_THRESHOLD=0.82",
+    "",
+    "# Weekly dream-tick (deterministic pre-filter → DreamWeaver). Schedule is",
+    "# 5-field cron; the window is days BY TIME (not since-last-tick).",
+    "# IAPEER_MEMORY_DREAM_CRON=0 4 * * 1",
+    "# IAPEER_MEMORY_DREAM_WINDOW_DAYS=7",
+    "# description longer than this many chars → a reformulation candidate.",
+    "# IAPEER_MEMORY_DREAM_DESC_MAXLEN=250",
+    "# >threshold new notes in a folder → its own subagent; smaller folders are",
+    "# grouped up to the cap (sum of per-folder weights).",
+    "# IAPEER_MEMORY_DREAM_BATCH_THRESHOLD=20",
+    "# IAPEER_MEMORY_DREAM_GROUP_CAP=20",
+    "# Per-folder cap on transcripts handed to phase D (most recent N by mtime;",
+    "# bounds an ephemeral worker's hundreds of sessions). 0 = uncapped.",
+    "# IAPEER_MEMORY_DREAM_TRANSCRIPT_CAP=20",
+    "",
   ].join("\n");
 }
 

package/src/templates/roles-en.ts

@@ -51,17 +51,12 @@ different world.
   scriber thread stalled: place the stale drafts UNVETTED by the usual
   rules; \`needs_review: true\` already travels with each file. The
   Scriber re-vets them with the next PERMANENT_BATCH once alive.
-- **DREAM_TICK** (notifier timer, weekly) — run \`iapeer-memory
-  dream-paths\` (read-only; the LIVE registry at tick time) and fan out
-  DreamWeaver over the folders of its output (including your own),
-  strictly one folder per task, sequentially. DreamWeaver takes tasks ONLY
-  from you (the one exception: a folder's owner may task it on their own
-  folder). Task: \`{agent, path, mode, transcripts_window_days,
-  transcripts}\` — copy \`transcripts\` from the verb's output AS IS
-  (globs + the codex cwdFilter; path forms are the code's zone, not
-  yours). A verb error = report to the owner, never guess the fleet. On
-  the consolidation report: archive what it deprecated, act on its
-  \`attention\` blocks yourself.
+- **DreamWeaver consolidation report** (weekly) — DreamWeaver now
+  orchestrates the tick (a deterministic pre-filter finds the work, it
+  fans out subagents); you are OFF the entry and only FINALISE. On its
+  report: archive each note it deprecated (move to the archive subfolder),
+  build the links section for each new merged note via vault_search, and
+  act on its \`attention\` items yourself.
 - **Direct IAP** from agents or the human — structure questions; never
   run searches for others (they have their own vault tools).
 
@@ -114,8 +109,8 @@ it under the usual three conditions.
 Never write note content (authors own it); never answer other agents'
 search requests; never dispatch the Scriber (events reach it directly —
 it reports to you); never detect events yourself (memoryd detects, the
-notifier delivers); never let DreamWeaver take tasks from anyone but you
-(save the owner-on-own-folder exception).
+notifier delivers); never orchestrate the dream-tick (DreamWeaver owns it
+end to end now — you only finalise on its report).
 `;
 
 export const SCRIBER_DOCTRINE_EN = `---
@@ -233,47 +228,78 @@ locale: en
 ---
 # DreamWeaver — sleep-cycle memory consolidation
 
-You are DreamWeaver: an ephemeral worker peer, the weekly hygiene
-instrument for agent memory. Vault root on this host: \`{{VAULT_PATH}}\`
-(never guess it). Tasks arrive as IAP messages: weekly fan-out
-from the Index (one task per subfolder, including the Index's own), or
-on-demand from a folder's OWNER for their own folder only. One task = one
-clean window = ONE outbound message (the final consolidation report to the
-task sender). Discipline: touch ONLY the folder named in the task.
-
-Task: \`{agent, path, mode, transcripts_window_days, transcripts}\`.
-
-## The four phases
-
-- **A — Dedup.** Read the folder's notes; group the ones about one topic
-  (LLM judgement). For each group of 2+: write ONE merging note (meaningful
-  filename in the vault language, \`subtype\` + \`description\` + body with
-  inline \`[[old note A]]\`, \`[[old note B]]\` mentions) and flip each old
-  note's \`status\` to the outdated token.
-- **B — Compress descriptions.** \`description\` longer than ~250 chars →
-  tighten to 1–2 sentences (~150 chars). Never touch the body in this
-  phase.
-- **C — Local fact verification.** Find file paths and env-variable
-  mentions in bodies; read the targets; on a clear mismatch (file gone,
-  function renamed) write an updated note and flip the old one to the
-  outdated token. LOCAL checks only.
-- **D — Transcript scan.** Read the session transcripts for the window
-  (\`transcripts_window_days\`) per the task's \`transcripts\`: each entry
-  is a glob; for \`runtime: codex\` the store is HOST-WIDE — take ONLY the
-  sessions whose \`session_meta.cwd\` equals the entry's \`cwdFilter\`
-  (foreign cwds are foreign memory). No entries / empty glob → skip the
-  phase. Find user phrases that formulate a rule with 2+ explicit
-  confirmations in different sessions; check against existing feedback
-  notes; write new notes with quotes for what's missing.
-
-## Hard limits
-
-- No hard deletes — only the outdated status token; archiving and links
-  are the Index's pass (it acts on your report), not yours.
-- Never touch canon folders; no vault MCP tools; no web fact-checking
-  (that's the distill skill's domain, not yours).
-- Your edits are stamped \`last_edited_by: dreamweaver\`; the \`author\`
-  constant is parsed from the subfolder path, so writing into a foreign
-  subfolder ON TASK keeps the owner's attribution intact — that is by
-  design.
+You are DreamWeaver: an ephemeral worker peer that ORCHESTRATES the weekly
+agent-memory hygiene tick. Vault root on this host: \`{{VAULT_PATH}}\`
+(never guess it — a stale copy elsewhere on disk is a different world). A
+deterministic pre-filter has already found the work; you turn its output
+into subagent tasks, then report once. The notifier delivers DREAM_TICK to
+you, weekly, only on a week that has work (a gate skips dead weeks) —
+nobody else tasks you.
+
+## Running the tick
+
+1. Run \`iapeer-memory dream-collect\` (Bash, read-only). It returns JSON:
+   \`{vault, windowDays, tasks[], skipped[]}\`. Each task is
+   \`{kind, folders[]}\`; each folder carries \`{agent, path,
+   newNotes:[{path, flags}], transcripts:[{runtime, files}]}\`. A
+   \`folder\` task is one busy folder for one subagent; a \`grouped\` task
+   is several small folders for one subagent. The pre-filter already
+   dropped inactive folders, so you spawn ONLY where there is real work.
+2. A verb error line = report it to the human owner and stop; never guess
+   the fleet. Empty \`tasks\` = a clean week — finish with \`iapeer
+   self-done\` (the non-waking finish), no report.
+3. Fan out one subagent per task, using your runtime's own subagent
+   mechanism (whatever it is called there). Run tasks concurrently when
+   your runtime allows, otherwise in sequence.
+4. Collect the subagents' results into ONE consolidation report to the
+   Index: the notes they deprecated (for archival), the new merged notes
+   (for linking), and any attention items. The Index finalises — archival
+   and the links section are its pass, not yours.
+
+Your window is one clean cycle = ONE outbound message (the report to the
+Index, or \`self-done\` on an empty week).
+
+## The subagent's task
+
+Each subagent sees ONLY the task you write — make it self-sufficient. Copy,
+verbatim from the verb's output, the folder path(s), the \`newNotes\` with
+their flags, the \`transcripts\` files, and the vault root. State the
+objective, the four judgement phases, the boundaries, and the report shape
+below. The subagent JUDGES the supplied material; it never re-discovers
+(the script already did the finding, so a subagent that re-scans the folder
+wastes the whole point).
+
+- **A — Dedup.** Group the supplied \`newNotes\` that cover one topic. Read
+  sibling notes in the folder for CONTEXT — including ones outside the
+  window — so a fresh note merges with an older twin; edit ONLY in-window
+  notes (the rest are already settled). For each group of 2+: write one
+  merging note (meaningful filename in the vault language, \`subtype\` +
+  \`description\` + body with inline \`[[old note]]\` mentions) and flip
+  each merged note's \`status\` to the outdated token.
+- **B — Compress descriptions.** For a note flagged \`long-desc\`: tighten
+  \`description\` to 1–2 sentences (~150 chars), leaving the body untouched.
+- **C — Verify flagged references.** For a note flagged \`broken-ref\`: the
+  script already located the suspect path/env mention — read the target,
+  and on a clear mismatch (file gone, var unset, function renamed) write an
+  updated note and flip the old one to outdated. Local checks only.
+- **D — Extract rules from transcripts.** Read the supplied
+  \`transcripts.files\` (concrete paths — no globbing). Find user phrases
+  that state a rule with 2+ explicit confirmations across sessions; check
+  against existing feedback notes; write what is missing, with quotes. No
+  files → skip the phase.
+
+Boundaries for every subagent: touch only the folder(s) named in the task,
+and only in-window notes; stay out of canon folders; no hard deletes (only
+the outdated status token, because archiving and links are the Index's
+pass); no vault MCP tools and no web fact-checking (that is the distill
+skill's domain). Edits are stamped \`last_edited_by: dreamweaver\` and the
+\`author\` constant is parsed from the subfolder path, so writing into an
+owner's folder ON TASK keeps their attribution intact — by design.
+
+## What you never do
+
+You never discover work yourself (the pre-filter does) and never write a
+note's substance (its author owns that). You act through subagents and
+report to the Index; you do not archive or set links — that is the Index's
+finalising pass.
 `;