@inetafrica/open-claudia 2.10.0 → 2.12.0

package/core/system-prompt.js

@@ -607,6 +607,57 @@ function buildEntityBlock(matches, budget) {
   }
 }
 
+// Speaker persona pack: unlike the entity router (which matches on message
+// content), this is the DETERMINISTIC persona of whoever is talking right now.
+// It shapes voice/scope every turn, so it rides the uncached tail (R13) and is
+// injected once per (channel, session, entity-version) to spare tail tokens —
+// a compaction mints a new session id and re-injects, same as packs/entities.
+const speakerPersonaInjectedFor = new Map(); // `${adapterId}:${channelId}` -> `${sessionId}:${slug}:${updated}`
+const SPEAKER_PERSONA_MAX_CHARS = 1400;
+
+function buildSpeakerPersonaBlock() {
+  try {
+    const adapter = currentAdapter();
+    const channelId = currentChannelId();
+    if (!adapter || !channelId) return "";
+    const speaker = people.findByHandle(adapter.type, channelId);
+    if (!speaker) return "";
+    const slug = people.resolveEntitySlug(speaker);
+    if (!slug) return "";
+    const entitiesLib = require("./entities");
+    const ent = entitiesLib.readEntity(slug);
+    if (!ent) return "";
+    const s = ent.sections || {};
+    // Style/Knows/Mandate are what shape a turn; Role frames who they are.
+    // Mandate is the speaker's OWN scope (no leak risk — it's about the person
+    // you're talking to), and only meaningful for non-owners.
+    const rows = [];
+    if ((s.Role || "").trim()) rows.push(`Role: ${s.Role.trim()}`);
+    if ((s.Style || "").trim()) rows.push(`How to talk to them: ${s.Style.trim()}`);
+    if ((s.Knows || "").trim()) rows.push(`Assume they know: ${s.Knows.trim()}`);
+    if (!speaker.isOwner && (s.Mandate || "").trim()) {
+      rows.push(`Mandate — what you may do/discuss with them: ${s.Mandate.trim()}`);
+    }
+    if (rows.length === 0) return "";
+    const state = currentState();
+    const sess = state.lastSessionId || "new";
+    const key = `${adapter.id || "?"}:${channelId}`;
+    const stamp = `${sess}:${slug}:${ent.updated}`;
+    if (speakerPersonaInjectedFor.get(key) === stamp) return "";
+    speakerPersonaInjectedFor.set(key, stamp);
+    const rel = ent.relationship || (speaker.isOwner ? "owner" : "");
+    const clip = (str) => (str.length > SPEAKER_PERSONA_MAX_CHARS ? str.slice(0, SPEAKER_PERSONA_MAX_CHARS) + "\n…[truncated — `open-claudia entity show " + slug + "`]" : str);
+    return clip([
+      `\n\n## Who you're speaking with: ${speaker.name}${rel ? ` (${rel})` : ""}`,
+      `Their persona pack (source: ${entitiesLib.ENTITIES_DIR}/${slug}.md) — adapt your voice and scope to it. Edit that file to refine how you treat them.`,
+      "",
+      rows.join("\n"),
+    ].join("\n"));
+  } catch (e) {
+    return "";
+  }
+}
+
 // The composed prompt can carry text the user didn't write this turn:
 // router.js wraps Telegram reply-quotes in "Replying to …:\n---\n…\n---",
 // and quoting a 📖 recall announcement echoes every entity named in it.
@@ -791,10 +842,10 @@ async function promptWithDynamicContext(prompt, opts = {}) {
       ? `\n\n## Memory budget\n${budget.omitted} matched memory item${budget.omitted === 1 ? " was" : "s were"} omitted to keep this turn under the recall budget (${budget.maxChars} chars). Use \`open-claudia pack show <dir>\`, \`entity show <slug>\`, or transcript search if deeper context is needed.`
       : "";
     const transcriptPointer = opts.includeTranscriptPointer ? `${transcriptPointerNote(state)}\n\n` : "";
-    return `${transcriptPointer}${buildDynamicContextBlock()}${packBlock}${entityBlock}${toolBlock}${episodeBlock}${budgetNote}${voiceReplyGuidance()}\n\nCurrent user request:\n${prompt}`;
+    return `${transcriptPointer}${buildDynamicContextBlock()}${buildSpeakerPersonaBlock()}${packBlock}${entityBlock}${toolBlock}${episodeBlock}${budgetNote}${voiceReplyGuidance()}\n\nCurrent user request:\n${prompt}`;
   } catch (e) {
     return prompt;
   }
 }
 
