openmausbot 0.1.89 → 0.1.91

package/dist-server/server/memory-upkeep.js

@@ -0,0 +1,452 @@
+// Memory upkeep: the background half of a bot's memory. On for every bot
+// unless switched off (BotRecord.memoryUpkeep === false). The main agent
+// keeps reading and writing its notes as before; this adds what happens
+// without it choosing:
+//   - capture: finished 1:1 turns are read after the chat goes quiet; core
+//     facts go to MEMORY.md, detail to a topic file per subject that upkeep
+//     creates and names, with other words for it (server/memory-capture.ts);
+//   - About me: a durable fact about the person, from their own words, is
+//     added to the shared About me and listed in Settings with Remove
+//     (server/profile-learned.ts);
+//   - tidy-up: nightly, and on demand, expired entries are archived, exact
+//     duplicates merged (MEMORY.md and topic files) and contradictions in
+//     MEMORY.md struck (server/memory-tidy.ts).
+// Every memory write is a journal row with actor "upkeep", so the Memory
+// panel shows it and Undo works. The model steps need a one-shot text call
+// (`generateText`: Claude and the chat-completion engines); on any other
+// engine they are skipped and only the deterministic tidy steps run.
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "./atomic.js";
+import { DATA_DIR } from "./config.js";
+import { CaptureBuffer, capturePrompt, newCandidates, parseCandidates } from "./memory-capture.js";
+import { factIdentity, lineFactIdentity, notebookIdentities } from "./memory-entries.js";
+import { mergeTopicText } from "./memory-topics.js";
+import { applyMoves, MAX_MOVES, organizeCandidates, organizePrompt, parseMoves } from "./memory-organize.js";
+import { recordMemoryChange } from "./memory-journal.js";
+import { applyTidy, contradictionCandidates, contradictionPrompt, parseContradictions, planChanges, planTidy } from "./memory-tidy.js";
+import { ensureWorkspace, listMemoryTopics, memoryDate, memoryEntry, memoryTopicIndex, updateMemory, workspaceDir, writeMemoryFile, writeMemoryTopic } from "./workspace.js";
+export const CAPTURE_MAX_TURNS = 6;
+export const MODEL_TIMEOUT_MS = 60_000;
+export const TIDY_CHECK_MS = 10 * 60_000;
+/** Below this many live entries there is nothing a contradiction pass may change. */
+export const MIN_ENTRIES_FOR_CONTRADICTIONS = 5;
+export const ARCHIVE_TOPIC = "archive.md";
+/** A topic file past this size gains nothing more from capture. */
+export const TOPIC_MAX_BYTES = 64 * 1024;
+/** On unless switched off: every bot keeps its memory in shape by default. */
+export function upkeepEnabled(bot) {
+    return Boolean(bot) && bot.memoryUpkeep !== false;
+}
+/** How many "this entry is core" judgements are remembered per bot. */
+const MAX_CORE = 500;
+function statePath() {
+    return join(DATA_DIR, "memory-upkeep.json");
+}
+function loadState() {
+    try {
+        const parsed = JSON.parse(readFileSync(statePath(), "utf8"));
+        return parsed && typeof parsed.bots === "object" && parsed.bots ? parsed : { bots: {} };
+    }
+    catch {
+        return { bots: {} };
+    }
+}
+function saveState(state) {
+    try {
+        mkdirSync(DATA_DIR, { recursive: true, mode: 0o700 });
+        writeFileAtomic(statePath(), `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch {
+        // status is a convenience; losing it only means the tidy may run again
+    }
+}
+function readRaw(botId, relative) {
+    try {
+        return readFileSync(join(workspaceDir(botId), relative), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+async function askModel(engine, prompt) {
+    if (!engine.generateText)
+        return null;
+    const expiry = AbortSignal.timeout(MODEL_TIMEOUT_MS);
+    try {
+        const answer = await Promise.race([
+            engine.generateText(prompt, { signal: expiry }),
+            new Promise((_, reject) => expiry.addEventListener("abort", () => reject(new Error("timed out")), { once: true })),
+        ]);
+        return typeof answer === "string" ? answer : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const NO_TEXT_ENGINE = "This bot's engine cannot make the quick background model call upkeep uses, so only expired notes and exact duplicates are tidied.";
+export function createMemoryUpkeep(deps) {
+    const now = () => deps.now?.() ?? new Date();
+    const log = (line) => deps.log?.(line);
+    const inflight = new Set();
+    const tidying = new Map();
+    let timer = null;
+    let paused = false;
+    const deferred = [];
+    const record = (botId, patch) => {
+        const state = loadState();
+        state.bots[botId] = { ...state.bots[botId], ...patch };
+        saveState(state);
+    };
+    const track = (promise) => {
+        inflight.add(promise);
+        void promise.finally(() => inflight.delete(promise)).catch(() => undefined);
+        return promise;
+    };
+    async function capture(batch) {
+        const bot = deps.bot(batch.botId);
+        const at = now().getTime();
+        const off = { at, added: 0, topics: 0, aboutMe: 0, note: "upkeep is off" };
+        if (!upkeepEnabled(bot))
+            return off;
+        const engine = deps.engine(bot.id);
+        if (!engine?.generateText) {
+            const report = { at, added: 0, topics: 0, aboutMe: 0, note: NO_TEXT_ENGINE };
+            record(bot.id, { lastCapture: report });
+            return report;
+        }
+        ensureWorkspace(bot.id);
+        const today = memoryDate(now());
+        const answer = await askModel(engine, capturePrompt({
+            botName: bot.name,
+            turns: batch.turns,
+            notebook: readRaw(bot.id, "MEMORY.md") ?? "",
+            today,
+            topics: memoryTopicIndex(bot.id),
+        }));
+        if (answer === null) {
+            const report = { at, added: 0, topics: 0, aboutMe: 0, note: "The capture call did not answer in time." };
+            record(bot.id, { lastCapture: report });
+            return report;
+        }
+        if (paused) {
+            // a backup began while the model answered: run it again after
+            deferred.push(batch);
+            return { at, added: 0, topics: 0, aboutMe: 0, note: "deferred until the backup finishes" };
+        }
+        // Re-read after the await: the bot or the person may have written since.
+        // From here to the journal rows there is no await, so no write interleaves.
+        if (!upkeepEnabled(deps.bot(bot.id)))
+            return off;
+        const before = readRaw(bot.id, "MEMORY.md");
+        const parsed = parseCandidates(answer, today);
+        const fresh = newCandidates(parsed, before ?? "");
+        const source = `${deps.sourceLabel(bot.id, batch.threadId)} (noticed)`;
+        let added = 0;
+        let full = false;
+        const byTopic = new Map();
+        for (const candidate of fresh) {
+            if (candidate.topic) {
+                byTopic.set(candidate.topic, [...(byTopic.get(candidate.topic) ?? []), candidate]);
+                continue;
+            }
+            const result = updateMemory(bot.id, { action: "append", text: candidate.text, ...(candidate.until ? { until: candidate.until } : {}) }, { source, now: now() });
+            if (result.ok)
+                added += 1;
+            else if (result.code === "over-budget")
+                full = true;
+        }
+        if (added)
+            recordMemoryChange(bot.id, { path: "MEMORY.md", actor: "upkeep", via: "capture", threadId: batch.threadId, before, after: readRaw(bot.id, "MEMORY.md") });
+        // Detail goes to a topic file the bot keeps for that subject, created
+        // with a header (title and other words for it) the first time.
+        const existing = new Map(listMemoryTopics(bot.id).map((topic) => [topic.name.toLowerCase(), topic.name]));
+        let topics = 0;
+        for (const [wanted, candidates] of byTopic) {
+            const name = existing.get(wanted) ?? wanted;
+            const path = `memory/${name}`;
+            const current = readRaw(bot.id, path);
+            if (current !== null && Buffer.byteLength(current, "utf8") > TOPIC_MAX_BYTES)
+                continue;
+            const seen = notebookIdentities(current ?? "");
+            const lines = candidates
+                .filter((candidate) => !seen.has(factIdentity(candidate.text)))
+                .map((candidate) => memoryEntry(candidate.text, { source, now: now(), ...(candidate.until ? { until: candidate.until } : {}) }));
+            if (!lines.length)
+                continue;
+            const title = name.replace(/\.md$/, "").replace(/-/g, " ");
+            const aliases = [...new Set(candidates.flatMap((candidate) => candidate.topicAliases ?? []))];
+            try {
+                writeMemoryTopic(bot.id, name, mergeTopicText(current, { title, aliases, lines }));
+            }
+            catch {
+                continue;
+            }
+            recordMemoryChange(bot.id, { path, actor: "upkeep", via: "capture", threadId: batch.threadId, before: current, after: readRaw(bot.id, path) });
+            existing.set(name.toLowerCase(), name);
+            topics += lines.length;
+        }
+        // Only the owner's own words reach About me: on a shared workspace
+        // another person's facts are not the owner's profile. Every parsed fact
+        // counts, not only new ones — the bot may already have noted it in its
+        // own memory, and About me is where every other bot learns it.
+        const owner = batch.turns.every((turn) => turn.owner !== false);
+        const aboutMe = owner ? deps.addToAboutMe({ botId: bot.id, botName: bot.name }, parsed.filter((c) => c.aboutUser).map((c) => c.text)) : 0;
+        // whoever wrote MEMORY.md — the bot, the person or this capture — detail
+        // that is not core moves to its topic now, not only at night
+        const organized = await organize(bot.id);
+        const report = { at, added, topics, aboutMe, organized, ...(full ? { note: "MEMORY.md is full; the tidy-up or a person needs to make room." } : {}) };
+        record(bot.id, { lastCapture: report });
+        if (added || topics || aboutMe)
+            log(`memory upkeep: noticed ${added} fact(s) for MEMORY.md, ${topics} for topic files and ${aboutMe} for About me — ${bot.name} (${bot.id}) from ${batch.threadId}`);
+        return report;
+    }
+    const buffer = new CaptureBuffer({
+        quietMs: deps.quietMs,
+        maxTurns: CAPTURE_MAX_TURNS,
+        onFlush: (batch) => {
+            if (paused) {
+                deferred.push(batch);
+                return;
+            }
+            void track(capture(batch)).catch((error) => log(`memory upkeep: capture failed for ${batch.botId}: ${error.message}`));
+        },
+    });
+    /** Move MEMORY.md entries that are not core into their topic files. One
+     * model call over entries not judged before; lines move unchanged, topics
+     * first so undoing the newest row (MEMORY.md) never loses one. */
+    async function organize(botId) {
+        const engine = deps.engine(botId);
+        if (!engine?.generateText)
+            return 0;
+        const today = memoryDate(now());
+        const state = loadState();
+        const core = new Set(state.bots[botId]?.core ?? []);
+        const first = readRaw(botId, "MEMORY.md") ?? "";
+        const candidates = organizeCandidates(first, today, core);
+        if (!candidates.length)
+            return 0;
+        const answer = await askModel(engine, organizePrompt(candidates, memoryTopicIndex(botId)));
+        if (answer === null || paused || !upkeepEnabled(deps.bot(botId)))
+            return 0;
+        // the line numbers are the file's as read; a write since means ask again later
+        const before = readRaw(botId, "MEMORY.md") ?? "";
+        if (before !== first)
+            return 0;
+        const proposed = parseMoves(answer, candidates);
+        if (proposed === null)
+            return 0;
+        // Deferred moves are not core: let the next pass reconsider them.
+        const moved = new Set(proposed.map((move) => move.entry.line));
+        const moves = proposed.slice(0, MAX_MOVES);
+        const judgedCore = candidates.filter((entry) => !moved.has(entry.line)).map((entry) => factIdentity(entry.body));
+        const saved = loadState();
+        saved.bots[botId] = { ...saved.bots[botId], core: [...new Set([...(saved.bots[botId]?.core ?? []), ...judgedCore])].slice(-MAX_CORE) };
+        saveState(saved);
+        if (!moves.length)
+            return 0;
+        const { byTopic } = applyMoves(before, moves);
+        const written = new Set();
+        const existing = new Map(listMemoryTopics(botId).map((topic) => [topic.name.toLowerCase(), topic.name]));
+        let count = 0;
+        for (const [wanted, group] of byTopic) {
+            const name = existing.get(wanted) ?? wanted;
+            const path = `memory/${name}`;
+            const current = readRaw(botId, path);
+            const seen = notebookIdentities(current ?? "");
+            const lines = group.lines.filter((line) => !seen.has(lineFactIdentity(line)));
+            if (lines.length) {
+                try {
+                    writeMemoryTopic(botId, name, mergeTopicText(current, { title: name.replace(/\.md$/, "").replace(/-/g, " "), aliases: group.aliases, lines }));
+                }
+                catch (error) {
+                    log(`memory upkeep: could not write ${path}; kept its entries in MEMORY.md: ${error.message}`);
+                    continue;
+                }
+                recordMemoryChange(botId, { path, actor: "upkeep", via: "organize", before: current, after: readRaw(botId, path) });
+            }
+            existing.set(name.toLowerCase(), name);
+            written.add(wanted);
+            count += group.lines.length;
+        }
+        if (!written.size)
+            return 0;
+        const { text } = applyMoves(before, moves.filter((move) => written.has(move.topic)));
+        writeMemoryFile(botId, text);
+        recordMemoryChange(botId, { path: "MEMORY.md", actor: "upkeep", via: "organize", before, after: readRaw(botId, "MEMORY.md") });
+        log(`memory upkeep: moved ${count} entr${count === 1 ? "y" : "ies"} from MEMORY.md into topic files for ${deps.bot(botId)?.name ?? botId}`);
+        return count;
+    }
+    function appendArchive(botId, archived) {
+        const archivePath = `memory/${ARCHIVE_TOPIC}`;
+        const archiveBefore = readRaw(botId, archivePath);
+        const head = archiveBefore ?? "---\ntitle: Archive\ndescription: expired notes moved out by the tidy-up\n---\n";
+        writeMemoryTopic(botId, ARCHIVE_TOPIC, `${head}${head.endsWith("\n") ? "" : "\n"}${archived.join("\n")}\n`);
+        recordMemoryChange(botId, { path: archivePath, actor: "upkeep", via: "tidy", before: archiveBefore, after: readRaw(botId, archivePath) });
+    }
+    async function runTidy(botId) {
+        const bot = deps.bot(botId);
+        const at = now().getTime();
+        const today = memoryDate(now());
+        const stopped = { at, expired: 0, duplicates: 0, superseded: 0, deferred: 0, contradictionsChecked: false, note: "Memory upkeep is off or paused; no further changes were made." };
+        if (paused || !upkeepEnabled(bot))
+            return stopped;
+        ensureWorkspace(botId);
+        const organized = await organize(botId);
+        if (paused || !upkeepEnabled(deps.bot(botId)))
+            return stopped;
+        const first = readRaw(botId, "MEMORY.md") ?? "";
+        const engine = deps.engine(botId);
+        const candidates = contradictionCandidates(first, today);
+        let contradictions = [];
+        let contradictionsChecked = false;
+        let note;
+        if (!engine?.generateText)
+            note = NO_TEXT_ENGINE;
+        else if (candidates.length < MIN_ENTRIES_FOR_CONTRADICTIONS)
+            note = `Contradictions are checked from ${MIN_ENTRIES_FOR_CONTRADICTIONS} notes on.`;
+        else {
+            const answer = await askModel(engine, contradictionPrompt(candidates));
+            if (answer === null)
+                note = "The contradiction check did not answer in time.";
+            else {
+                contradictions = parseContradictions(answer, candidates.length);
+                contradictionsChecked = true;
+            }
+        }
+        if (paused || !upkeepEnabled(deps.bot(botId)))
+            return stopped;
+        // Re-read after the await. If the notes changed meanwhile, the model's
+        // line numbers no longer point at the same facts: keep only the
+        // deterministic steps this time.
+        const before = readRaw(botId, "MEMORY.md") ?? "";
+        if (before !== first && contradictions.length) {
+            contradictions = [];
+            note = "The notes changed during the check; contradictions wait for the next tidy-up.";
+        }
+        const plan = planTidy(before, today, contradictions);
+        if (planChanges(plan)) {
+            const { text, archived } = applyTidy(before, plan, today);
+            // The archive is written first: a line is never out of MEMORY.md
+            // before it is in the archive, and the newest journal row — the one a
+            // person undoes — is MEMORY.md, whose undo brings the line back.
+            if (archived.length)
+                appendArchive(botId, archived);
+            writeMemoryFile(botId, text);
+            recordMemoryChange(botId, { path: "MEMORY.md", actor: "upkeep", via: "tidy", before, after: readRaw(botId, "MEMORY.md") });
+        }
+        // Topic files get the two steps that need no model: expired lines to the
+        // archive (written first, as above) and exact duplicates merged.
+        let topicExpired = 0;
+        let topicDuplicates = 0;
+        for (const topic of listMemoryTopics(botId)) {
+            if (topic.name === ARCHIVE_TOPIC)
+                continue;
+            const path = `memory/${topic.name}`;
+            const topicBefore = readRaw(botId, path);
+            if (topicBefore === null)
+                continue;
+            const topicPlan = planTidy(topicBefore, today);
+            if (!planChanges(topicPlan))
+                continue;
+            const tidied = applyTidy(topicBefore, topicPlan, today);
+            if (tidied.archived.length)
+                appendArchive(botId, tidied.archived);
+            writeMemoryTopic(botId, topic.name, tidied.text);
+            recordMemoryChange(botId, { path, actor: "upkeep", via: "tidy", before: topicBefore, after: readRaw(botId, path) });
+            topicExpired += topicPlan.expired.length;
+            topicDuplicates += topicPlan.duplicates.length;
+        }
+        const report = {
+            at,
+            expired: plan.expired.length + topicExpired,
+            duplicates: plan.duplicates.length + topicDuplicates,
+            superseded: plan.superseded.length,
+            deferred: plan.deferred,
+            ...(organized ? { organized } : {}),
+            contradictionsChecked,
+            ...(note ? { note } : {}),
+        };
+        record(botId, { lastTidy: report });
+        if (report.expired || report.duplicates || report.superseded || organized)
+            log(`memory upkeep: tidied ${bot?.name ?? botId} — ${report.expired} expired, ${report.duplicates} duplicate(s), ${report.superseded} contradicted`);
+        return report;
+    }
+    function tidy(botId) {
+        const running = tidying.get(botId);
+        if (running)
+            return running;
+        const promise = track(runTidy(botId)).finally(() => tidying.delete(botId));
+        tidying.set(botId, promise);
+        return promise;
+    }
+    function due(botId) {
+        const current = now();
+        if (current.getHours() < deps.tidyHour())
+            return false;
+        const last = loadState().bots[botId]?.lastTidy?.at;
+        return !last || memoryDate(new Date(last)) < memoryDate(current);
+    }
+    async function tick() {
+        if (paused)
+            return;
+        for (const bot of deps.bots()) {
+            if (paused)
+                return;
+            if (!upkeepEnabled(bot) || deps.busy(bot.id) || !due(bot.id))
+                continue;
+            try {
+                await tidy(bot.id);
+            }
+            catch (error) {
+                log(`memory upkeep: tidy failed for ${bot.id}: ${error.message}`);
+            }
+        }
+    }
+    return {
+        noteTurn(botId, threadId, turn) {
+            if (!upkeepEnabled(deps.bot(botId)))
+                return;
+            if (!turn.person.trim() && !turn.bot.trim())
+                return;
+            buffer.add(botId, threadId, turn);
+        },
+        flushThread: (threadId) => buffer.flush(threadId),
+        dropBot: (botId) => buffer.dropBot(botId),
+        capture: (batch) => track(capture(batch)),
+        tidy,
+        status(botId) {
+            // the core judgements are upkeep's own bookkeeping, not status
+            const { lastTidy, lastCapture } = loadState().bots[botId] ?? {};
+            return { ...(lastTidy ? { lastTidy } : {}), ...(lastCapture ? { lastCapture } : {}), modelSteps: Boolean(deps.engine(botId)?.generateText) };
+        },
+        tick,
+        start() {
+            if (timer)
+                return;
+            timer = setInterval(() => void tick(), TIDY_CHECK_MS);
+            timer.unref?.();
+            // a first pass shortly after start catches a night the computer slept through
+            const first = setTimeout(() => void tick(), 60_000);
+            first.unref?.();
+        },
+        stop() {
+            if (timer)
+                clearInterval(timer);
+            timer = null;
+        },
+        pause() {
+            paused = true;
+        },
+        resume() {
+            paused = false;
+            for (const batch of deferred.splice(0)) {
+                void track(capture(batch)).catch((error) => log(`memory upkeep: capture failed for ${batch.botId}: ${error.message}`));
+            }
+        },
+        async idle() {
+            while (inflight.size)
+                await Promise.allSettled(inflight);
+        },
+    };
+}

package/dist-server/server/message-db.js

@@ -475,7 +475,7 @@ const STOP_WORDS = new Set("a an and are as at be by did do for from had has hav
  * whitespace-separated token becomes a quoted string, so `AND`, `NOT`,
  * `*`, `:`, and stray quotes are searched for rather than interpreted.
  * Tokens are ANDed — FTS5's default — so a hit contains all of them. */
-function ftsQuery(query) {
+function ftsQuery(query, mode = "all") {
     const tokens = query
         .split(/\s+/)
         .map((token) => token.replace(/"/g, "").trim())
@@ -483,8 +483,49 @@ function ftsQuery(query) {
     if (!tokens.length)
         return null;
     const content = tokens.filter((token) => !STOP_WORDS.has(token.toLowerCase()));
+    if (mode === "any") {
+        // Automatic recall searches with a whole message: any content word may
+        // match, ranked by bm25. Punctuation-only tokens are dropped, since a
+        // lone "?" or "—" would match nothing useful. No content word, no query.
+        const terms = recallTerms(query).map(recallMatchTerm).filter(Boolean);
+        return terms.length ? terms.join(" OR ") : null;
+    }
     return (content.length ? content : tokens).map((token) => `"${token}"`).join(" ");
 }
+/** One recall term as FTS5 syntax. The index does no stemming, so a word
+ * of four or more letters matches as a prefix, with a plural -s taken off
+ * first: "restaurant" and "restaurants" find each other. Skip punctuation
+ * terms: unicode61 cannot distinguish "-10" from "10" or "c++" from "c",
+ * even in a quoted FTS phrase. Explicit all-term search stays unchanged. */
+export function recallMatchTerm(term) {
+    if (!/^[\p{L}\p{N}]+$/u.test(term))
+        return null;
+    if (!/^\p{L}{4,}$/u.test(term))
+        return `"${term}"`;
+    const stem = term.length > 4 && term.endsWith("s") && !term.endsWith("ss") ? term.slice(0, -1) : term;
+    return `"${stem}"*`;
+}
+/** Words that go at the end of a question and say nothing about its topic. */
+const RECALL_FILLER = new Set("about again also any anything can could does don't know me my please remember remind should tell there they us would hi hello hey thanks thank ok okay yes yeah no i'm im i've i'll i'd you're quick just".split(" "));
+/** The content words of a message, for an any-term recall: lower-cased,
+ * de-duplicated, stop words and filler dropped. Ordinary separators between
+ * letters split words; signs, language symbols and versions (`-10`, `c++`,
+ * `v2.1`) survive as written rather than matching a different fact. */
+export function recallTerms(query) {
+    const out = [];
+    for (const raw of query.split(/\s+|(?<=\p{L})[/,;:.—–-]+(?=\p{L})/u)) {
+        const token = raw.replace(/"/g, "").replace(/^[\s.,;:!?()[\]{}'`“”‘’]+|[\s.,;:!?()[\]{}'`“”‘’]+$/g, "").toLowerCase();
+        if (token.length < 2 && !/\d/.test(token))
+            continue;
+        if (!/[\p{L}\p{N}]/u.test(token))
+            continue;
+        if (STOP_WORDS.has(token) || RECALL_FILLER.has(token))
+            continue;
+        if (!out.includes(token))
+            out.push(token);
+    }
+    return out.slice(0, 16);
+}
 /** How much of a matched message rides back in a hit. Wide enough that a
  * short report reads whole; a longer one is fetched with readMessageText. */
 const SNIPPET_TOKENS = 48;
@@ -523,8 +564,8 @@ function rangeClause(range, column) {
     }
     return { sql: parts.map((part) => ` AND ${part}`).join(""), params };
 }
