@inetafrica/open-claudia 2.6.38 → 2.6.40

package/core/dream.js

@@ -149,7 +149,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.
@@ -700,6 +700,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" };
@@ -720,7 +747,14 @@ async function runDream({ trigger = "manual" } = {}) {
 
     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);
+    const report = decision.report || (consolidationLines.length > 0 ? "Tidied up my memory overnight." : "");
 
     // Phase 2: self-improvement introspection. Reviews the day's seeds, reads
     // its own code/memory READ-ONLY (allowedTools whitelist), promotes lessons
@@ -767,11 +801,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 +860,7 @@ function initDream(adapters) {
 }
 
 module.exports = {
-  runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers,
+  runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies,
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled,
   DREAM_CRON, DREAM_MODEL, DREAM_EFFORT, PROMOTE_MIN_PROJECTS,

package/core/handlers.js

@@ -966,8 +966,16 @@ register({
       setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
       state.runningProcess = null;
       if (state.streamInterval) clearTimeout(state.streamInterval);
+      if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
       state.messageQueue = [];
       await send("Cancelled.");
+    } else if (state.preparingRun) {
+      // Turn is mid-recall/compaction — no process to kill yet. Flag it so
+      // runClaude bails at its pre-spawn checkpoint, and stop typing now.
+      state.cancelRequested = true;
+      state.messageQueue = [];
+      if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
+      await send("Cancelled.");
     } else await send("Nothing running.");
   },
 });

package/core/pack-review.js

@@ -14,8 +14,11 @@ const packGuard = require("./pack-guard");
 const { redactSensitive } = require("./redact");
 
 const MIN_TURN_CHARS = 400;
-const MAX_TEXT_CHARS = 7000;
-const REVIEW_MODEL = process.env.PACK_REVIEW_MODEL || "haiku";
+const MAX_TEXT_CHARS = 16000;
+// Create/merge decisions need real judgement (the cheap model over-created
+// per-version/per-facet packs), so default to the latest Sonnet. Override with
+// PACK_REVIEW_MODEL if cost/latency of running it on every substantial turn matters.
+const REVIEW_MODEL = process.env.PACK_REVIEW_MODEL || "claude-sonnet-4-6";
 const MAX_ACTIONS = 2;
 const MAX_ENTITY_ACTIONS = 3;
 // Lessons are precious always-on budget — at most one promotion per turn,
@@ -111,7 +114,7 @@ Decide. Rules:
 - Bias toward action: if the turn did real work on an identifiable topic (a named system, project, server, app, person, or domain), record it — at minimum a journal line. Most working turns deserve one. Reserve empty actions for small talk, pure status checks, and turns that contain nothing new.
 - UPDATE an existing pack when the turn touched that topic: append a journal line, and rewrite State if where-things-stand changed. Update Stance when the user expressed a lasting preference or rule; Procedure when a verified working method emerged.
 - PROMOTE durable conclusions out of the Journal. A confirmed root-cause diagnosis, an established fact, or a settled design decision must go into Stance/Procedure/State (the parts always injected in full), NOT only a Journal line — Journal is truncated to the last few lines on injection, so a conclusion left only there will silently fall out of recall over time.
-- CREATE a pack when the turn worked on a durable topic no existing pack covers. Topics recur more than you expect — a named system or project is durable by default. Do not create packs for one-off trivia, and prefer update when an existing pack fits.
+- CREATE a pack ONLY when the turn worked on a durable topic that NO existing pack covers. Before creating, scan the existing packs above for one already about this project/system/domain — if one exists, UPDATE it instead. A new pack must be a genuinely DISTINCT topic, never a narrower facet, version, release, sub-feature, phase, or component of a topic an existing pack already owns. In particular: a release or version of a project (e.g. a pack named after "<project> v2.6.39") is a Journal line + State update on that project's EXISTING pack — NEVER its own pack. Likewise sub-features of one system belong in that system's pack, not in siblings. When unsure whether something is a new topic or a facet of an existing one, treat it as a facet and UPDATE. Do not create packs for one-off trivia.
 - ABILITY vs CONTEXT: most creates are context packs (a project/system tracker). Create an ability (kind:"ability") only for a genuinely reusable how-to as defined above, and always set learned_on + applied_on to the originating project dir. When a turn re-used an EXISTING ability on a NEW project, do NOT create anything — UPDATE that ability and put the new project dir in "applied_on" so the cross-project reuse is recorded.
 - Never store secrets, tokens, passwords, or credentials.
 - State should be concise (under 150 words). Journal entries one sentence. Never start a journal or log sentence with a date — dates are prepended automatically.
@@ -164,6 +167,28 @@ function guardCheck(a) {
   return hit;
 }
 