-module.exports = { loadSoul, buildSystemPrompt, buildDynamicContextBlock, promptWithDynamicContext, consumeLastInjected };
+module.exports = { loadSoul, buildSystemPrompt, buildDynamicContextBlock, buildSpeakerPersonaBlock, promptWithDynamicContext, consumeLastInjected };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "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-runner-watchdog-static.js && 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 && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-unified-identity.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-runner-watchdog-static.js && 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 && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-unified-identity.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-queue-routing.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-persona-packs.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-speaker-persona.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-persona-pipeline.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-recall-relationship-gate.js"
   },
   "files": [
     "bot.js",
@@ -50,7 +50,14 @@
     "test-tool-guard.js",
     "test-tooling-mode.js",
     "test-tool-manifest.js",
-    "test-approval-async.js"
+    "test-approval-async.js",
+    "test-recall-evolution.js",
+    "test-unified-identity.js",
+    "test-queue-routing.js",
+    "test-persona-packs.js",
+    "test-speaker-persona.js",
+    "test-persona-pipeline.js",
+    "test-recall-relationship-gate.js"
   ],
   "keywords": [
     "claude",

package/test-persona-packs.js

@@ -0,0 +1,126 @@
+// Persona packs: the entity note upgraded into a per-person memory that shapes
+// how the bot talks to someone. These tests lock in the additive contract (R7):
+// an ordinary entity serializes byte-identically to before the upgrade, while a
+// person entity gains Role/Style/Knows/Mandate sections + a relationship scalar
+// that round-trip cleanly. They also pin the FTS rule that Mandate (policy) is
+// NOT indexed while the descriptive persona sections are.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "persona-packs-"));
+process.env.ENTITIES_DIR = path.join(tmp, "entities");
+
+const ent = require("./core/entities");
+
+// ── normalizeRelationship: only the three known scalars survive ──
+assert.strictEqual(ent.normalizeRelationship("owner"), "owner", "owner passes");
+assert.strictEqual(ent.normalizeRelationship("  Trusted "), "trusted", "trimmed + lowercased");
+assert.strictEqual(ent.normalizeRelationship("EXTERNAL"), "external", "case-folded");
+assert.strictEqual(ent.normalizeRelationship("stranger"), "", "unknown → empty");
+assert.strictEqual(ent.normalizeRelationship(""), "", "empty → empty");
+assert.strictEqual(ent.normalizeRelationship(null), "", "null → empty");
+
+// ── R7: an ordinary (non-persona) entity serializes byte-identically ──
+// No relationship line, no persona sections — just the historical Notes/Log
+// frontmatter block. This is the exact shape entities had before the upgrade.
+ent.writeEntity({
+  slug: "ordinary-co",
+  name: "Ordinary Co",
+  type: "org",
+  aliases: ["OC", "OrdCo"],
+  description: "an ordinary org",
+  relationship: "",
+  created: "2026-01-01T00:00:00.000Z",
+  updated: "2026-01-02T00:00:00.000Z",
+  last_seen: "2026-01-03T00:00:00.000Z",
+  sections: { Notes: "They do things.", Log: "- [2026-01-01] met them", Role: "", Style: "", Knows: "", Mandate: "" },
+});
+const ordinaryRaw = fs.readFileSync(path.join(process.env.ENTITIES_DIR, "ordinary-co.md"), "utf-8");
+const expectedOrdinary = [
+  "---",
+  "name: Ordinary Co",
+  "type: org",
+  "aliases: OC, OrdCo",
+  "description: an ordinary org",
+  "created: 2026-01-01T00:00:00.000Z",
+  "updated: 2026-01-02T00:00:00.000Z",
+  "last_seen: 2026-01-03T00:00:00.000Z",
+  "---",
+  "",
+  "## Notes",
+  "",
+  "They do things.",
+  "",
+  "## Log",
+  "",
+  "- [2026-01-01] met them",
+  "",
+].join("\n");
+assert.strictEqual(ordinaryRaw, expectedOrdinary, "ordinary entity is byte-identical to the pre-upgrade format");
+assert.ok(!ordinaryRaw.includes("relationship:"), "no relationship line leaks into an ordinary entity");
+assert.ok(!/##\s+(Role|Style|Knows|Mandate)/.test(ordinaryRaw), "no persona sections leak into an ordinary entity");
+
+// ── a persona pack round-trips: relationship + all four sections survive ──
+const person = ent.upsertEntity({
+  name: "Ada Owner",
+  type: "person",
+  relationship: "owner",
+  notes: "Runs the whole show.",
+  role: "Founder and primary operator.",
+  style: "Terse, technical, mobile-first. No hand-holding.",
+  knows: "Deep in the codebase; assume kubernetes and gitops fluency.",
+  mandate: "Full trust — no guardrails apply to the owner.",
+  log: "kicked off the persona work",
+});
+assert.strictEqual(person.created, true, "first upsert creates");
+const ada = ent.findEntity("Ada Owner");
+assert.strictEqual(ada.relationship, "owner", "relationship persisted");
+assert.strictEqual(ada.sections.Role, "Founder and primary operator.", "Role round-trips");
+assert.strictEqual(ada.sections.Style, "Terse, technical, mobile-first. No hand-holding.", "Style round-trips");
+assert.strictEqual(ada.sections.Knows, "Deep in the codebase; assume kubernetes and gitops fluency.", "Knows round-trips");
+assert.strictEqual(ada.sections.Mandate, "Full trust — no guardrails apply to the owner.", "Mandate round-trips");
+assert.strictEqual(ada.sections.Notes, "Runs the whole show.", "Notes still work alongside persona");
+assert.ok(ada.sections.Log.includes("kicked off the persona work"), "Log still appends");
+
+const adaRaw = fs.readFileSync(path.join(process.env.ENTITIES_DIR, "ada-owner.md"), "utf-8");
+assert.ok(adaRaw.includes("relationship: owner"), "relationship written to frontmatter");
+assert.ok(adaRaw.includes("## Mandate"), "Mandate section written when populated");
+
+// ── persona sections replace wholesale (like Notes), log still appends ──
+const person2 = ent.upsertEntity({
+  name: "Ada Owner",
+  style: "Even terser now.",
+  log: "second observation",
+});
+assert.strictEqual(person2.created, false, "second upsert merges, not creates");
+const ada2 = ent.findEntity("Ada Owner");
+assert.strictEqual(ada2.sections.Style, "Even terser now.", "Style replaced wholesale");
+assert.strictEqual(ada2.sections.Role, "Founder and primary operator.", "unspecified Role is left untouched");
+assert.ok(ada2.sections.Log.includes("kicked off the persona work"), "old log line retained");
+assert.ok(ada2.sections.Log.includes("second observation"), "new log line appended");
+
+// ── relationship is validated on upsert: junk is ignored, not stored ──
+ent.upsertEntity({ name: "Ada Owner", relationship: "banana" });
+assert.strictEqual(ent.findEntity("Ada Owner").relationship, "owner", "invalid relationship does not overwrite a valid one");
+
+// ── FTS: descriptive persona sections are matchable; Mandate (policy) is not ──
+if (ent.reindex()) {
+  ent.upsertEntity({
+    name: "Zephyr Contact",
+    type: "person",
+    relationship: "external",
+    knows: "familiar with quantumfoo pipelines",
+    mandate: "may only discuss zebranaut invoicing, nothing else",
+  });
+  ent.reindex();
+  const byKnows = ent.matchEntities("quantumfoo", { threshold: 1 }).map((r) => r.slug);
+  assert.ok(byKnows.includes("zephyr-contact"), "a Knows word matches the persona pack");
+  const byMandate = ent.matchEntities("zebranaut", { threshold: 1 }).map((r) => r.slug);
+  assert.ok(!byMandate.includes("zephyr-contact"), "a Mandate word does NOT surface the pack (policy, not description)");
+  console.log("persona packs OK (incl. FTS mandate-exclusion)");
+} else {
+  console.log("persona packs OK (FTS mandate-exclusion skipped — no node:sqlite)");
+}

package/test-persona-pipeline.js

@@ -0,0 +1,79 @@
+// Persona pipeline: the two write-side paths that POPULATE a persona pack —
+// the post-turn reviewer (pack-review.applyEntityAction) and the nightly dream
+// consolidation (dream.applyDream entity_notes). Both must thread the persona
+// fields (relationship/role/style/knows/mandate) into the entity, replacing
+// each section wholesale, without disturbing the base Notes/Log contract.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "persona-pipeline-"));
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.ENTITIES_DIR = path.join(tmp, "entities");
+
+const entities = require("./core/entities");
+const review = require("./core/pack-review");
+const dream = require("./core/dream");
+
+// ── reviewer: a persona-bearing entity action writes all persona sections ──
+const res = review.applyEntityAction({
+  name: "Rex Boss",
+  type: "person",
+  relationship: "trusted",
+  description: "the CTO",
+  role: "CTO — owns platform architecture.",
+  style: "Blunt and fast. Skip preamble.",
+  knows: "Deep backend; assume distributed-systems fluency.",
+  mandate: "May discuss roadmap and architecture, not headcount.",
+  log: "first mapped his persona",
+});
+assert.strictEqual(res.kind, "create", "reviewer creates the entity");
+let rex = entities.findEntity("Rex Boss");
+assert.strictEqual(rex.relationship, "trusted", "reviewer set relationship");
+assert.strictEqual(rex.sections.Role, "CTO — owns platform architecture.", "reviewer set Role");
+assert.strictEqual(rex.sections.Style, "Blunt and fast. Skip preamble.", "reviewer set Style");
+assert.strictEqual(rex.sections.Knows, "Deep backend; assume distributed-systems fluency.", "reviewer set Knows");
+assert.strictEqual(rex.sections.Mandate, "May discuss roadmap and architecture, not headcount.", "reviewer set Mandate");
+assert.ok(rex.sections.Log.includes("first mapped his persona"), "reviewer appended Log");
+
+// ── reviewer: a note-only action leaves persona sections intact ──
+review.applyEntityAction({ name: "Rex Boss", notes: "Now leads a second team.", log: "team change" });
+rex = entities.findEntity("Rex Boss");
+assert.strictEqual(rex.sections.Notes, "Now leads a second team.", "notes updated");
+assert.strictEqual(rex.sections.Style, "Blunt and fast. Skip preamble.", "persona Style untouched by a note-only update");
+assert.strictEqual(rex.sections.Mandate, "May discuss roadmap and architecture, not headcount.", "persona Mandate untouched");
+
+// ── dream: entity_notes consolidation can refine persona fields wholesale ──
+const lines = dream.applyDream({
+  entity_notes: [{
+    entity: "rex-boss",
+    style: "Even blunter now — one-liners.",
+    mandate: "Roadmap, architecture AND hiring.",
+  }],
+}, null);
+rex = entities.findEntity("Rex Boss");
+assert.strictEqual(rex.sections.Style, "Even blunter now — one-liners.", "dream refined Style wholesale");
+assert.strictEqual(rex.sections.Mandate, "Roadmap, architecture AND hiring.", "dream refined Mandate wholesale");
+assert.strictEqual(rex.sections.Role, "CTO — owns platform architecture.", "dream left unspecified Role intact");
+assert.ok(lines.some((l) => /persona/.test(l)), "dream announces a persona refresh");
+
+// ── dream: a plain note refresh still works and does NOT wipe persona ──
+dream.applyDream({ entity_notes: [{ entity: "rex-boss", notes: "Back to one team." }] }, null);
+rex = entities.findEntity("Rex Boss");
+assert.strictEqual(rex.sections.Notes, "Back to one team.", "dream refreshed Notes");
+assert.strictEqual(rex.sections.Style, "Even blunter now — one-liners.", "note-only dream refresh preserves persona Style");
+
+// ── provenance (2.5): non-owner contributions are stamped, owner's are not ──
+assert.strictEqual(review.provenanceTag({ name: "Zephyr Contact", isOwner: false }), "(via Zephyr Contact) ", "non-owner stamped");
+assert.strictEqual(review.provenanceTag({ name: "Ada Owner", isOwner: true }), "", "owner not stamped (default author)");
+assert.strictEqual(review.provenanceTag(null), "", "no source → no stamp");
+assert.strictEqual(review.provenanceTag({ name: "  ", isOwner: false }), "", "blank name → no stamp");
+// The tag decorates the appended Log line (Rex already exists by now).
+review.applyEntityAction({ name: "Rex Boss", log: "(via Zephyr Contact) flagged a billing question" });
+const lastLog = entities.findEntity("Rex Boss").sections.Log.split("\n").pop();
+assert.ok(lastLog.includes("(via Zephyr Contact) flagged a billing question"), "provenance tag lands in the Log line");
+assert.ok(/^- \[\d{4}-\d{2}-\d{2}\] \(via Zephyr Contact\)/.test(lastLog), "date is prepended before the provenance tag");
+
+console.log("persona pipeline OK");

package/test-queue-routing.js

@@ -0,0 +1,52 @@
+// Origin-aware queue draining. Under unified identity the owner's channels
+// share one run-lock and message queue, so a message queued from one channel
+// during a run on another must still be answered on its own channel. These
+// tests lock in the grouping that guarantees that routing.
+
+const assert = require("assert");
+const { originKey, splitLeadingOriginGroup } = require("./core/queue-drain");
+
+const tg = (id) => ({ prompt: `m${id}`, origin: { transport: "telegram", channelId: "6251055967" } });
+const kz = (id) => ({ prompt: `m${id}`, origin: { transport: "kazee", channelId: "abc" } });
+const legacy = (id) => ({ prompt: `m${id}` }); // queued before origin capture
+
+// originKey
+assert.strictEqual(originKey(tg(1)), "telegram:6251055967", "telegram key");
+assert.strictEqual(originKey(kz(1)), "kazee:abc", "kazee key");
+assert.strictEqual(originKey(legacy(1)), "__current__", "legacy → sentinel");
+
+// Empty queue
+assert.deepStrictEqual(splitLeadingOriginGroup([]), { group: [], rest: [] }, "empty");
+
+// All one origin → single group, no remainder (the common case: preserves the
+// prior single-batch behaviour, now scoped to that origin).
+{
+  const q = [tg(1), tg(2), tg(3)];
+  const { group, rest } = splitLeadingOriginGroup(q);
+  assert.strictEqual(group.length, 3, "same-origin: all grouped");
+  assert.strictEqual(rest.length, 0, "same-origin: nothing requeued");
+}
+
+// Mixed origins → only the leading same-origin run comes out; the rest is
+// requeued so the next drain routes it to its own channel.
+{
+  const q = [tg(1), tg(2), kz(3), tg(4)];
+  const { group, rest } = splitLeadingOriginGroup(q);
+  assert.deepStrictEqual(group.map((m) => m.prompt), ["m1", "m2"], "leading telegram group");
+  assert.deepStrictEqual(rest.map((m) => m.prompt), ["m3", "m4"], "kazee + later telegram requeued");
+  // Draining the remainder next peels off the kazee message on its own.
+  const next = splitLeadingOriginGroup(rest);
+  assert.deepStrictEqual(next.group.map((m) => m.prompt), ["m3"], "next drain: kazee alone");
+  assert.deepStrictEqual(next.rest.map((m) => m.prompt), ["m4"], "next drain: trailing telegram requeued");
+}
+
+// Legacy items (no origin) group together under the sentinel and fall back to
+// the finishing turn's context — matching pre-change behaviour.
+{
+  const q = [legacy(1), legacy(2), tg(3)];
+  const { group, rest } = splitLeadingOriginGroup(q);
+  assert.deepStrictEqual(group.map((m) => m.prompt), ["m1", "m2"], "legacy grouped");
+  assert.deepStrictEqual(rest.map((m) => m.prompt), ["m3"], "origin item requeued");
+}
+
+console.log("queue-routing OK");

package/test-recall-evolution.js

@@ -0,0 +1,214 @@
+// v2.6.59 evolution: dream-tunable knobs (bounded, env-pinned, revertible),
+// walker cascade verdicts, per-node evidence, windowed health deltas, delta
+// dreaming (dump selection + merge clusters), reviewer skip-gate, journal
+// backfill dedupe, and version-stamped KPI aggregation.
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+// Redirect EVERYTHING before any require: CONFIG_DIR derives from HOME, and
+// metrics._resetForTest() deletes files — must never touch live telemetry.
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-evolution-"));
+process.env.HOME = tmp;
+process.env.PACKS_DIR = path.join(tmp, "packs");
+process.env.RECALL_GRAPH_DB = path.join(tmp, "graph.db");
+delete process.env.RECALL_WALKER_MAX_CANDIDATES;
+
+const tuning = require("./core/recall/tuning");
+const metrics = require("./core/recall/metrics");
+const disc = require("./core/recall/discoverer");
+const review = require("./core/pack-review");
+const dream = require("./core/dream");
+const kpi = require("./core/recall/kpi");
+const packs = require("./core/packs");
+
+// ── tuning: bounds, precedence, revert ──
+tuning._resetForTest();
+assert.strictEqual(tuning.get("walkerMaxCandidates"), 14, "default value");
+assert.strictEqual(tuning.get("cascade"), "on", "enum default");
+assert.strictEqual(tuning.get("nope"), undefined, "unknown knob → undefined");
+
+const ch = tuning.set("walkerMaxCandidates", 18, { reason: "test", evidence: "unit" });
+assert.deepStrictEqual({ knob: ch.knob, from: ch.from, to: ch.to }, { knob: "walkerMaxCandidates", from: 14, to: 18 });
+assert.strictEqual(tuning.get("walkerMaxCandidates"), 18, "set applies");
+assert.strictEqual(tuning.set("walkerMaxCandidates", 18), null, "no-op set rejected");
+assert.strictEqual(tuning.set("walkerMaxCandidates", 99).to, 20, "clamped to max");
+assert.strictEqual(tuning.set("bogusKnob", 5), null, "unknown knob rejected");
+assert.strictEqual(tuning.set("cascade", "sideways"), null, "illegal enum clamps to default → no-op");
+assert.strictEqual(tuning.get("cascade") === "on" || tuning.get("cascade") === "off", true);
+
+process.env.RECALL_WALKER_MAX_CANDIDATES = "10";
+assert.strictEqual(tuning.get("walkerMaxCandidates"), 10, "env pin wins over tuning file");
+assert.strictEqual(tuning.set("walkerMaxCandidates", 16), null, "env-pinned knob refuses dream writes");
+delete process.env.RECALL_WALKER_MAX_CANDIDATES;
+
+const rv = tuning.revert("walkerMaxCandidates", { reason: "test rollback" });
+assert.strictEqual(rv.to, 18, "revert restores the value before the last change");
+assert.ok(tuning.history().some((h) => /^rollback:/.test(h.reason)), "rollback recorded in history");
+assert.ok(tuning.lastChange() && !/^rollback:/.test(tuning.lastChange().reason), "lastChange skips rollbacks");
+
+// ── cascade verdicts: conservative, evidence-only ──
+assert.strictEqual(disc.cascadeVerdict(null), null, "no history → judge");
+assert.strictEqual(disc.cascadeVerdict({ seen: 6, kept: 0, open: 0, rev: 0 }), "drop", "seen≥6 never kept never used → drop");
+assert.strictEqual(disc.cascadeVerdict({ seen: 5, kept: 4, open: 1 }), "keep", "keep-rate ≥0.8 with real use → keep");
+assert.strictEqual(disc.cascadeVerdict({ seen: 5, kept: 4, open: 0, rev: 0 }), null, "high keep but never used → judge");
+assert.strictEqual(disc.cascadeVerdict({ seen: 3, kept: 0, open: 0 }), null, "too little history → judge");
+assert.strictEqual(disc.cascadeVerdict({ seen: 6, kept: 1, open: 0 }), null, "ambiguous middle → judge");
+
+// ── metrics: node stats, rescues, co-rescue pairs, evidence ──
+metrics._resetForTest();
+for (let i = 0; i < 7; i++) {
+  metrics.logTurn({
+    query: "q", tier: "full",
+    seeds: [{ id: "pack:seeded", score: 3 }],
+    activated: [{ id: "pack:noisy", activation: 0.5, hop: 1 }],
+    cand: [{ id: "pack:seeded", act: false }, { id: "pack:noisy", act: true }],
+    kept: i < 3 ? [{ id: "pack:seeded", why: "w" }, { id: "pack:resc-a", why: "w" }, { id: "pack:resc-b", why: "w" }]
+                : [{ id: "pack:seeded", why: "w" }],
+    latencyMs: 1000, costUsd: 0.001,
+  });
+}
+metrics.logUse(["pack:seeded"]);
+metrics.logUse(["pack:seeded"], "reviewer");
+const ns = metrics.nodeStats().nodes;
+assert.strictEqual(ns["pack:noisy"].seen, 7, "candidate seen count accumulates");
+assert.strictEqual(ns["pack:noisy"].kept, 0, "never-kept stays zero");
+assert.strictEqual(ns["pack:noisy"].act, 7, "graph-arrival count tracked");
+assert.strictEqual(ns["pack:resc-a"].resc, 3, "kept-without-seed counts as rescue");
+assert.strictEqual(ns["pack:seeded"].open, 1, "📖 open tracked per node");
+assert.strictEqual(ns["pack:seeded"].rev, 1, "reviewer credit tracked per node");
+
+const ev = metrics.evidence({ minSeen: 6, coRescueMin: 3 });
+assert.ok(ev.neverKept.some((n) => n.id === "pack:noisy"), "noisy node lands in neverKept");
+assert.ok(!ev.neverKept.some((n) => n.id === "pack:seeded"), "used node never in neverKept");
+assert.ok(ev.coRescuePairs.some((p) => p.a === "pack:resc-a" && p.b === "pack:resc-b" && p.n === 3), "co-rescue pair counted");
+assert.ok(ev.summary.turns === 7, "evidence carries the raw summary");
+
+// cascadeVerdict against the accumulated stats: noisy is a drop, seeded needs more
+assert.strictEqual(disc.cascadeVerdict(ns["pack:noisy"]), "drop", "real accumulated stats produce a drop verdict");
+
+// ── dream: windowed deltas + health ──
+const delta = dream.summaryDelta(
+  { turns: 10, opens: 5, keptTotal: 12, rescueTurns: 3, latencyMsTotal: 30000, shadowChecks: 4, shadowAgree: 4, byTier: { full: { n: 4, ms: 40000 }, seeds: { n: 6, ms: 600 } } },
+  { turns: 6, opens: 2, keptTotal: 6, rescueTurns: 1, latencyMsTotal: 10000, byTier: { full: { n: 2, ms: 10000 } } }
+);
+assert.strictEqual(delta.turns, 4);
+assert.strictEqual(delta.opens, 3);
+assert.deepStrictEqual(delta.byTier.full, { n: 2, ms: 30000 });
+assert.deepStrictEqual(delta.byTier.seeds, { n: 6, ms: 600 });
+const health = dream.healthOf({ turns: 10, rescueTurns: 3, keptTotal: 10, opens: 2, reviewerUses: 1, latencyMsTotal: 20000 });
+assert.strictEqual(health.rescueRate, 0.3);
+assert.strictEqual(health.noiseRate, 0.7);
+assert.strictEqual(health.avgLatencyMs, 2000);
+
+// ── dream: merge clusters (similarity + ability boundary) ──
+const mkPack = (dir, name, description, kind) => ({ dir, name, description, tags: ["kazee", "mobile"], kind });
+const clusters = dream.mergeClusters([
+  mkPack("kazee-mobile-deploy", "Kazee Mobile Deployment", "APK versionCode updater pipeline GitLab CI"),
+  mkPack("kazee-mobile-deployment", "Kazee Mobile Deployment", "APK versionCode updater pipeline GitLab"),
+  mkPack("villa-heatmap", "Villa WiFi Heatmap", "LAN hosted survey renders access points"),
+]);
+assert.strictEqual(clusters.length, 1, "one similar pair clusters");
+assert.deepStrictEqual([...clusters[0]].sort(), ["kazee-mobile-deploy", "kazee-mobile-deployment"]);
+const abilitySplit = dream.mergeClusters([
+  mkPack("deploy-a", "Kazee Mobile Deployment", "APK versionCode updater pipeline", "ability"),
+  mkPack("deploy-b", "Kazee Mobile Deployment", "APK versionCode updater pipeline"),
+]);
+assert.strictEqual(abilitySplit.length, 0, "ability/context never cluster together");
+
+// ── dream: delta dump selection ──
+const now = Date.now();
+const iso = (d) => new Date(d).toISOString();
+const corpus = [
+  { dir: "touched", updated: iso(now - 3600e3), tags: [] },
+  { dir: "stale", updated: iso(now - 40 * 86400e3), tags: [] },
+  { dir: "concernpack", updated: iso(now - 40 * 86400e3), tags: ["concern"] },
+  { dir: "clustered", updated: iso(now - 40 * 86400e3), tags: [] },
+];
+const since = iso(now - 86400e3);
+const dump = dream.selectDumpDirs(corpus, { sinceTs: since, fullSweep: false, clusters: [["clustered", "touched"]] });
+assert.ok(dump.has("touched"), "touched pack dumped in full");
+assert.ok(dump.has("concernpack"), "shared concern always dumped");
+assert.ok(dump.has("clustered"), "merge-cluster member dumped");
+assert.ok(!dump.has("stale"), "untouched pack stays an index row");
+const sweep = dream.selectDumpDirs(corpus, { sinceTs: since, fullSweep: true, clusters: [] });
+assert.strictEqual(sweep.size, 4, "full sweep dumps everything");
+
+// ── reviewer skip-gate: only provably-empty turns skip ──
+const pad = "The deployment pipeline completed and artifacts were archived. ".repeat(8); // ~500 chars, no preference words
+assert.strictEqual(review.shouldSkipReview({ userText: "ok", assistantText: "", signals: {} }), "short");
+assert.strictEqual(review.shouldSkipReview({ userText: "thanks!", assistantText: pad, signals: { tier: "skip" } }), "trivial");
+assert.strictEqual(review.shouldSkipReview({ userText: "fup status today", assistantText: pad, signals: { tier: "seeds", wrote: false } }), "lookup");
+assert.strictEqual(review.shouldSkipReview({ userText: "fup status today", assistantText: pad, signals: { tier: "seeds", wrote: true } }), null, "a write means review");
+assert.strictEqual(review.shouldSkipReview({ userText: "fup status today", assistantText: pad, signals: { tier: "seeds" } }), null, "unknown wrote-state means review");
+assert.strictEqual(review.shouldSkipReview({ userText: "remember the fup rule", assistantText: pad, signals: { tier: "seeds", wrote: false } }), null, "preference language escapes the skip");
+assert.strictEqual(review.shouldSkipReview({ userText: "fup status today", assistantText: pad, signals: { tier: "full", wrote: false } }), null, "full tier always reviews");
+assert.strictEqual(review.shouldSkipReview({ userText: "fup status today", assistantText: pad + pad + pad, signals: { tier: "seeds", wrote: false } }), null, "long turns always review");
+
+// ── dream: journal backfill dedupe ──
+packs.createPack({ dir: "backfill-me", name: "Backfill", description: "test" });
+const p = packs.readPack("backfill-me");
+p.sections.Journal = [
+  "- [2026-06-01] Tuned the FUP enforcer thresholds and reran the dry-run",
+  "- [2026-06-02] Tuned the FUP enforcer thresholds and reran the dry-run",
+  "- [2026-06-03] Tuned FUP enforcer thresholds and reran the dry-run again",
+  "- [2026-06-04] Shipped the tiered recall gate with the candidate cap",
+].join("\n");
+packs.writePack(p);
+const backupRoot = path.join(tmp, "backup");
+const jd = dream.journalBackfillDedupe(backupRoot);
+assert.ok(jd.removed >= 2, `near-dup journal lines collapsed (removed ${jd.removed})`);
+const after = packs.readPack("backfill-me").sections.Journal.split("\n").filter((l) => l.trim());
+assert.ok(after.some((l) => /tiered recall gate/.test(l)), "distinct line survives");
+assert.ok(after.some((l) => /FUP enforcer/.test(l)), "one representative of the dup family survives");
+assert.ok(fs.existsSync(path.join(backupRoot, "packs", "backfill-me")), "deduped pack backed up first");
+
+// ── KPI: version-stamped aggregation + snapshots + report ──
+metrics._resetForTest();
+const L = (o) => JSON.stringify(o) + "\n";
+fs.writeFileSync(metrics.LOG_FILE, [
+  L({ ts: "2026-06-01T00:00:00Z", v: "2.6.50", model: "haiku", tier: "full", seeds: [{ id: "pack:a" }], kept: [{ id: "pack:a" }, { id: "pack:b" }], latencyMs: 10000, costUsd: 0.01 }),
+  L({ ts: "2026-06-01T00:01:00Z", v: "2.6.50", use: ["pack:a"] }),
+  L({ ts: "2026-06-02T00:00:00Z", v: "2.6.50", model: "haiku", tier: "full", gated: true, latencyMs: 5 }),
+  L({ ts: "2026-07-01T00:00:00Z", v: "2.6.59", model: "haiku", tier: "seeds", seeds: [{ id: "pack:a" }], kept: [{ id: "pack:a" }], latencyMs: 2000, costUsd: 0, auto: { kept: ["pack:a"], dropped: ["pack:z"] } }),
+  L({ ts: "2026-05-01T00:00:00Z", tier: "full", seeds: [], kept: [], latencyMs: 3000, walker: "failed" }),
+].join(""));
+const rows = kpi.aggregate();
+assert.strictEqual(rows.length, 3, "three version buckets (two stamped + legacy)");
+assert.strictEqual(rows[0].v, kpi.LEGACY_VERSION, "unstamped records fall into the legacy bucket, ordered first");
+const v50 = rows.find((r) => r.v === "2.6.50");
+assert.strictEqual(v50.turns, 2);
+assert.strictEqual(v50.gatedPct, 50);
+assert.strictEqual(v50.rescuePct, 100, "kept-without-seed counts as a rescue turn");
+assert.strictEqual(v50.noisePct, 50, "one of two kept nodes was used");
+assert.deepStrictEqual(v50.models, ["haiku"]);
+const v59 = rows.find((r) => r.v === "2.6.59");
+assert.strictEqual(v59.rescuePct, 0);
+assert.strictEqual(v59.autoKept, 1);
+assert.strictEqual(v59.autoDropped, 1);
+assert.strictEqual(rows.find((r) => r.v === kpi.LEGACY_VERSION).walkerFailPct, 100);
+
+metrics.appendKpi({ trigger: "test", health: { rescueRate: 0.25, noiseRate: 0.5, avgLatencyMs: 8000 }, window: { turns: 40 } });
+metrics.appendKpi({ trigger: "test", health: { rescueRate: 0.30, noiseRate: 0.4, avgLatencyMs: 7000 }, window: { turns: 55 } });
+const snaps = metrics.readKpi();
+assert.strictEqual(snaps.length, 2, "nightly snapshots append");
+assert.ok(snaps[0].v && snaps[0].ts, "snapshots are version-stamped");
+
+const table = kpi.renderTable(rows);
+assert.ok(/2\.6\.50/.test(table) && /rescue/.test(table), "table renders versions and metrics");
+const html = kpi.htmlReport();
+assert.ok(/<svg/.test(html) && /2\.6\.59/.test(html) && /rescue/i.test(html), "HTML report has charts and versions");
+const outPath = kpi.writeHtmlReport(path.join(tmp, "kpi.html"));
+assert.ok(fs.existsSync(outPath), "report file written");
+
+// ── dream: prompt carries evidence + knob table; parseDream accepts tuning ──
+const prompt = dream.buildDreamPrompt({ sinceTs: since, fullSweep: false, clusters: [], evidence: ev, windowDelta: { turns: 4, rescueTurns: 1, keptTotal: 4, opens: 1, latencyMsTotal: 8000, byTier: {} } });
+assert.ok(/RECALL EVIDENCE/.test(prompt), "evidence section present");
+assert.ok(/walkerMaxCandidates/.test(prompt), "knob table present");
+assert.ok(/delta night/.test(prompt), "delta framing present");
+const parsed = dream.parseDream(JSON.stringify({ report: "hi", tuning: { knob: "episodeLimit", to: 4, reason: "r" } }));
+assert.deepStrictEqual(parsed.tuning, { knob: "episodeLimit", to: 4, reason: "r" }, "tuning proposal parses");
+assert.strictEqual(dream.parseDream(JSON.stringify({ report: "hi", tuning: "bogus" })).tuning, null, "non-object tuning ignored");
+
+console.log("recall evolution OK");

package/test-recall-relationship-gate.js

@@ -0,0 +1,42 @@
+// Relationship-gated cross-conversation recall (R6). Episodic recall reaches
+// into the owner's project transcripts, so it must be OWNER-ONLY: an external
+// speaker's turn must never pull the owner's past conversations. These tests
+// pin the fail-closed gate — owner allowed, non-owner blocked, unknown blocked,
+// and no-speaker-context (CLI/tests) ungated so local tooling still works.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "recall-gate-"));
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.PEOPLE_FILE = path.join(tmp, "people.json");
+process.env.ENTITIES_DIR = path.join(tmp, "entities");
+
+const people = require("./core/people");
+const { runInChat } = require("./core/context");
+const { episodesAllowedForSpeaker } = require("./core/recall/discoverer");
+
+const adapter = { id: "telegram", type: "telegram" };
+
+const owner = people.add({ name: "Ada Owner", isOwner: true });
+people.linkHandle(owner.id, { adapter: "telegram", channelId: "111" });
+const ext = people.add({ name: "Zephyr Contact" });
+people.linkHandle(ext.id, { adapter: "telegram", channelId: "222" });
+
+const inChat = (channelId, fn) => runInChat({ adapter, channelId, transport: "telegram" }, fn);
+
+// No speaker context at all (CLI / tests) → ungated, episodes flow as before.
+assert.strictEqual(episodesAllowedForSpeaker(), true, "no chat context → episodes allowed (CLI/tests)");
+
+// Owner speaking → allowed.
+assert.strictEqual(inChat("111", () => episodesAllowedForSpeaker()), true, "owner → episodes allowed");
+
+// Known non-owner speaking → blocked (their turn can't pull the owner's past).
+assert.strictEqual(inChat("222", () => episodesAllowedForSpeaker()), false, "external → episodes blocked");
+
+// Unknown channel (no person record) → fail closed.
+assert.strictEqual(inChat("999", () => episodesAllowedForSpeaker()), false, "unknown speaker → episodes blocked");
+
+console.log("recall relationship gate OK");