@audiofool/moondog 0.1.0 → 0.2.0-beta.3

package/src/memory/local-memory-store.mjs

@@ -3,7 +3,7 @@ import { chmod, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
-export const MOONDOG_MEMORY_SCHEMA_VERSION = 2;
+export const MOONDOG_MEMORY_SCHEMA_VERSION = 3;
 export function resolveMoondogMemoryPath(environment = process.env) {
   const configuredState = environment.MOONDOG_STATE_HOME?.trim();
   if (configuredState) {
@@ -92,6 +92,53 @@ const schema = `
   CREATE INDEX IF NOT EXISTS turns_session_position
     ON turns(session_id, position);
 
+  -- Display/model conversation history is separate from memory and reflection.
+  -- It contains no raw tool calls or reusable action authority.
+  CREATE TABLE IF NOT EXISTS conversation_entries (
+    entry_id TEXT PRIMARY KEY NOT NULL,
+    session_id TEXT NOT NULL REFERENCES sessions(session_id),
+    position INTEGER NOT NULL,
+    user_text TEXT NOT NULL,
+    assistant_text TEXT NOT NULL DEFAULT '',
+    outcome TEXT NOT NULL CHECK (outcome IN ('running', 'completed', 'aborted', 'interrupted', 'failed')),
+    transient INTEGER NOT NULL DEFAULT 0 CHECK (transient IN (0, 1)),
+    created_at TEXT NOT NULL,
+    UNIQUE (session_id, position)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS conversation_branches (
+    session_id TEXT PRIMARY KEY NOT NULL REFERENCES sessions(session_id),
+    root_session_id TEXT NOT NULL REFERENCES sessions(session_id),
+    parent_session_id TEXT REFERENCES sessions(session_id),
+    source_entry_id TEXT,
+    draft TEXT NOT NULL DEFAULT '',
+    queued_json TEXT NOT NULL DEFAULT '[]'
+  ) STRICT;
+
+  -- Additive tables keep the schema version, so older cores still open this database.
+  CREATE TABLE IF NOT EXISTS conversation_folders (
+    folder_id TEXT PRIMARY KEY NOT NULL,
+    name TEXT NOT NULL,
+    position INTEGER NOT NULL,
+    created_at TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS conversation_labels (
+    session_id TEXT PRIMARY KEY NOT NULL REFERENCES sessions(session_id),
+    title TEXT,
+    pinned_at TEXT,
+    folder_id TEXT REFERENCES conversation_folders(folder_id)
+  ) STRICT;
+
+  -- The process writing each running reply, so the terminal and the App answer one message at a
+  -- time in the conversation they share, and a reply left by a process that died blocks nothing.
+  -- No foreign key: an older core deletes conversations without knowing this table.
+  CREATE TABLE IF NOT EXISTS conversation_writers (
+    entry_id TEXT PRIMARY KEY NOT NULL,
+    session_id TEXT NOT NULL,
+    pid INTEGER NOT NULL
+  ) STRICT;
+
   CREATE TABLE IF NOT EXISTS memory_claims (
     memory_id TEXT PRIMARY KEY NOT NULL,
     kind TEXT NOT NULL CHECK (kind IN ('fact', 'preference', 'constraint', 'goal')),
@@ -218,6 +265,62 @@ function cleanText(value, maximum, label) {
   return Array.from(cleaned).slice(0, maximum).join("");
 }
 
+export function normalizeMemoryContent(value) {
+  return cleanText(value, 2_000, "Memory");
+}
+
+function cleanSessionId(value) {
+  if (typeof value !== "string" || !value || value.length > 128) {
+    throw new TypeError("Session ID is invalid");
+  }
+  return value;
+}
+
+// A partial patch: a missing key keeps its value, and a null or empty title clears it.
+// The in-memory conversations reuse this, so both paths accept the same input.
+export function normalizeConversationLabel(patch) {
+  if (!patch || typeof patch !== "object" || Array.isArray(patch) ||
+      Object.keys(patch).some((key) => !["title", "pinned", "folderId"].includes(key))) {
+    throw new TypeError("Conversation label is invalid");
+  }
+  const label = {};
+  if (patch.title !== undefined) {
+    label.title = patch.title === null || (typeof patch.title === "string" && !patch.title.trim())
+      ? null : cleanText(patch.title, 160, "Conversation title");
+  }
+  if (patch.pinned !== undefined) {
+    if (typeof patch.pinned !== "boolean") throw new TypeError("Conversation pin is invalid");
+    label.pinned = patch.pinned;
+  }
+  if (patch.folderId !== undefined) {
+    label.folderId = patch.folderId === null ? null : cleanText(patch.folderId, 128, "Folder ID");
+  }
+  return label;
+}
+
+// The first message stands in for a conversation's name until it has one. A long one is cut, at a space when
+// that keeps most of it, so the list never shows a whole paragraph. Text without spaces is cut where it stands.
+export function shortConversationTitle(text, limit = 60) {
+  const flat = String(text ?? "").replace(/\s+/gu, " ").trim();
+  const characters = Array.from(flat);
+  if (characters.length <= limit) return flat;
+  const cut = characters.slice(0, limit - 1).join("");
+  const space = cut.lastIndexOf(" ");
+  const head = space >= cut.length * 0.6 ? cut.slice(0, space) : cut;
+  return `${head.replace(/[\s.,;:!?\-…、。，；：！？]+$/u, "")}…`;
+}
+
+export function normalizeConversationFolder({ folderId, name, position } = {}) {
+  if (position !== undefined && (!Number.isSafeInteger(position) || position < 0)) {
+    throw new TypeError("Folder position is invalid");
+  }
+  return {
+    folderId: folderId === undefined || folderId === null ? null : cleanText(folderId, 128, "Folder ID"),
+    name: cleanText(name, 80, "Folder name"),
+    position,
+  };
+}
+
 function cleanKind(value) {
   const kind = value ?? "fact";
   if (!memoryKinds.has(kind)) throw new TypeError("Memory kind is invalid");
@@ -469,8 +572,31 @@ function normalized(value) {
   return value.normalize("NFKC").toLocaleLowerCase("en-US");
 }
 
+// Memories the listener saved themselves: with remember, /remember or the desktop app, or by
+// asking Moondog in conversation, where the host checks the words against their message.
+const listenerSavedOrigins = ["explicit_user", "agent_from_explicit_user_statement"];
+
+// Text cut to `maximum` characters, ending in an ellipsis when it was cut.
+function clipped(value, maximum) {
+  const characters = Array.from(value);
+  return characters.length > maximum ? `${characters.slice(0, maximum).join("").trimEnd()}…` : value;
+}
+
+// Common English words that would recall unrelated memories on their own.
+const stopwords = new Set(`about after again all also am an and any are as at be been but by can could
+  did do does don for from get had has have he her here him his how if in into is it its just let like
+  me more most my no not now of on one or our out please really she so some than that the their them
+  then there these they this those to too up us very was we were what when where which who why will
+  with would you your`.split(/\s+/u));
+const cjkScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const cjkScripts = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+/gu;
+// A word without a plural "s", so "record" and "records" find each other.
+const singular = (word) => (word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word);
+
+// Search terms in a query: Han bigrams, and whole words elsewhere. No query gives null, which
+// matches everything; a query of only common words gives no terms, which matches nothing.
 function queryTerms(value) {
-  if (typeof value !== "string") return [];
+  if (typeof value !== "string" || !value.trim()) return null;
   const text = normalized(value);
   const segments = text.match(/\p{Script=Han}+|[\p{L}\p{N}]+/gu) ?? [];
   const terms = [];
@@ -481,18 +607,21 @@ function queryTerms(value) {
       for (let index = 0; index < characters.length - 1; index += 1) {
         terms.push(`${characters[index]}${characters[index + 1]}`);
       }
-    } else if (Array.from(segment).length >= 2) {
-      terms.push(segment);
+    } else if (Array.from(segment).length >= 2 && !stopwords.has(segment)) {
+      terms.push(cjkScript.test(segment) ? segment : singular(segment));
     }
   }
   return [...new Set(terms)].slice(0, 24);
 }
 
+// CJK terms match inside the text, since those scripts do not space words; other terms match
+// whole words only, plural or not, so "me" no longer recalls "named".
 function relevanceScore(memory, terms) {
-  if (terms.length === 0) return 0;
+  if (!terms?.length) return 0;
   const content = normalized(memory.content);
+  const words = new Set((content.replace(cjkScripts, " ").match(/[\p{L}\p{N}]+/gu) ?? []).map(singular));
   return terms.reduce(
-    (score, term) => score + (content.includes(term) ? term.length : 0),
+    (score, term) => score + ((cjkScript.test(term) ? content.includes(term) : words.has(term)) ? term.length : 0),
     0,
   );
 }
@@ -501,16 +630,30 @@ export class LocalMemoryStore {
   #database;
   #clock;
   #closed = false;
+  #processId;
 
-  constructor(database, { clock = () => new Date() } = {}) {
+  constructor(database, { clock = () => new Date(), processId = process.pid } = {}) {
     this.#database = database;
     this.#clock = clock;
+    this.#processId = processId;
   }
 
   #assertOpen() {
     if (this.#closed) throw new Error("Memory store is closed");
   }
 
+  // The reply another running Moondog process is writing in this conversation, if any.
+  #replyElsewhere(sessionId) {
+    const running = (pid) => {
+      try { process.kill(pid, 0); return true; } catch (error) { return error.code === "EPERM"; }
+    };
+    const row = this.#database.prepare(`SELECT e.entry_id, e.user_text, e.assistant_text, w.pid
+      FROM conversation_entries e JOIN conversation_writers w ON w.entry_id = e.entry_id
+      WHERE e.session_id = ? AND e.outcome = 'running' AND w.pid != ?`).all(sessionId, this.#processId)
+      .find((candidate) => running(candidate.pid));
+    return row ? { entry_id: row.entry_id, user_text: row.user_text, assistant_text: row.assistant_text } : null;
+  }
+
   #insertEpisode({
     episodeId = randomUUID(),
     sessionId,
@@ -607,6 +750,16 @@ export class LocalMemoryStore {
         timestamp,
         timestamp,
       );
+    // Saving again what the memory agent drew from talk makes it the listener's own.
+    if (inserted.changes === 0 && listenerSavedOrigins.includes(mutation.origin)) {
+      this.#database
+        .prepare(`
+          UPDATE memory_claims SET origin = ?
+          WHERE status = 'active' AND normalized_content = ?
+            AND origin NOT IN (${listenerSavedOrigins.map(() => "?").join(", ")})
+        `)
+        .run(mutation.origin, mutation.normalizedContent, ...listenerSavedOrigins);
+    }
     const row = this.#database
       .prepare(`
         SELECT *
@@ -814,6 +967,27 @@ export class LocalMemoryStore {
     return existing ?? this.startSession({ routeKey: route });
   }
 
+  // The conversation opened last on the route, by this process or another. The terminal and
+  // the App both show this one.
+  activeSession(routeKey = "local:main") {
+    this.#assertOpen();
+    const route = cleanText(routeKey, 128, "Session route");
+    const row = this.#database.prepare("SELECT session_id, route_key, started_at FROM sessions WHERE route_key = ? AND status = 'active'")
+      .get(route);
+    return row ? { ...row } : null;
+  }
+
+  replyElsewhere(sessionId) {
+    this.#assertOpen();
+    return this.#replyElsewhere(sessionId);
+  }
+
+  latestConversationEntryId(sessionId) {
+    this.#assertOpen();
+    return this.#database.prepare("SELECT entry_id FROM conversation_entries WHERE session_id = ? ORDER BY position DESC LIMIT 1")
+      .get(sessionId)?.entry_id ?? null;
+  }
+
   listSessions({ routeKey = "local:main", limit = 200 } = {}) {
     this.#assertOpen();
     const route = cleanText(routeKey, 128, "Session route");
@@ -821,42 +995,191 @@ export class LocalMemoryStore {
     const bounded = Number.isFinite(requestedLimit)
       ? Math.max(1, Math.min(Math.trunc(requestedLimit), 200))
       : 200;
-    return this.#database
-      .prepare(`
-        SELECT
-          s.session_id,
-          s.started_at,
-          MAX(t.created_at) AS updated_at,
-          COUNT(t.turn_id) AS turn_count,
-          COALESCE((
-            SELECT first_turn.content
-            FROM turns first_turn
-            WHERE first_turn.session_id = s.session_id AND first_turn.role = 'user'
-            ORDER BY first_turn.position ASC
-            LIMIT 1
-          ), '') AS title
-        FROM sessions s
-        JOIN turns t ON t.session_id = s.session_id
-        WHERE s.route_key = ?
-        GROUP BY s.session_id
-        ORDER BY updated_at DESC, s.started_at DESC, s.rowid DESC
-        LIMIT ?
-      `)
-      .all(route, bounded)
-      .map((session) => ({
-        session_id: session.session_id,
-        started_at: session.started_at,
-        updated_at: session.updated_at,
-        turn_count: session.turn_count,
-        title: session.title,
-      }));
+    return this.#database.prepare(`
+      SELECT s.session_id, s.started_at,
+        MAX(s.started_at, COALESCE((SELECT MAX(created_at) FROM conversation_entries WHERE session_id = s.session_id),
+          (SELECT MAX(created_at) FROM turns WHERE session_id = s.session_id), s.started_at)) AS updated_at,
+        CASE WHEN EXISTS (SELECT 1 FROM conversation_entries WHERE session_id = s.session_id)
+          THEN (SELECT SUM(1 + (assistant_text != '')) FROM conversation_entries WHERE session_id = s.session_id)
+          ELSE (SELECT COUNT(*) FROM turns WHERE session_id = s.session_id) END AS turn_count,
+        l.title AS label_title,
+        COALESCE((SELECT user_text FROM conversation_entries WHERE session_id = s.session_id ORDER BY position LIMIT 1),
+          (SELECT content FROM turns WHERE session_id = s.session_id AND role = 'user' ORDER BY position LIMIT 1),
+          b.draft, '') AS first_text,
+        l.title IS NOT NULL AS custom_title, l.pinned_at, l.folder_id,
+        b.parent_session_id,
+        CASE WHEN b.parent_session_id IS NOT NULL AND l.title IS NULL THEN
+          (SELECT title FROM conversation_labels WHERE session_id = b.root_session_id) END AS lineage_label,
+        CASE WHEN b.parent_session_id IS NOT NULL AND l.title IS NULL THEN COALESCE(
+          (SELECT user_text FROM conversation_entries WHERE session_id = b.root_session_id ORDER BY position LIMIT 1),
+          (SELECT content FROM turns WHERE session_id = b.root_session_id AND role = 'user' ORDER BY position LIMIT 1)) END AS lineage_first,
+        CASE WHEN b.parent_session_id IS NOT NULL AND l.title IS NULL THEN (SELECT COUNT(*) FROM conversation_branches r
+          JOIN sessions rs ON rs.session_id = r.session_id WHERE r.root_session_id = b.root_session_id
+            AND (rs.started_at < s.started_at OR (rs.started_at = s.started_at AND rs.rowid <= s.rowid))) END AS lineage_number,
+        COALESCE(NULLIF(b.draft, ''), (SELECT user_text FROM conversation_entries WHERE session_id = s.session_id ORDER BY position DESC LIMIT 1), '') AS last_message
+      FROM sessions s LEFT JOIN conversation_branches b ON b.session_id = s.session_id
+        LEFT JOIN conversation_labels l ON l.session_id = s.session_id
+      WHERE s.route_key = ? AND (
+        EXISTS (SELECT 1 FROM conversation_entries WHERE session_id = s.session_id) OR
+        EXISTS (SELECT 1 FROM turns WHERE session_id = s.session_id) OR b.draft != '')
+      ORDER BY l.pinned_at IS NULL, updated_at DESC, s.started_at DESC, s.rowid DESC LIMIT ?
+    `).all(route, bounded).map(row => {
+      // An unnamed conversation shows its first message, cut short.
+      const title = row.label_title ?? shortConversationTitle(row.first_text);
+      // A branch starts with its parent's first message, so an unnamed one would share its parent's title.
+      // It shows its lineage's title and its place in that lineage instead, "Late night #2"; a name the
+      // listener gives it replaces both.
+      const lineage = row.lineage_label || shortConversationTitle(row.lineage_first) || title;
+      return {
+        session_id: row.session_id, started_at: row.started_at, updated_at: row.updated_at,
+        turn_count: row.turn_count, title: row.lineage_number ? `${lineage} #${row.lineage_number}` : title,
+        custom_title: row.custom_title === 1, pinned_at: row.pinned_at ?? null, folder_id: row.folder_id ?? null,
+        ...(row.parent_session_id ? { parent_session_id: row.parent_session_id, last_message: row.last_message } : {}),
+      };
+    });
+  }
+
+  // The first message and reply of a conversation the model may name: one with no name, no parent and
+  // exactly one finished reply. Null for any other, so each conversation is named at most once.
+  untitledConversationStart(sessionId, { routeKey = "local:main" } = {}) {
+    this.#assertOpen();
+    const id = cleanSessionId(sessionId);
+    const route = cleanText(routeKey, 128, "Session route");
+    const row = this.#database.prepare(`SELECT
+        (SELECT title FROM conversation_labels WHERE session_id = s.session_id) AS title,
+        (SELECT parent_session_id FROM conversation_branches WHERE session_id = s.session_id) AS parent_session_id,
+        (SELECT COUNT(*) FROM conversation_entries WHERE session_id = s.session_id AND outcome = 'completed' AND assistant_text != '') AS replies
+      FROM sessions s WHERE s.session_id = ? AND s.route_key = ?`).get(id, route);
+    if (!row || row.title !== null || row.parent_session_id || row.replies !== 1) return null;
+    const entry = this.#database.prepare(`SELECT user_text, assistant_text FROM conversation_entries
+      WHERE session_id = ? AND outcome = 'completed' AND assistant_text != '' LIMIT 1`).get(id);
+    return { user: entry.user_text, assistant: entry.assistant_text };
+  }
+
+  sessionExists(sessionId) {
+    this.#assertOpen();
+    return Boolean(this.#database.prepare("SELECT 1 FROM sessions WHERE session_id = ?").get(sessionId));
+  }
+
+  // With ifUntitled, a conversation that already has a name keeps it and this returns null: the model's
+  // name never replaces one the listener gave, even one given while the model was choosing.
+  labelConversation(sessionId, patch, { routeKey = "local:main", ifUntitled = false } = {}) {
+    this.#assertOpen();
+    const id = cleanSessionId(sessionId);
+    const route = cleanText(routeKey, 128, "Session route");
+    const label = normalizeConversationLabel(patch);
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      if (!this.#database.prepare("SELECT 1 FROM sessions WHERE session_id = ? AND route_key = ?").get(id, route)) {
+        throw new Error("Saved conversation not found for this route.");
+      }
+      if (label.folderId && !this.#database.prepare("SELECT 1 FROM conversation_folders WHERE folder_id = ?").get(label.folderId)) {
+        throw new Error("Conversation folder not found.");
+      }
+      const current = this.#database.prepare("SELECT title, pinned_at, folder_id FROM conversation_labels WHERE session_id = ?").get(id);
+      if (ifUntitled && (current?.title ?? null) !== null) {
+        this.#database.exec("COMMIT");
+        return null;
+      }
+      const next = {
+        title: label.title !== undefined ? label.title : current?.title ?? null,
+        // Pinning again keeps the first pin time.
+        pinned_at: label.pinned === undefined ? current?.pinned_at ?? null
+          : label.pinned ? current?.pinned_at ?? isoTimestamp(this.#clock) : null,
+        folder_id: label.folderId !== undefined ? label.folderId : current?.folder_id ?? null,
+      };
+      if (next.title === null && next.pinned_at === null && next.folder_id === null) {
+        this.#database.prepare("DELETE FROM conversation_labels WHERE session_id = ?").run(id);
+      } else {
+        this.#database.prepare(`INSERT INTO conversation_labels(session_id, title, pinned_at, folder_id) VALUES (?, ?, ?, ?)
+          ON CONFLICT(session_id) DO UPDATE SET title = excluded.title, pinned_at = excluded.pinned_at, folder_id = excluded.folder_id`)
+          .run(id, next.title, next.pinned_at, next.folder_id);
+      }
+      this.#database.exec("COMMIT");
+      return { session_id: id, ...next };
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+  }
+
+  listConversationFolders() {
+    this.#assertOpen();
+    return this.#database.prepare(`SELECT folder_id, name, position, created_at FROM conversation_folders
+      ORDER BY position, created_at, folder_id`).all().map(row => ({ ...row }));
+  }
+
+  // Without a folder ID this creates a folder; with one it renames or moves that folder.
+  saveConversationFolder(folder) {
+    this.#assertOpen();
+    const { folderId, name, position } = normalizeConversationFolder(folder);
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      let id = folderId;
+      if (id) {
+        const changed = this.#database.prepare("UPDATE conversation_folders SET name = ?, position = COALESCE(?, position) WHERE folder_id = ?")
+          .run(name, position ?? null, id);
+        if (changed.changes !== 1) throw new Error("Conversation folder not found.");
+      } else {
+        id = randomUUID();
+        const last = this.#database.prepare("SELECT MAX(position) AS position FROM conversation_folders").get().position;
+        this.#database.prepare("INSERT INTO conversation_folders(folder_id, name, position, created_at) VALUES (?, ?, ?, ?)")
+          .run(id, name, position ?? (last === null ? 0 : last + 1), isoTimestamp(this.#clock));
+      }
+      const row = this.#database.prepare("SELECT folder_id, name, position, created_at FROM conversation_folders WHERE folder_id = ?").get(id);
+      this.#database.exec("COMMIT");
+      return { ...row };
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+  }
+
+  // Deleting a folder keeps its conversations; they return to the unfiled list.
+  deleteConversationFolder(folderId) {
+    this.#assertOpen();
+    const id = cleanText(folderId, 128, "Folder ID");
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const unfiled = this.#database.prepare("UPDATE conversation_labels SET folder_id = NULL WHERE folder_id = ?").run(id).changes;
+      this.#database.prepare("DELETE FROM conversation_labels WHERE title IS NULL AND pinned_at IS NULL AND folder_id IS NULL").run();
+      const deleted = this.#database.prepare("DELETE FROM conversation_folders WHERE folder_id = ?").run(id).changes === 1;
+      this.#database.exec("COMMIT");
+      return { deleted, folder_id: id, unfiled };
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+  }
+
+  // Removes one conversation and its transcript but keeps durable memories, so a
+  // preference stated in it still holds. Its branches stay, re-parented and re-rooted.
+  deleteConversation(sessionId, { routeKey = "local:main" } = {}) {
+    this.#assertOpen();
+    const id = cleanSessionId(sessionId);
+    const route = cleanText(routeKey, 128, "Session route");
+    const run = (sql, ...values) => this.#database.prepare(sql).run(...values).changes;
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const session = this.#database.prepare("SELECT status FROM sessions WHERE session_id = ? AND route_key = ?").get(id, route);
+      if (!session) throw new Error("Saved conversation not found for this route.");
+      // The terminal and the App both show the active one, and a reply may still run in another one.
+      if (session.status === "active" || this.#replyElsewhere(id)) throw new Error("This conversation is open in another Moondog window or terminal.");
+      // Foreign keys are checked at once, so every reference to the session goes before its row.
+      const parent = this.#database.prepare("SELECT parent_session_id FROM conversation_branches WHERE session_id = ?").get(id)?.parent_session_id ?? null;
+      const reparented = run("UPDATE conversation_branches SET parent_session_id = ? WHERE parent_session_id = ?", parent, id);
+      const heir = this.#database.prepare(`SELECT b.session_id FROM conversation_branches b JOIN sessions s ON s.session_id = b.session_id
+        WHERE b.root_session_id = ? AND b.session_id != ? ORDER BY s.started_at, s.rowid LIMIT 1`).get(id, id)?.session_id;
+      if (heir) run("UPDATE conversation_branches SET root_session_id = ? WHERE root_session_id = ? AND session_id != ?", heir, id, id);
+      // Dialogue episodes hold the raw user text. With no session they would be recalled
+      // in every conversation, so they go; explicit memories and retractions stay.
+      run(`DELETE FROM claim_episode_refs WHERE episode_id IN
+        (SELECT episode_id FROM episodes WHERE session_id = ? AND kind = 'dialogue')`, id);
+      run("DELETE FROM episodes WHERE session_id = ? AND kind = 'dialogue'", id);
+      run("UPDATE episodes SET session_id = NULL WHERE session_id = ?", id);
+      run("UPDATE memory_claims SET source_session_id = NULL WHERE source_session_id = ?", id);
+      for (const table of ["conversation_labels", "conversation_writers", "conversation_entries", "turns", "conversation_branches", "sessions"]) {
+        run(`DELETE FROM ${table} WHERE session_id = ?`, id);
+      }
+      this.#database.exec("COMMIT");
+      return { deleted: true, session_id: id, reparented };
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
   }
 
   resumeSession(sessionId, { routeKey = "local:main" } = {}) {
     this.#assertOpen();
-    if (typeof sessionId !== "string" || !sessionId || sessionId.length > 128) {
-      throw new TypeError("Session ID is invalid");
-    }
+    cleanSessionId(sessionId);
     const route = cleanText(routeKey, 128, "Session route");
     this.#database.exec("BEGIN IMMEDIATE");
     try {
@@ -1030,6 +1353,24 @@ export class LocalMemoryStore {
     }
   }
 
+  commitMemoryMutations(memoryMutations) {
+    this.#assertOpen();
+    const timestamp = isoTimestamp(this.#clock);
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      const results = memoryMutations.map((mutation) => {
+        if (mutation?.type === "remember") return this.#applyPreparedRemember(mutation, { timestamp });
+        if (mutation?.type === "forget") return this.#applyPreparedForget(mutation, { timestamp });
+        throw new TypeError("Memory mutation is invalid");
+      });
+      this.#database.exec("COMMIT");
+      return results;
+    } catch (error) {
+      this.#database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+
   readSessionTurns(sessionId, { limit = 40 } = {}) {
     this.#assertOpen();
     const bounded = Math.max(1, Math.min(Number(limit) || 40, 100));
@@ -1050,6 +1391,118 @@ export class LocalMemoryStore {
       }));
   }
 
+  #ensureConversation(sessionId) {
+    const exists = this.#database.prepare("SELECT 1 FROM conversation_branches WHERE session_id = ?").get(sessionId);
+    if (exists) return;
+    this.#database.prepare(`INSERT INTO conversation_branches(session_id, root_session_id) VALUES (?, ?)`).run(sessionId, sessionId);
+    // Import only an old session's rendered text, never tool messages or plans.
+    const legacy = this.#database.prepare("SELECT * FROM turns WHERE session_id = ? ORDER BY position").all(sessionId);
+    const insert = this.#database.prepare(`INSERT INTO conversation_entries
+      (entry_id, session_id, position, user_text, assistant_text, outcome, transient, created_at)
+      VALUES (?, ?, ?, ?, ?, 'completed', 0, ?)`);
+    for (let index = 0, position = 1; index < legacy.length; index += 1) {
+      const user = legacy[index];
+      if (user.role !== 'user') continue;
+      const assistant = legacy[index + 1]?.role === 'assistant' ? legacy[++index].content : '';
+      insert.run(user.turn_id, sessionId, position++, user.content, assistant, user.created_at);
+    }
+  }
+
+  beginConversationEntry(sessionId, user) {
+    this.#assertOpen();
+    if (typeof user !== 'string' || !user.trim() || user.length > 8_000) throw new TypeError("Conversation input is invalid");
+    const text = user;
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      this.#ensureConversation(sessionId);
+      if (this.#replyElsewhere(sessionId)) {
+        throw Object.assign(new Error("Moondog is answering in this conversation in another window or terminal."), { code: "conversation_busy" });
+      }
+      const position = this.#database.prepare("SELECT COALESCE(MAX(position), 0) + 1 AS n FROM conversation_entries WHERE session_id = ?").get(sessionId).n;
+      const entryId = randomUUID();
+      this.#database.prepare(`INSERT INTO conversation_entries(entry_id, session_id, position, user_text, outcome, created_at)
+        VALUES (?, ?, ?, ?, 'running', ?)`).run(entryId, sessionId, position, text, isoTimestamp(this.#clock));
+      this.#database.prepare("INSERT INTO conversation_writers(entry_id, session_id, pid) VALUES (?, ?, ?)").run(entryId, sessionId, this.#processId);
+      this.#database.prepare("UPDATE conversation_branches SET draft = '' WHERE session_id = ?").run(sessionId);
+      this.#database.exec("COMMIT");
+      return entryId;
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+  }
+
+  finishConversationEntry(sessionId, entryId, { text = '', status = 'failed', transient = false } = {}) {
+    this.#assertOpen();
+    if (!['completed', 'aborted', 'interrupted', 'failed'].includes(status) || typeof text !== 'string' || text.length > 40_000) {
+      throw new TypeError("Conversation outcome is invalid");
+    }
+    this.#database.prepare("DELETE FROM conversation_writers WHERE entry_id = ?").run(entryId);
+    const changed = this.#database.prepare(`UPDATE conversation_entries SET assistant_text = ?, outcome = ?, transient = ?
+      WHERE session_id = ? AND entry_id = ? AND outcome = 'running'`).run(text, status, transient ? 1 : 0, sessionId, entryId);
+    if (changed.changes !== 1) throw new Error("Conversation turn is no longer active");
+  }
+
+  // The reply so far, so another Moondog window or terminal can show it while it grows.
+  showConversationProgress(sessionId, entryId, text) {
+    this.#assertOpen();
+    if (typeof text !== 'string') throw new TypeError("Conversation progress is invalid");
+    this.#database.prepare(`UPDATE conversation_entries SET assistant_text = ?
+      WHERE session_id = ? AND entry_id = ? AND outcome = 'running'`).run(text.slice(0, 40_000), sessionId, entryId);
+  }
+
+  readConversationEntries(sessionId, { limit = 200 } = {}) {
+    this.#assertOpen();
+    this.#database.exec("BEGIN IMMEDIATE");
+    try { this.#ensureConversation(sessionId); this.#database.exec("COMMIT"); }
+    catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+    const bounded = Math.max(1, Math.min(Math.trunc(Number(limit)) || 200, 500));
+    return this.#database.prepare(`SELECT entry_id, user_text, assistant_text, outcome, transient, created_at
+      FROM conversation_entries WHERE session_id = ? ORDER BY position DESC LIMIT ?`).all(sessionId, bounded).reverse()
+      .map(row => ({ ...row, transient: row.transient === 1 }));
+  }
+
+  conversationPending(sessionId, pending) {
+    this.#assertOpen();
+    if (pending !== undefined && (typeof pending?.draft !== 'string' || pending.draft.length > 8_000 ||
+        !Array.isArray(pending.queued) || pending.queued.length > 30 ||
+        pending.queued.some(text => typeof text !== 'string' || text.length > 8_000))) throw new TypeError("Conversation draft is invalid");
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      this.#ensureConversation(sessionId);
+      if (pending !== undefined) this.#database.prepare("UPDATE conversation_branches SET draft = ?, queued_json = ? WHERE session_id = ?")
+        .run(pending.draft, JSON.stringify(pending.queued), sessionId);
+      const row = this.#database.prepare("SELECT draft, queued_json FROM conversation_branches WHERE session_id = ?").get(sessionId);
+      this.#database.exec("COMMIT");
+      return { draft: row.draft, queued: JSON.parse(row.queued_json) };
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+  }
+
+  forkConversation(sessionId, entryId, { routeKey = 'local:main' } = {}) {
+    this.#assertOpen();
+    const route = cleanText(routeKey, 128, "Session route");
+    this.#database.exec("BEGIN IMMEDIATE");
+    try {
+      // Another window or terminal may have opened a conversation since this one; the branch still
+      // becomes the one both show.
+      const original = this.#database.prepare("SELECT * FROM sessions WHERE session_id = ? AND route_key = ?").get(sessionId, route);
+      if (!original) throw new Error("The selected conversation is no longer available");
+      this.#ensureConversation(sessionId);
+      const selected = this.#database.prepare("SELECT * FROM conversation_entries WHERE session_id = ? AND entry_id = ?").get(sessionId, entryId);
+      if (!selected) throw new Error("The selected turn is no longer available");
+      const root = this.#database.prepare("SELECT root_session_id FROM conversation_branches WHERE session_id = ?").get(sessionId).root_session_id;
+      const createdAt = isoTimestamp(this.#clock);
+      const nextId = randomUUID();
+      this.#database.prepare("UPDATE sessions SET status = 'closed', ended_at = ?, close_reason = 'rewind' WHERE route_key = ? AND status = 'active'").run(createdAt, route);
+      this.#database.prepare("INSERT INTO sessions(session_id, route_key, started_at, status) VALUES (?, ?, ?, 'active')").run(nextId, route, createdAt);
+      this.#database.prepare(`INSERT INTO conversation_branches(session_id, root_session_id, parent_session_id, source_entry_id, draft)
+        VALUES (?, ?, ?, ?, ?)`).run(nextId, root, sessionId, entryId, selected.user_text);
+      const prefix = this.#database.prepare("SELECT * FROM conversation_entries WHERE session_id = ? AND position < ? ORDER BY position").all(sessionId, selected.position);
+      const insert = this.#database.prepare(`INSERT INTO conversation_entries
+        (entry_id, session_id, position, user_text, assistant_text, outcome, transient, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+      for (const row of prefix) insert.run(randomUUID(), nextId, row.position, row.user_text, row.assistant_text, row.outcome, row.transient, row.created_at);
+      this.#database.exec("COMMIT");
+      return { session_id: nextId, route_key: route, started_at: createdAt, parent_session_id: sessionId, draft: selected.user_text };
+    } catch (error) { this.#database.exec("ROLLBACK"); throw error; }
+  }
+
   prepareRemember({
     text,
     kind = "fact",
@@ -1058,7 +1511,7 @@ export class LocalMemoryStore {
     sourceSessionId,
   }) {
     this.#assertOpen();
-    const content = cleanText(text, 2_000, "Memory");
+    const content = normalizeMemoryContent(text);
     const normalizedContent = normalized(content);
     const existing = this.#database
       .prepare(`
@@ -1511,7 +1964,7 @@ export class LocalMemoryStore {
     const terms = queryTerms(query);
     const ranked = rows
       .map((row) => ({ row, score: relevanceScore(row, terms) }))
-      .filter(({ score }) => terms.length === 0 || score > 0)
+      .filter(({ score }) => terms === null || score > 0)
       .sort(
         (left, right) =>
           right.score - left.score ||
@@ -1535,6 +1988,7 @@ export class LocalMemoryStore {
   recentEpisodes({
     query,
     excludeSessionId,
+    includeCurrentSession = false,
     limit = 12,
     now = this.#clock(),
   } = {}) {
@@ -1547,11 +2001,12 @@ export class LocalMemoryStore {
         FROM episodes
         WHERE status = 'active'
           AND (expires_at IS NULL OR expires_at > ?)
-          AND (session_id IS NULL OR session_id != COALESCE(?, ''))
+          AND (session_id IS NULL OR (session_id = ? AND ? = 1) OR COALESCE((SELECT root_session_id FROM conversation_branches b WHERE b.session_id = episodes.session_id), session_id)
+            != COALESCE((SELECT root_session_id FROM conversation_branches WHERE session_id = ?), ?, ''))
         ORDER BY occurred_at DESC, episode_id ASC
         LIMIT 256
       `)
-      .all(nowTimestamp, excludeSessionId ?? null);
+      .all(nowTimestamp, excludeSessionId ?? null, includeCurrentSession ? 1 : 0, excludeSessionId ?? null, excludeSessionId ?? null);
     const terms = queryTerms(query);
     return rows
       .map((row) => ({
@@ -1559,7 +2014,7 @@ export class LocalMemoryStore {
         score: relevanceScore({ content: row.summary }, terms),
       }))
       .filter(
-        ({ score }) => terms.length === 0 || score > 0,
+        ({ score }) => terms === null || score > 0,
       )
       .sort(
         (left, right) =>
@@ -1582,12 +2037,13 @@ export class LocalMemoryStore {
       .prepare(`
         SELECT s.session_id, s.started_at, s.ended_at
         FROM sessions s
-        WHERE s.session_id != COALESCE(?, '')
+        WHERE COALESCE((SELECT root_session_id FROM conversation_branches b WHERE b.session_id = s.session_id), s.session_id)
+          != COALESCE((SELECT root_session_id FROM conversation_branches WHERE session_id = ?), ?, '')
           AND EXISTS (SELECT 1 FROM turns t WHERE t.session_id = s.session_id)
         ORDER BY COALESCE(s.ended_at, s.started_at) DESC
         LIMIT ?
       `)
-      .all(excludeSessionId ?? null, boundedSessions);
+      .all(excludeSessionId ?? null, excludeSessionId ?? null, boundedSessions);
     const readTurns = this.#database.prepare(`
       SELECT role, content, created_at
       FROM turns
@@ -1610,29 +2066,50 @@ export class LocalMemoryStore {
     }));
   }
 
+  // What the agent reads on every model request, so it is kept short: no ids it cannot use,
+  // and earlier turns clipped.
   context({ query, currentSessionId } = {}) {
     this.#assertOpen();
-    const durableMemories = this.listMemories({ limit: 12 })
-      .filter((memory) => memory.kind !== "fact")
-      .slice(0, 6);
+    // Facts the memory agent drew from conversations come back only when a request is about
+    // them. A fact the listener saved themselves is something they want kept in mind, so it
+    // stays in view, in slots of its own so saved notes never push out a preference or a rule.
+    const latest = (filter, ...values) => this.#database.prepare(`SELECT * FROM memory_claims
+      WHERE status = 'active' AND ${filter} ORDER BY updated_at DESC, memory_id ASC LIMIT ?`).all(...values);
+    const durableMemories = [
+      ...latest("kind != 'fact'", 6),
+      ...latest(`kind = 'fact' AND origin IN (${listenerSavedOrigins.map(() => "?").join(", ")})`, ...listenerSavedOrigins, 4),
+    ].map(publicMemory);
     const durableIds = new Set(
       durableMemories.map((memory) => memory.memory_id),
     );
+    const memory = ({ memory_id, kind, horizon, text, created_at }) => ({ memory_id, kind, horizon, text, created_at });
     return {
-      durable_memories: durableMemories,
-      relevant_memories: this.listMemories({ limit: 8, query }).filter(
-        (memory) => !durableIds.has(memory.memory_id),
-      ),
+      durable_memories: durableMemories.map(memory),
+      relevant_memories: this.listMemories({ limit: 8, query })
+        .filter((candidate) => !durableIds.has(candidate.memory_id))
+        .map(memory),
       recent_episodes: this.recentEpisodes({
         query,
         excludeSessionId: currentSessionId,
         limit: 10,
-      }),
+      }).map((episode) => ({
+        kind: episode.kind,
+        summary: clipped(episode.summary, 400),
+        occurred_at: episode.occurred_at,
+        ...(episode.expires_at ? { expires_at: episode.expires_at } : {}),
+      })),
       recent_sessions: this.recentSessions({
         excludeSessionId: currentSessionId,
         limit: 2,
         turnsPerSession: 6,
-      }),
+      }).map((session) => ({
+        started_at: session.started_at,
+        ended_at: session.ended_at,
+        turns: session.turns.map((turn) => ({
+          ...turn,
+          text: clipped(turn.text, turn.role === "assistant" ? 600 : 400),
+        })),
+      })),
     };
   }
 
@@ -1663,6 +2140,13 @@ export class LocalMemoryStore {
     };
   }
 
+  // SQLite's count of commits made by other connections, such as another Moondog window or terminal.
+  // It changes when they write; this connection's own writes leave it alone.
+  dataVersion() {
+    this.#assertOpen();
+    return this.#database.prepare("PRAGMA data_version").get().data_version;
+  }
+
   close() {
     if (this.#closed) return;
     this.#closed = true;
@@ -1673,6 +2157,7 @@ export class LocalMemoryStore {
 export async function openLocalMemoryStore({
   databasePath = defaultMoondogMemoryPath,
   clock,
+  processId,
 } = {}) {
   const parent = path.dirname(path.resolve(databasePath));
   await mkdir(parent, { recursive: true, mode: 0o700 });
@@ -1687,7 +2172,7 @@ export async function openLocalMemoryStore({
     database.exec("PRAGMA trusted_schema = OFF");
     const currentVersion = database.prepare("PRAGMA user_version").get()
       .user_version;
-    if (![0, 1, MOONDOG_MEMORY_SCHEMA_VERSION].includes(currentVersion)) {
+    if (![0, 1, 2, MOONDOG_MEMORY_SCHEMA_VERSION].includes(currentVersion)) {
       throw new Error("Memory database schema is incompatible");
     }
     database.exec(schema);
@@ -1697,7 +2182,7 @@ export async function openLocalMemoryStore({
     if (process.platform !== "win32") {
       await chmod(path.resolve(databasePath), 0o600);
     }
-    return new LocalMemoryStore(database, { clock });
+    return new LocalMemoryStore(database, { clock, processId });
   } catch (error) {
     database.close();
     throw error;