talon-agent 5.26.1 → 5.26.3

package/src/storage/repositories/history-repo.ts

@@ -131,11 +131,19 @@ export function insertMany(
   });
 }
 
-/** Most-recent `limit` messages, in chronological order. */
-export function recent(chatId: string, limit: number): HistoryMessage[] {
+/**
+ * Most-recent `limit` messages, in chronological order. `floorId` is the
+ * chat's context-reset marker: only rows with a larger id are returned
+ * (0 = every row).
+ */
+export function recent(
+  chatId: string,
+  limit: number,
+  floorId = 0,
+): HistoryMessage[] {
   const rows = getDatabase()
     .prepare(historySql.recent)
-    .all(chatId, limit) as Row[];
+    .all(chatId, floorId, limit) as Row[];
   return rows.reverse().map(rowToMessage);
 }
 
@@ -147,10 +155,11 @@ export function recentBefore(
   chatId: string,
   beforeMsgId: number,
   limit: number,
+  floorId = 0,
 ): HistoryMessage[] {
   const rows = getDatabase()
     .prepare(historySql.recentBefore)
-    .all(chatId, beforeMsgId, limit) as Row[];
+    .all(chatId, beforeMsgId, floorId, limit) as Row[];
   return rows.reverse().map(rowToMessage);
 }
 
@@ -158,10 +167,11 @@ export function recentBeforeTime(
   chatId: string,
   beforeTs: number,
   limit: number,
+  floorId = 0,
 ): HistoryMessage[] {
   const rows = getDatabase()
     .prepare(historySql.recentBeforeTime)
-    .all(chatId, beforeTs, limit) as Row[];
+    .all(chatId, beforeTs, floorId, limit) as Row[];
   return rows.reverse().map(rowToMessage);
 }
 
@@ -173,8 +183,66 @@ export function setFilePath(
   getDatabase().prepare(historySql.setFilePath).run(filePath, chatId, msgId);
 }
 
-export function deleteChat(chatId: string): void {
-  getDatabase().prepare(historySql.deleteChat).run(chatId);
+/**
+ * Hard-delete a chat's rows and its state. Only the operator's explicit
+ * purge reaches this (history.ts purgeChatHistory). Returns rows deleted.
+ */
+export function purgeChat(chatId: string): number {
+  return inTransaction(() => {
+    const db = getDatabase();
+    const result = db.prepare(historySql.purgeChat).run(chatId) as {
+      changes: number | bigint;
+    };
+    db.prepare(historySql.purgeChatState).run(chatId);
+    return Number(result.changes);
+  });
+}
+
+/** A chat's soft-reset / soft-delete state. */
+export type ChatHistoryState = {
+  /** Rows with an id at or under this predate the last context reset. */
+  clearedThroughId: number;
+  clearedAt?: number;
+  hiddenAt?: number;
+};
+
+export function chatState(chatId: string): ChatHistoryState | undefined {
+  const row = getDatabase().prepare(historySql.chatState).get(chatId) as
+    | {
+        cleared_through_id: number;
+        cleared_at: number | null;
+        hidden_at: number | null;
+      }
+    | undefined;
+  if (!row) return undefined;
+  return {
+    clearedThroughId: row.cleared_through_id,
+    clearedAt: row.cleared_at ?? undefined,
+    hiddenAt: row.hidden_at ?? undefined,
+  };
+}
+
+export function markCleared(chatId: string, at: number): void {
+  getDatabase().prepare(historySql.markCleared).run(chatId, chatId, at);
+}
+
+export function markHidden(chatId: string, at: number): void {
+  getDatabase().prepare(historySql.markHidden).run(chatId, chatId, at, at);
+}
+
+export type HiddenChat = { chatId: string; hiddenAt: number; total: number };
+
+export function hiddenChats(): HiddenChat[] {
+  const rows = getDatabase().prepare(historySql.hiddenChats).all() as Array<{
+    chat_id: string;
+    hidden_at: number;
+    total: number;
+  }>;
+  return rows.map((r) => ({
+    chatId: r.chat_id,
+    hiddenAt: r.hidden_at,
+    total: r.total,
+  }));
 }
 
 /**

package/src/storage/sessions.ts

@@ -23,6 +23,7 @@ import { recordError } from "../util/watchdog.js";
 import { files } from "../util/paths.js";
 import { importLegacyJson } from "./legacy-import.js";
 import { dbErrorFields } from "./db.js";
+import { kvGet, kvSet } from "./kv.js";
 import * as repo from "./repositories/sessions-repo.js";
 
 export type {
@@ -534,18 +535,76 @@ function removeSessionRow(chatId: string): void {
   }
 }
 
+// ── Replaced-session archive ───────────────────────────────────────────────
+
+/** A backend session id a reset replaced — kept so it can be re-linked. */
+export type ArchivedSession = {
+  chatId: string;
+  sessionId: string;
+  /** Why the session was replaced ("reset", "backend-unavailable", …). */
+  reason: string;
+  /** When it was replaced (ms epoch). */
+  at: number;
+  turns: number;
+  lastModel?: string;
+  sessionName?: string;
+};
+
+const SESSION_ARCHIVE_KEY = "sessions.archive";
+/** Newest entries kept; the transcripts themselves stay on disk regardless. */
+const SESSION_ARCHIVE_MAX = 500;
+
+/**
+ * Remember a session id that is about to be dropped. A reset used to
+ * forget it outright, leaving the backend transcript on disk with nothing
+ * pointing at it; with the id kept, a chat reset by mistake (or by a boot
+ * reconcile) can be re-linked to its old conversation. Never throws.
+ */
+function archiveSessionId(entry: ArchivedSession): void {
+  try {
+    const prior = kvGet<ArchivedSession[]>(SESSION_ARCHIVE_KEY);
+    const list = Array.isArray(prior) ? prior : [];
+    list.push(entry);
+    kvSet(SESSION_ARCHIVE_KEY, list.slice(-SESSION_ARCHIVE_MAX));
+  } catch (err) {
+    logError("sessions", `Failed to archive session chat=${entry.chatId}`, err);
+  }
+}
+
+/** Archived (replaced) session ids, oldest first; one chat's when given. */
+export function getArchivedSessions(chatId?: string): ArchivedSession[] {
+  const list = kvGet<ArchivedSession[]>(SESSION_ARCHIVE_KEY);
+  if (!Array.isArray(list)) return [];
+  return chatId ? list.filter((e) => e.chatId === chatId) : list;
+}
+
 /**
  * Reset the chat's conversation state (backend session id, turns, usage)
  * while carrying its metrics forward. Resets fire on /new, model switches
  * and error recovery — none of which should erase the chat's accounting
  * history (that's what makes per-session metrics survive anything short
  * of deleting the chat). Use deleteSession() to drop the chat entirely.
+ *
+ * The replaced backend session id is archived (see getArchivedSessions),
+ * never just discarded. Talon's own chat history is untouched: clearing
+ * it is a separate, explicit call.
  */
-export function resetSession(chatId: string): void {
+export function resetSession(chatId: string, reason = "reset"): void {
   const session = cache.get(chatId);
   const turns = session?.turns ?? 0;
   const name = session?.sessionName;
   const metrics = session?.metrics;
+  if (session?.sessionId) {
+    archiveSessionId({
+      chatId,
+      sessionId: session.sessionId,
+      reason,
+      at: Date.now(),
+      turns,
+      ...(session.lastModel ? { lastModel: session.lastModel } : {}),
+      ...(name ? { sessionName: name } : {}),
+    });
+  }
   removeSessionRow(chatId);
   const hasHistory =
     metrics &&

package/src/storage/sql/history.sql

@@ -9,10 +9,13 @@ INSERT OR IGNORE INTO history_messages
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 
 -- name: recent
+-- The `id > ?` floor is the chat's context-reset marker (0 for none; see
+-- chatState below): rows at or under it stay stored and searchable but
+-- are no longer the chat's current conversation.
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
        timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
-WHERE chat_id = ? ORDER BY id DESC LIMIT ?
+WHERE chat_id = ? AND id > ? ORDER BY id DESC LIMIT ?
 
 -- name: recentBefore
 -- Scroll-back pagination: the window of messages strictly older than a
@@ -20,7 +23,7 @@ WHERE chat_id = ? ORDER BY id DESC LIMIT ?
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
        timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
-WHERE chat_id = ? AND msg_id < ? ORDER BY id DESC LIMIT ?
+WHERE chat_id = ? AND msg_id < ? AND id > ? ORDER BY id DESC LIMIT ?
 
 -- name: recentBeforeTime
 -- Time-cursor variant of recentBefore for the read_history `before` date
@@ -28,14 +31,52 @@ WHERE chat_id = ? AND msg_id < ? ORDER BY id DESC LIMIT ?
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
        timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
-WHERE chat_id = ? AND timestamp < ? ORDER BY id DESC LIMIT ?
+WHERE chat_id = ? AND timestamp < ? AND id > ? ORDER BY id DESC LIMIT ?
 
 -- name: setFilePath
 UPDATE history_messages SET file_path = ? WHERE chat_id = ? AND msg_id = ?
 
--- name: deleteChat
+-- name: purgeChat
+-- The ONLY statement that deletes history rows. Reached solely through the
+-- operator's explicit `talon history purge` (history.ts purgeChatHistory);
+-- resets, backend switches and chat deletion never delete rows.
 DELETE FROM history_messages WHERE chat_id = ?
 
+-- name: purgeChatState
+DELETE FROM history_chat_state WHERE chat_id = ?
+
+-- name: chatState
+SELECT cleared_through_id, cleared_at, hidden_at
+FROM history_chat_state WHERE chat_id = ?
+
+-- name: markCleared
+-- Soft reset: move the chat's context floor to its newest stored row. The
+-- rows stay; readers that build the bot's context skip everything at or
+-- under the floor. Parameters: chat_id, chat_id, cleared_at.
+INSERT INTO history_chat_state (chat_id, cleared_through_id, cleared_at)
+VALUES (?, (SELECT COALESCE(MAX(id), 0) FROM history_messages WHERE chat_id = ?), ?)
+ON CONFLICT(chat_id) DO UPDATE SET
+  cleared_through_id = excluded.cleared_through_id,
+  cleared_at = excluded.cleared_at
+
+-- name: markHidden
+-- Soft delete: a chat the user deleted is hidden (and its context floor
+-- moved, so a chat that reappears under the same id starts fresh). The
+-- rows stay. Parameters: chat_id, chat_id, cleared_at, hidden_at.
+INSERT INTO history_chat_state (chat_id, cleared_through_id, cleared_at, hidden_at)
+VALUES (?, (SELECT COALESCE(MAX(id), 0) FROM history_messages WHERE chat_id = ?), ?, ?)
+ON CONFLICT(chat_id) DO UPDATE SET
+  cleared_through_id = excluded.cleared_through_id,
+  cleared_at = excluded.cleared_at,
+  hidden_at = excluded.hidden_at
+
+-- name: hiddenChats
+SELECT s.chat_id, s.hidden_at,
+       (SELECT COUNT(*) FROM history_messages h WHERE h.chat_id = s.chat_id) AS total
+FROM history_chat_state s
+WHERE s.hidden_at IS NOT NULL
+ORDER BY s.hidden_at DESC
+
 -- name: searchFts
 -- The match param must already be a valid FTS5 expression
 -- (see history.ts ftsQuery).

package/src/storage/sql/schema.sql

@@ -52,6 +52,19 @@ CREATE TRIGGER IF NOT EXISTS history_au AFTER UPDATE OF text, sender_name ON his
   VALUES (new.id, new.text, new.sender_name);
 END;
 
+-- Per-chat history state. Chat history is never deleted by a reset, a
+-- backend switch or a chat deletion: a reset records a context floor
+-- (`cleared_through_id`, the newest history_messages.id at reset time) so
+-- the bot's context starts fresh after it while every row stays stored
+-- and searchable; deleting a chat in a client sets `hidden_at`. Only the
+-- operator's explicit `talon history purge` removes rows.
+CREATE TABLE IF NOT EXISTS history_chat_state (
+  chat_id            TEXT    PRIMARY KEY,
+  cleared_through_id INTEGER NOT NULL DEFAULT 0,
+  cleared_at         INTEGER,
+  hidden_at          INTEGER
+);
+
 -- Typed memory: one row per claim, with an FTS5 index over subject +
 -- text. Kinds are lifecycles, not labels (docs/memory-persona-plan.md
 -- §3.1): `directive` is durable human intent, `fact` is durable and

package/src/storage/sql/statements.generated.ts

@@ -57,6 +57,19 @@ CREATE TRIGGER IF NOT EXISTS history_au AFTER UPDATE OF text, sender_name ON his
   VALUES (new.id, new.text, new.sender_name);
 END;
 
+-- Per-chat history state. Chat history is never deleted by a reset, a
+-- backend switch or a chat deletion: a reset records a context floor
+-- (\`cleared_through_id\`, the newest history_messages.id at reset time) so
+-- the bot's context starts fresh after it while every row stays stored
+-- and searchable; deleting a chat in a client sets \`hidden_at\`. Only the
+-- operator's explicit \`talon history purge\` removes rows.
+CREATE TABLE IF NOT EXISTS history_chat_state (
+  chat_id            TEXT    PRIMARY KEY,
+  cleared_through_id INTEGER NOT NULL DEFAULT 0,
+  cleared_at         INTEGER,
+  hidden_at          INTEGER
+);
+
 -- Typed memory: one row per claim, with an FTS5 index over subject +
 -- text. Kinds are lifecycles, not labels (docs/memory-persona-plan.md
 -- §3.1): \`directive\` is durable human intent, \`fact\` is durable and
@@ -518,24 +531,55 @@ export const historySql = {
    reply_to_msg_id, timestamp, media_type, sticker_file_id, file_path,
    attachments)
 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  recent: `SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
+  recent: `-- The \`id > ?\` floor is the chat's context-reset marker (0 for none; see
+-- chatState below): rows at or under it stay stored and searchable but
+-- are no longer the chat's current conversation.
+SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
        timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
-WHERE chat_id = ? ORDER BY id DESC LIMIT ?`,
+WHERE chat_id = ? AND id > ? ORDER BY id DESC LIMIT ?`,
   recentBefore: `-- Scroll-back pagination: the window of messages strictly older than a
 -- given msg_id, newest-first (the repository reverses to chronological).
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
        timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
-WHERE chat_id = ? AND msg_id < ? ORDER BY id DESC LIMIT ?`,
+WHERE chat_id = ? AND msg_id < ? AND id > ? ORDER BY id DESC LIMIT ?`,
   recentBeforeTime: `-- Time-cursor variant of recentBefore for the read_history \`before\` date
 -- parameter: the newest \`limit\` messages strictly older than a timestamp.
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,
        timestamp, media_type, sticker_file_id, file_path, attachments
 FROM history_messages
-WHERE chat_id = ? AND timestamp < ? ORDER BY id DESC LIMIT ?`,
+WHERE chat_id = ? AND timestamp < ? AND id > ? ORDER BY id DESC LIMIT ?`,
   setFilePath: `UPDATE history_messages SET file_path = ? WHERE chat_id = ? AND msg_id = ?`,
-  deleteChat: `DELETE FROM history_messages WHERE chat_id = ?`,
+  purgeChat: `-- The ONLY statement that deletes history rows. Reached solely through the
+-- operator's explicit \`talon history purge\` (history.ts purgeChatHistory);
+-- resets, backend switches and chat deletion never delete rows.
+DELETE FROM history_messages WHERE chat_id = ?`,
+  purgeChatState: `DELETE FROM history_chat_state WHERE chat_id = ?`,
+  chatState: `SELECT cleared_through_id, cleared_at, hidden_at
+FROM history_chat_state WHERE chat_id = ?`,
+  markCleared: `-- Soft reset: move the chat's context floor to its newest stored row. The
+-- rows stay; readers that build the bot's context skip everything at or
+-- under the floor. Parameters: chat_id, chat_id, cleared_at.
+INSERT INTO history_chat_state (chat_id, cleared_through_id, cleared_at)
+VALUES (?, (SELECT COALESCE(MAX(id), 0) FROM history_messages WHERE chat_id = ?), ?)
+ON CONFLICT(chat_id) DO UPDATE SET
+  cleared_through_id = excluded.cleared_through_id,
+  cleared_at = excluded.cleared_at`,
+  markHidden: `-- Soft delete: a chat the user deleted is hidden (and its context floor
+-- moved, so a chat that reappears under the same id starts fresh). The
+-- rows stay. Parameters: chat_id, chat_id, cleared_at, hidden_at.
+INSERT INTO history_chat_state (chat_id, cleared_through_id, cleared_at, hidden_at)
+VALUES (?, (SELECT COALESCE(MAX(id), 0) FROM history_messages WHERE chat_id = ?), ?, ?)
+ON CONFLICT(chat_id) DO UPDATE SET
+  cleared_through_id = excluded.cleared_through_id,
+  cleared_at = excluded.cleared_at,
+  hidden_at = excluded.hidden_at`,
+  hiddenChats: `SELECT s.chat_id, s.hidden_at,
+       (SELECT COUNT(*) FROM history_messages h WHERE h.chat_id = s.chat_id) AS total
+FROM history_chat_state s
+WHERE s.hidden_at IS NOT NULL
+ORDER BY s.hidden_at DESC`,
   searchFts: `-- The match param must already be a valid FTS5 expression
 -- (see history.ts ftsQuery).
 SELECT msg_id, sender_id, sender_name, sender_handle, text, reply_to_msg_id,

package/src/storage/turn-meta.ts

@@ -121,7 +121,7 @@ export function getTurnMeta<T>(chatId: string, msgId: string): T | null {
   }
 }
 
-/** Forget a chat entirely (chat deleted / history cleared). */
+/** Forget a chat's turn meta — only the operator's history purge does. */
 export function clearTurnMeta(chatId: string): void {
   ensureLoaded();
   try {