@inetafrica/open-claudia 2.4.0 → 2.5.0

package/core/pack-review.js

@@ -0,0 +1,199 @@
+// Post-turn pack reviewer (Hermes-inspired, selective-but-active).
+// After each substantial turn a cheap model reviews the exchange and
+// decides whether a context pack should be created or mutated. The model
+// only RETURNS a JSON decision — all file writes are applied here by bot
+// code, so the reviewer needs no tools and no permissions. Every applied
+// mutation is announced in chat (one line), per the no-silent-learning
+// rule.
+
+const { spawnSubagent } = require("./subagent");
+const packs = require("./packs");
+const entities = require("./entities");
+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_ACTIONS = 2;
+const MAX_ENTITY_ACTIONS = 3;
+
+function enabled() {
+  return (process.env.PACK_REVIEW || "on").toLowerCase() !== "off";
+}
+
+function clip(text, n = MAX_TEXT_CHARS) {
+  const s = String(text || "");
+  return s.length > n ? s.slice(0, n) + "\n…[truncated]" : s;
+}
+
+function buildReviewPrompt(userText, assistantText) {
+  const index = packs.listPacks().map((p) =>
+    `- ${p.dir}: ${p.name} — ${p.description}${p.tags.length ? ` [${p.tags.join(", ")}]` : ""}`
+  ).join("\n") || "(none yet)";
+
+  const entityIndex = entities.listEntities().map((e) =>
+    `- ${e.slug}: ${e.name} (${e.type})${e.aliases.length ? ` aka ${e.aliases.join(", ")}` : ""} — ${e.description}`
+  ).join("\n") || "(none yet)";
+
+  return `You are the memory reviewer for a personal AI assistant. After each conversation turn you decide whether the assistant's long-term "context packs" and "entity notes" should change.
+
+A context pack is a living document about ONE topic (a project, a system, a recurring task, a domain). It has four sections:
+- Stance: how to think about the topic — preferences, framing, hard rules the user has expressed.
+- Procedure: verified how-to steps and commands.
+- State: where work on the topic stands NOW — decisions made, open questions, next steps. Replaces wholesale.
+- Journal: one-line dated log of what happened each session.
+
+An entity note is a short memory file about ONE specific named entity — a person, place, project, org, or system. It has:
+- Notes: current truth about the entity (who/what it is, role, preferences, relationships). Replaces wholesale.
+- Log: one-line dated observations, appended.
+
+Existing packs:
+${index}
+
+Known entities:
+${entityIndex}
+
+The turn to review:
+
+<user_message>
+${clip(userText)}
+</user_message>
+
+<assistant_reply>
+${clip(assistantText)}
+</assistant_reply>
+
+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.
+- 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.
+- 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.
+- At most ${MAX_ACTIONS} pack actions.
+- Entities: add an item when the turn revealed something durable about a specific named person, place, project, org, or system — their role, status, preferences, or relationship to other work. Use the existing entity name when one matches (check aliases). Skip entities mentioned only in passing with nothing learned. Notes under 100 words; "notes" null means leave Notes unchanged. At most ${MAX_ENTITY_ACTIONS} entity items.
+- Packs and entities are independent — a turn can update both, either, or neither. Do not duplicate the same fact in a pack AND an entity unless it genuinely belongs to both.
+
+Reply with ONLY a JSON object, no prose, no code fences:
+{"actions": [
+  {"action": "update", "pack": "<existing dir>", "journal": "<one sentence>", "state": "<full new State or null>", "stance": null, "procedure": null}
+  | {"action": "create", "dir": "<kebab-slug>", "name": "<title>", "description": "<one line: when this pack is relevant>", "tags": ["..."], "stance": "<or empty>", "procedure": "<or empty>", "state": "<where things stand>", "journal": "<one sentence>"}
+],
+"entities": [
+  {"name": "<canonical name>", "type": "person|place|project|org|system|thing", "aliases": ["..."], "description": "<one line: who/what this is>", "notes": "<full new Notes or null>", "log": "<one sentence observation>"}
+]}
+or {"actions": [], "entities": []}`;
+}
+
+function parseDecision(text) {
+  const raw = String(text || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end <= start) return null;
+  try {
+    const obj = JSON.parse(raw.slice(start, end + 1));
+    const actions = Array.isArray(obj.actions) ? obj.actions.slice(0, MAX_ACTIONS) : (obj.action ? [obj] : []);
+    const entityActions = Array.isArray(obj.entities) ? obj.entities.slice(0, MAX_ENTITY_ACTIONS) : [];
+    return { actions, entities: entityActions };
+  } catch (e) {
+    return null;
+  }
+}
+
+function applyAction(a) {
+  if (!a || typeof a !== "object") return null;
+  if (a.action === "update" && a.pack) {
+    const existing = packs.readPack(a.pack);
+    if (!existing) return null;
+    packs.updatePack(a.pack, {
+      journal: a.journal || "",
+      state: typeof a.state === "string" ? a.state : "",
+      stance: typeof a.stance === "string" ? a.stance : "",
+      procedure: typeof a.procedure === "string" ? a.procedure : "",
+    });
+    return { kind: "update", dir: a.pack, name: existing.name, note: a.journal || "state updated" };
+  }
+  if (a.action === "create" && (a.dir || a.name)) {
+    const dir = packs.slugify(a.dir || a.name);
+    if (packs.readPack(dir)) {
+      packs.updatePack(dir, { journal: a.journal || "", state: a.state || "" });
+      return { kind: "update", dir, name: a.name || dir, note: a.journal || "state updated" };
+    }
+    const pack = packs.createPack({
+      dir,
+      name: a.name,
+      description: a.description,
+      tags: Array.isArray(a.tags) ? a.tags.slice(0, 6) : [],
+      stance: a.stance || "",
+      procedure: a.procedure || "",
+      state: a.state || "",
+      journal: a.journal || "",
+    });
+    return { kind: "create", dir: pack.dir, name: pack.name, note: a.description || "" };
+  }
+  return null;
+}
+
+function applyEntityAction(e) {
+  if (!e || typeof e !== "object" || !String(e.name || "").trim()) return null;
+  const { entity, created } = entities.upsertEntity({
+    name: e.name,
+    type: e.type,
+    aliases: Array.isArray(e.aliases) ? e.aliases.slice(0, 5) : [],
+    description: e.description,
+    notes: typeof e.notes === "string" ? e.notes : "",
+    log: e.log || "",
+  });
+  return { kind: created ? "create" : "update", slug: entity.slug, name: entity.name, type: entity.type, note: e.log || e.description || "" };
+}
+
+// Fire-and-forget. `announce` is an async (text) => void bound to the
+// originating channel; failures are logged, never thrown into the turn.
+function reviewTurn({ userText, assistantText, channelId, announce }) {
+  if (!enabled()) return;
+  const combined = (String(userText || "") + String(assistantText || "")).trim();
+  if (combined.length < MIN_TURN_CHARS) return;
+
+  const prompt = buildReviewPrompt(redactSensitive(String(userText || "")), redactSensitive(String(assistantText || "")));
+
+  spawnSubagent(prompt, {
+    model: REVIEW_MODEL,
+    channelId,
+    timeoutMs: 3 * 60 * 1000,
+    systemPrompt: "You are a background memory reviewer. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
+  }).then(({ text }) => {
+    const decision = parseDecision(text);
+    if (!decision || (decision.actions.length === 0 && decision.entities.length === 0)) return;
+    const lines = [];
+    for (const a of decision.actions) {
+      try {
+        const r = applyAction(a);
+        if (r) {
+          lines.push(r.kind === "create"
+            ? `New pack: ${r.name} — ${clip(r.note, 100)}`
+            : `Pack updated: ${r.name} — ${clip(r.note, 100)}`);
+        }
+      } catch (e) {
+        console.warn(`[pack-review] apply failed: ${e.message}`);
+      }
+    }
+    for (const ea of decision.entities) {
+      try {
+        const r = applyEntityAction(ea);
+        if (r) {
+          lines.push(r.kind === "create"
+            ? `New entity: ${r.name} (${r.type}) — ${clip(r.note, 100)}`
+            : `Entity noted: ${r.name} — ${clip(r.note, 100)}`);
+        }
+      } catch (e) {
+        console.warn(`[pack-review] entity apply failed: ${e.message}`);
+      }
+    }
+    if (lines.length > 0 && typeof announce === "function") {
+      announce(lines.join("\n")).catch(() => {});
+    }
+  }).catch((e) => {
+    console.warn(`[pack-review] reviewer failed: ${e.message}`);
+  });
+}
+
+module.exports = { reviewTurn, parseDecision, applyAction, applyEntityAction, buildReviewPrompt };

