@saadnvd1/agent-os 0.3.585 → 0.3.588

package/lib/bookmarks/snapshot.ts

@@ -0,0 +1,33 @@
+/**
+ * The text a bookmark keeps of what it marks: readable, clipped, and with
+ * secrets masked so a key in a tool's output doesn't sit in a second table.
+ */
+
+import type { ChatItem } from "../chat/events";
+import { toRaw } from "../share/snapshot";
+import { NO_CONTEXT, redactForShare } from "../share/redact";
+import { envSecrets } from "../share/context";
+import { MAX_SNAPSHOT_CHARS } from "./types";
+
+function plain(item: ChatItem): string {
+  const raw = toRaw(item);
+  if (!raw) return "";
+  return raw.label ? `${raw.label}\n${raw.text}` : raw.text;
+}
+
+// A turn reads as what was asked and the start of the answer.
+export function snapshotText(item: ChatItem, reply?: ChatItem): string {
+  const text = [plain(item), reply ? plain(reply) : ""]
+    .filter((t) => t.trim())
+    .join("\n\n")
+    .trim();
+  // Redacted before the cut, so a secret the cut splits is still caught; the
+  // wide first cut only bounds the work on a huge tool output.
+  const safe = redactForShare(text.slice(0, MAX_SNAPSHOT_CHARS * 4), {
+    ...NO_CONTEXT,
+    secrets: envSecrets(),
+  }).text;
+  return safe.length > MAX_SNAPSHOT_CHARS
+    ? safe.slice(0, MAX_SNAPSHOT_CHARS) + "…"
+    : safe;
+}

package/lib/bookmarks/store.ts