-export function recallMessages(query, threadIds, limit = 12, range) {
-    const match = ftsQuery(query);
+export function recallMessages(query, threadIds, limit = 12, range, mode = "all") {
+    const match = ftsQuery(query, mode);
     if (!match || !threadIds.length)
         return [];
     const placeholders = threadIds.map(() => "?").join(", ");
@@ -632,8 +673,8 @@ export function indexedMemoryFiles(botId) {
 /** Relevance-ranked recall over ONE bot's memory files. Scoped by bot id
  * in SQL, the same way recallMessages scopes by thread: another bot's
  * memory is not a lower-ranked result, it is not a result. */
-export function recallMemory(query, botId, limit = 12) {
-    const match = ftsQuery(query);
+export function recallMemory(query, botId, limit = 12, mode = "all") {
+    const match = ftsQuery(query, mode);
     if (!match)
         return [];
     const rows = db()
@@ -641,6 +682,9 @@ export function recallMemory(query, botId, limit = 12) {
         `snippet(memory_fts, 0, '[', ']', '…', ${SNIPPET_TOKENS}) AS snippet ` +
         "FROM memory_fts JOIN memory_files f ON f.rowid = memory_fts.rowid " +
         "WHERE memory_fts MATCH ? AND f.bot_id = ? " +
+        // Automatic recall must filter before LIMIT; historical logs can
+        // otherwise crowd all current topic files out of the result set.
+        (mode === "any" ? "AND f.path NOT IN ('MEMORY.md', 'memory/archive.md') AND f.path NOT LIKE 'memory/log/%' " : "") +
         "ORDER BY bm25(memory_fts), f.mtime_ms DESC LIMIT ?")
         // SAFETY: the SELECT names exactly these three columns; snippet() is never null
         .all(match, botId, limit);

package/dist-server/server/model-context-window.js

@@ -6,10 +6,10 @@ export function modelContextWindow(model) {
     if (!model)
         return undefined;
     const id = model.toLowerCase();
-    // Opus 5.5 is 1M without a `[1m]` suffix. Only the exact slug, or that
-    // slug after a slash or a provider dot. A longer suffix such as
-    // `claude-opus-5-5-local` stays on the generic Claude rule, as does `host::`.
-    if (/(?:^|[/.])claude-opus-5(?:-5|\.5)$/.test(id))
+    // Opus 5.5 and Sonnet 5.5 are 1M without a `[1m]` suffix. Only the exact
+    // slug, or that slug after a slash or a provider dot. A longer suffix such
+    // as `claude-sonnet-5-5-local` stays on the generic Claude rule, as does `host::`.
+    if (/(?:^|[/.])claude-(?:opus|sonnet)-5(?:-5|\.5)$/.test(id))
         return 1_000_000;
     if (/claude/.test(id) || /^(opus|sonnet|haiku|fable)\b/.test(id))
         return /\[1m\]|-1m\b|1m-context/.test(id) ? 1_000_000 : 200_000;

package/dist-server/server/package-export.js

@@ -15,6 +15,21 @@ function portableKey(value, fallback, used) {
     used.add(key);
     return key;
 }
+/** A room's responder in package terms. An Auto room is written as its lead
+ * (its fallback, else its first exported member): that is how it behaves on
+ * any install without the decision model, and every older app can read it,
+ * where a new `auto` kind would make them refuse the whole package. */
+function packageRoomResponder(responder, keys, members) {
+    if (responder.kind === "member" && keys.has(responder.botId))
+        return { kind: "agent", agent: keys.get(responder.botId) };
+    if (responder.kind === "everyone")
+        return { kind: "everyone" };
+    if (responder.kind === "auto") {
+        const lead = responder.fallbackBotId ? keys.get(responder.fallbackBotId) : undefined;
+        return { kind: "agent", agent: lead ?? members[0] };
+    }
+    return { kind: "mentions" };
+}
 function samePlaybook(a, b) {
     return a.name === b.name && a.summary === b.summary && a.instructions === b.instructions &&
         a.triggers.join("\n") === b.triggers.join("\n");
@@ -122,11 +137,7 @@ export function createBotPackageExport(input) {
         const members = group.memberIds.flatMap((id) => idToKey.has(id) ? [idToKey.get(id)] : []);
         if (!members.length)
             continue;
-        const defaultResponder = group.defaultResponder.kind === "member" && idToKey.has(group.defaultResponder.botId)
-            ? { kind: "agent", agent: idToKey.get(group.defaultResponder.botId) }
-            : group.defaultResponder.kind === "everyone"
-                ? { kind: "everyone" }
-                : { kind: "mentions" };
+        const defaultResponder = packageRoomResponder(group.defaultResponder, idToKey, members);
         rooms.push({
             key: portableKey(group.name, `room-${index + 1}`, roomKeys),
             name: group.name,
@@ -587,11 +598,7 @@ export function createTeamPackageExport(input) {
         const members = group.memberIds.flatMap((id) => botKeys.has(id) ? [botKeys.get(id)] : []);
         if (!members.length)
             continue;
-        const defaultResponder = group.defaultResponder.kind === "member" && botKeys.has(group.defaultResponder.botId)
-            ? { kind: "agent", agent: botKeys.get(group.defaultResponder.botId) }
-            : group.defaultResponder.kind === "everyone"
-                ? { kind: "everyone" }
-                : { kind: "mentions" };
+        const defaultResponder = packageRoomResponder(group.defaultResponder, botKeys, members);
         const key = roomKeys.get(group.id);
         rooms.push({ key, name: group.name, members, ...(group.bulletin ? { bulletin: group.bulletin } : {}), defaultResponder });
         roomMembers.set(group.id, new Set(members));

package/dist-server/server/package-import.js

@@ -318,9 +318,12 @@ function runImport(source, options, deps) {
             const ids = room.members.map((key) => botIds.get(key));
             let created = store.createGroup(room.name, ids, false, section);
             createdGroups.push(created);
-            const defaultResponder = room.defaultResponder.kind === "agent"
-                ? { kind: "member", botId: botIds.get(room.defaultResponder.agent) }
-                : { kind: room.defaultResponder.kind };
+            const responder = room.defaultResponder;
+            const defaultResponder = responder.kind === "agent"
+                ? { kind: "member", botId: botIds.get(responder.agent) }
+                : responder.kind === "auto"
+                    ? { kind: "auto", ...(responder.agent ? { fallbackBotId: botIds.get(responder.agent) } : {}) }
+                    : { kind: responder.kind };
             created = store.patchGroup(created.id, {
                 bulletin: room.bulletin ?? "",
                 defaultResponder,

package/dist-server/server/package-parts.js

@@ -53,7 +53,9 @@ export const roomReleaseValues = (room) => ({
     members: [...room.members].sort(),
     defaultResponder: room.defaultResponder.kind === "agent"
         ? { kind: "agent", agent: room.defaultResponder.agent }
-        : { kind: room.defaultResponder.kind },
+        : room.defaultResponder.kind === "auto" && room.defaultResponder.agent
+            ? { kind: "auto", agent: room.defaultResponder.agent }
+            : { kind: room.defaultResponder.kind },
 });
 /** One normal form for a routine's timing on both sides, so an untouched
  * routine compares equal: absent cap → null, absent overlap → "skip". */

package/dist-server/server/permission-proxy.js

@@ -14,7 +14,7 @@
 // CLI's own AskUserQuestion. It is the tool the model actually reaches for
 // when it wants a person to choose, and acceptEdits will not run it unasked,
 // so it lands here looking like "may I run a tool?" — which is how a question
-// ended up on screen as an Allow/Deny box over a JSON blob. It is intercepted
+// ended up on screen as an Allow/Deny dialog over a JSON blob. It is intercepted
 // below and asked as what it is: one card carrying every question it posed,
 // answered through the tool's own `answers` field.
 //
@@ -89,8 +89,8 @@ const asRecord = (value) => typeof value === "object" && value !== null && !Arra
  *
  * There is deliberately no "fall through to the permission path" here. That
  * path cannot answer this tool — allowing it throws the click away, as
- * above — so the fallback offered a person an Allow/Deny box over raw JSON.
- * That box is the bug this file exists to remove.
+ * above — so the fallback offered a person an Allow/Deny dialog over raw JSON.
+ * That dialog is the bug this file exists to remove.
  */
 async function answerNativeQuestions(input) {
     // Unanswerable entries are SKIPPED by the parser, not fatal: one bad entry