package/core/packs.js

@@ -0,0 +1,334 @@
+// Context packs: living per-topic documents that merge skills + memory.
+// Each pack is ~/.open-claudia/packs/<dir>/PACK.md with YAML-ish
+// frontmatter and four sections:
+//   ## Stance     — how to think about the topic (a topic-scoped sub-soul)
+//   ## Procedure  — how to do the thing (what skills used to be)
+//   ## State      — where we left off: decisions, open questions
+//   ## Journal    — dated recaps of past sessions, newest last
+// A pre-turn router FTS-matches the incoming message against packs and
+// injects hits into the user-message context block; a post-turn reviewer
+// (cheap model) mutates packs after each substantial turn.
+
+const fs = require("fs");
+const path = require("path");
+
+let DatabaseSync = null;
+try { ({ DatabaseSync } = require("node:sqlite")); } catch (e) { /* old node — matching disabled */ }
+
+const CONFIG_DIR = require("../config-dir");
+const PACKS_DIR = process.env.PACKS_DIR ? path.resolve(process.env.PACKS_DIR) : path.join(CONFIG_DIR, "packs");
+
+const SECTIONS = ["Stance", "Procedure", "State", "Journal"];
+const MAX_JOURNAL_ENTRIES = 30;
+
+function ensureDir() {
+  fs.mkdirSync(PACKS_DIR, { recursive: true, mode: 0o700 });
+}
+
+function slugify(name) {
+  return String(name || "").toLowerCase().trim()
+    .replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+
+function parseFrontmatter(content) {
+  const m = String(content || "").match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return { fm: {}, body: String(content || "") };
+  const fm = {};
+  for (const line of m[1].split("\n")) {
+    const kv = line.match(/^([a-z_]+):\s*(.*)$/);
+    if (kv) fm[kv[1]] = kv[2].trim().replace(/^["']|["']$/g, "");
+  }
+  return { fm, body: content.slice(m[0].length).replace(/^\n+/, "") };
+}
+
+function parseSections(body) {
+  const out = { Stance: "", Procedure: "", State: "", Journal: "" };
+  let current = null;
+  const pre = [];
+  for (const line of String(body || "").split("\n")) {
+    const h = line.match(/^##\s+(Stance|Procedure|State|Journal)\s*$/i);
+    if (h) {
+      current = SECTIONS.find((s) => s.toLowerCase() === h[1].toLowerCase());
+      continue;
+    }
+    if (current) out[current] += line + "\n";
+    else pre.push(line);
+  }
+  for (const s of SECTIONS) out[s] = out[s].trim();
+  return { sections: out, preamble: pre.join("\n").trim() };
+}
+
+function serialize(pack) {
+  const fmLines = [
+    "---",
+    `name: ${pack.name}`,
+    `description: ${pack.description || ""}`,
+    `tags: ${(pack.tags || []).join(", ")}`,
+  ];
+  if (pack.parent) fmLines.push(`parent: ${pack.parent}`);
+  fmLines.push(
+    `created: ${pack.created || new Date().toISOString()}`,
+    `updated: ${pack.updated || new Date().toISOString()}`,
+    `last_used: ${pack.last_used || ""}`,
+    "---",
+  );
+  const sections = SECTIONS
+    .map((s) => `## ${s}\n\n${(pack.sections?.[s] || "").trim()}`)
+    .join("\n\n");
+  return fmLines.join("\n") + "\n\n" + sections + "\n";
+}
+
+function packFile(dir) {
+  return path.join(PACKS_DIR, dir, "PACK.md");
+}
+
+function readPack(dir) {
+  let content;
+  try { content = fs.readFileSync(packFile(dir), "utf-8"); }
+  catch (e) { return null; }
+  const { fm, body } = parseFrontmatter(content);
+  const { sections } = parseSections(body);
+  let stat = null;
+  try { stat = fs.statSync(packFile(dir)); } catch (e) {}
+  return {
+    dir,
+    name: fm.name || dir,
+    description: fm.description || "",
+    tags: (fm.tags || "").split(",").map((t) => t.trim()).filter(Boolean),
+    parent: fm.parent || null,
+    created: fm.created || "",
+    updated: fm.updated || (stat ? stat.mtime.toISOString() : ""),
+    last_used: fm.last_used || "",
+    sections,
+  };
+}
+
+function listPacks() {
+  let entries;
+  try { entries = fs.readdirSync(PACKS_DIR); } catch (e) { return []; }
+  const packs = [];
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    try { if (!fs.statSync(path.join(PACKS_DIR, name)).isDirectory()) continue; }
+    catch (e) { continue; }
+    const p = readPack(name);
+    if (p) packs.push(p);
+  }
+  packs.sort((a, b) => a.dir.localeCompare(b.dir));
+  return packs;
+}
+
+function findPack(nameOrDir) {
+  const needle = String(nameOrDir || "").trim().toLowerCase();
+  if (!needle) return null;
+  return listPacks().find((p) => p.dir.toLowerCase() === needle || p.name.toLowerCase() === needle) || null;
+}
+
+function writePack(pack) {
+  ensureDir();
+  const dir = path.join(PACKS_DIR, pack.dir);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(packFile(pack.dir), serialize(pack), { mode: 0o600 });
+  markIndexDirty();
+  return pack.dir;
+}
+
+function createPack({ dir, name, description, tags, stance, procedure, state, journal, parent }) {
+  const d = slugify(dir || name);
+  if (!d) throw new Error("pack needs a name");
+  if (readPack(d)) throw new Error(`pack ${d} already exists`);
+  const pack = {
+    dir: d,
+    name: name || d,
+    description: description || "",
+    tags: Array.isArray(tags) ? tags : [],
+    parent: parent || null,
+    created: new Date().toISOString(),
+    sections: {
+      Stance: stance || "",
+      Procedure: procedure || "",
+      State: state || "",
+      Journal: journal ? `- [${today()}] ${journal}` : "",
+    },
+  };
+  writePack(pack);
+  return pack;
+}
+
+function today() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+// Apply a reviewer mutation. Only supplied fields change; journal entries
+// append (capped); state replaces (it represents "current truth").
+function updatePack(dir, { description, tags, stance, procedure, state, journal } = {}) {
+  const pack = readPack(dir);
+  if (!pack) throw new Error(`no pack: ${dir}`);
+  pack.updated = new Date().toISOString();
+  if (description) pack.description = description;
+  if (Array.isArray(tags) && tags.length) pack.tags = tags;
+  if (typeof stance === "string" && stance.trim()) pack.sections.Stance = stance.trim();
+  if (typeof procedure === "string" && procedure.trim()) pack.sections.Procedure = procedure.trim();
+  if (typeof state === "string" && state.trim()) pack.sections.State = state.trim();
+  if (typeof journal === "string" && journal.trim()) {
+    const entries = pack.sections.Journal.split("\n").filter((l) => l.trim());
+    entries.push(`- [${today()}] ${journal.trim().replace(/\n+/g, " ")}`);
+    pack.sections.Journal = entries.slice(-MAX_JOURNAL_ENTRIES).join("\n");
+  }
+  writePack(pack);
+  return pack;
+}
+
+function removePack(nameOrDir) {
+  const pack = findPack(nameOrDir);
+  if (!pack) return null;
+  fs.rmSync(path.join(PACKS_DIR, pack.dir), { recursive: true, force: true });
+  markIndexDirty();
+  return pack;
+}
+
+function touchUsed(dirs) {
+  const now = new Date().toISOString();
+  for (const dir of [].concat(dirs || [])) {
+    const pack = readPack(dir);
+    if (!pack) continue;
+    pack.last_used = now;
+    try { writePack(pack); } catch (e) {}
+  }
+}
+
+// Recognise a Write/Edit aimed at a pack file (for chat announcements).
+function packNameFromPath(filePath) {
+  if (!filePath) return null;
+  const resolved = path.resolve(String(filePath));
+  const rel = path.relative(PACKS_DIR, resolved);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+  const parts = rel.split(path.sep);
+  if (parts.length !== 2 || parts[1] !== "PACK.md") return null;
+  return parts[0];
+}
+
+// ---------------------------------------------------------------------------
+// FTS matching. Packs are few and small, so the index is rebuilt from
+// scratch whenever any pack changes — no incremental bookkeeping.
+
+let _db = null;
+let _indexedAt = 0;
+let _dirty = true;
+
+function markIndexDirty() { _dirty = true; }
+
+function openDb() {
+  if (!DatabaseSync) return null;
+  if (_db) return _db;
+  try {
+    ensureDir();
+    const dbPath = path.join(PACKS_DIR, "index.db");
+    const db = new DatabaseSync(dbPath);
+    try { fs.chmodSync(dbPath, 0o600); } catch (e) {}
+    db.exec("PRAGMA journal_mode=WAL");
+    db.exec("PRAGMA busy_timeout=3000");
+    db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS packs USING fts5(
+      name, description, tags, content, dir UNINDEXED,
+      tokenize='porter unicode61'
+    )`);
+    _db = db;
+    return db;
+  } catch (e) {
+    return null;
+  }
+}
+
+function latestMtime() {
+  let latest = 0;
+  let names = [];
+  try { names = fs.readdirSync(PACKS_DIR); } catch (e) { return 0; }
+  for (const name of names) {
+    try {
+      const m = fs.statSync(packFile(name)).mtimeMs;
+      if (m > latest) latest = m;
+    } catch (e) {}
+  }
+  return latest;
+}
+
+function reindex() {
+  const db = openDb();
+  if (!db) return false;
+  const packs = listPacks();
+  db.exec("BEGIN");
+  try {
+    db.exec("DELETE FROM packs");
+    const insert = db.prepare("INSERT INTO packs (name, description, tags, content, dir) VALUES (?, ?, ?, ?, ?)");
+    for (const p of packs) {
+      const content = [p.sections.Stance, p.sections.Procedure, p.sections.State, p.sections.Journal].join("\n");
+      insert.run(p.name, p.description, p.tags.join(" "), content, p.dir);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    try { db.exec("ROLLBACK"); } catch (e2) {}
+    return false;
+  }
+  _dirty = false;
+  _indexedAt = Date.now();
+  return true;
+}
+
+function ensureIndex() {
+  if (_dirty || latestMtime() > _indexedAt) reindex();
+}
+
+const STOPWORDS = new Set(("a an and are as at be but by can did do for from had has have how i if in is it its " +
+  "me my no not of on or our so that the their then there this to up us was we what when where which who why " +
+  "will with you your yes yeah ok okay please thanks just like dont don't im i'm its it's").split(" "));
+
+function queryTerms(text) {
+  const seen = new Set();
+  const terms = [];
+  for (const raw of String(text || "").toLowerCase().split(/[^a-z0-9_.-]+/)) {
+    const t = raw.replace(/^[.-]+|[.-]+$/g, "");
+    if (t.length < 3 || STOPWORDS.has(t) || seen.has(t)) continue;
+    seen.add(t);
+    terms.push(t);
+    if (terms.length >= 40) break;
+  }
+  return terms;
+}
+
+// Match a free-text message against packs. BM25 is unusable here — with
+// a small corpus its IDF term collapses to ~0 — so score per term
+// instead: a hit in name/description/tags counts 2 (porter-stemmed via
+// FTS), a body-only hit counts 1; packs at/above the threshold win. A
+// single incidental body word (score 1) never drags a pack in.
+function matchPacks(text, { limit = 3, threshold = null } = {}) {
+  const db = openDb();
+  if (!db) return [];
+  ensureIndex();
+  const terms = queryTerms(text);
+  if (terms.length === 0) return [];
+  const minScore = threshold ?? Number(process.env.PACK_MATCH_THRESHOLD || 2);
+  const scores = new Map();
+  let stmt;
+  try { stmt = db.prepare("SELECT dir FROM packs WHERE packs MATCH ?"); } catch (e) { return []; }
+  for (const t of terms) {
+    const quoted = `"${t.replace(/"/g, '""')}"`;
+    let strong = [];
+    let any = [];
+    try { strong = stmt.all(`{name description tags} : ${quoted}`); } catch (e) {}
+    try { any = stmt.all(quoted); } catch (e) {}
+    const strongSet = new Set(strong.map((r) => r.dir));
+    for (const r of any) scores.set(r.dir, (scores.get(r.dir) || 0) + (strongSet.has(r.dir) ? 2 : 1));
+  }
+  const names = new Map(listPacks().map((p) => [p.dir, p.name]));
+  return [...scores.entries()]
+    .filter(([, s]) => s >= minScore)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, Math.max(1, Math.min(10, limit)))
+    .map(([dir, score]) => ({ dir, name: names.get(dir) || dir, score }));
+}
+
+module.exports = {
+  PACKS_DIR, SECTIONS, slugify,
+  listPacks, findPack, readPack, writePack, createPack, updatePack, removePack,
+  touchUsed, packNameFromPath, matchPacks, reindex, markIndexDirty,
+};

