@oar-sh/oar 0.9.9 → 0.9.11

package/server/relay-tools.md

@@ -24,7 +24,7 @@ Use `restart: true` in the request body when the user wants a real relay restart
 
 ## Preview servers
 
-Publish a local web server or a static directory on a public preview URL so the user can open it from any device, or list/close existing previews. Use this whenever the user wants to see, try, or share something with a web UI — never ask them to open localhost or forward a port. For a dev server: call this FIRST with {action:"create", port} to get the basePath, then start the server configured to serve under that basePath (Vite --base, Next basePath, Express mount prefix); the proxy forwards X-Forwarded-Prefix but does not rewrite bodies, so root-absolute asset paths will not work. For plain files or a build output: pass {action:"create", dir} instead and the relay serves the directory itself — no dev server needed. Always tell the user the returned URL and that the link is public: anyone who has it can reach the app without logging in. Previews never expire on their own; close them with {action:"close"} when the user is done.
+Publish a local web server or a static directory on a public preview URL so the user can open it from any device, or list/close existing previews. Use this whenever the user wants to see, try, or share something with a web UI — never ask them to open localhost or forward a port. For a dev server: call this FIRST with {action:"create", port} to get the basePath, then start the server configured to serve under that basePath (Vite --base, Next basePath, Express mount prefix); the proxy forwards X-Forwarded-Prefix but does not rewrite bodies, so root-absolute asset paths will not work. For plain files or a build output: pass {action:"create", dir} instead and the relay serves the directory itself — no dev server needed. Always tell the user the returned URL and that the link is public: anyone who has it can reach the app without logging in. Publishing the same port or directory again in this conversation returns the same link. Previews never expire and survive a relay restart (a port preview until the machine reboots); close them with {action:"close"} when the user is done.
 
 If you have a `preview` tool, use it. Otherwise use the authenticated localhost API (same auth as `POST /api/relay/shutdown`): `POST /api/previews` with `{ "conversationId": "<conv>", "port": 5173, "label": "web app" }` (or `"dir": "./dist"` instead of the port) publishes, `GET /api/previews` lists, `DELETE /api/previews/:token` closes the link without touching the dev server behind it. A 503 with `details` means the preview lane is disabled or misconfigured — surface those details, they are the operator's fix. See `docs/preview-servers.md`.
 
@@ -38,6 +38,7 @@ This relay itself is listed with "self": true when its owner switched agent sess
 
 - `create_session` starts a session with any provider that `relay_info` lists: a local one in a folder ("cwd"), or provider "claude-cloud" with "repo" (a GitHub URL or owner/repo) and an optional "branch". At most 4 sessions you started may work at the same time; a fifth is refused until one finishes.
 - The first `create_session` on this relay shows the user an approval card, once per conversation. A session that an agent created cannot create sessions itself (one level only).
+- Sessions you start here are grouped under this session in the user's sidebar. `list_sessions` lists in the sidebar's order (a group sorts by its newest session, head first) and shows the group as a "group" field (id, name, role); `read_session` adds the group's live members with their state. Agents only read groups, the user arranges them.
 - A new session knows nothing of this conversation: write a self-contained prompt. A Claude Cloud session works on a fresh clone in a sandbox at Anthropic, so name the branch it should work on and push.
 - Follow each session with `wait` (the message id comes back from `create_session` and `send`) and `read_session`; "wait_seconds" is limited to the maximum set on the relay (default 600).
 - Sessions run on the relay owner's accounts and cost their usage: start only what the task needs.

package/server/relay.mjs

@@ -32,6 +32,7 @@ import {
   extractModelDescriptors,
   normalizeContextLimitTokens,
 } from '../shared/model-descriptors.mjs';
+import { windowsSystemToolPath } from '../shared/windows-system-tools.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -379,7 +380,7 @@ async function spawnForegroundCliViaPowerShell(tcpConnectionToken, port) {
   ].join(' ');
 
   const psCommand = `$env:COPILOT_CONNECTION_TOKEN='${tcpConnectionToken}'; & '${NODE_PATH}' ${nodeArgs}`;
-  const child = await waitForProcessSpawn('powershell.exe', [
+  const child = await waitForProcessSpawn(windowsSystemToolPath('powershell.exe'), [
     '-NoExit',
     '-Command',
     psCommand,

package/server/repositories/conversation-group-repository.mjs

@@ -0,0 +1,444 @@
+'use strict';
+
+import { randomUUID } from 'node:crypto';
+
+import { compareGroupMembers } from '../public/app/conversation-group-order.mjs';
+
+// Session groups (migration 0014): the set of conversations that share a
+// `group_id`, with a row in `conversation_groups` for what the set itself
+// needs: a name given by hand, and the head (the session that created the
+// others with the remote_relay tool; NULL for a group made by hand or once
+// the head is deleted).
+//
+// A session an agent creates on this relay joins its creator's group at
+// bootstrap (`attachCreatedConversation`); the origin stays the record of who
+// created it and is not read again for the grouping. Everything else is done
+// by hand in the sidebar. Every reader tolerates a schema without the
+// migration: it then sees no groups and writes nothing.
+//
+// A group can have a hand order (migration 0015): once the owner drags a row
+// into place, every member after the head gets a `group_position` (10, 20,
+// 30, ...) and keeps it; later arrivals join at the end. A group nobody
+// reordered keeps NULL positions and the activity order. Without the column
+// the hand order is off and moves only change the membership.
+
+const POSITION_STEP = 10;
+
+export const GROUP_NAME_MAX = 60;
+
+function toText(value) {
+  return String(value ?? '').trim();
+}
+
+/** The name a group shows: its own, else the head's current title, else "Group". */
+export function resolveGroupDisplayName({ name = null, headTitle = null } = {}) {
+  return toText(name) || toText(headTitle) || 'Group';
+}
+
+/** A group name as stored: trimmed, capped, NULL when empty. */
+export function normalizeGroupName(value) {
+  const text = toText(value).replace(/\s+/g, ' ');
+  return text ? text.slice(0, GROUP_NAME_MAX) : null;
+}
+
+function rowToGroup(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    name: row.name || null,
+    parentConversationId: row.parent_conversation_id || null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export function createConversationGroupRepository(db) {
+  const hasTable = !!db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'conversation_groups'`).get();
+  const hasColumn = db.prepare(`PRAGMA table_info(conversations)`).all().some((column) => column.name === 'group_id');
+  const enabled = hasTable && hasColumn;
+  const hasPosition = enabled && db.prepare(`PRAGMA table_info(conversations)`).all().some((column) => column.name === 'group_position');
+  if (!enabled) {
+    return {
+      enabled: false,
+      getGroup: () => null,
+      listGroupsByIds: () => new Map(),
+      groupOfConversation: () => null,
+      membersOf: () => [],
+      createGroup: () => null,
+      renameGroup: () => null,
+      setMembership: () => ({ ok: false, error: 'groups-unavailable' }),
+      moveConversation: () => ({ ok: false, error: 'groups-unavailable' }),
+      attachCreatedConversation: () => null,
+      dissolveGroup: () => false,
+      forgetConversation: () => null,
+      carryToCompacted: () => null,
+      deleteIfEmpty: () => false,
+      sweepEmpty: () => 0,
+      repair: () => ({ headsDetached: 0, groupsRemoved: 0 }),
+      freezeNamesForHeads: () => 0,
+      membershipsOf: () => ({}),
+      describeGroup: () => null,
+      orderOf: () => [],
+      positionsOf: () => ({}),
+    };
+  }
+
+  const getGroup = db.prepare(`SELECT * FROM conversation_groups WHERE id = ?`);
+  const insertGroup = db.prepare(`INSERT INTO conversation_groups (id, name, parent_conversation_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`);
+  const updateName = db.prepare(`UPDATE conversation_groups SET name = ?, updated_at = ? WHERE id = ?`);
+  const updateParent = db.prepare(`UPDATE conversation_groups SET parent_conversation_id = ?, updated_at = ? WHERE id = ?`);
+  // A frozen head title keeps to the name cap, so a later rename is never
+  // refused for a length it did not choose.
+  const freezeName = db.prepare(`UPDATE conversation_groups SET name = COALESCE(name, substr(?, 1, ${GROUP_NAME_MAX})), parent_conversation_id = NULL, updated_at = ? WHERE id = ?`);
+  const freezeNameKeepHead = db.prepare(`UPDATE conversation_groups SET name = COALESCE(name, substr(?, 1, ${GROUP_NAME_MAX})), updated_at = ? WHERE id = ? AND name IS NULL`);
+  const findGroupHeadedBy = db.prepare(`SELECT id FROM conversation_groups WHERE parent_conversation_id = ? ORDER BY created_at ASC LIMIT 1`);
+  const listGroupsWithHead = db.prepare(`
+    SELECT g.id, g.parent_conversation_id, c.title, c.status
+    FROM conversation_groups g LEFT JOIN conversations c ON c.id = g.parent_conversation_id
+    WHERE g.parent_conversation_id IS NOT NULL
+  `);
+  const deleteGroup = db.prepare(`DELETE FROM conversation_groups WHERE id = ?`);
+  const positionSelect = hasPosition ? 'group_position' : 'NULL AS group_position';
+  const getConversation = db.prepare(`SELECT id, title, archived, status, group_id, ${positionSelect}, updated_at FROM conversations WHERE id = ?`);
+  // Every change of group sets the position too: NULL unless given.
+  const setGroupStatement = db.prepare(hasPosition
+    ? `UPDATE conversations SET group_id = ?, group_position = ? WHERE id = ?`
+    : `UPDATE conversations SET group_id = ? WHERE id = ?`);
+  const setGroup = {
+    run: (groupId, conversationId, position = null) => (hasPosition
+      ? setGroupStatement.run(groupId, position, conversationId)
+      : setGroupStatement.run(groupId, conversationId)),
+  };
+  const setPosition = hasPosition ? db.prepare(`UPDATE conversations SET group_position = ? WHERE id = ?`) : null;
+  const clearGroup = db.prepare(hasPosition
+    ? `UPDATE conversations SET group_id = NULL, group_position = NULL WHERE group_id = ?`
+    : `UPDATE conversations SET group_id = NULL WHERE group_id = ?`);
+  const listMembersByTime = db.prepare(`
+    SELECT id, title, archived, group_id, ${positionSelect}, updated_at FROM conversations
+    WHERE group_id = ? AND status != 'deleted'
+    ORDER BY updated_at DESC
+  `);
+  const maxPosition = hasPosition
+    ? db.prepare(`SELECT MAX(group_position) AS n FROM conversations WHERE group_id = ? AND status != 'deleted'`)
+    : null;
+  const countMembers = db.prepare(`SELECT COUNT(*) AS n FROM conversations WHERE group_id = ? AND status != 'deleted'`);
+  const listEmptyGroups = db.prepare(`
+    SELECT g.id FROM conversation_groups g
+    WHERE NOT EXISTS (SELECT 1 FROM conversations c WHERE c.group_id = g.id AND c.status != 'deleted')
+  `);
+
+  /** The group's rows in display order: the head, then the members (see compareGroupMembers). */
+  const listMembers = {
+    all(groupId) {
+      const id = toText(groupId);
+      const headId = toText(getGroup.get(id)?.parent_conversation_id);
+      const rows = listMembersByTime.all(id);
+      const head = headId ? rows.find((row) => row.id === headId) || null : null;
+      const members = rows.filter((row) => row !== head).sort(compareGroupMembers);
+      return head ? [head, ...members] : members;
+    },
+  };
+
+  const positionValue = (row) => (row?.group_position == null ? null : Number(row.group_position));
+
+  /** Where a row joining `groupId` goes: after the last placed member, or NULL when nobody ordered the group. */
+  function joiningPosition(groupId) {
+    if (!hasPosition) return null;
+    const max = maxPosition.get(toText(groupId))?.n;
+    return max == null ? null : Number(max) + POSITION_STEP;
+  }
+
+  const liveConversation = (id) => {
+    const row = getConversation.get(toText(id));
+    return row && String(row.status || '') !== 'deleted' ? row : null;
+  };
+
+  function deleteIfEmpty(groupId) {
+    const id = toText(groupId);
+    if (!id) return false;
+    if (Number(countMembers.get(id)?.n || 0) > 0) return false;
+    return deleteGroup.run(id).changes > 0;
+  }
+
+  /**
+   * The conversation leaves its group. A head that leaves makes its group
+   * headless: the name freezes to the head's title unless one was given by
+   * hand. An empty group is removed. Returns the previous group id.
+   */
+  const leaveGroup = db.transaction((conversationId, nowIso, { anyStatus = false } = {}) => {
+    // A row already marked deleted (the delete path marks before it removes)
+    // still leaves its group the same way.
+    const row = anyStatus ? getConversation.get(toText(conversationId)) : liveConversation(conversationId);
+    const previous = toText(row?.group_id);
+    if (!row || !previous) return null;
+    const group = getGroup.get(previous);
+    if (group && toText(group.parent_conversation_id) === row.id) freezeName.run(row.title || null, nowIso, previous);
+    setGroup.run(null, row.id);
+    deleteIfEmpty(previous);
+    return previous;
+  });
+
+  const createGroup = db.transaction(({ name = null, parentConversationId = null, conversationIds = [] } = {}, nowIso = new Date().toISOString()) => {
+    const id = `grp_${randomUUID().replace(/-/g, '').slice(0, 20)}`;
+    const head = liveConversation(parentConversationId);
+    insertGroup.run(id, normalizeGroupName(name), head ? head.id : null, nowIso, nowIso);
+    const members = new Set([...(head ? [head.id] : []), ...conversationIds.map(toText).filter(Boolean)]);
+    for (const memberId of members) {
+      if (!liveConversation(memberId)) continue;
+      leaveGroup(memberId, nowIso);
+      setGroup.run(id, memberId);
+    }
+    return rowToGroup(getGroup.get(id));
+  });
+
+  const setMembership = db.transaction((conversationId, groupId, nowIso = new Date().toISOString()) => {
+    const row = liveConversation(conversationId);
+    if (!row) return { ok: false, error: 'conversation-not-found' };
+    const target = toText(groupId);
+    if (target && !getGroup.get(target)) return { ok: false, error: 'group-not-found' };
+    if (toText(row.group_id) === target) return { ok: true, changed: false, groupId: target || null, previousGroupId: target || null };
+    const previousGroupId = leaveGroup(row.id, nowIso);
+    if (target) setGroup.run(target, row.id, joiningPosition(target));
+    return { ok: true, changed: true, groupId: target || null, previousGroupId };
+  });
+
+  /** The ids of a group in display order, head first. */
+  function orderOf(groupId) {
+    return listMembers.all(groupId).map((member) => member.id);
+  }
+
+  /**
+   * A drag in the sidebar: the conversation goes into `groupId` (null: out of
+   * its group) and lands before `beforeConversationId`, or at the end when
+   * that is null or not a member there. The group then has a hand order:
+   * every member after the head is numbered 10, 20, 30, ... in the order
+   * that results. The head stays first and unnumbered; moving it within its
+   * own group, or dropping a row before it, never displaces it.
+   */
+  const moveConversation = db.transaction((conversationId, { groupId = null, beforeConversationId = null } = {}, nowIso = new Date().toISOString()) => {
+    const row = liveConversation(conversationId);
+    if (!row) return { ok: false, error: 'conversation-not-found' };
+    const target = toText(groupId);
+    const group = target ? getGroup.get(target) : null;
+    if (target && !group) return { ok: false, error: 'group-not-found' };
+    const current = toText(row.group_id);
+    if (!target) {
+      if (!current) return { ok: true, changed: false, groupId: null, previousGroupId: null, order: [] };
+      const previousGroupId = leaveGroup(row.id, nowIso);
+      return { ok: true, changed: true, groupId: null, previousGroupId, order: [] };
+    }
+    const headId = toText(group.parent_conversation_id);
+    if (current === target && row.id === headId) {
+      return { ok: true, changed: false, groupId: target, previousGroupId: target, order: orderOf(target) };
+    }
+    let changed = false;
+    let previousGroupId = current || null;
+    if (current !== target) {
+      previousGroupId = leaveGroup(row.id, nowIso);
+      setGroup.run(target, row.id);
+      changed = true;
+    }
+    // A row that turns out to be the head (a link kept for a re-import) leads unnumbered.
+    if (hasPosition && row.id !== headId) {
+      const rows = listMembers.all(target).filter((member) => member.id !== headId);
+      const before = toText(beforeConversationId);
+      const moved = rows.find((member) => member.id === row.id);
+      // Dropped before itself: it stays where it is.
+      const others = before === row.id ? rows : rows.filter((member) => member !== moved);
+      if (before !== row.id) {
+        const index = headId && before === headId ? 0 : (before ? others.findIndex((member) => member.id === before) : -1);
+        others.splice(index < 0 ? others.length : index, 0, moved);
+      }
+      others.forEach((member, index) => {
+        const position = (index + 1) * POSITION_STEP;
+        if (positionValue(member) === position) return;
+        setPosition.run(position, member.id);
+        changed = true;
+      });
+    }
+    return { ok: true, changed, groupId: target, previousGroupId, order: orderOf(target) };
+  });
+
+  /** `{ [conversationId]: position | null }` for the ids given (rows outside a group read as null). */
+  function positionsOf(conversationIds) {
+    const out = {};
+    for (const raw of new Set((Array.isArray(conversationIds) ? conversationIds : []).map(toText).filter(Boolean))) {
+      const row = liveConversation(raw);
+      out[raw] = row && toText(row.group_id) ? positionValue(row) : null;
+    }
+    return out;
+  }
+
+  /**
+   * Bootstrap of a session an agent created here: the child joins the
+   * creator's group, or a new group with the creator as head. A creator that
+   * is gone leaves the child ungrouped.
+   */
+  const attachCreatedConversation = db.transaction((childId, creatorId, nowIso = new Date().toISOString()) => {
+    const child = liveConversation(childId);
+    const creator = liveConversation(creatorId);
+    if (!child || !creator || child.id === creator.id) return null;
+    let groupId = toText(creator.group_id);
+    if (!groupId || !getGroup.get(groupId)) {
+      // A group that still names this creator as its head (its row was
+      // removed and made again, as a cache rebuild does) is taken up again
+      // rather than doubled.
+      const headed = findGroupHeadedBy.get(creator.id);
+      groupId = headed ? toText(headed.id) : createGroup({ parentConversationId: creator.id }, nowIso).id;
+      setGroup.run(groupId, creator.id);
+    }
+    setGroup.run(groupId, child.id, joiningPosition(groupId));
+    return groupId;
+  });
+
+  /**
+   * What a delete path that does not know groups leaves behind: a head whose
+   * row is tombstoned (the group stays headless, the title frozen as its
+   * name) and groups without a live member. A head whose row is simply
+   * absent keeps its link: a cache wipe froze its name first, and the row
+   * may be imported again under the same id and take the group up.
+   */
+  const repair = db.transaction((nowIso = new Date().toISOString()) => {
+    let headsDetached = 0;
+    for (const row of listGroupsWithHead.all()) {
+      if (!row.status || String(row.status) !== 'deleted') continue;
+      freezeName.run(row.title || null, nowIso, row.id);
+      headsDetached += 1;
+    }
+    let groupsRemoved = 0;
+    for (const row of listEmptyGroups.all()) groupsRemoved += deleteGroup.run(row.id).changes;
+    return { headsDetached, groupsRemoved };
+  });
+
+  /**
+   * Before rows are wiped (the cache rebuild): the groups headed by any of
+   * them get their head's title as their name, so the group that survives
+   * (its hand-titled members stay) is not nameless. The head link stays for
+   * a re-import. Returns how many names were frozen.
+   */
+  const freezeNamesForHeads = db.transaction((conversationIds, nowIso = new Date().toISOString()) => {
+    const ids = new Set((Array.isArray(conversationIds) ? conversationIds : []).map(toText).filter(Boolean));
+    let frozen = 0;
+    for (const row of listGroupsWithHead.all()) {
+      if (!ids.has(toText(row.parent_conversation_id))) continue;
+      frozen += freezeNameKeepHead.run(row.title || null, nowIso, row.id).changes;
+    }
+    return frozen;
+  });
+
+  /** `{ [conversationId]: { groupId, role } | null }` for the ids given (deleted rows read as null). */
+  function membershipsOf(conversationIds) {
+    const out = {};
+    for (const raw of new Set((Array.isArray(conversationIds) ? conversationIds : []).map(toText).filter(Boolean))) {
+      const row = liveConversation(raw);
+      const groupId = toText(row?.group_id);
+      const group = groupId ? getGroup.get(groupId) : null;
+      out[raw] = row && group
+        ? { groupId, role: toText(group.parent_conversation_id) === row.id ? 'head' : 'member' }
+        : null;
+    }
+    return out;
+  }
+
+  return {
+    enabled: true,
+    getGroup(groupId) {
+      return rowToGroup(getGroup.get(toText(groupId)));
+    },
+    /** `Map<id, group>` for the ids given (unknown ids are left out). */
+    listGroupsByIds(groupIds) {
+      const map = new Map();
+      for (const raw of new Set((Array.isArray(groupIds) ? groupIds : []).map(toText).filter(Boolean))) {
+        const group = rowToGroup(getGroup.get(raw));
+        if (group) map.set(group.id, group);
+      }
+      return map;
+    },
+    groupOfConversation(conversationId) {
+      const row = liveConversation(conversationId);
+      return row?.group_id ? rowToGroup(getGroup.get(row.group_id)) : null;
+    },
+    /**
+     * `[{ id, title, archived, updatedAt, groupPosition }]` in display order
+     * (the head, then the placed members, then the others newest first),
+     * deleted rows left out.
+     */
+    membersOf(groupId) {
+      return listMembers.all(toText(groupId)).map((row) => ({
+        id: row.id,
+        title: row.title,
+        archived: Number(row.archived || 0) === 1,
+        updatedAt: row.updated_at,
+        groupPosition: positionValue(row),
+      }));
+    },
+    createGroup,
+    renameGroup(groupId, name, nowIso = new Date().toISOString()) {
+      const id = toText(groupId);
+      if (!getGroup.get(id)) return null;
+      updateName.run(normalizeGroupName(name), nowIso, id);
+      return rowToGroup(getGroup.get(id));
+    },
+    setMembership,
+    moveConversation,
+    orderOf,
+    positionsOf,
+    attachCreatedConversation,
+    /** Every member leaves; the group row goes. Conversations are untouched otherwise. */
+    dissolveGroup(groupId) {
+      const id = toText(groupId);
+      if (!getGroup.get(id)) return false;
+      clearGroup.run(id);
+      deleteGroup.run(id);
+      return true;
+    },
+    /**
+     * Called before a conversation's rows are deleted: a head leaves its group
+     * (name frozen), and a group left empty goes. Returns the group id it was in.
+     */
+    forgetConversation(conversationId, nowIso = new Date().toISOString()) {
+      return leaveGroup(conversationId, nowIso, { anyStatus: true });
+    },
+    /** Compaction: the new conversation takes the old one's group, its place in it, and its head role. */
+    carryToCompacted(sourceId, targetId, nowIso = new Date().toISOString()) {
+      const source = liveConversation(sourceId);
+      const groupId = toText(source?.group_id);
+      if (!groupId || !getGroup.get(groupId) || !getConversation.get(toText(targetId))) return null;
+      setGroup.run(groupId, toText(targetId), positionValue(source));
+      // The old row stays in the group, unplaced: it must not tie with the new one.
+      if (toText(targetId) !== source.id) setGroup.run(groupId, source.id, null);
+      const group = getGroup.get(groupId);
+      if (toText(group?.parent_conversation_id) === source.id) updateParent.run(toText(targetId), nowIso, groupId);
+      return groupId;
+    },
+    deleteIfEmpty,
+    /** Removes groups without a live member; returns how many. */
+    sweepEmpty() {
+      let removed = 0;
+      for (const row of listEmptyGroups.all()) removed += deleteGroup.run(row.id).changes;
+      return removed;
+    },
+    repair,
+    freezeNamesForHeads,
+    membershipsOf,
+    /**
+     * The group as the list payload and the change event describe it: name,
+     * display name (the head's current title when none was given), head and
+     * member counts. `headTitle(title)` may dress the title as the list does.
+     */
+    describeGroup(groupId, { headTitle = (title) => title } = {}) {
+      const group = rowToGroup(getGroup.get(toText(groupId)));
+      if (!group) return null;
+      const members = listMembers.all(group.id);
+      const head = group.parentConversationId ? members.find((member) => member.id === group.parentConversationId) || null : null;
+      return {
+        id: group.id,
+        name: group.name || null,
+        displayName: resolveGroupDisplayName({ name: group.name, headTitle: head ? headTitle(head.title) : null }),
+        parentConversationId: group.parentConversationId || null,
+        memberCount: members.length,
+        liveMemberCount: members.filter((member) => Number(member.archived || 0) !== 1).length,
+      };
+    },
+  };
+}

package/server/repositories/message-repository.mjs

@@ -29,6 +29,7 @@ export function createMessageRepository(db) {
         getSharedMessages: shareVisibility.getSharedMessages,
         getMessageByConversation: db.prepare(`SELECT * FROM messages WHERE id = ? AND conversation_id = ? LIMIT 1`),
         setMessageShareVisibility: shareVisibility.setMessageShareVisibility,
+        listHiddenMessages: shareVisibility.listHiddenMessages,
         setMessagePinnedAt: messagePins.setMessagePinnedAt,
         listPinnedMessages: messagePins.listPinnedMessages,
         countPinnedMessages: messagePins.countPinnedMessages,
@@ -346,6 +347,12 @@ export function createMessageRepository(db) {
         //
         // A turn blocked on an unanswered AskUserQuestion is never stale — it is
         // waiting on the human, and relay_questions carries its own expiry.
+        //
+        // The ceiling counts from the last human interaction with the turn, not
+        // from its start: answering a question restarts the clock. Otherwise an
+        // interview that waited hours for its answers would be cut off by the
+        // ceiling the moment the last answer arrived (live 2026-10-10: a
+        // five-question interview lost its reply that way).
         listRecoverableProcessing: db.prepare(`
           SELECT id, conversation_id, kind, relay_mode, model, retry_count, consumed_at
           FROM queue
@@ -353,7 +360,13 @@ export function createMessageRepository(db) {
             AND COALESCE(kind, '') != 'continuation'
             AND (
               COALESCE(owner_last_claimed_at, processing_at, timestamp) < @inactiveBefore
-              OR (@ceilingBefore IS NOT NULL AND COALESCE(processing_at, timestamp) < @ceilingBefore)
+              OR (
+                @ceilingBefore IS NOT NULL
+                AND MAX(
+                  COALESCE(processing_at, timestamp),
+                  COALESCE((SELECT MAX(answered_at) FROM relay_questions WHERE queue_id = queue.id), '')
+                ) < @ceilingBefore
+              )
             )
             AND id NOT IN (SELECT queue_id FROM relay_questions WHERE status = 'pending')
         `),
@@ -431,15 +444,29 @@ export function createMessageRepository(db) {
         // A continuation with no live worker can only be torn down — replaying
         // it as deliverable work would send the CLI's own bookkeeping text back
         // to the CLI as a user prompt.
+        //
+        // Same staleness rules as listRecoverableProcessing: a continuation
+        // waiting on an unanswered question is never stale, and an answer
+        // restarts the ceiling clock. A background-agent interview hangs its
+        // question cards on the continuation row, so without this a long
+        // interview was torn down by the ceiling while the human was still
+        // answering (live 2026-10-10).
         listStaleProcessingContinuations: db.prepare(`
-          SELECT id, conversation_id
+          SELECT id, conversation_id, timestamp, processing_at, owner_last_claimed_at
           FROM queue
           WHERE status = 'processing'
             AND kind = 'continuation'
             AND (
               COALESCE(owner_last_claimed_at, processing_at, timestamp) < @inactiveBefore
-              OR (@ceilingBefore IS NOT NULL AND COALESCE(processing_at, timestamp) < @ceilingBefore)
+              OR (
+                @ceilingBefore IS NOT NULL
+                AND MAX(
+                  COALESCE(processing_at, timestamp),
+                  COALESCE((SELECT MAX(answered_at) FROM relay_questions WHERE queue_id = queue.id), '')
+                ) < @ceilingBefore
+              )
             )
+            AND id NOT IN (SELECT queue_id FROM relay_questions WHERE status = 'pending')
         `),
         listQueueForPauseDrop: db.prepare(`SELECT id, conversation_id FROM queue WHERE status IN ('pending', 'processing', 'parked')`),
         // Authoritative "is a turn in flight" signal for the conversation list.

package/server/repositories/question-repository.mjs

@@ -1,7 +1,13 @@
 'use strict';
 
+import { createSubagentTimelineStatements } from './subagent-timeline-statements.mjs';
+
 export function createQuestionRepository(db) {
+    const subagentTimeline = createSubagentTimelineStatements(db);
+    const runColumns = subagentTimeline.subagentRunSelectColumns;
+    const runColumnsAs = (alias) => runColumns.split(', ').map((column) => `${alias}.${column}`).join(', ');
     return {
+        ...subagentTimeline,
         // relay questions
         insertQuestion: db.prepare(`INSERT INTO relay_questions (id, queue_id, conversation_id, message_id, relay_mode, prompt, choices, request, request_schema, status, answer, structured_answer, sdk_session_id, owner_worker_id, continuation_id, continuation_question_id, created_at, answered_at, expires_at, attempt_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?, ?, ?, ?, NULL, ?, ?)`),
         getQuestion:    db.prepare(`SELECT * FROM relay_questions WHERE id = ?`),
@@ -99,7 +105,7 @@ export function createQuestionRepository(db) {
           WHERE id = ?
         `),
         listSubagentRunsByQueueMessage: db.prepare(`
-          SELECT id, queue_message_id, conversation_id, parent_subagent_id, display_name, status, started_at, updated_at, completed_at
+          SELECT ${runColumns}
           FROM subagent_runs
           WHERE queue_message_id = ?
           ORDER BY started_at ASC, id ASC
@@ -108,7 +114,7 @@ export function createQuestionRepository(db) {
         // abort) also ends its subagent runs — nothing else ever will, and an
         // un-reconciled row renders as a bubble stuck "running" forever.
         listRunningSubagentRunsByQueueMessage: db.prepare(`
-          SELECT id, conversation_id, parent_subagent_id, display_name
+          SELECT ${runColumns}
           FROM subagent_runs
           WHERE queue_message_id = ? AND status = 'running'
         `),
@@ -121,7 +127,7 @@ export function createQuestionRepository(db) {
           WHERE queue_message_id = ? AND status = 'running'
         `),
         listSubagentRunsByResponse: db.prepare(`
-          SELECT sr.id, sr.queue_message_id, sr.conversation_id, sr.parent_subagent_id, sr.display_name, sr.status, sr.started_at, sr.updated_at, sr.completed_at
+          SELECT ${runColumnsAs('sr')}
           FROM subagent_runs sr
           WHERE sr.queue_message_id IN (
             SELECT id FROM queue WHERE response_message_id = ?

package/server/repositories/remote-relay-repository.mjs

@@ -29,7 +29,10 @@ export function createRemoteRelayRepository(db) {
   const hasUnlock = db.prepare(`SELECT 1 FROM conversation_remote_relay_unlocks WHERE conversation_id = ? AND remote_relay_id = ?`);
   const listUnlocks = db.prepare(`SELECT remote_relay_id, message_id, created_at FROM conversation_remote_relay_unlocks WHERE conversation_id = ? ORDER BY created_at ASC`);
   const insertUnlock = db.prepare(`INSERT OR IGNORE INTO conversation_remote_relay_unlocks (conversation_id, remote_relay_id, message_id, created_at) VALUES (?, ?, ?, ?)`);
-  const deleteUnlocksForRelay = db.prepare(`DELETE FROM conversation_remote_relay_unlocks WHERE remote_relay_id = ?`);
+  // The relay's unlocks and the approvals stored under its id (`<id>:watch`).
+  const deleteUnlocksForRelay = db.prepare(`
+    DELETE FROM conversation_remote_relay_unlocks WHERE remote_relay_id = ? OR substr(remote_relay_id, 1, length(?) + 1) = ? || ':'
+  `);
   const deleteUnlocksForConversation = db.prepare(`DELETE FROM conversation_remote_relay_unlocks WHERE conversation_id = ?`);
   const setMessageOrigin = db.prepare(`UPDATE messages SET origin_json = ? WHERE id = ?`);
   const getMessageOrigin = db.prepare(`SELECT origin_json FROM messages WHERE id = ?`);
@@ -101,7 +104,8 @@ export function createRemoteRelayRepository(db) {
         .map((row) => String(row.id));
     },
     forgetRelay(remoteRelayId) {
-      return deleteUnlocksForRelay.run(String(remoteRelayId || '')).changes;
+      const id = String(remoteRelayId || '');
+      return deleteUnlocksForRelay.run(id, id, id).changes;
     },
     forgetConversation(conversationId) {
       return deleteUnlocksForConversation.run(String(conversationId || '')).changes;