@@ -0,0 +1,333 @@
+/**
+ * Bookmarks: a person's "come back to this" marks on single chat items,
+ * keyed by the item's stable id. Each keeps a redacted snapshot of what it
+ * marks, so it can be searched and still reads after the chat is gone.
+ */
+
+import { randomUUID } from "crypto";
+import { db, type Session } from "../db";
+import type { ChatItem } from "../chat/events";
+import { getItem } from "../chat/store";
+import { getProject } from "../projects";
+import { snapshotText } from "./snapshot";
+import {
+  BOOKMARKABLE_KINDS,
+  MAX_NOTE_CHARS,
+  type Bookmark,
+  type BookmarkKind,
+  type BookmarkScope,
+  type BookmarksPage,
+} from "./types";
+
+// An orchestrator's own workspace, or its project's (as sessionWorkspace in
+// lib/schedules/store, without pulling the scheduler into a move).
+const sessionWorkspace = (s: Session): string | null =>
+  s.workspace_id ??
+  (s.project_id ? (getProject(s.project_id)?.workspace_id ?? null) : null);
+
+/** A refusal the routes turn into its status. */
+export class BookmarkError extends Error {
+  constructor(
+    message: string,
+    readonly status: 400 | 404
+  ) {
+    super(message);
+  }
+}
+
+interface Row {
+  id: string;
+  session_id: string;
+  item_id: string;
+  scope: BookmarkScope;
+  workspace_id: string | null;
+  kind: BookmarkKind;
+  text: string;
+  session_name: string;
+  note: string | null;
+  created_at: string;
+}
+
+type Joined = Row & {
+  s_id: string | null;
+  task_status: string | null;
+  archived_at: string | null;
+};
+
+// The bookmark with its chat's state as of now.
+const SELECT = `
+  SELECT b.*, s.id AS s_id, s.task_status, s.archived_at
+  FROM chat_bookmarks b LEFT JOIN sessions s ON s.id = b.session_id`;
+
+function toBookmark(r: Joined): Bookmark {
+  return {
+    id: r.id,
+    sessionId: r.session_id,
+    itemId: r.item_id,
+    scope: r.scope,
+    kind: r.kind,
+    text: r.text,
+    note: r.note,
+    sessionName: r.session_name,
+    workspaceId: r.workspace_id,
+    createdAt: r.created_at,
+    state: !r.s_id
+      ? "deleted"
+      : r.task_status === "moved"
+        ? "moved"
+        : r.archived_at
+          ? "archived"
+          : "live",
+  };
+}
+
+export function getBookmark(id: string): Bookmark | null {
+  const r = db.prepare(`${SELECT} WHERE b.id = ?`).get(id) as
+    | Joined
+    | undefined;
+  return r ? toBookmark(r) : null;
+}
+
+const cleanNote = (note: unknown): string | null => {
+  if (note === null || note === undefined) return null;
+  if (typeof note !== "string") throw new BookmarkError("Bad note", 400);
+  const t = note.replace(/\s+/g, " ").trim().slice(0, MAX_NOTE_CHARS);
+  return t || null;
+};
+
+// The first reply in the turn a user item starts, for its excerpt.
+function firstReply(
+  sessionId: string,
+  userItemId: string
+): ChatItem | undefined {
+  const rows = db
+    .prepare(
+      `SELECT data FROM chat_items
+       WHERE session_id = ? AND seq > (
+         SELECT seq FROM chat_items WHERE session_id = ? AND item_id = ?)
+       ORDER BY seq LIMIT 200`
+    )
+    .all(sessionId, sessionId, userItemId) as { data: string }[];
+  for (const r of rows) {
+    let item: ChatItem | null;
+    try {
+      item = JSON.parse(r.data) as ChatItem | null;
+    } catch {
+      item = null;
+    }
+    // A row that isn't an item just isn't the reply.
+    if (!item || typeof item !== "object") continue;
+    if (item.kind === "user" || item.kind === "turn_end") return undefined;
+    if (item.kind === "assistant" && item.text.trim()) return item;
+  }
+  return undefined;
+}
+
+/**
+ * Marks an item. Idempotent: the same item and scope again returns the
+ * bookmark it already has, with `created: false`.
+ */
+export function createBookmark(input: {
+  sessionId: string;
+  itemId?: unknown;
+  scope?: unknown;
+  note?: unknown;
+}): { bookmark: Bookmark; created: boolean } {
+  const { sessionId } = input;
+  if (typeof input.itemId !== "string" || !input.itemId)
+    throw new BookmarkError("itemId is required", 400);
+  const scope = input.scope ?? "item";
+  if (scope !== "item" && scope !== "turn")
+    throw new BookmarkError("scope must be 'item' or 'turn'", 400);
+  const note = cleanNote(input.note);
+  const session = db
+    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
+  if (!session) throw new BookmarkError("Session not found", 404);
+  const existing = db
+    .prepare(
+      `SELECT id FROM chat_bookmarks WHERE session_id = ? AND item_id = ? AND scope = ?`
+    )
+    .get(sessionId, input.itemId, scope) as { id: string } | undefined;
+  if (existing) return { bookmark: getBookmark(existing.id)!, created: false };
+  const item = getItem(sessionId, input.itemId);
+  if (!item) throw new BookmarkError("Message not found", 404);
+  if (!(BOOKMARKABLE_KINDS as readonly string[]).includes(item.kind))
+    throw new BookmarkError("That can't be bookmarked", 400);
+  if (scope === "turn" && item.kind !== "user")
+    throw new BookmarkError("A turn is bookmarked by its first message", 400);
+  const kind = (scope === "turn" ? "turn" : item.kind) as BookmarkKind;
+  const text = snapshotText(
+    item,
+    scope === "turn" ? firstReply(sessionId, item.id) : undefined
+  );
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO chat_bookmarks
+       (id, session_id, item_id, scope, workspace_id, kind, text, session_name, note)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT (session_id, item_id, scope) DO NOTHING`
+  ).run(
+    id,
+    sessionId,
+    item.id,
+    scope,
+    sessionWorkspace(session),
+    kind,
+    text,
+    session.name,
+    note
+  );
+  // A request that raced this one may have made it first.
+  const made = db
+    .prepare(
+      `SELECT id FROM chat_bookmarks WHERE session_id = ? AND item_id = ? AND scope = ?`
+    )
+    .get(sessionId, item.id, scope) as { id: string };
+  return { bookmark: getBookmark(made.id)!, created: made.id === id };
+}
+
+/** One chat's bookmarks, in the order they appear in it. */
+export function listSessionBookmarks(sessionId: string): Bookmark[] {
+  return (
+    db
+      .prepare(
+        `${SELECT}
+         LEFT JOIN chat_items c ON c.session_id = b.session_id AND c.item_id = b.item_id
+         WHERE b.session_id = ?
+         ORDER BY c.seq IS NULL, c.seq, b.created_at, b.id`
+      )
+      .all(sessionId) as Joined[]
+  ).map(toBookmark);
+}
+
+const escapeLike = (s: string) => s.replace(/[\\%_]/g, (c) => `\\${c}`);
+
+const cursorOf = (b: Bookmark) => `${b.createdAt}|${b.id}`;
+
+/**
+ * Bookmarks across chats, newest first: one workspace's (null: those with
+ * none) or every one's, matching `q` in the text, the note or the chat's
+ * name. The copy a move left behind isn't listed: its live twin is.
+ */
+export function listBookmarks(opts: {
+  workspace: string | null | "all";
+  q?: string;
+  before?: string | null;
+  limit?: number;
+}): BookmarksPage {
+  const limit = Math.min(Math.max(opts.limit ?? 50, 1), 200);
+  const where = [`(s.task_status IS NULL OR s.task_status != 'moved')`];
+  const args: (string | number)[] = [];
+  if (opts.workspace === null) where.push(`b.workspace_id IS NULL`);
+  else if (opts.workspace !== "all") {
+    where.push(`b.workspace_id = ?`);
+    args.push(opts.workspace);
+  }
+  const q = opts.q?.trim();
+  if (q) {
+    const like = `%${escapeLike(q)}%`;
+    where.push(
+      `(b.text LIKE ? ESCAPE '\\' OR b.note LIKE ? ESCAPE '\\' OR b.session_name LIKE ? ESCAPE '\\')`
+    );
+    args.push(like, like, like);
+  }
+  if (opts.before) {
+    const at = opts.before.lastIndexOf("|");
+    if (at > 0) {
+      where.push(`(b.created_at < ? OR (b.created_at = ? AND b.id < ?))`);
+      const created = opts.before.slice(0, at);
+      args.push(created, created, opts.before.slice(at + 1));
+    }
+  }
+  const rows = (
+    db
+      .prepare(
+        `${SELECT} WHERE ${where.join(" AND ")}
+         ORDER BY b.created_at DESC, b.id DESC LIMIT ?`
+      )
+      .all(...args, limit + 1) as Joined[]
+  ).map(toBookmark);
+  const more = rows.length > limit;
+  const bookmarks = more ? rows.slice(0, limit) : rows;
+  return {
+    bookmarks,
+    next: more ? cursorOf(bookmarks[bookmarks.length - 1]) : null,
+  };
+}
+
+export function setBookmarkNote(id: string, note: unknown): Bookmark | null {
+  const clean = cleanNote(note);
+  const changed = db
+    .prepare(`UPDATE chat_bookmarks SET note = ? WHERE id = ?`)
+    .run(clean, id).changes;
+  return changed ? getBookmark(id) : null;
+}
+
+export function removeBookmark(id: string): boolean {
+  return (
+    db.prepare(`DELETE FROM chat_bookmarks WHERE id = ?`).run(id).changes > 0
+  );
+}
+
+/** What a move carries: the chat's bookmarks, as stored. */
+export interface MovedBookmark {
+  itemId: string;
+  scope: BookmarkScope;
+  kind: BookmarkKind;
+  text: string;
+  note: string | null;
+  createdAt: string;
+}
+
+export function bookmarksForMove(sessionId: string): MovedBookmark[] {
+  return (
+    db
+      .prepare(
+        `SELECT item_id, scope, kind, text, note, created_at
+         FROM chat_bookmarks WHERE session_id = ? ORDER BY created_at, id`
+      )
+      .all(sessionId) as Row[]
+  ).map((r) => ({
+    itemId: r.item_id,
+    scope: r.scope,
+    kind: r.kind,
+    text: r.text,
+    note: r.note,
+    createdAt: r.created_at,
+  }));
+}
+
+/**
+ * Writes a moved chat's bookmarks under the row it arrived as, scoped to
+ * that row's workspace here. Run inside the transaction that makes the row.
+ */
+export function insertMovedBookmarks(
+  sessionId: string,
+  rows: MovedBookmark[]
+): void {
+  if (!rows.length) return;
+  const session = db
+    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
+  if (!session) return;
+  const workspace = sessionWorkspace(session);
+  const insert = db.prepare(
+    `INSERT OR IGNORE INTO chat_bookmarks
+       (id, session_id, item_id, scope, workspace_id, kind, text, session_name, note, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const r of rows)
+    insert.run(
+      randomUUID(),
+      sessionId,
+      r.itemId,
+      r.scope,
+      workspace,
+      r.kind,
+      r.text,
+      session.name,
+      r.note,
+      r.createdAt
+    );
+}

