@agfpd/iapeer-memory 0.2.7 → 0.2.9

package/package.json

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

package/src/cli.ts

@@ -24,7 +24,8 @@ 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 { cmdDreamPaths } from "./commands/dream-paths.js";
+import { cmdDreamCollect } from "./commands/dream-collect.js";
+import { cmdArchiveStale } from "./commands/archive-stale.js";
 import { cmdProvisionPeer, cmdUnprovisionPeer } from "./commands/provision-peer.js";
 import { cmdRender } from "./commands/render.js";
 import { cmdStatus } from "./commands/status.js";
@@ -62,10 +63,17 @@ Commands:
   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)
-  dream-paths               tick-time DreamWeaver fan-out resolution: agent
-                            memory folders + transcript globs per runtime
-                            from the LIVE registry (the Index shells this on
-                            DREAM_TICK; read-only)
+  dream-collect [--gate]    deterministic weekly-tick pre-filter (zero LLM):
+                            active agent-memory folders in the 7d window +
+                            candidate flags + resolved transcript files +
+                            batched tasks, from the LIVE registry (read-only).
+                            --gate: no output, exit 0 iff there is work (the
+                            notifier check that decides if DreamWeaver wakes)
+  archive-stale [--commit]  deliberate backlog archiver (lean §2.2a): move
+                            pre-existing stale notes to the archive. Dry-run by
+                            default (lists what would move); --commit executes.
+                            03_Projects is excluded; memoryd archives ongoing
+                            staleness incrementally on its own.
   render index|fragment|doctrine|guide
                             render one artifact explicitly (memoryd does this
                             continuously; render is the manual/scripted path)
@@ -130,8 +138,10 @@ export async function main(argv: string[]): Promise<number> {
       return cmdUpdate(rest, egress);
     case "install-binary":
       return cmdInstallBinary(rest, egress);
-    case "dream-paths":
-      return cmdDreamPaths(rest, egress);
+    case "dream-collect":
+      return cmdDreamCollect(rest, egress);
+    case "archive-stale":
+      return cmdArchiveStale(rest);
     case "provision-peer":
       return cmdProvisionPeer(rest, egress);
     case "unprovision-peer":

package/src/commands/archive-stale.ts

@@ -0,0 +1,87 @@
+/**
+ * `iapeer-memory archive-stale [--commit]` — the DELIBERATE backlog archiver
+ * (lean §2.2a, decision boris 15.06).
+ *
+ * memoryd archives notes incrementally as they BECOME stale (an edit fires the
+ * change pass). Pre-existing stale notes are NOT swept on startup (that would
+ * be a mass move as a side-effect of a daemon boot — banned by §1: bulk
+ * actions are deliberate and verifiable). This verb is that deliberate path:
+ *
+ *   archive-stale            DRY-RUN — list what would move + a count
+ *   archive-stale --commit   actually move them
+ *
+ * `03_Projects` is excluded (a completed phase is a project record, not
+ * displaced knowledge — `isArchivableZone`). memoryd reindexes the moves on
+ * its next pass (or on restart); the verb itself only moves files.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  configFromEnv,
+  snapshotVault,
+  shouldArchive,
+  archiveTargetRel,
+} from "@agfpd/iapeer-memory-core";
+
+export function cmdArchiveStale(argv: string[]): number {
+  const commit = argv.includes("--commit");
+  const config = configFromEnv();
+  const vault = config.vaultPath;
+  const taxonomy = config.taxonomy;
+
+  // Candidates: notes in the monitored content folders carrying a final
+  // status, EXCLUDING 03_Projects (filtered by shouldArchive → isArchivableZone).
+  const snap = snapshotVault(vault, taxonomy);
+  const reserved = new Set<string>(); // archive targets claimed within this run
+  const moves: Array<{ from: string; to: string }> = [];
+  for (const rel of snap.keys()) {
+    let content: string;
+    try {
+      content = fs.readFileSync(path.join(vault, rel), "utf-8");
+    } catch {
+      continue;
+    }
+    if (!shouldArchive(rel, content, taxonomy)) continue;
+    const to = archiveTargetRel(
+      path.basename(rel),
+      taxonomy,
+      (r) => reserved.has(r) || fs.existsSync(path.join(vault, r)),
+    );
+    reserved.add(to);
+    moves.push({ from: rel, to });
+  }
+
+  if (moves.length === 0) {
+    console.log("archive-stale: no stale notes outside the archive — nothing to do.");
+    return 0;
+  }
+
+  if (!commit) {
+    console.log(
+      `archive-stale (DRY-RUN): ${moves.length} stale note(s) WOULD move to ${taxonomy.folders.archive}/:`,
+    );
+    for (const m of moves) console.log(`  ${m.from}  →  ${m.to}`);
+    console.log(
+      `\nPass --commit to move them. (03_Projects is excluded — completed phases stay project-local.)`,
+    );
+    return 0;
+  }
+
+  let moved = 0;
+  for (const m of moves) {
+    const toAbs = path.join(vault, m.to);
+    try {
+      fs.mkdirSync(path.dirname(toAbs), { recursive: true });
+      fs.renameSync(path.join(vault, m.from), toAbs);
+      moved += 1;
+      console.log(`  moved: ${m.from}  →  ${m.to}`);
+    } catch (err) {
+      console.error(`  FAILED: ${m.from} (${String(err)})`);
+    }
+  }
+  console.log(
+    `archive-stale: moved ${moved}/${moves.length}. memoryd reindexes on its next pass (or restart).`,
+  );
+  return 0;
+}