+// 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 tagStr = Array.isArray(tags) ? tags.join(" ") : "";
+  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;
+}
+
 function applyAction(a) {
   if (!a || typeof a !== "object") return null;
   const guard = guardCheck(a);
@@ -202,11 +227,28 @@ function applyAction(a) {
       if (kind === "ability") for (const proj of projects) packs.recordApplied(dir, proj);
       return { kind: "update", dir, name: a.name || dir, note: a.journal || "state updated" };
     }
+    // Deterministic dedupe: a versioned/facet proposal folds INTO the project
+    // pack it belongs to rather than spawning a sibling (abilities are exempt —
+    // they are activity-named and cross-project by design).
+    const dupeDir = kind === "context" ? findDuplicatePack({ dir, name: a.name, description: a.description, tags: a.tags }) : null;
+    if (dupeDir && packs.readPack(dupeDir)) {
+      packs.updatePack(dupeDir, { journal: a.journal || "", state: a.state || "" }, "reviewer");
+      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 || "",
@@ -215,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;
 }
@@ -278,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/core/runner.js

@@ -794,7 +794,21 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     resumeSessionId: opts.resumeSessionId || null,
   }, state, getActiveSessionId);
 
-  if (adapter && channelId) adapter.typing(channelId).catch(() => {});
+  // Typing heartbeat: keep the indicator alive continuously from message
+  // receipt through the recall/discoverer phase and into streaming, not just
+  // for the ~5s a single typing action lasts. Stored on state so /stop can
+  // clear it instantly. Cleared on close/error/cancel.
+  const startTyping = () => {
+    if (!adapter || !channelId) return;
+    adapter.typing(channelId).catch(() => {});
+    if (!state.typingHeartbeat) state.typingHeartbeat = setInterval(() => adapter.typing(channelId).catch(() => {}), 4000);
+  };
+  const stopTyping = () => { if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; } };
+  // Pre-spawn window (recall/compaction/auth): /stop has no process to kill, so
+  // it sets state.cancelRequested and we bail at the checkpoint before spawning.
+  state.preparingRun = true;
+  state.cancelRequested = false;
+  startTyping();
   state.statusMessageId = null;
   state.streamBuffer = "";
   let assistantText = "";
@@ -883,7 +897,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     } catch (e) { /* announcements are best-effort */ }
   };
 
-  const args = await buildClaudeArgs(prompt, opts);
+  let args;
+  try {
+    args = await buildClaudeArgs(prompt, opts);
+  } catch (e) {
+    state.preparingRun = false;
+    stopTyping();
+    throw e;
+  }
   // Recall announcements are now fired at READ time, not injection time:
   // matched packs/entities enter context only as small headlines (see
   // system-prompt.js recallHeadline). The "📖 Recalled my notes on …" line is
@@ -902,6 +923,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       else if (r.gated) send(`🧠 <b>Recall</b> (${esc(r.engine)}): skipped by pre-gate — trivial turn.`).catch(() => {});
     }
   } catch (e) { /* best-effort */ }
+  // /stop landed during the pre-spawn window (recall/compaction): bail before
+  // spawning. The /stop handler already acknowledged in chat, so stay silent.
+  if (state.cancelRequested) {
+    state.cancelRequested = false;
+    state.preparingRun = false;
+    stopTyping();
+    return;
+  }
   const binaryPath = getActiveBinary();
   const proc = spawn(binaryPath, args, {
     cwd,
@@ -911,6 +940,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 
   state.runningProcess = proc;
+  state.preparingRun = false;
   const startTime = Date.now();
   let longRunningNotified = false;
 
@@ -1094,6 +1124,8 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("close", (code) => chatContext.run(store, async () => {
     state.runningProcess = null;
+    state.preparingRun = false;
+    stopTyping();
     clearTimeout(state.streamInterval); state.streamInterval = null;
     clearTimeout(processTimeout);
 
@@ -1240,6 +1272,8 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("error", (err) => chatContext.run(store, async () => {
     state.runningProcess = null;
+    state.preparingRun = false;
+    stopTyping();
     clearTimeout(state.streamInterval);
     clearTimeout(processTimeout);
     await send(`Error: ${err.message}`);

package/core/state.js

@@ -59,6 +59,9 @@ function createUserState(userId) {
     channelId: currentChannelId(),
     currentSession: saved.currentSession || null,
     runningProcess: null,
+    preparingRun: false,
+    cancelRequested: false,
+    typingHeartbeat: null,
     statusMessageId: null,
     streamBuffer: "",
     streamInterval: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.38",
+  "version": "2.6.40",
   "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,100 @@
+// 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");
+
+// ── 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)");
+}