package/core/runner.js

@@ -25,6 +25,9 @@ const {
 const { getClaudeOAuthToken, claudeAuthRecoveryMessage, isClaudeAuthErrorText, claudeUsageLimitMessage, isClaudeUsageLimitText, runClaudeAuthStatusDiagnostic, claudeSubprocessEnv } = require("./auth-flow");
 const loopback = require("./loopback");
 const skillsLib = require("./skills");
+const packsLib = require("./packs");
+const entitiesLib = require("./entities");
+const packReview = require("./pack-review");
 
 function telegramHtmlOpts(extra = {}) {
   const adapter = currentAdapter();
@@ -500,7 +503,10 @@ async function runClaudeCapture(prompt, cwd, opts = {}) {
           if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
           saveState();
         }
-        if (evt.type === "result" && evt.result) assistantText = evt.result;
+        // evt.result only carries the FINAL text segment of the turn. Using it
+        // as anything but a fallback would clobber text streamed before tool
+        // calls (the "long reply, then tools, then short closing line" shape).
+        if (evt.type === "result" && evt.result && !assistantText.trim()) assistantText = evt.result;
       }
     });
     proc.stderr.on("data", (d) => { stderrBuffer += d.toString(); });
@@ -618,6 +624,18 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       }
       const filePath = input?.file_path || input?.filePath;
       if ((toolName === "Write" || toolName === "Edit") && filePath) {
+        const packDir = packsLib.packNameFromPath(filePath);
+        if (packDir) {
+          if (packsLib.readPack(packDir)) notifySkill(`pack:${packDir}`, `Updating pack: ${packDir}`);
+          else notifySkill(`pack:${packDir}`, `New pack: ${packDir} — open-claudia pack show ${packDir} to inspect.`);
+          return;
+        }
+        const entSlug = entitiesLib.entityNameFromPath(filePath);
+        if (entSlug) {
+          if (entitiesLib.readEntity(entSlug)) notifySkill(`entity:${entSlug}`, `Updating entity: ${entSlug}`);
+          else notifySkill(`entity:${entSlug}`, `New entity: ${entSlug} — open-claudia entity show ${entSlug} to inspect.`);
+          return;
+        }
         const dir = skillsLib.skillNameFromPath(filePath);
         if (!dir) return;
         // The tool_use event precedes the actual write, so existence now
@@ -803,7 +821,9 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
         saveState();
       }
