@inetafrica/open-claudia 2.6.39 → 2.6.41

package/core/dream.js

@@ -41,6 +41,16 @@ const DREAM_MODEL = pickDreamModel();
 // reasoning effort by default. Overridable via DREAM_EFFORT (low|medium|high|xhigh|max).
 const DREAM_EFFORT = process.env.DREAM_EFFORT || "max";
 const DREAM_CRON = process.env.DREAM_CRON || "0 4 * * *";
+// Consolidation model timeout. The model weighs the WHOLE corpus in one pass,
+// so a fixed budget that was fine at 30 packs starves at 130 (the timeout that
+// motivated this). Floor 20m, +6s per pack, capped at 40m; DREAM_TIMEOUT_MS
+// (ms) overrides entirely. Even if it still times out, the deterministic phases
+// (prefix nesting, graph tend) run regardless — the model pass is best-effort.
+function dreamTimeoutMs(packCount = 0) {
+  const override = Number(process.env.DREAM_TIMEOUT_MS);
+  if (override > 0) return override;
+  return Math.min(20 * 60 * 1000 + packCount * 6000, 40 * 60 * 1000);
+}
 const MAX_PACK_CHARS = 2500;
 const MAX_ENTITY_CHARS = 900;
 const LIMITS = {
@@ -149,7 +159,7 @@ Your job — decide what consolidation, if any, is warranted:
 
 1. merges: packs that are clearly the SAME topic under different names get merged into one. Supply the merged Stance/Procedure/State (synthesised, not concatenated; null leaves the target's section alone) and a one-sentence journal note. Be conservative: when in doubt, do not merge. A Stance marked USER-AUTHORED is off-limits — leave its stance null; the system preserves it verbatim regardless. Packs marked [ABILITY] are reusable cross-project how-tos, NOT project trackers: only ever merge an [ABILITY] into another [ABILITY] (the merged result must stay an ability), and never merge a project pack into an [ABILITY] or an [ABILITY] into a project pack — that would lose the reusable how-to or pollute it with one project's specifics.
 2. umbrellas: when 3+ packs are siblings under one theme, create an umbrella pack whose State is a 3-6 line map of the family ("for X see pack Y"), and list its children. The umbrella is a router, not a duplicate.
-3. parents: assign an existing pack as parent of another (sub-topic relationship) without creating anything.
+3. parents: assign an existing pack as parent of another (sub-topic relationship) without creating anything. NOTE: a separate deterministic pass already auto-files packs whose slug is a prefix-child of another (e.g. foo-bar under foo), so DON'T spend a parents op on those — reserve parents (and umbrellas) for semantic groupings the slug prefix can't catch (differently-named siblings of one theme).
 4. retag: tighten descriptions and tags. The router FTS-matches incoming messages against name/description/tags, so generic words there cause false matches. Descriptions should be one specific line; tags specific nouns.
 5. entity_merges: the same real-world entity recorded twice gets merged (the better slug wins).
 6. entity_notes: rewrite an entity's Notes to be current and cross-linked — mention related packs as [[pack-dir]] and related entities by name.
@@ -277,7 +287,7 @@ function applyDream(decision, backupRoot) {
   const lines = [];
   const gone = new Set(); // dirs/slugs removed this run
 
-  for (const m of decision.merges) {
+  for (const m of decision.merges || []) {
     try {
       const into = m?.into && packs.readPack(m.into);
       const from = [].concat(m?.from || []).filter((d) => d && d !== m.into && !gone.has(d) && packs.readPack(d));
@@ -312,7 +322,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] merge failed: ${e.message}`); }
   }
 
-  for (const u of decision.umbrellas) {
+  for (const u of decision.umbrellas || []) {
     try {
       const dir = packs.slugify(u?.dir || u?.name);
       if (!dir || gone.has(dir)) continue;
@@ -345,7 +355,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] umbrella failed: ${e.message}`); }
   }
 
-  for (const p of decision.parents) {
+  for (const p of decision.parents || []) {
     try {
       const child = p?.pack && !gone.has(p.pack) && packs.readPack(p.pack);
       if (!child || !p.parent || gone.has(p.parent) || !packs.readPack(p.parent)) continue;
@@ -358,7 +368,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] parent failed: ${e.message}`); }
   }
 
-  for (const r of decision.retag) {
+  for (const r of decision.retag || []) {
     try {
       if (!r?.pack || gone.has(r.pack) || !packs.readPack(r.pack)) continue;
       const desc = typeof r.description === "string" ? r.description.trim() : "";
@@ -374,7 +384,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] retag failed: ${e.message}`); }
   }
 
-  for (const em of decision.entity_merges) {
+  for (const em of decision.entity_merges || []) {
     try {
       const into = em?.into && entities.readEntity(em.into);
       const from = [].concat(em?.from || []).filter((s) => s && s !== em.into && !gone.has(s) && entities.readEntity(s));
@@ -397,7 +407,7 @@ function applyDream(decision, backupRoot) {
     } catch (e) { console.warn(`[dream] entity merge failed: ${e.message}`); }
   }
 
-  for (const en of decision.entity_notes) {
+  for (const en of decision.entity_notes || []) {
     try {
       const ent = en?.entity && !gone.has(en.entity) && entities.readEntity(en.entity);
       if (!ent || typeof en.notes !== "string" || !en.notes.trim()) continue;
@@ -700,6 +710,33 @@ function staleTaskReport() {
   } catch (e) { return ""; }
 }
 
+// Deterministic hierarchy backfill. Files every orphan context pack under the
+// LONGEST existing context pack whose dir is a slug-prefix of it (kazee-people-x
+// → kazee-people). Runs every dream AFTER the model's own parents/umbrellas
+// decision, so it only mops up the obvious prefix families the model left flat.
+// Prefix parents are always shorter, so this can't cycle; never overrides a
+// parent already set (by user, reviewer, or this run's model). Backs up each
+// pack it moves. Returns per-parent summary lines + a count.
+function nestPrefixFamilies(backupRoot) {
+  const all = packs.listPacks();
+  const contextDirs = all.filter((p) => p.kind !== "ability").map((p) => p.dir);
+  const byParent = new Map();
+  for (const p of all) {
+    if (p.kind === "ability" || p.parent) continue;
+    const parent = packs.parentByPrefix(p.dir, contextDirs);
+    if (!parent || !packs.readPack(parent) || wouldCycle(p.dir, parent)) continue;
+    try {
+      if (backupRoot) backupPack(p.dir, backupRoot);
+      packs.setParent(p.dir, parent);
+      byParent.set(parent, (byParent.get(parent) || 0) + 1);
+    } catch (e) { console.warn(`[dream] nest failed for ${p.dir}: ${e.message}`); }
+  }
+  const lines = [...byParent.entries()].map(([parent, n]) =>
+    `🌳 Filed ${n} sub-pack${n === 1 ? "" : "s"} under ${parent}`);
+  const filed = [...byParent.values()].reduce((a, b) => a + b, 0);
+  return { lines, filed };
+}
+
 async function runDream({ trigger = "manual" } = {}) {
   if (!enabled()) return { skipped: "dream is disabled (DREAM=off)" };
   if (_dreaming) return { skipped: "a dream is already in progress" };
@@ -709,18 +746,40 @@ async function runDream({ trigger = "manual" } = {}) {
 
   _dreaming = true;
   try {
-    const { text } = await spawnSubagent(buildDreamPrompt(), {
-      model: DREAM_MODEL,
-      effort: DREAM_EFFORT,
-      timeoutMs: 8 * 60 * 1000,
-      systemPrompt: "You are a background memory consolidation process. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
-    });
-    const decision = parseDream(text);
-    if (!decision) return { skipped: "dream model returned unparseable output" };
+    // Best-effort consolidation: on a large corpus this call can time out or
+    // return unreadable JSON. That must NOT abort the dream — the deterministic
+    // phases below (prefix nesting, graph tend) need no model and are the
+    // load-bearing cleanup. Catch any model failure, fall back to an empty
+    // decision (applyDream no-ops), note it for the report, and carry on.
+    let decision = null;
+    let modelFailNote = "";
+    try {
+      const { text } = await spawnSubagent(buildDreamPrompt(), {
+        model: DREAM_MODEL,
+        effort: DREAM_EFFORT,
+        timeoutMs: dreamTimeoutMs(packCount),
+        systemPrompt: "You are a background memory consolidation process. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
+      });
+      decision = parseDream(text);
+      if (!decision) modelFailNote = "the AI consolidation step returned unreadable output";
+    } catch (e) {
+      modelFailNote = `the AI consolidation step didn't finish (${e.message})`;
+    }
+    if (!decision) decision = { report: "" };
 
     const backupRoot = makeBackupRoot();
     const applied = applyDream(decision, backupRoot);
-    const report = decision.report || (applied.length > 0 ? "Tidied up my memory overnight." : "");
+    // Deterministic hierarchy backfill (kazee-people-* → kazee-people), after the
+    // model's parents/umbrellas decision so it only fills the obvious prefix
+    // families left flat. Backed up + announced like everything else.
+    let nestLines = [];
+    try { nestLines = nestPrefixFamilies(backupRoot).lines; }
+    catch (e) { console.warn(`[dream] nesting pass failed: ${e.message}`); }
+    const consolidationLines = applied.concat(nestLines);
+    let report = decision.report || (consolidationLines.length > 0 ? "Tidied up my memory overnight." : "");
+    if (modelFailNote) {
+      report = `Heads up — ${modelFailNote}, so I skipped the AI-led merges this round but still ran the automatic filing + graph upkeep.${report ? " " + report : ""}`;
+    }
 
     // Phase 2: self-improvement introspection. Reviews the day's seeds, reads
     // its own code/memory READ-ONLY (allowedTools whitelist), promotes lessons
@@ -767,11 +826,11 @@ async function runDream({ trigger = "manual" } = {}) {
     } catch (e) { /* graph is best-effort */ }
 
     const staleNote = staleTaskReport();
-    const dreamLines = applied.concat(introApplied);
+    const dreamLines = consolidationLines.concat(introApplied);
 
     const reportPath = writeDreamReport({
       model: DREAM_MODEL, effort: DREAM_EFFORT, trigger,
-      consolidation: { report: decision.report, lines: applied },
+      consolidation: { report: decision.report, lines: consolidationLines },
       introspection: { report: introReport, lines: introApplied, proposed: introProposed },
       graphNote, staleNote, backupRoot,
     });
@@ -826,7 +885,7 @@ function initDream(adapters) {
 }
 
 module.exports = {
-  runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers,
+  runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies, dreamTimeoutMs,
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled,
   DREAM_CRON, DREAM_MODEL, DREAM_EFFORT, PROMOTE_MIN_PROJECTS,

package/core/pack-review.js

@@ -167,31 +167,24 @@ function guardCheck(a) {
   return hit;
 }
 
-// Deterministic dedupe backstop for the create path. Even with the prompt rule,
-// a cheap model tends to spawn a fresh pack for each version/release/facet of a
-// project an existing pack already owns. This catches two robust signals — a
-// slug that is a hyphen-boundary prefix/extension of an existing pack dir, and a
-// version-named proposal whose name/description strongly matches an existing
-// pack — and the caller folds the proposal into that pack instead. Conservative
-// by design (only context packs; only a clear prefix relationship or a versioned
-// proposal with a strong text match) so genuinely distinct topics still get their
-// own pack. Mirrors the structural "no lesson without a trigger" enforcement.
+// Deterministic dedupe backstop for the create path. A cheap model tends to
+// spawn a fresh pack for each VERSION/RELEASE of a project an existing pack
+// already owns ("<project> v2.6.39"); this folds such a proposal into the
+// project pack instead of spawning a sibling. Scoped tightly: only context
+// packs, only a *versioned* proposal whose name/description strongly matches an
+// existing pack. NOTE: a non-versioned prefix-child (kazee-people-leave under
+// kazee-people) is NOT folded here — it is filed as a sub-pack under its parent
+// at creation (see birth-time parenting in applyAction), which keeps sub-area
+// detail as its own node instead of collapsing it into the parent's State.
 function findDuplicatePack({ dir, name, description, tags }) {
-  const slug = packs.slugify(dir || name || "");
-  if (!slug) return null;
-  const contextDirs = packs.listPacks().filter((p) => p.kind !== "ability").map((p) => p.dir);
-  for (const d of contextDirs) {
-    if (d === slug) continue;
-    if (slug.startsWith(d + "-") || d.startsWith(slug + "-")) return d;
-  }
   const tagStr = Array.isArray(tags) ? tags.join(" ") : "";
-  const versioned = /\bv?\d+\.\d+(?:\.\d+)?\b|\brelease\b|\bv\d+\b/i.test(`${slug} ${name || ""} ${description || ""} ${tagStr}`);
-  if (versioned) {
-    const ctx = new Set(contextDirs);
-    const text = `${name || ""} ${description || ""} ${tagStr}`.trim();
-    for (const m of packs.matchPacks(text, { limit: 3, threshold: 4 })) {
-      if (m.dir !== slug && ctx.has(m.dir)) return m.dir;
-    }
+  const text = `${name || ""} ${description || ""} ${tagStr}`.trim();
+  const versioned = /\bv?\d+\.\d+(?:\.\d+)?\b|\brelease\b|\bv\d+\b/i.test(text);
+  if (!versioned) return null;
+  const slug = packs.slugify(dir || name || "");
+  const ctx = new Set(packs.listPacks().filter((p) => p.kind !== "ability").map((p) => p.dir));
+  for (const m of packs.matchPacks(text, { limit: 3, threshold: 4 })) {
+    if (m.dir !== slug && ctx.has(m.dir)) return m.dir;
   }
   return null;
 }
@@ -243,11 +236,19 @@ function applyAction(a) {
       const ex = packs.readPack(dupeDir);
       return { kind: "update", dir: dupeDir, name: (ex && ex.name) || dupeDir, note: a.journal || "folded a new-pack proposal into the existing pack" };
     }
+    // Birth-time hierarchy: a new context pack whose slug is a prefix-child of an
+    // existing pack (kazee-people-leave → kazee-people) is filed under it at
+    // creation, so families never accumulate flat at the top level. Abilities are
+    // cross-project and never prefix-nested.
+    const parentDir = kind === "context"
+      ? packs.parentByPrefix(dir, packs.listPacks().filter((p) => p.kind !== "ability").map((p) => p.dir))
+      : null;
     const pack = packs.createPack({
       dir,
       name: a.name,
       description: a.description,
       tags: Array.isArray(a.tags) ? a.tags.slice(0, 6) : [],
+      parent: parentDir && packs.readPack(parentDir) ? parentDir : null,
       stance: a.stance || "",
       procedure: a.procedure || "",
       state: a.state || "",
@@ -256,7 +257,7 @@ function applyAction(a) {
       learned_on: kind === "ability" ? learned_on : "",
       applied_on: kind === "ability" ? projects : [],
     }, "reviewer");
-    return { kind: "create", dir: pack.dir, name: pack.name, note: a.description || "", ability: kind === "ability", learned_on: pack.learned_on };
+    return { kind: "create", dir: pack.dir, name: pack.name, note: a.description || "", ability: kind === "ability", learned_on: pack.learned_on, parent: pack.parent };
   }
   return null;
 }
@@ -319,7 +320,7 @@ function reviewTurn({ userText, assistantText, channelId, announce }) {
         } else if (r && r.kind === "create" && r.ability) {
           lines.push(`🧩 New ability: ${r.name}${r.learned_on ? ` (learned on ${r.learned_on})` : ""}\n${clipWords(r.note, 180)}\n↳ open-claudia pack show ${r.dir}`);
         } else if (r && r.kind === "create") {
-          lines.push(`📦 New pack: ${r.name}\n${clipWords(r.note, 180)}\n↳ open-claudia pack show ${r.dir}`);
+          lines.push(`📦 New pack: ${r.name}${r.parent ? ` (filed under ${r.parent})` : ""}\n${clipWords(r.note, 180)}\n↳ open-claudia pack show ${r.dir}`);
         } else if (r) {
           lines.push(`✏️ ${r.name} — ${clipWords(r.note, 180)}${r.appliedTo ? ` 🧩 (now also applies to ${r.appliedTo})` : ""}\n↳ open-claudia pack show ${r.dir}`);
         }

package/core/packs.js

@@ -171,6 +171,35 @@ function setKind(nameOrDir, kind) {
   return pack;
 }
 
+// The natural parent of a pack within a slug family: the LONGEST existing dir
+// that is a hyphen-boundary prefix of `dir` (kazee-people-mobile-x →
+// kazee-people if it exists, else kazee). Pure — the caller supplies candidate
+// dirs (so it can scope to context packs / exclude self). A strict prefix is
+// always shorter than the slug, so a prefix parent can never be a descendant:
+// nesting by prefix cannot create a cycle.
+function parentByPrefix(dir, candidateDirs) {
+  const slug = slugify(dir);
+  if (!slug) return null;
+  let best = null;
+  for (const d of candidateDirs || []) {
+    if (!d || d === slug) continue;
+    if (slug.startsWith(d + "-") && (!best || d.length > best.length)) best = d;
+  }
+  return best;
+}
+
+// Structural setter for a pack's parent (hierarchy). Separate from updatePack:
+// parent is frontmatter metadata, not an authored content section, so it carries
+// no provenance and never touches Stance/State/etc. Pass null/"" to un-parent.
+function setParent(nameOrDir, parentDir) {
+  const pack = findPack(nameOrDir);
+  if (!pack) return null;
+  pack.parent = parentDir ? slugify(parentDir) : null;
+  pack.updated = new Date().toISOString();
+  writePack(pack);
+  return pack;
+}
+
 // Record that an ability was applied on a project (provenance of reuse): appends
 // to applied_on (deduped) and sets learned_on to the first project if unset.
 function recordApplied(nameOrDir, project) {
@@ -562,7 +591,7 @@ function matchPacks(text, { limit = 3, threshold = null } = {}) {
 module.exports = {
   PACKS_DIR, SECTIONS, slugify,
   listPacks, findPack, readPack, writePack, createPack, updatePack, removePack,
-  listSkillPacks, setSkill, listAbilities, setKind, recordApplied, recordCoUse,
+  listSkillPacks, setSkill, listAbilities, setKind, parentByPrefix, setParent, recordApplied, recordCoUse,
   touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
   archivePack, restorePack, listArchived,
   readProvenance, provenanceOf, setProvenance, recordForegroundWrite,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.39",
+  "version": "2.6.41",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {
@@ -9,7 +9,7 @@
   "scripts": {
     "setup": "node setup.js",
     "start": "node bot.js",
-    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-learning-e2e.js"
+    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-pack-nesting.js"
   },
   "files": [
     "bot.js",
@@ -41,7 +41,8 @@
     "test-ability-transfer.js",
     "test-ability-tiers.js",
     "test-ability-merge-guard.js",
-    "test-learning-e2e.js"
+    "test-learning-e2e.js",
+    "test-pack-nesting.js"
   ],
   "keywords": [
     "claude",

package/test-pack-nesting.js

@@ -0,0 +1,115 @@
+// Hierarchy nesting: the deterministic prefix-family pass that keeps pack
+// families (kazee-people-*) filed under their parent instead of sprawling flat
+// at the top level. Covers the pure selector (parentByPrefix), the structural
+// setter (setParent), reviewer birth-time parenting (applyAction create), the
+// dream backfill (nestPrefixFamilies), and the versioned-only fold guard.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "pack-nesting-"));
+process.env.PACKS_DIR = path.join(tmp, "packs");
+
+const packs = require("./core/packs");
+const review = require("./core/pack-review");
+const dream = require("./core/dream");
+
+// ── parentByPrefix: pure longest-prefix selection ──
+assert.strictEqual(
+  packs.parentByPrefix("kazee-people-leave-display", ["kazee", "kazee-people", "other"]),
+  "kazee-people",
+  "longest matching prefix wins"
+);
+assert.strictEqual(packs.parentByPrefix("kazee", ["kazee"]), null, "a pack is never its own parent");
+assert.strictEqual(packs.parentByPrefix("kazeebot", ["kazee"]), null, "prefix must end on a dash boundary");
+assert.strictEqual(packs.parentByPrefix("orphan", ["kazee", "kazee-people"]), null, "no prefix → no parent");
+assert.strictEqual(packs.parentByPrefix("anything", []), null, "no candidates → null");
+
+// ── setParent: structural setter writes + clears frontmatter ──
+packs.createPack({ dir: "np-root", name: "NP Root", description: "a root" });
+packs.createPack({ dir: "np-solo", name: "NP Solo", description: "a leaf" });
+packs.setParent("np-solo", "np-root");
+assert.strictEqual(packs.readPack("np-solo").parent, "np-root", "setParent persists parent");
+packs.setParent("np-solo", null);
+assert.strictEqual(packs.readPack("np-solo").parent, null, "setParent(null) un-parents");
+
+// ── reviewer birth-time parenting: a new prefix-child files under its parent ──
+packs.createPack({ dir: "kazee", name: "Kazee", description: "the platform" });
+packs.createPack({ dir: "kazee-people", name: "Kazee People", description: "the HR module" });
+const born = review.applyAction({
+  action: "create", dir: "kazee-people-payroll", name: "Kazee People Payroll",
+  description: "payroll inside the HR module", state: "started",
+});
+assert.strictEqual(born.kind, "create", "a fresh prefix-child is created, not folded");
+assert.strictEqual(born.parent, "kazee-people", "birth-time parent is the LONGEST prefix (kazee-people, not kazee)");
+assert.strictEqual(packs.readPack("kazee-people-payroll").parent, "kazee-people", "parent persisted to disk");
+
+const orphanBorn = review.applyAction({
+  action: "create", dir: "standalone-thing", name: "Standalone Thing",
+  description: "belongs to no family", state: "started",
+});
+assert.strictEqual(orphanBorn.parent, null, "a pack with no prefix-parent stays top-level");
+
+// abilities are cross-project and must never be prefix-nested
+const abilityBorn = review.applyAction({
+  action: "create", dir: "kazee-people-export", name: "Kazee People Export",
+  description: "reusable export how-to", kind: "ability", learned_on: "kazee",
+});
+assert.strictEqual(abilityBorn.parent, null, "an ability is never prefix-nested");
+
+// ── dream.nestPrefixFamilies: backfills existing flat families ──
+// Three flat siblings + the root, plus an ability that must be left alone.
+packs.createPack({ dir: "billing", name: "Billing", description: "billing system" });
+packs.createPack({ dir: "billing-invoices", name: "Billing Invoices", description: "invoice generation" });
+packs.createPack({ dir: "billing-refunds", name: "Billing Refunds", description: "refund flow" });
+packs.createPack({ dir: "billing-cli", name: "Billing CLI", description: "reusable billing CLI", kind: "ability", learned_on: "billing" });
+
+const res = dream.nestPrefixFamilies(null); // null backupRoot → skip backups in test
+assert.strictEqual(packs.readPack("billing-invoices").parent, "billing", "flat sibling filed under root");
+assert.strictEqual(packs.readPack("billing-refunds").parent, "billing", "second flat sibling filed under root");
+assert.strictEqual(packs.readPack("billing").parent, null, "the family root stays top-level");
+assert.strictEqual(packs.readPack("billing-cli").parent, null, "the billing ability is NOT nested");
+assert.ok(res.filed >= 2, "nest pass reports what it filed");
+assert.ok(res.lines.some((l) => l.includes("billing")), "nest pass announces the family it filed");
+
+// running it again is a no-op (idempotent — everything already parented)
+const again = dream.nestPrefixFamilies(null);
+assert.strictEqual(again.filed, 0, "second pass files nothing new");
+
+// ── dream resilience: the deterministic cleanup must not depend on the model ──
+// applyDream tolerates an empty decision (the fallback used when the AI
+// consolidation step times out / returns garbage) instead of throwing.
+assert.deepStrictEqual(dream.applyDream({}, null), [], "empty decision applies nothing, throws nothing");
+assert.deepStrictEqual(dream.applyDream({ report: "" }, null), [], "report-only fallback decision is safe");
+
+// timeout scales with corpus: floor 20m, grows per pack, capped at 40m, env override.
+assert.strictEqual(dream.dreamTimeoutMs(0), 20 * 60 * 1000, "floor is 20 minutes");
+assert.ok(dream.dreamTimeoutMs(130) > dream.dreamTimeoutMs(30), "more packs → longer budget");
+assert.strictEqual(dream.dreamTimeoutMs(100000), 40 * 60 * 1000, "capped at 40 minutes");
+const prev = process.env.DREAM_TIMEOUT_MS;
+process.env.DREAM_TIMEOUT_MS = "777000";
+assert.strictEqual(dream.dreamTimeoutMs(50), 777000, "DREAM_TIMEOUT_MS overrides entirely");
+if (prev === undefined) delete process.env.DREAM_TIMEOUT_MS; else process.env.DREAM_TIMEOUT_MS = prev;
+
+// ── versioned-only fold (FTS-gated): a versioned proposal folds into its pack,
+//    a non-versioned near-duplicate does NOT. Skipped when node:sqlite is absent. ──
+if (packs.reindex()) {
+  packs.createPack({ dir: "payroll-tax-filing", name: "Payroll Tax Filing", description: "quarterly payroll tax filing" });
+  packs.reindex();
+  const folded = review.applyAction({
+    action: "create", dir: "payroll-tax-filing-v2", name: "Payroll Tax Filing v2 release",
+    description: "payroll tax filing notes", state: "v2 shipped",
+  });
+  assert.strictEqual(folded.kind, "update", "a versioned near-dup folds into the existing pack");
+  assert.strictEqual(folded.dir, "payroll-tax-filing", "fold targets the existing pack");
+
+  const notFolded = review.applyAction({
+    action: "create", dir: "payroll-tax-summary", name: "Payroll Tax Summary",
+    description: "payroll tax filing summary view", state: "started",
+  });
+  assert.strictEqual(notFolded.kind, "create", "a non-versioned near-dup is a real new pack, not a fold");
+  console.log("pack nesting OK (incl. versioned-fold)");
+} else {
+  console.log("pack nesting OK (versioned-fold skipped — no node:sqlite)");
+}