package/lib/bookmarks/types.ts

@@ -0,0 +1,38 @@
+// A person's mark on one chat item, shared by the routes, the web app and
+// the native app.
+
+export type BookmarkScope = "item" | "turn";
+export type BookmarkKind = "user" | "assistant" | "tool" | "turn";
+// live: the chat is there; archived: it is, archived; moved: this row is the
+// copy left behind by a move; deleted: the chat is gone, the snapshot stays.
+export type BookmarkState = "live" | "archived" | "moved" | "deleted";
+
+export interface Bookmark {
+  id: string;
+  sessionId: string;
+  itemId: string;
+  scope: BookmarkScope;
+  kind: BookmarkKind;
+  text: string;
+  note: string | null;
+  sessionName: string;
+  workspaceId: string | null;
+  createdAt: string;
+  state: BookmarkState;
+}
+
+export interface BookmarksPage {
+  bookmarks: Bookmark[];
+  // Pass as `before` for the next page; null on the last one.
+  next: string | null;
+}
+
+export const BOOKMARKABLE_KINDS = ["user", "assistant", "tool"] as const;
+
+export const MAX_NOTE_CHARS = 500;
+// A snapshot is clipped to this, plus the ellipsis that marks the cut.
+export const MAX_SNAPSHOT_CHARS = 4_000;
+
+// The key the stars look a bookmark up by.
+export const bookmarkKey = (itemId: string, scope: BookmarkScope) =>
+  `${itemId}:${scope}`;

package/lib/chat/commands.ts

@@ -1,10 +1,14 @@
 import type { ChatCommand } from "./events";
 
-// The command being typed, if the message is still just "/something".
-// Agents only run a command that opens the message.
-export function slashQuery(text: string): string | null {
-  const m = /^\/(\S*)$/.exec(text);
-  return m ? m[1].toLowerCase() : null;
+// The /command being typed: a "/" at the start of a line or after whitespace,
+// then the partial name, right up to the caret. Not "a/b" or "http://x".
+// `start` is where the "/" sits in the text before the caret.
+export function slashQuery(
+  beforeCaret: string
+): { query: string; start: number } | null {
+  const m = /(^|\s)\/([^\s/]*)$/.exec(beforeCaret);
+  if (!m) return null;
+  return { query: m[2].toLowerCase(), start: m.index + m[1].length };
 }
 
 function isSubsequence(q: string, s: string): boolean {

package/lib/db/changes.ts

@@ -41,6 +41,8 @@ export const TABLES_WATCHED_80 = [
   "feature_pieces",
 ] as const;
 
+export const TABLES_WATCHED_CHAT_BOOKMARKS = ["chat_bookmarks"] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
@@ -49,6 +51,7 @@ export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_58,
   ...TABLES_WATCHED_78,
   ...TABLES_WATCHED_80,
+  ...TABLES_WATCHED_CHAT_BOOKMARKS,
 ];
 
 export function installChangeTriggers(

package/lib/db/migrations.ts

@@ -6,6 +6,7 @@ import {
   TABLES_WATCHED_58,
   TABLES_WATCHED_78,
   TABLES_WATCHED_80,
+  TABLES_WATCHED_CHAT_BOOKMARKS,
 } from "./changes";
 import type Database from "better-sqlite3";
 import { moveSchedulesToRecipes } from "./schedules-move";
@@ -2297,6 +2298,33 @@ export const migrations: Migration[] = [
       `);
     },
   },
+  {
+    key: "20261014T2000_chat_bookmarks",
+    up: (db) => {
+      // A person's marks on single chat items. No FK to sessions: a
+      // bookmark outlives a deleted chat with its own snapshot. Additive.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS chat_bookmarks (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          item_id TEXT NOT NULL,
+          scope TEXT NOT NULL DEFAULT 'item',
+          workspace_id TEXT,
+          kind TEXT NOT NULL,
+          text TEXT NOT NULL,
+          session_name TEXT NOT NULL,
+          note TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE (session_id, item_id, scope)
+        )
+      `);
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_chat_bookmarks_ws
+           ON chat_bookmarks(workspace_id, created_at DESC)`
+      );
+      installChangeTriggers(db, TABLES_WATCHED_CHAT_BOOKMARKS);
+    },
+  },
 ];
 
 // `upTo`: stop after this legacy id or timestamp key, inclusive (tests that

package/lib/tasks/finish.ts

@@ -24,7 +24,13 @@ import {
 import { mergePR } from "./merge-pr";
 import { getProject } from "../projects";
 import { canSignOff } from "./state";
-import { forgetPR, getTaskSession, prFor, projectPathFor } from "./session";
+import {
+  forgetPR,
+  getTaskSession,
+  isAllowedBase,
+  prFor,
+  projectPathFor,
+} from "./session";
 import { dropSessionDatabase } from "../project-config/database";
 import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
@@ -114,7 +120,13 @@ async function finishMerge(
 // machine merged it and didn't say).
 export async function signOffTask(
   id: string,
-  opts: { wait?: boolean; head?: string; device?: string | null } = {}
+  opts: {
+    wait?: boolean;
+    head?: string;
+    device?: string | null;
+    // The base another machine judged the gates against (a forwarded merge).
+    base?: string;
+  } = {}
 ): Promise<MergeMethod | null> {
   const session = getTaskSession(id);
   if (session.task_status !== "running")
@@ -124,14 +136,24 @@ export async function signOffTask(
   if (held) throw new Error(held);
   // Its own machine checks the gates and merges.
   // That machine's settings chose the method; null if it didn't say.
-  if (isMirror(session)) return remoteTaskAction(session, "merge", opts.head);
+  if (isMirror(session))
+    return remoteTaskAction(session, "merge", opts.head, session.base_branch);
   const repo = projectPathFor(session);
   if (!repo) throw new Error("Task has no project");
   const refusal = signOffRefusal(id);
   if (refusal) throw new Error(refusal);
   // prFor follows a retarget onto the record, so compare with what the
   // checks above were judged against.
-  const judgedBase = session.base_branch;
+  // A forwarded merge was judged on the other machine against the base it
+  // recorded, which may be newer than this machine's row; only a base this
+  // task may have is taken.
+  if (
+    opts.base &&
+    opts.base !== session.base_branch &&
+    !(await isAllowedBase(session, repo, opts.base))
+  )
+    throw new Error(`${opts.base} isn't a base ${session.name} may merge into`);
+  const judgedBase = opts.base ?? session.base_branch;
   const pr = await prFor(session, true);
   const verdict = canSignOff(pr);
   if (!verdict.ok) throw new Error(verdict.reason);

package/lib/tasks/move-bundle.ts

@@ -6,6 +6,8 @@
 import { isBranchName } from "../git";
 import { CHAT_ACCESS, type ChatAccess } from "../chat/events";
 import type { ProjectRef } from "./project-ref";
+import type { MovedBookmark } from "../bookmarks/store";
+import { MAX_NOTE_CHARS, MAX_SNAPSHOT_CHARS } from "../bookmarks/types";
 import { isClaudeSessionId } from "./transcript";
 
 // A long task's conversation runs to a few MB; this is far past that.
@@ -92,11 +94,17 @@ export interface ChatBundle {
   // An undo's resume point not yet used up, and the context meter.
   resumeAt: string | null;
   context: string | null;
+  // Its bookmarks; absent from a machine that predates them.
+  bookmarks?: MovedBookmark[];
 }
 
 const isStr = (v: unknown): v is string => typeof v === "string";
 const isStrOrNull = (v: unknown) => v === null || isStr(v);
 
+const BOOKMARK_KINDS = ["user", "assistant", "tool", "turn"];
+// Far past what a person stars in one chat.
+export const MAX_MOVED_BOOKMARKS = 2000;
+
 function validateChat(c: ChatBundle): ChatBundle {
   if (!c || typeof c !== "object" || !Array.isArray(c.items))
     throw new Error("Bad chat");
@@ -119,6 +127,26 @@ function validateChat(c: ChatBundle): ChatBundle {
       throw new Error("Bad queued message");
     bytes += m.id.length + m.text.length + (m.images?.length ?? 0);
   }
+  if (c.bookmarks !== undefined && !Array.isArray(c.bookmarks))
+    throw new Error("Bad chat bookmarks");
+  if ((c.bookmarks?.length ?? 0) > MAX_MOVED_BOOKMARKS)
+    throw new Error("Too many bookmarks to move");
+  for (const b of c.bookmarks ?? []) {
+    if (
+      !b ||
+      !isStr(b.itemId) ||
+      b.itemId.length > 200 ||
+      !(b.scope === "item" || b.scope === "turn") ||
+      !BOOKMARK_KINDS.includes(b.kind) ||
+      !isStr(b.text) ||
+      b.text.length > MAX_SNAPSHOT_CHARS + 1 ||
+      !isStrOrNull(b.note) ||
+      (b.note?.length ?? 0) > MAX_NOTE_CHARS ||
+      !isStr(b.createdAt)
+    )
+      throw new Error("Bad bookmark");
+    bytes += b.itemId.length + b.text.length + (b.note?.length ?? 0);
+  }
   if (bytes > MAX_CHAT_BYTES) throw new Error("The chat is too large to move");
   if (!isStrOrNull(c.resumeAt) || !isStrOrNull(c.context))
     throw new Error("Bad chat");

package/lib/tasks/move-chat.ts

@@ -11,6 +11,7 @@ import { settle, listItems } from "../chat/store";
 import { stopChatAtTurnEnd } from "../chat/stop";
 import { rewritePaths } from "./transcript";
 import { MAX_CHAT_BYTES, type ChatBundle } from "./move-bundle";
+import { bookmarksForMove, insertMovedBookmarks } from "../bookmarks/store";
 
 // A turn this long is left to finish: the move is refused, not cut short.
 export const MOVE_TURN_WAIT_MS = 3 * 60_000;
@@ -50,6 +51,7 @@ export function packChat(session: Session): ChatBundle {
     sentBy: r.sent_by,
     createdAt: r.created_at,
   }));
+  const bookmarks = bookmarksForMove(session.id);
   const chat: ChatBundle = {
     items,
     queue,
@@ -57,10 +59,15 @@ export function packChat(session: Session): ChatBundle {
     plan: !!session.chat_plan,
     resumeAt: session.chat_resume_at,
     context: session.chat_context,
+    bookmarks,
   };
   const bytes =
     items.reduce((n, i) => n + i.id.length + i.data.length, 0) +
-    queue.reduce((n, m) => n + m.text.length + (m.images?.length ?? 0), 0);
+    queue.reduce((n, m) => n + m.text.length + (m.images?.length ?? 0), 0) +
+    bookmarks.reduce(
+      (n, b) => n + b.itemId.length + b.text.length + (b.note?.length ?? 0),
+      0
+    );
   if (bytes > MAX_CHAT_BYTES) throw new Error("The chat is too large to move");
   return chat;
 }
@@ -103,6 +110,7 @@ export function unpackChat(
       m.createdAt
     )
   );
+  insertMovedBookmarks(id, chat.bookmarks ?? []);
 }
 
 const imageCount = (images: string) => {
@@ -118,4 +126,5 @@ const imageCount = (images: string) => {
 export function dropChat(id: string): void {
   db.prepare(`DELETE FROM chat_items WHERE session_id = ?`).run(id);
   db.prepare(`DELETE FROM chat_queue WHERE session_id = ?`).run(id);
+  db.prepare(`DELETE FROM chat_bookmarks WHERE session_id = ?`).run(id);
 }

package/lib/tasks/remote.ts

@@ -191,7 +191,8 @@ export function setMirrorStatus(id: string, status: TaskStatus): void {
 export async function remoteTaskAction(
   session: Session,
   action: "merge" | "drop",
-  head?: string
+  head?: string,
+  base?: string | null
 ): Promise<MergeMethod | null> {
   const link = requireHostLink(session.host_id);
   // An AgentOS that predates pinned merges would ignore the head and merge
@@ -203,11 +204,28 @@ export async function remoteTaskAction(
         `${link.hostName}'s AgentOS can't pin a merge to a commit; update it first`
       );
   }
+  // base: what the gates here were judged against; the machine that merges
+  // compares the PR with it, not with a base only it recorded.
   const res = await hostApi<{ head?: string | null; method?: unknown }>(
     link,
     `/api/tasks/${encodeURIComponent(session.id)}/${action}`,
-    { body: head ? { head } : {}, timeout: 300000 }
-  );
+    {
+      body: { ...(head && { head }), ...(head && base && { base }) },
+      timeout: 300000,
+    }
+  ).catch(async (err) => {
+    if (action !== "merge" || !unknownOutcome(err)) throw err;
+    // A proxy or a dropped connection after the merge ran answers 502 with
+    // nothing from AgentOS: ask what state the task is in before failing.
+    const merged = await hostTasks(link, true)
+      .then((l) => l.tasks.find((t) => t.id === session.id)?.state === "merged")
+      .catch(() => false);
+    if (!merged)
+      throw new Error(
+        `${(err as Error).message}: couldn't confirm whether ${link.hostName} merged ${session.name}; check its PR before signing off again`
+      );
+    return { head: head ?? null, method: undefined };
+  });
   forgetHostTasks(link.hostId);
   setMirrorStatus(session.id, action === "merge" ? "merged" : "dropped");
   if (head && res.head !== head)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.585",
+  "version": "0.3.588",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"