-      if (evt.type === "result" && evt.result) assistantText = evt.result;
+      // Fallback only: evt.result is just the final text segment, and assigning
+      // it unconditionally wiped everything the model said before tool calls.
+      if (evt.type === "result" && evt.result && !assistantText.trim()) assistantText = evt.result;
     }
   });
 
@@ -877,6 +897,17 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     if (settings.budget) settings.budget = null;
     state.statusMessageId = null;
 
+    // Post-turn pack review: fire-and-forget on a cheap model; never
+    // blocks queue drain or the next turn.
+    if ((code === 0 || code === null) && assistantText.trim()) {
+      packReview.reviewTurn({
+        userText: prompt,
+        assistantText,
+        channelId,
+        announce: (text) => chatContext.run(store, () => send(text)),
+      });
+    }
+
     if (state.lastSessionId && state.currentSession) {
       const title = state.isFirstMessage ? (prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt) : null;
       recordSession(state.userId, state.currentSession.name, state.lastSessionId, title);

package/core/subagent.js

@@ -59,10 +59,11 @@ async function spawnSubagent(prompt, opts = {}) {
       "-p",
       "--output-format", opts.json ? "json" : "text",
       "--verbose",
-      "--append-system-prompt", buildSubagentSystemPrompt(role),
+      "--append-system-prompt", opts.systemPrompt || buildSubagentSystemPrompt(role),
       "--dangerously-skip-permissions",
-      prompt,
     ];
+    if (opts.model) args.push("--model", opts.model);
+    args.push(prompt);
     const env = { ...botSubprocessEnv(), ...claudeSubprocessEnv() };
     const proc = spawn(CLAUDE_PATH, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });