@saadnvd1/agent-os 0.3.673 → 0.3.680

package/lib/health/spin.ts

@@ -0,0 +1,158 @@
+/**
+ * bg-spin: a background job whose shell burns a core with nothing printed is a
+ * wait loop that can never exit (`until grep -q "" /dev/null; do :; done`).
+ * The pure half: deciding it, picking what to stop, and the words about it.
+ * No I/O here; spin-tick.ts reads the processes and stops them.
+ *
+ * Only the CPU of shells in the job's tree is counted. A loop's work happens
+ * in the shell itself (builtins, or children reaped into its total), while a
+ * build's lives in node, cc or cargo, so a silent heavy build never reads as
+ * spinning.
+ */
+
+import path from "path";
+import { WAIT_ADVICE } from "../agents/brief";
+import type { ProcRow } from "../process-table";
+import { MIN } from "./types";
+
+// Share of one core, every interval of the window.
+export const SPIN_CORES = 0.8;
+// How long it has to hold, with nothing new in the output.
+export const SPIN_WINDOW_MS = 4 * MIN;
+// Younger jobs aren't sampled.
+export const SPIN_MIN_AGE_MS = SPIN_WINDOW_MS;
+// A longer gap between samples (missed ticks, a sleeping laptop) starts over.
+export const SPIN_MAX_GAP_MS = 3 * MIN;
+// SIGTERM, then SIGKILL for whatever is still there.
+export const KILL_GRACE_MS = 3000;
+// Samples older than this are no use to the decision.
+export const SPIN_KEEP_MS = SPIN_WINDOW_MS + 2 * MIN;
+
+const SHELLS = new Set(["sh", "bash", "zsh", "dash", "fish", "ksh"]);
+const AGENTS = new Set(["claude"]);
+// Never part of a job's tree to stop.
+const NEVER = new Set(["tmux", "claude"]);
+
+export const baseOf = (comm: string): string =>
+  path.basename(comm).replace(/^-/, "");
+
+export interface SpinSample {
+  at: number;
+  // Cumulative CPU seconds of the tree's shells.
+  cpuSec: number;
+  // The output file's last write, if it has one.
+  outputAt: number | null;
+}
+
+export type SpinClass =
+  | "warming"
+  | "sleeping"
+  | "busy-with-output"
+  | "spinning";
+
+export function classifySpin(samples: SpinSample[]): SpinClass {
+  if (samples.length < 2) return "warming";
+  // The unbroken run of samples ending now.
+  let from = samples.length - 1;
+  while (from > 0 && samples[from].at - samples[from - 1].at <= SPIN_MAX_GAP_MS)
+    from--;
+  const run = samples.slice(from);
+  const last = run[run.length - 1];
+  // Start at the newest sample at least a window old.
+  let start = -1;
+  for (let i = 0; i < run.length; i++)
+    if (last.at - run[i].at >= SPIN_WINDOW_MS) start = i;
+  if (start < 0) return "warming";
+  const win = run.slice(start);
+  for (let i = 1; i < win.length; i++) {
+    const wall = (win[i].at - win[i - 1].at) / 1000;
+    const cpu = Math.max(0, win[i].cpuSec - win[i - 1].cpuSec);
+    if (wall <= 0 || cpu / wall < SPIN_CORES) return "sleeping";
+  }
+  const wrote = win.some((s) => s.outputAt !== null && s.outputAt > win[0].at);
+  return wrote ? "busy-with-output" : "spinning";
+}
+
+// Of the processes holding a task's output file open, the job's root: the
+// one whose parent doesn't hold it too.
+export function pickRoot(holders: number[], table: ProcRow[]): number | null {
+  const held = new Set(holders);
+  const roots = table.filter((r) => held.has(r.pid) && !held.has(r.ppid));
+  return roots.length === 1 ? roots[0].pid : null;
+}
+
+export function jobTree(root: number, table: ProcRow[]): ProcRow[] {
+  const kids = new Map<number, ProcRow[]>();
+  for (const r of table) {
+    const list = kids.get(r.ppid);
+    if (list) list.push(r);
+    else kids.set(r.ppid, [r]);
+  }
+  const byPid = new Map(table.map((r) => [r.pid, r]));
+  const out: ProcRow[] = [];
+  const seen = new Set<number>();
+  const stack = [byPid.get(root)].filter((r): r is ProcRow => !!r);
+  while (stack.length) {
+    const at = stack.shift() as ProcRow;
+    if (seen.has(at.pid)) continue;
+    seen.add(at.pid);
+    out.push(at);
+    stack.push(...(kids.get(at.pid) ?? []));
+  }
+  return out;
+}
+
+export const shellPids = (tree: ProcRow[]): number[] =>
+  tree.filter((r) => SHELLS.has(baseOf(r.comm))).map((r) => r.pid);
+
+// Whether this tree is a background job of an agent and nothing else: a
+// shell directly under the agent, with nothing of AgentOS, tmux or the agent
+// inside it.
+export function safeToKill(
+  root: number,
+  table: ProcRow[],
+  protectedPids: number[] = [process.pid, process.ppid]
+): boolean {
+  const head = table.find((r) => r.pid === root);
+  if (!head || root <= 1) return false;
+  if (!SHELLS.has(baseOf(head.comm))) return false;
+  const parent = table.find((r) => r.pid === head.ppid);
+  if (!parent || !AGENTS.has(baseOf(parent.comm))) return false;
+  return !jobTree(root, table).some(
+    (r) =>
+      protectedPids.includes(r.pid) ||
+      r.pid === parent.pid ||
+      NEVER.has(baseOf(r.comm))
+  );
+}
+
+// The PIDs to signal: the root first, so a loop can't respawn children, then
+// everything under it.
+export const killPlan = (root: number, table: ProcRow[]): number[] =>
+  jobTree(root, table).map((r) => r.pid);
+
+// ps's TIME column: [[D-]H:]M:SS[.cc] to seconds.
+export function parseCpuTime(text: string): number | null {
+  const m = /^\s*(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)\s*$/.exec(text);
+  if (!m) return null;
+  return (
+    Number(m[1] ?? 0) * 86400 +
+    Number(m[2] ?? 0) * 3600 +
+    Number(m[3]) * 60 +
+    Number(m[4])
+  );
+}
+
+export function spinNote(description: string, pid: number): string {
+  const mins = Math.round(SPIN_WINDOW_MS / MIN);
+  return `AgentOS stopped your background job "${description}" (PID ${pid}): its shell used about a core for ${mins}+ minutes with no output, which is a wait loop that can't exit. ${WAIT_ADVICE}`;
+}
+
+export function spinEventLine(
+  sessionName: string,
+  description: string,
+  pid: number
+): string {
+  const mins = Math.round(SPIN_WINDOW_MS / MIN);
+  return `Stopped background job "${description}" (PID ${pid}) in ${sessionName}: a shell wait loop holding a core for ${mins}+ minutes with no output. The task was told.`;
+}

package/lib/health/tick.ts

@@ -11,6 +11,7 @@ import { healthConfig, type HealthConfig } from "./config";
 import { runDetectors } from "./detectors";
 import { gatherFacts, liveBackgroundJobs } from "./facts";
 import { envTick, realEnv, type EnvDeps } from "./env/envTick";
+import { spinTick } from "./spin-tick";
 import { addNote } from "./notes";
 import { closeResolvedPieces } from "./pieces";
 import { deliver, deliverClosed, type RouteDeps, realRoute } from "./route";
@@ -43,9 +44,10 @@ export const MAX_WAKES = 2;
 // A wake that never came back (a restart cut it off) is given up on.
 export const WAKE_GIVE_UP_MS = 3 * MIN;
 
-// The checks the tick evaluates: piece-dup is raised where a piece starts.
+// The checks the tick evaluates: piece-dup is raised where a piece starts,
+// bg-spin by the process step (spin-tick.ts).
 export const TICK_CHECKS: readonly CheckId[] = CHECKS.filter(
-  (c) => c !== "piece-dup"
+  (c) => c !== "piece-dup" && c !== "bg-spin"
 );
 
 export interface TickDeps {
@@ -54,6 +56,8 @@ export interface TickDeps {
   watch: WatchDeps;
   route: RouteDeps;
   env: EnvDeps;
+  // Stops background jobs that spin (spin-tick.ts).
+  spin: (now: number) => Promise<void>;
   wake: typeof wake;
 }
 
@@ -63,6 +67,7 @@ export const realTick: TickDeps = {
   watch: { run: runClaude, usagePct: currentUsagePct },
   route: realRoute,
   env: realEnv,
+  spin: spinTick,
   wake,
 };
 
@@ -145,6 +150,9 @@ export function healthTick(
   closeResolvedPieces(now);
   leaveHeartbeat(now, liveBackgroundJobs());
   giveUpStale(now, deps);
+  void deps
+    .spin(now)
+    .catch((error) => console.error("[health] spin check:", error));
   void envTick(now, c, deps.env).catch((error) =>
     console.error("[health] environment failures:", error)
   );

package/lib/health/types.ts

@@ -14,6 +14,7 @@ export const CHECKS = [
   "load-red",
   "queue-held",
   "bg-quiet",
+  "bg-spin",
   "piece-dup",
   "restarts",
   "ci-slow",
@@ -26,6 +27,7 @@ export const AREA_OF: Record<CheckId, Area> = {
   "load-red": "scheduler",
   "queue-held": "scheduler",
   "bg-quiet": "tasks",
+  "bg-spin": "tasks",
   "piece-dup": "pipeline",
   restarts: "pipeline",
   "ci-slow": "pipeline",

package/lib/orchestrator/read.ts

@@ -10,6 +10,7 @@ import { hostLink } from "../hosts/remote-api";
 import { peerPane } from "../hosts/peer-sessions";
 import { workspaceSessions } from "./facts";
 import { untrusted } from "./untrusted";
+import { grepText } from "../bus/condense";
 import { heldChatTail, isHeldRemote } from "../tasks/contract/held-calls";
 import {
   findExternalSession,
@@ -55,7 +56,10 @@ export function findWorkspaceSession(
 // A session AgentOS didn't start: its screen, read the way the sidebar
 // reads one (a linked machine's only through its AgentOS, which doesn't
 // serve a screen it didn't start).
-async function readExternal(s: ExternalSession, n: number): Promise<string> {
+export async function readExternal(
+  s: ExternalSession,
+  n: number
+): Promise<string> {
   const head = `${s.ref} (external terminal on ${s.host}, not started by AgentOS)`;
   if (hostLink(s.hostId))
     return `${head}: its screen is on that machine and isn't served to this one.`;
@@ -127,6 +131,16 @@ export async function readSession(
     if (!external) throw error;
     return readExternal(external, n);
   }
+  return readResolved(s, n);
+}
+
+// One session's recent conversation or screen, whichever it has.
+export async function readResolved(
+  s: Session,
+  n: number,
+  grep?: string
+): Promise<string> {
+  const cut = (text: string) => tail(grep ? grepText(text, grep) : text, n);
   const link = hostLink(s.host_id);
   if (s.view === "chat" && link) {
     // Its orchestrator's task is read through the machine that holds it.
@@ -137,12 +151,12 @@ export async function readSession(
   }
   if (s.view === "chat") {
     const text = chatText(lastItems(s.id, n * 2));
-    const body = text ? untrusted(s.name, tail(text, n)) : "(no messages yet)";
+    const body = text ? untrusted(s.name, cut(text)) : "(no messages yet)";
     return `${s.name} (chat), last ${n} lines:\n${body}`;
   }
   if (link) {
     const lines = await peerPane(link, s.id);
-    const body = lines ? tail(lines.join("\n"), n) : "";
+    const body = lines ? cut(lines.join("\n")) : "";
     return `${s.name} (terminal on ${link.hostName}), last ${n} lines:\n${body ? untrusted(s.name, body) : "(couldn't be read)"}`;
   }
   await statusDetector.refreshCache();
@@ -152,6 +166,6 @@ export async function readSession(
     s.host_id || "local",
     `tmux capture-pane -t ${shellQuote(`=${s.tmux_name}:`)} -p -J -S -${n}`
   );
-  const body = tail(pane, n);
+  const body = cut(pane);
   return `${s.name} (terminal), last ${n} lines:\n${body ? untrusted(s.name, body) : "(empty)"}`;
 }

package/lib/palette/registry.ts

@@ -12,6 +12,10 @@ export interface PaletteCommand {
   keywords?: string[];
   // Shown beside it, e.g. ⌘K.
   hint?: string;
+  // A line under the title (what a conversation hit said).
+  detail?: string;
+  // Running it leaves the palette open (it changes the palette itself).
+  keepOpen?: boolean;
   icon?: unknown;
   run: () => void;
 }

package/lib/resurrect/index.ts

@@ -46,6 +46,7 @@ import { planFromTranscript } from "./plan";
 import { dropSnapshot, restoreWorktree, type RestoredAs } from "./snapshot";
 import { restoreSwept, sweptNote } from "./swept";
 import { forgetSwept } from "../worktree-sweep/store";
+import { isRestorableTask } from "../tasks/restorable";
 import { setPr, setTask } from "../db/session-parts";
 
 export interface ResurrectOptions {
@@ -66,8 +67,6 @@ export interface ResurrectOutcome {
 const row = (id: string) =>
   queries.getSession(db).get(id) as Session | undefined;
 
-const ENDED_TASK = new Set(["dropped", "done"]);
-
 // Restores in flight here, so two clicks can't both build a worktree.
 const g = globalThis as unknown as { __agentosResurrecting?: Set<string> };
 const inFlight = (g.__agentosResurrecting ??= new Set());
@@ -113,7 +112,7 @@ export async function resurrectSession(
     throw new Error(`${s.name} runs on ${peer.hostName}: restore it there.`);
   if (isMirror(s)) return onItsMachine(s);
 
-  const endedTask = !!s.task_status && ENDED_TASK.has(s.task_status);
+  const endedTask = isRestorableTask(s.task_status);
   if (s.task_status === "merged")
     throw new Error(
       `${s.name} was merged: its work is in the base branch. Start a new task to continue it.`

package/lib/search/conversations/backfill.ts

@@ -0,0 +1,117 @@
+import type Database from "better-sqlite3";
+import { getDb } from "@/lib/db";
+import { SCHEMA_VERSION, SEARCHED_KINDS } from "./schema";
+
+const BATCH = 500;
+
+interface State {
+  version: number;
+  cursor: number;
+  backfill_to: number;
+  done: number;
+}
+
+const stateOf = (db: Database.Database): State | undefined =>
+  db.prepare(`SELECT * FROM chat_search_state WHERE id = 1`).get() as
+    | State
+    | undefined;
+
+// Starts the index over: the stored version is not this build's.
+function reset(db: Database.Database): void {
+  db.transaction(() => {
+    db.exec(`DELETE FROM chat_search; DELETE FROM chat_search_keys`);
+    db.prepare(
+      `UPDATE chat_search_state SET version = ?, cursor = 0, done = 0,
+         backfill_to = (SELECT COALESCE(MAX(rowid), 0) FROM chat_items)
+       WHERE id = 1`
+    ).run(SCHEMA_VERSION);
+  })();
+}
+
+// Indexes one batch of the chats that were already there when the index was
+// made, in rowid order, and records where it got to in the same transaction:
+// stopped at any point, the next call carries on. Returns true when finished.
+export function backfillStep(db: Database.Database, batch = BATCH): boolean {
+  const state = stateOf(db);
+  if (!state) return true;
+  if (state.version !== SCHEMA_VERSION) reset(db);
+  else if (state.done) return true;
+  const { cursor, backfill_to } = stateOf(db)!;
+  const kinds = SEARCHED_KINDS.map(() => "?").join(", ");
+  return db.transaction(() => {
+    // Rowids are not dense (tool calls are most rows), so the batch is
+    // counted in rows of the kinds searched and the cursor moves to the last.
+    const rows = db
+      .prepare(
+        `SELECT rowid AS rid, session_id, item_id,
+                json_extract(data, '$.text') AS text
+         FROM chat_items
+         WHERE rowid > ? AND rowid <= ? AND kind IN (${kinds})
+         ORDER BY rowid LIMIT ?`
+      )
+      .all(cursor, backfill_to, ...SEARCHED_KINDS, batch) as {
+      rid: number;
+      session_id: string;
+      item_id: string;
+      text: string | null;
+    }[];
+    const key = db.prepare(
+      `SELECT id FROM chat_search_keys WHERE session_id = ? AND item_id = ?`
+    );
+    const del = db.prepare(`DELETE FROM chat_search WHERE rowid = ?`);
+    const mk = db.prepare(
+      `INSERT OR IGNORE INTO chat_search_keys (session_id, item_id) VALUES (?, ?)`
+    );
+    const put = db.prepare(
+      `INSERT INTO chat_search (rowid, body) VALUES (?, ?)`
+    );
+    for (const r of rows) {
+      if (!r.text) continue;
+      const have = key.get(r.session_id, r.item_id) as
+        | { id: number }
+        | undefined;
+      if (have) del.run(have.id);
+      else mk.run(r.session_id, r.item_id);
+      const id = (key.get(r.session_id, r.item_id) as { id: number }).id;
+      put.run(id, r.text);
+    }
+    const finished = rows.length < batch;
+    const next = finished ? backfill_to : rows[rows.length - 1].rid;
+    db.prepare(
+      `UPDATE chat_search_state SET cursor = ?, done = ? WHERE id = 1`
+    ).run(next, finished ? 1 : 0);
+    return finished;
+  })();
+}
+
+// 0..1 while the first index is being built; null once it is complete.
+export function indexProgress(): number | null {
+  const s = stateOf(getDb());
+  if (!s || (s.done && s.version === SCHEMA_VERSION)) return null;
+  return s.backfill_to ? Math.min(1, s.cursor / s.backfill_to) : 0;
+}
+
+let running = false;
+
+// Runs batches until done, giving the event loop back between them, so a
+// large history never holds up a request or the boot.
+export function startConversationBackfill(): void {
+  if (running) return;
+  running = true;
+  const t0 = Date.now();
+  const tick = () => {
+    try {
+      if (backfillStep(getDb())) {
+        running = false;
+        console.log(`Conversation search index ready (${Date.now() - t0} ms)`);
+        return;
+      }
+    } catch (error) {
+      running = false;
+      console.error("Indexing conversations for search failed:", error);
+      return;
+    }
+    setImmediate(tick);
+  };
+  setImmediate(tick);
+}

package/lib/search/conversations/buildMatchQuery.ts

@@ -0,0 +1,31 @@
+export interface MatchQuery {
+  // An FTS5 MATCH expression.
+  match: string;
+  // The words typed, lowercased, for marking a preview.
+  terms: string[];
+}
+
+const HAS_WORD = /[\p{L}\p{N}]/u;
+const WORDS = /[\p{L}\p{N}_]+/gu;
+// A quoted phrase (possibly still being typed) or a bare word.
+const TOKEN = /"([^"]*)(")?|[^\s"]+/g;
+
+// What was typed as an FTS5 expression. Every piece goes in as a quoted
+// string, so FTS syntax typed by hand (AND, NEAR, *, :, -, parentheses) is
+// plain text. Bare words match as prefixes, so a word being typed finds its
+// completions; a closed "phrase" is exact, an open one is a prefix on its last
+// word. Null when nothing searchable was typed.
+export function buildMatchQuery(input: string): MatchQuery | null {
+  const parts: string[] = [];
+  const terms: string[] = [];
+  for (const m of input.matchAll(TOKEN)) {
+    const quoted = m[1] !== undefined;
+    const text = (quoted ? m[1] : m[0]).trim();
+    if (!HAS_WORD.test(text)) continue;
+    const prefix = !quoted || !m[2];
+    parts.push(`"${text}"${prefix ? "*" : ""}`);
+    for (const w of text.toLowerCase().match(WORDS) ?? []) terms.push(w);
+  }
+  if (!parts.length || terms.join("").length < 2) return null;
+  return { match: parts.join(" "), terms };
+}

package/lib/search/conversations/index.ts

@@ -0,0 +1,9 @@
+export { buildMatchQuery } from "./buildMatchQuery";
+export { searchConversations } from "./searchConversations";
+export { getMessageContext } from "./messageContext";
+export {
+  startConversationBackfill,
+  backfillStep,
+  indexProgress,
+} from "./backfill";
+export type * from "./types";

package/lib/search/conversations/messageContext.ts

@@ -0,0 +1,45 @@
+import { getDb } from "@/lib/db";
+import type { ContextItem } from "./types";
+
+interface Row {
+  item_id: string;
+  kind: "user" | "assistant";
+  text: string | null;
+  created_at: number | null;
+  seq: number;
+}
+
+const COLS = `item_id, kind, seq, json_extract(data, '$.text') AS text,
+              json_extract(data, '$.createdAt') AS created_at`;
+
+// A message and the ones said just before and after it, in order. Null when
+// the message is gone. Only text: images and files stay out of a preview.
+export function getMessageContext(
+  sessionId: string,
+  itemId: string,
+  around = 3
+): ContextItem[] | null {
+  const db = getDb();
+  const hit = db
+    .prepare(
+      `SELECT ${COLS} FROM chat_items WHERE session_id = ? AND item_id = ?`
+    )
+    .get(sessionId, itemId) as Row | undefined;
+  if (!hit) return null;
+  const side = (op: "<" | ">", order: "ASC" | "DESC") =>
+    db
+      .prepare(
+        `SELECT ${COLS} FROM chat_items
+         WHERE session_id = ? AND kind IN ('user', 'assistant') AND seq ${op} ?
+         ORDER BY seq ${order} LIMIT ?`
+      )
+      .all(sessionId, hit.seq, around) as Row[];
+  const rows = [...side("<", "DESC").reverse(), hit, ...side(">", "ASC")];
+  return rows.map((r) => ({
+    id: r.item_id,
+    role: r.kind,
+    text: r.text ?? "",
+    createdAt: r.created_at,
+    hit: r.item_id === itemId,
+  }));
+}

package/lib/search/conversations/schema.ts

@@ -0,0 +1,71 @@
+import type Database from "better-sqlite3";
+
+// Bump to rebuild the index from scratch (a different set of kinds, a new
+// tokenizer); the next start's backfill does it.
+export const SCHEMA_VERSION = 1;
+
+// The item kinds whose text is searched. Tool calls and their output are
+// most of the rows and mostly noise.
+export const SEARCHED_KINDS = ["user", "assistant"] as const;
+
+const KINDS_SQL = SEARCHED_KINDS.map((k) => `'${k}'`).join(", ");
+
+// An item worth indexing: a searched kind with some text.
+const eligible = `new.kind IN (${KINDS_SQL}) AND COALESCE(json_extract(new.data, '$.text'), '') <> ''`;
+
+// The item's own key: the FTS rowid. chat_items has no integer primary key,
+// so its rowids can be renumbered by a VACUUM.
+const keyOf = (row: "new" | "old") =>
+  `(SELECT id FROM chat_search_keys WHERE session_id = ${row}.session_id AND item_id = ${row}.item_id)`;
+
+const reindexItem = `
+  DELETE FROM chat_search WHERE rowid = ${keyOf("old")};
+  DELETE FROM chat_search_keys WHERE session_id = old.session_id AND item_id = old.item_id;
+  INSERT INTO chat_search_keys (session_id, item_id)
+    SELECT new.session_id, new.item_id WHERE ${eligible};
+  INSERT INTO chat_search (rowid, body)
+    SELECT ${keyOf("new")}, json_extract(new.data, '$.text') WHERE ${eligible};`;
+
+// Every writer of chat_items (the server, the chat worker, an import) is
+// indexed by these, so no code path can forget.
+export function createConversationSearch(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_search_keys (
+      id INTEGER PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      item_id TEXT NOT NULL,
+      UNIQUE (session_id, item_id)
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS chat_search USING fts5(
+      body,
+      tokenize = "unicode61 remove_diacritics 2 tokenchars '_'",
+      prefix = '2 3'
+    );
+    CREATE TABLE IF NOT EXISTS chat_search_state (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      version INTEGER NOT NULL,
+      cursor INTEGER NOT NULL DEFAULT 0,
+      backfill_to INTEGER NOT NULL DEFAULT 0,
+      done INTEGER NOT NULL DEFAULT 0
+    );
+    INSERT OR IGNORE INTO chat_search_state (id, version, backfill_to, done)
+      SELECT 1, ${SCHEMA_VERSION}, COALESCE(MAX(rowid), 0), MAX(rowid) IS NULL
+      FROM chat_items;
+    CREATE TRIGGER IF NOT EXISTS chat_search_ai AFTER INSERT ON chat_items
+    BEGIN
+      DELETE FROM chat_search WHERE rowid = ${keyOf("new")};
+      INSERT OR IGNORE INTO chat_search_keys (session_id, item_id)
+        SELECT new.session_id, new.item_id WHERE ${eligible};
+      INSERT INTO chat_search (rowid, body)
+        SELECT ${keyOf("new")}, json_extract(new.data, '$.text') WHERE ${eligible};
+    END;
+    CREATE TRIGGER IF NOT EXISTS chat_search_au AFTER UPDATE OF data ON chat_items
+    BEGIN${reindexItem}
+    END;
+    CREATE TRIGGER IF NOT EXISTS chat_search_ad AFTER DELETE ON chat_items
+    BEGIN
+      DELETE FROM chat_search WHERE rowid = ${keyOf("old")};
+      DELETE FROM chat_search_keys WHERE session_id = old.session_id AND item_id = old.item_id;
+    END;
+  `);
+}